1
00:00:06,960 --> 00:00:20,719
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í.

2
00:00:21,460 --> 00:00:33,960
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á.

3
00:00:34,640 --> 00:00:40,060
Pero simplemente el otro día presenté lo que era un vector 3.

4
00:00:40,200 --> 00:00:42,380
En el tema ya habréis leído para qué se emplea, ¿no?

5
00:00:42,659 --> 00:00:45,520
Para marcar coordenadas o para marcar direcciones.

6
00:00:46,460 --> 00:00:47,799
Es un poco los valores.

7
00:00:48,399 --> 00:00:51,840
Pero me interesa mucho, ya el otro día hablamos cómo se iban sumando,

8
00:00:51,840 --> 00:00:53,520
cómo se declaraba un vector nuevo.

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

10
00:01:00,100 --> 00:01:03,039
hay que poner primero la palabra nuevo.

11
00:01:03,039 --> 00:01:22,180
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?

12
00:01:22,560 --> 00:01:30,560
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?

13
00:01:30,620 --> 00:01:37,900
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.

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

15
00:01:43,939 --> 00:02:05,299
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.

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

17
00:02:15,879 --> 00:02:23,340
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?

18
00:02:23,740 --> 00:02:35,020
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,

19
00:02:35,020 --> 00:02:38,659
que solo tenga dos de sus posiciones, es decir, x e y.

20
00:02:39,439 --> 00:02:43,120
En esta primera suma, básicamente, que va a ser la que salga la primera frase

21
00:02:43,120 --> 00:02:46,479
de la consola que pone sumando vectores 1, y va a ser esta,

22
00:02:46,580 --> 00:02:49,280
esta variable que hemos creado aquí dentro del start,

23
00:02:49,400 --> 00:02:52,900
y por tanto es local dentro de esta cápsula,

24
00:02:53,219 --> 00:02:57,240
vamos a tener un primer resultado que va a ser un vector de 1,

25
00:02:57,560 --> 00:03:00,000
voy haciendo, recordad que se va haciendo las operaciones

26
00:03:00,000 --> 00:03:03,979
con las posiciones correspondientes de cada vector 3 en este caso,

27
00:03:03,979 --> 00:03:21,120
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.

28
00:03:21,120 --> 00:03:37,120
¿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.

29
00:03:37,759 --> 00:03:50,560
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.

30
00:03:50,560 --> 00:03:55,460
Lo mismo, se sobreentiende que si solo se ponen dos posiciones es porque esta no vale nada.

31
00:03:55,460 --> 00:04:07,439
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.

32
00:04:07,699 --> 00:04:10,060
Entonces será el resultado 3, 4, 4.

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

34
00:04:20,100 --> 00:04:29,980
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.

35
00:04:30,079 --> 00:04:37,500
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.

36
00:04:38,439 --> 00:04:49,459
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.

37
00:04:49,899 --> 00:04:53,040
Que esto vamos a ver que es importante, por ejemplo, cuando tengamos que mover un objeto

38
00:04:53,040 --> 00:04:57,300
que se mueve a partir de un vector 3, porque señala las tres dimensiones,

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

40
00:05:03,560 --> 00:05:05,459
que es un poco lo que puede dar la velocidad.

41
00:05:06,060 --> 00:05:08,860
Por tanto, es importante diferenciar entre lo que se puede hacer con las sumas,

42
00:05:08,939 --> 00:05:14,019
que veis que da error, lo pongo ya en comentario porque no va a haber resultado, va a dar error,

43
00:05:14,019 --> 00:05:39,399
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.

44
00:05:39,399 --> 00:05:59,019
¿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?

45
00:05:59,019 --> 00:06:23,160
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?

46
00:06:23,160 --> 00:06:26,920
Y pone, el operador más es ambiguo en operandos del tipo vector 3 y vector 2.

47
00:06:27,000 --> 00:06:30,519
Básicamente lo que nos quiere decir es que no son compatibles, ¿no?

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

49
00:06:37,660 --> 00:06:40,560
y estar operando realmente como si fuera un vector 2, ¿vale?

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

51
00:06:49,199 --> 00:07:08,100
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.

52
00:07:08,100 --> 00:07:29,339
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.

53
00:07:29,339 --> 00:07:44,540
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?

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

55
00:07:54,500 --> 00:07:59,000
Ha multiplicado cada una de las posiciones de ese vector 3 por ese número.

56
00:07:59,360 --> 00:08:06,720
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?

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

58
00:08:12,939 --> 00:08:27,100
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.

59
00:08:27,100 --> 00:08:51,940
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.

60
00:08:51,940 --> 00:09:16,779
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.

61
00:09:16,779 --> 00:09:42,039
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.

62
00:09:42,039 --> 00:09:56,919
¿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.

63
00:09:56,919 --> 00:10:18,419
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.

64
00:10:18,419 --> 00:10:40,919
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.

65
00:10:40,919 --> 00:11:01,620
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.

66
00:11:01,620 --> 00:11:12,580
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.

67
00:11:13,259 --> 00:11:23,360
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.

68
00:11:27,279 --> 00:11:31,000
Lo voy a copiar y cambio la dimensión.

69
00:11:31,620 --> 00:11:40,659
Z y Z. Y diréis, ¿y esto que estás haciendo qué es?

70
00:11:41,440 --> 00:11:52,019
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.

71
00:11:52,019 --> 00:11:56,480
Pero bueno, lo voy a dejar con este nombre para que no sea un lío.

72
00:11:56,480 --> 00:12:13,919
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.

73
00:12:13,919 --> 00:12:43,039
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.

74
00:12:43,039 --> 00:12:44,320
Las referencias que haya

75
00:12:44,320 --> 00:12:47,200
Suma vectores por posiciones

76
00:12:47,200 --> 00:12:48,100
Yo que sé, ¿vale?

77
00:12:48,120 --> 00:12:49,440
Veis que se están cambiando las dos

78
00:12:49,440 --> 00:12:51,539
Cuando lo tengáis, le dais a escape

79
00:12:51,539 --> 00:12:53,919
Ah, bueno, no, a escape no

80
00:12:53,919 --> 00:12:59,820
Le dais a suma vectores por posiciones

81
00:12:59,820 --> 00:13:02,559
Le dais a intro y ya está, ¿vale?

82
00:13:02,879 --> 00:13:04,179
Veis que se cambian los dos

83
00:13:04,179 --> 00:13:05,620
Pero no en los comentados, cuidado

84
00:13:05,620 --> 00:13:07,860
Que ahí pueden surgir problemas

85
00:13:07,860 --> 00:13:10,019
Porque luego yo sigo descomentando

86
00:13:10,019 --> 00:13:12,039
Y ya no se está refiriendo a esto

87
00:13:12,039 --> 00:13:24,840
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.

88
00:13:25,659 --> 00:13:28,740
Bueno, entonces, estamos aquí. ¿Qué es lo que estamos haciendo?

89
00:13:29,379 --> 00:13:35,899
Importante. Cada vector 3 tiene la posición x, la y y la z.

90
00:13:36,679 --> 00:13:44,879
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.

91
00:13:45,639 --> 00:13:51,580
Aunque no son exactamente lo mismo, dijimos que eran variables compuestas de varios valores.

92
00:13:51,580 --> 00:14:04,820
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.

93
00:14:04,940 --> 00:14:14,340
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.

94
00:14:14,340 --> 00:14:31,019
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.

95
00:14:31,019 --> 00:14:46,259
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.

96
00:14:46,259 --> 00:14:47,759
¿por qué os digo esto?

97
00:14:48,200 --> 00:14:50,200
a ver, lo vemos, un segundete

98
00:14:50,200 --> 00:14:52,759
que igual hay algo con error por lo que me dice

99
00:14:52,759 --> 00:14:54,519
ahí sale

100
00:14:54,519 --> 00:14:55,379
como que sobra un

101
00:14:55,379 --> 00:14:56,620
algo

102
00:14:56,620 --> 00:14:58,899
como que sobra

103
00:14:58,899 --> 00:15:03,080
vale, bueno, no sé

104
00:15:03,080 --> 00:15:05,080
sí, me he debido de cargar

105
00:15:05,080 --> 00:15:06,899
alguna llave

106
00:15:06,899 --> 00:15:09,360
vamos a

107
00:15:09,360 --> 00:15:11,500
aquí, y bueno, cuando le damos al play

108
00:15:11,500 --> 00:15:13,899
va a dar el resultado de 1, 3, 6

109
00:15:13,899 --> 00:15:15,860
¿vale? que es lo que tiene que dar

110
00:15:15,860 --> 00:15:17,360
como sentido a esto

111
00:15:17,360 --> 00:15:39,620
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.

112
00:15:39,620 --> 00:16:01,899
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.

113
00:16:01,899 --> 00:16:10,960
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.

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

115
00:16:17,080 --> 00:16:23,820
1, 1, 4. Vamos a verlo, como venimos haciendo, y veis que es 1, 1, 4.

116
00:16:24,159 --> 00:16:28,379
Esto es importante saber que se pueden descomponer los vectores a la hora de luego usarlos.

117
00:16:28,379 --> 00:16:42,720
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?

118
00:16:42,720 --> 00:17:06,380
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.

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

120
00:17:13,980 --> 00:17:16,519
porque es que no se va a mover, entonces este que quede fijo aquí.

121
00:17:16,980 --> 00:17:19,759
Esto, como no estoy operando, pues va a ser el vector que viniera.

122
00:17:26,880 --> 00:17:31,440
Sigo a la siguiente cosa, que yo entiendo que se queda claro en el tema,

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

124
00:17:39,240 --> 00:17:40,559
Y es lógico también, al principio.

125
00:17:40,559 --> 00:18:03,200
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.

126
00:18:03,200 --> 00:18:24,799
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.

127
00:18:24,799 --> 00:18:27,700
que son dos momentos de ejecución que no se deberían mezclar, ¿vale?

128
00:18:27,859 --> 00:18:30,539
Simplemente que los errores salen por todos lados

129
00:18:30,539 --> 00:18:34,859
y lo importante siempre es saber cómo salir del escollo, ¿no?

130
00:18:35,579 --> 00:18:39,700
Vale, para ver esto, este ejemplo que voy a hablar un poco

131
00:18:39,700 --> 00:18:42,200
de cómo se descompone el movimiento con el translate, ¿vale?

132
00:18:43,039 --> 00:18:47,079
Y dejar claras un par de cosas de los inputs que están en el tema.

133
00:18:48,579 --> 00:18:51,839
Dejadme que haga un cubo o algún elemento que sea visible.

134
00:18:51,839 --> 00:19:09,839
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.

135
00:19:09,839 --> 00:19:17,339
al cubo al cubo al cubo ahora si quiere venga entonces ahora mismo tenemos un cubo que yo le

136
00:19:17,339 --> 00:19:22,140
doy a play y está quieto vale porque todavía por ejemplo no hemos aprendido a usar las fuerzas de

137
00:19:22,140 --> 00:19:30,480
la gravedad entonces está quietito que voy a hacer en este con este escrito bueno ahora mismo como si

138
00:19:30,480 --> 00:19:38,319
borrar a todo esto del estar vale porque todo son operaciones para una consola pero en el update es

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

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

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

142
00:19:58,819 --> 00:20:07,799
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í.

143
00:20:08,319 --> 00:20:32,380
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.

144
00:20:32,380 --> 00:20:49,900
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.

145
00:20:49,900 --> 00:20:52,660
importante porque

