Vídeos UT2 - #2 - DEIM - Curso 25·26 | Mediateca de EducaMadrid

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í. 00:00:06

Y vamos a ir con este de cálculos durante, que es el que he aplicado en Empty, simplemente porque vamos a ver resultados en la consola. Entonces no va a haber muchas cosas más allá. 00:00:21

Pero simplemente el otro día presenté lo que era un vector 3. 00:00:34

En el tema ya habréis leído para qué se emplea, ¿no? 00:00:40

Para marcar coordenadas o para marcar direcciones. 00:00:42

Es un poco los valores. 00:00:46

Pero me interesa mucho, ya el otro día hablamos cómo se iban sumando, 00:00:48

cómo se declaraba un vector nuevo. 00:00:51

Cuando queremos poner un número vector 3 que no ha sido todavía recogido por una variable vector 3, 00:00:53

hay que poner primero la palabra nuevo. 00:01:00

Si no, va a dar fallo siempre, ¿vale? Entonces cuando digáis esto debería estar funcionando, poned este nuevo porque pueden surgir los problemas, ¿sí? Entonces simplemente me gustaría que veamos rápidamente porque a veces si no hay operaciones que decís esto es posible, esto no, vamos a verlo rápido, ¿vale? 00:01:03

Tengo aquí preparados dos vectores, ¿vale? Con estos dos valores, 1, 2, 4, en el caso del A y 0, 1, 2 en el caso del B, ¿vale? 00:01:22

Que voy a usar en estos ejemplos que tengo aquí debajo, ¿vale? A ver, perdonad que para que no salgan luego más códigos de los que debiera. 00:01:30

Ahí está, ¿vale? Va a ser en el start, solo va a salir una vez distintos mensajes. 00:01:38

Entonces, simplemente quiero que veamos que se pueden sumar vectores distintos que vamos creando sobre la marcha, al vuelo. Se pueden sumar los que hemos guardado en vectores 3 como variable previamente y por eso aquí operamos con estos vectores A y vector B, esto lo vimos el otro día. 00:01:43

También es importante saber que se puede hacer, y me paso aquí, se pueden ir sumando vectores con distintas dimensiones, ¿vale? 00:02:06

Porque un vector 3, en el tema también sale que pueden existir vectores 2, incluso existen por ahí, aunque no son tan comunes, los vectores 4, ¿vale? 00:02:15

Pero que no os veáis limitados en algún momento a pensar que porque tengáis un vector 3, ese no se puede sumar, pues por ejemplo, con un vector 2 o con un vector 3, 00:02:23

que solo tenga dos de sus posiciones, es decir, x e y. 00:02:35

En esta primera suma, básicamente, que va a ser la que salga la primera frase 00:02:39

de la consola que pone sumando vectores 1, y va a ser esta, 00:02:43

esta variable que hemos creado aquí dentro del start, 00:02:46

y por tanto es local dentro de esta cápsula, 00:02:49

vamos a tener un primer resultado que va a ser un vector de 1, 00:02:53

voy haciendo, recordad que se va haciendo las operaciones 00:02:57

con las posiciones correspondientes de cada vector 3 en este caso, 00:03:00

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. 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. 00:03:03

¿Vale? Luego fijaos, y voy así pasando rápido, que también se puede sumar a través de variables que hemos declarado anteriormente, ¿no? En cuyo caso este resultado, ¿vale? Que es la segunda línea, sería 1, 3 y 6, ¿verdad? Pues mira, aquí está 1, 3, 6. 00:03:21

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:03:37

Lo mismo, se sobreentiende que si solo se ponen dos posiciones es porque esta no vale nada. 00:03:50

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:03:55

Entonces será el resultado 3, 4, 4. 00:04:07

Vamos a ver rápidamente también qué sucede si lo que hacemos es sumar un vector 3 con un número suelto. 00:04:10

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. 00:04:20

Vais a ver que, sin embargo, y lo tengo aquí preparado, sí se puede hacer esa misma operación en las multiplicaciones. Y veis que aquí no da fallo. 00:04:30

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:04:38

Que esto vamos a ver que es importante, por ejemplo, cuando tengamos que mover un objeto 00:04:49

que se mueve a partir de un vector 3, porque señala las tres dimensiones, 00:04:53

y si queremos que se mueva más o menos rápido, lo multiplicamos las tres dimensiones por un número, 00:04:57

que es un poco lo que puede dar la velocidad. 00:05:03

Por tanto, es importante diferenciar entre lo que se puede hacer con las sumas, 00:05:06

que veis que da error, lo pongo ya en comentario porque no va a haber resultado, va a dar error, 00:05:08

Y lo que se puede hacer con multiplicaciones o con divisiones. Son dos tipos de operaciones en este sentido. Y luego, por otro lado, pongo como comentario todo lo que ya hemos ido viendo y voy a poner el que es esta cuarta línea, que es intentar sumar vectores de distintas dimensiones. 00:05:14

¿Vale? Entonces si yo activo esto, ¿vale? Porque en el tema se va hablando de que existen eso, vectores de dos dimensiones, de tres. Por ejemplo, las de dos dimensiones en ocasiones se usa también en el entorno 3D, no solo se usa en juegos de tipo 2D, ¿vale? 00:05:39

Si os fijáis, da problemas, es decir, a diferencia de lo que estábamos viendo en la anterior, que si ponemos esto no da problemas, hay que ser consecuente e ir operando con vectores, ¿vale? Y vemos aquí el error que estará aquí, ¿vale? A ver, sí, bueno, esto también os lo enseño para que veáis que cuando dais a la consola, si dais a un error, ¿vale? Os va a decir aquí el por qué, ¿no? 00:05:59

Y pone, el operador más es ambiguo en operandos del tipo vector 3 y vector 2. 00:06:23

Básicamente lo que nos quiere decir es que no son compatibles, ¿no? 00:06:27

Entonces, bueno, que sepáis eso, que aunque en muchas ocasiones se puede usar un vector 3 por sus dos dimensiones 00:06:30

y estar operando realmente como si fuera un vector 2, ¿vale? 00:06:37

Considerad que no se puede hacer esta mezcla entre tipos de vectores en cuanto a su número de posiciones, ¿vale? 00:06:41

Esto creo que es importante porque luego podéis encontrar conflictos que salen errores o veis, ¿cómo puede ser que un vector 3 solo tenga dos posiciones? Pues sí, puede ser. Vamos por poder, ¿vale? Y lo vemos, incluso creo, vamos, igual ahora me equivoco, pero, ah, no, siempre tiene que haber mínimo 2. 00:06:49

Pues juraría que se podía, aunque para tener un vector 3 que solo tiene una posición, pues es lo mismo que decir aquí un 2, ¿vale? Entonces 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:07:08

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:07:29

Pues vamos a ver qué ocurre cuando vuelvo a arrancar, que ya, a ver aquí, 2, 4, 8, ¿vale? 00:07:44

Ha multiplicado cada una de las posiciones de ese vector 3 por ese número. 00:07:54

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:07:59

Luego, por otro caso, en otro caso, lo lógico que estamos haciendo con las sumas de vectores, ¿vale? 00:08:07

Lo que no se puede hacer es multiplicar un vector por otro de manera directa. Si os fijáis aquí la operación, pone multiplicar y decís, ¿y por qué 1 no se multiplica por 0, 2 por 1, 4 con 2? Bueno, por la sintaxis no lo permite. 00:08:12

Pero sí que es verdad, y esto lo tenéis en un saber más del tema, que de hecho lo tengo por aquí, un segundito que lo encuentre, tenéis un saber más, lo pongo aquí en este apartado 2.3.1, que os pone distintos métodos relacionados con los vectores, entre los que vais a encontrar, por ejemplo, uno que es este de scale, multiplicar vectores entre ejes respectivos. 00:08:27

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, pero ves 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:08:51

Entonces, un vector 3 por otro vector 3, como hemos dicho, da error. 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:09:16

¿Qué significa esto? Pues que este multiplicando vectores va a conseguir que haya una multiplicación entre el vector A, este que tenemos aquí, y este que tenemos aquí, segundo. 00:09:42

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. 0, 2, 8. Si lo comprobamos, vamos a ello, 0, 2, 8. Así se podría conseguir una multiplicación. 00:09:56

Que ya os digo, esta es una operación más compleja, pero bueno, en algún momento os podría ser necesario. 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:10:18

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:10:40

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:11:01

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:11:13

Lo voy a copiar y cambio la dimensión. 00:11:27

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

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:11:41

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

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:11:56

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:12:13

Las referencias que haya 00:12:43

Suma vectores por posiciones 00:12:44

Yo que sé, ¿vale? 00:12:47

Veis que se están cambiando las dos 00:12:48

Cuando lo tengáis, le dais a escape 00:12:49

Ah, bueno, no, a escape no 00:12:51

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

Le dais a intro y ya está, ¿vale? 00:12:59

Veis que se cambian los dos 00:13:02

Pero no en los comentados, cuidado 00:13:04

Que ahí pueden surgir problemas 00:13:05

Porque luego yo sigo descomentando 00:13:07

Y ya no se está refiriendo a esto 00:13:10

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:13:12

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

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

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:13:36

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

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:13:51

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:14:04

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:14:14

Entonces, esto como resultado va a dar que esto vale 1, esto vale 0, si os fijáis, y 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:14:31

¿por qué os digo esto? 00:14:46

a ver, lo vemos, un segundete 00:14:48

que igual hay algo con error por lo que me dice 00:14:50

ahí sale 00:14:52

como que sobra un 00:14:54

algo 00:14:55

como que sobra 00:14:56

vale, bueno, no sé 00:14:58

sí, me he debido de cargar 00:15:03

alguna llave 00:15:05

vamos a 00:15:06

aquí, y bueno, cuando le damos al play 00:15:09

va a dar el resultado de 1, 3, 6 00:15:11

¿vale? que es lo que tiene que dar 00:15:13

como sentido a esto 00:15:15

Aquí pone multiplicando vectores, ¿vale? Si os fijáis, ¿vale? No perdáis de vista porque esto es un string que he puesto aquí, ¿vale? ¿Qué pasa? Que cuando ponemos, cuando estamos trabajando con vectores es muy importante tener en cuenta que si un vector, una de las posiciones del vector no se quieren cambiar, se puede poner el nombre del vector con su dimensión y eso significa que se queda fija. 00:15:17

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:15:39

Y en la última, si por ejemplo nos quedamos con el de vector A, esto va a valer, ahora mismo va a devolver la consola un 1, 1, 4. 00:16:01

Ahora no es que se está haciendo una operación, sino simplemente estamos rescatando valores dentro de los vectores. 00:16:11

1, 1, 4. Vamos a verlo, como venimos haciendo, y veis que es 1, 1, 4. 00:16:17

Esto es importante saber que se pueden descomponer los vectores a la hora de luego usarlos. 00:16:24

A veces tenéis que poner, porque os lo pide, las tres posiciones de un vector y solo queréis cambiar uno, ¿vale? Pues las otras dos las ponéis como estaban, con X y Z y esto es lo que ponéis, pues 55, ¿vale? 00:16:28

Ahora mismo la única que se ha variado es la I, ¿vale? Entonces es importante porque, por ejemplo, en la nave, en este ejemplo que estamos haciendo, solo se va a mover arriba-abajo, izquierda-derecha, ¿no? 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:16:42

