Tutoría 5 - DEIM - UT0 y 2 - Curso 24·25 - 10 Diciembre

Vale, veo que en el chat me habéis puesto que hay alguna duda ya prevista. En los foros no he visto nada, por tanto no hay nada preparado en cuanto a resolución de dudas. 00:00:01

Yo voy a ir comentando cosas que creo que son pertinentes. Así que bueno, no sé, antes de dar paso a esta duda, no sé si... ¿Cómo lleváis el tema 2? 00:00:14

espero que ya por lo menos leído 00:00:25

y bueno, comenzando 00:00:27

con la tarea quienes vayáis a hacerla 00:00:29

que como siempre son más que recomendables 00:00:30

porque si no se practica esto 00:00:33

vais a ver que es complicado 00:00:34

saber ir asimilando 00:00:37

todo, entonces bueno 00:00:39

esa duda 00:00:41

si me la queréis comentar 00:00:41

indica, estoy un poco 00:00:44

atascado con lo de añadir la rotación a la nave cuando 00:00:47

se desplaza lateralmente, vale, esa probablemente 00:00:49

es la parte más 00:00:51

peleaguda del 00:00:52

del enunciado 00:00:54

de todos modos en el 00:00:56

pues eso, en el mismo enunciado se dice 00:00:58

que se puede llegar de varias maneras 00:01:03

y bueno, en el tema también se anuncia 00:01:04

o se deja ver que lo que es 00:01:06

la rotación y como la gestiona 00:01:08

el propio Unity es 00:01:10

complejo en el sentido de que usa 00:01:12

estos cuaternios que son cuatro dimensiones 00:01:14

para que no exista este bloque 00:01:16

del Gimbal Lock, eso lo tenéis 00:01:18

y entonces 00:01:20

surgen problemas entre 00:01:21

Pero digamos, estáis viendo mi pantalla, ¿verdad? Entiendo que sí, vale, perfecto. No vaya a ser que me ponga aquí a hablar. Vale, hay una discordancia entre la rotación y los grados que podemos ir dando, que veis que son, digamos, infinitos, ¿no? Cada 360 grados empezará una rotación, pero a nivel numérico aquí podemos ver que el número no se ve restringido. 00:01:24

Pero sí que es verdad que por debajo, los cálculos que está haciendo, y ahora de hecho hacemos un ejemplo, la realidad es que estos valores solo van de 0 a 360. 00:01:47

Entonces, digamos que cuando a lo mejor se pasa de una vuelta a la siguiente, con estos valores genera conflictos extraños. 00:02:00

Entonces, ese puede que sea uno de los problemas que están surgiendo. 00:02:08

Ahora, de todos modos, de hecho quería explicar prácticamente lo que de tiempo, pero lo que creo que es necesario hasta el punto de la rotación y la rotación dejarla un poco abierta, dándose una solución rápida y la más simple, ¿vale? 00:02:11

y bueno, un poco para que a partir de ahí 00:02:26

también a lo mejor busquéis alguna más de cara a la siguiente 00:02:29

pero bueno, es un poco por saber 00:02:32

si ya veis, si todos habéis conseguido más o menos mover la nave 00:02:34

ponerle límites, etcétera 00:02:37

puedo avanzar un poco más 00:02:39

aunque hay cosas que creo que estaría bien repasar 00:02:40

entonces, si os parece 00:02:43

me pongo a hablar de algunas cosas previas 00:02:47

vemos así rápidamente cómo se movería la nave 00:02:51

o cuál sería el planteamiento lógico 00:02:54

con lo que hemos visto 00:02:56

y acabamos un poco con lo de la rotación 00:02:57

os lo digo 00:03:00

vale, pues vamos 00:03:02

voy a ir 00:03:04

voy a intentar ir lo más rápido posible 00:03:06

quiero ir a una cosa previa de los vectores 00:03:08

que dejé el otro día 00:03:10

un poco así presentada 00:03:11

pero no, bueno, hay algún detalle 00:03:13

que me gustaría que viéramos 00:03:15

y vamos a lo siguiente 00:03:16

si no es algo concreto 00:03:19

más allá de que te has bloqueado ahí 00:03:21

que evidentemente eso ya es una duda 00:03:23

lo hacemos así, ¿os parece? 00:03:24

vale, lo vamos a hacer así en el sentido de que creo que es lo más óptimo 00:03:27

porque creo que a lo mejor incluso si habéis conseguido mover ciertas cosas 00:03:33

pueden surgir problemas que con estas dudas que creo que vamos a ir resolviendo 00:03:38

pues se van viendo, ¿vale? 00:03:42

yo voy arrancando y vamos viendo, ¿vale? si os parece 00:03:45

que así vamos viendo 00:03:48

A ver, vale, eso, primeramente querría ver algunas cosas sobre los vectores, que quedaron pendientes, voy a ir rápido, bueno, tengo aquí dos códigos preparados, un segundete, que los tengo aquí, y vamos a ir con este de cálculos durante, que es el que he aplicado un empty, simplemente porque vamos a ver resultados en la consola, 00:03:51

Entonces no va a haber muchas cosas más allá. Pero simplemente el otro día presenté lo que era un vector 3. En el tema ya habréis leído para qué se emplean, para marcar coordenadas o para marcar direcciones. Es un poco los valores. 00:04:17

Pero me interesa mucho, ya el otro día hablamos cómo se iban sumando, cómo se declaraba un vector nuevo. Cuando queremos poner un número vector 3 que no ha sido todavía recogido por una variable vector 3, hay que poner primero la palabra nuevo, si no va a dar fallo siempre. 00:04:35

Entonces cuando digáis esto debería estar funcionando, poned ese nuevo porque pueden surgir los problemas. 00:04:52

Entonces simplemente me gustaría que veamos rápidamente, si ya hay dudas me las vais planteando en los foros, 00:04:59

pero bueno, porque a veces si no hay operaciones que decís esto es posible, esto no, vamos a verlo rápido. 00:05:09

Tengo aquí preparados dos vectores con estos dos valores, 1, 2, 4, en el caso del A y 0, 1, 2 en el caso del B, que voy a usar en estos ejemplos que tengo aquí debajo. 00:05:16

A ver, perdonad, para que no salgan luego más códigos de los que debiera. Ahí está. Va a ser en el start, solo va a salir una vez, distintos mensajes. 00:05:27

simplemente quiero que veamos que se pueden sumar 00:05:37

vectores distintos 00:05:41

que vamos creando 00:05:43

sobre la marcha, al vuelo 00:05:45

se pueden sumar los que hemos guardado 00:05:47

en 00:05:49

vectores 3 como variable 00:05:50

previamente, y por eso aquí 00:05:53

operamos con estos vectores A 00:05:55

y vector B, esto lo vimos el otro día 00:05:57

también es importante saber 00:05:59

que se puede 00:06:01

hacer, y me paso aquí 00:06:03

se pueden ir sumando 00:06:04

vectores con distintas dimensiones, ¿vale? Porque un vector 3, en el tema también sale que pueden existir 00:06:07

vectores 2, incluso existen por ahí, aunque no son tan comunes, los vectores 4, ¿vale? 00:06:12

Pero que no os veáis limitados en algún momento a pensar que porque tengáis un vector 3, 00:06:17

ese no se puede sumar, pues por ejemplo, con un vector 2 o con un vector 3 que solo tenga dos de sus posiciones, 00:06:24

Es decir, x e y. Entonces, simplemente para ir rápido, si veis algo que no cuadra, lo vemos. En esta primera suma, básicamente, que va a ser la que salga la primera frase de la consola que pone sumando vectores 1, y va a ser esta, esta variable que hemos creado aquí dentro del star, y por tanto es local dentro de esta cápsula, vamos a tener un primer resultado que va a ser un vector de 1. 00:06:31

Voy haciendo, recordad que se van haciendo las operaciones con las posiciones correspondientes de cada vector 3 en este caso, entonces el resultado sería de 1, de 0,5, porque en realidad es una resta aunque sea una suma, 1, 0,5 y 2. 00:06:55

Bueno, vamos a la primera, que entiendo que esa es la que no tiene mucho misterio. Van a salir varias, pero la primera es 1, 0,5 y 2. Luego, fijaos, y voy así pasando rápido, que también se puede sumar a través de variables que hemos declarado anteriormente, en cuyo caso este resultado, que es la segunda línea, sería 1, 3 y 6. 00:07:10

¿Verdad? Pues mira, aquí está 1, 3, 6. Voy rápido, pero entiendo que lo vais siguiendo. Luego, el que es sumar vectores 5, que es este resultado aquí, fijaos que lo que estamos haciendo es sumar un vector 3, que es este vector A de 1, 2, 4, con un vector 3, pero que solo tiene dos posiciones. 00:07:32

Lo mismo, se sobreentiende que si solo se ponen dos posiciones es porque esta no vale nada. Esto es completamente válido y por tanto valdrá vector 1 más 2, 3, vector en la segunda posición 2 más 2, 4 y la segunda se queda como 4. 00:07:52

Entonces era el resultado 3, 4, 4. ¿Sí? ¿Vale? Hasta aquí entiendo que... a ver, voy a mirar el chat... vale. Entiendo que sin problemas. Vamos a ver rápidamente también qué sucede si lo que hacemos es sumar un vector 3, ¿vale? Con un número suelto. 00:08:09

Y vais a ver que da fallo. No se puede hacer una suma de las tres posiciones, por ejemplo, con un número suelto. Esto no se puede hacer. Vais a ver que, sin embargo, y lo tengo aquí preparado, sí se puede hacer esa misma operación en las multiplicaciones. 00:08:29

Y veis que aquí no da falla, ¿vale? La suma sí que tiene que quedar de manera más o menos explícita entre qué valores está sumando, pero lo que sí se puede hacer es que las tres posiciones de un vector 3 se multipliquen por un mismo número. 00:08:45

Que esto vamos a ver que es importante, por ejemplo, cuando tengamos que mover un objeto que se mueve a partir de un vector 3, porque señala las tres dimensiones, y si queremos que se mueva más o menos rápido, lo multiplicamos las tres dimensiones por un número, ¿no? 00:08:59

Que es un poco lo que puede dar la velocidad. 00:09:12

Por tanto, es importante diferenciar entre lo que se puede hacer con las sumas, que veis que da error, 00:09:15

lo pongo ya en comentario porque no va a haber resultado, va a dar error, 00:09:19

y lo que se puede hacer con multiplicaciones, ¿vale? 00:09:24

O con, a ver, que no me equivoque, o con divisiones, ¿vale? 00:09:27

Son dos tipos de operaciones en este sentido. 00:09:31

Y luego, por otro lado, pongo como comentario todo lo que ya hemos ido viendo, 00:09:33

Y voy a poner el que es esta cuarta línea, que es intentar sumar vectores de distintas dimensiones. 00:09:38

Entonces, si yo activo esto, porque en el tema se va hablando de que existen vectores de dos dimensiones, de tres. 00:09:49

Por ejemplo, las de dos dimensiones en ocasiones se usan también en el entorno 3D. 00:09:56

No solo se usa en juegos de tipo 2D, ¿vale? 00:10:00

Si os fijáis, da problemas, es decir, a diferencia de lo que estábamos viendo en la anterior, 00:10:08

que si ponemos esto no da problemas, hay que ser consecuente e ir operando con vectores, ¿vale? 00:10:13

Y vemos aquí el error, que estará aquí, ¿vale? A ver... 00:10:20

Bueno, esto también os lo enseño para que veáis que cuando dais a la consola, 00:10:24

si dais a un error 00:10:28

os va a decir aquí el porqué 00:10:30

y pone el operador más es ambiguo en operandos 00:10:32

del tipo vector 3 y vector 2 00:10:34

básicamente lo que nos quiere decir es 00:10:36

que no son compatibles 00:10:38

entonces, bueno, que sepáis eso 00:10:39

que aunque en muchas ocasiones se puede 00:10:42

usar un vector 3 por sus dos 00:10:44

dimensiones y estar operando 00:10:46

realmente como si fuera un vector 2 00:10:48

considerad que no se puede 00:10:49

hacer esta mezcla entre tipos 00:10:52

de vectores en cuanto a su número 00:10:54

de posiciones 00:10:56

¿vale? 00:10:57

esto creo que es importante porque 00:10:59

luego podéis encontrar conflictos que salen 00:11:01

errores o veis 00:11:03

¿cómo puede ser que un vector 3 00:11:05

solo tenga dos posiciones? pues sí, puede ser 00:11:07

vamos por poder, ¿vale? y lo 00:11:09

vemos, incluso creo, vamos 00:11:11

igual ahora me equivoco, pero 00:11:13

ah no, siempre tiene que haber mínimo 2 00:11:15

pues juraría que se 00:11:17

podía, aunque para tener un vector 00:11:19

3 que solo tiene una posición, pues es lo mismo 00:11:21

que decir aquí un 2, ¿vale? entonces 00:11:23

No tendría sentido. Y como os he dicho antes, no se pueden sumar los vectores con un número entero, ¿vale? Aunque el número fuera una variable de tipo int o float, no dejaría tampoco. 00:11:25

Vale, a ver si no paso a la siguiente cosa. Vale, entiendo que hasta aquí me vais siguiendo. 00:11:40

Bueno, sobre las multiplicaciones de vectores. A ver, pongo aquí esto para que se vea. Lo que hemos dicho, si vector A, que es 1, 2, 4, lo multiplico por 2, ¿vale? El resultado serán 2, 4, 8, ¿verdad? 00:11:46

Pues vamos a ver qué ocurre cuando vuelvo a arrancar, que ya, a ver aquí, 2, 4, 8, ¿vale? Ha multiplicado cada una de las posiciones de ese vector 3 por ese número. 00:12:03

Ya os digo, es un método muy empleado para conseguir que algo se mueva más rápido o menos rápido de manera proporcional, ¿vale? 00:12:17

Luego, por otro caso, en otro caso, lo lógico que estamos haciendo con la sumar de vectores, ¿vale? 00:12:26

Lo que no se puede hacer es multiplicar un vector por otro de manera directa. 00:12:31

Si os fijáis aquí la operación, pone un multiplicar y decís, ¿y por qué 1 no se multiplica por 0, 2 por 1, 4 con 2? 00:12:36

Bueno, por la sintaxis no lo permite. Pero sí que es verdad, y esto lo tenéis en un saber más del tema, 00:12:43

que de hecho lo tengo por aquí, un segundito que lo encuentre, tenéis un saber más, os lo pongo aquí en este apartado 2.3.1, que os pone distintos métodos relacionados con los vectores, 00:12:50

entre los que vais a encontrar, por ejemplo, uno que es este de scale, multiplicar vectores entre ejes respectivos. 00:13:05

Bueno, más avanzado, esta operación no es tan recurrente, digamos, como la de multiplicar por un número concreto, por una velocidad, para que todo sea proporcional, 00:13:11

Pero veis que a veces, aunque la sintaxis sea compleja, pues simplemente hay que hacerlo dando un poquito de vueltas, usando los operadores que nos proporciona nuestro lenguaje. 00:13:20

Entonces, un vector 3 por otro vector 3, como hemos dicho, da error. 00:13:36

Y lo que también os comentaba, existe el vector 3 scale, que es el que estamos viendo, que al final lo que sí que habrá que hacer es, igual que estamos haciendo, hacer un vector que como resultado de este valor. 00:13:42

¿Qué significa esto? Pues que este multiplicando vectores va a conseguir que haya una multiplicación entre el vector a, 00:14:01

este que tenemos aquí, y este que tenemos aquí segundo. 00:14:09

El resultado de esto va a ser lo que estábamos diciendo, 1 por 0 es 0, 2 por 1 es 2, y 4 por 2 es 8. 00:14:16

0, 2, 8. Si lo comprobamos, vamos a ello, hay muchos líos, 0, 2, 8. Así se podría conseguir una multiplicación, que ya os digo, esta es una operación más compleja, pero en algún momento os podría ser necesaria. 00:14:22

Y luego aquí, con respecto a esto, también podría caer la suposición de que se puede operar de esta forma, hacer la multiplicación entre dos vectores creando un vector nuevo. 00:14:43

No, esto da error. Pero lo que sí se puede hacer, y esto también es importante, es que se pueden sumar cada una de las coordenadas de las posiciones por la otra dentro de un nuevo vector 3. 00:14:59

Lo voy a escribir muy rápido y lo vemos, porque esto sí que es algo que es a veces un poco farragoso, pero es necesario conocer. 00:15:20

Voy a ello, no tardo nada, vector A. Ahora os explico qué es esto, porque esto sí que puede ser algo diferencial para que podáis hacer bien la tarea. 00:15:31

Lo voy a copiar y cambio la dimensión. 00:15:45

Z y Z. Y diréis, ¿y esto que estás haciendo qué es? 00:15:50

Bueno, esto en vez de llamarse multiplicación de vectores sería sumar dimensiones de dos vectores en cada una de sus dimensiones, por ser redundante. 00:16:00

Pero bueno, lo voy a dejar con este nombre para que no sea un lío. 00:16:10

Bueno, por cierto, y ya aprovecho, si queréis cambiar, veis que cuando marcáis, ya lo habréis visto, cuando marcáis un nombre de variable, se marca en el resto del código, ¿vale? Para que podáis ir rápidamente y ver dónde está. Esto no funciona si una parte está en comentario. 00:16:15

Veis que se está marcando este porque está sin comentar, pero no este. Si en algún momento quisierais cambiar, claro, porque imaginaos que de hecho por eso lo hago, a ver, si quisierais cambiar el nombre de todos en vez de ir uno a uno y quisierais llamarlo suma posiciones vector, si dais dos veces, bueno, con una vez vale, dos veces control más R, control R, podéis poner otro nombre y veis que se va a ir cambiando en todos. 00:16:32

Las referencias que haya 00:17:01

Suma vectores por posiciones 00:17:02

Yo que sé, ¿vale? 00:17:05

Veis que se están cambiando las dos 00:17:06

Cuando lo tengáis, le dais a escape 00:17:08

Ah, bueno, no, a escape no 00:17:10

Le dais a suma vectores por posiciones 00:17:12

Le dais a intro y ya está, ¿vale? 00:17:18

Veis que se cambian los dos 00:17:21

Pero no en los comentados, cuidado 00:17:22

Que ahí pueden surgir problemas 00:17:24

Porque luego yo sigo descomentando 00:17:26

Y ya no se está refiriendo a esto 00:17:28

Pero es muy útil cuando tenéis en un código 85 veces velocidad, porque estáis multiplicando elementos por velocidad, no sé, y lo queréis cambiar de una sola vez. Control-R, lo escribís y le dais a intro. Escape si no hacéis el cambio. 00:17:30

Bueno, entonces, estamos aquí. ¿Qué es lo que estamos haciendo? 00:17:44

Importante. Cada vector 3 tiene la posición x, la y y la z. 00:17:47

O, bueno, si usáramos el argot de los arrays, serían también la posición 0, la posición 1 y la posición 2, si recordáis el otro día. 00:17:55

Aunque no son exactamente lo mismo, dijimos que eran variables compuestas de varios valores. 00:18:04

Entonces, a veces nos interesa estar trabajando con una variable compuesta por varios, como un vector 3, que tiene estos tres valores, pero solo hablar de una de las tres posiciones. 00:18:11

Y entonces lo que hay que hacer, y eso cuando le dais al punto salen las sugerencias que suelen salir, y os salen los tres componentes de este vector. 00:18:23

Pues con esto puede decir que la posición primera de las tres es x. Y aquí básicamente lo que he hecho ha sido descomponer estos vectores en sus tres dimensiones para que se vayan sumando de manera correlativa entre ellas. 00:18:32