146
00:20:52,660 --> 00:20:54,380
otros años me decían

147
00:20:54,380 --> 00:20:56,559
pero cuando yo doy a getKeyDown

148
00:20:56,559 --> 00:20:58,660
es que estoy dando a la flecha de abajo o a la de arriba

149
00:20:58,660 --> 00:20:59,819
no tiene nada que ver

150
00:20:59,819 --> 00:21:02,799
cuando estamos definiendo una interacción

151
00:21:02,799 --> 00:21:04,519
hay que tener en cuenta

152
00:21:04,519 --> 00:21:06,700
que al menos de partida

153
00:21:06,700 --> 00:21:08,500
hay tres momentos importantes

154
00:21:08,500 --> 00:21:10,759
y lo podéis ver cuando pulsáis una tecla

155
00:21:10,759 --> 00:21:12,700
el momento en el que se pulsa

156
00:21:12,700 --> 00:21:14,619
el tiempo durante el que

157
00:21:14,619 --> 00:21:16,619
está pulsado y el momento en el que

158
00:21:16,619 --> 00:21:17,500
se levanta

159
00:21:17,500 --> 00:21:37,680
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.

160
00:21:37,680 --> 00:21:57,880
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.

161
00:21:57,880 --> 00:22:20,539
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.

162
00:22:20,539 --> 00:22:37,059
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.

163
00:22:37,720 --> 00:22:49,099
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.

164
00:22:49,099 --> 00:23:09,460
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.

165
00:23:09,460 --> 00:23:28,559
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.

166
00:23:28,559 --> 00:23:49,140
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.

167
00:23:49,140 --> 00:24:09,500
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.

168
00:24:09,500 --> 00:24:34,700
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?

169
00:24:34,700 --> 00:24:47,220
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.

170
00:24:48,220 --> 00:25:02,160
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?

171
00:25:02,160 --> 00:25:23,859
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.

172
00:25:23,859 --> 00:25:26,859
transform, todo lo tendremos claro

173
00:25:26,859 --> 00:25:28,740
pero se refiere esencialmente

174
00:25:28,740 --> 00:25:30,500
a lo que ocupa este componente

175
00:25:30,500 --> 00:25:32,619
que tienen ya por defecto la mayor parte

176
00:25:32,619 --> 00:25:34,539
de los GameObjects

177
00:25:34,539 --> 00:25:36,640
que tenemos en nuestro

178
00:25:36,640 --> 00:25:37,680
juego

179
00:25:37,680 --> 00:25:40,359
entonces

180
00:25:40,359 --> 00:25:42,539
¿qué es lo que conseguimos?

181
00:25:42,660 --> 00:25:44,099
bueno y dentro de transform hay muchos

182
00:25:44,099 --> 00:25:46,740
pero bueno, en este caso sobre todo vamos a ver el translate

183
00:25:46,740 --> 00:25:48,799
que sirve para ir moviendo objetos

184
00:25:48,799 --> 00:25:51,019
y el rotate para ir rotando objetos

185
00:25:51,019 --> 00:25:52,940
como siempre

186
00:25:52,940 --> 00:26:09,759
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.

187
00:26:09,759 --> 00:26:21,160
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.

188
00:26:21,799 --> 00:26:27,240
Y vais a ver que en este caso se puede declarar de dos formas este transform translate.

189
00:26:27,920 --> 00:26:35,660
Pero es importante entender que lo que se tiene que poner siempre como primer argumento es un vector 3.

190
00:26:35,660 --> 00:26:41,680
Y que puede ser una variable vector3 que hayamos guardado antes o crear un new vector3 dentro de este translate.

191
00:26:42,880 --> 00:26:45,119
Entonces, aquí estamos.

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

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

194
00:27:02,430 --> 00:27:04,390
y esta la voy a poner comentado,

195
00:27:04,390 --> 00:27:18,769
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.

196
00:27:19,549 --> 00:27:22,529
Esto lo dejamos en cero, por tanto no varía en nada.

197
00:27:23,009 --> 00:27:31,890
Van a cambiar la posición de ese objeto con respecto a donde estuviera una posición en cada actualización del update.

198
00:27:31,890 --> 00:27:53,190
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.

199
00:27:53,190 --> 00:27:57,940
vuelvo a hacerlo, se ve ahí muy pequeñito

200
00:27:57,940 --> 00:27:59,900
me voy a acercar un poco más, que se me ha ido un poco

201
00:27:59,900 --> 00:28:03,940
importante, cuando vayáis a hacer interacciones

202
00:28:03,940 --> 00:28:06,559
veis que yo tengo el panel de escena y el de juego

203
00:28:06,559 --> 00:28:09,640
para que el juego se ejecute

204
00:28:09,640 --> 00:28:12,680
y detecte las interacciones, aunque tengáis aquí abierta

205
00:28:12,680 --> 00:28:15,799
la escena, que a mí me interesa mucho, para ver en el entorno

206
00:28:15,799 --> 00:28:18,559
este objeto, tenéis que clicar en juego

207
00:28:18,559 --> 00:28:20,859
hasta que no cliquéis en juego, yo aunque le dé a la D

208
00:28:20,859 --> 00:28:24,539
no se movería, porque no está en el área

209
00:28:24,539 --> 00:28:26,059
del editor de Unity

210
00:28:26,059 --> 00:28:28,319
necesario para que

211
00:28:28,319 --> 00:28:30,420
se pueda interactuar, importante que a veces

212
00:28:30,420 --> 00:28:32,400
decís, no me funciona nada

213
00:28:32,400 --> 00:28:34,619
de esto, y es porque estáis clicando

214
00:28:34,619 --> 00:28:36,480
en escena mismamente, o que es

215
00:28:36,480 --> 00:28:38,680
lógico, en escena podéis mover los elementos

216
00:28:38,680 --> 00:28:40,339
vosotros como queráis, ¿vale?

217
00:28:40,339 --> 00:28:42,599
en reproducción para comprobar cosas

218
00:28:42,599 --> 00:28:44,500
¿vale? pero lo que son las interacciones

219
00:28:44,500 --> 00:28:46,400
tenéis que dar clic a game y ya ahí

220
00:28:46,400 --> 00:28:48,079
funciona, y fijaos que

221
00:28:48,079 --> 00:28:50,240
yo puedo volver a poner aquí el objeto

222
00:28:50,240 --> 00:28:51,900
que le doy a la tecla D, ¿vale?

223
00:28:52,039 --> 00:28:54,000
y se mueve en el eje X

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

225
00:29:00,259 --> 00:29:04,019
le va sumando, digamos, al valor que ya tenga, uno en cada fotograma.

226
00:29:04,319 --> 00:29:06,339
Y estos dos los deja igual porque son cero.

227
00:29:07,579 --> 00:29:12,160
De hecho, lo que hemos dicho antes, si yo pongo un vector 3 solo con dos valores,

228
00:29:12,799 --> 00:29:14,839
también me lo coge y va a ser equivalente a esto.

229
00:29:15,740 --> 00:29:17,819
Simplemente que veáis que eso puede ocurrir.

230
00:29:18,759 --> 00:29:22,059
¿Qué problema surge de esto? ¿Es estable este movimiento? Pues no.

231
00:29:22,059 --> 00:29:35,619
¿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.

232
00:29:35,619 --> 00:29:57,160
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?

233
00:29:57,160 --> 00:30:07,359
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?

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

235
00:30:19,019 --> 00:30:28,880
pero si en el siguiente segundo ha podido reproducir 20 fotogramas, se habrá movido 20 posiciones en un segundo.

236
00:30:29,460 --> 00:30:33,519
Esto no tiene sentido porque el objeto se debería mover siempre a la misma velocidad.

237
00:30:34,960 --> 00:30:42,559
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,

238
00:30:42,559 --> 00:30:45,660
vais a ver que puede ir dando como saltitos

239
00:30:45,660 --> 00:30:47,720
porque en un fotograma

240
00:30:47,720 --> 00:30:50,319
tarda más que otro en reproducirse

241
00:30:50,319 --> 00:30:50,700
entonces

242
00:30:50,700 --> 00:30:53,819
voy a alejarme

243
00:30:53,819 --> 00:30:55,099
que como se ve el gizmo

244
00:30:55,099 --> 00:30:57,940
me voy a alejar y a lo mejor veis algún salto

245
00:30:57,940 --> 00:30:59,579
normalmente va a ser mínimo

246
00:30:59,579 --> 00:31:01,779
pero a veces se ven como tirones

247
00:31:01,779 --> 00:31:04,460
y se debe precisamente a esto que os estoy comentando

248
00:31:04,460 --> 00:31:06,279
la solución a esto

249
00:31:06,279 --> 00:31:07,359
¿cuál es?

250
00:31:07,779 --> 00:31:08,480
a ver

251
00:31:08,480 --> 00:31:11,880
usar este elemento que se llama

252
00:31:11,880 --> 00:31:23,099
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?

253
00:31:23,400 --> 00:31:33,940
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

254
00:31:33,940 --> 00:31:36,380
ese fotograma precisamente en tiempo,

255
00:31:36,480 --> 00:31:38,599
en segundos, cuánto tiempo tarda el fotograma

256
00:31:38,599 --> 00:31:40,160
en

257
00:31:40,160 --> 00:31:42,059
reproducirse.

258
00:31:42,180 --> 00:31:44,160
El tiempo que ha tardado desde el anterior hasta que

259
00:31:44,160 --> 00:31:46,539
ese se ejecuta.

260
00:31:46,799 --> 00:31:48,420
De hecho, vais a ver que si yo

261
00:31:48,420 --> 00:31:50,460
a ver, tengo todos los de Barlogs aquí ocultos.

262
00:31:50,839 --> 00:31:52,500
Que si yo voy ahora

263
00:31:52,500 --> 00:31:53,619
aquí a

264
00:31:53,619 --> 00:31:56,759
Unity, a la consola,

265
00:31:57,359 --> 00:31:58,079
veis que los valores

266
00:31:58,079 --> 00:31:59,940
van cambiando. Lo que os he dicho,

267
00:31:59,940 --> 00:32:01,440
todos los

268
00:32:01,440 --> 00:32:03,819
fotogramas tardan lo mismo, o el

269
00:32:03,819 --> 00:32:06,859
El ordenador no tiene la velocidad para hacerlo de manera constante.

270
00:32:07,500 --> 00:32:11,559
Y esto nos está dando el time delta time, es lo que estamos viendo.

271
00:32:11,700 --> 00:32:17,400
Es el valor de tiempo que transcurre entre un fotograma y el anterior realmente.

272
00:32:18,339 --> 00:32:20,640
¿Qué es lo que hace esto al multiplicarlo?

273
00:32:20,839 --> 00:32:26,220
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.

274
00:32:26,500 --> 00:32:31,640
Para que toda la multiplicación afecte a las tres, en este caso, a las tres posiciones por igual.

275
00:32:31,640 --> 00:32:37,839
y sea, por tanto, bueno, pues antes se me ha salido la palabra, equivalente, ¿no?

276
00:32:37,839 --> 00:32:41,140
Entre las tres, que no haya un eje que se mueva más rápido que otro.

277
00:32:41,380 --> 00:32:43,880
Las multiplicaciones siempre ponen el mismo valor.

278
00:32:44,359 --> 00:32:45,339
Entonces, ¿qué conseguimos?

279
00:32:45,599 --> 00:32:50,640
Y aquí pongo algún ejemplo que lo que hace esto es compensar...

280
00:32:52,279 --> 00:32:58,700
A ver, vale, esto es simplemente para daros un detalle teórico, ¿no?