Entonces, en muchas ocasiones hay que recurrir a, no, no, yo quiero que esto siga siendo la posición original, 00:17:07

porque es que no se va a mover, entonces este que quede fijo aquí. 00:17:13

Esto, como no estoy operando, pues va a ser el vector que viniera. 00:17:16

Sigo a la siguiente cosa, que yo entiendo que se queda claro en el tema, 00:17:26

pero que queda aún más claro, porque en mi experiencia es algo que a veces genera dudas. 00:17:31

Y es lógico también, al principio. 00:17:39

Vale, tenemos aquí un update, ¿por qué viene señalado? Pues lo mismo, si tenemos dudas de por qué viene señalado, pues ponemos aquí esto de la advertencia en este caso, porque sale verde, a ver, que ahora se ha escondido, y pone la función local update se declara pero nunca se usa, y eso tiene algo que ver con las llaves de antes. 00:17:40

Si os fijáis, por algún motivo el start... Ah, vale. Lo que pasa es que había borrado el de cierre del start. Y ahora me sobra uno. Pues eso. Gracias a ver en contexto la advertencia que me estaba saliendo, me he dado cuenta de que estaba metiendo el update dentro del start. 00:18:03

que son dos momentos de ejecución que no se deberían mezclar, ¿vale? 00:18:24

Simplemente que los errores salen por todos lados 00:18:27

y lo importante siempre es saber cómo salir del escollo, ¿no? 00:18:30

Vale, para ver esto, este ejemplo que voy a hablar un poco 00:18:35

de cómo se descompone el movimiento con el translate, ¿vale? 00:18:39

Y dejar claras un par de cosas de los inputs que están en el tema. 00:18:43

Dejadme que haga un cubo o algún elemento que sea visible. 00:18:48

Por ejemplo, este cubo que está en 0, 0. Perfecto. Y me voy a cargar esto de empty 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:18:51

al cubo al cubo al cubo ahora si quiere venga entonces ahora mismo tenemos un cubo que yo le 00:19:09

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

la gravedad entonces está quietito que voy a hacer en este con este escrito bueno ahora mismo como si 00:19:22

borrar a todo esto del estar vale porque todo son operaciones para una consola pero en el update es 00:19:30

Es decir, en cada fotograma yo estoy diciendo que surja una condición, un if, que ya hemos visto también cómo funcionan, 00:19:38

que en este caso ponen en juego lo que son las, bueno, pues los inputs, las interacciones que podemos hacer con dispositivos nuestros. 00:19:45

Que en este caso nos vamos a centrar sobre todo en teclado, pero pueden ser de más tipos. 00:19:54

Si, bueno, 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í. 00:19:58

Que veamos las diferencias entre interactividad, clase input. Y aparte en el tema, también vais a ver 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:20:08

Entonces nos vamos a quedar con este input manager. 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:20:32

importante porque 00:20:49

otros años me decían 00:20:52

pero cuando yo doy a getKeyDown 00:20:54

es que estoy dando a la flecha de abajo o a la de arriba 00:20:56

no tiene nada que ver 00:20:58

cuando estamos definiendo una interacción 00:20:59

hay que tener en cuenta 00:21:02

que al menos de partida 00:21:04

hay tres momentos importantes 00:21:06

y lo podéis ver cuando pulsáis una tecla 00:21:08

el momento en el que se pulsa 00:21:10

el tiempo durante el que 00:21:12

está pulsado y el momento en el que 00:21:14

se levanta 00:21:16

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:21:17

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:21:37

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:21:57

No tiene nada que ver con la dirección en sí. La dirección luego se explica en la tecla que hay entre paréntesis, o el código que se da entre paréntesis, y luego la orden que se da ya entre llaves del condicional. 00:22:20

Entonces, por ejemplo, la sintaxis en este caso siempre empieza por esta clase input, que recoge en su interior las distintas configuraciones de interacción que tiene el input manager. 00:22:37

Y luego aquí es donde entra uno de estos métodos que tenemos aquí, que son varios. Hay otros pensados para botón del ratón, como en este caso, que con este input se dice, si ponemos esta línea, es que si se pulsa el botón izquierdo del ratón, pues se da esta orden. 00:22:49

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:23:09

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:23:28

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:23:49

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? 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 D, ¿vale? Pues para que este elemento se mueva hacia la derecha, ¿vale? 00:24:09

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? Mientras mantenga pulsada esta tecla D, se ejecuta lo que hay en estas llaves. 00:24:34

Pasamos a lo que son los transform, ¿vale? Que es, como dijimos, es un método, ¿vale? 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, ¿vale? 00:24:48

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 a tajo para poder desplegar todos los métodos que haya relacionados con variar valores de transform. 00:25:02

transform, todo lo tendremos claro 00:25:23

pero se refiere esencialmente 00:25:26

a lo que ocupa este componente 00:25:28

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

de los GameObjects 00:25:32

que tenemos en nuestro 00:25:34

juego 00:25:36

entonces 00:25:37

¿qué es lo que conseguimos? 00:25:40

bueno y dentro de transform hay muchos 00:25:42

pero bueno, en este caso sobre todo vamos a ver el translate 00:25:44

que sirve para ir moviendo objetos 00:25:46

y el rotate para ir rotando objetos 00:25:48

como siempre 00:25:51

Y fijaos que yo lo que hago cuando tengo dudas es poner Unity en Google y pongo transform translate. A ver qué me cuenta de esto. Siempre va a salir el scripting API y aquí os habla de cómo se usa con algún ejemplo. 00:25:52

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:26:09

Y vais a ver que en este caso se puede declarar de dos formas este transform translate. 00:26:21

Pero es importante entender que lo que se tiene que poner siempre como primer argumento es un vector 3. 00:26:27

Y que puede ser una variable vector3 que hayamos guardado antes o crear un new vector3 dentro de este translate. 00:26:35

Entonces, aquí estamos. 00:26:42

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

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

y esta la voy a poner comentado, 00:27:02

Lo que vamos a decir es, en cada fotograma, si yo pulso, mejor dicho, no pulso, mantengo pulsado la tecla D, esto se va a ir moviendo en un vector 3. 00:27:04

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

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

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:27:31

vuelvo a hacerlo, se ve ahí muy pequeñito 00:27:53

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

importante, cuando vayáis a hacer interacciones 00:27:59

veis que yo tengo el panel de escena y el de juego 00:28:03

para que el juego se ejecute 00:28:06

y detecte las interacciones, aunque tengáis aquí abierta 00:28:09

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

este objeto, tenéis que clicar en juego 00:28:15

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

no se movería, porque no está en el área 00:28:20

del editor de Unity 00:28:24

necesario para que 00:28:26

se pueda interactuar, importante que a veces 00:28:28

decís, no me funciona nada 00:28:30

de esto, y es porque estáis clicando 00:28:32

en escena mismamente, o que es 00:28:34

lógico, en escena podéis mover los elementos 00:28:36

vosotros como queráis, ¿vale? 00:28:38

en reproducción para comprobar cosas 00:28:40

¿vale? pero lo que son las interacciones 00:28:42

tenéis que dar clic a game y ya ahí 00:28:44

funciona, y fijaos que 00:28:46

yo puedo volver a poner aquí el objeto 00:28:48

que le doy a la tecla D, ¿vale? 00:28:50

y se mueve en el eje X 00:28:52

hacia la derecha. ¿Por qué? Pues porque, hemos dicho, la tecla D se va moviendo con respecto a donde esté, 00:28:54

le va sumando, digamos, al valor que ya tenga, uno en cada fotograma. 00:29:00

Y estos dos los deja igual porque son cero. 00:29:04

De hecho, lo que hemos dicho antes, si yo pongo un vector 3 solo con dos valores, 00:29:07

también me lo coge y va a ser equivalente a esto. 00:29:12

Simplemente que veáis que eso puede ocurrir. 00:29:15

¿Qué problema surge de esto? ¿Es estable este movimiento? Pues no. 00:29:18

¿Por qué? Por lo que viene en el tema también. El problema del update o la ventaja, según como se vea, es que este método se ejecuta en cada fotograma de reproducción del juego. 00:29:22

Pero esto no significa que el ordenador tenga constantemente la misma velocidad de reproducción, ¿vale? Va a ir, digamos, si abrís 85 programas a la vez, irá más despacio ese ordenador, tendrá menor capacidad de computación, que si solo estamos con Unity, con este juego, ¿vale? Puede variar, ¿no? 00:29:35

Entonces, ¿qué ocurre? Que si en cada update yo muevo uno, ¿qué os asegura que se mueva a la misma distancia en un segundo que en el siguiente? 00:29:57

Me explico. Si, digamos, en un segundo el ordenador ha tenido la capacidad de reproducir 15 fotogramas, se moverá 15 posiciones. 00:30:08

pero si en el siguiente segundo ha podido reproducir 20 fotogramas, se habrá movido 20 posiciones en un segundo. 00:30:19

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

Por eso, ahora mismo este objeto no es estable. De hecho, si nos fijáramos y hiciéramos pruebas más largas que las que voy a hacer ahora mismo, 00:30:34

vais a ver que puede ir dando como saltitos 00:30:42

porque en un fotograma 00:30:45

tarda más que otro en reproducirse 00:30:47

entonces 00:30:50

voy a alejarme 00:30:50

que como se ve el gizmo 00:30:53

me voy a alejar y a lo mejor veis algún salto 00:30:55

normalmente va a ser mínimo 00:30:57

pero a veces se ven como tirones 00:30:59

y se debe precisamente a esto que os estoy comentando 00:31:01

la solución a esto 00:31:04

¿cuál es? 00:31:06

a ver 00:31:07

usar este elemento que se llama 00:31:08

TimeDeltaTime, ¿vale? Y lo voy a comentar esto para dejarlo aquí. Vale, ¿qué hace? Y esto de momento me lo cargo. ¿Qué hace el TimeDeltaTime? 00:31:11

El TimeDeltaTime 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 00:31:23

ese fotograma precisamente en tiempo, 00:31:33

en segundos, cuánto tiempo tarda el fotograma 00:31:36

en 00:31:38

reproducirse. 00:31:40

El tiempo que ha tardado desde el anterior hasta que 00:31:42

ese se ejecuta. 00:31:44

De hecho, vais a ver que si yo 00:31:46

a ver, tengo todos los de Barlogs aquí ocultos. 00:31:48

Que si yo voy ahora 00:31:50

aquí a 00:31:52

Unity, a la consola, 00:31:53

veis que los valores 00:31:57

van cambiando. Lo que os he dicho, 00:31:58

todos los 00:31:59

fotogramas tardan lo mismo, o el 00:32:01

El ordenador no tiene la velocidad para hacerlo de manera constante. 00:32:03

Y esto nos está dando el time delta time, es lo que estamos viendo. 00:32:07

Es el valor de tiempo que transcurre entre un fotograma y el anterior realmente. 00:32:11

¿Qué es lo que hace esto al multiplicarlo? 00:32:18

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. 00:32:20

Para que toda la multiplicación afecte a las tres, en este caso, a las tres posiciones por igual. 00:32:26

y sea, por tanto, bueno, pues antes se me ha salido la palabra, equivalente, ¿no? 00:32:31

Entre las tres, que no haya un eje que se mueva más rápido que otro. 00:32:37