Entonces, esto como resultado va a dar que esto vale 1, esto vale 0, si os fijáis, y bueno, el resultado va a ser el mismo que si hacemos 1 más 0, 2 más 1, 3, y 4 más 2, 6, lo mismo que habíamos dicho. 00:18:49

¿por qué os digo esto? 00:19:04

a ver, lo vemos, un segundete 00:19:06

que igual hay algo con error por lo que me dice 00:19:08

ahí sale como que sobra 00:19:11

algo 00:19:13

como que sobra 00:19:15

vale, bueno, no sé 00:19:17

sí, me he debido de cargar 00:19:21

alguna llave 00:19:23

bueno, vamos a 00:19:25

aquí, y bueno, cuando le damos al play 00:19:28

va a dar el resultado de 00:19:30

1, 3, 6, ¿vale? que es lo que 00:19:31

tiene que dar como sentido a esto. Aquí pone multiplicando 00:19:33

vectores, ¿vale? Si os fijáis, ¿vale? No perdáis de vista porque 00:19:37

esto es un string que he puesto aquí, ¿vale? Vale, esto como ya lo hemos 00:19:41

hablado otros días, si nadie tiene dudas, sigo. ¿Qué pasa? Que cuando 00:19:45

ponemos, cuando estamos trabajando con vectores, es muy importante 00:19:49

tener en cuenta que si un vector, una de las posiciones del vector no se 00:19:53

quieren cambiar, se puede poner el nombre del vector con su dimensión y eso 00:19:57

Esto significa que se queda fija. Si no hiciéramos nada aquí, ¿vale? Estamos apelando a este vector A, ¿vale? Y solo vamos a guardar el valor 1. Entonces esto va a valer 1 y no va a haber ninguna operación. Aquí va a valer 1, ¿no? Esto si yo quiero aquí la I del B, pues va a valer 1 también porque es la posición I de este vector B. 00:20:00

Y en la última, pues si por ejemplo nos quedamos con el de vector A, ¿vale? Esto va a valer, ahora mismo va a devolver la consola un 1, 1, 4, ¿vale? Ahora no es que se está haciendo una operación, sino simplemente estamos rescatando valores dentro de los vectores. 1, 1, 4, ¿no? Vamos a verlo, como venimos haciendo, y veis que es 1, 1, 4, ¿vale? Esto es importante saber que se pueden descomponer los vectores a la hora de luego usarlos. 00:20:24

¿Hasta aquí qué tal? Bien, me seguís, vale. 00:20:52

Vale, esto es importante porque a veces tenéis que poner, porque os lo pide las tres posiciones de un vector y solo queréis cambiar uno, 00:21:00

pues las otras dos las ponéis como estaban, con x y z y esto es lo que ponéis, pues 55, ¿vale? 00:21:08

Ahora mismo la única que se ha variado es la y, ¿vale? 00:21:15

Entonces, es importante porque, por ejemplo, en la nave, en este ejemplo que estamos haciendo, el suelo se va a mover arriba-abajo, izquierda-derecha, en dos ejes, y el de profundidad no, porque como dice el enunciado, la sensación de profundidad, lo que lo va a dar son los pivotes, que son los que se mueven hacia la pantalla. Eso sí tiene movimiento en profundidad. 00:21:20

Entonces, en muchas ocasiones hay que recurrir a, no, no, yo quiero que esto siga siendo la posición original porque es que no se va a mover. Entonces, este que quede fijo aquí. Esto, como no estoy operando, pues va a ser el vector que viniera. 00:21:39

Sigo a la siguiente cosa importante 00:21:52

que yo entiendo que se queda claro en el tema 00:21:57

pero que queda aún más claro 00:22:00

porque en mi experiencia es algo que a veces genera dudas 00:22:03

y es lógico también al principio 00:22:08

Tenemos aquí un update 00:22:10

¿Por qué viene señalado? 00:22:13

Pues lo mismo, si tenemos dudas de por qué viene señalado 00:22:16

pues ponemos aquí 00:22:18

esto de la advertencia en este caso 00:22:21

porque sale verde, vale, a ver 00:22:24

que ahora se ha escondido y pone la función local update 00:22:25

se declara pero nunca se usa 00:22:28

y eso tiene algo que ver con las llaves 00:22:29

de antes, vale, si os fijáis 00:22:32

vale 00:22:34

por algún motivo el start 00:22:34

ah, vale 00:22:37

lo que pasa es que había borrado el de cierre 00:22:39

del start, vale, y ahora me sobra 00:22:42

uno, vale, pues eso 00:22:44

gracias a ver en contexto 00:22:45

la advertencia 00:22:47

que me estaba saliendo, me he dado cuenta 00:22:50

de que estaba metiendo el update dentro del 00:22:52

start, que son dos momentos de ejecución que no se deberían 00:22:54

mezclar, ¿vale? Simplemente 00:22:56

que los errores salen por todos lados 00:22:57

y lo importante siempre es saber 00:23:00

cómo salir del 00:23:01

escollo, ¿no? Vale, para 00:23:03

ver esto, este ejemplo 00:23:05

que voy a hablar un poco de cómo se descompone 00:23:08

el movimiento con el translate, ¿vale? 00:23:10

Y dejar claras un par de cosas 00:23:12

de los inputs, ¿no? 00:23:14

Que están en el tema. 00:23:15

Dejadme que haga un cubo o algún elemento que sea visible, por ejemplo este cubo que está en 0,0, y me voy a cargar esto de ANTI y le voy a poner este código en el que estoy ahora mismo trabajando, que se llama cálculo durante, y se lo incorpora al cubo. 00:23:17

al cubo al cubo al cubo ahora si quiere venga entonces ahora mismo tenemos un cubo que yo le 00:23:40

doy a play y está quieto vale porque todavía por ejemplo no hemos aprendido a usar las fuerzas de 00:23:46

la gravedad entonces está quietito que voy a hacer en este con este script no bueno ahora mismo como 00:23:51

si borrar a todo esto del estar vale porque todo son operaciones para una consola pero 00:23:59

Pero en el update, es decir, en cada fotograma, yo estoy diciendo que surja una condición, un if, que ya hemos visto también cómo funcionan, que en este caso ponen en juego lo que son los inputs, las interacciones que podemos hacer con dispositivos nuestros, que en este caso nos vamos a centrar sobre todo en teclado, pero pueden ser de más tipos. 00:24:04

Si veis la sintaxis que está en el tema desarrollada y lo que me importa es, a ver un segundo que lo pongo por aquí, que veamos las diferencias entre interactividad, clase input. 00:24:27

Bueno, y aparte del tema, también vais a haber señalado, lo que pasa es que es bastante complejo en este momento, que existe un nuevo sistema de interacción que permite añadir más dispositivos, pero que tiene bastante más intríngulis. 00:24:46

Entonces nos vamos a quedar con este Input Manager, este sistema más clásico, que es operativo, pero que de momento nos sirve. 00:25:01

Y lo importante es que veamos las diferencias, las sutilezas que hay entre los distintos tipos de inputs. Todo esto que va apareciendo son dentro de esta clase input distintos métodos que se pueden emplear. 00:25:09

importante porque 00:25:24

otros años me decían 00:25:27

pero cuando yo doy a getKeyDown 00:25:29

es que estoy dando a la flecha de abajo o a la de arriba 00:25:31

no tiene nada que ver 00:25:33

cuando estamos definiendo una interacción 00:25:34

hay que tener en cuenta 00:25:37

que al menos de partida 00:25:39

hay tres momentos importantes 00:25:41

y lo podéis ver cuando pulsáis una tecla 00:25:43

el momento en el que se pulsa 00:25:45

el tiempo durante el que 00:25:47

está pulsado y el momento en el que 00:25:49

se levanta 00:25:51

Y eso es lo que hace referencia a los apellidos de down o up. Luego dentro de los paréntesis ya se pondrá qué tecla o qué botón o qué elemento es el que estamos pulsando. Pero los métodos que estamos usando aquí sirven precisamente para decir que algo ocurra cuando lo pulso o ocurra cuando levanto o ocurra mientras lo mantengo pulsado. 00:25:52

Que es un poco lo que se explica en este apartado. Entonces, ¿qué diferencia hay entre getKeyDown, getKeyUp y luego getKeyAsecas? Pues lo importante, y es muy importante, es pensar que cuando pulsamos una tecla, esa operación, hasta que no volvamos a pulsar otra o esa misma, solo se da una vez en un fotograma concreto. 00:26:12

Pues está sucediendo, doy a la tecla E y solo es ese momento. O cuando lo suelto también es un momento. Pero no es lo mismo que cuando tenemos un método como GetKey, que lo que significa es que durante todo el tiempo que esté pulsada esa tecla, que puede ser 10 segundos, se está fotograma a fotograma, si lo metemos dentro de un update, ejecutándose una orden. 00:26:32

Esa es algo muy importante que entender en este momento 00:26:55

No tiene nada que ver con la dirección en sí 00:27:00

La dirección luego se explicita en la tecla que hay entre paréntesis 00:27:03

O el código que se da entre paréntesis 00:27:11

Y luego la orden que se da ya entre llaves del condicional 00:27:12

Entonces, por ejemplo, la sintaxis en este caso siempre empieza por esta clase input 00:27:17

que recoge en su interior las distintas configuraciones de interacción que tiene el InputManager. 00:27:25

Y luego aquí es donde entra uno de estos métodos que tenemos aquí, que son varios. 00:27:31

Hay otros pensados para botón del ratón, como en este caso, que con este input se dice 00:27:37

si ponemos esta línea es que si se pulsa el botón izquierdo del ratón se da esta orden. 00:27:46

Si es el botón derecho sería con el 1, el central es con el 2. Sería un poco ir estudiando todas estas variables que hay. Luego está el ketaxis, que ahora vamos a ir a él. 00:27:51

Y hay otro intermedio que es para pulsar un botón, por ejemplo, de un gamepad, por ejemplo, que se puede definir también. Entonces, vamos a volver a esto. Si vemos esta línea, lo que está ocurriendo es que estamos diciendo, mientras se mantenga pulsada una tecla, ¿y qué tecla es? Entre paréntesis es donde ponemos el nombre de esa tecla. 00:28:10

Y para saber qué tecla es, se puede poner de una forma que me parece más complicada, que es poner la tecla como un string, el nombre de la tecla, que significa de, o hay otra palabra reservada, que es un enum, que guarda en su interior. 00:28:30

si ponéis aquí, dice, voy a poner get key, ¿qué key es? Si ponéis key code, ¿vale? Y le dais a punto, salen todas las posibilidades que hay, ¿vale? 00:28:51

De un teclado, pues desde el F11, la G, la tecla help, la que queráis, ¿vale? Yo en este caso, por ejemplo, había puesto la B, ¿vale? 00:29:00

Pues para que este elemento se mueva hacia la derecha, ¿vale? 00:29:11

Entonces, yo, esta línea lo que quiere decir es si, mientras mantenga pulsada, por eso no es ni down ni up, sino get key, ¿vale? 00:29:18

Mientras mantenga pulsada esta tecla D, se ejecuta lo que hay en estas llaves, ¿vale? 00:29:25

Entiendo que más o menos esto también lo seguís. 00:29:32

Bueno, si habéis leído el tema y visto los vídeos. 00:29:35

Perdón. 00:29:39

Vale, pasamos a lo que son los transform, que es como dijimos es un método, que a diferencia de otros que hay que crear aquí un tipo de variable y convertirlo en variable, es una variable que ya viene por sí misma. 00:29:40

Si nos ponemos encima pone que es de la clase transform con mayúscula la T, pero digamos que ya es, como es el componente que se usa por defecto siempre, ya tiene su propia palabra hecha ya atajo para poder desplegar todos los métodos que haya relacionados con variar valores de transform. 00:29:54

transform, todo lo tendremos claro 00:30:17

pero se refiere esencialmente 00:30:20

a lo que ocupa este componente 00:30:21

que tienen ya por defecto la mayor parte 00:30:23

de los GameObjects 00:30:25

que tenemos en nuestro 00:30:27

juego 00:30:29

entonces 00:30:30

¿qué es lo que conseguimos? 00:30:33

bueno y dentro de transform hay muchos 00:30:35

pero bueno, en este caso sobre todo vamos a ver 00:30:37

el translate que sirve para ir moviendo 00:30:39

objetos y el rotate para ir 00:30:41

rotando objetos 00:30:43

este 00:30:44

transfer translate, si nos metemos en el 00:30:46

y aquí 00:30:48

vuelve a pasar algo de que me está 00:30:50

diciendo que Nanay, a ver 00:30:52

que es 00:30:54

aquí ahora me sobra esta llave 00:30:54

no sé cuando estoy poniendo yo llaves para que me diga esto 00:30:57

todo el rato, pero bueno 00:31:00

lo que vamos a conseguir 00:31:01

que iba a ir a ver 00:31:05

como siempre y fijaos que yo lo que hago cuando 00:31:07

tengo dudas es poner Unity en Google 00:31:10

Y pongo transform, translate. A ver qué me cuenta de esto. Siempre va a salir el scripting API y aquí os hablo de cómo se usa, con algún ejemplo. Y aquí lo que vais a ver es que dentro del translate se necesita un vector 3 que marque el movimiento, hacia dónde se dirige y con qué intensidad de movimiento, qué magnitud de movimiento. 00:31:12

Y vais a ver que, bueno, en este caso se puede declarar de dos formas este transform translate, ¿vale? Pero, importante, entender que lo que se tiene que poner siempre como primer argumento es un vector3, ¿vale? 00:31:36

Y que puede ser una variable vector3 que ya habíamos guardado antes o crear un new vector3 dentro de este translate, ¿vale? 00:31:51

Entonces, aquí estamos. 00:31:58

Aquí ahora mismo, si os fijáis, he puesto muchas más cosas que ahora explico el por qué, 00:32:01

pero si las dejo aquí, si yo hago aquí una copia y me cargo todo lo que no es el vector3, 00:32:06

y esta la voy a poner comentado, ¿vale? 00:32:18

Lo que vamos a decir es, en cada fotograma, ¿vale? 00:32:21

Si yo pulso, mejor dicho, no pulso, mantengo pulsado la tecla D, esto se va a ir moviendo en un vector 3. 00:32:24

Esto lo dejamos en cero, por tanto no varía en nada. 00:32:35

Van a cambiar la posición de ese objeto con respecto a donde estuviera una posición en cada actualización del update. 00:32:38

Entonces, vamos a verlo. Si yo voy ahora al juego y le doy aquí, y voy a alejarme aquí porque se va a mover rápido seguramente, si yo le doy a la D, veis que, lo voy a poner mirando al horizonte, si voy dando a la D, se va moviendo. 00:32:47

vuelvo a hacerlo, se ve ahí muy pequeñito 00:33:09

me voy a acercar un poco más, que se me ha ido un poco 00:33:13

importante, cuando vayáis a hacer interacciones 00:33:15

veis que yo tengo el panel de escena y el de juego 00:33:19

para que el juego se ejecute 00:33:22

y detecte las interacciones, aunque tengáis aquí abierta la escena 00:33:25

que a mí me interesa mucho, para ver en el entorno 00:33:28

este objeto, tenéis que clicar en juego 00:33:31

hasta que no cliquéis en juego, yo aunque le dé a la D 00:33:34

no se movería, porque no está en el área 00:33:36

del editor de Unity 00:33:40

es necesario para que 00:33:41

se pueda interactuar, ¿vale? 00:33:44

¿Hasta aquí me vais siguiendo? 00:33:46

Perdona que pregunte 00:33:49

tanto esto, pero es que quiero saber 00:33:50

si me vais siguiendo, porque si no me pongo 00:33:52

aquí a hablar... Vale, perfecto. Importante 00:33:54

que a veces decís, no me funciona 00:33:56

nada de esto, y es porque estáis 00:33:58

clicando en escena mismamente, 00:33:59

lógico, en escena podéis mover 00:34:02

los elementos vosotros como queráis, 00:34:04

¿vale? En reproducción para comprobar 00:34:06

cosas vale pero lo que son las interacciones tenéis que dar clic a game y ya ahí funciona y 00:34:08

fijaos que yo puedo volver a poner aquí el objeto que le doy a la tecla de vale y se mueve en el eje 00:34:13

x hacia la derecha porque pues porque hemos dicho la tecla de pues se va moviendo con respecto a 00:34:19

donde esté le va sumando digamos al valor que ya tenga uno en cada fotograma vale y estos dos los 00:34:25

deja igual porque son cero de hecho lo que hemos dicho antes si yo pongo un vector 3 solo con dos 00:34:31

valores también me lo coge y va a ser equivalente a esto vale simplemente que veáis que eso puede 00:34:38

ocurrir qué problema surge de esto es estable este movimiento pues no porque por lo que viene 00:34:43

en el tema también el problema del update o la ventaja según como se vea es que está esta orden 00:34:50

digamos este método se ejecuta en cada fotograma de reproducción del juego pero esto no significa 00:34:57

que el ordenador tenga constantemente la misma velocidad de reproducción vale va a ir digamos 00:35:03

si abrís 85 programas a la vez irá más despacio el ordenador tendrá menos capacidad de computación 00:35:11

que si pues sólo estamos con unity con este juego vale puede variar no entonces qué ocurre que si 00:35:17

en cada update yo muevo uno que os asegura que se mueva a la misma distancia en un segundo que 00:35:25

En el siguiente, me explico, si en un segundo el ordenador ha tenido la capacidad de reproducir 15 fotogramas, 00:35:32

se moverá 15 posiciones, pero si en el siguiente segundo ha podido reproducir 20 fotogramas, 00:35:43

se habrá movido 20 posiciones en un segundo. 00:35:51

Esto no tiene sentido porque el objeto se debería mover siempre a la misma velocidad. 00:35:55

Por eso, ahora mismo este objeto no es estable 00:35:59

De hecho, si nos fijáramos y hiciéramos pruebas más largas que las que voy a hacer ahora mismo 00:36:03

Vais a ver que puede ir dando como saltitos 00:36:08

Porque en un fotograma tarda más que otro en reproducirse 00:36:11

Entonces, bueno, es que, a ver, voy a alejarme 00:36:16

Que como se ve el gizmo, me voy a alejar 00:36:19

Y a lo mejor veis algún salto, ¿vale? 00:36:22

Normalmente va a ser mínimo 00:36:24

Pero a veces se ven como tirones 00:36:25

Y se debe precisamente a esto que os estoy comentando. La solución a esto, ¿cuál es? A ver, usar este elemento que se llama time delta time, ¿vale? Y lo voy a comentar esto para dejarlo aquí. 00:36:27

Vale, ¿qué hace? Y esto de momento me lo cargo. ¿Qué hace el time delta time? El time delta time lo que calcula, lo que dice básicamente, y mira, tengo aquí un debug log también preparadico, lo que dice es, lo que devuelve es el tiempo que tarda ese fotograma precisamente en tiempo, en segundos, cuánto tiempo tarda el fotograma en reproducirse, el tiempo que ha tardado desde el anterior hasta que ese se ejecuta. 00:36:43

De hecho, vais a ver que si yo voy ahora aquí a Unity, a la consola, veis que los valores van cambiando. Lo que os he dicho, todos los fotogramas tardan lo mismo o el ordenador no tiene la velocidad para hacerlo de manera constante. 00:37:12

Y esto nos está dando el time delta time, es lo que estamos viendo. Es el valor de tiempo que transcurre entre un fotograma y el anterior realmente. 00:37:33

¿Qué es lo que hace esto al multiplicarlo? Y recordad que es un número, un número solo, que antes hemos dicho que la multiplicación de un número solo sí se puede dar, para que toda la multiplicación afecte a las tres posiciones por igual. 00:37:44

y sea, por tanto, bueno, pues antes me ha salido la palabra, equivalente, ¿no? Entre las tres, que no haya un eje que se mueva más rápido que otro. 00:37:57