281
00:32:59,220 --> 00:33:02,339
Para compensar precisamente que la velocidad de movimiento,

282
00:33:02,339 --> 00:33:14,400
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.

283
00:33:14,839 --> 00:33:27,259
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?

284
00:33:27,259 --> 00:33:42,599
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.

285
00:33:42,599 --> 00:33:52,900
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.

286
00:33:52,900 --> 00:34:11,579
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?

287
00:34:11,579 --> 00:34:19,500
esto es algo muy propio de cuando se hacen movimientos en el update y diréis por si a

288
00:34:19,500 --> 00:34:23,880
alguien le ha surgido la pregunta y por qué y por qué no dejan fijo el número de fotogramas

289
00:34:23,880 --> 00:34:29,420
que se reproducen en el juego para que siempre sea estable y nos quitamos de esta historia del

290
00:34:29,420 --> 00:34:36,539
del time delta time pues muy simple para empezar porque sí que hay otro método que ya veremos en

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

292
00:34:43,400 --> 00:34:47,380
Se pone que es 0.2 y todo lo que se ejecuta tarda 0.2.

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

294
00:34:54,340 --> 00:34:56,780
Pero está pensado para que sea fijo y estable.

295
00:34:57,500 --> 00:35:04,840
Pero el Update tiene una ventaja, que es intentar, aunque luego lo estabilicemos en algunos valores que no nos interese,

296
00:35:04,840 --> 00:35:10,179
intentar captar también por ejemplo una interacción lo antes posible vamos a ver

297
00:35:10,179 --> 00:35:15,099
que cuando nosotros pulsamos una tecla vale al final vamos a poner en el ate y

298
00:35:15,099 --> 00:35:18,400
que es el que está todo el rato escuchando cuando sucede algo vamos a

299
00:35:18,400 --> 00:35:23,320
poner que capte esa interacción aquí por ejemplo si os fijáis mismamente si

300
00:35:23,320 --> 00:35:28,420
pusiera aquí down para para que sólo capte el momento en el que pulso la

301
00:35:28,420 --> 00:35:33,820
tecla de vale va a haber un momento en el que digamos unity entiende que se ha

302
00:35:33,820 --> 00:35:38,539
pulsado cuanto antes sea ese momento es decir relacionándolo con en cuanto haya

303
00:35:38,539 --> 00:35:42,519
otro momento de reproducción cáptalo vale eso no habría que compensarlo de

304
00:35:42,519 --> 00:35:46,480
ninguna forma porque lo que queremos es que lo capte lo antes posible para que

305
00:35:46,480 --> 00:35:50,980
la interacción no tenga ningún lag o sea el mínimo vale pero luego la orden que

306
00:35:50,980 --> 00:35:54,219
ejecuta así que queremos que sea consecuente para que no dé en este caso

307
00:35:54,219 --> 00:35:58,659
tirones es decir la interacción la queremos cuanto antes vale lógicamente

308
00:35:58,659 --> 00:36:03,760
para que cuanto antes ya aquí se procesa lo que sea porque los movimientos sí que

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

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

311
00:36:14,280 --> 00:36:17,579
Eso cuanto antes también, pues lo pondremos aquí.

312
00:36:17,579 --> 00:36:22,440
Si esta booleana... cambiar, yo que sé.

313
00:36:23,599 --> 00:36:26,440
La queremos convertir en falsa, no sé, estoy haciendo aquí una chorrada.

314
00:36:26,900 --> 00:36:29,179
En cuanto le dé a la tecla D, quiero que suceda eso.

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

316
00:36:33,760 --> 00:36:49,119
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.

317
00:36:49,119 --> 00:37:11,260
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.

318
00:37:11,260 --> 00:37:31,320
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.

319
00:37:31,320 --> 00:37:43,320
¿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.

320
00:37:44,760 --> 00:37:59,079
¿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.

321
00:37:59,079 --> 00:38:09,840
¿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.

322
00:38:10,300 --> 00:38:28,960
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,

323
00:38:28,960 --> 00:38:32,139
pues luego ya lo multiplico para que vaya más rápido

324
00:38:32,139 --> 00:38:33,239
yo no quiero que vaya tan lento

325
00:38:33,239 --> 00:38:37,360
pero ya lo va a hacer en base a una velocidad

326
00:38:37,360 --> 00:38:40,039
digamos estabilizada y proporcional

327
00:38:40,039 --> 00:38:41,480
con esto yo lo aumento

328
00:38:41,480 --> 00:38:43,139
por eso ahora cuando yo le dé

329
00:38:43,139 --> 00:38:45,119
ahora que le he puesto una speed de 100

330
00:38:45,119 --> 00:38:46,539
que multiplicaba bastante

331
00:38:46,539 --> 00:38:50,000
y 100 está bien si solo estáis poniendo el time delta time

332
00:38:50,000 --> 00:38:52,219
porque fijaos, bueno de hecho sería 1000

333
00:38:52,219 --> 00:38:53,199
pero si ponemos 100

334
00:38:53,199 --> 00:38:55,599
básicamente volvemos a recuperar la unidad

335
00:38:55,599 --> 00:38:58,360
entonces digamos que es lo más equilibrado

336
00:38:58,360 --> 00:39:09,739
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.

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

338
00:39:17,340 --> 00:39:20,980
Que vaya, que a veces va a haber que multiplicarlo por mil o por más.

339
00:39:20,980 --> 00:39:24,519
y se va sumando en cada fotograma

340
00:39:24,519 --> 00:39:26,340
porque recordad que he quitado el getKeyDown

341
00:39:26,340 --> 00:39:27,900
o getKeyUp y entonces

342
00:39:27,900 --> 00:39:30,380
es el tiempo que yo mantenga esa tecla

343
00:39:30,380 --> 00:39:37,449
pulsada. Hay un

344
00:39:37,449 --> 00:39:39,469
último operador que quiero que veamos

345
00:39:39,469 --> 00:39:41,469
que es el que se llama

346
00:39:41,469 --> 00:39:41,969
módulo

347
00:39:41,969 --> 00:39:45,949
y el módulo en ocasiones

348
00:39:45,949 --> 00:39:47,590
puede ser útil y de hecho cuando

349
00:39:47,590 --> 00:39:49,670
vayamos hablando

350
00:39:49,670 --> 00:39:51,670
voy a quitar los de Barlog para que no distraigan

351
00:39:51,670 --> 00:39:53,809
y me centro en el Start, me voy aquí

352
00:39:53,809 --> 00:39:56,150
abajo y sigo. El módulo

353
00:39:56,150 --> 00:40:05,269
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.

354
00:40:05,829 --> 00:40:14,610
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,

355
00:40:15,250 --> 00:40:20,429
y si no da decimales, digamos, ese número, dará cero, y si da decimales, pues dará el resto.

356
00:40:20,429 --> 00:40:38,710
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,

357
00:40:38,710 --> 00:40:43,150
para que lo plante un segundo que lo tenía para explicarlo de otra forma pero quiero

358
00:40:43,150 --> 00:40:54,409
verlo aquí primero módulo resultante es igual a 9 de 3 y aquí lo que vamos a hacer es un de

359
00:40:54,409 --> 00:41:01,329
backlog para ver el resultado que nos está devolviendo que va a dar lo que valga módulo

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

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

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

363
00:41:25,889 --> 00:41:29,750
pero luego el resto aparecía a la izquierda, debajo de los numeritos. Vamos a hacer otro

364
00:41:29,750 --> 00:41:44,849
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.

365
00:41:44,849 --> 00:41:59,190
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.

366
00:41:59,710 --> 00:42:11,849
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.

367
00:42:12,710 --> 00:42:16,050
El resto de una división es el número que queda cuando la división no es exacta.

368
00:42:16,230 --> 00:42:19,110
Por eso, cuando no es exacta es un valor diferente a cero.

369
00:42:19,510 --> 00:42:21,869
Cuando una división tiene resto, decimos que es una división entera.

370
00:42:22,510 --> 00:42:28,269
Cuando se hace una división y digamos que el valor no queda redondo, como un número entero, va a haber un resto.

371
00:42:28,269 --> 00:42:33,630
Y ese resto es el número de unidades que han quedado sueltas hasta el siguiente valor.

372
00:42:34,610 --> 00:42:38,289
Entonces, 10 módulo 3 sería 1.

373
00:42:39,030 --> 00:42:39,690
Vamos a verlo.

374
00:42:39,690 --> 00:42:44,130
10 módulo 3

375
00:42:44,130 --> 00:42:45,650
sería igual a 1

376
00:42:45,650 --> 00:42:48,050
y le doy y lo vamos a ver

377
00:42:48,050 --> 00:42:49,949
aquí está

378
00:42:49,949 --> 00:42:51,630
el resultado del módulo es 1

379
00:42:51,630 --> 00:42:54,030
¿vale? si yo aquí pongo 11

380
00:42:54,030 --> 00:42:55,730
el resto serán 2, porque

381
00:42:55,730 --> 00:42:58,130
9 entre 3 da el resultado y sobran

382
00:42:58,130 --> 00:43:00,150
2, ese es el resto, por eso de hecho

383
00:43:00,150 --> 00:43:02,030
se llama así, ¿vale? ahora

384
00:43:02,030 --> 00:43:04,130
vamos a ver que el resultado del módulo

385
00:43:04,130 --> 00:43:06,090
es 2, ¿qué pasa si yo lo pongo

386
00:43:06,090 --> 00:43:08,070
en 12? que el resto volverá

387
00:43:08,070 --> 00:43:09,949
a ser 2, no, perdón

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

389
00:43:19,449 --> 00:43:23,570
importante y diréis, ¿esto para qué sirve? Pues fijaos, por ejemplo, que si cualquier

390
00:43:23,570 --> 00:43:30,710
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

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

392
00:43:35,070 --> 00:43:47,250
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.

393
00:43:47,630 --> 00:43:58,190
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,

394
00:43:58,190 --> 00:44:14,010
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,

395
00:44:14,070 --> 00:44:28,230
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,

396
00:44:28,230 --> 00:44:47,389
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.

397
00:44:47,389 --> 00:44:59,489
vamos a este código de aquí vamos aquí que aquí yo he puesto lo que es un método y voy a poner

398
00:44:59,489 --> 00:45:08,550
voy a seguir en esta en este que tengo aquí que lo tengo más recogido cuando vosotros empleáis

399
00:45:08,550 --> 00:45:16,289
después de una clase ponéis un punto vale o va a poner que es un método vale que son estos pues

400
00:45:16,289 --> 00:45:21,210
translate por ejemplo que aquí en este caso primero tienen una clase como transforme input

401
00:45:21,210 --> 00:45:29,929
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.

402
00:45:30,550 --> 00:45:40,130
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,

403
00:45:40,630 --> 00:45:46,429
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.

404
00:45:46,429 --> 00:46:10,829
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.

405
00:46:10,829 --> 00:46:26,210
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.

406
00:46:26,210 --> 00:46:45,510
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.

407
00:46:45,510 --> 00:46:52,750
si ponemos fuera es decir fuera de otro método que haya vale la declaración de

408
00:46:52,750 --> 00:46:57,389
métodos si os fijáis aquí está voy de start vamos y esa llave cierra y aquí

409
00:46:57,389 --> 00:47:02,530
dentro habrá unas instrucciones luego se abre otro void que cierra en sí mismo y

410
00:47:02,530 --> 00:47:05,750
tendrá sus instrucciones nosotros vamos a hacer ahora otro conjunto de