Las multiplicaciones siempre ponen el mismo valor. 00:32:41

Entonces, ¿qué conseguimos? 00:32:44

Y aquí pongo algún ejemplo que lo que hace esto es compensar... 00:32:45

A ver, vale, esto es simplemente para daros un detalle teórico, ¿no? 00:32:52

Para compensar precisamente que la velocidad de movimiento, 00:32:59

al multiplicarlo por este time delta time sea siempre equivalente. ¿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. 00:33:02

Al multiplicarlo por el tiempo que ha tardado, se va a equilibrar siempre para que sea el mismo, ¿no? Y fijaos aquí, si se hubieran ejecutado 10 fotogramas, ¿vale? El time delta time sería 0,1, ¿no? 00:33:14

Porque 0,1 es el tiempo que tardaría para que se ejecuten 10 en un segundo y sería 1. 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:33:27

Y veis que al final equilibra para que la duración de todos, siempre al final de 1, si solo se han hecho 3 fotogramas, se multiplicará por un time delta time de este valor. 00:33:42

Entonces, aquí está, digamos, equilibrando en todo momento, ¿vale? Porque está cambiando este valor realmente, en todo momento, este valor o los que hay aquí, aquí como estos son 0, pues la multiplicación da 0, pero se está variando de manera dinámica cuántas posiciones se tiene que mover para que sea equilibrada, ¿vale? 00:33:52

esto es algo muy propio de cuando se hacen movimientos en el update y diréis por si a 00:34:11

alguien le ha surgido la pregunta y por qué y por qué no dejan fijo el número de fotogramas 00:34:19

que se reproducen en el juego para que siempre sea estable y nos quitamos de esta historia del 00:34:23

del time delta time pues muy simple para empezar porque sí que hay otro método que ya veremos en 00:34:29

El tema 3, que es el Fixed Update, que ese sí que es fijo. Este es una velocidad de actualización constante. 00:34:36

Se pone que es 0.2 y todo lo que se ejecuta tarda 0.2. 00:34:43

Si el ordenador no le da tiempo, habrá que subir esta velocidad, bajar, hacer más lenta esta velocidad para que le dé tiempo. 00:34:48

Pero está pensado para que sea fijo y estable. 00:34:54

Pero el Update tiene una ventaja, que es intentar, aunque luego lo estabilicemos en algunos valores que no nos interese, 00:34:57

intentar captar también por ejemplo una interacción lo antes posible vamos a ver 00:35:04

que cuando nosotros pulsamos una tecla vale al final vamos a poner en el ate y 00:35:10

que es el que está todo el rato escuchando cuando sucede algo vamos a 00:35:15

poner que capte esa interacción aquí por ejemplo si os fijáis mismamente si 00:35:18

pusiera aquí down para para que sólo capte el momento en el que pulso la 00:35:23

tecla de vale va a haber un momento en el que digamos unity entiende que se ha 00:35:28

pulsado cuanto antes sea ese momento es decir relacionándolo con en cuanto haya 00:35:33

otro momento de reproducción cáptalo vale eso no habría que compensarlo de 00:35:38

ninguna forma porque lo que queremos es que lo capte lo antes posible para que 00:35:42

la interacción no tenga ningún lag o sea el mínimo vale pero luego la orden que 00:35:46

ejecuta así que queremos que sea consecuente para que no dé en este caso 00:35:50

tirones es decir la interacción la queremos cuanto antes vale lógicamente 00:35:54

para que cuanto antes ya aquí se procesa lo que sea porque los movimientos sí que 00:35:58

Es verdad que nos interesa que sean estables, porque visualmente si va dando tirones, pues queda mal, no tiene sentido. 00:36:03

Pero yo que sé, puedo convertir una booleana en falsa en este segundo y eso sí queda igual. 00:36:09

Eso cuanto antes también, pues lo pondremos aquí. 00:36:14

Si esta booleana... cambiar, yo que sé. 00:36:17

La queremos convertir en falsa, no sé, estoy haciendo aquí una chorrada. 00:36:23

En cuanto le dé a la tecla D, quiero que suceda eso. 00:36:26

Ahí no voy a poner un tema en delta time, pues que suceda cuanto más rápido mejor. 00:36:29

Entonces, ¿qué problema tiene también? Y vuelvo a ponerlo como estaba para que lo mantenga. Porque, ojo, si dejo este down, aunque yo mantenga la tecla D, me meto aquí y selecciono el cubo para que se vea, le doy a la tecla D ahora mismo. 00:36:33

Y la estoy manteniendo pulsada. Bueno, no, en realidad la estoy manteniendo pulsada y confiada en mí. Y no se mueve. Se ha movido una fraccioncita la primera vez. ¿Por qué? 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. 00:36:49

Y no mientras lo mantengo, entonces se ejecuta una vez y no se está moviendo de manera continua. Y fijaos además que los valores que va subiendo es poquísimo, son decimales. Y aquí teníamos uno. Debería moverse una unidad cada vez que al menos pulsara esta tecla D. 00:37:11

¿Por qué está sucediendo esto? Porque fijaos los valores de decimales que tiene, de lo poco que tarda, claro, es muy rápido, el procesador en generar cada fotograma. 00:37:31

¿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:37:44

¿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:37:59

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í, fraude speed, 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:38:10

pues luego ya lo multiplico para que vaya más rápido 00:38:28

yo no quiero que vaya tan lento 00:38:32

pero ya lo va a hacer en base a una velocidad 00:38:33

digamos estabilizada y proporcional 00:38:37

con esto yo lo aumento 00:38:40

por eso ahora cuando yo le dé 00:38:41

ahora que le he puesto una speed de 100 00:38:43

que multiplicaba bastante 00:38:45

y 100 está bien si solo estáis poniendo el time delta time 00:38:46

porque fijaos, bueno de hecho sería 1000 00:38:50

pero si ponemos 100 00:38:52

básicamente volvemos a recuperar la unidad 00:38:53

entonces digamos que es lo más equilibrado 00:38:55

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:38:58

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

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

y se va sumando en cada fotograma 00:39:20

porque recordad que he quitado el getKeyDown 00:39:24

o getKeyUp y entonces 00:39:26

es el tiempo que yo mantenga esa tecla 00:39:27

pulsada. Hay un 00:39:30

último operador que quiero que veamos 00:39:37

que es el que se llama 00:39:39

módulo 00:39:41

y el módulo en ocasiones 00:39:41

puede ser útil y de hecho cuando 00:39:45

vayamos hablando 00:39:47

voy a quitar los de Barlog para que no distraigan 00:39:49

y me centro en el Start, me voy aquí 00:39:51

abajo y sigo. El módulo 00:39:53

es un operador, igual que el de sumar, el de restar, el de multiplicar y el de dividir, que ya tenemos vistos, que es con el porcentaje. 00:39:56

Esto es otro operador. ¿Y qué es lo que hace el módulo? Devolver el resto de una división. Es decir, hace una división, sabemos lo que hace una división, 00:40:05

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

Entonces, por ejemplo, voy a poner aquí un float, que lo voy a llamar módulo, resultante, resultante, y aquí lo que vamos a hacer es que módulo, 00:40:20

para que lo plante un segundo que lo tenía para explicarlo de otra forma pero quiero 00:40:38

verlo aquí primero módulo resultante es igual a 9 de 3 y aquí lo que vamos a hacer es un de 00:40:43

backlog para ver el resultado que nos está devolviendo que va a dar lo que valga módulo 00:40:54

resultante. Voy a poner aquí, como siempre, el resultado del módulo es un espacio y nos 00:41:01

lo dará. Si dividimos 9 entre 3, ¿cuál va a ser el resto de esa división? 9 entre 00:41:13

3 da de resto 0. Si cuando hacíamos las divisiones, no sé si os acordáis, que salía un resultado 00:41:20

pero luego el resto aparecía a la izquierda, debajo de los numeritos. Vamos a hacer otro 00:41:25

Otro ejemplo, si hacemos 10 entre 3, ¿cuál sería el resto? Hay que hacer una división, ¿vale? Esto lo que está diciendo es una división, pero lo que nos interesa no es el resultado, que es lo lógico. 00:41:29

En el anterior, evidentemente, era 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:41:44

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. 00:41:59

El resto de una división es el número que queda cuando la división no es exacta. 00:42:12

Por eso, cuando no es exacta es un valor diferente a cero. 00:42:16

Cuando una división tiene resto, decimos que es una división entera. 00:42:19

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:42:22

Y ese resto es el número de unidades que han quedado sueltas hasta el siguiente valor. 00:42:28

Entonces, 10 módulo 3 sería 1. 00:42:34

Vamos a verlo. 00:42:39

10 módulo 3 00:42:39

sería igual a 1 00:42:44

y le doy y lo vamos a ver 00:42:45

aquí está 00:42:48

el resultado del módulo es 1 00:42:49

¿vale? si yo aquí pongo 11 00:42:51

el resto serán 2, porque 00:42:54

9 entre 3 da el resultado y sobran 00:42:55

2, ese es el resto, por eso de hecho 00:42:58

se llama así, ¿vale? ahora 00:43:00

vamos a ver que el resultado del módulo 00:43:02

es 2, ¿qué pasa si yo lo pongo 00:43:04

en 12? que el resto volverá 00:43:06

a ser 2, no, perdón 00:43:08

cero, porque 12 entre 3 da 4 y es un número entero, entonces no sobran valores. Esto es 00:43:09

importante y diréis, ¿esto para qué sirve? Pues fijaos, por ejemplo, que si cualquier 00:43:19

número se divide entre 2, si es un número par va a dar un resto cero y si no es un número 00:43:23

impar va a dar un resto uno. Y es una forma muy rápida, por ejemplo, por poner un ejemplo 00:43:30

de aplicación, para discriminar entre valores pares e impares, que esto puede ser útil en diversas ocasiones, ¿vale? 12 entre 2 da un valor de 0. 00:43:35

Si pongo cualquier número, cualquiera, que no sea par, ¿vale? Por ejemplo este, con esto estamos guardando básicamente en esta variable que si el resultado es 1, 00:43:47

se trata de un número impar, ¿vale? Y este es uno y es un impar, ¿vale? Esto por un lado. Sobre todo, de momento, por ejemplo, nos sirve esto de saber si esto es un valor par o impar, 00:43:58

porque luego podemos decir que si módulo resultante es igual a 0 o a 1, ¿vale? Si yo pongo aquí, si módulo resultante en este caso es igual a 0, 00:44:14

Y me falta aquí otro. Si pongo esto, significa que este número es par. Si fuera 1, significaría que es impar. Y ya según eso puedo ir discriminando que ocurran unas acciones u otras en ese condicional. 00:44:28

vamos a este código de aquí vamos aquí que aquí yo he puesto lo que es un método y voy a poner 00:44:47

voy a seguir en esta en este que tengo aquí que lo tengo más recogido cuando vosotros empleáis 00:44:59

después de una clase ponéis un punto vale o va a poner que es un método vale que son estos pues 00:45:08

translate por ejemplo que aquí en este caso primero tienen una clase como transforme input 00:45:16

y luego estos métodos que, si veis, vienen marcados de amarillo y siempre están continuados por un paréntesis, que puede llevar cosas o no llevar cosas. 00:45:21