Las multiplicaciones siempre ponen el mismo valor. Entonces, ¿qué conseguimos? Y aquí pongo algún ejemplo que lo que hace esto es compensar... 00:38:07

A ver, vale, esto es simplemente para daros un detalle teórico, ¿no? Para compensar precisamente que la velocidad de movimiento, al multiplicarlo por este time delta time, sea siempre equivalente. 00:38:16

¿Por qué? Porque si os fijáis, lo que hace es, antes os he dicho, si en un segundo se hacen 15, se generan 15 fotogramas, se moverá 15 posiciones. Al multiplicarlo por el tiempo que ha tardado, se va a equilibrar siempre para que sea el mismo, ¿no? 00:38:31

Y fijaos aquí, si se hubieran ejecutado 10 fotogramas, el time delta time sería 0,1, porque 0,1 es el tiempo que tardaría para que se ejecuten 10 en un segundo y sería 1. 00:38:46

Si por el contrario se hubieran generado 5 fotogramas, cada fotograma habría tardado en ser 0,2, que es el time delta time. 00:39:00

Y veis que al final equilibra para que la duración de todos sea siempre al final de 1. 00:39:09

Si solo se han hecho tres fotogramas, se multiplicará por un time delta time de este valor. 00:39:14

Entonces, aquí está, digamos, equilibrando en todo momento, ¿vale? 00:39:19

Porque está cambiando este valor realmente, en todo momento, este valor, o los que hay aquí, 00:39:22

aquí como estos son cero, pues la multiplicación da cero, 00:39:27

pero se está variando de manera dinámica cuántas posiciones se tiene que mover 00:39:30

para que sea equilibrada, ¿vale? 00:39:35

Esto es algo muy propio de cuando se hacen movimientos en el update. 00:39:37

Y diréis, por si a alguien le ha surgido la pregunta, ¿y por qué? ¿Y por qué no dejan fijo el número de fotogramas que se reproducen en el juego para que siempre sea estable y nos quitamos de esta historia del time delta time? 00:39:44

Pues muy simple. Para empezar, porque sí que hay otro método que ya veremos en el tema 3, que es el fix update, que ese sí que es fijo. Este es una velocidad de actualización constante. 00:39:58

vale pues se pone que es 0.2 y todo lo que se ejecuta tarda 0.2 vale si el 00:40:08

ordenador no le da tiempo habrá que subir esta velocidad bajar hacer más 00:40:14

lenta esta velocidad para que le dé tiempo pero está pensado para que sea 00:40:18

fijo y estable vale pero el update tiene una ventaja que es intentar aunque luego 00:40:21

lo estabilicemos en algunos valores que no nos interese intentar captar también 00:40:27

por ejemplo una interacción lo antes posible vamos a ver que cuando nosotros 00:40:32

pulsemos una tecla vale al final vamos a poner en el ate que es el que está todo el rato escuchando 00:40:36

cuando sucede algo vamos a poner que capte esa interacción aquí por ejemplo si os fijáis 00:40:42

mismamente si pusiera aquí down para para que sólo capte el momento en el que pulso la tecla 00:40:47

de vale va a haber un momento en el que digamos unity entiende que se ha pulsado cuanto antes sea 00:40:54

ese momento es decir relacionándolo con en cuanto haya otro momento de reproducción cáptalo vale 00:41:01

Eso no habría que compensarlo de ninguna forma porque lo que queremos es que lo capte lo antes posible para que la interacción no tenga ningún lag o sea el mínimo. 00:41:06

Pero luego la orden que ejecuta sí que queremos que sea consecuente para que no dé, en este caso, tirones. 00:41:15

Es decir, la interacción la queremos cuanto antes, lógicamente, para que cuanto antes ya aquí se procese lo que sea. 00:41:21

Porque los movimientos sí que es verdad que nos interesa que sean estables porque visualmente si va dando tirones queda mal, no tiene sentido. 00:41:28

pero yo que sé, puedo convertir una booleana 00:41:35

en falsa en este segundo y eso sí 00:41:37

queda igual, eso cuanto antes también 00:41:39

pues lo pondremos aquí 00:41:41

si esta booleana 00:41:43

cambiar, yo que sé 00:41:45

la queremos convertir en falsa, no sé 00:41:48

estoy haciendo aquí una chorrada, en cuanto le dé 00:41:51

a la tecla D, quiero que suceda eso 00:41:53

ahí no voy a poner un tema en delta time 00:41:55

pues que suceda cuanto más rápido mejor 00:41:57

¿sí? 00:41:59

entonces, bueno 00:42:02

¿qué problema tiene también 00:42:03

y vuelvo a ponerlo como estaba para que lo mantenga 00:42:04

porque, ojo, si dejo 00:42:07

este down, ¿vale? 00:42:09

entiendo que esto 00:42:11

me estáis siguiendo, pero si pongo 00:42:12

que solo sea un get key down 00:42:15

aunque yo mantenga la tecla D 00:42:17

¿vale? me meto aquí 00:42:19

y selecciono el cubo para que se vea, le doy a la tecla D 00:42:21

ahora mismo, y la estoy manteniendo pulsada 00:42:23

bueno, no, en realidad la estoy manteniendo 00:42:25

pulsada y confiada en mí, y no se mueve 00:42:27

se ha movido una fraccioncita 00:42:30

la primera vez, ¿por qué? 00:42:31

Porque aunque esté manteniendo la tecla, solo está detectando el momento, ¿vale? Y le estoy dando diferentes ocasiones el momento justo de pulsar la tecla. Y no mientras lo mantengo, entonces se ejecuta una vez y no se está moviendo de manera continua. 00:42:33

Y fijaos además que los valores que va subiendo son poquísimos, son decimales. Y aquí teníamos uno. Debería moverse una unidad cada vez que al menos pulsara esta tecla D. 00:42:52

¿Por qué está sucediendo esto? Porque fijaos los valores de decimales que tiene, de lo poco que tarda, el procesador en generar cada fotograma. 00:43:07

¿Qué significa? Que claro, cuando se multiplica un valor por el time delta time, indefectiblemente siempre se va a ver muy reducido, porque se ocupa de valores muy pequeños. 00:43:18

¿Eso cómo se soluciona? Y es una de las razones por las que es tan importante nuevamente conocer que un vector se puede multiplicar de manera consistente o proporcional por un número. 00:43:34

Por eso es por lo que vais a ver en muchas ocasiones que hay otra variable por aquí, que yo he declarado como variable global aquí, FroudeSpeed, con un valor, que es básicamente en este caso el que nos sirve para, una vez ya equilibrado este movimiento en consecuencia con los fotogramas, 00:43:45

pues luego ya lo multiplico 00:44:03

para que vaya más rápido, yo no quiero que vaya tan lento 00:44:06

pero ya lo va a hacer 00:44:08

en base a una velocidad 00:44:09

digamos, estabilizada 00:44:12

y proporcional, con esto yo lo aumento 00:44:14

por eso ahora cuando yo le de 00:44:16

ahora que le he puesto una speed de 100 00:44:18

que multiplicaba bastante 00:44:20

y 100 está bien si solo estáis poniendo 00:44:21

el time delta time, porque fijaos 00:44:24

bueno, de hecho sería 1000, pero si ponemos 100 00:44:25

básicamente volvemos a recuperar 00:44:28

la unidad, entonces 00:44:30

digamos que es lo más equilibrado 00:44:31

Pero yo si ahora ejecuto y le doy a la D, a ver, y me vuelvo ahí, se va moviendo ya en función de unidades. 00:44:33

Es verdad que ahora estoy lejos, pero veis que ahora va a una velocidad más interesante, que no son decimales. 00:44:44

Que vaya, que a veces va a haber que multiplicarlo por mil o por más. 00:44:52

y bueno, se va sumando en cada fotograma 00:44:55

porque recordad que he quitado el getKeyDown 00:44:59

o getKeyUp y entonces 00:45:01

es el tiempo que yo mantenga esa tecla 00:45:02

pulsada 00:45:05

os queda más o menos 00:45:05

claro por qué es este time delta time 00:45:09

lo de poder multiplicar 00:45:11

valores por sí mismos 00:45:13

bueno, por sí mismos, entre sí, de qué forma 00:45:14

vale 00:45:17

sigamos 00:45:20

vale, esta primera parte 00:45:22

hecha 00:45:24

voy a la siguiente 00:45:25

vale, sí es denso 00:45:27

pero realmente 00:45:30

de mejor o peor manera 00:45:31

yo intento que esto es complicado 00:45:33

ponerlo en el tema en textos 00:45:35

y bueno, también están los vídeos de Álvaro y tal 00:45:37

es complicado 00:45:39

pero por eso estoy repasándolo 00:45:40

por verlo un poco más 00:45:43

en detalle 00:45:46

sí que es verdad que a medida que vaya pasando el curso 00:45:46

me iré deteniendo menos 00:45:49

en explicaciones como concretas 00:45:51

Porque es que ya lo dije en las primeras clases, es muy importante tener la base bien porque si no el resto ya se desbarajusta y a partir de ahí es más investigar y más ir implementando cosas. 00:45:53

Vale, aquí tenía varias cosas, os quiero explicar otras dos. Sí, me ponen en el chat, lo complejo es coger todo y enhebrarlo. Y efectivamente, eso es lo complicado. 00:46:05

Para esto, antes de seguir, yo con mi libro, os doy dos consejos. Lo primero es cuando se... Bueno, yo no he estudiado informática, ni cerca ando de eso, pero cuando la gente estudia algo de informática, sobre todo en la carrera que es más académica, en la ingeniería informática, 00:46:18

hacen lo que se llama, y creo que no he equivocado, pero lo que se llama pseudocódigo. 00:46:40

Pseudocódigo, y si no, pues código escrito en lenguaje coloquial se podría llamar, ¿vale? 00:46:45

Significa que hay que intentar ir descomponiendo cada acción que vamos a hacer en una frase. 00:46:52

Pues, por ejemplo, aquí quiero, es lo que estoy haciendo aquí con los argumentos, 00:46:58

ir escribiendo qué quiero conseguir yo y ir poniendo, pues al arrancar el juego, 00:47:02

poner el valor a 0, yo que sé, y luego siguiente, fijar la velocidad a 100, ¿vale? 00:47:07

Y una vez, digamos que ya hemos descompuesto en órdenes básicas todo lo que queremos ir logrando, 00:47:20

ya es ir buscando la forma de hacer esa línea, ¿vale? 00:47:26

Pero al principio abruma mucho intentar hacer todo, porque hay que ir realmente pasito a pasito 00:47:29

ir volviendo al código, ir depurándolo para ir consiguiendo lo que se quiere, pero lo más fácil, digamos, es ir descomponiendo en operaciones básicas cada orden que queremos hacer, ¿vale? 00:47:36

Y esto tiene algo que ver con lo que voy a explicar ahora de poder declarar nuestros propios métodos. 00:47:49

El otro consejo que os doy, y lo voy a dejar por grabado, aunque desde luego y para nada quiero que esto sea la dinámica, los programadores ahora están usando mucha inteligencia artificial para ir haciendo sus códigos y sobre todo, que es lo que me interesa aquí, para los momentos en los que uno está atascado y no sabe por dónde tirar. 00:47:54

Porque tú puedes copiar un código y decir, oye, ¿y cómo sigo para conseguir que esto gire de tal forma? 00:48:17

ChatGPT, o el que usarais, os va a dar unas ideas, pero que vosotros podéis copiar y pegar. 00:48:27

Yo estoy tranquilo porque aunque copiéis y peguéis, si no entendéis lo que estáis copiando y pegando, 00:48:35

al final va a dar errores o no vais a saber luego que se conecte con esto. 00:48:39

pero sí que es verdad que para que os dé sugerencias 00:48:44

de por dónde tirar si os quedáis atascados 00:48:46

aparte de preguntarme a mí, por supuesto, también 00:48:48

es muy útil 00:48:50

porque además explica 00:48:52

los códigos muy bien si le ponéis algo 00:48:54

entonces, bueno, si en algún momento os quedáis muy atascados 00:48:56

y es algo que sabéis pero no sabéis por dónde tirar 00:48:58

que es la gran 00:49:01

complejidad que tiene este módulo, ¿vale? 00:49:02

que yo voy a dar muchas 00:49:04

todo lo que yo sé y pueda lo voy a ir 00:49:05

dando, pero como bien han dicho, luego hay que 00:49:08

irlo combinando para ir consiguiendo 00:49:10

distintas cosas. En eso es algo 00:49:12

Y por eso justo en programación puede que sea una de las primeras cosas que la inteligencia artificial se ha metido en los softwares. Es muy útil, ¿vale? Porque además es que CGPT y la inteligencia artificial hablan esos lenguajes casi mejor que nosotros, ¿no? Son nativos. 00:49:14

Son, bueno, entonces, bueno, si en algún momento os atascáis, podéis intentar preguntarle y, bueno, si no lo entendéis, incluso decirle, oye, más básico y yo conozco este método, pero como lo, bueno, pues también es buena utilidad. 00:49:30

Al final, ya os digo, si no sabéis qué os está escribiendo, por mucho que os lo intente explicar, se necesita una base y en esas estamos, ¿vale? 00:49:44

Bueno, ahí van dos consejos. Ir por instrucciones, ir desentrañando las cositas poco a poco, porque si intentas abarcar todo de una, normalmente te aturullas y acabas bloqueándote demasiado. 00:49:52

Y luego lo otro, pues tenemos ahora una ayuda, bueno, y por supuesto, mirar el scripting para ver cómo funcionan los métodos. Eso, la documentación de Unity hay que tenerla siempre ahí a mano. 00:50:07

vale 00:50:20

vale, sigo 00:50:21

sobre lo que os he dicho precisamente 00:50:24

de 00:50:26

a ver, me ponen una duda 00:50:26

voy a aprovechar 00:50:30

para quitarme la sudadera, mientras me la escribes 00:50:32

o me la planteas 00:50:34

la guía de Unity 00:50:36

que nos recomiendas 00:50:51

está en formato PDF 00:50:53

por tener una copia independiente 00:50:54

no sé si está, pero 00:50:56

la verdad es que no tiene mucho sentido, y me explico 00:50:58

lo pone en los apuntes 00:51:01

pero existen dos cosas 00:51:02

el manual, cuando metéis en la documentación 00:51:04

de Unity pone el manual 00:51:07

y la API de scripting 00:51:08

lo primero también es importante 00:51:10

definir la versión que estáis usando 00:51:13

por defecto va a salir la 6 00:51:15

que todavía está como en desarrollo 00:51:16

bueno, ya ha salido pero 00:51:19

todavía puede estar mejor 00:51:20

nosotros estamos usando esta 00:51:23

la 2022.3 que es la última 00:51:24

que yo creo que se puede usar 00:51:26

sin experimentos todavía 00:51:28

entonces, bueno, lo ponéis ahí 00:51:30

y el manual sí que es como un manual 00:51:32

que intenta ir explicando qué hace cada cosa 00:51:34

y ves que tiene secciones, pues mira, me voy a meter en el apartado 00:51:36

de physics, vale, tiene tantos 00:51:38

hipervínculos, vale 00:51:40

que tener un pdf de texto 00:51:42

no es muy operativo 00:51:44

porque la gracia de esto es que se puede 00:51:46

ir saltando de una cosa a otra 00:51:48

e irla viendo, y luego en el scripting 00:51:49

pasa un poco lo mismo, en el scripting 00:51:52

lo que se describe es 00:51:54

los métodos, o digamos 00:51:56

el lenguaje que se ha aplicado, aunque se 00:51:58

parta de C-SARP, ¿vale? Pues como 00:52:00

se ha ido desarrollando distintas 00:52:02

métodos, distintas propiedades, 00:52:03

distintos todos, que son las que luego nosotros 00:52:06

podemos usar en nuestro código, ¿no? 00:52:08

Entonces, la gracia aquí es poder 00:52:10

poner Translate y 00:52:12

te lleva a Translate. Si tú tienes que buscar eso en un 00:52:14

PDF, te cuesta. 00:52:16

Y entender, por ejemplo, el Translate que vamos a 00:52:18

ver ahora, no es ninguno de estos. 00:52:20

Bueno, esto 00:52:22

por ejemplo, es la explicación de que hace 00:52:24

la traslación. Si te metes aquí, 00:52:25

Te habla cómo se construye bajo el código, pero bueno, el que nos interesa ahora sería el Transport Translate. 00:52:28

Y aquí es, otra vez, donde vemos incluidos ejemplos, que son estas pantallas en negro, cómo se declara y las funciones. 00:52:34

Y en inglés, eso sí que es verdad que no está en español, o si hay en español, a veces, normalmente no. 00:52:41

Bueno, pues aquí podemos ir viendo distintos usos y también lo que tenemos que saber, porque en muchas ocasiones un método tiene un uso y tiene excepciones que no se pueden usar y hasta que no lo lees aquí dices, ¿y por qué esto no va? Y es que resulta que ese método precisamente no está pensado para hacer algo de esta manera. 00:52:49

Bueno, pues hay que buscar otra, ¿vale? Pero aparte, un PDF, además es que esto lo van como actualizando en cada versión y es, como puedes ver, larguísimo. 00:53:08

Entonces, la copia es tenerlo en internet. Vale, vamos con lo que iba. 00:53:20

Ahora, antes de seguir, ¿vale? Y perdonad que os voy a explicar una cosita antes. Era por los momentos que uno no tiene internet. Bueno, pues hay que intentar tenerlos, pero si no, bueno, pero es que vais a necesitar internet. 00:53:30

de help se puede acceder a estas dos funcionalidades pero te lo abre en un 00:53:51

navegador vale entonces bueno por lo que el abierto aquí entonces no no que yo 00:53:55

sepa no está pero es que ya te digo que ni siquiera creo que tenga 00:54:01

mucho sentido que te lo den así vale cálculos durante me meto ahí otra 00:54:06

vez perdonadas lo tengo por aquí cálculos durante hay un último operador 00:54:12

que quiero que veamos que es el que se llama módulo vale y el módulo en ocasiones puede ser 00:54:18

útil y de hecho cuando vayamos hablando voy a quitar los de barlos para que no distraigan vale 00:54:26

y me centro en el start me voy aquí abajo y sigo vale el módulo es un operador igual que el de 00:54:32

sumar el de restar el de multiplicar y el de dividir vale que ya tenemos vistos que es con 00:54:38

el porcentaje. Esto es otro operador. ¿Y qué es lo que hace el módulo? 00:54:44

Devolver el resto de una división. Es decir, hace una división, 00:54:48

sabemos lo que hace una división, y si 00:54:52

no da decimales, digamos, ese número, dará cero, y si da decimales, pues dará el resto. 00:54:56

Entonces, por ejemplo, voy a poner aquí un float 00:55:01

que lo voy a llamar módulo. 00:55:05

Resultante, resultante... 00:55:10

y aquí lo que vamos a hacer es 00:55:14

que módulo, esperad que lo planteo 00:55:18

un segundo, que lo tenía para explicarlo 00:55:20

de otra forma, pero quiero verlo aquí primero 00:55:22

módulo resultante 00:55:24

es igual a 00:55:26

9 00:55:27

de 3 00:55:28

y aquí lo que vamos a hacer 00:55:31

es un debug log para ver el resultado 00:55:34

que nos está devolviendo 00:55:36

que va a dar 00:55:37

lo que valga módulo resultante 00:55:40

¿vale? 00:55:42

Y voy a poner aquí, como siempre, el resultado del módulo es un espacio y nos lo dará. 00:55:42

Vale, si dividimos 9 entre 3, os lo pregunto, ¿cuál va a ser el resto de esa división? 00:55:54

¿Este concepto del resto lo tenemos claro? 00:56:02

A ver, que miro el chat. Tengo yo aquí más pantallas abiertas que... 00:56:07