411
00:47:05,750 --> 00:47:12,130
instrucciones. Podemos hacer un método que se llame

412
00:47:12,349 --> 00:47:18,670
recogeCódigo. ¿Vale? Veis que cuando escribimos después de

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

414
00:47:23,730 --> 00:47:31,070
letra, ¿vale? Y bueno, con pascal case, ¿no? Y posteriormente se pone este paréntesis.

415
00:47:31,070 --> 00:47:35,690
La sintaxis continúa con unas llaves. ¿Qué es lo que acabamos de hacer? Hemos hecho un

416
00:47:35,690 --> 00:47:40,789
método que lo que hace es en base a este nombre vamos a poder ejecutar un código

417
00:47:40,789 --> 00:47:44,389
que va a estar aquí dentro y lo vamos a poder llamar siempre que queramos igual

418
00:47:44,389 --> 00:47:48,929
que aquí cuando ponemos translate o el otro día poníamos instantiate vale que

419
00:47:48,929 --> 00:47:52,570
es otro método instantiate y por eso vais a ver también que se pone en

420
00:47:52,570 --> 00:47:58,369
amarillo le falta poner lo que nos pide pero ahí está vale este código una vez

421
00:47:58,369 --> 00:48:02,570
se ha declarado así con este void pues yo puedo ahora en otro momento en otro

422
00:48:02,570 --> 00:48:05,510
momento de ejecución vale porque ahora mismo esto no se está ejecutando en

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

424
00:48:12,130 --> 00:48:19,070
hay distintos, pero dentro del update yo voy a decir quiero que se ejecute en cada fotograma,

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

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

427
00:48:29,989 --> 00:48:37,730
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.

428
00:48:38,670 --> 00:48:49,530
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.

429
00:48:49,530 --> 00:48:54,530
Y como lo he cambiado, disparo.

430
00:48:54,530 --> 00:49:15,679
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?

431
00:49:15,679 --> 00:49:28,360
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

432
00:49:28,360 --> 00:49:37,980
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

433
00:49:37,980 --> 00:49:46,420
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,

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

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

436
00:50:03,000 --> 00:50:18,139
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.

437
00:50:18,139 --> 00:50:37,099
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.

438
00:50:37,099 --> 00:50:55,800
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.

439
00:50:55,800 --> 00:51:07,099
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.

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

441
00:51:13,119 --> 00:51:23,880
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.

442
00:51:23,880 --> 00:51:26,400
igual, disparo cuando me agacho

443
00:51:26,400 --> 00:51:27,780
cuando apunto y cuando tal

444
00:51:27,780 --> 00:51:29,239
y se van dando muchas condiciones

445
00:51:29,239 --> 00:51:31,719
entonces ir copiando todo el rato el mismo código

446
00:51:31,719 --> 00:51:32,920
es un tostón

447
00:51:32,920 --> 00:51:36,000
¿qué conseguimos con esto? que simplemente poniendo

448
00:51:36,000 --> 00:51:38,219
la llamada, el disparo, pues lo pongo aquí

449
00:51:38,219 --> 00:51:40,019
y que luego aquí hay otra condición que disparo

450
00:51:40,019 --> 00:51:40,639
pues la copio aquí

451
00:51:40,639 --> 00:51:44,139
y que tengo que cambiar algo de disparo, pues de manera tal

452
00:51:44,139 --> 00:51:44,880
lo cambio aquí

453
00:51:44,880 --> 00:51:48,320
entonces es una forma de ir organizando

454
00:51:48,320 --> 00:51:48,940
los

455
00:51:48,940 --> 00:51:51,960
bueno pues los

456
00:51:51,960 --> 00:51:56,800
el uso de nuestro trabajo, ¿vale?

457
00:51:57,699 --> 00:52:01,199
Eso es la primera función de un método,

458
00:52:01,679 --> 00:52:04,460
organizar, organizar y conseguir ir, digamos,

459
00:52:04,579 --> 00:52:08,460
encapsulando instrucciones que pueden ser de muchísimas líneas

460
00:52:08,460 --> 00:52:10,960
para que solo con una llamada a ese método

461
00:52:10,960 --> 00:52:12,559
se ejecute lo que hay adentro.

462
00:52:13,400 --> 00:52:16,559
Luego empieza a complicarse, porque como hemos dicho antes,

463
00:52:16,559 --> 00:52:20,360
los métodos, entre sus paréntesis, pueden pedir cosas.

464
00:52:20,360 --> 00:52:46,239
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.

465
00:52:46,239 --> 00:52:49,119
¿vale? esto ¿cómo se hace?

466
00:52:49,900 --> 00:52:50,860
y es simple en realidad

467
00:52:50,860 --> 00:52:53,099
si lo pensamos, de primeras puede costar

468
00:52:53,099 --> 00:52:54,960
pero es simple, igual que declaramos

469
00:52:54,960 --> 00:52:56,960
variables y primero hay que decir

470
00:52:56,960 --> 00:52:59,199
de qué tipo es la variable y luego el nombre de la variable

471
00:52:59,199 --> 00:53:00,900
¿no? aquí

472
00:53:00,900 --> 00:53:02,900
también podemos estar pidiendo lo que se

473
00:53:02,900 --> 00:53:04,719
llaman parámetros ¿vale?

474
00:53:04,860 --> 00:53:06,800
dentro del método se pueden pedir

475
00:53:06,800 --> 00:53:09,039
parámetros y en disparo

476
00:53:09,039 --> 00:53:10,360
¿qué nos puede interesar?

477
00:53:11,880 --> 00:53:13,039
pues por ejemplo

478
00:53:13,039 --> 00:53:14,980
yo que sé, voy a poner

479
00:53:14,980 --> 00:53:26,800
cosas un poco abstractas pero por ejemplo puedo pedir el tipo de de arma no sé vale entonces para

480
00:53:26,800 --> 00:53:36,739
que voy a dejarme poner el código luego lo vemos tipo de arma vale cuando creamos este string

481
00:53:36,739 --> 00:53:42,739
estamos diciendo que cuando llegue a este momento y veis que ahora da fallo porque hemos pedido un

482
00:53:42,739 --> 00:53:47,239
parámetro vale cuando se declara se llaman parámetros y cuando luego nos lo

483
00:53:47,239 --> 00:53:52,400
pida se llamarán argumentos vale que si en algún momento leís pasa un argumento

484
00:53:52,400 --> 00:53:56,059
al método o un parámetro bueno pues que sepáis que se refiere básicamente en dos

485
00:53:56,059 --> 00:53:59,840
puntos distintos a lo que hay entre paréntesis vale pero veis que en cuanto

486
00:53:59,840 --> 00:54:06,460
yo ya declaró un un tipo de parámetro ya obligatoriamente

487
00:54:06,460 --> 00:54:10,780
a no ser que declare otro que esté vacío vale

488
00:54:10,780 --> 00:54:15,019
directamente va a dar error si no decimos ese parámetro que es un poco lo

489
00:54:15,019 --> 00:54:19,400
que está pasando aquí con translate si lo vaciamos vale que cuando está

490
00:54:19,400 --> 00:54:24,019
declarado translate si os fijáis y mirad lo que sale ahí que es lo mismo también

491
00:54:24,019 --> 00:54:30,059
que sale en la documentación de unity pone transport punto translate y entre

492
00:54:30,059 --> 00:54:34,539
paréntesis tiene que pasar una variable o un elemento de vector 3 llama

493
00:54:34,539 --> 00:54:39,659
translation vale y otro de espacio que se llama related to y luego más 5

494
00:54:39,659 --> 00:54:45,059
sobrecargas vale si os fijáis en la documentación que lo estábamos viendo antes y por eso también

495
00:54:45,059 --> 00:54:53,340
es muy útil me meto en transportas ley tener el lápiz de scripting aquí este método está

496
00:54:53,340 --> 00:55:00,239
declarado de dos formas vale tiene dos formas de actuar y bueno y si seguimos bajando de hecho

497
00:55:00,239 --> 00:55:06,920
tenemos dos luego hay otra aquí otras dos más luego hay otra aquí ya llevamos cinco otra aquí

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

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

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

501
00:55:31,639 --> 00:55:35,920
de pasar valores, de pasar argumentos a este método

502
00:55:35,920 --> 00:55:38,239
para que luego los ejecute de una forma u otra.

503
00:55:38,500 --> 00:55:41,059
¿Os acordáis el otro día, la tarea de la unidad 1,

504
00:55:41,059 --> 00:55:46,059
que había tres formas de rellenar estos paréntesis

505
00:55:46,619 --> 00:55:51,159
y según de lo que pusiéramos en la instancia se hacía hija

506
00:55:51,159 --> 00:55:56,500
del GameObjectPadre o no se cogía otra referencia?

507
00:55:56,780 --> 00:56:00,260
Eso significa, porque cuando se diseñó ese InstanceAid,

508
00:56:01,639 --> 00:56:12,039
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.

509
00:56:13,320 --> 00:56:30,500
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.

510
00:56:31,639 --> 00:56:33,159
Y eso es lo que se llaman sobrecargas.

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

512
00:56:37,860 --> 00:56:38,739
Fijaos todo lo que tiene.

513
00:56:39,400 --> 00:56:42,880
Por eso, dependiendo, si lo que pasabais era una variable tipo transform,

514
00:56:43,059 --> 00:56:44,300
lo considera como un padre.

515
00:56:45,300 --> 00:56:50,280
Si lo que pasáis como segundo parámetro es un vector 3,

516
00:56:50,780 --> 00:56:53,559
lo que hace es que no hay ningún padre y por eso no se hacía hijo

517
00:56:53,559 --> 00:56:57,500
y lo que va a poner es la posición de que estamos pasando aquí.

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

519
00:57:04,820 --> 00:57:10,599
Primero, que aquí lo que pongamos obliga a que luego haya que cumplir al llamar a ese método

520
00:57:10,599 --> 00:57:13,920
Porque lo que se puede hacer, y por eso puede haber sobrecargas

521
00:57:13,920 --> 00:57:19,880
Yo puedo hacer un disparo sin pedir argumentos en su interior, sin pedir parámetros

522
00:57:19,880 --> 00:57:21,940
Y ahora no da fallo

523
00:57:21,940 --> 00:57:25,940
Porque si yo pongo este disparo en este punto, lo que va a buscar es en este

524
00:57:25,940 --> 00:57:38,780
Y aquí puedo poner, de backlog, sin argumentos, ¿vale?

525
00:57:40,280 --> 00:57:52,320
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?

526
00:57:52,320 --> 00:58:03,119
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.

527
00:58:03,679 --> 00:58:04,239
Le voy a dar.

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

529
00:58:11,179 --> 00:58:20,599
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?

530
00:58:21,420 --> 00:58:29,619
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.

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

532
00:58:34,360 --> 00:58:41,159
Pues va a poner en cada fotograma, va a poner sin argumentos, correspondiente a este, ¿sí?

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

534
00:58:47,460 --> 00:59:16,380
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í,

535
00:59:16,380 --> 00:59:18,940
llega a este punto y dice que objeto instancio

536
00:59:18,940 --> 00:59:20,400
y aquí dentro es donde lo instancia

537
00:59:20,400 --> 00:59:22,760
pero gracias a estos paréntesis se hace el puente

538
00:59:22,760 --> 00:59:24,820
entre lo que se está llamando

539
00:59:24,820 --> 00:59:26,860
y otro valor