De hecho, si os fijáis, los momentos de ejecución son métodos, sí que es verdad que no los llamamos porque ya vienen aquí declarados, 00:45:30

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. 00:45:40

Esto significa que aunque ya vienen programados para ser usados así, nosotros podemos crear nuestros propios métodos. Y los métodos tienen principalmente dos usos. Uno, estructurar mejor el código, permitir hacer capítulos, vamos, mejor que capítulos, secciones de código que van ejecutando órdenes. 00:45:46

Y otra es para hacer operaciones en su interior. Como esto de primeras entiendo que igual no se entiende, vamos a verlo en uso. Así además sabéis cómo, aunque luego son muy complejos en su interior, cómo llegan a existir estos métodos. 00:46:10

Que básicamente, si os fijáis, pone void transform translate. Esta palabra de void, que significa en inglés vacío, la nada, si yo pongo este void a continuación, y cuidado, void con minúscula, que hay otro void por ahí en mayúscula que pueda aparecer, aquí nos quedamos con el de minúscula. 00:46:26

si ponemos fuera es decir fuera de otro método que haya vale la declaración de 00:46:45

métodos si os fijáis aquí está voy de start vamos y esa llave cierra y aquí 00:46:52

dentro habrá unas instrucciones luego se abre otro void que cierra en sí mismo y 00:46:57

tendrá sus instrucciones nosotros vamos a hacer ahora otro conjunto de 00:47:02

instrucciones. Podemos hacer un método que se llame 00:47:05

recogeCódigo. ¿Vale? Veis que cuando escribimos después de 00:47:12

un void, y ojo, la sintaxis de los métodos, recordad que es con mayúscula la primera 00:47:18

letra, ¿vale? Y bueno, con pascal case, ¿no? Y posteriormente se pone este paréntesis. 00:47:23

La sintaxis continúa con unas llaves. ¿Qué es lo que acabamos de hacer? Hemos hecho un 00:47:31

método que lo que hace es en base a este nombre vamos a poder ejecutar un código 00:47:35

que va a estar aquí dentro y lo vamos a poder llamar siempre que queramos igual 00:47:40

que aquí cuando ponemos translate o el otro día poníamos instantiate vale que 00:47:44

es otro método instantiate y por eso vais a ver también que se pone en 00:47:48

amarillo le falta poner lo que nos pide pero ahí está vale este código una vez 00:47:52

se ha declarado así con este void pues yo puedo ahora en otro momento en otro 00:47:58

momento de ejecución vale porque ahora mismo esto no se está ejecutando en 00:48:02

ningún lado. Están los métodos de ejecución, pues eso, el start, el update, el fix update, el awake, 00:48:05

hay distintos, pero dentro del update yo voy a decir quiero que se ejecute en cada fotograma, 00:48:12

recoge código. Bueno, ahora mismo se ejecutará además si pulsamos la tecla D. Yo lo voy a poner 00:48:19

que sea en cada fotograma impepinablemente. ¿Esto qué significa? Que yo todo lo que ponga aquí, 00:48:23

Y cuando llegue cada vuelta de cada fotograma y se reproduzca lo que hay dentro de Update, va a ejecutar lo que hay aquí dentro. 00:48:29

Imaginaos que vamos a poner, en vez de recoge código, voy a poner un nombre más concreto, disparo, o salto, o una acción. 00:48:38

Y como lo he cambiado, disparo. 00:48:49

Disparo. Aquí en cada fotograma se va a ejecutar lo que haya en este disparo. Si yo pongo que en disparo me ponga debug log he disparado, ¿qué es lo que va a ocurrir? 00:48:54

que esta orden se va a ejecutar, porque lo he puesto dentro del update, en cada fotograma, ¿vale? Digamos que cuando llega a esta línea dice, ojo, hay un método 00:49:15

llamado disparo. ¿Qué es eso? Y va, lo busca y dice, ah, mira, disparo. Y ejecuta lo que hay aquí tal cual, ¿vale? Lo ejecuta y una vez lo ha ejecutado, pues ya sigue 00:49:28

con el resto del código. Va, digamos, saltando de una parte a otra. Por eso, igual que aquí al comienzo, dentro de lo que es la clase, 00:49:37

hacemos la declaración de las variables globales para luego poder ir usándolas dentro de cada cápsula, incluida esto. 00:49:46

Esto también son cápsulas, tienen su entorno entre las llaves, su ámbito. Con los métodos va a suceder algo parecido. 00:49:54

Se pueden ir incorporando entre otros métodos, ya os he dicho que para declarar un método lo suyo es hacerlo fuera de los métodos de ejecución, porque si no se estará creando también en ese momento de ejecución y no es lo que queremos, lo vamos a declarar en un punto aparte. 00:50:03

Y aquí podemos ir haciendo el void salto. Y dentro de esto, pues yo puedo ir metiendo aquí las instrucciones de salto. Otro que va a ser void correr. Yo qué sé, os estoy poniendo ejemplos que ya vais a usar, incluso en esta práctica lo podéis hacer. 00:50:18

Y con esto lo que conseguimos es ir las distintas acciones segmentando. Y que en cierto momento cuando pulso la tecla D quiero que haga un salto, pues en vez de poner todo el código del salto, pongo esta llamada al método y lo buscará y ejecutará lo que hay dentro. 00:50:37

Y luego continuará el código. Porque si no, a lo mejor tenemos para ejecutar ese salto un código de 87 líneas y aquí estamos dando las distintas opciones que configuran el salto. 00:50:55

Imaginaos que luego en otro momento del código, si doy a otra tecla o hago cualquier otra cosa, también tengo que saltar. 00:51:07

Tendría que copiar estas 87 líneas y pegarlas aquí. Entonces sería muy farragoso porque al final el código sería muy largo y luego otras 87 líneas para hacer el disparo. 00:51:13

igual, disparo cuando me agacho 00:51:23

cuando apunto y cuando tal 00:51:26

y se van dando muchas condiciones 00:51:27

entonces ir copiando todo el rato el mismo código 00:51:29

es un tostón 00:51:31

¿qué conseguimos con esto? que simplemente poniendo 00:51:32

la llamada, el disparo, pues lo pongo aquí 00:51:36

y que luego aquí hay otra condición que disparo 00:51:38

pues la copio aquí 00:51:40

y que tengo que cambiar algo de disparo, pues de manera tal 00:51:40

lo cambio aquí 00:51:44

entonces es una forma de ir organizando 00:51:44

los 00:51:48

bueno pues los 00:51:48

el uso de nuestro trabajo, ¿vale? 00:51:51

Eso es la primera función de un método, 00:51:57

organizar, organizar y conseguir ir, digamos, 00:52:01

encapsulando instrucciones que pueden ser de muchísimas líneas 00:52:04

para que solo con una llamada a ese método 00:52:08

se ejecute lo que hay adentro. 00:52:10

Luego empieza a complicarse, porque como hemos dicho antes, 00:52:13

los métodos, entre sus paréntesis, pueden pedir cosas. 00:52:16

De hecho, yo no puedo poner un translate sin poner nada. Estoy llamando a un método como aquí disparo y ves que este no da problemas y este sí. ¿Y por qué? Porque cuando se declara el método, aquí, yo puedo decirle que obligatoriamente haya que pasarle entre estos paréntesis, que digamos que se conecta con el de la declaración, con el paréntesis luego de la llamada, y requiere que se pase algún valor. 00:52:20

¿vale? esto ¿cómo se hace? 00:52:46

y es simple en realidad 00:52:49

si lo pensamos, de primeras puede costar 00:52:50

pero es simple, igual que declaramos 00:52:53

variables y primero hay que decir 00:52:54

de qué tipo es la variable y luego el nombre de la variable 00:52:56

¿no? aquí 00:52:59

también podemos estar pidiendo lo que se 00:53:00

llaman parámetros ¿vale? 00:53:02

dentro del método se pueden pedir 00:53:04

parámetros y en disparo 00:53:06

¿qué nos puede interesar? 00:53:09

pues por ejemplo 00:53:11

yo que sé, voy a poner 00:53:13

cosas un poco abstractas pero por ejemplo puedo pedir el tipo de de arma no sé vale entonces para 00:53:14

que voy a dejarme poner el código luego lo vemos tipo de arma vale cuando creamos este string 00:53:26

estamos diciendo que cuando llegue a este momento y veis que ahora da fallo porque hemos pedido un 00:53:36

parámetro vale cuando se declara se llaman parámetros y cuando luego nos lo 00:53:42

pida se llamarán argumentos vale que si en algún momento leís pasa un argumento 00:53:47

al método o un parámetro bueno pues que sepáis que se refiere básicamente en dos 00:53:52

puntos distintos a lo que hay entre paréntesis vale pero veis que en cuanto 00:53:56

yo ya declaró un un tipo de parámetro ya obligatoriamente 00:53:59

a no ser que declare otro que esté vacío vale 00:54:06

directamente va a dar error si no decimos ese parámetro que es un poco lo 00:54:10

que está pasando aquí con translate si lo vaciamos vale que cuando está 00:54:15

declarado translate si os fijáis y mirad lo que sale ahí que es lo mismo también 00:54:19

que sale en la documentación de unity pone transport punto translate y entre 00:54:24

paréntesis tiene que pasar una variable o un elemento de vector 3 llama 00:54:30

translation vale y otro de espacio que se llama related to y luego más 5 00:54:34

sobrecargas vale si os fijáis en la documentación que lo estábamos viendo antes y por eso también 00:54:39

es muy útil me meto en transportas ley tener el lápiz de scripting aquí este método está 00:54:45

declarado de dos formas vale tiene dos formas de actuar y bueno y si seguimos bajando de hecho 00:54:53

tenemos dos luego hay otra aquí otras dos más luego hay otra aquí ya llevamos cinco otra aquí 00:55:00

6, ¿vale? 6. Y de hecho, vais a ver que cuando yo me pongo aquí pone esa forma de usar el método, ¿vale? 00:55:06

Más 5 sobrecargas. Si os fijáis está una más 5, las 6 que tienen. Porque al programar, al declarar 00:55:17

quien haya hecho el código de MonoBehaviour o de CISAR para Unity, Translate dijo va a haber 5 formas 00:55:24

de pasar valores, de pasar argumentos a este método 00:55:31

para que luego los ejecute de una forma u otra. 00:55:35

¿Os acordáis el otro día, la tarea de la unidad 1, 00:55:38

que había tres formas de rellenar estos paréntesis 00:55:41

y según de lo que pusiéramos en la instancia se hacía hija 00:55:46

del GameObjectPadre o no se cogía otra referencia? 00:55:51

Eso significa, porque cuando se diseñó ese InstanceAid, 00:55:56

Si nos metemos en object instantiate, bueno, había dos más, pero había estas tres primeras, bueno, eran estas dos primeras y esta cuarta, las que hemos usado. 00:56:01

Están declaradas todas estas variables de distintas formas y todas son válidas y apelan a un mismo nombre, instantiate, pero dependiendo del tipo de parámetro que pasemos y cuántos pasemos, que también es un valor importante, se ejecutará de una forma u otra. 00:56:13

Y eso es lo que se llaman sobrecargas. 00:56:31

Este método tiene, a ver, bueno, es que tiene un montón, si os fijáis. 00:56:33

Fijaos todo lo que tiene. 00:56:37