A ver, 9 entre 3, ¿qué resto da? No, 3 es el resultado. 9 entre 3 da 3. Y ya está, y no tiene decimales, por eso no hay resto. 00:56:11

9 entre 3 da de resto 0. Si cuando hacíamos las divisiones, no sé si os acordáis, que salía un resultado, pero luego el resto aparecía a la izquierda, debajo de los numeritos. 00:56:37

¿Os acordáis de eso? 00:56:48

Vale, vamos a hacer otro ejemplo. 00:56:52

Si hacemos 10 entre 3, ¿cuál sería el resto? 00:56:54

El resto. 00:57:00

Os lo digo yo. 00:57:07

10 entre 3 no da un resultado. 00:57:07

Sí, esto está en los apuntes, pero todavía nadie me lo ha contestado bien, 00:57:11

así que entiendo que no... 00:57:16

No, hay que hacer una división, ¿vale? 00:57:17

Esto lo que está diciendo es una división. 00:57:19

Pero lo que nos interesa no es el resultado, que es lo lógico. En el anterior, evidentemente, 9 entre 3 era 3. Ese es el resultado. El resto, sin embargo, es si te sale un número con decimales, es cuántos valores quedan por haber sido aplicados para ser un número entero. 00:57:20

10 entre 3, por ejemplo, el resto sería 1. ¿Por qué? Porque 10 entre 3 daría puro si fuera 9, ¿vale? Pero si ponemos 10, faltaría 1 para que se pudiera dividir. ¿Sí? 00:57:38

¿Vale? Esto, no sé explicaroslo mejor, pero el resto en una división. El resto en una división es el número que queda cuando la división no es exacta, ¿vale? Por eso, cuando no es exacta es un valor diferente a cero. 00:57:52

Cuando una división tiene resto decimos que es una división entera. En una división entera el dividendo es igual al divisor... Bueno, es complicado, pero no sé si me estáis pillando. Cuando se hace una división y digamos que el valor no queda redondo, como un número entero, va a haber un resto. 00:58:10

Y ese resto es el número de unidades que han quedado sueltas hasta el siguiente valor, ¿vale? Entonces 10 módulo 3 sería 1, vamos a verlo, 10 módulo 3 sería igual a 1 y le doy y lo vamos a ver, aquí está. 00:58:26

El resultado del módulo es 1, ¿vale? Si yo aquí pongo 11, el resto serán 2, porque 9 entre 3 da el resultado y sobran 2, ese es el resto. Por eso, de hecho, se llama así. 00:58:47

Ahora vamos a ver que el resultado del módulo es 2. ¿Qué pasa si yo lo pongo en 12? Que el resto volverá a ser 2. No, perdón, 0, porque 12 entre 3 da 4 y es un número entero, 00:58:59

entonces no sobran valores. Esto es importante y diréis, ¿esto para qué sirve? Pues fijaos, por ejemplo, que si cualquier número se divide entre dos, 00:59:12

si es un número par va a dar un resto cero y si no es un número impar va a dar un resto uno. Y es una forma muy rápida, por ejemplo, 00:59:23

por poner un ejemplo de aplicación, para discriminar entre valores pares e impares, que esto puede ser útil en diversas ocasiones, ¿vale? 12 entre 2 será un valor de 0 el resto, ¿verdad? 00:59:32

A ver, aquí, da un valor de cero. Si pongo cualquier número, cualquiera, que no sea par, por ejemplo este, con esto estamos guardando básicamente en esta variable que si el resultado es uno, se trata de un número impar. 00:59:45

Y este es uno y es impar. Esto por un lado, que ahora lo voy a conectar con otra cosa, pero entendéis lo que hace el módulo. 01:00:11

Siempre el resto va a estar vinculado a eso, a que el resultado sea un número entero 01:00:18

Y luego va a haber determinados valores hasta llegar el divisor 01:00:24

Es decir, siempre va a ser el máximo un número menos al que pongamos aquí 01:00:30

Por eso cuando ponemos aquí 4, el resto máximo que puede tener es de 3 01:00:34

Porque si pongo 12 es 0 el resto, si pongo 15 el resto es 3 01:00:39

porque el siguiente valor, que ya es 16, vuelve a hacer un resto 0, ¿vale? 01:00:45

Si este fuera de 7, por lo mismo, el resto máximo que puede tener es 6, ¿vale? 01:00:50

Y hay valores intermedios. 01:00:55

Sobre todo, de momento, por ejemplo, nos sirve esto de saber si esto es un valor par o impar 01:00:58

porque luego podemos decir que si módulo resultante es igual a 0 o a 1, ¿vale? 01:01:04

Si yo pongo aquí, si módulo resultante en este caso es igual a cero, y me falta aquí otro, ¿vale? 01:01:14

Si pongo esto, significa que este número es par, ¿vale? 01:01:24

Si fuera uno, significaría que es impar, y ya según eso puedo ir discriminando que ocurran unas acciones u otras, ¿no? 01:01:29

En ese condicional. 01:01:37

O sea, que el módulo me escribe, o sea, el módulo solo dice cero y uno para indicar decimal par o impar. 01:01:41

En este caso, si hacemos un módulo donde el segundo valor es un 2, sí, para indicar decimal par o impar. No es decimal par o impar, es que tenga resto o el resto sea cero. 01:01:47

Esto si no, habrá algún vídeo en YouTube que lo explica. Esto lo habéis visto seguro 100% en el instituto, pero entiendo que son cosas que se olvidan. 01:02:02

Os lo digo porque de hecho una de las soluciones que yo he llegado para una de las formas de la rotación, si no se usa este módulo, no se puede hacer. Por eso me parece interesante que sepáis que existe, aparte de que es que se usa, de verdad, para ciertas cosas. 01:02:17

vale entonces vamos a seguir porque si no nos detenemos pero no entendí pero formule parte 01:02:34

de la pregunta pero vale sí que está más o menos resulta perfecto vamos a este código de aquí vamos 01:02:40

aquí que aquí yo he puesto lo que es un método y voy a poner voy a seguir en esta en este que 01:02:47

tengo aquí que lo tengo más recogido cuando vosotros empleáis después de una clase ponéis 01:02:53

un punto, os va a poner que es un método, que son estos 01:03:03

translate, por ejemplo, getKey en este caso, primero tienen una clase 01:03:07

como transformInput y luego estos métodos que si veis vienen marcados 01:03:12

de amarillo y siempre están continuados por un paréntesis 01:03:15

que puede llevar cosas o no llevar cosas. De hecho, si os fijáis 01:03:19

los momentos de ejecución tienen 01:03:23

son métodos, sí que es verdad que no los llamamos porque ya vienen aquí declarados 01:03:26

pero no deja de ser un método como los que tenemos aquí, con una letra mayúscula y con un paréntesis después. 01:03:31

Esto significa que aunque ya vienen programados para ser usados así, nosotros podemos crear nuestros propios métodos. 01:03:38

Y los métodos tienen principalmente dos usos. 01:03:46

Uno, estructurar mejor el código, permitir hacer capítulos, mejor que capítulos, secciones de código 01:03:52

que van ejecutando órdenes y otra es para hacer operaciones en su interior. 01:04:01

Como esto de primeras entiendo que igual no se entiende, vamos a verlo en uso. 01:04:06

Esto viene del tema cero. No sé si le habéis echado un ojo y que igual me decís todos. 01:04:12

Yo ya sabemos cómo se declaran métodos y para qué. ¿Lo vemos? ¿O pasó la tarea? 01:04:17

Sí, vale, lo vemos, ¿no? Yo sí lo he visto. Vale. Vale. Es que ahora lo suyo sería preguntaros, ponedme un ejemplo, y lo haríamos, pero aquí... ¿Lo hago muy rápido? Vale. ¿Lo repasamos, os parece? Sí, vale, señal. 01:04:26

Vamos, además es que es algo muy importante, por eso quiero incidir, porque así además sabéis cómo, aunque luego son muy complejos en su interior, cómo llegan a existir estos métodos, que básicamente si os fijáis, y mira, me queda encima, pone void, transform, translate, ¿vale? 01:04:52

Esta palabra de void, que significa en inglés vacío, la nada, ¿no? Si yo pongo este void a continuación, y cuidado, void con minúscula, ¿vale? Que hay otro void por ahí en mayúscula que pueda aparecer. Aquí nos quedamos con el de minúscula. 01:05:08

si ponemos fuera es decir fuera de otro método que haya vale la declaración de 01:05:22

métodos si os fijáis aquí está voy de start vamos y esa llave cierra y aquí 01:05:29

dentro habrá unas instrucciones luego se abre otro void que cierra en sí mismo y 01:05:34

tendrá sus instrucciones nosotros vamos a hacer ahora otro conjunto de 01:05:39

instrucciones y luego lo voy a unir con lo del módulo que estoy hablando de 01:05:42

algunas cosas para luego juntarlas. Podemos hacer un método que se llame 01:05:47

recogeCódigo. ¿Vale? Veis que cuando escribimos después de 01:05:55

un void, y ojo, la sintaxis de los métodos, recordad que es con mayúscula la 01:06:01

primera letra, ¿vale? Y bueno, con Pascal case, ¿no? Y posteriormente se pone este 01:06:06

paréntesis. La sintaxis continúa con unas llaves. ¿Qué 01:06:11

lo que acabamos de hacer hemos hecho un método que lo que hace es en base a este nombre vamos 01:06:16

a poder ejecutar un código que va a estar aquí dentro y lo vamos a poder llamar siempre que 01:06:21

queramos igual que aquí cuando ponemos translate o el otro día poníamos instancia vale que es otro 01:06:26

método instancia y por eso vais a ver también que se pone en amarillo vale falta poner lo que nos 01:06:31

pide pero ahí está vale este código una vez se ha declarado así con este void pues yo puedo ahora 01:06:37

En otro momento de ejecución, porque ahora mismo esto no se está ejecutando en ningún lado, 01:06:44

están los métodos de ejecución, el Start, el Update, el Fixed Update, el Awake, hay distintos. 01:06:49

Pero dentro del Update yo voy a decir, quiero que se ejecute en cada fotograma, recoge código. 01:06:56

Bueno, ahora mismo se ejecutará además si pulsamos la tecla D. 01:07:02

Yo lo voy a poner que sea en cada fotograma impepinablemente. 01:07:05

esto qué significa que yo todo lo que ponga aquí cuando llegue cada vuelta de cada fotograma y se 01:07:09

reproduzca lo que hay dentro de update va a ejecutar lo que hay aquí dentro vale imaginaos 01:07:17

que vamos a poner en vez de recoger código voy a poner un nombre más concreto disparo o salto 01:07:21

o una acción, ¿vale? 01:07:30

Y bueno, como lo he cambiado, pues disparo. 01:07:34

Aquí en cada fotograma se va a ejecutar lo que haya en este disparo. 01:07:39

Si yo pongo que en disparo me ponga debug log, 01:07:42

he disparado, ¿vale? 01:07:48

¿Qué es lo que va a ocurrir? 01:07:57

Que esta orden se va a ejecutar, 01:07:58

porque lo he puesto dentro del update, 01:08:01

en cada fotograma, ¿vale? 01:08:02

Y digamos que cuando llega a esta línea dice, ojo, hay un método llamado disparo. ¿Qué es eso? Y va, lo busca y dice, ah, mira, disparo. Y ejecuta lo que hay aquí tal cual. Lo ejecuta y una vez lo ha ejecutado, pues ya sigue con el resto del código. Va, digamos, saltando de una parte a otra. 01:08:06

Por eso, igual que aquí al comienzo, dentro de lo que es la clase, hacemos la declaración de las variables globales, para luego poder ir usándolas dentro de cada cápsula, incluida esto, esto también son cápsulas, tienen su entorno entre las llaves, su ámbito. 01:08:24

con los métodos va a suceder algo parecido 01:08:40

se pueden ir incorporando entre otros métodos 01:08:45

ya os he dicho que para declarar un método 01:08:48

lo suyo es hacerlo fuera de los métodos de ejecución 01:08:50

porque si no se estará creando también en ese momento de ejecución 01:08:53

y no es lo que queremos 01:08:56

lo vamos a declarar en un punto aparte 01:08:57

y aquí podemos ir haciendo el void salto 01:09:00

y dentro de esto yo puedo ir metiendo aquí las instrucciones de salto 01:09:04

otro que va a ser 01:09:09

voy a ir 01:09:11

correr, yo que sé, os estoy poniendo ejemplos 01:09:13

que ya vais a usar 01:09:15

incluso en esta práctica lo podéis hacer 01:09:17

y con esto lo que conseguimos es ir 01:09:19

las distintas acciones 01:09:21

irlas segmentando 01:09:23

y que en cierto momento cuando pulso 01:09:25

la tecla D, quiero que haga un salto 01:09:27

pues en vez de poner todo el código del salto 01:09:29

pongo esta 01:09:31

digamos esta llamada 01:09:33

al método y lo buscará y ejecutará 01:09:35

lo que hay dentro y luego continuará el código. Porque si no, a lo mejor tenemos para ejecutar 01:09:37

ese salto un código de 87 líneas y aquí estamos dando las distintas opciones que configuran 01:09:42

el salto. Imaginaos que luego en otro momento del código, si doy a otra tecla o hago cualquier 01:09:49

otra cosa, también tengo que saltar. Tendría que copiar estas 87 líneas y pegarlas aquí. 01:09:53

Entonces sería muy farragoso porque al final el código sería muy largo y luego otras 01:10:00

87 líneas para hacer el disparo igual disparo cuando me agacho cuando apunto y cuando tal no 01:10:04

y se van dando muchas condiciones entonces ir copiando todo el rato el mismo código es un 01:10:10

tostón que conseguimos con esto que simplemente poniendo la llamada el disparo pues lo pongo aquí 01:10:14

y que luego aquí hay otra condición que disparó por la copia aquí y que tengo que cambiar algo 01:10:20

de disparo por de manera tal lo cambio aquí si me seguís no entiendo entonces es una forma de ir 01:10:25

organizando el uso de nuestro trabajo. Eso es la primera función de un método, organizar, 01:10:32

organizar y conseguir ir encapsulando instrucciones que pueden ser de muchísimas líneas para 01:10:48

que solo con una llamada a ese método se ejecute lo que hay adentro. Luego empieza 01:10:54

complicarse porque como hemos dicho antes los métodos entre sus paréntesis pueden pedir cosas 01:11:01

de hecho yo no puedo poner un translate sin poner nada estoy llamando un método como aquí disparo 01:11:07

y ves que éste no da problemas y éste sí y hay por qué porque cuando se declara el método aquí 01:11:12

vale yo puedo decirle que obligatoriamente haya que pasarle entre estos paréntesis que digamos 01:11:18

que se conecta con el de la declaración con el paréntesis luego de la llamada vale y requiere 01:11:24

que se pase algún valor. 01:11:30

¿Esto cómo se hace? 01:11:35

Y es simple, en realidad, si lo pensamos. 01:11:37

De primeras puede costar, pero es simple. 01:11:39

Igual que declaramos variables 01:11:41

y primero hay que decir de qué tipo es la variable 01:11:42

y luego el nombre de la variable, 01:11:45

aquí también podemos estar pidiendo 01:11:47

lo que se llaman parámetros. 01:11:49

Dentro del método se pueden pedir parámetros. 01:11:52

Y en disparo, ¿qué nos puede interesar? 01:11:55

pues por ejemplo 01:11:57

yo que sé, voy a poner cosas un poco abstractas 01:12:00

pero por ejemplo 01:12:03

puedo pedir 01:12:05

el tipo de 01:12:06

de arma, no sé 01:12:08

¿vale? entonces 01:12:10

para que 01:12:13

voy a, dejadme poner el código 01:12:14

luego lo vemos 01:12:19

tipo de arma, vale, cuando creamos 01:12:19

este string estamos diciendo 01:12:23

que cuando llegue a este momento y veis que ahora 01:12:24

da fallo porque hemos 01:12:27

pedido un parámetro, cuando se declara se llaman parámetros y cuando luego nos lo pida 01:12:29

se llamarán argumentos. Si en algún momento leéis, pasa un argumento al método o un 01:12:34

parámetro, que sepáis que se refiere básicamente en dos puntos distintos a lo que hay entre 01:12:40

paréntesis. Pero veis que en cuanto yo ya declaro un tipo de parámetro, ya obligatoriamente, 01:12:44

A no ser que declare otro que esté vacío, ¿vale? Directamente va a dar error si no decimos ese parámetro, que es un poco lo que está pasando aquí con translate si lo vaciamos, ¿vale? 01:12:53

Que cuando está declarado translate, si os fijáis y mirad lo que sale ahí, que es lo mismo también que sale en la documentación de Unity, pone transport.translate y entre paréntesis tiene que pasar una variable o un elemento de vector 3 llamado translation y otro de espacio que se llama relative to. 01:13:05

Y luego más cinco sobrecargas. Si os fijáis en la documentación que lo estábamos viendo antes, y por eso también es muy útil, me meto en Transfer Translate, en el API de Scripting, aquí este método está declarado de dos formas. 01:13:25

tiene dos formas de actuar y bueno y si seguimos bajando de hecho tenemos dos luego hay otra aquí 01:13:41

otras dos más luego hay otra aquí ya llevamos cinco otra aquí seis vale seis y de hecho vais 01:13:49

a ver que cuando yo me pongo aquí pone esa forma de usar el método vale más cinco sobrecargas si 01:13:58

Fijáis, está una más cinco, las seis que tienen. 01:14:06

Porque al programar, al declarar, quien haya hecho el código de MonoBehaviour o de CISAR para Unity, 01:14:09

Translate dijo, va a haber cinco formas de pasar valores, de pasar argumentos a este método 01:14:16

para que luego los ejecute de una forma u otra. 01:14:23

¿Os acordáis cuando en la tarea, sí, es decir, han puesto en el chat, 01:14:25

sobrecargas igual a formas diferentes de ejecutar ese método? 01:14:31

Sí, podría ser. Y en cada uno va a pedir unos argumentos dentro de este paréntesis. ¿Os acordáis el otro día, la tarea de la unidad 1, que ya se ha cerrado y por eso os puedo hablar libremente de ella, que había tres formas de pasar, de rellenar estos paréntesis? 01:14:34

y según de lo que pusiéramos en la instancia se hacía hija del GameObjectPadre 01:14:54

o no se cogía otra referencia. 01:15:01

Eso significa, porque cuando se diseñó ese InstanceAid, 01:15:03

si nos metemos en ObjectInstanceAid, 01:15:09

bueno, había dos más, pero había estas tres primeras, 01:15:12

bueno, eran estas dos primeras y esta cuarta, las que hemos usado. 01:15:15

están declaradas 01:15:19

todas estas variables de distintas 01:15:21

formas, ¿vale? Y todas son válidas 01:15:24

y apelan a un mismo nombre, Instanced 01:15:26

pero dependiendo del tipo de 01:15:28

parámetro que pasemos 01:15:30

¿vale? Y cuántos pasemos 01:15:32

que también es un valor importante 01:15:34

se ejecutará de una forma u otra 01:15:35

y eso es lo que se llaman sobrecargas 01:15:37

este método tiene 01:15:40

a ver, bueno, es que tiene un montón 01:15:42

si os fijáis, fijaos todo lo que tiene 01:15:44

¿vale? Por eso dependiendo 01:15:46

Si lo que pasabais era una variable tipo transform, lo considera como un padre. Si lo que pasáis como segundo parámetro es un vector 3, lo que hace es que no hay ningún padre y por eso no se hacía hijo y lo que va a poner es la posición de que estamos pasando aquí. 01:15:47

¿Sí? Entonces, ¿a qué viene esto, digamos, en el momento en el que estamos explicando cómo se declaran métodos? 01:16:04