540
00:59:26,860 --> 00:59:29,019
o varios como hemos visto separados por coma

541
00:59:29,019 --> 00:59:30,679
que se ejecutan en su interior

542
00:59:30,679 --> 00:59:32,619
y la gracia es

543
00:59:32,619 --> 00:59:34,860
conectar cuando llamamos

544
00:59:34,860 --> 00:59:37,079
meter un valor del mismo

545
00:59:37,079 --> 00:59:38,480
tipo de lo que tengamos aquí

546
00:59:38,480 --> 00:59:40,639
y luego dentro de ese método

547
00:59:40,639 --> 00:59:43,019
ese tipo, ese valor

548
00:59:43,019 --> 00:59:44,880
que ha entrado se llamará esa variable

549
00:59:44,880 --> 00:59:48,539
hay que referenciarla con el nombre que habíamos puesto a este parámetro.

550
00:59:49,039 --> 00:59:52,019
Es decir, esto sirve para decir, cada vez que ponemos un argumento,

551
00:59:52,059 --> 00:59:56,460
y ya os digo que pueden ser varios, puede ser un string y un flow llamado numerazo,

552
00:59:56,619 --> 00:59:58,099
yo qué sé, por poner un nombre llamativo.

553
00:59:58,739 --> 01:00:01,619
Ahora da error porque nos faltaría aquí el numerazo.

554
01:00:01,780 --> 01:00:06,599
Ahora no hay ninguna variable, ningún método, perdonad, que solo tenga un argumento.

555
01:00:07,420 --> 01:00:13,039
Entonces, hasta que no pongamos en este caso un número, pues da error nuevamente

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

557
01:00:19,980 --> 01:00:28,940
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,

558
01:00:29,500 --> 01:00:36,139
da error porque tiene que ir en el mismo orden en el que se están declarando esos parámetros.

559
01:00:36,139 --> 01:01:00,239
¿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í.

560
01:01:00,239 --> 01:01:24,780
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?

561
01:01:24,780 --> 01:01:43,260
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.

562
01:01:43,260 --> 01:01:50,360
Entonces vais a ver que eso se está todo el rato ejecutando así

563
01:01:50,360 --> 01:01:54,840
Y veis que de manera interactiva se están adaptando los valores

564
01:01:54,840 --> 01:01:59,739
Todo esto es pensar para usarlo a nuestros intereses

565
01:01:59,739 --> 01:02:06,460
Pero si por ejemplo tenemos un enemigo que le queremos ir quitando según

566
01:02:06,460 --> 01:02:10,199
Pues yo que sé, tenemos un personaje con una espada y una escopeta

567
01:02:10,199 --> 01:02:12,599
Y el método se llama daña

568
01:02:12,599 --> 01:02:43,079
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.

569
01:02:43,079 --> 01:02:44,579
Disparo sería

570
01:02:44,579 --> 01:02:47,320
Espada, vale, y el valor

571
01:02:47,320 --> 01:02:49,320
De daño que quita, vale, la da con la espada

572
01:02:49,320 --> 01:02:51,480
Y el valor que quita de vida es 10

573
01:02:51,480 --> 01:02:52,440
Vale

574
01:02:52,440 --> 01:02:55,079
Si no, yo que sé

575
01:02:55,079 --> 01:02:57,199
Imaginaos que si no, la otra variable es

576
01:02:57,199 --> 01:02:58,480
Si le golpea

577
01:02:58,480 --> 01:03:01,280
O si no, si le golpea

578
01:03:01,280 --> 01:03:01,579
Con

579
01:03:01,579 --> 01:03:05,599
Martillo

580
01:03:05,599 --> 01:03:06,079
Yo que sé

581
01:03:06,079 --> 01:03:08,599
¿Qué hace más daño?

582
01:03:08,760 --> 01:03:09,400
Pues aquí

583
01:03:09,400 --> 01:03:12,179
Lo que pondríamos es

584
01:03:12,179 --> 01:03:34,880
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.

585
01:03:34,880 --> 01:03:37,400
pensad otra vez en el instant seed

586
01:03:37,400 --> 01:03:38,900
el instant seed es un método

587
01:03:38,900 --> 01:03:41,219
que luego hará lo que sea con los elementos

588
01:03:41,219 --> 01:03:42,699
que le vamos dando en sus paréntesis

589
01:03:42,699 --> 01:03:45,119
que en cada ocasión, en este caso es una nave

590
01:03:45,119 --> 01:03:47,559
pero podría ser un prefab de una casa

591
01:03:47,559 --> 01:03:49,480
o de los pivotes

592
01:03:49,480 --> 01:03:50,179
que hay ahora en esta

593
01:03:50,179 --> 01:03:52,559
tarea que hay que esquivar

594
01:03:52,559 --> 01:03:54,780
eso es para lo que sirve

595
01:03:54,780 --> 01:03:57,239
definir que cada vez que llamemos

596
01:03:57,239 --> 01:03:59,340
al método, según el momento en el que estemos

597
01:03:59,340 --> 01:04:01,420
con un mismo nombre de método

598
01:04:01,420 --> 01:04:03,000
podemos pasar un montón de

599
01:04:03,000 --> 01:04:05,380
diferentes

600
01:04:05,380 --> 01:04:08,320
datos, elementos, variables, lo que queramos.

601
01:04:08,320 --> 01:04:11,679
Voy a hacer otro ejemplo.

602
01:04:11,679 --> 01:04:14,739
Voy a hacer una pequeña calculadora

603
01:04:14,739 --> 01:04:18,280
y entonces lo que voy a hacer es declarar

604
01:04:18,280 --> 01:04:22,219
un método llamado calculadora.

605
01:04:22,219 --> 01:04:24,380
De momento sin nada

606
01:04:24,380 --> 01:04:28,460
de parámetros, de argumentos.

607
01:04:28,460 --> 01:04:29,539
Entonces

608
01:04:29,539 --> 01:04:30,940
al arrancar

609
01:04:30,940 --> 01:04:32,800
yo lo que voy a hacer es decir

610
01:04:32,800 --> 01:04:54,280
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.

611
01:04:54,280 --> 01:05:13,239
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.

612
01:05:13,239 --> 01:05:16,760
y según eso

613
01:05:16,760 --> 01:05:20,699
luego nos devuelve

614
01:05:20,699 --> 01:05:21,860
de backlog

615
01:05:21,860 --> 01:05:26,980
el resultado es

616
01:05:26,980 --> 01:05:30,409
más resultado

617
01:05:30,409 --> 01:05:32,190
¿qué ocurre?

618
01:05:32,190 --> 01:05:34,469
he creado un método

619
01:05:34,469 --> 01:05:36,210
y aquí lo que voy a decir

620
01:05:36,210 --> 01:05:37,010
es en el start

621
01:05:37,010 --> 01:05:39,070
me haces calculadora

622
01:05:39,070 --> 01:05:41,050
esto

623
01:05:41,050 --> 01:05:45,409
cuando empieza el juego

624
01:05:45,409 --> 01:05:46,150
en el start dice

625
01:05:46,150 --> 01:05:53,789
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?

626
01:05:53,809 --> 01:06:01,449
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?

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

628
01:06:11,670 --> 01:06:30,489
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í.

629
01:06:30,489 --> 01:06:50,309
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.

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

631
01:06:56,429 --> 01:07:04,469
Lo primero que va a suceder es que por mucho que, aunque pongamos aquí número C y número D, ¿vale?

632
01:07:04,949 --> 01:07:07,369
Aquí estamos referenciando a número A y número B, ¿vale?

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

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

635
01:07:17,349 --> 01:07:35,190
¿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?

636
01:07:36,150 --> 01:07:39,369
Cuidado, tiene que ser del mismo tipo de variable, ¿vale?

637
01:07:39,869 --> 01:07:40,650
Del mismo variable.

638
01:07:40,829 --> 01:07:47,449
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?

639
01:07:47,449 --> 01:07:51,070
Si quisiéramos un float, habría que poner aquí que esto sea un float, ¿vale?

640
01:07:51,070 --> 01:07:51,809
Y ahí no da el problema.

641
01:07:52,710 --> 01:07:52,869
Vale.

642
01:07:53,369 --> 01:07:56,610
Entonces, 7 y 9.

643
01:07:57,289 --> 01:07:57,730
Vale.

644
01:07:58,150 --> 01:07:59,369
¿Qué va a hacer ahora calculadora?

645
01:07:59,449 --> 01:08:00,010
¿Qué va a devolver?

646
01:08:00,909 --> 01:08:05,030
Algo va a devolver, porque va a entrar aquí y va a ver esto.

647
01:08:05,190 --> 01:08:05,949
Y lo va a ejecutar.

648
01:08:06,030 --> 01:08:08,769
Y hay un debug log que no hay ningún condicional y se va a aplicar.

649
01:08:08,869 --> 01:08:10,349
Así que va a poner el resultado es.

650
01:08:11,190 --> 01:08:11,949
¿Y qué resultado?

651
01:08:14,489 --> 01:08:14,849
12.

652
01:08:15,050 --> 01:08:15,389
¿Por qué?

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

654
01:08:21,850 --> 01:08:21,930
¿Vale?

655
01:08:21,989 --> 01:08:24,010
Esto de momento no hemos conseguido nada.

656
01:08:24,010 --> 01:08:27,390
Lo conseguimos en el momento en el que llamamos a estos dos valores.

657
01:08:27,770 --> 01:08:29,689
A D, por ejemplo, aquí, y aquí a C.

658
01:08:30,689 --> 01:08:30,850
¿Vale?

659
01:08:31,069 --> 01:08:32,430
¿Ahora qué valor va a dar esto?

660
01:08:36,310 --> 01:08:36,670
16.

661
01:08:36,670 --> 01:08:54,430
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?

662
01:08:54,430 --> 01:09:14,189
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.

663
01:09:14,189 --> 01:09:32,270
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.

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

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

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

667
01:09:56,170 --> 01:10:06,300
quiero que haga varios cálculos calculadora pues va a hacer 100 más 100 5 calculadora

668
01:10:09,590 --> 01:10:16,930
22 y así podría hacer muchos que va a suceder ahora que al arrancar el juego va a poner tres

669
01:10:16,930 --> 01:10:23,850
líneas con los resultados de estas sumas porque lo hemos configurado así porque son los argumentos

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

671
01:10:29,510 --> 01:10:37,449
aquí. Entonces va a salir primero 16, luego 105 y luego 22. Guardo 16, 105 y 22. Y veis

672
01:10:37,449 --> 01:10:42,010
que de una forma, con poco esfuerzo, ya tenemos una calculadora. Pongamos lo que pongamos

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

674
01:10:46,750 --> 01:10:52,729
que se instancian o a lo que sea, pues con una sola línea podemos referenciar, y este

675
01:10:52,729 --> 01:10:54,510
código muy simple, pero podríamos tener uno

676
01:10:54,510 --> 01:10:56,529
súper complejo en el que luego

677
01:10:56,529 --> 01:10:58,409
número D cambie, metamos

678
01:10:58,409 --> 01:11:00,229
el número A y le restamos el C,

679
01:11:00,729 --> 01:11:02,670
que ahí sí que está cogiendo un valor global

680
01:11:02,670 --> 01:11:04,630
de todo el juego con el que estamos

681
01:11:04,630 --> 01:11:06,409
pasando por los argumentos, ¿vale?

682
01:11:06,489 --> 01:11:07,829
Y va operando en base a eso.

683
01:11:08,609 --> 01:11:10,649
Vale. Voy un paso