Por eso, dependiendo, si lo que pasabais era una variable tipo transform, 00:56:39

lo considera como un padre. 00:56:43

Si lo que pasáis como segundo parámetro es un vector 3, 00:56:45

lo que hace es que no hay ningún padre y por eso no se hacía hijo 00:56:50

y lo que va a poner es la posición de que estamos pasando aquí. 00:56:53

Entonces, ¿a qué viene esto en el momento en el que estamos explicando cómo se declaran métodos? 00:56:57

Primero, que aquí lo que pongamos obliga a que luego haya que cumplir al llamar a ese método 00:57:04

Porque lo que se puede hacer, y por eso puede haber sobrecargas 00:57:10

Yo puedo hacer un disparo sin pedir argumentos en su interior, sin pedir parámetros 00:57:13

Y ahora no da fallo 00:57:19

Porque si yo pongo este disparo en este punto, lo que va a buscar es en este 00:57:21

Y aquí puedo poner, de backlog, sin argumentos, ¿vale? 00:57:25

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? 00:57:40

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. 00:57:52

Le voy a dar. 00:58:03

¿Y qué pone? Dos veces, bueno, como está en el update, pues sale dos veces en cada fotograma, sin argumentos. 00:58:05

Si yo por contra, en esta primera lo dejo como está, que va a poner sin argumentos, esta me la voy a cargar, aunque si no pulsamos la D no ocurriría, ¿no? 00:58:11

Esta pondría sin argumentos y en esta voy a decir, el disparo voy a poner, como lo que me está pidiendo es un string, hay que pasarlo en string. 00:58:21

Y voy a poner, no sé, una colt, ¿no? Creo que es un tipo de arma, ¿vale? 00:58:30

Pues va a poner en cada fotograma, va a poner sin argumentos, correspondiente a este, ¿sí? 00:58:34

Y luego este disparo va a buscar, ¿vale? Cuando llamas a este método, ¿cuál cuadra con este? 00:58:41

Y dice, ah, vale, me está pasando un string, por tanto, y solo un elemento, ¿vale? Y solo un elemento y es este. Pues entonces voy a poner edit parado 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í, 00:58:47

llega a este punto y dice que objeto instancio 00:59:16

y aquí dentro es donde lo instancia 00:59:18

pero gracias a estos paréntesis se hace el puente 00:59:20

entre lo que se está llamando 00:59:22

y otro valor 00:59:24

o varios como hemos visto separados por coma 00:59:26

que se ejecutan en su interior 00:59:29

y la gracia es 00:59:30

conectar cuando llamamos 00:59:32

meter un valor del mismo 00:59:34

tipo de lo que tengamos aquí 00:59:37

y luego dentro de ese método 00:59:38

ese tipo, ese valor 00:59:40

que ha entrado se llamará esa variable 00:59:43

hay que referenciarla con el nombre que habíamos puesto a este parámetro. 00:59:44

Es decir, esto sirve para decir, cada vez que ponemos un argumento, 00:59:49

y ya os digo que pueden ser varios, puede ser un string y un flow llamado numerazo, 00:59:52

yo qué sé, por poner un nombre llamativo. 00:59:56

Ahora da error porque nos faltaría aquí el numerazo. 00:59:58

Ahora no hay ninguna variable, ningún método, perdonad, que solo tenga un argumento. 01:00:01

Entonces, hasta que no pongamos en este caso un número, pues da error nuevamente 01:00:07

porque no cuadra con ninguno. Busca y dice, no hay ninguno que se llame disparo y tenga dos argumentos de estos tipos. 01:00:13

Que ojo, y por eso es importante el orden de los métodos. Si yo pongo 5 y colt, aunque en teoría estamos haciendo lo mismo, 01:00:19

da error porque tiene que ir en el mismo orden en el que se están declarando esos parámetros. 01:00:29

¿Vale? Entonces, lo bueno es que este mismo método, dependiendo de lo que pasemos, en este caso, en cada uno de estos dos valores, pues luego el resultado va a ser distinto, ¿vale? Porque aquí, por ejemplo, va a coger que es colt y más del calibre y en vez de numerazo voy a llamarlo calibre, ¿vale? Porque me interesa para luego referenciarlo aquí. 01:00:36

He disparado con colt de calibre, ¿vale? Y aquí lo que pongo es que me muestre lo que hayamos pasado en el segundo parámetro que se llame calibre, ¿vale? Y vais a ver ahora que lo que devuelve cada fotograma va a ser, por un lado, el disparo que es sin argumentos 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í, ¿vale? 01:01:00

Si en otro punto, y bueno, y 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:01:24

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

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

Todo esto es pensar para usarlo a nuestros intereses 01:01:54

Pero si por ejemplo tenemos un enemigo que le queremos ir quitando según 01:01:59

Pues yo que sé, tenemos un personaje con una espada y una escopeta 01:02:06

Y el método se llama daña 01:02:10

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, le voy a llamar disparo. 01:02:12

Disparo sería 01:02:43

Espada, vale, y el valor 01:02:44

De daño que quita, vale, la da con la espada 01:02:47

Y el valor que quita de vida es 10 01:02:49

Vale 01:02:51

Si no, yo que sé 01:02:52

Imaginaos que si no, la otra variable es 01:02:55

Si le golpea 01:02:57

O si no, si le golpea 01:02:58

Con 01:03:01

Martillo 01:03:01

Yo que sé 01:03:05

¿Qué hace más daño? 01:03:06

Pues aquí 01:03:08

Lo que pondríamos es 01:03:09

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:03:12

pensad otra vez en el instant seed 01:03:34

el instant seed es un método 01:03:37

que luego hará lo que sea con los elementos 01:03:38

que le vamos dando en sus paréntesis 01:03:41

que en cada ocasión, en este caso es una nave 01:03:42

pero podría ser un prefab de una casa 01:03:45

o de los pivotes 01:03:47

que hay ahora en esta 01:03:49

tarea que hay que esquivar 01:03:50

eso es para lo que sirve 01:03:52

definir que cada vez que llamemos 01:03:54

al método, según el momento en el que estemos 01:03:57

con un mismo nombre de método 01:03:59

podemos pasar un montón de 01:04:01

diferentes 01:04:03

datos, elementos, variables, lo que queramos. 01:04:05

Voy a hacer otro ejemplo. 01:04:08

Voy a hacer una pequeña calculadora 01:04:11

y entonces lo que voy a hacer es declarar 01:04:14

un método llamado calculadora. 01:04:18

De momento sin nada 01:04:22

de parámetros, de argumentos. 01:04:24

Entonces 01:04:28

al arrancar 01:04:29

yo lo que voy a hacer es decir 01:04:30

Aquí podría decir, bueno, pues número, una variable, un int, que sea número, bueno, voy a hacer floats mejor, float, número a, como antes, y va a ser en este caso 5, y float número b, y que va a ser 7, yo que sé, por poner un ejemplo. 01:04:32

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:04:54

y según eso 01:05:13

luego nos devuelve 01:05:16

de backlog 01:05:20

el resultado es 01:05:21

más resultado 01:05:26

¿qué ocurre? 01:05:30

he creado un método 01:05:32

y aquí lo que voy a decir 01:05:34

es en el start 01:05:36

me haces calculadora 01:05:37

esto 01:05:39

cuando empieza el juego 01:05:41

en el start dice 01:05:45

Ah, vale, llamo a calculadora, lo busco. Aquí podría haber 87 métodos, pero ha buscado el que se llama calculadora y no tiene nada entre sus paréntesis, ¿vale? 01:05:46

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:05:53

Bueno, pues le damos y 5 más 7, 12. El resultado es 12. Ok. Pues aquí estamos aplicando lo que hemos dicho. 01:06:01

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í. ¿Qué pasa? Que ahora mismo siempre da el mismo resultado, porque como no damos ningún tipo de diferencia, pues ejecuta lo que hay aquí. 01:06:11

No hay nada entre los paréntesis, ejecuta esto y ¡chimpún! Listo. Que no es lo mismo que decir, aquí vamos a decir que esta calculadora haya que pasarle un parámetro que sea un int número A y otro int que es número B. 01:06:30

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

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

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

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

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

¿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:07:17

Cuidado, tiene que ser del mismo tipo de variable, ¿vale? 01:07:36

Del mismo variable. 01:07:39

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:07:40

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

Y ahí no da el problema. 01:07:51

Vale. 01:07:52

Entonces, 7 y 9. 01:07:53

Vale. 01:07:57

¿Qué va a hacer ahora calculadora? 01:07:58

¿Qué va a devolver? 01:07:59

Algo va a devolver, porque va a entrar aquí y va a ver esto. 01:08:00

Y lo va a ejecutar. 01:08:05

Y hay un debug log que no hay ningún condicional y se va a aplicar. 01:08:06

Así que va a poner el resultado es. 01:08:08

¿Y qué resultado? 01:08:11

12. 01:08:14

¿Por qué? 01:08:15

Porque aunque yo aquí le esté pasando valores, os vuelvo a decir que el resultado es 5, los que estaban antes, y 7. 01:08:15

¿Vale? 01:08:21

Esto de momento no hemos conseguido nada. 01:08:21

Lo conseguimos en el momento en el que llamamos a estos dos valores. 01:08:24

A D, por ejemplo, aquí, y aquí a C. 01:08:27

¿Vale? 01:08:30

¿Ahora qué valor va a dar esto? 01:08:31

16. 01:08:36

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:08:36

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. Igual que resultado, resultado lo hemos nombrado aquí y si yo intento buscar resultado, pues no existe. 01:08:54

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:09:14

Entonces, ahora mismo efectivamente estamos pasando un 7 y un 9 y el resultado es 16, ¿no? La suma de esos dos. 01:09:32

Entonces, bueno, simplemente para ver que esto es así, ahí, ¿vale? Y va a poner el resultado es 16, ¿vale? 01:09:41

¿Qué es lo bueno de esto? Que yo puedo ir diciendo, voy a hacer luego que en el Start, porque me interesa calculadora, 01:09:48

quiero que haga varios cálculos calculadora pues va a hacer 100 más 100 5 calculadora 01:09:56

22 y así podría hacer muchos que va a suceder ahora que al arrancar el juego va a poner tres 01:10:09

líneas con los resultados de estas sumas porque lo hemos configurado así porque son los argumentos 01:10:16

que estamos pasando. Ojo, no número A y B, sino C y D, que son los que hemos referenciado 01:10:23

aquí. Entonces va a salir primero 16, luego 105 y luego 22. Guardo 16, 105 y 22. Y veis 01:10:29

que de una forma, con poco esfuerzo, ya tenemos una calculadora. Pongamos lo que pongamos 01:10:37

aquí, ya está la operación de sumar. Que si esto luego se aplica a vidas o a objetos 01:10:42

que se instancian o a lo que sea, pues con una sola línea podemos referenciar, y este 01:10:46

código muy simple, pero podríamos tener uno 01:10:52

súper complejo en el que luego 01:10:54

número D cambie, metamos 01:10:56

el número A y le restamos el C, 01:10:58

que ahí sí que está cogiendo un valor global 01:11:00

de todo el juego con el que estamos 01:11:02

pasando por los argumentos, ¿vale? 01:11:04

Y va operando en base a eso. 01:11:06

Vale. Voy un paso 01:11:08

más allá. Aquí se pueden ir añadiendo 01:11:10