Primero, que aquí lo que pongamos obliga a que luego haya que cumplir al llamar ese método. 01:16:14

Porque lo que se puede hacer, y por eso puede haber sobrecargas, yo puedo hacer un disparo sin pedir argumentos en su interior, sin pedir parámetros, ¿vale? 01:16:20

Y ahora no da fallo, porque si yo pongo este disparo en este punto, lo que va a buscar es en este. Y aquí puedo poner, de backlog, sin argumentos, ¿vale? 01:16:30

Ok, y entonces ahora, aunque hay varias posibilidades de llamar a disparo, la que busca al llegar a este momento, dice, a ver, sí, hay dos llamadas a disparo, pero esta es la que se adecua a lo que pone aquí, ¿vale? 01:16:48

Entonces ahora, cuando yo lance el juego, de esta va a pasar, porque aunque estoy llamando disparo dos ocasiones, y de hecho va a salir dos veces el mensaje, va a poner sin argumentos porque es la que estamos llamando realmente. 01:17:01

Le voy a dar 01:17:12

Y que pone dos veces 01:17:13

Bueno, como está en el update 01:17:15

Pues sale dos veces en cada fotograma 01:17:17

Sin argumentos 01:17:19

Si yo por contra 01:17:20

En esta primera lo dejo como está 01:17:21

Que va a poner sin argumentos 01:17:25

Esta me la voy a cargar 01:17:27

Aunque si no pulsamos la D no ocurriría 01:17:27

Esta pondría sin argumentos 01:17:29

Y en esta voy a decir 01:17:32

El disparo voy a poner 01:17:33

Como lo que me está pidiendo es un string 01:17:36

Hay que pasarlo en string 01:17:38

Y voy a poner, no sé, una colt 01:17:39

Creo que es un tipo de arma 01:17:41

Vale, pues va a poner en cada fotograma, va a poner sin argumentos, correspondiente a este, ¿sí? Y luego este disparo va a buscar, ¿vale? Cuando llamas a este método, ¿cuál cuadra con este? Dice, ah, vale, me está pasando un stream, por tanto, y solo un elemento, ¿vale? Y solo un elemento y es este. 01:17:42

Pues entonces voy a poner ahí disparado con, y aquí está la gracia y por lo que sirve esto de meter argumentos entre los paréntesis, que es que aunque el método siempre ejecute lo mismo, en cada momento, en cada llamada podemos llamar, igual que hacíamos con el instant seed, que instant seed en cada momento instanciará un prefab o lo que hayamos puesto, según lo que estemos referenciando aquí, llega a este punto y dice, ¿qué objeto? Instancio. 01:18:02

Y aquí dentro es donde lo instancia. Pero gracias a estos paréntesis se hace el puente entre lo que se está llamando y otro valor, o varios, como hemos visto, separados por coma, que se ejecutan en su interior. 01:18:28

Y la gracia es conectar cuando llamamos, meter un valor del mismo tipo de lo que tengamos aquí. 01:18:41

Y luego dentro de ese método, ese tipo, ese valor que ha entrado, se llamará esa variable, hay que referenciarla con el nombre que habíamos puesto a este parámetro. 01:18:48

Es decir, esto sirve para decir, cada vez que ponemos un argumento, y ya os digo que pueden ser varios, puede ser un string y un flow llamado numerazo, yo que sé, por poner un nombre llamativo. 01:18:58

Ahora da error porque nos faltaría aquí el numerazo. Ahora no hay ninguna variable, ningún método, perdonad, que solo tenga un argumento. 01:19:08

entonces hasta que no pongamos en este caso un número vale pues da error 01:19:16

nuevamente porque no cuadra con ninguno busca y dice no hay ninguno que se llame 01:19:21

disparo y tenga dos argumentos de estos tipos que ojo y por eso es importante el 01:19:25

orden de los métodos si yo pongo 5 y colt aunque en teoría estamos haciendo lo 01:19:31

mismo da error porque tiene que ir en el mismo orden en el que se están 01:19:38

declarando esos parámetros, ¿vale? Entonces, lo bueno es que este mismo método, dependiendo 01:19:42

de lo que pasemos, en este caso, en cada uno de estos dos valores, pues luego el resultado 01:19:50

va a ser distinto, ¿vale? Porque aquí, por ejemplo, va a coger que es colt y más del 01:19:55

calibre y en vez de numerazo voy a llamarlo calibre, ¿vale? Porque me interesa para luego 01:20:05

referenciarlo aquí. He disparado con colt de calibre, y aquí lo que pongo es que me muestre lo que hayamos pasado en el segundo parámetro, 01:20:08

que se llame calibre. Y vais a ver ahora que lo que devuelve cada fotograma va a ser, por un lado, el disparo, que es sin argumentos, 01:20:19

y luego, en cada fotograma también, porque no hay ninguna condición, he disparado con colt de calibre 5, que es lo que se ha pasado aquí. 01:20:27

Si en otro punto, y bueno, si yo por ejemplo aquí digo otro, que es disparo y en vez de col es, no sé, escopeta, no sé, con escopeta y digo que esto diga 10, vais a ver que también va a haber otra línea debajo que va a poner ahí disparado con escopeta de calibre 10. 01:20:33

Entonces vais a ver que eso se está todo el rato ejecutando así 01:20:52

Y veis que de manera interactiva se están adaptando los valores 01:20:59

A ver, me indican en el chat 01:21:04

Así que si hicieras algún cambio de valor, no lo cambias en el método disparo 01:21:09

Sino que lo cambias cuando lo llamas en otra parte del código 01:21:12

¿Me equivoco? 01:21:14

Sí, efectivamente 01:21:15

Tú lo puedes llamar 01:21:16

Claro, todo esto es, pensad, para usarlo a nuestros intereses 01:21:18

Pero si, por ejemplo, tenemos un enemigo que le queremos ir quitando según, pues yo qué sé, tenemos un personaje con una espada y una escopeta, ¿vale? Y el método se llama daña. 01:21:22

Si en un momento le da con la escopeta y ponemos if, le voy a poner el pseudocódigo, eso es lo mismo, habría que hacerlo, ¿no? Pero si le golpea con espada, ¿vale? Y podríamos hacer que, perdonad que lo escribo así rápido y mal, pero si le golpea con espada, el disparo, ¿vale? O daño, que sería el nombre más representativo, hay que intentar que tenga nombre representativo, pero bueno, voy a llamar disparo. 01:21:35

Disparo sería 01:22:05

Espada, vale, y el valor 01:22:07

De daño que quita, vale, la da con la espada 01:22:10

Y el valor que quita de vida es 10 01:22:12

Vale 01:22:14

Si no, yo que sé 01:22:15

Imaginaos que si no, la otra variable es 01:22:17

Si le golpea 01:22:19

O si no, si le golpea 01:22:21

Con 01:22:24

Martillo 01:22:24

Yo que sé 01:22:28

Que hace más daño 01:22:28

Pues aquí 01:22:31

Lo que pondríamos es 01:22:32

Pues disparo y otra vez hay que ser consecuentes. Martillo y este quita más daño, 50. Si luego aquí dentro hacemos que las operaciones le reste lo que pase en calibre, que es el segundo valor, estaremos quitando una vida u otra según el mensaje que estemos dando a este método. 01:22:34

Pensad otra vez en el instant seat 01:22:57

El instant seat es un método 01:23:00

Que luego hará lo que sea con los elementos 01:23:01

Que le vamos dando en sus paréntesis 01:23:03

Que en cada ocasión, en este caso es una nave 01:23:05

Pero podría ser un prefab de una casa 01:23:07

O de los pivotes 01:23:10

Que hay ahora en esta 01:23:12

Tarea que hay que esquivar 01:23:12

Eso es para lo que sirve 01:23:15

Definir que cada vez que llamemos 01:23:17

Al método, según el momento en el que estemos 01:23:19

Con un mismo nombre de método 01:23:22

Podemos pasar un montón de 01:23:24

diferentes datos, elementos, variables, lo que queramos. 01:23:25

Voy a parar un segundo. 01:23:34

¿Me seguís más o menos? 01:23:36

A fin de cuentas, ¿sabes cómo están construidos los métodos que estamos usando? 01:23:40

Solo que los podemos hacer nosotros mismos. 01:23:43

Por ejemplo, voy a hacer otro ejemplo. 01:23:49

Voy a hacer una pequeña calculadora. 01:23:53

¿Vale? Voy a borrar todo esto 01:23:55

Bueno, no 01:23:59

Voy a comentar el update 01:24:01

Porque lo voy a hacer todo en el start 01:24:04

Si me seguís 01:24:05

Digo, o... 01:24:08

A ver, esto por qué no lo... 01:24:09

Me seguís, entiendo que 01:24:16

Solo veo una persona y me da un poco de cosa 01:24:18

Que el resto no me sigáis 01:24:20

Me voy a cargar todo esto 01:24:21

Y voy a hacer 01:24:23

Otro método 01:24:25

Vale 01:24:28

y claro que hablo tanto aquí que sin veros 01:24:28

a veces no sé si estáis poniendo 01:24:32

cara de que me cuenta este tío 01:24:34

o de todo bien 01:24:35

por eso necesito confirmación a veces 01:24:37

vale 01:24:40

bueno he dejado todo muy virgen 01:24:44

está todo comentado 01:24:45

lo único es que como ya lo tengo 01:24:47

ahí aplicado pues 01:24:50

vamos a ello 01:24:51

y esto también me lo voy a cargar 01:24:52

me cargo todo que ya estas partes 01:24:54

yo creo que de momento están explicadas 01:24:57

fuera todo, ya está 01:24:59

me he cansado, perdonad 01:25:02

vale, vamos a hacer una pequeña calculadora 01:25:05

sí 01:25:08

¿ha sido sin querer? 01:25:10

sí, ha sido sin querer 01:25:13

baja la mano y sigo, genial 01:25:14

vale 01:25:17

voy a hacer una pequeña calculadora 01:25:21

y entonces lo que voy a hacer 01:25:22

es declarar 01:25:25

un método llamado 01:25:26

calculadora de momento sin nada de parámetros de argumentos vale entonces al arrancar yo lo 01:25:29

que voy a hacer es decir aquí podría decir bueno pues número una variable un int que sea número 01:25:41

voy a hacer floats mejor, float número A, como antes, y va a ser en este caso 5, y float número B, que va a ser 7, yo que sé, por poner un ejemplo. 01:25:49

Y vamos a hacer que, a diferencia de antes, que lo que hace es un código, es que vamos a hacer otra variable que se llama float resultado, que es igual a número A más número B. 01:26:04

¿Vale? Y según eso, pues, luego nos devuelve de backlog, el resultado es, más resultado, hasta aquí me seguís, ¿qué ocurre? 01:26:23

He creado un método y aquí lo que voy a decir es en el start, vale, pues me haces calculadora, ¿vale? Esto, pues como cuando empieza el juego en el start dice, ah, vale, llamo a calculadora, lo busco. 01:26:44

Aquí podría haber 87 métodos, pero ha buscado el que se llama calculadora y no tiene nada entre sus paréntesis, ¿vale? Porque es el que cuadra, como hemos visto. Entonces vamos a ver que lo que hace es ejecutar esta suma, la devuelve y dará, el resultado es 5 más 7, 12, ¿no? 01:27:00

Bueno, pues le damos y 5 más 7, 12. A ver si quiere. He guardado. Igual. Sí. Vale. El resultado es 12. Ok. Pues aquí estamos aplicando lo que hemos dicho. Llega un momento y en vez de poner todo este código como habíamos hecho hasta ahora dentro de Start, pues lo hemos recogido aquí. 01:27:14

¿Vale? ¿Qué pasa? Que ahora mismo siempre da el mismo resultado, ¿no? Porque como no damos ningún tipo de diferencia, pues ejecuta lo que hay aquí, ¿vale? No hay nada entre los paréntesis, ejecuta esto y ¡chimpún! Listo. 01:27:40

Que no es lo mismo que decir, vale, aquí vamos a decir que esta calculadora tenga, haya que pasarle un parámetro que sea un int número A y otro int que es número B. 01:27:57

Bueno, en vez de A y B, que son los que ya existen, lo voy a poner como C y como D, ¿vale? 01:28:13

Lo primero que va a suceder es que por mucho que, aunque pongamos aquí número C y número D, ¿vale? 01:28:19

Aquí estamos referenciando a número A y número B, ¿vale? 01:28:27

Cuidado cuando llaméis a una variable porque lo que está referenciando es a la que se llama igual. 01:28:30

Aunque esté en su interior, está llamando a esa, si os fijáis, de arriba, ¿vale? 01:28:35

¿Qué pasaría ahora? Da error porque no hay ningún método llamado calculadora que no pida dos argumentos, ¿vale? Pues vamos a decir 7 y separado por coma, que es como se hace esto, otro que se llama 10, ¿vale? 01:28:40

Cuidado, tiene que ser del mismo tipo de variable, ¿vale? 01:28:58

Del mismo variable. 01:29:02

Igual que si yo pongo un 5.5f, como es un float, tampoco lo va a dar por bueno y va a seguir dando fallo, ¿vale? 01:29:03

Si quisiéramos un float, habría que poner aquí que esto sea un float, ¿vale? 01:29:10

Y ahí no da problema. 01:29:13

Vale. 01:29:15

Entonces, 7 y 9. 01:29:16

Vale. 01:29:20

¿Qué va a hacer ahora calculadora? 01:29:20

¿Qué va a devolver? 01:29:22

A ver si alguien se atreve. 01:29:32

No, algo va a devolver. 01:29:34

Porque va a entrar aquí y va a ver esto y lo va a ejecutar. Y hay un debug log que no hay ningún condicional y se va a aplicar. Así que va a poner el resultado es. ¿Y qué resultado? Nadie se aventura. 12. Efectivamente, 12. ¿Por qué? Porque aunque yo aquí le esté pasando valores, os vuelvo a decir que el resultado es 5, los que estaban antes, y 7. 01:29:36

Esto de momento no hemos conseguido nada. Lo conseguimos en el momento en el que llamamos a estos dos valores. A D, por ejemplo, aquí, y aquí a C. ¿Ahora qué valor va a dar esto? 16. Efectivamente. Eso es. 01:30:05

Porque ahora sí que estamos haciendo este puente entre este valor y este, ¿vale? Y una vez dentro ya podemos llamar a estos valores, que si recordamos el encapsulamiento, yo aquí no puedo llamar a número C ni a D, porque solo existen en este ámbito, ¿vale? 01:30:27

A y B, números A y B, como son de ámbito global, van a estar en todo el código. Cuando creamos variables dentro de un método, se restringen a ese método. Recordamos eso, ¿verdad? Igual que resultado. Resultado lo hemos nombrado aquí y si yo intento buscar resultado, pues no existe. 01:30:45

No existe, que no es lo mismo, recordad que esto es muy importante, que si aquí decimos flow a resultado, lo declaramos aquí y aquí ya operamos con él, que en ese caso aquí se está actualizando y aquí pues sí que sale, ¿vale? Recordad los ámbitos globales, locales, etc. 01:31:06

Entonces, ahora mismo efectivamente estamos pasando un 7 y un 9 y el resultado es 16, ¿no? La suma de esos dos. Entonces, bueno, simplemente para ver que esto es así, voy aquí, le eche, ahí, ¿vale? Y va a poner el resultado es 16, ¿vale? 01:31:25

¿Qué es lo bueno de esto? Que yo puedo ir diciendo, voy a hacer luego que en el start, porque me interesa, calculadora, quiero que haga varios cálculos. Calculadora, pues va a hacer 100, 5, calculadora, 20, 2 y así podría hacer muchos. 01:31:47

¿Qué va a suceder ahora? Que al arrancar el juego va a poner tres líneas con los resultados de estas sumas, porque lo hemos configurado así, porque son los argumentos que estamos pasando. Ojo, no número A y B, sino C y D, que son los que hemos referenciado aquí. 01:32:13

Entonces va a salir primero 16, luego 105 y luego 22. Guardo 16, 105 y 22. Y veis que de una forma, con poco esfuerzo, ya tenemos una calculadora. Pongamos lo que pongamos aquí, ya está la operación de sumar. 01:32:29

¿vale? entiendo que con esto 01:32:43

veis que si esto luego se aplica 01:32:46

a vidas o a objetos que se instancian 01:32:48

o a lo que sea, pues 01:32:50

con una sola línea podemos 01:32:51

referenciar a, y este código es muy simple 01:32:54

pero podríamos tener uno súper complejo 01:32:56

en el que luego el número D cambie 01:32:58

metamos el número A y le restamos 01:33:00

el C, que ahí sí que está cogiendo 01:33:02

un valor global de todo el juego 01:33:04

con el que estamos pasando por los 01:33:06

argumentos, ¿vale? y va operando en base a eso 01:33:08

¿vale? 01:33:10

Entiendo que me seguís. Esto es importante, ¿eh? Vale. Voy un paso más allá. Es que son clases de base, por eso me centro en esto. Me ponen una dudilla. Vale, mientras vas escribiéndola, te la voy yo escribiendo. 01:33:12

casi mejor que te la digo por mí 01:33:33

creo que es una duda así que me ha surgido 01:33:36

la clase 01:33:38

esta que es pública 01:33:40

pero no es pública y puedes poner parámetros 01:33:42

que es la que hemos utilizado para 01:33:44

poner algún objeto, para poder poner 01:33:46

algún parámetro, ¿se podría hacer 01:33:48

una calculadora utilizando ese 01:33:50

tipo de clase? en plan 01:33:52

poner dos valores para que se sumen, ese resultado 01:33:53

se multiplica con otro 01:33:56

número, entonces 01:33:58

podrías poner en 01:33:59

En esas cajitas pones 5 y 2, que es lo que se suma, y el resultado que es 7. 01:34:01

Tú no pones 7, sino que pones resultado suma más resultado lo que sea o un valor. 01:34:06

Claro, ahora mismo el problema que hay es que está muy cerrado. 01:34:12

Aquí se pueden ir añadiendo más métodos. 01:34:15

Si yo, por ejemplo, aquí hago... A ver si te contesto con esto. 01:34:18

De todos modos, creo que es lo siguiente que iba a explicar. 01:34:21

Pero si yo pongo aquí número E y yo programo para que el resultado luego sea... 01:34:23

y voy a poner otro float que es resultado tras multiplicar, ¿vale? 01:34:28

Si yo aquí a resultado, luego digo, vale, resultado ya lo tengo aquí, 01:34:38

entonces voy a hacer otro que se llama resultado tras multiplicar, 01:34:43

que va a ser igual a lo que ya teníamos en resultado por el número e, 01:34:46

que es el siguiente valor, ¿vale? 01:34:51

Ahora el problema que va a haber es que necesitamos poner otro argumento, porque este sería 2, por ejemplo. Y aquí 2 también, y aquí 2 para que se vea. Y aquí habría que poner que lo que muestra es resultado tras multiplicar. 01:34:53

aquí lo que hemos conseguido 01:35:13

es que se vayan haciendo más operaciones 01:35:14

¿qué ocurre? 01:35:17

que si alguna no la quieres o la quieres vacía 01:35:19

pues dale este error que hay aquí 01:35:21

sin embargo había una forma 01:35:23

a ver si recuerdo cómo era 01:35:25

para poner un valor 01:35:27

que no es obligatorio poner 01:35:29

esto si no me equivoco era 01:35:31

a ver si me acuerdo 01:35:33

un segundo 01:35:34

¿pero? 01:35:37

¿con Z? 01:35:41

¿el qué? 01:35:42

0 con Z, o sea, para poner valor en 0, sin que necesite poner valor en... 01:35:44

Ah, vale. No, me acabas de dar la respuesta. ¿Te refieres a esto? 01:35:49

Pero no con 0, 0, sino 0 escrito en inglés. 01:35:55