684
01:11:10,649 --> 01:11:12,529
más allá. Aquí se pueden ir añadiendo

685
01:11:12,529 --> 01:11:14,810
más métodos. Si yo, por ejemplo,

686
01:11:14,909 --> 01:11:16,710
aquí hago... Si yo pongo aquí número E

687
01:11:16,710 --> 01:11:18,430
y yo programo

688
01:11:18,430 --> 01:11:20,529
para que el resultado luego sea...

689
01:11:20,529 --> 01:11:29,199
y voy a poner otro float que es resultado tras multiplicar, ¿vale?

690
01:11:29,800 --> 01:11:35,060
Si yo aquí a resultado, luego digo, vale, resultado ya lo tengo aquí,

691
01:11:35,180 --> 01:11:37,899
entonces voy a hacer otro que se llama resultado tras multiplicar,

692
01:11:37,899 --> 01:11:43,239
que va a ser igual a lo que ya teníamos en resultado por el número e,

693
01:11:43,420 --> 01:11:44,920
que es el siguiente valor, ¿vale?

694
01:11:45,579 --> 01:11:50,899
Ahora el problema que va a haber es que necesitamos poner otro argumento,

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

696
01:12:01,880 --> 01:12:05,140
Y aquí habría que poner que lo que muestra es resultado tras multiplicar.

697
01:12:05,140 --> 01:12:09,600
Aquí lo que hemos conseguido es que se vayan haciendo más operaciones.

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

699
01:12:15,260 --> 01:12:34,359
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.

700
01:12:34,359 --> 01:12:55,380
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.

701
01:12:55,380 --> 01:13:11,279
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.

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

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

704
01:13:23,000 --> 01:13:27,840
Que tenga lo que sea dentro y tú luego aquí también puedes llamar a disparo.

705
01:13:28,500 --> 01:13:33,260
Entonces, si se cumple tal cosa, pues disparo ocurre tal, si no, la otra.

706
01:13:33,819 --> 01:13:37,140
Que se pueden ir intrincando ya muchas operaciones.

707
01:13:37,140 --> 01:13:53,579
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.

708
01:13:53,579 --> 01:14:05,699
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.

709
01:14:06,100 --> 01:14:16,619
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.

710
01:14:16,619 --> 01:14:32,720
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.

711
01:14:32,720 --> 01:14:42,479
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?

712
01:14:42,479 --> 01:14:53,260
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.

713
01:14:53,260 --> 01:15:17,840
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,

714
01:15:17,840 --> 01:15:28,180
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?

715
01:15:28,680 --> 01:15:47,640
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?

716
01:15:47,840 --> 01:16:04,199
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.

717
01:16:05,060 --> 01:16:14,300
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.

718
01:16:14,300 --> 01:16:27,720
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,

719
01:16:27,720 --> 01:16:45,899
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.

720
01:16:45,899 --> 01:17:03,000
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.

721
01:17:03,000 --> 01:17:20,560
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í?

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

723
01:17:29,199 --> 01:17:35,300
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,

724
01:17:35,300 --> 01:17:43,319
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.

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

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

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

728
01:18:02,359 --> 01:18:10,260
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.

729
01:18:10,260 --> 01:18:19,020
Y ahora si nos fijamos, lo que va a devolver la consola es un 7.

730
01:18:19,439 --> 01:18:34,939
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.

731
01:18:34,939 --> 01:19:00,300
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.

732
01:19:00,300 --> 01:19:16,720
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.

733
01:19:16,720 --> 01:19:30,640
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.

734
01:19:31,659 --> 01:19:37,260
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.

735
01:19:37,520 --> 01:19:45,779
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.

736
01:19:45,779 --> 01:19:48,180
por ejemplo aquí, lo que tenemos aquí

737
01:19:48,180 --> 01:19:50,560
voy a copiar esta y lo voy a pegar

738
01:19:50,560 --> 01:19:52,699
aquí, en el otro que teníamos

739
01:19:52,699 --> 01:19:53,920
y así lo vamos a ver más claro

740
01:19:53,920 --> 01:19:56,779
tu tu y tu tu

741
01:19:56,779 --> 01:19:58,000
vale

742
01:19:58,000 --> 01:19:59,560
en start

743
01:19:59,560 --> 01:20:02,899
spar y lo copio

744
01:20:02,899 --> 01:20:04,460
de aquí, que la tenía

745
01:20:04,460 --> 01:20:06,560
que estaba preparada, fijaos en este

746
01:20:06,560 --> 01:20:10,060
ejemplo, vale

747
01:20:10,060 --> 01:20:10,939
tu tu

748
01:20:10,939 --> 01:20:14,460
y voy a poner que integer, voy a hacer otra

749
01:20:14,460 --> 01:20:16,560
variable llamada integer, que es como se

750
01:20:16,560 --> 01:20:25,500
aquí que en principio vale 5 vale y bueno luego ahí mi mensaje que es bueno vamos a ver como unos

751
01:20:25,500 --> 01:20:33,420
métodos se intrincan en otros viene bien el mensaje vale vamos a ver así rápido esto yo

752
01:20:33,420 --> 01:20:40,680
tengo un código que he creado dos métodos para funciones para llamarlos cuando me interese no

753
01:20:40,680 --> 01:20:57,739
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.

754
01:20:57,739 --> 01:21:07,199
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.

755
01:21:08,500 --> 01:21:20,460
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.

756
01:21:20,460 --> 01:21:36,579
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?

757
01:21:36,579 --> 01:21:58,500
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?

758
01:21:58,500 --> 01:22:07,520
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.

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

760
01:22:18,760 --> 01:22:20,239
Aquí es lo que he dicho antes.

761
01:22:20,460 --> 01:22:22,800
Está al revés y esto debería ser false y esto true.

762
01:22:24,100 --> 01:22:27,840
Ahora, esto es false.

763
01:22:28,500 --> 01:22:55,859
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.

764
01:22:55,859 --> 01:23:03,359
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.

765
01:23:04,539 --> 01:23:13,899
Entonces, ahora mismo, por poner que este valor es 5, va a mostrar que mi mensaje, myInteger, es impar.

766
01:23:14,359 --> 01:23:19,659
Vamos a verlo. Y yo ahora veo esto. Y aquí vemos myInteger is par.

767
01:23:19,659 --> 01:23:37,359
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.

768
01:23:37,359 --> 01:23:40,899
si íntegre es

769
01:23:40,899 --> 01:23:42,760
igual a falso

770
01:23:42,760 --> 01:23:45,060
¿vale? es decir, esto es un valor

771
01:23:45,060 --> 01:23:46,960
booleano, si este es igual que este

772
01:23:46,960 --> 01:23:48,859
va a decir que

773
01:23:48,859 --> 01:23:50,720
esto está al revés también

774
01:23:50,720 --> 01:23:53,020
es impar, ¿vale? y si no, ¿qué es par?

775
01:23:53,560 --> 01:23:54,340
entonces ahora

776
01:23:54,340 --> 01:23:56,300
cuando yo vaya aquí

777
01:23:56,300 --> 01:23:58,500
pues nuevamente

778
01:23:58,500 --> 01:24:01,140
la íntegre es par, bueno, estoy todo el rato

779
01:24:01,140 --> 01:24:03,020
como dando vueltas, porque

780
01:24:03,020 --> 01:24:05,220
si lo que

781
01:24:05,220 --> 01:24:06,939
pasamos aquí es igual a

782
01:24:06,939 --> 01:24:39,060
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,

783
01:24:39,079 --> 01:24:42,960
par, ¿vale? Entonces, con esta operación lo que hacemos, por ejemplo, es

784
01:24:42,960 --> 01:24:46,760
por un lado, definir si esto es verdadero o falso, una booleana,

785
01:24:47,119 --> 01:24:51,140
porque aquí estamos llevándolo a esto de que sea algo verdadero o falso en relación a si

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

787
01:24:55,100 --> 01:24:59,279
con poner la palabra return cuando no es un void. Y una vez

788
01:24:59,279 --> 01:25:03,220
se comprueba ese valor, ¿vale? En realidad se podría poner aquí, porque

789
01:25:03,220 --> 01:25:06,739
también se llama aquí, si lo que devuelve este método es

790
01:25:06,739 --> 01:25:08,979
falso en este caso, llamo

791
01:25:08,979 --> 01:25:10,800
a otro método, en vez de poner el debug log

792
01:25:10,800 --> 01:25:12,920
aquí directamente, porque se podrían poner

793
01:25:12,920 --> 01:25:14,920
más operaciones, que

794
01:25:14,920 --> 01:25:16,760
conecte con ese mensaje

795
01:25:16,760 --> 01:25:26,050
que es el que va a mostrar. Voy a ir

796
01:25:26,050 --> 01:25:28,170
a una escena que yo tenía aquí preparada

797
01:25:28,170 --> 01:25:28,489
con

798
01:25:28,489 --> 01:25:34,569
una escena con

799
01:25:34,569 --> 01:25:38,189
la nave. Aquí estamos.

800
01:25:38,970 --> 01:25:40,029
¿Vale? Cosas

801
01:25:40,029 --> 01:25:41,590
a tener en cuenta.

802
01:25:41,590 --> 01:25:46,810
entiendo que ya todos tenéis claro pues cómo se instancia un objeto aquí no hace falta que

803
01:25:46,810 --> 01:25:51,489
instancia y la nave puede estar ya desde el principio en el espacio vale aquí preparada

804
01:25:51,489 --> 01:25:59,409
porque en su momento era yo tan pesado con que el prefab vale este prefab estuviera en el 0 0 0 vale

805
01:25:59,409 --> 01:26:06,609
porque así al empezar el juego si está centrado y le instancia mos en el centro vale si toda rotación

806
01:26:06,609 --> 01:26:12,010
la hacemos en base a su centro vale no va a dar problemas de que a lo mejor pongamos el

807
01:26:12,010 --> 01:26:19,270
el ritmo el elemento de referencia en un ala y gire como desviado un poco vale entonces cuando

808
01:26:19,270 --> 01:26:24,449
hagamos cualquier elemento no sólo éste sino cualquiera en sí el prefab vale a no ser que

809
01:26:24,449 --> 01:26:29,850
hagamos aposta debería tener igual que cuando trabajáis en 3d al modelar etcétera ponéis el

810
01:26:29,850 --> 01:26:35,609
punto de ancla en donde queréis que gire pues hay que tenerlo en cuenta también para que esté en

811
01:26:35,609 --> 01:26:40,649
ese punto y el giro se haga con respecto a donde queráis. Si por ejemplo modeláis una muñeca y el

812
01:26:40,649 --> 01:26:45,329
punto de ancla con el que gira está en el hombro pues va a girar mal. Estos son conceptos que

813
01:26:45,329 --> 01:26:51,930
entiendo que del módulo animación tenéis claros. Y para simplificar ahora ciertas acciones los

814
01:26:51,930 --> 01:26:58,010
suyos que hagáis, esta nave la situéis, esta nave que recordemos no se va a mover en profundidad

815
01:26:58,010 --> 01:27:02,630
sino hacia arriba, abajo, izquierda, derecha, que la situéis en el cero en todos los ejes menos,

816
01:27:02,630 --> 01:27:19,670
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?

817
01:27:19,670 --> 01:27:40,369
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?

818
01:27:40,369 --> 01:28:08,970
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í.

819
01:28:08,970 --> 01:28:28,729
¿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.

820
01:28:28,729 --> 01:28:33,310
pero al menos nos da una relación de dónde van a salir esos pivotes, etc.