más métodos. Si yo, por ejemplo, 01:11:12

aquí hago... Si yo pongo aquí número E 01:11:14

y yo programo 01:11:16

para que el resultado luego sea... 01:11:18

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

Si yo aquí a resultado, luego digo, vale, resultado ya lo tengo aquí, 01:11:29

entonces voy a hacer otro que se llama resultado tras multiplicar, 01:11:35

que va a ser igual a lo que ya teníamos en resultado por el número e, 01:11:37

que es el siguiente valor, ¿vale? 01:11:43

Ahora el problema que va a haber es que necesitamos poner otro argumento, 01:11:45

otro argumento, porque este sería 2, por ejemplo, y aquí 2 también, y aquí 2 para que se vea, ¿vale? 01:11:50

Y aquí habría que poner que lo que muestra es resultado tras multiplicar. 01:12:01

Aquí lo que hemos conseguido es que se vayan haciendo más operaciones. 01:12:05

¿Qué ocurre? Que si alguna no la quieres o la quieres vacía, pues da este error que hay aquí. 01:12:10

Sin embargo, había una forma para poner un valor que no es obligatorio poner. Con esto lo que hacemos es que sea obligatorio pasar un... Es decir, estas dos son obligatorias pasarla, pero esta que hay aquí, si no pasa nada, lo va a asumir que es un 0 y no da error. 01:12:15

Lo único es que si pones 0 va a dar 0. Lo suyo igual es 1 en este caso. Pero si pones un igual y un valor, por defecto, si no se pone nada, pues toma ese, el valor. Y por eso ahora mismo 7 más 9, que es lo que tenemos aquí, daría 16. 01:12:34

Y por 1, aunque no haya puesto nada, sería 16. Si aquí ya ponemos otro valor y ponemos 2, daría 32. 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. 01:12:55

En caso de que haya un if, claro, esto ya lo puedes hacer más complejo, ¿vale? 01:13:11

Ir metiendo método, porque tú puedes hacer aquí, por ejemplo, un disparo, ¿vale? 01:13:17

Que tenga lo que sea dentro y tú luego aquí también puedes llamar a disparo. 01:13:23

Entonces, si se cumple tal cosa, pues disparo ocurre tal, si no, la otra. 01:13:28

Que se pueden ir intrincando ya muchas operaciones. 01:13:33

Así 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. Si vemos en este caso, vais a ver momentos en los que pone precisamente eso. 01:13:37

Bueno, 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:13:53

Si os fijáis, este método tiene un montón de parámetros, un vector3 que se llama origin, otro vector3, direction, y luego ya a partir de aquí, todos los que hay son opcionales. 01:14:06

Lo 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. Con este igual se define un valor en caso de que no se especifique ese argumento. 01:14:16

Y voy a la siguiente cosa, 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:14:32

Si es void, es lo que hemos dicho, va a ejecutar en su interior lo que haya entre estas llaves, que hay parámetros y argumentos, los aplican estas llaves como se haya definido. 01:14:42

Pero calculadora, si yo la llamo, también se puede decir que sea un int. Cuando tenemos un método declarado para que devuelva un tipo de valor, significa que cuando salgamos de este método no es que recoja y ejecute lo que hay en su interior, 01:14:53

sino que va a dar un resultado concreto, ¿vale? 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:15:17

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, a ver, algún tipo de argumento, de parámetro, a ver, ahí, ¿vale? 01:15:28

A esta variable, cuando tenemos una que dice que es de un tipo, hay una sutileza que es que tiene que acabar con un return algo. Tiene que acabar con un valor. Por ejemplo, número C en este caso. 01:15:47

Si ponemos esto, 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:16:05

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, 01:16:14

Lo que estamos haciendo aquí es que nuevamente estamos conectando esta calculadora, 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:16:27

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. 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:16:45

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:17:03

Y atención, cuando estamos trabajando y tiene que devolver un valor, el valor tiene que ser de ese tipo. 01:17:20

Fijaos que suma yo la he declarado como un float y por eso da error, porque no puede mostrar, si os recordáis al principio, 01:17:29

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:17:35

Entonces, ¿qué devolvería aquí? Nuevamente un 7, pero no es porque se haya ejecutado el debug log dentro del método, 01:17:43

sino porque es que cuando llamo a calculadora, tal y como ha sido declarado aquí, vale un 7, se sustituye por un 7. 01:17:49

No es que esté haciendo otras operaciones, es que el propio método es el resultado de una operación. 01:17:57

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:18:02

Y ahora si nos fijamos, lo que va a devolver la consola es un 7. 01:18:10

Esto en cierto momento también tiene sentido. Podemos querer operaciones que luego se convierten en operaciones. Entonces, a lo mejor en cierto momento podemos meter una variable, un método dentro como resultado de otro método. 01:18:19

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í, que podemos ir declarando un método de tipo booleano que vaya a devolver si algo es verdadero o falso. 01:18:34

Veis que aquí tengo un método que devuelve un valor y por eso es un return. 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 integer, que es 7. 01:19:00

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:19:16

Si no, es falso. Esto en realidad está al revés, porque debería ser, si no es 0, es falso porque no es par. 01:19:31

Pero veis que con esto ya se puede ir definiendo luego si es par y da tal cosa, mi mensaje es la variable es par o es igual a 10. 01:19:37

por ejemplo aquí, lo que tenemos aquí 01:19:45

voy a copiar esta y lo voy a pegar 01:19:48

aquí, en el otro que teníamos 01:19:50

y así lo vamos a ver más claro 01:19:52

tu tu y tu tu 01:19:53

vale 01:19:56

en start 01:19:58

spar y lo copio 01:19:59

de aquí, que la tenía 01:20:02

que estaba preparada, fijaos en este 01:20:04

ejemplo, vale 01:20:06

tu tu 01:20:10

y voy a poner que integer, voy a hacer otra 01:20:10

variable llamada integer, que es como se 01:20:14

aquí que en principio vale 5 vale y bueno luego ahí mi mensaje que es bueno vamos a ver como unos 01:20:16

métodos se intrincan en otros viene bien el mensaje vale vamos a ver así rápido esto yo 01:20:25

tengo un código que he creado dos métodos para funciones para llamarlos cuando me interese no 01:20:33

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:20:40

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:20:57

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:21:08

Pongo un 5. 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, ¿no? 01:21:20

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, es decir, en este momento pondría true. Esto sería igual, en este caso, lo que devolvería es un true, ¿vale? Si no, pues devolvería false, ¿vale? 01:21:36

Pues ya espar, que como hemos visto no es un vacío, sino que se queda como un valor, que en este caso es true, va a valer ahora para seguir trabajando. 01:21:58

Si este espar, este true, es así, si esto es true, el mensaje que se va a pasar es myInteger is espar. 01:22:08

Aquí es lo que he dicho antes. 01:22:18

Está al revés y esto debería ser false y esto true. 01:22:20

Ahora, esto es false. 01:22:24

Vale, ahora sí tiene sentido con respecto a que sea par o no sea par. Si mi íntegra es par, pues va a entrar aquí y va a decir si este resultado es falso, me meto aquí y digo, vale, 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. 01:22:28

Y que va a coger el mensaje que pongamos aquí, que es un string, para luego devolverlo en este var log y al llamarlo lo devuelve. 01:22:55

Entonces, ahora mismo, por poner que este valor es 5, va a mostrar que mi mensaje, myInteger, es impar. 01:23:04

Vamos a verlo. Y yo ahora veo esto. Y aquí vemos myInteger is par. 01:23:14

A ver, ¿por qué está haciendo esto? Si myInteger es par, me vuelvo falso, y aquí habría que hacer otra vez, si esto, bueno, lo voy a poner así verbalizado, si esto es falso, y ahora sí que va a ir bien. 01:23:19

si íntegre es 01:23:37

igual a falso 01:23:40

¿vale? es decir, esto es un valor 01:23:42

booleano, si este es igual que este 01:23:45

va a decir que 01:23:46

esto está al revés también 01:23:48

es impar, ¿vale? y si no, ¿qué es par? 01:23:50

entonces ahora 01:23:53

cuando yo vaya aquí 01:23:54

pues nuevamente 01:23:56

la íntegre es par, bueno, estoy todo el rato 01:23:58

como dando vueltas, porque 01:24:01

si lo que 01:24:03

pasamos aquí es igual a 01:24:05

0, falso, vale, si enter es falso, pues debería estar bien, algo estoy haciendo así que está al revés, ah, bueno, claro, joder, la que se cumple es esa y aquí esta, vale, ahora sí que va a ir bien, vamos, esto es, eso es, si yo por en cambio, ahora pongo que esto sea 6, por poner un valor par, ahora es cuando yo sí que voy a poder decir que algo, que este valor es, 01:24:06

par, ¿vale? Entonces, con esta operación lo que hacemos, por ejemplo, es 01:24:39

por un lado, definir si esto es verdadero o falso, una booleana, 01:24:42

porque aquí estamos llevándolo a esto de que sea algo verdadero o falso en relación a si 01:24:47

es par o impar, pero se podría programar en base a lo que queramos, ¿vale? Y ojo 01:24:51

con poner la palabra return cuando no es un void. Y una vez 01:24:55

se comprueba ese valor, ¿vale? En realidad se podría poner aquí, porque 01:24:59

también se llama aquí, si lo que devuelve este método es 01:25:03

falso en este caso, llamo 01:25:06

a otro método, en vez de poner el debug log 01:25:08

aquí directamente, porque se podrían poner 01:25:10

más operaciones, que 01:25:12

conecte con ese mensaje 01:25:14

que es el que va a mostrar. Voy a ir 01:25:16

a una escena que yo tenía aquí preparada 01:25:26

con 01:25:28

una escena con 01:25:28

la nave. Aquí estamos. 01:25:34

¿Vale? Cosas 01:25:38

a tener en cuenta. 01:25:40

entiendo que ya todos tenéis claro pues cómo se instancia un objeto aquí no hace falta que 01:25:41

instancia y la nave puede estar ya desde el principio en el espacio vale aquí preparada 01:25:46

porque en su momento era yo tan pesado con que el prefab vale este prefab estuviera en el 0 0 0 vale 01:25:51

porque así al empezar el juego si está centrado y le instancia mos en el centro vale si toda rotación 01:25:59

la hacemos en base a su centro vale no va a dar problemas de que a lo mejor pongamos el 01:26:06

el ritmo el elemento de referencia en un ala y gire como desviado un poco vale entonces cuando 01:26:12

hagamos cualquier elemento no sólo éste sino cualquiera en sí el prefab vale a no ser que 01:26:19

hagamos aposta debería tener igual que cuando trabajáis en 3d al modelar etcétera ponéis el 01:26:24

punto de ancla en donde queréis que gire pues hay que tenerlo en cuenta también para que esté en 01:26:29

ese punto y el giro se haga con respecto a donde queráis. Si por ejemplo modeláis una muñeca y el 01:26:35

punto de ancla con el que gira está en el hombro pues va a girar mal. Estos son conceptos que 01:26:40

entiendo que del módulo animación tenéis claros. Y para simplificar ahora ciertas acciones los 01:26:45

suyos que hagáis, esta nave la situéis, esta nave que recordemos no se va a mover en profundidad 01:26:51