¿Pero dónde? ¿Aquí? 01:35:59

No, en int número E igual 0. 01:36:03

Sí, eso es. Sí, sí, sí. Eso sí. 01:36:08

Con esto lo que hacemos es 01:36:10

Que sea obligatorio pasar un 01:36:13

Es decir, estas dos son obligatorias 01:36:15

Pasarla, pero esta que hay aquí 01:36:18

Si no pasa nada 01:36:19

Lo va a asumir que es un 0 01:36:21

Y no da error, efectivamente, así es 01:36:22

Lo único es que si pones 0 va a dar 0 01:36:25

Lo suyo igual es 1, en este caso 01:36:27

¿Vale? Pero 01:36:29

Sí, exacto, si pones un igual 01:36:30

Y un valor, por defecto, si no se pone 01:36:33

Nada, pues 01:36:35

Toma ese, el valor 01:36:37

Y por eso ahora mismo, 7 más 9, que es lo que tenemos aquí, daría 16. Y por 1, aunque no haya puesto nada, sería 16. Si aquí ya ponemos otro valor y ponemos 2, daría 32. Entonces sí, así se podría hacer. 01:36:39

Y luego dentro de un método puedes meter otro método también, es decir, que uno se ocupe de la suma y otro de la multiplicación. En caso de que haya un if, claro, esto ya lo puedes hacer más complejo, ir metiendo método, porque tú puedes hacer aquí, por ejemplo, un disparo, que tenga lo que sea dentro, y tú luego aquí también puedes llamar a disparo. 01:36:57

Entonces, si se cumple tal cosa, pues disparo ocurre tal, si no, la otra. ¿Entendéis lo que quiero decir? Que se pueden ir intrincando ya muchas operaciones. Sí que es verdad que hay que intentar ir haciéndolo lo más limpio y por fragmentos posible, porque si no esto se convierte en un jaleo grande. 01:37:24

¿Sí? Entonces, por poder se puede. Y efectivamente, si aquí, y esto es lo que si vemos en este caso, vais a ver momentos en el que pone precisamente eso. En estos casos no, pero por ejemplo, uno que me acuerdo ahora mismo, que ahora mismo no sabemos qué es, pero lo que me importa es ver la sintaxis. 01:37:43

Si os fijáis, este método tiene un montón de parámetros, un vector 3 que se llama origin, otro vector 3, direction. Y luego ya a partir de aquí, todos los que hay son opcionales. Los podemos poner o no en este orden. Si no ponemos nada, se entiende que este de aquí será un infinity, el layer más será el que hay por defecto y este usa global. 01:38:08

¿Vale? Pero es justo lo que ha dicho el compañero, no me acordaba. Con este igual se define un valor en caso de que no se especifique ese argumento. ¿Vale? Eso es. Bueno, eso es. ¿Vale? 01:38:29

A lo que iba 01:38:44

Y voy a la siguiente cosa 01:38:46

Perdonad que me estoy enrollando mucho 01:38:47

Pero es que creo que 01:38:51

Os está aclarando esto cosas 01:38:52

O ya más o menos las conocíais 01:38:54

Porque es verdad que esto está en los apuntes 01:38:56

Pero bueno, lo mismo 01:38:59

Está un poco 01:39:00

Sin desarrollar 01:39:01

Yo voy a ir poniendo otra cosita mientras 01:39:03

Si me dejáis algún comentario 01:39:05

Os lo agradeceré 01:39:08

A ver 01:39:10

Vale 01:39:10

Luego, que también lo ponen en los apuntes, no siempre tienen que ser los métodos de tipo void, pueden ser también un tipo de variable, ¿vale? 01:39:19

Si es void, es lo que hemos dicho, va a ejecutar en su interior lo que haya entre estas llaves. 01:39:28

Que hay parámetros y argumentos, los aplican estas llaves como se haya definido. 01:39:32

Pero calculadora, ¿vale? Si yo la llamo, también se puede decir, vale, calculadora, y con esto se restringe también el tipo de resultado que va a dar, 01:39:39

Se puede decir que sea un int, ¿vale? Y hay que poner que es público, ¿vale? Cuando es void no hace falta, pero cuando es privado sí. A ver, un segundillo, ¿por qué no me está dando esto? 01:39:47

calculadora, calculadora, no existe 01:40:08

un segundete, una cosa, perdona, que ahora mismo estoy dudando 01:40:12

de una historia y no quiero explicarla mal, un segundito 01:40:16

que mire una cosa, vale, vale, sí 01:40:20

incalculadora, vale, esto también sale 01:40:32

cuando tenemos un método declarado para que devuelva 01:40:36

un tipo de valor, vale, significa que en este 01:40:40

cuando salgamos de este método, no es que recoja y ejecute lo que hay en su interior, sino que va a dar un resultado concreto, ¿vale? 01:40:43

Y va a valer algo, que va a valer, al final, lo que va a salir al llamar a calculadora en este momento, en este caso va a ser un número entero, ¿vale? 01:40:52

Entonces, la diferencia de sintaxis de esto es que, claro, cuando es un número entero, también hay que declarar algún tipo de argumento, de parámetro. 01:41:00

A ver, ahí, ¿vale? Cuando luego llamamos a esta variable, cuando tenemos una, que es lo que pone, cuando tenemos una que dice que es de un tipo, hay una sutileza que es que tiene que acabar con un return algo, ¿vale? 01:41:18

Tiene que acabar con un valor, por ejemplo, número C en este caso. Si ponemos esto, que es cuando ya no da valor, podemos hacer una calculadora que al final lo que vale no tiene que ser reflejado en otra variable, sino que directamente es el resultado lo que da. 01:41:39

Es decir, si yo pongo aquí un debug log y le digo que me muestre lo que devuelva calculadora con un 5 y un 2, lo que estamos haciendo aquí es que nuevamente estamos conectando esta calculadora, 01:41:54

pero el debug log no está dentro de aquí, está dentro de la operación, es decir, sustituye este método en vez de recoger el código, es un valor en sí mismo. 01:42:14

Entonces igual que podríamos poner aquí 10 o 5, esto está devolviendo un valor, que puede ser un int, un string y de distintos tipos. 01:42:26

Entonces lo que estamos haciendo aquí es, no estamos en ninguna operación, devuélveme número c, que en este caso devolvería 5 y se mostraría 5. 01:42:34

Pero aquí nuevamente podemos ir haciendo diferentes operaciones, guardándolo en variables, etc. Y luego que devuelva, suma. Y aquí lo que está devolviendo es, a ver, ¿qué está dando aquí? 01:42:43

Return. Vale. Y atención, cuando estamos trabajando y tiene que devolver un valor, ¿vale? El valor tiene que ser de ese tipo. Fijaos que suma, yo lo he declarado como un float. Y por eso da error, porque no puede mostrar, si os recordáis al principio, un float es más específico que un int y no lo puede mostrar. Tendría que ser un int, que eso sí que es lo que devuelve. 01:43:00

Entonces, ¿qué devolvería aquí? Nuevamente un 7. Pero no es porque se haya ejecutado el debug log dentro del método, sino porque es que cuando llamo a calculadora, tal y como ha sido declarado aquí, vale un 7. Se sustituye por un 7. No es que esté haciendo otras operaciones, es que el propio método es el resultado de una operación. 01:43:23

Y por eso, para que no dé este error, hay que acabar poniendo un return, que devuelve el valor que tiene que devolver y en lo que se convierte esta variable. 01:43:41

Y ahora si nos fijamos, lo que va a devolver la consola es un 7. 01:43:50

Esto en cierto momento también tiene sentido, porque lo que vamos a hacer, y esto es un poco lo que apuntaba antes el compañero, 01:44:00

podemos querer operaciones que luego se convierten en operaciones. 01:44:07

Entonces, a lo mejor en un cierto momento podemos meter una variable, un método dentro como resultado de otro método. Entonces, incluso pedirlo como un parámetro. Esto ya es más enrevesado, pero por ejemplo, también puede ser, y es lo que tenía preparado aquí, 01:44:10

que podemos ir declarando una variable de tipo booleano, 01:44:32

perdón, una variable no, un método de tipo booleano 01:44:38

que vaya a devolver si algo es verdadero o falso. 01:44:41

A ver, un segundito, que me estoy quedando... 01:44:44

Un segundo, me estoy cayendo de la silla. 01:44:48

Vale, eso. 01:44:55

Veis que aquí tengo un método que devuelve un valor 01:44:56

y por eso es un return. 01:45:01

Por ejemplo, aquí si os fijáis, cuando llame a spar en distintos momentos, spar llama una función con argumento y le pasas un valor que se llama ínteger, que es 7. Si al llamar a esta variable spar le pasamos un 7, que es de tipo numérico, si 7 su resto es igual a 0, devuelvo verdadero. 01:45:02

si no es falso, esto en realidad está al revés 01:45:26

porque debería ser, si no es 0 01:45:29

es falso porque no es par 01:45:31

pero veis que con esto ya se puede ir definiendo 01:45:32

luego si es par y da tal cosa 01:45:35

mi mensaje, la variable es 01:45:37

es par o es igual a 10 01:45:39

por ejemplo aquí, lo que tenemos aquí 01:45:41

voy a copiar esta y lo voy a 01:45:43

pegar aquí 01:45:45

en el otro que teníamos y así lo vamos a ver más claro 01:45:46

tu tu y 01:45:49

tu tu 01:45:51

vale, en start 01:45:52

Spark y lo copio 01:45:55

de aquí, que la tenía 01:45:58

que estaba preparada, fijaos en este ejemplo 01:46:00

vale 01:46:02

y voy a poner 01:46:05

que integer, voy a hacer otra variable 01:46:08

llamada integer, que es como se llama aquí 01:46:10

que en principio vale 01:46:12

5 01:46:14

vale, y bueno, luego hay mi mensaje 01:46:15

que es, bueno, vamos a ver 01:46:18

como unos métodos se intrincan 01:46:20

en otros, viene bien 01:46:22

el mensaje, vale 01:46:23

Vamos a ver así rápido esto. Yo tengo un código que he creado dos métodos o funciones para llamarlos cuando me interese. Entonces tenemos el método 1 que va a devolver si lo que le pasemos como número, porque queremos comprobarlo, es par o no, definiendo como puede ser o sí o no, porque puede ser par o no, lo hacemos con un booleano en este caso. 01:46:25

Y luego, según el resultado, vamos a poner una variable vacía que lo que hace es mostrar un debug log con el mensaje que defina la condicional. 01:46:53

Entonces, si vamos aquí al empezar, hemos definido que ínteger, de hecho lo voy a poner aquí, ínteger igual a, y aquí podemos cambiar al arrancar el juego el valor que queramos. 01:47:04

Ahora mismo, llegamos, ínteger la variable vale 5. Llegamos y dice, vale, ahora ejecuta este método pasando 5. Va a pasar y va a venir aquí y decir, a ver qué devuelve esto, que tiene que devolver un booleano. 01:47:16

Y dice, vale, pasamos un 5 y dice, si ese número que he pasado, que es un 5, al dividirlo entre 2 da igual a 0, el booleano va a devolver true. 01:47:32

Es decir, en este momento pondría true. Esto sería igual, en este caso, lo que devolvería es un true. 01:47:43

Si no, pues devolvería false. 01:47:51

vale, pues ya 01:47:53

espar, que como hemos visto 01:47:55

no es un vacío, sino que se queda como 01:47:57

un valor, que en este caso es true 01:47:59

va a valer ahora para seguir trabajando 01:48:00

si 01:48:03

este espar, vale, este true 01:48:03

es así, vale, si esto es 01:48:06

true, el mensaje que se va a pasar 01:48:09

es my integer 01:48:11

is par, vale, aquí es 01:48:13

lo que he dicho antes, está al revés y esto 01:48:15

debería ser false y esto true 01:48:17

vale, ahora 01:48:18

ahora esto es 01:48:20

false. Ahora sí tiene sentido con respecto a que sea par o no sea par. Si mi íntegra es par, va a entrar aquí y va a decir si este resultado es falso, me meto aquí y digo voy a llamar a otro método que tengo aquí y que sea el mensaje que yo pongo aquí, que luego lo voy a reciclar en cada uno porque este sí que es un vacío que no es que devuelva un valor cerrado, sino lo que yo esté procesando en este y que va a coger el mensaje que 01:48:23

pongamos aquí que es una string para luego devolverlo en este barlog y al 01:48:53

llamarlo pues lo devuelve vale entonces ahora mismo por poner que 01:48:57

este valor es 5 va a demostrar que mi mensaje myInteger es impar vamos a 01:49:02

verlo y yo ahora veo esto y aquí vemos myInteger es par vale porque está 01:49:10

haciendo esto. Si myInteger es par, me vuelvo falso. Y aquí habría que hacer otra vez. 01:49:17

Si esto, bueno, lo voy a poner así verbalizado. Si esto es falso, y ahora sí que va a ir 01:49:26

bien. Si ínteger es igual a falso, es decir, esto es un valor booleano. Si este es igual 01:49:32

que éste va a decir que esto está al revés también es impar y si no que es par entonces 01:49:42

ahora cuando yo vaya aquí pues nuevamente la íntegra es paro bueno estoy todo el rato como 01:49:49

dando vueltas porque si lo que pasamos a ti es igual a cero falso vale si interés falso 01:49:57

Pues debería estar bien 01:50:06

Algo estoy haciendo así, que está al revés 01:50:11

Ah, bueno, claro 01:50:13

Joder, la que se cumple es esa 01:50:15

Y aquí esta 01:50:16

Vale, ahora sí que va a ir bien 01:50:17

Vamos, esto es, eso es 01:50:22

Si yo por en cambio, ahora pongo que esto sea 6 01:50:24

Por poner un valor par 01:50:27

Ahora es cuando yo sí que voy a poder decir 01:50:29

Que algo 01:50:32

Que este valor es par 01:50:33

¿Vale? Entonces, con esta operación 01:50:35

lo que hacemos, por ejemplo, es por un lado definir si esto es verdadero o falso, una booleana, porque aquí estamos llevándolo a esto de que sea algo verdadero o falso en relación a si es par o impar, 01:50:37

pero se podría programar en base a lo que queramos, ¿vale? Y ojo con poner la palabra return cuando no es un void. Y una vez se comprueba ese valor, ¿vale? 01:50:47

que en realidad se podría poner aquí, porque también se llama aquí, si lo que devuelve este método es falso en este caso, 01:50:56

llamo a otro método, en vez de poner el debug log aquí directamente, porque se podrían poner más operaciones, 01:51:04

que conecte con ese mensaje que es el que va a mostrar. 01:51:10

¿Qué tal? Está aquí. Y ya esto lo dejo y vamos a la tarea. 01:51:19

Si más o menos me vais entendiendo, sé que se han revezado, pero si más o menos me vais siguiendo, 01:51:24

funciona así, es pensarlo y darle vueltas 01:51:29

y ya os digo que yo 01:51:32

me equivoco mucho también, pero es ir 01:51:33

viendo las lógicas, todo esto es ir viendo las lógicas 01:51:35

y poco a poco ir analizando 01:51:38

qué estamos haciendo en cada momento 01:51:39

vale, me preguntan, el triple igual 01:51:41

sé para qué sirve, pero no le veo una función 01:51:45

concreta o que sea útil 01:51:47

bueno, pues imagínate 01:51:48

vale, tampoco te voy a poner 01:51:50

un super ejemplo así de primeras, pero bueno 01:51:53

el compañero dice que también puede ser 01:51:55

un triple igual, vale, el triple igual 01:51:57

lo que hace, y mira aquí da error 01:51:59

precisamente por esto seguramente 01:52:01

es que aparte de que 01:52:02

en el comparativo sea igual, tiene que ser 01:52:05

del mismo tipo y como 01:52:07

aquí, a ver 01:52:09

qué mensaje me devuelve esto 01:52:10

mensaje 01:52:12

sí, número 01:52:16

pues debería 01:52:18

funcionar 01:52:21

y por qué no me deja 01:52:22

bueno, yo la verdad es que tampoco 01:52:25

lo uso nunca, pero sirve para decir que 01:52:27

aparte, cuando hay una variable 01:52:29

Por ejemplo, es que esto, claro, sí es numérico, pero aquí ahora... A ver, por ejemplo, si ínteger es igual a resultado, ¿vale? A ver, da error porque resultado es... 01:52:32

Permitid que lo pruebe porque ya te digo que no lo suelo usar 01:53:05

Sí, es que esto no sé por qué no lo está cogiendo 01:53:09

Pero vamos, básicamente es que tampoco lo uso yo nunca 01:53:15

Entonces, lo que quiere decir es que aparte de que sea igual para que el comparativo se dé 01:53:18

Tienen que ser del mismo tipo, es decir, si uno es entero, el otro también tiene que ser entero 01:53:22

Y aquí se está cumpliendo, por eso me extraña que no esté dando 01:53:28

Eso en qué apartado aparecía en los apuntes 01:53:33

digo, porque esto entiendo que lo has visto 01:53:36

que no me acuerdo donde explicaba eso 01:53:39

supongo que en operadores 01:53:41

lo pondré, ah vale 01:53:43

sí, en el 0, 3, 2 01:53:48

bueno, pues no 01:53:50

no da buen resultado 01:53:56

a ver, float 01:53:58

resultado, claro, también porque 01:53:59

esto, a ver, igual 01:54:02

a 5 01:54:04

esto, y aquí voy a poner 01:54:05

Resultado igual a 7 01:54:08

Y esto lo pongo como resultado 01:54:10

Y sigue dando error 01:54:13

Pues no sé si es que han cambiado algo 01:54:16

La sintaxis, pero sí debería ser 01:54:18

Debería ser así 01:54:20

Ah, esto 01:54:23

No, la verdad es que no lo sé 01:54:26

Lo pone y es así 01:54:33

Porque eso es así, pero 01:54:34

a ver, claro, esto igual se usaba para los strings 01:54:36

string, nombre usuario 01:54:42

yo que sé, vale, si 01:54:46

nombre usuario es igual a 01:54:49

bueno, pp, voy a poner, pues ejecuta eso, vale 01:54:56

si yo pongo aquí otro igual, pues no sé, no sé porque 01:55:04

lo investigaré, pero vamos 01:55:08

yo os digo que este no se usa mucho 01:55:11

de hecho en los apuntes viene bastante 01:55:13

su número de cadenas 01:55:14

es igual a otro 01:55:17

no sé 01:55:17

sí que funciona así, pero no estoy 01:55:20

consiguiendo que funcione, entonces bueno 01:55:22

no quiero darle más vueltas a esto 01:55:24

para la siguiente lo 01:55:26

lo vemos otro día, ¿vale? 01:55:27

me lo recordáis 01:55:31

vale 01:55:32

vamos a lo de la tarea 01:55:33

Ahora, básicamente, a ver, y voy a ir pasando rápido por ciertas cosas que si no, si tenéis dudas me decís, ¿vale? 01:55:35

Porque para agilizar, que ya ha pasado bastante rato y no hemos empezado con la tarea. 01:55:48

A ver, esto me está dando error, lo borro. 01:55:55

Joder, me quedo con esa duda porque en realidad sí que debería funcionar bien, pero bueno. 01:56:01

Bueno, no me acuerdo por qué. Vale, volvemos aquí y voy a ir a una escena que yo tenía aquí preparada con la nave. Aquí estamos. Cosas a tener en cuenta. 01:56:05

entiendo que ya todos tenéis claro 01:56:30

pues como se instancia un objeto, aquí no hace falta 01:56:33

que instancieis, la nave puede estar ya desde el principio 01:56:35

en el espacio 01:56:38

aquí preparada, porque 01:56:39

en su momento era yo tan pesado con que 01:56:41

el prefab 01:56:43