821
01:28:35,609 --> 01:28:39,890
Os explico una cosa muy rápida también para que no sea todo tan blanco y se vea mejor

822
01:28:39,890 --> 01:28:44,689
que es que para dar color, esto ya se verá más adelante en más detalle

823
01:28:44,689 --> 01:28:48,909
pero para darle un color a un elemento, por ejemplo al suelo y que no sea igual que la nave

824
01:28:48,909 --> 01:28:53,449
en este blanco impoluto, en una carpeta lo suyo de materiales o de lo que queráis

825
01:28:53,449 --> 01:28:57,689
con clic derecho podemos crear, entre otros elementos, un material

826
01:28:57,689 --> 01:29:03,930
vale un material para la visualización de un objeto entonces material voy a llamar suelo vale

827
01:29:03,930 --> 01:29:08,970
este es el material que vamos a con el que vamos a colorear el suelo cuando metéis en un material

828
01:29:08,970 --> 01:29:14,430
que salen con este icono que tenemos aquí vale estoy ampliando y reduciendo con este slider o

829
01:29:14,430 --> 01:29:20,609
con control y la ruleta vale se hacen más grandes o más pequeños entre sus parámetros que hay muchos

830
01:29:20,609 --> 01:29:25,770
ya lo veremos hay uno que dice el albedo que estoy imagino que os suena también de el módulo de color

831
01:29:25,770 --> 01:29:33,189
El albedo que es el color base, digamos, antes de ser afectado por reflejos, por metalicidad, etcétera

832
01:29:33,189 --> 01:29:37,989
Podemos cambiarlo de color y decir que sea, en este caso lo voy a poner un gris

833
01:29:37,989 --> 01:29:41,430
Un gris azulado, da igual, si es para que se distinga, ¿vale?

834
01:29:41,770 --> 01:29:49,170
Veis que esta bola que muestra el material va cambiando en relación a lo que indiquéis aquí

835
01:29:49,170 --> 01:29:51,390
Pues si se pone rojo, pues rojo, etcétera, ¿vale?

836
01:29:51,390 --> 01:29:54,909
Podéis toquetear más cosas, ya os digo

837
01:29:54,909 --> 01:29:55,909
No es lo que me interesa ahora

838
01:29:55,909 --> 01:29:58,810
Y para aplicar un material, cuando vais por ejemplo

839
01:29:58,810 --> 01:30:00,630
Al plane, que parece avión

840
01:30:00,630 --> 01:30:02,329
Pero voy a poner el suelo a este GameObject

841
01:30:02,329 --> 01:30:04,689
Si arrastráis este material

842
01:30:04,689 --> 01:30:06,590
Al propio GameObject

843
01:30:06,590 --> 01:30:08,189
O visualmente aquí

844
01:30:08,189 --> 01:30:09,489
A la pantalla

845
01:30:09,489 --> 01:30:11,970
Veis que se colorea de ese material

846
01:30:11,970 --> 01:30:13,850
En esencia lo que está haciendo

847
01:30:13,850 --> 01:30:17,130
Es que los GameObjects

848
01:30:17,130 --> 01:30:18,109
Por lo general tienen

849
01:30:18,109 --> 01:30:20,229
Un componente que se llama

850
01:30:20,229 --> 01:30:22,510
Mesh Renderer, que es lo que renderiza esa malla

851
01:30:22,510 --> 01:30:24,489
y que tiene un material que se

852
01:30:24,489 --> 01:30:25,850
cambia de esta forma, ¿vale?

853
01:30:26,029 --> 01:30:28,130
Veis que cuando lo pongo, coge ese material

854
01:30:28,130 --> 01:30:30,550
¿vale? Una forma muy rápida ya si queréis

855
01:30:30,550 --> 01:30:32,590
tener cosas un poquito más vistosas

856
01:30:32,590 --> 01:30:34,710
para ir coloreando

857
01:30:34,710 --> 01:30:36,350
elementos, ¿vale? Así rápido

858
01:30:36,350 --> 01:30:37,909
no es lo que me voy a meter ahora

859
01:30:37,909 --> 01:30:45,760
Indica, estoy un poco atascado con lo de añadir

860
01:30:45,760 --> 01:30:48,020
la rotación a la nave cuando se desplaza lateralmente

861
01:30:48,020 --> 01:30:50,000
¿vale? Esa probablemente es la parte

862
01:30:50,000 --> 01:30:51,739
más peleaguda

863
01:30:51,739 --> 01:30:54,199
del enunciado

864
01:30:54,199 --> 01:31:15,199
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?

865
01:31:15,199 --> 01:31:18,260
Para que no exista este bloque del Gimbal Lock, ¿no? Eso lo tenéis.

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

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

868
01:31:31,640 --> 01:31:36,939
pero a nivel numérico aquí podemos ver que el número no se ve restringido.

869
01:31:37,300 --> 01:31:41,220
Pero sí que es verdad que por debajo, los cálculos que está haciendo,

870
01:31:41,220 --> 01:31:54,340
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.

871
01:31:54,340 --> 01:32:25,489
¿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?

872
01:32:25,489 --> 01:32:42,569
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á.

873
01:32:42,569 --> 01:32:47,609
voy a ir rápido, os digo una forma rápida para hacer la rotación

874
01:32:47,609 --> 01:32:50,189
más o menos yo creo que se va a ir encaminando

875
01:32:50,189 --> 01:32:52,350
con las lógicas que vamos viendo aquí

876
01:32:52,350 --> 01:32:55,510
si yo tengo esta nave lo que quiero es

877
01:32:55,510 --> 01:32:58,189
que en todo momento se vayan captando

878
01:32:58,189 --> 01:33:01,590
interacciones que vayan definiendo

879
01:33:01,590 --> 01:33:03,750
que esta nave vaya para arriba o para abajo

880
01:33:03,750 --> 01:33:07,810
las interacciones igual que se

881
01:33:07,810 --> 01:33:11,449
hace con cualquier variable

882
01:33:11,449 --> 01:33:18,010
Se pueden ir guardando como vectores o como posiciones que tienen valores.

883
01:33:18,710 --> 01:33:20,670
¿Qué es lo que vamos a hacer en este caso?

884
01:33:20,989 --> 01:33:26,289
Vamos a digregar por un lado los movimientos horizontales y por otro lado los movimientos verticales,

885
01:33:26,390 --> 01:33:30,109
porque vamos a tener dos ejes de interacción.

886
01:33:30,109 --> 01:33:35,670
Hay otro tipo de input que son el getAxis, que sirve para, está en el tema,

887
01:33:35,670 --> 01:33:44,829
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,

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

889
01:33:52,170 --> 01:33:59,729
Lo cual nos puede ser muy útil para hacer las posibilidades de movimientos contradictorios o contrarios.

890
01:33:59,729 --> 01:34:14,310
¿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.

891
01:34:14,310 --> 01:34:26,470
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.

892
01:34:26,470 --> 01:34:41,050
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.

893
01:34:41,869 --> 01:34:55,289
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.

894
01:34:55,289 --> 01:35:18,689
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.

895
01:35:18,689 --> 01:35:39,869
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.

896
01:35:39,869 --> 01:36:02,069
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.

897
01:36:02,069 --> 01:36:09,869
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.

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

899
01:36:17,090 --> 01:36:25,390
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?

900
01:36:25,390 --> 01:36:37,710
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,

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

902
01:36:52,390 --> 01:37:07,310
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.

903
01:37:07,310 --> 01:37:27,010
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.

904
01:37:27,010 --> 01:37:35,229
El negativo será el menos 1, el positivo será el d, y si no lo pulsamos, el positivo será el d, que valdrá 1.

905
01:37:35,750 --> 01:37:38,710
Y hay un rango intermedio entre el menos 1 y el 1.

906
01:37:40,550 --> 01:37:49,449
Aquí debería permitir coger el axis, input getAxis, y a ver qué está pasando.

907
01:37:49,449 --> 01:38:09,420
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.

908
01:38:09,420 --> 01:38:24,060
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.

909
01:38:24,060 --> 01:38:43,479
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.

910
01:38:43,479 --> 01:39:09,380
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.

911
01:39:09,380 --> 01:39:24,720
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.

912
01:39:24,720 --> 01:39:49,699
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.

913
01:39:49,699 --> 01:40:19,210
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.

914
01:40:19,210 --> 01:40:33,829
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.

915
01:40:33,829 --> 01:40:58,390
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.

916
01:40:59,149 --> 01:41:09,890
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.

917
01:41:10,529 --> 01:41:23,689
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,

918
01:41:23,689 --> 01:41:33,510
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.

919
01:41:34,369 --> 01:41:43,630
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,

920
01:41:43,630 --> 01:41:51,510
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

921
01:41:51,510 --> 01:42:03,229
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,

922
01:42:03,229 --> 01:42:16,550
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,

923
01:42:16,670 --> 01:42:27,949
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.

924
01:42:27,949 --> 01:42:55,800
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.

925
01:42:55,800 --> 01:43:03,439
como variable global

926
01:43:03,439 --> 01:43:06,000
estos, vuelco un poco lo que tenía

927
01:43:06,000 --> 01:43:07,460
no estoy haciendo otra cosa

928
01:43:07,460 --> 01:43:13,760
y este de cálculo durante ya lo puedo cerrar y este lo guardo

929
01:43:13,760 --> 01:43:17,340
es lo mismo, se lo estoy aplicando a la nave

930
01:43:17,340 --> 01:43:20,279
entonces el movimiento horizontal de la nave

931
01:43:20,279 --> 01:43:22,399
si voy aquí y le doy a play

932
01:43:22,399 --> 01:43:25,380
pues si le doy a la A

933
01:43:25,380 --> 01:43:28,560
a la D va a la derecha y si le doy a la A va a la izquierda

934
01:43:28,560 --> 01:43:30,800
Ahora mismo se está moviendo

935
01:43:30,800 --> 01:43:32,380
Bueno, claro, es que estoy

936
01:43:32,380 --> 01:43:34,340
Estoy en una escena

937
01:43:34,340 --> 01:43:37,020
Que ya tiene muchas cosas configuradas

938
01:43:37,020 --> 01:43:38,939
Voy a quitar el follow

939
01:43:38,939 --> 01:43:40,840
Vale, por defecto

940
01:43:40,840 --> 01:43:42,239
Y esto es una práctica buena

941
01:43:42,239 --> 01:43:43,859
Cuando empecéis a trabajar

942
01:43:43,859 --> 01:43:47,899
La cámara va a quedarse quieta

943
01:43:47,899 --> 01:43:49,100
Porque nada está diciendo

944
01:43:49,100 --> 01:43:50,659
Que siga a la nave

945
01:43:50,659 --> 01:43:51,859
Vale, entonces

946
01:43:51,859 --> 01:43:54,979
De momento

947
01:43:54,979 --> 01:43:57,359
Bueno, es otra de las cosas que os pide la tarea

948
01:43:57,359 --> 01:44:02,380
De momento, alejadla todo lo posible para ir viendo los movimientos

949
01:44:02,380 --> 01:44:05,539
O abrir la ventana de escena que podemos navegar aquí

950
01:44:05,539 --> 01:44:07,439
Para ir viendo estas interacciones

951
01:44:07,439 --> 01:44:10,479
Porque la cámara se va a ir viendo según ubiquemos la cámara

952
01:44:10,479 --> 01:44:14,560
Entonces si está en un punto que no están viendo al objeto, pues no se ve