sino hacia arriba, abajo, izquierda, derecha, que la situéis en el cero en todos los ejes menos, 01:26:58

Bueno, pues en todos los ejes menos en el Y porque va a subir y bajar o en el X, pero 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:27:02

Porque 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? Que algún compañero me ha dicho, ¿se puede cambiar por otra nave o por otro pivote? 01:27:19

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? ¿Qué habrá que hacer? Bueno, aparte hay que crear un suelo que nuevamente los suyos que estén situados en posiciones cercanas al cero, ¿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:27:40

¿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:28:08

pero al menos nos da una relación de dónde van a salir esos pivotes, etc. 01:28:28

Os explico una cosa muy rápida también para que no sea todo tan blanco y se vea mejor 01:28:35

que es que para dar color, esto ya se verá más adelante en más detalle 01:28:39

pero para darle un color a un elemento, por ejemplo al suelo y que no sea igual que la nave 01:28:44

en este blanco impoluto, en una carpeta lo suyo de materiales o de lo que queráis 01:28:48

con clic derecho podemos crear, entre otros elementos, un material 01:28:53

vale un material para la visualización de un objeto entonces material voy a llamar suelo vale 01:28:57

este es el material que vamos a con el que vamos a colorear el suelo cuando metéis en un material 01:29:03

que salen con este icono que tenemos aquí vale estoy ampliando y reduciendo con este slider o 01:29:08

con control y la ruleta vale se hacen más grandes o más pequeños entre sus parámetros que hay muchos 01:29:14

ya lo veremos hay uno que dice el albedo que estoy imagino que os suena también de el módulo de color 01:29:20

El albedo que es el color base, digamos, antes de ser afectado por reflejos, por metalicidad, etcétera 01:29:25

Podemos cambiarlo de color y decir que sea, en este caso lo voy a poner un gris 01:29:33

Un gris azulado, da igual, si es para que se distinga, ¿vale? 01:29:37

Veis que esta bola que muestra el material va cambiando en relación a lo que indiquéis aquí 01:29:41

Pues si se pone rojo, pues rojo, etcétera, ¿vale? 01:29:49

Podéis toquetear más cosas, ya os digo 01:29:51

No es lo que me interesa ahora 01:29:54

Y para aplicar un material, cuando vais por ejemplo 01:29:55

Al plane, que parece avión 01:29:58

Pero voy a poner el suelo a este GameObject 01:30:00

Si arrastráis este material 01:30:02

Al propio GameObject 01:30:04

O visualmente aquí 01:30:06

A la pantalla 01:30:08

Veis que se colorea de ese material 01:30:09

En esencia lo que está haciendo 01:30:11

Es que los GameObjects 01:30:13

Por lo general tienen 01:30:17

Un componente que se llama 01:30:18

Mesh Renderer, que es lo que renderiza esa malla 01:30:20

y que tiene un material que se 01:30:22

cambia de esta forma, ¿vale? 01:30:24

Veis que cuando lo pongo, coge ese material 01:30:26

¿vale? Una forma muy rápida ya si queréis 01:30:28

tener cosas un poquito más vistosas 01:30:30

para ir coloreando 01:30:32

elementos, ¿vale? Así rápido 01:30:34

no es lo que me voy a meter ahora 01:30:36

Indica, estoy un poco atascado con lo de añadir 01:30:37

la rotación a la nave cuando se desplaza lateralmente 01:30:45

¿vale? Esa probablemente es la parte 01:30:48

más peleaguda 01:30:50

del enunciado 01:30:51

Bueno, de todos modos en el mismo enunciado se dice que se puede llegar de varias maneras y bueno, en el tema también se anuncia o se deja ver que lo que es la rotación y cómo la gestiona el propio Unity es complejo en el sentido de que usa estos cuaternios que son cuatro dimensiones, ¿no? 01:30:54

Para que no exista este bloque del Gimbal Lock, ¿no? Eso lo tenéis. 01:31:15

Y entonces surgen problemas, hay una discordancia entre la rotación y los grados que podemos ir dando, 01:31:18

que veis que son, digamos, infinitos, ¿no? Cada 360 grados empezará una rotación, 01:31:26

pero a nivel numérico aquí podemos ver que el número no se ve restringido. 01:31:31

Pero sí que es verdad que por debajo, los cálculos que está haciendo, 01:31:37

La realidad es que estos valores solo van de 0 a 360. Entonces, digamos que cuando a lo mejor se pasa de una vuelta a la siguiente, con estos valores genera conflictos extraños. 01:31:41

¿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, movimiento nave, ¿vale? 01:31:54

Y ya antes, como hemos visto en la estructura de cómo se hace un transform, vamos a ir a ello. Vamos a poner este script en esta nave que va a definir la nave y nos metemos. Vamos allá. Movimiento nave. Aquí está. 01:32:25

voy a ir rápido, os digo una forma rápida para hacer la rotación 01:32:42

más o menos yo creo que se va a ir encaminando 01:32:47

con las lógicas que vamos viendo aquí 01:32:50

si yo tengo esta nave lo que quiero es 01:32:52

que en todo momento se vayan captando 01:32:55

interacciones que vayan definiendo 01:32:58

que esta nave vaya para arriba o para abajo 01:33:01

las interacciones igual que se 01:33:03

hace con cualquier variable 01:33:07

Se pueden ir guardando como vectores o como posiciones que tienen valores. 01:33:11

¿Qué es lo que vamos a hacer en este caso? 01:33:18

Vamos a digregar por un lado los movimientos horizontales y por otro lado los movimientos verticales, 01:33:20

porque vamos a tener dos ejes de interacción. 01:33:26

Hay otro tipo de input que son el getAxis, que sirve para, está en el tema, 01:33:30

para en vez de solo dar un valor que va de 0 a 1 o de 0 a activo, como una booleana, que tenga dos ejes contrapuestos, 01:33:35

por ejemplo, como en una cruceta o en un joystick, que tienes una posición hacia arriba y otra hacia abajo y son contrapuestas. 01:33:45

Lo cual nos puede ser muy útil para hacer las posibilidades de movimientos contradictorios o contrarios. 01:33:52

¿No? Voy a volver un momento a la escena anterior, porque teníamos este cubo con cálculos durante, que no sé si me cargué... A ver, espera, lo abro. 01:33:59

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. 01:34:14

Vale, ahí está, ya no da error. Antes hemos dicho que si pulsábamos la D, este vector 3 en horizontal, que es el eje X, pues a medida que mantengamos pulsado con este GetKey la D, se irá moviendo hacia la derecha. 01:34:26

Inciso rápido. En los apuntes va a poner que hay maneras simplificadas de hablar de estos vectores 3 normalizados, es decir, que solo tenga un valor de 1 en alguno de los ejes, o de 0 incluso en los tres ejes. 01:34:41

Porque en muchas ocasiones, en vez de crear un nuevo vector, podemos decir, y esto está en los apuntes, por eso no me voy a meter mucho, pero es muy útil para marcar direcciones, 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. 01:34:55

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. 01:35:18

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. 01:35:39

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. 01:36:02

Cuando ponemos un getAxis, lo que hacemos es, bueno, lo primero ya no sería un getKey, sino un getAxis, ¿vale? 01:36:10

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, ¿vale? 01:36:17

que sea el nombre del axis, podemos decir un eje. El axis lo que hace referencia es, también vienen los apuntes, si os metéis en Edit, Project Settings, 01:36:25

y os abre este menú, los axes son los ejes que tiene configurado el juego, el proyecto ya para funcionar. 01:36:38

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. 01:36:52

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. 01:37:07

El negativo será el menos 1, el positivo será el d, y si no lo pulsamos, el positivo será el d, que valdrá 1. 01:37:27

Y hay un rango intermedio entre el menos 1 y el 1. 01:37:35

Aquí debería permitir coger el axis, input getAxis, y a ver qué está pasando. 01:37:40

Ah, bueno, claro. Sí, perdón. Cuando estamos haciendo, y vuelvo para atrás, cuando estamos poniendo una tecla, un key down, un key, al final esos valores devuelven un booleano de pulsado o no pulsado. 01:37:49

Es un booleano. Este if, al final, lo que está pidiendo es un booleano. Aquí es donde tenemos que ir creando también variables que lo que hagan sean recoger movimiento, por ejemplo, movimiento horizontal. 01:38:09

Y lo dejamos ahí como variable global y otro que sea movimiento vertical. Os acabo de decir que es un eje, lo que vamos a llamar ahora, es un eje que va a ir entre el menos 1 y el 1, pasando por los distintos valores. 01:38:24

Entonces, si tenemos aquí la a, la d, lo que os he dicho, el que sale como negativo es el menos uno y el positivo el uno. Si nos fijamos, aquí lo que vamos a hacer en el update, y por eso os he dicho antes que era bueno el update para captar interacciones, es que vamos a guardar en una variable de tipo numérico un float que cogerá los decimales entre el menos uno y el uno para tener los valores intermedios. 01:38:43

Si por ejemplo estamos usando un joystick, pues no es pulsar una tecla A o D que siempre es un número entero, porque está dando esa señal, sino que puede haber valores intermedios a medida que movemos el joystick, en este caso representados como decimales. 01:39:09

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, sino que el condicional va a funcionar el propio código. 01:39:24

Lo que vamos a conseguir aquí si multiplicamos por este move horizontal, lo escribo y ahora lo analizamos, es, y ojo a la jugada, tenemos una variable que funciona en todo el código porque es global para los valores horizontales, que va a ir guardando en cada fotograma, según lo pulsemos, en qué punto de este eje estamos interactuando. 01:39:49

Si estamos pulsando en este caso la A o la D, que son los que están configurados, entonces aquí si pulsamos la D se estará guardando un 1, si pulsamos la A se estará guardando en moveHorizontal un menos 1. 01:40:19

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. 01:40:33

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. 01:40:59

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, 01:41:10

no como con 0, porque todo lo que se multiplica por 0 es igual a 0. Aquí estamos siempre controlando una variación de movimiento en el eje X, en el horizontal. 01:41:23

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 0, 01:41:34

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 01:41:43

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, 01:41:51

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, 01:42:03

si pulso la A va hacia la izquierda. Entonces ahí podemos ir teniendo en un axis este movimiento. Esto ya se podría poner directamente en la nave. 01:42:16

Si yo al código que estoy haciendo en la nave ya le digo exactamente esto, y tengo movimiento nave aquí, aquí estaría, voy a copiar estos mismos valores que tengo aquí y los voy a volcar. 01:42:27

como variable global 01:42:55

estos, vuelco un poco lo que tenía 01:43:03

no estoy haciendo otra cosa 01:43:06

y este de cálculo durante ya lo puedo cerrar y este lo guardo 01:43:07

es lo mismo, se lo estoy aplicando a la nave 01:43:13

entonces el movimiento horizontal de la nave 01:43:17

si voy aquí y le doy a play 01:43:20

pues si le doy a la A 01:43:22

a la D va a la derecha y si le doy a la A va a la izquierda 01:43:25

Ahora mismo se está moviendo 01:43:28

Bueno, claro, es que estoy 01:43:30

Estoy en una escena 01:43:32

Que ya tiene muchas cosas configuradas 01:43:34

Voy a quitar el follow 01:43:37

Vale, por defecto 01:43:38

Y esto es una práctica buena 01:43:40

Cuando empecéis a trabajar 01:43:42