estuviera en el 0, 0, 0 01:56:44

porque así al empezar 01:56:48

el juego si está centrado y lo instanciamos 01:56:49

en el centro 01:56:52

si toda rotación 01:56:52

la hacemos en base a su centro 01:56:56

no va a dar problemas 01:56:58

de que a lo mejor pongamos el 01:57:00

el guitmo, el elemento de referencia 01:57:02

en un ala y gire como 01:57:04

desviado un poco, ¿vale? Entonces 01:57:05

cuando hagamos cualquier elemento 01:57:07

no solo este, sino cualquiera 01:57:09

en sí el prefab, ¿vale? A no ser que lo hagamos 01:57:11

a posta, debería tener, igual 01:57:13

que cuando trabajáis en 3D al modelar 01:57:15

etcétera, ponéis el punto de ancla 01:57:18

en donde queréis que gire 01:57:19

pues hay que tenerlo en cuenta también para 01:57:21

que esté en ese punto y el 01:57:23

giro se haga con respecto a donde queráis, ¿no? 01:57:26

Si por ejemplo modeláis una muñeca y 01:57:28

el punto de ancla con el que gira está en el hombro, pues va a girar mal. Estos son 01:57:29

conceptos que entiendo que del módulo animación tenéis claros. Y para simplificar ahora ciertas 01:57:34

acciones, lo suyo es que hagáis esta nave, la situéis, esta nave que recordemos no se 01:57:40

va a mover en profundidad sino hacia arriba, abajo, izquierda, derecha, que la situéis 01:57:45

en el cero en todos los ejes menos en el Y porque va a subir y bajar o en el X, pero 01:57:50

en el Z que esté en el 0, ¿vale? Para que siempre tengamos de referencia un punto claro que, por ejemplo, cuando atraviese los pivotes sepamos siempre en qué punto del horizonte es, ¿vale? 01:57:59

Simplifica mucho usar valores absolutos y si son los de origen del espacio, mejor. Vale, entonces, básicamente, en el material que se os proporciona ya vienen algunos prefabs, ¿vale? 01:58:09

Que algún compañero me ha dicho, ¿se puede cambiar por otra nave o por otro pivote? Sí, siempre y cuando eso, tengáis en cuenta que los puntos de ancla están donde tienen que estar, porque si no va a ser problemático, ¿vale? 01:58:24

¿Qué habrá que hacer? Bueno, aparte hay que crear un suelo que nuevamente los suyos que estén situados en posiciones cercanas al 0, ¿vale? He generado un suelo que es en esencia un plano, ¿vale? Si generamos un plano y lo situamos en el 0, 0, 0, ¿vale? Como tenemos la nave bien ubicada, al resetearla se genera ahí. 01:58:36

¿Qué hacemos después? Pues escalarla todo lo que necesitemos. Este suelo, en y no porque es un plano, sirve más o menos de referencia. Esto no va a servir para nada. Todavía no sabemos usar físicas y ni siquiera un objeto sabemos cómo detiene a otro o colisionan, etc. Eso se ve en el tema 3. 01:58:58

pero al menos nos da una relación de dónde van a salir esos pivotes, etc. 01:59:18

Os explico una cosa muy rápida también para que no sea todo tan blanco y se vea mejor 01:59:24

que es que para dar color, esto ya se verá más adelante en más detalle 01:59:29

pero para darle un color a un elemento, por ejemplo al suelo y que no sea igual que la nave 01:59:33

en este blanco impoluto, en una carpeta lo suyo de materiales o de lo que queráis 01:59:38

con clic derecho podemos crear entre otros elementos un material 01:59:42

un material que en este caso es físico, es para la visualización de un objeto 01:59:46

entonces el material voy a llamar suelo, este es el material 01:59:52

con el que vamos a colorear el suelo, cuando metéis en un material 01:59:55

que salen con este icono que tenemos aquí, estoy ampliando y reduciendo 01:59:59

con este slider o con control y la ruleta, se hacen más 02:00:03

grandes o más pequeños, entre sus parámetros, que hay muchos 02:00:07

ya lo veremos, hay uno que dice el albedo, que esto imagino que os suena también 02:00:11

de el módulo de color el albedo que es el color base digamos antes de ser afectado por reflejos 02:00:15

por metalicidad etcétera podemos cambiarlo de color y decir que sea en este caso lo voy a poner 02:00:22

un gris un gris azulado da igual si es para que se distinga vale veis que esta bola que muestra 02:00:28

el material va cambiando en relaciona lo que indique es aquí pues si se pone rojo pues rojo 02:00:35

Podéis toquetear más cosas 02:00:41

Ya os digo, no es lo que me interesa ahora 02:00:45

Y para aplicar un material 02:00:46

Cuando vais por ejemplo al plane 02:00:48

Que parece avión pero voy a poner el suelo 02:00:50

A este GameObject 02:00:52

Si arrastráis este material al propio GameObject 02:00:53

O visualmente aquí 02:00:57

A la pantalla 02:00:59

Veis que se colorea de ese material 02:01:00

En esencia lo que está haciendo 02:01:03

Es que 02:01:04

Los GameObjects por lo general tienen 02:01:06

Un componente que se llama 02:01:09

es renderer que es lo que renderiza esa malla y que tiene un material que se cambia de esta forma 02:01:11

vale veis que cuando lo pongo coge ese material vale una forma muy rápida ya si queréis tener 02:01:16

cosas un poquito más vistosas para ir coloreando elementos vale así rápido no es lo que me voy a 02:01:22

meter ahora sí pero que no sé si a lo mejor me escribís algo en el chat no vale entonces 02:01:28

Entonces tenemos esta nave. ¿Qué es lo que habrá que hacer ahora con la nave? Pues tenemos aquí este prefab, ya os digo, no lo voy a instanciar, y bueno, yo tengo aquí ya vinculado un script que, bueno, tengo hecho, vamos a empezarlo un poco de cero, pero voy a ir rápido porque, bueno, a ver, durante, durante, pues voy a hacer un script que va a ser el movimiento de la nave. 02:01:34

movimiento nave vale y ya antes como hemos visto en la estructura de de 02:02:01

de cómo se hace un transform no vamos a ir a ello vamos a poner esto escribe en esta nave 02:02:13

que va a definir la nave y nos metemos vamos allá movimiento nave aquí está voy a ir rápido 02:02:18

vale porque también quiero que le deis vuelta pues luego vosotros con esto que hemos visto 02:02:25

visto y con lo del tema os digo una forma rápida para hacer la rotación y con esto a ver si vais 02:02:29

desenvolviendo la tarea durante las navidades etcétera a la vuelta de navidades también si 02:02:36

me preguntáis cosas concretas en el foro lo vemos vale pero más o menos yo creo que se va a ir en 02:02:40

caminando con las lógicas que vamos viendo aquí si yo tengo esta nave lo que quiero es que en todo 02:02:45

momento se vayan captando e interacciones que vayan definiendo que esta nave vaya para arriba 02:02:52

o para abajo. Las interacciones, igual que se hace con cualquier variable, se pueden 02:02:58

ir guardando como vectores o como posiciones que tienen valores. ¿Qué es lo que vamos 02:03:07

a hacer en este caso? Vamos a digregar por un lado los movimientos horizontales y por 02:03:15

otro lado los movimientos verticales, porque vamos a tener dos ejes de interacción. Hay 02:03:20

otro tipo de input que son el graxis que sirve esto no lo explica y debería que 02:03:27

sirve para estar en el tema para en vez de sólo dar un valor que va de 0 a 1 o 02:03:32

de 0 a activos vale como una booleana que tenga dos ejes contrapuestos pues 02:03:38

por ejemplo como en una cruceta o en un joystick que tienes una posición hacia 02:03:44

arriba y otra hacia abajo y son contrapuestas vale lo cual nos puede ser 02:03:48

muy útil para hacer las posibilidades de movimientos contradictorios o contrarios, ¿no? 02:03:52

Voy a volver un momento a la escena anterior, ¿vale? Porque teníamos este cubo con cálculos 02:04:01

durante, que no sé si me cargué, a ver, espera, lo abro, si me cargué lo de la D, creo que sí, 02:04:10

pero lo tenía por aquí, si no, a ver, tenía otro, es que esto también es importante, porque si no además os ponéis a escribir un montón de código que no es necesario, vale, voy a cálculo durante, a este código que teníamos, aplicado a ese cubo, aquí está, vale, bueno, borro todo lo que había a esto de los cálculos, etcétera, porque nos da un poco igual para este propósito, ahí está y fuera, 02:04:15

Vale, y vuelvo a hacer un update. Vale, y antes hemos visto qué pasaba si le damos a la tecla D, ¿no? Y bueno, me falta aquí una variable tipo speed, pues speed, por ejemplo, y es 100. Vale, ahí está, ya no da error. 02:04:52

Antes hemos dicho que si pulsábamos la D, este vector 3 en horizontal, ¿no?, que es el eje X, pues a medida que mantengamos pulsado con este get key la D, se irá moviendo hacia la derecha, ¿vale? 02:05:09

Inciso rápido. Perdona que haya tantos incisos, pero es que hay tantas cosas. En los apuntes va a poner que hay maneras simplificadas de hablar de estos vectores 3 normalizados. 02:05:22

Es decir, que solo tenga un valor de 1 en alguno de los ejes, o de 0 incluso en los 3 ejes. Porque en muchas ocasiones, en vez de crear un nuevo vector, podemos decir... 02:05:33

Y esto está en los apuntes, por eso no me voy a meter mucho, pero es muy útil para marcar direcciones. A ver, vector3.write, que si lo veis, esto también está en los apuntes, es un atajo para escribir vector3, 1, 0, 0, porque el 1, el positivo en horizontal, es hacia la derecha. 02:05:43

Si aquí ponemos left, va a ser menos uno cero cero, ¿vale? Si os fijáis, el write previo es exactamente igual que lo que habíamos escrito aquí, ¿vale? Entonces esto, simplemente también para no hacernos lío, también se puede escribir como un vector tres punto write y da el mismo resultado. 02:06:03

Si probáramos, este cubo se movería hacia la derecha. Lo que queremos conseguir ahora es, usando otro de los métodos que venían aquí en el apartado 2.5.1, usar este que se llama el GetAxis, que es muy conveniente para direcciones. 02:06:24

Es decir, cuando tenemos cualquier movimiento de un personaje, normalmente, siempre que va hacia un lado, también podemos tener la posibilidad de ir hacia el otro. 02:06:46

¿Esto qué tal? ¿Lo habéis visto la utilidad? Esto, por ejemplo, en el vídeo de Álvaro lo explica. 02:06:55

Entonces, no sé si rápido o no, pero es fundamental que entendamos cómo funcionan los getAxis. 02:07:00

Lo explico rápido, porque entiendo que algunos sí, a lo mejor otros no lo han visto. 02:07:09

Cuando ponemos un getAxis, lo que hacemos es, lo primero ya no sería un getKey, sino un getAxis, que es otro que tenemos aquí, y entre sus paréntesis, su método, y este sí que pide cosas, nos ponemos encima y nos pide un string, que sea el nombre del axis, podemos decir un eje. 02:07:12

Y el otro día, si no me equivoco, un compañero lo apuntó. Existen distintos tipos de ejes. También cuando salga un error, si le dais a esta llavecita, os puede dar una solución, pero esta no es la solución. 02:07:32

Ahora vemos por qué pasa eso. Pero el axis lo que hace referencia es, también vienen los apuntes, si os metéis en Edit, Project Settings, os abre este menú, los axes son los ejes que tiene configurado el juego, el proyecto ya para funcionar. 02:08:02

Y si os fijáis y os metéis en el input manager, ¿vale? Vais a ver que ya viene un número definido de axis, ¿no? Con sus nombres. Estos nombres, ¿vale? En este caso hay 19 axes, 19 ejes listos para ser utilizados. 02:08:28

Por ejemplo, tenemos este llamado horizontal, que si lo desplegamos, y este es el nombre que hay que meter como un string, por eso no me está funcionando, no sé por qué, ahora lo miramos, tiene ya configuradas cuáles son las teclas, que en este caso son la tecla A y la tecla D, que son los opuestos del eje. 02:08:43

¿Vale? El negativo será el menos 1, el positivo será el d, y si no lo pulsamos, el positivo será el d, que valdrá 1, ¿vale? Y hay un rango intermedio entre el menos 1 y el 1. ¿Sí? Esto el otro día más o menos lo apunté. 02:09:03

Aquí debería de permitir coger el axis, input getaxis, a ver qué está pasando, ah bueno, claro, sí, perdón, cuando estamos haciendo, y vuelvo para atrás, cuando estamos poniendo una tecla, ¿vale? 02:09:19

Un key down, un key, ¿vale? Al final esos valores devuelven un booleano de pulsado o no pulsado, ¿vale? Es un booleano. Este if al final lo que está pidiendo es un booleano. 02:09:42

Aquí es donde tenemos que ir creando también variables que lo que hagan sea recoger el movimiento, por ejemplo, movimiento horizontal. 02:09:53

Y lo dejamos ahí como variable global y otro que sea movimiento vertical. 02:10:06

os acabo de decir que es un eje 02:10:13

lo que vamos a llamar ahora 02:10:16

es un eje que va a ir 02:10:18

entre el menos uno y el uno 02:10:20

pasando por los distintos valores 02:10:21

si tenemos aquí 02:10:24

la a, la d, lo que os he dicho 02:10:26

el que sale como negativo 02:10:28

es el menos uno y el positivo 02:10:30

el uno, si nos 02:10:32

fijamos, aquí lo que vamos 02:10:34

a hacer en el update y por eso os he dicho antes 02:10:36

que era bueno el update para captar 02:10:38

interacciones, es que vamos a guardar 02:10:40

en una variable de tipo numérico, un float que cogerá los decimales 02:10:42

entre el menos uno y el uno para tener los valores intermedios. 02:10:46

Si por ejemplo estamos usando un joystick, pues no es pulsar una tecla A o D 02:10:50

que siempre es un número entero, porque está dando esa señal, 02:10:56

sino que puede haber valores intermedios a medida que movemos el joystick, 02:10:59

en este caso representados como decimales. 02:11:03

Si ponemos aquí que, por ejemplo, moveHorizontal recoja lo que estemos marcando con este getAxis, y ahora sí que no va a dar error, llamado horizontal, lo que vamos a hacer, y aquí no es un condicional, 02:11:05

sino que el condicional, digamos, que va a funcionar el propio código, lo que vamos a conseguir aquí, si multiplicamos por este moveHorizontal, lo escribo y ahora lo analizamos, 02:11:25

¿Vale? Es, y ojo a la jugada, tenemos una variable que funciona en todo el código porque es global para los valores horizontales, ¿vale? Que va a ir guardando en cada fotograma según lo pulsemos en qué punto de este eje estamos interactuando, ¿vale? 02:11:41

Si estamos pulsando, en este caso, la A o la D, ¿vale? Que son los que están configurados, ¿vale? Entonces, aquí, si pulsamos la D, se estará guardando un 1. Si pulsamos la A, se estará guardando en move horizontal un menos 1. 02:11:59

Si no pulsamos nada, esto vale 0. ¿Y esto para qué sirve? Este código lo va a tener el cubo. Entonces, según pulsemos estas teclas del eje, las A o la D, se va a ir trasladando mediante este valor, que se está guardando aquí, a la multiplicación de este vector que está vinculado al horizontal. 02:12:14

Tened en cuenta, y vuelvo a poner la versión no simplificada, que aquí todo lo que se multiplique por 0 es 0, es ausencia de movimiento. 02:12:39

Cuando ponemos un vector 3 que solo se va a ver afectado en una de sus posiciones, que al poner el 1 todo lo que vayamos multiplicando es susceptible de cambiar de valor, 02:12:51

no como con cero, porque todo lo que se multiplica por cero es igual a cero, aquí estamos siempre controlando una variación de movimiento en el eje X, en el horizontal. 02:13:04

Luego hay un time delta time que siempre va a estar devolviendo resultados en cuanto se reproduce, como hemos visto, y un speed que, a no ser que nosotros configuremos en cero, 02:13:14

cosa que no deberíamos hacer, va a valer 100. Entonces, el único elemento en este caso que va a ir aportando más o menos movimiento 02:13:24

es este axis que estamos captando aquí. Entonces, si no tocamos nada en el eje habrá un 0, si ponemos un 1 será un 1 y se moverá hacia la derecha, 02:13:32

Si es un menos uno, valdrá un menos uno. Por eso los axis son tan interesantes, porque al jugar, digamos, si yo pulso solo con esa línea, la tecla D va hacia la derecha, si pulso la A va hacia la izquierda. 02:13:43

Entonces ahí podemos ir teniendo en un axis este movimiento. Esto ya se podría poner directamente en la nave. Y de hecho lo vamos a hacer ahora mismo. 02:14:00

Veo una duda por ahí, pero dame un segundo que voy a volcar esto en la que estábamos haciendo de la nave. Si yo al código que estoy haciendo en la nave ya le digo exactamente esto, y tengo movimiento nave aquí, a ver, ¿dónde lo tengo? 02:14:11

que aquí tengo muchas pestañas, movimiento nave, aquí estaría, vale, voy a copiar estos mismos valores, vale, un segundo, voy a copiar estos mismos valores 02:14:30

que tengo aquí y los voy a volcar, espera que voy a también poner esto aquí, vale, vale, como variable global estos, vale, vuelco un poco lo que tenía, 02:14:43

no estoy haciendo otra cosa 02:14:56

en el update, vale, y este de cálculo 02:14:57

durante yo lo puedo cerrar y este lo guardo 02:15:01

vale, es lo mismo 02:15:03

se lo estoy aplicando a la nave 02:15:05

¿no? entonces el movimiento horizontal 02:15:07

de la nave, si voy aquí 02:15:09

y le doy a play 02:15:11

pues si le doy a la A 02:15:12

a la D va a la derecha y si le doy a la A 02:15:15

va a la izquierda, vale 02:15:17

ahora mismo se está moviendo 02:15:19

bueno, claro, es que estoy 02:15:20

en una escena que 02:15:22

ya tiene muchas cosas configuradas 02:15:25

Voy a quitar el follow. Por defecto, y esto es una práctica buena, cuando empecéis a trabajar la cámara va a quedarse quieta porque nada está diciendo que siga a la nave. 02:15:27

Vale, entonces, de momento, bueno, es otra de las cosas que se os pide en la tarea, de momento, alejadla todo lo posible para ir viendo los movimientos o abrir la ventana de escena que podemos navegar aquí para ir viendo estas interacciones, ¿vale? Porque la cámara se va a ir viendo según ubiquemos la cámara. 02:15:40

Si está en un punto que no están viendo al objeto, pues no se ve. Ahora mismo el código que hemos cambiado, que no hay otro previo, es el de la nave y ya podemos ir izquierda a derecha. De esta forma, de una forma más o menos rápida, lo que podemos hacer es ir a los Project Settings y buscar. 02:16:00

Tenemos algún valor, si vamos abriendo cada uno de estos, que sirva para subir y bajar la nave. 02:16:24

Y aquí tenemos uno que, tanto las teclas W y S, como las de arriba y abajo de la cruceta, ya vendrá configurada como vertical. 02:16:30

Vamos a usar ese axis. 02:16:38

Que, ojo, nosotros podemos ir cambiando los axis e ir creando más si añadimos aquí más números. 02:16:39

Pero vamos a aprovechar esto que se llama vertical para hacer lo mismo con el movimiento vertical. 02:16:44

Entonces vamos a decir que la variable, una variable distinta a otro float, lo que va a captar es, y lo copio para ir más rápido, el axis, pero en vez de D horizontal, el que se llama el axis vertical. 02:16:49