953
01:44:14,560 --> 01:44:18,460
Entonces, ahora mismo el código que hemos cambiado

954
01:44:18,460 --> 01:44:20,520
Que no hay otro previo, es el de la nave

955
01:44:20,520 --> 01:44:22,140
Y ya podemos ir izquierda a derecha

956
01:44:22,140 --> 01:44:26,560
De esta forma, de una forma más o menos rápida

957
01:44:26,560 --> 01:44:33,840
lo que podemos hacer es ir a los Project Settings y buscar.

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

959
01:44:39,840 --> 01:44:44,779
Y aquí tenemos uno que tanto las teclas W y S como las de arriba y abajo de la cruceta

960
01:44:44,779 --> 01:44:47,520
ya vendrá configurada como vertical.

961
01:44:48,079 --> 01:44:49,020
Vamos a usar ese axis.

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

963
01:44:54,100 --> 01:45:13,600
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.

964
01:45:13,600 --> 01:45:29,119
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.

965
01:45:29,119 --> 01:45:50,680
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,

966
01:45:50,680 --> 01:46:01,239
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?

967
01:46:01,859 --> 01:46:08,079
Entonces, este número que estamos recogiendo está aquí, como move vertical, ¿vale?

968
01:46:08,119 --> 01:46:16,399
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?

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

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

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

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

973
01:46:44,899 --> 01:47:01,380
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?

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

975
01:47:07,720 --> 01:47:37,739
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.

976
01:47:37,739 --> 01:47:56,079
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.

977
01:47:56,079 --> 01:48:14,819
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?

978
01:48:14,819 --> 01:48:30,060
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.

979
01:48:30,060 --> 01:48:41,039
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.

980
01:48:41,600 --> 01:48:56,640
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.

981
01:48:56,640 --> 01:49:12,659
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?

982
01:49:12,659 --> 01:49:36,000
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.

983
01:49:36,000 --> 01:49:52,819
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.

984
01:49:52,819 --> 01:50:10,279
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.

985
01:50:10,279 --> 01:50:32,699
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.

986
01:50:32,699 --> 01:50:56,579
¿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.

987
01:50:56,579 --> 01:51:11,279
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.

988
01:51:11,279 --> 01:51:41,039
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.

989
01:51:41,279 --> 01:51:48,420
cuenta vale ahora mismo si vamos a juego vale guardo teóricamente cuando yo de a

990
01:51:48,420 --> 01:51:53,420
las teclas y vale igual que mueva arriba abajo con las que ya había definido con

991
01:51:53,420 --> 01:51:59,500
uno y con y veis que va rotando vale

992
01:51:59,500 --> 01:52:04,199
entonces con eso ya yo puedo estar con las teclas que definido antes moviendo

993
01:52:04,199 --> 01:52:10,300
la nave hacia arriba hacia abajo y con la rotación pues vamos rotando vale

994
01:52:10,300 --> 01:52:24,840
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.

995
01:52:24,840 --> 01:52:53,699
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,

996
01:52:53,699 --> 01:53:06,920
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?

997
01:53:07,039 --> 01:53:15,479
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,

998
01:53:15,479 --> 01:53:29,699
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.

999
01:53:29,939 --> 01:53:38,859
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.

1000
01:53:38,859 --> 01:53:55,439
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.

1001
01:53:55,439 --> 01:54:00,920
ahora mismo estamos aquí, muevo

1002
01:54:00,920 --> 01:54:02,899
con la U giro

1003
01:54:02,899 --> 01:54:04,279
y esto está invertido

1004
01:54:04,279 --> 01:54:06,779
cuando doy a la U está yendo

1005
01:54:06,779 --> 01:54:09,100
hacia la izquierda y a la I a la derecha

1006
01:54:09,100 --> 01:54:10,239
entonces

1007
01:54:10,239 --> 01:54:12,039
yo ahora cuando le doy arriba

1008
01:54:12,039 --> 01:54:15,039
sí que lo hace, veis que lo hace con respecto al mundo

1009
01:54:15,039 --> 01:54:16,939
da igual hacia donde esté mirando

1010
01:54:16,939 --> 01:54:17,300
la nave

1011
01:54:17,300 --> 01:54:20,579
entonces con esto ya

1012
01:54:20,579 --> 01:54:22,420
resolvemos ese problema de

1013
01:54:22,420 --> 01:54:24,659
tener distintos

1014
01:54:24,659 --> 01:54:28,039
distinta orientación

1015
01:54:28,039 --> 01:54:29,939
que también nos puede interesar llegar al punto

1016
01:54:29,939 --> 01:54:31,739
que la subida y bajada sea

1017
01:54:31,739 --> 01:54:33,659
en relación a donde esté mirando la nave

1018
01:54:33,659 --> 01:54:36,199
me gustaría, pero no va a ser esencial

1019
01:54:36,199 --> 01:54:37,420
para el apto o no apto

1020
01:54:37,420 --> 01:54:39,500
que no solo la rotación fuera

1021
01:54:39,500 --> 01:54:41,939
libremente así como tenemos

1022
01:54:41,939 --> 01:54:42,920
para

1023
01:54:42,920 --> 01:54:45,380
que sea todo el giro

1024
01:54:45,380 --> 01:54:47,100
sino que a los 90 grados

1025
01:54:47,100 --> 01:54:49,279
se restrinja, pero eso tiene

1026
01:54:49,279 --> 01:54:50,979
varios peros, pero de momento

1027
01:54:50,979 --> 01:54:52,359
podéis ir

1028
01:54:52,359 --> 01:54:55,479
gestionándolo así, ¿vale?

1029
01:55:01,970 --> 01:55:03,829
ya que estamos, por si lo estáis viendo

1030
01:55:03,829 --> 01:55:05,489
vamos a darle una rotación propia

1031
01:55:05,489 --> 01:55:09,250
a una velocidad propia de la rotación

1032
01:55:09,250 --> 01:55:12,529
no, básicamente es hacer un eje

1033
01:55:12,529 --> 01:55:15,550
¿vale? que se va a ocupar de recoger en una variable

1034
01:55:15,550 --> 01:55:18,630
de tipo float, el menos uno o el uno

1035
01:55:18,630 --> 01:55:22,069
que capture con los

1036
01:55:22,069 --> 01:55:24,909
inputs horizontales, es decir, con la A o con la D

1037
01:55:24,909 --> 01:55:27,989
¿vale? en este caso, porque lo que está configurado

1038
01:55:27,989 --> 01:55:29,930
en el input manager, ¿vale? Se puede cambiar.

1039
01:55:30,609 --> 01:55:32,409
Luego, otra variable distinta

1040
01:55:32,409 --> 01:55:33,949
que se llame moveVertical

1041
01:55:33,949 --> 01:55:35,890
y va a coger el 1 y el menos 1

1042
01:55:35,890 --> 01:55:38,329
de la W y la S, las teclas

1043
01:55:38,329 --> 01:55:39,789
de subir y bajar normalmente.

1044
01:55:40,489 --> 01:55:41,710
Y luego va a haber otra, que es

1045
01:55:41,710 --> 01:55:43,949
este eje que hemos creado nosotros, hemos

1046
01:55:43,949 --> 01:55:45,649
customizado, que es el

1047
01:55:45,649 --> 01:55:48,329
rotateData o se podría

1048
01:55:48,329 --> 01:55:48,909
llamar

1049
01:55:48,909 --> 01:55:51,909
moveRotation, no sé,

1050
01:55:52,489 --> 01:55:54,250
que lo que va a coger es el menos 1 o el 1

1051
01:55:54,250 --> 01:55:56,310
en este caso de la U y la I porque son las teclas

1052
01:55:56,310 --> 01:56:06,430
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

1053
01:56:06,430 --> 01:56:15,050
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

1054
01:56:15,050 --> 01:56:22,550
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

1055
01:56:22,550 --> 01:56:28,189
por el time delta time y se multiplica también por una velocidad que lo que hace es aumentar el

1056
01:56:28,189 --> 01:56:33,369
detrimento en la reducción que se ha tenido por estos valores que antes hemos visto que eran

1057
01:56:33,369 --> 01:56:42,109
decimales que genera el time delta time vale y por último si es necesario hay otro otro parámetro

1058
01:56:42,109 --> 01:56:47,210
dentro del translate y el rotation en el rotate también que es que los movimientos se hagan en

1059
01:56:47,210 --> 01:56:53,890
base a sí mismo, en cuyo caso aquí pondría space.self, o con respecto al mundo, que es

1060
01:56:53,890 --> 01:56:58,390
lo que nos interesa aquí para que no considere la rotación que está teniendo el objeto

1061
01:56:58,390 --> 01:57:03,590
cuando lo vamos rotando, que es que lo hago en torno al mundo. Y la rotación es lo mismo,

1062
01:57:04,170 --> 01:57:09,449
lo hace con respecto al eje de profundidad, y nuevamente esto es lo mismo que escribir

1063
01:57:09,449 --> 01:57:14,689
vector 3, 0, 0, 1, ¿vale?

1064
01:57:14,710 --> 01:57:18,409
Porque en este caso el eje sobre el que gira es el de profundidad, ¿vale?

1065
01:57:18,909 --> 01:57:24,350
Y lo multiplica por el valor que está recogiendo en este float de rotador, ¿vale?

1066
01:57:24,409 --> 01:57:27,130
Igual, lo equilibramos y le damos una velocidad mayor,

1067
01:57:27,949 --> 01:57:30,069
que para que no sea exactamente la del movimiento,

1068
01:57:30,550 --> 01:57:32,130
pues he hecho otra variable con otro valor,

1069
01:57:32,229 --> 01:57:34,270
pero vamos, podría ser también la del movimiento.

1070
01:57:34,270 --> 01:57:38,369
Eso es por tener, digamos, un poco desgregadas las opciones.

1071
01:57:39,449 --> 01:57:59,250
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.

1072
01:57:59,250 --> 01:58:11,890
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.

1073
01:58:11,890 --> 01:58:41,630
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?

1074
01:58:41,630 --> 01:58:57,449
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.

1075
01:58:57,449 --> 01:59:14,909
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.

1076
01:59:15,189 --> 01:59:23,670
Aquí si os fijáis estoy usando esa forma de emplear los métodos para recopilar código.

1077
01:59:23,670 --> 01:59:29,930
Entonces bueno, con esto, simplemente para que veáis que acabamos con algo que funciona

1078
01:59:29,930 --> 01:59:32,630
Ya tendríamos el movimiento de la nave

1079
01:59:32,630 --> 01:59:35,390
Y si doy a la I y a la U

1080
01:59:35,390 --> 01:59:38,470
Ahora va más lento porque he cambiado la Speed Rotation, que la he hecho a la mitad

1081
01:59:38,470 --> 01:59:41,550
Con la I y la U voy haciendo que se rote

1082
01:59:41,550 --> 01:59:44,409
Entonces más o menos el movimiento estaría

1083
01:59:44,409 --> 01:59:49,069
Luego lo que habrá que hacer es que estos movimientos

1084
01:59:49,069 --> 01:59:53,729
solo se ejecuten cuando no se traspasen ciertas coordenadas.

1085
01:59:53,930 --> 01:59:57,109
En plan, si la altura es mayor de donde está la nave,

1086
01:59:57,930 --> 02:00:02,770
si es mayor que 10 en i,

1087
02:00:03,550 --> 02:00:07,590
entonces este movimiento deje de producirse.

1088
02:00:07,930 --> 02:00:09,869
Y con eso podemos ir definiendo también límites.