La cámara va a quedarse quieta 01:43:43

Porque nada está diciendo 01:43:47

Que siga a la nave 01:43:49

Vale, entonces 01:43:50

De momento 01:43:51

Bueno, es otra de las cosas que os pide la tarea 01:43:54

De momento, alejadla todo lo posible para ir viendo los movimientos 01:43:57

O abrir la ventana de escena que podemos navegar aquí 01:44:02

Para ir viendo estas interacciones 01:44:05

Porque la cámara se va a ir viendo según ubiquemos la cámara 01:44:07

Entonces si está en un punto que no están viendo al objeto, pues no se ve 01:44:10

Entonces, ahora mismo el código que hemos cambiado 01:44:14

Que no hay otro previo, es el de la nave 01:44:18

Y ya podemos ir izquierda a derecha 01:44:20

De esta forma, de una forma más o menos rápida 01:44:22

lo que podemos hacer es ir a los Project Settings y buscar. 01:44:26

¿Tenemos algún valor, si vamos abriendo cada uno de estos, que sirva para subir y bajar la nave? 01:44:34

Y aquí tenemos uno que tanto las teclas W y S como las de arriba y abajo de la cruceta 01:44:39

ya vendrá configurada como vertical. 01:44:44

Vamos a usar ese axis. 01:44:48

Que, ojo, nosotros podemos ir cambiando los axis e ir creando más si añadimos aquí más números. 01:44:49

Pero vamos a aprovechar este que se llama vertical para hacer lo mismo con el movimiento vertical. 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. 01:44:54

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. 01:45:13

Lo que vamos a hacer es, bueno, pues el movimiento horizontal ya lo teníamos y aquí vamos a hacer otro movimiento vertical, que 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, 01:45:29

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, ¿no? 01:45:50

Entonces, este número que estamos recogiendo está aquí, como move vertical, ¿vale? 01:46:01

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, ¿vale? 01:46:08

Si vamos aquí a esto, y pues ya el instanciador lo voy a desbloquear para no ver cosas que no hemos hecho, ¿vale? 01:46:16

Yo ya puedo subir y bajar la nave y ir a la derecha e izquierda con estas teclas que tenemos, ¿vale? 01:46:26

Sin ningún tipo de límite, puedo atravesar el suelo, etcétera, porque no hay nada que lo impida. 01:46:31

Es mucho más rápido, y por eso os decía antes, poner un vector 3 right cuando vayamos a hacer instrucciones horizontales 01:46:37

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, ¿vale? 01:46:44

Voy a hablar de cómo hacer la rotación, la forma más simple que hay, ¿vale? Vamos a ello. 01:47:02

Para hacer esto, la lógica que voy a seguir es un poco la misma. Voy a hacer otra variable, otro float, que voy a llamar rotateData, que preparo aquí, y luego en el update voy a hacer otro axis que sirva para indicar que el menos uno vaya a la izquierda la rotación y a la derecha la rotación, con la E, por ejemplo, o con otra tecla. 01:47:07

Entonces, lo que voy a hacer es guardar nuevamente en el update, a medida que se van haciendo las actualizaciones, un input getAxis, que en este caso no va a venir creado, no va a haber uno que defina nuestras interacciones como queremos. 01:47:37

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? 01:47:56

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. 01:48:14

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. 01:48:30

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. 01:48:41

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? 01:48:56

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. 01:49:12

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. 01:49:36

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. 01:49:52

El problema que os habréis encontrado es que, igual que aquí usamos el transform translate, había otro método que se llama transform rotate. Igual que el transform translate, si nos ponemos encima, da error porque pide argumentos. 01:50:10

¿Vale? Entonces, ¿cómo se puede hacer una forma rápida de que gire una nave hasta, digamos, la izquierda y la derecha? Que entiendo que si yo dejo esto aquí y digo, pues yo qué sé, vector 3, voy a hacer lo equivalente a lo que acabamos de hacer con el translate. 01:50:32

Pongo vector 3 y en este caso el eje de rotación es el del horizonte, ¿vale? Por tanto es forward, ¿vale? Se gira en relación al eje que está mirando. Entonces si queremos que gire hacia derecha o izquierda, el eje es el que va en profundidad. 01:50:56

Lo que vamos a hacer es un poco la misma lógica, que se multiplique por el valor que estemos dando a rotate data y también debería estar por un time delta time, para que sea estable como hemos hablado y bueno por una velocidad que lo suyo sería que fuera diferente a la de, de hecho la voy a hacer aquí, float speed pero de rotación, de rotación y voy a poner que esta sea, yo que sé, esto es ir probando e ir ajustando. 01:51:11

cuenta vale ahora mismo si vamos a juego vale guardo teóricamente cuando yo de a 01:51:41

las teclas y vale igual que mueva arriba abajo con las que ya había definido con 01:51:48

uno y con y veis que va rotando vale 01:51:53

entonces con eso ya yo puedo estar con las teclas que definido antes moviendo 01:51:59

la nave hacia arriba hacia abajo y con la rotación pues vamos rotando vale 01:52:04

Hasta aquí una forma. Esto ahora tiene dos peros que os digo ahora mismo. 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. 01:52:10

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, 01:52:24

Hay otro de tipo space, que por defecto, como hemos dicho, está sobre sí mismo. Pero hay otra versión que es space con respecto al mundo. ¿Qué cambia eso? 01:52:53

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 o parámetro, 01:53:07

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. 01:53:15

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. 01:53:29

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. 01:53:38

ahora mismo estamos aquí, muevo 01:53:55

con la U giro 01:54:00

y esto está invertido 01:54:02

cuando doy a la U está yendo 01:54:04

hacia la izquierda y a la I a la derecha 01:54:06

entonces 01:54:09

yo ahora cuando le doy arriba 01:54:10

sí que lo hace, veis que lo hace con respecto al mundo 01:54:12

da igual hacia donde esté mirando 01:54:15

la nave 01:54:16

entonces con esto ya 01:54:17

resolvemos ese problema de 01:54:20

tener distintos 01:54:22

distinta orientación 01:54:24

que también nos puede interesar llegar al punto 01:54:28

que la subida y bajada sea 01:54:29

en relación a donde esté mirando la nave 01:54:31

me gustaría, pero no va a ser esencial 01:54:33

para el apto o no apto 01:54:36

que no solo la rotación fuera 01:54:37

libremente así como tenemos 01:54:39

para 01:54:41

que sea todo el giro 01:54:42

sino que a los 90 grados 01:54:45

se restrinja, pero eso tiene 01:54:47

varios peros, pero de momento 01:54:49

podéis ir 01:54:50

gestionándolo así, ¿vale? 01:54:52

ya que estamos, por si lo estáis viendo 01:55:01

vamos a darle una rotación propia 01:55:03

a una velocidad propia de la rotación 01:55:05

no, básicamente es hacer un eje 01:55:09

¿vale? que se va a ocupar de recoger en una variable 01:55:12

de tipo float, el menos uno o el uno 01:55:15

que capture con los 01:55:18

inputs horizontales, es decir, con la A o con la D 01:55:22

¿vale? en este caso, porque lo que está configurado 01:55:24

en el input manager, ¿vale? Se puede cambiar. 01:55:27

Luego, otra variable distinta 01:55:30

que se llame moveVertical 01:55:32

y va a coger el 1 y el menos 1 01:55:33

de la W y la S, las teclas 01:55:35

de subir y bajar normalmente. 01:55:38

Y luego va a haber otra, que es 01:55:40

este eje que hemos creado nosotros, hemos 01:55:41

customizado, que es el 01:55:43

rotateData o se podría 01:55:45

llamar 01:55:48

moveRotation, no sé, 01:55:48

que lo que va a coger es el menos 1 o el 1 01:55:52

en este caso de la U y la I porque son las teclas 01:55:54

que he hecho. Luego, igual que hemos hecho que haya un vector normalizado, un 1, 0, 0 en el eje que queramos mover, que es el que se multiplica 01:55:56

por este input, que si no tocamos nada es 0. Por eso si no tocamos nada, esto no actúa nada. Hasta que no varíe alguno de estos valores que siempre 01:56:06

están multiplicando, no va a haber una interacción. Luego todos, como están en el update y son movimientos para que sean estables, se multiplican 01:56:15

por el time delta time y se multiplica también por una velocidad que lo que hace es aumentar el 01:56:22

detrimento en la reducción que se ha tenido por estos valores que antes hemos visto que eran 01:56:28

decimales que genera el time delta time vale y por último si es necesario hay otro otro parámetro 01:56:33

dentro del translate y el rotation en el rotate también que es que los movimientos se hagan en 01:56:42

base a sí mismo, en cuyo caso aquí pondría space.self, o con respecto al mundo, que es 01:56:47

lo que nos interesa aquí para que no considere la rotación que está teniendo el objeto 01:56:53

cuando lo vamos rotando, que es que lo hago en torno al mundo. Y la rotación es lo mismo, 01:56:58

lo hace con respecto al eje de profundidad, y nuevamente esto es lo mismo que escribir 01:57:04

vector 3, 0, 0, 1, ¿vale? 01:57:09

Porque en este caso el eje sobre el que gira es el de profundidad, ¿vale? 01:57:14

Y lo multiplica por el valor que está recogiendo en este float de rotador, ¿vale? 01:57:18

Igual, lo equilibramos y le damos una velocidad mayor, 01:57:24

que para que no sea exactamente la del movimiento, 01:57:27

pues he hecho otra variable con otro valor, 01:57:30

pero vamos, podría ser también la del movimiento. 01:57:32

Eso es por tener, digamos, un poco desgregadas las opciones. 01:57:34

Esto 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. 01:57:39

Y yo aquí meto todo lo que sea del movimiento nave. Por ejemplo, estas líneas las meto aquí. Y aquí en todo momento está buscando movimiento nave. 01:57:59

A ver, ¿por qué no me lo coge? ¿Por qué? ¿Qué he llamado yo movimiento nave? Bueno, movimiento nave, sí, a ver, ah, vale, sí, perdón, 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? 01:58:11

Pues la voy a llamar mover nave, fijaos por qué está dando ese error, ¿vale? Mover nave, ¿vale? Ahí sí está. Y luego otro que sea rotar nave, ¿vale? Y que esto es lo de siempre. 01:58:41

Luego dentro de estas llaves podemos irlo complicando, bueno esto es un void, y aquí meto esto, y aquí pues en todo momento digo aquí hay un RotarNave. 01:58:57

Aquí si os fijáis estoy usando esa forma de emplear los métodos para recopilar código. 01:59:15

Entonces bueno, con esto, simplemente para que veáis que acabamos con algo que funciona 01:59:23

Ya tendríamos el movimiento de la nave 01:59:29

Y si doy a la I y a la U 01:59:32

Ahora va más lento porque he cambiado la Speed Rotation, que la he hecho a la mitad 01:59:35

Con la I y la U voy haciendo que se rote 01:59:38

Entonces más o menos el movimiento estaría 01:59:41

Luego lo que habrá que hacer es que estos movimientos 01:59:44

solo se ejecuten cuando no se traspasen ciertas coordenadas. 01:59:49

En plan, si la altura es mayor de donde está la nave, 01:59:53

si es mayor que 10 en i, 01:59:57

entonces este movimiento deje de producirse. 02:00:03