Y ojo que tiene que llamarse exactamente igual, con mayúsculas incluidas, que los que tengamos aquí. Si yo este lo cambio por ejemplo a V minúscula, aparentemente está funcionando, pero no funciona. 02:17:03

¿Vale? Entonces, a ver, un segundito, que tengo aquí molestándome una ventana. Vale, entonces, lo que vamos a hacer es, bueno, pues el movimiento horizontal ya lo teníamos y aquí vamos a hacer otro movimiento vertical, ¿vale? 02:17:19

La diferencia es que va a ir controlando el movimiento vertical, que es el eje Y, por tanto ponemos aquí el 1, porque vamos a afectar al movimiento vertical, y va a ir trasladando, lo voy a poner bien porque si no va a dar error, lo que yo vaya interactuando en este eje entre WS o la cruz de arriba o de abajo de la cruceta. 02:17:35

Entonces, este número que estamos recogiendo está aquí, como move vertical. Entonces, ahora por separado vamos a tener un movimiento que se va a ocupar de lo horizontal y otro movimiento que se va a ocupar de lo vertical. 02:17:58

Si vamos aquí a esto, y el instanciador lo voy a desbloquear para no ver cosas que no hemos hecho, 02:18:14

yo ya puedo subir y bajar la nave y ir a la derecha e izquierda con estas teclas que tenemos. 02:18:24

Sin ningún tipo de límite, puedo atravesar el suelo, etc., porque no hay nada que lo impida. 02:18:29

Entonces, con esto podemos ir viendo esto. 02:18:37

Es mucho más rápido y por eso os decía antes, poner un vector 3 right cuando vayamos a hacer instrucciones horizontales y otra cuando sean instrucciones, un vector 3 up, que es la forma simplificada de poner el eje vertical para hacer esta subida y bajada. 02:18:40

¿Vale? Como tampoco tengo ya mucho tiempo de tutoría y la compañera parecía que esto sí lo había hecho y habrá otra tutoría antes de la entrega de esta tarea, ¿vale? Me podéis preguntar en el foro. Voy a decir el método más rápido para hacer... Es que quería explicar lo que he explicado y lo quería dejar ya explicado porque así nos quitamos dudas futuras. 02:19:04

Voy a hablar de cómo hacer la rotación 02:19:27

La forma más simple que hay 02:19:31

Vamos a ello 02:19:33

Para hacer esto 02:19:34

La lógica que voy a seguir 02:19:37

Es un poco la misma 02:19:39

Voy a hacer otra variable 02:19:40

Otro float 02:19:44

Que voy a llamar, yo que sé, rotate data 02:19:45

Que preparo aquí 02:19:48

Y luego en el update 02:19:52

Voy a hacer otro axis 02:19:54

Que sirva para indicar que el menos uno 02:19:56

vaya a la izquierda la rotación y a la derecha la rotación con la E, por ejemplo, o con otra tecla, ¿vale? 02:19:57

Entonces, lo que voy a hacer es guardar nuevamente en el update, a medida que se van haciendo las actualizaciones, 02:20:06

pues un input getAxis, que en este caso no va a venir creado, ¿vale? 02:20:12

No va a haber uno que defina nuestras interacciones como queremos. 02:20:18

Vamos a crear un axis nuevo, ¿vale? Un axis que vamos a llamar rotador, ¿vale? Para crear un axis, pues como hemos dicho, vamos al Project Settings y en Input Manager no tenemos ninguno llamado rotador, ¿vale? 02:20:23

Y voy a poner uno más, 20, que lo que hace es generar uno nuevo. Y este, en realidad ya tenía uno medio creado antes, que lo voy a eliminar. Con clic derecho podéis también ir duplicando el eje en el que estéis. 02:20:42

Puedes copiar sus parámetros, lo podéis duplicar para tener un mismo nombre que si os fijáis puede haber, esto lo dije el otro día, varios axis llamados igual con distintas entradas. 02:20:57

Esta, por ejemplo, se refiere a recoge, si no me equivoco, por ejemplo, aquí es que está borrado, pero recoge valores de un joystick y aparte también recoge valores de unas teclas que hayamos configurado. 02:21:08

Si yo hago aquí uno que se llama rotador, ¿vale? Recordad que se tiene que llamar igual, lo que voy a decir es que, y esto por defecto viene así, ¿vale? Para que sea como cuando creáis un nuevo eje, voy a poner que left y right son las teclas de izquierda y derecha, ¿vale? 02:21:23

Pero voy a decir, no, la rotación, en vez de hacerlo con las teclas izquierda y derecha, que las puedo dejar incluso en horizontal. Aquí he puesto A y D, pero incluso puedo decir que esto sea izquierda y derecha y tener varios métodos de mover la nave en horizontal. Estos son los métodos alternativos porque se pueden hacer dos por cada axis. 02:21:39

Ahora mismo es equivalente a pulsar la A, que es la tecla izquierda, o right, que es la tecla derecha. ¿Qué voy a hacer aquí? Que voy a decir que rotador, pues por ejemplo, el valor negativo sea la U, la tecla U, y el valor positivo la tecla I, ¿vale? De nuestro teclado. 02:22:03

Entonces, ahora mismo lo que está recogiendo este código aquí es que el valor rotateData valdrá menos 1 si damos a la tecla U y valor 1, menos 1 si es la U y 1 si es la Y. 02:22:20

Perdonad si a veces digo cosas que tengo la cabeza un poco frita de tanto hablar. 02:22:37

Entonces, el problema que os habréis encontrado es que, claro, igual que aquí usamos el transform translate, 02:22:43

había otro método que se llama transform rotate. 02:22:51

Lo tengo aquí. 02:22:56

Igual que el transform translate, si nos ponemos encima, da error porque pide argumentos. 02:22:58

Entonces, ¿cómo se puede hacer una forma rápida de que gire una nave hasta la izquierda y la derecha? 02:23:08

Que entiendo que si yo dejo esto aquí y digo vector 3, voy a hacer lo equivalente a lo que acabamos de hacer con el translate. Pongo vector 3 y en este caso el eje de rotación es el del horizonte. Por tanto, es forward. Se gira en relación al eje que está mirando. 02:23:20

Entonces, si queremos que gire hacia derecha o izquierda, el eje es el que va en profundidad. 02:23:41

Esto también lo ponen los apuntes, entiendo. 02:23:46

Y lo que vamos a hacer es un poco la misma lógica, que se multiplique por el valor que estemos dando a rotate data. 02:23:49

Y también debería estar por un time delta time, para que sea estable, como hemos hablado, 02:23:57

y por una velocidad que lo suyo sería que fuera diferente a la de... 02:24:02

De hecho, la voy a hacer aquí. Float Speed, pero de rotación. Y le voy a poner que esta sea... Yo qué sé. Esto es ir probando e ir ajustando. 50, ¿vale? Ahora mismo, si vamos al juego, ¿vale? Guardo. 02:24:06

teóricamente, cuando yo dé a las teclas U e I 02:24:23

igual que muevo arriba y abajo con las que ya había definido 02:24:27

con U y con I 02:24:30

veis que va rotando 02:24:33

entonces con eso ya 02:24:35

yo puedo estar con las teclas que he definido antes 02:24:38

moviendo la nave hacia arriba y hacia abajo 02:24:41

y con la rotación vamos rotando 02:24:44

hasta aquí una forma 02:24:47

esto ahora tiene dos peros que os digo ahora mismo 02:24:49

¿hasta aquí me seguís? 02:24:52

Más o menos. La tarea se entrega el miércoles que viene. ¿Esta tarea está para el miércoles que viene? A ver. Porque si no, la retraso. No pasa nada. A ver. Fecha máxima para el 18 de diciembre. Sí, efectivamente. La voy a retrasar, ¿vale? A después de Navidades. ¿Vale? Porque sí que es verdad que depende un poco del ritmo. El año pasado la recogí en enero, así que no pasa nada. 02:24:53

pero bueno, os comento 02:25:24

como hacerlo, si lo que me importa es que sepáis 02:25:28

hacerlo, pero la traslado 02:25:30

a... 02:25:32

voy a abrir aquí un calendario 02:25:33

luego la cambio, pues si volvemos de navidad 02:25:34

es como el 02:25:38

8 de enero 02:25:39

la voy a poner para la semana 02:25:42

siguiente, vale, el problema 02:25:43

de esto es que se va, a ver 02:25:45

un segundo, cuando tengo yo prevista 02:25:47

una cosa, perdón 02:25:49

vale, retrasaré también un poco la siguiente 02:25:51

Vale, ok. La retraso ya después de enero, no hay problema. Vale, pero bueno, me vais siguiendo esto de la rotación, ¿no? Vale, el problema que podéis tener es que, claro, cuando luego subís y bajáis, lo hace en relación a dónde está mirando la rotación. 02:25:56

Yo ahora mismo le doy a la flecha arriba y en vez de ir hacia arriba en el mundo, lo hace hacia arriba de la nave, está cogiendo la dirección de la nave. Para eso, que también lo ponen en el enunciado de la tarea, los translates y el rotate también, si os metéis en el script y vemos, por ejemplo, transform translate, si vamos a este, vais a ver que aparte del vector 3 de la traslación, que es el que estamos teniendo, 02:26:18

hay otro de tipo space, ¿vale? Que por defecto, como hemos dicho, está sobre sí mismo, ¿vale? Pero hay otra versión que es space con respecto al mundo. 02:26:51

¿Qué cambia eso? Que en este caso es fundamental para que sea más sencillo. Que nosotros aquí estamos todo el rato operando para tener el primer argumento parámetro 02:27:04

pero que es el del vector 3, pero luego con coma, después, separado por coma, podemos decir que el space sea igual a, y hay dos opciones, a sí mismo o al mundo. 02:27:13

Por defecto, si no ponemos nada, ponía que es a sí mismo. Por tanto, si la nave ya está rotada, cuando le damos hacia arriba, rota hacia donde ya está rotada. 02:27:27

Pero si ponemos que esto lo haga con respecto al mundo, tanto el movimiento vertical como el horizontal, perdón, como el vertical, si lo hace con respecto al mundo, vamos a ver que eso se corrige. 02:27:36

Ahora mismo estamos aquí, muevo, con la U giro y esto está invertido. 02:27:56

Cuando doy a la U está yendo hacia la izquierda y a la I a la derecha. 02:28:02

Entonces yo ahora cuando le doy arriba, sí que lo hace, veis que lo hace con respecto al mundo. 02:28:07

Da igual hacia dónde esté mirando la nave. 02:28:13

¿Vale? Entonces, con esto ya resolvemos ese problema de tener distinta orientación, ¿vale? Que también nos puede interesar llegar al punto que la subida y bajada sea en relación a donde esté mirando la nave, ¿sí? 02:28:15

la compañera que al principio 02:28:33

esto le vamos a dar más vueltas en el futuro 02:28:35

¿vale? de momento 02:28:38

para la entrega, bueno 02:28:40

lo que son la distanciación de los pivotes 02:28:42

y el movimiento continuo y el destroy 02:28:44

quienes lo hayáis intentado 02:28:45

lo tenéis claro 02:28:48

ya os digo, vais a tener navidades 02:28:49

también para hacer esta tarea, que lo voy a alargar 02:28:52

pensaba que estaba para enero, de todo modo 02:28:53

vale 02:28:56

pues vamos a hacer esa cosa 02:29:04

lo vamos a dejar por aquí 02:29:06

Pero lo de la rotación con esto te vale. Es verdad que me gustaría, pero no va a ser esencial para el apto o no apto, que no solo la rotación fuera libremente así como tenemos para que sea todo el giro, sino que a los 90 grados se restrinja. 02:29:08

Pero eso tiene varios peros. Pero de momento podéis ir gestionándolo así. Lo de los pivotes, etc. Intentadlo. Hay pistas en el enunciado, se habla del destroy. Es poner una condicional de cuando se sobrepase una cierta distancia al moverse el pivote hacia cámara, que se destruya ese objeto. 02:29:25

Lo tendréis que poner en el script del propio objeto 02:29:46

Creo que más o menos está elaborado en la tarea 02:29:49

Lo voy a dejar aquí a menos que me digáis algo concreto que queráis ver 02:29:54

Porque también, a ver, hacer un nuevo input para la rotación 02:29:59

Claro, voy a ello 02:30:04

Lo que hemos hecho aquí, lo que he hecho 02:30:06

A ver, esperad, que lo tengo acá 02:30:09

y aquí ya que estamos 02:30:13

por si lo estáis viendo 02:30:17

vamos a darle una rotación propia 02:30:18

a una velocidad propia 02:30:19

de la rotación 02:30:23

básicamente es hacer un eje 02:30:23

que se va a ocupar 02:30:26

de recoger en una variable de tipo float 02:30:28

el menos uno o el uno 02:30:31

que capture con 02:30:33

los inputs horizontales 02:30:34

es decir, con la A o con la B 02:30:37

en este caso 02:30:39

porque es lo que está configurado en el input manager 02:30:40

Se puede cambiar. Luego, otra variable distinta que se llama moveVertical y va a coger el 1 y el menos 1 de la W y la S, las teclas de subir y bajar normalmente. 02:30:43

Y luego va a haber otra, que es este eje que hemos creado nosotros, que hemos customizado, que es el rotateData o se podría llamar moveRotation, no sé, 02:30:54

que lo que va a coger es el menos 1 o el 1, en este caso de la U y la I, porque son las teclas que he hecho. 02:31:06

Luego, igual que hemos hecho que haya un vector normalizado, un 1, 0, 0 en el eje que queramos mover, 02:31:11

que es el que se multiplica por este input, que si no tocamos nada es 0. 02:31:19

Por eso si no tocamos nada, esto no actúa nada. 02:31:23

Hasta que no varíe alguno de estos valores que siempre están multiplicando, no va a haber una interacción. 02:31:26

Luego todos, como están en el update y son movimientos para que sean estables, 02:31:33

se multiplican por el time delta time y se multiplica también por una velocidad 02:31:36

que lo que hace es aumentar el detrimento, la reducción que se ha tenido por estos valores 02:31:40

que antes hemos visto que eran decimales, que genera el time delta time, ¿vale? 02:31:46

Y por último, si es necesario, hay otro parámetro dentro del translate y en el rotate también, 02:31:51

que es que los movimientos se hagan en base a sí mismo, en cuyo caso aquí pondría space.self, 02:31:59

¿Vale? O con respecto al mundo, que es lo que nos interesa aquí para que no considere la rotación que está teniendo el objeto cuando lo vamos rotando, que es que lo hago en torno al mundo. 02:32:06

¿Vale? Y la rotación es lo mismo. Lo hace con respecto al eje de profundidad, ¿vale? Y nuevamente esto es lo mismo que escribir vector 3, 0, 0, 1, ¿vale? 02:32:16

Porque en este caso el eje sobre el que gira es el de profundidad, ¿vale? 02:32:29

Y lo multiplica por el valor que está recogiendo en este float de rotador, ¿vale? 02:32:33

Igual lo equilibramos y le damos una velocidad mayor, 02:32:38

que para que no sea exactamente la del movimiento, pues he hecho otra variable con otro valor. 02:32:42

Pero vamos, podría ser también la del movimiento. 02:32:46

Eso es por tener, digamos, un poco desgregadas las opciones, ¿vale? 02:32:48

Esta se puede hacer de muchas formas y luego lo mismo, lo suyo probablemente sería de las dates que se vayan cogiendo los inputs y para hacer los límites hacer voids en plan movimiento nave, ¿vale? 02:32:54

y yo aquí meto todo lo que sea del movimiento nave. 02:33:16

Por ejemplo, estas líneas las meto aquí. 02:33:20

Y aquí en todo momento está mirando, está buscando movimiento nave. 02:33:23

A ver, ¿por qué no me lo coge? 02:33:28

¿Por qué? 02:33:33

¿Qué he llamado yo movimiento nave? 02:33:39

Bueno, movimiento nave, sí. 02:33:41

Ah, vale, sí. 02:33:48

Pero nada, bueno, esto veis que conflicto, como se llama igual el método que he creado que la clase, que es su padre, no se puede, ¿vale? Pues la voy a llamar moverNave, fijaos porque está dando ese error, ¿vale? MoverNave, ¿vale? Ahí sí está. 02:33:49

Y luego otro que sea RotarNave, que esto es lo de siempre. Luego dentro de estas llaves podemos irlo complicando. Esto es un void y aquí meto esto y aquí hay un RotarNave. 02:34:05

Aquí, si os fijáis, estoy usando esa forma de emplear los métodos para recopilar código, ¿vale? Entonces, bueno, con esto, simplemente para que veáis que acabamos con algo que funciona, ya tendríamos el movimiento de la nave, ¿vale? Y si doy a la I y a la U, ahora va más lento porque he cambiado la speed rotation, que la he hecho a la mitad, ¿vale? Con la I y la U, pues voy haciendo que rote, ¿vale? 02:34:30

Entonces, más o menos, el movimiento estaría. 02:35:00

Luego, lo que habrá que hacer es que estos movimientos solo se ejecuten cuando no se traspasen ciertas coordenadas. 02:35:04

En plan, si la altura es mayor de donde está la nave, si es mayor que 10 en i, 02:35:14

pues entonces que este movimiento deje de producirse. 02:35:23

Y con eso podemos ir definiendo también límites. 02:35:28

Pero bueno, eso os dejo probarlo a vosotros. De momento, para ir ya realizando el movimiento de la nave, etc. Ah, vale, me habíais escrito. ¿Cómo has creado el Input Get Axis que has llamado rotador? 02:35:30

Vale, lo llamas rotador, como se puede llamar de cualquier forma, y es en Edit, Project Settings, y hay un apartado de Input Manager, ¿vale? 02:35:45

Donde están los axis, los diferentes. Pues tú aquí, para crear uno nuevo, si el número que tengas le sumas otro. 02:35:53

Lo que va a hacer es añadir otro axis llamado como el último que haya, ¿vale? 02:36:01

Ahí, perdona. Vale, me ha creado uno. Con esto es el número que hay. Ahora se va a quitar cuando ponga 19. 02:36:06

Si ya tienes alguno en el que quieres basarte, al darle clic derecho se puede duplicar ese elemento y aquí te metes y dices, pues este se va a llamar rotador y aquí las teclas son la U y la I, ¿vale? Etcétera. 02:36:11

Y aquí va modificando estos valores, ¿vale? Esto lo voy a borrar, que es el que tenía ahí. Vale, importante. Una cosa importante, cuando puedes reiniciar los valores de los access, no. Hasta donde yo sé, no. 02:36:25

ya te vienen por defecto 02:36:47

y que yo sepa 02:36:51

no te deja reiniciar 02:36:53

a ver, pues mira 02:36:55

si le das a input manager 02:36:57

reset, lo reinicias 02:36:58

por defecto 02:37:01

y por tanto, rotador me lo he cargado 02:37:02

vale, ahí lo voy a dejar 02:37:05

que si no, para el próximo día si continuamos de aquí 02:37:11

vale, y como está 02:37:13

girando al revés, lo que voy a hacer es 02:37:15

cambiar aquí la I y la U 02:37:17

y ahora ya sí va a girar como quiero 02:37:18

Vale, algo más así, iré estudiando, abriré el tema 3, el 18 de hecho, no sé por qué lo hice coincidir, pero bueno, con la entrega de la 2. 02:37:20

Y irle echando un ojo, ¿vale? Poco a poco lo iremos viendo. Sé que es farragoso, sé que son muchas cosas, pero bueno, es que es así el proceso, vaya. 02:37:32

Pero bueno, hoy hemos terminado de ver un poco el plantamiento farragoso de las bases de programación, lo que está en el tema cero, yo creo. Así, sobre todo, lo más importante, que me faltaba hablar de cómo se creaban métodos, está ahí. Ya va a ser todo un poco más aplicado ya a los temas que vayan abriéndose. 02:37:42