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

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

3
00:00:25,019 --> 00:00:27,059
espero que ya por lo menos leído

4
00:00:27,059 --> 00:00:29,100
y bueno, comenzando

5
00:00:29,100 --> 00:00:30,699
con la tarea quienes vayáis a hacerla

6
00:00:30,699 --> 00:00:33,119
que como siempre son más que recomendables

7
00:00:33,119 --> 00:00:34,539
porque si no se practica esto

8
00:00:34,539 --> 00:00:37,399
vais a ver que es complicado

9
00:00:37,399 --> 00:00:39,299
saber ir asimilando

10
00:00:39,299 --> 00:00:41,159
todo, entonces bueno

11
00:00:41,159 --> 00:00:41,780
esa duda

12
00:00:41,780 --> 00:00:44,820
si me la queréis comentar

13
00:00:44,820 --> 00:00:47,020
indica, estoy un poco

14
00:00:47,020 --> 00:00:49,039
atascado con lo de añadir la rotación a la nave cuando

15
00:00:49,039 --> 00:00:51,500
se desplaza lateralmente, vale, esa probablemente

16
00:00:51,500 --> 00:00:52,640
es la parte más

17
00:00:52,640 --> 00:00:54,700
peleaguda del

18
00:00:54,700 --> 00:00:56,399
del enunciado

19
00:00:56,399 --> 00:00:58,880
de todos modos en el

20
00:00:58,880 --> 00:01:03,020
pues eso, en el mismo enunciado se dice

21
00:01:03,020 --> 00:01:04,239
que se puede llegar de varias maneras

22
00:01:04,239 --> 00:01:06,760
y bueno, en el tema también se anuncia

23
00:01:06,760 --> 00:01:08,780
o se deja ver que lo que es

24
00:01:08,780 --> 00:01:10,680
la rotación y como la gestiona

25
00:01:10,680 --> 00:01:12,319
el propio Unity es

26
00:01:12,319 --> 00:01:14,540
complejo en el sentido de que usa

27
00:01:14,540 --> 00:01:16,959
estos cuaternios que son cuatro dimensiones

28
00:01:16,959 --> 00:01:18,680
para que no exista este bloque

29
00:01:18,680 --> 00:01:20,480
del Gimbal Lock, eso lo tenéis

30
00:01:20,480 --> 00:01:21,439
y entonces

31
00:01:21,439 --> 00:01:24,140
surgen problemas entre

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

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

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

35
00:02:08,560 --> 00:02:11,400
Entonces, ese puede que sea uno de los problemas que están surgiendo.

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

37
00:02:26,340 --> 00:02:29,939
y bueno, un poco para que a partir de ahí

38
00:02:29,939 --> 00:02:32,699
también a lo mejor busquéis alguna más de cara a la siguiente

39
00:02:32,699 --> 00:02:34,620
pero bueno, es un poco por saber

40
00:02:34,620 --> 00:02:37,840
si ya veis, si todos habéis conseguido más o menos mover la nave

41
00:02:37,840 --> 00:02:39,500
ponerle límites, etcétera

42
00:02:39,500 --> 00:02:40,960
puedo avanzar un poco más

43
00:02:40,960 --> 00:02:43,620
aunque hay cosas que creo que estaría bien repasar

44
00:02:43,620 --> 00:02:47,120
entonces, si os parece

45
00:02:47,120 --> 00:02:51,659
me pongo a hablar de algunas cosas previas

46
00:02:51,659 --> 00:02:54,960
vemos así rápidamente cómo se movería la nave

47
00:02:54,960 --> 00:02:56,759
o cuál sería el planteamiento lógico

48
00:02:56,759 --> 00:02:57,520
con lo que hemos visto

49
00:02:57,520 --> 00:03:00,639
y acabamos un poco con lo de la rotación

50
00:03:00,639 --> 00:03:02,060
os lo digo

51
00:03:02,060 --> 00:03:04,939
vale, pues vamos

52
00:03:04,939 --> 00:03:06,400
voy a ir

53
00:03:06,400 --> 00:03:08,620
voy a intentar ir lo más rápido posible

54
00:03:08,620 --> 00:03:10,939
quiero ir a una cosa previa de los vectores

55
00:03:10,939 --> 00:03:11,919
que dejé el otro día

56
00:03:11,919 --> 00:03:13,840
un poco así presentada

57
00:03:13,840 --> 00:03:15,819
pero no, bueno, hay algún detalle

58
00:03:15,819 --> 00:03:16,780
que me gustaría que viéramos

59
00:03:16,780 --> 00:03:19,719
y vamos a lo siguiente

60
00:03:19,719 --> 00:03:21,939
si no es algo concreto

61
00:03:21,939 --> 00:03:23,219
más allá de que te has bloqueado ahí

62
00:03:23,219 --> 00:03:24,780
que evidentemente eso ya es una duda

63
00:03:24,780 --> 00:03:26,800
lo hacemos así, ¿os parece?

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

65
00:03:33,280 --> 00:03:38,060
porque creo que a lo mejor incluso si habéis conseguido mover ciertas cosas

66
00:03:38,060 --> 00:03:42,599
pueden surgir problemas que con estas dudas que creo que vamos a ir resolviendo

67
00:03:42,599 --> 00:03:45,300
pues se van viendo, ¿vale?

68
00:03:45,819 --> 00:03:48,139
yo voy arrancando y vamos viendo, ¿vale? si os parece

69
00:03:48,139 --> 00:03:51,000
que así vamos viendo

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

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

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

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

74
00:04:59,199 --> 00:05:08,600
Entonces simplemente me gustaría que veamos rápidamente, si ya hay dudas me las vais planteando en los foros,

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

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

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

78
00:05:37,980 --> 00:05:41,699
simplemente quiero que veamos que se pueden sumar

79
00:05:41,699 --> 00:05:43,139
vectores distintos

80
00:05:43,139 --> 00:05:45,379
que vamos creando

81
00:05:45,379 --> 00:05:47,439
sobre la marcha, al vuelo

82
00:05:47,439 --> 00:05:49,500
se pueden sumar los que hemos guardado

83
00:05:49,500 --> 00:05:50,639
en

84
00:05:50,639 --> 00:05:53,620
vectores 3 como variable

85
00:05:53,620 --> 00:05:55,480
previamente, y por eso aquí

86
00:05:55,480 --> 00:05:57,579
operamos con estos vectores A

87
00:05:57,579 --> 00:05:59,339
y vector B, esto lo vimos el otro día

88
00:05:59,339 --> 00:06:01,660
también es importante saber

89
00:06:01,660 --> 00:06:03,660
que se puede

90
00:06:03,660 --> 00:06:04,699
hacer, y me paso aquí

91
00:06:04,699 --> 00:06:07,279
se pueden ir sumando

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

93
00:06:12,399 --> 00:06:17,360
vectores 2, incluso existen por ahí, aunque no son tan comunes, los vectores 4, ¿vale?

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

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

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

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

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

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

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

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

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

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

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

105
00:09:12,919 --> 00:09:14,720
Que es un poco lo que puede dar la velocidad.

106
00:09:15,320 --> 00:09:18,840
Por tanto, es importante diferenciar entre lo que se puede hacer con las sumas, que veis que da error,

107
00:09:19,139 --> 00:09:23,279
lo pongo ya en comentario porque no va a haber resultado, va a dar error,

108
00:09:24,379 --> 00:09:27,419
y lo que se puede hacer con multiplicaciones, ¿vale?

109
00:09:27,500 --> 00:09:31,100
O con, a ver, que no me equivoque, o con divisiones, ¿vale?

110
00:09:31,559 --> 00:09:33,600
Son dos tipos de operaciones en este sentido.

111
00:09:33,600 --> 00:09:38,220
Y luego, por otro lado, pongo como comentario todo lo que ya hemos ido viendo,

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

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

114
00:09:56,779 --> 00:10:00,120
Por ejemplo, las de dos dimensiones en ocasiones se usan también en el entorno 3D.

115
00:10:00,120 --> 00:10:08,279
No solo se usa en juegos de tipo 2D, ¿vale?

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

117
00:10:13,059 --> 00:10:20,240
que si ponemos esto no da problemas, hay que ser consecuente e ir operando con vectores, ¿vale?

118
00:10:20,240 --> 00:10:24,539
Y vemos aquí el error, que estará aquí, ¿vale? A ver...

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

120
00:10:28,059 --> 00:10:30,480
si dais a un error

121
00:10:30,480 --> 00:10:32,279
os va a decir aquí el porqué

122
00:10:32,279 --> 00:10:34,419
y pone el operador más es ambiguo en operandos

123
00:10:34,419 --> 00:10:36,179
del tipo vector 3 y vector 2

124
00:10:36,179 --> 00:10:38,240
básicamente lo que nos quiere decir es

125
00:10:38,240 --> 00:10:39,580
que no son compatibles

126
00:10:39,580 --> 00:10:42,019
entonces, bueno, que sepáis eso

127
00:10:42,019 --> 00:10:44,240
que aunque en muchas ocasiones se puede

128
00:10:44,240 --> 00:10:46,279
usar un vector 3 por sus dos

129
00:10:46,279 --> 00:10:48,200
dimensiones y estar operando

130
00:10:48,200 --> 00:10:49,600
realmente como si fuera un vector 2

131
00:10:49,600 --> 00:10:52,120
considerad que no se puede

132
00:10:52,120 --> 00:10:54,059
hacer esta mezcla entre tipos

133
00:10:54,059 --> 00:10:56,139
de vectores en cuanto a su número

134
00:10:56,139 --> 00:10:57,639
de posiciones

135
00:10:57,639 --> 00:10:58,460
¿vale?

136
00:10:59,440 --> 00:11:01,240
esto creo que es importante porque

137
00:11:01,240 --> 00:11:03,580
luego podéis encontrar conflictos que salen

138
00:11:03,580 --> 00:11:05,360
errores o veis

139
00:11:05,360 --> 00:11:07,059
¿cómo puede ser que un vector 3

140
00:11:07,059 --> 00:11:09,580
solo tenga dos posiciones? pues sí, puede ser

141
00:11:09,580 --> 00:11:11,580
vamos por poder, ¿vale? y lo

142
00:11:11,580 --> 00:11:13,500
vemos, incluso creo, vamos

143
00:11:13,500 --> 00:11:15,220
igual ahora me equivoco, pero

144
00:11:15,220 --> 00:11:17,360
ah no, siempre tiene que haber mínimo 2

145
00:11:17,360 --> 00:11:19,580
pues juraría que se

146
00:11:19,580 --> 00:11:21,639
podía, aunque para tener un vector

147
00:11:21,639 --> 00:11:23,679
3 que solo tiene una posición, pues es lo mismo

148
00:11:23,679 --> 00:11:25,659
que decir aquí un 2, ¿vale? entonces

149
00:11:25,659 --> 00:11:38,620
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.

150
00:11:40,159 --> 00:11:46,000
Vale, a ver si no paso a la siguiente cosa. Vale, entiendo que hasta aquí me vais siguiendo.

151
00:11:46,000 --> 00:12:03,120
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?

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

153
00:12:17,960 --> 00:12:25,320
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?

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

155
00:12:31,879 --> 00:12:36,240
Lo que no se puede hacer es multiplicar un vector por otro de manera directa.

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

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

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

159
00:13:05,080 --> 00:13:10,559
entre los que vais a encontrar, por ejemplo, uno que es este de scale, multiplicar vectores entre ejes respectivos.

160
00:13:11,120 --> 00:13:20,399
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,

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

162
00:13:36,019 --> 00:13:42,100
Entonces, un vector 3 por otro vector 3, como hemos dicho, da error.

163
00:13:42,100 --> 00:14:00,629
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.

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

165
00:14:09,929 --> 00:14:15,610
este que tenemos aquí, y este que tenemos aquí segundo.

166
00:14:16,429 --> 00:14:22,629
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.

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

168
00:14:43,889 --> 00:14:59,529
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.

169
00:14:59,529 --> 00:15:20,210
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.

170
00:15:20,210 --> 00:15:31,169
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.

171
00:15:31,850 --> 00:15:41,950
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.

172
00:15:45,870 --> 00:15:49,610
Lo voy a copiar y cambio la dimensión.

173
00:15:50,210 --> 00:15:59,250
Z y Z. Y diréis, ¿y esto que estás haciendo qué es?

174
00:16:00,049 --> 00:16:10,629
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.

175
00:16:10,629 --> 00:16:15,070
Pero bueno, lo voy a dejar con este nombre para que no sea un lío.

176
00:16:15,070 --> 00:16:32,529
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.

177
00:16:32,529 --> 00:17:01,669
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.

178
00:17:01,669 --> 00:17:02,929
Las referencias que haya

179
00:17:02,929 --> 00:17:05,809
Suma vectores por posiciones

180
00:17:05,809 --> 00:17:06,710
Yo que sé, ¿vale?

181
00:17:06,730 --> 00:17:08,049
Veis que se están cambiando las dos

182
00:17:08,049 --> 00:17:10,150
Cuando lo tengáis, le dais a escape

183
00:17:10,150 --> 00:17:12,529
Ah, bueno, no, a escape no

184
00:17:12,529 --> 00:17:18,410
Le dais a suma vectores por posiciones

185
00:17:18,410 --> 00:17:21,170
Le dais a intro y ya está, ¿vale?

186
00:17:21,490 --> 00:17:22,769
Veis que se cambian los dos

187
00:17:22,769 --> 00:17:24,230
Pero no en los comentados, cuidado

188
00:17:24,230 --> 00:17:26,450
Que ahí pueden surgir problemas

189
00:17:26,450 --> 00:17:28,630
Porque luego yo sigo descomentando

190
00:17:28,630 --> 00:17:30,650
Y ya no se está refiriendo a esto

191
00:17:30,650 --> 00:17:43,450
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.

192
00:17:44,250 --> 00:17:47,329
Bueno, entonces, estamos aquí. ¿Qué es lo que estamos haciendo?

193
00:17:47,990 --> 00:17:54,509
Importante. Cada vector 3 tiene la posición x, la y y la z.

194
00:17:55,289 --> 00:18:03,490
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.

195
00:18:04,230 --> 00:18:10,190
Aunque no son exactamente lo mismo, dijimos que eran variables compuestas de varios valores.

196
00:18:11,009 --> 00:18:23,410
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.

197
00:18:23,970 --> 00:18:32,930
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.

198
00:18:32,930 --> 00:18:49,630
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.

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

200
00:19:04,869 --> 00:19:06,369
¿por qué os digo esto?

201
00:19:06,809 --> 00:19:08,789
a ver, lo vemos, un segundete

202
00:19:08,789 --> 00:19:11,369
que igual hay algo con error por lo que me dice

203
00:19:11,369 --> 00:19:13,769
ahí sale como que sobra

204
00:19:13,769 --> 00:19:15,190
algo

205
00:19:15,190 --> 00:19:17,509
como que sobra

206
00:19:17,509 --> 00:19:21,670
vale, bueno, no sé

207
00:19:21,670 --> 00:19:23,690
sí, me he debido de cargar

208
00:19:23,690 --> 00:19:25,490
alguna llave

209
00:19:25,490 --> 00:19:28,109
bueno, vamos a

210
00:19:28,109 --> 00:19:30,089
aquí, y bueno, cuando le damos al play

211
00:19:30,089 --> 00:19:31,750
va a dar el resultado de

212
00:19:31,750 --> 00:19:33,230
1, 3, 6, ¿vale? que es lo que

213
00:19:33,230 --> 00:19:37,490
tiene que dar como sentido a esto. Aquí pone multiplicando

214
00:19:37,490 --> 00:19:41,230
vectores, ¿vale? Si os fijáis, ¿vale? No perdáis de vista porque

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

216
00:19:45,230 --> 00:19:49,349
hablado otros días, si nadie tiene dudas, sigo. ¿Qué pasa? Que cuando

217
00:19:49,349 --> 00:19:53,369
ponemos, cuando estamos trabajando con vectores, es muy importante

218
00:19:53,369 --> 00:19:57,369
tener en cuenta que si un vector, una de las posiciones del vector no se

219
00:19:57,369 --> 00:20:00,829
quieren cambiar, se puede poner el nombre del vector con su dimensión y eso

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

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

222
00:20:52,349 --> 00:21:00,089
¿Hasta aquí qué tal? Bien, me seguís, vale.

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

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

225
00:21:15,529 --> 00:21:20,029
Ahora mismo la única que se ha variado es la y, ¿vale?

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

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

228
00:21:52,549 --> 00:21:57,890
Sigo a la siguiente cosa importante

229
00:21:57,890 --> 00:22:00,930
que yo entiendo que se queda claro en el tema

230
00:22:00,930 --> 00:22:03,329
pero que queda aún más claro

231
00:22:03,329 --> 00:22:08,289
porque en mi experiencia es algo que a veces genera dudas

232
00:22:08,289 --> 00:22:10,069
y es lógico también al principio

233
00:22:10,069 --> 00:22:13,109
Tenemos aquí un update

234
00:22:13,109 --> 00:22:16,170
¿Por qué viene señalado?

235
00:22:16,369 --> 00:22:18,769
Pues lo mismo, si tenemos dudas de por qué viene señalado

236
00:22:18,769 --> 00:22:21,470
pues ponemos aquí

237
00:22:21,470 --> 00:22:24,150
esto de la advertencia en este caso

238
00:22:24,150 --> 00:22:25,769
porque sale verde, vale, a ver

239
00:22:25,769 --> 00:22:28,029
que ahora se ha escondido y pone la función local update

240
00:22:28,029 --> 00:22:29,509
se declara pero nunca se usa

241
00:22:29,509 --> 00:22:32,210
y eso tiene algo que ver con las llaves

242
00:22:32,210 --> 00:22:34,269
de antes, vale, si os fijáis

243
00:22:34,269 --> 00:22:34,650
vale

244
00:22:34,650 --> 00:22:37,930
por algún motivo el start

245
00:22:37,930 --> 00:22:39,589
ah, vale

246
00:22:39,589 --> 00:22:42,289
lo que pasa es que había borrado el de cierre

247
00:22:42,289 --> 00:22:44,289
del start, vale, y ahora me sobra

248
00:22:44,289 --> 00:22:45,950
uno, vale, pues eso

249
00:22:45,950 --> 00:22:47,809
gracias a ver en contexto

250
00:22:47,809 --> 00:22:50,210
la advertencia

251
00:22:50,210 --> 00:22:52,109
que me estaba saliendo, me he dado cuenta

252
00:22:52,109 --> 00:22:54,029
de que estaba metiendo el update dentro del

253
00:22:54,029 --> 00:22:56,269
start, que son dos momentos de ejecución que no se deberían

254
00:22:56,269 --> 00:22:57,769
mezclar, ¿vale? Simplemente

255
00:22:57,769 --> 00:23:00,029
que los errores salen por todos lados

256
00:23:00,029 --> 00:23:01,769
y lo importante siempre es saber

257
00:23:01,769 --> 00:23:03,910
cómo salir del

258
00:23:03,910 --> 00:23:05,789
escollo, ¿no? Vale, para

259
00:23:05,789 --> 00:23:08,069
ver esto, este ejemplo

260
00:23:08,069 --> 00:23:10,130
que voy a hablar un poco de cómo se descompone

261
00:23:10,130 --> 00:23:11,690
el movimiento con el translate, ¿vale?

262
00:23:12,549 --> 00:23:14,130
Y dejar claras un par de cosas

263
00:23:14,130 --> 00:23:15,769
de los inputs, ¿no?

264
00:23:15,769 --> 00:23:16,569
Que están en el tema.

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

266
00:23:40,029 --> 00:23:46,809
al cubo al cubo al cubo ahora si quiere venga entonces ahora mismo tenemos un cubo que yo le

267
00:23:46,809 --> 00:23:51,589
doy a play y está quieto vale porque todavía por ejemplo no hemos aprendido a usar las fuerzas de

268
00:23:51,589 --> 00:23:59,769
la gravedad entonces está quietito que voy a hacer en este con este script no bueno ahora mismo como

269
00:23:59,769 --> 00:24:04,990
si borrar a todo esto del estar vale porque todo son operaciones para una consola pero

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

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

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

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

274
00:25:09,710 --> 00:25:24,630
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.

275
00:25:24,630 --> 00:25:27,390
importante porque

276
00:25:27,390 --> 00:25:29,109
otros años me decían

277
00:25:29,109 --> 00:25:31,289
pero cuando yo doy a getKeyDown

278
00:25:31,289 --> 00:25:33,390
es que estoy dando a la flecha de abajo o a la de arriba

279
00:25:33,390 --> 00:25:34,549
no tiene nada que ver

280
00:25:34,549 --> 00:25:37,529
cuando estamos definiendo una interacción

281
00:25:37,529 --> 00:25:39,250
hay que tener en cuenta

282
00:25:39,250 --> 00:25:41,430
que al menos de partida

283
00:25:41,430 --> 00:25:43,230
hay tres momentos importantes

284
00:25:43,230 --> 00:25:45,490
y lo podéis ver cuando pulsáis una tecla

285
00:25:45,490 --> 00:25:47,430
el momento en el que se pulsa

286
00:25:47,430 --> 00:25:49,349
el tiempo durante el que

287
00:25:49,349 --> 00:25:51,329
está pulsado y el momento en el que

288
00:25:51,329 --> 00:25:52,230
se levanta

289
00:25:52,230 --> 00:26:12,390
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.

290
00:26:12,390 --> 00:26:32,589
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.

291
00:26:32,589 --> 00:26:55,269
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.

292
00:26:55,269 --> 00:27:00,470
Esa es algo muy importante que entender en este momento

293
00:27:00,470 --> 00:27:03,029
No tiene nada que ver con la dirección en sí

294
00:27:03,029 --> 00:27:11,089
La dirección luego se explicita en la tecla que hay entre paréntesis

295
00:27:11,089 --> 00:27:12,950
O el código que se da entre paréntesis

296
00:27:12,950 --> 00:27:17,029
Y luego la orden que se da ya entre llaves del condicional

297
00:27:17,029 --> 00:27:25,049
Entonces, por ejemplo, la sintaxis en este caso siempre empieza por esta clase input

298
00:27:25,049 --> 00:27:30,849
que recoge en su interior las distintas configuraciones de interacción que tiene el InputManager.

299
00:27:31,490 --> 00:27:37,130
Y luego aquí es donde entra uno de estos métodos que tenemos aquí, que son varios.

300
00:27:37,569 --> 00:27:46,309
Hay otros pensados para botón del ratón, como en este caso, que con este input se dice

301
00:27:46,309 --> 00:27:51,150
si ponemos esta línea es que si se pulsa el botón izquierdo del ratón se da esta orden.

302
00:27:51,150 --> 00:28:10,250
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.

303
00:28:10,250 --> 00:28:30,829
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.

304
00:28:30,829 --> 00:28:51,210
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.

305
00:28:51,210 --> 00:29:00,329
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?

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

307
00:29:11,250 --> 00:29:16,390
Pues para que este elemento se mueva hacia la derecha, ¿vale?

308
00:29:18,190 --> 00:29:25,230
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?

309
00:29:25,230 --> 00:29:30,130
Mientras mantenga pulsada esta tecla D, se ejecuta lo que hay en estas llaves, ¿vale?

310
00:29:32,109 --> 00:29:35,130
Entiendo que más o menos esto también lo seguís.

311
00:29:35,990 --> 00:29:37,930
Bueno, si habéis leído el tema y visto los vídeos.

312
00:29:39,589 --> 00:29:40,029
Perdón.

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

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

315
00:30:17,029 --> 00:30:20,029
transform, todo lo tendremos claro

316
00:30:20,029 --> 00:30:21,910
pero se refiere esencialmente

317
00:30:21,910 --> 00:30:23,670
a lo que ocupa este componente

318
00:30:23,670 --> 00:30:25,769
que tienen ya por defecto la mayor parte

319
00:30:25,769 --> 00:30:27,710
de los GameObjects

320
00:30:27,710 --> 00:30:29,809
que tenemos en nuestro

321
00:30:29,809 --> 00:30:30,849
juego

322
00:30:30,849 --> 00:30:33,509
entonces

323
00:30:33,509 --> 00:30:35,690
¿qué es lo que conseguimos?

324
00:30:35,809 --> 00:30:37,250
bueno y dentro de transform hay muchos

325
00:30:37,250 --> 00:30:39,369
pero bueno, en este caso sobre todo vamos a ver

326
00:30:39,369 --> 00:30:41,549
el translate que sirve para ir moviendo

327
00:30:41,549 --> 00:30:43,309
objetos y el rotate para ir

328
00:30:43,309 --> 00:30:44,190
rotando objetos

329
00:30:44,190 --> 00:30:46,150
este

330
00:30:46,150 --> 00:30:48,890
transfer translate, si nos metemos en el

331
00:30:48,890 --> 00:30:50,470
y aquí

332
00:30:50,470 --> 00:30:52,450
vuelve a pasar algo de que me está

333
00:30:52,450 --> 00:30:54,210
diciendo que Nanay, a ver

334
00:30:54,210 --> 00:30:54,730
que es

335
00:30:54,730 --> 00:30:57,529
aquí ahora me sobra esta llave

336
00:30:57,529 --> 00:31:00,410
no sé cuando estoy poniendo yo llaves para que me diga esto

337
00:31:00,410 --> 00:31:01,789
todo el rato, pero bueno

338
00:31:01,789 --> 00:31:05,730
lo que vamos a conseguir

339
00:31:05,730 --> 00:31:07,529
que iba a ir a ver

340
00:31:07,529 --> 00:31:10,289
como siempre y fijaos que yo lo que hago cuando

341
00:31:10,289 --> 00:31:12,450
tengo dudas es poner Unity en Google

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

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

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

345
00:31:58,849 --> 00:32:00,950
Entonces, aquí estamos.

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

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

348
00:32:18,240 --> 00:32:20,400
y esta la voy a poner comentado, ¿vale?

349
00:32:21,059 --> 00:32:24,720
Lo que vamos a decir es, en cada fotograma, ¿vale?

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

351
00:32:35,380 --> 00:32:38,359
Esto lo dejamos en cero, por tanto no varía en nada.

352
00:32:38,839 --> 00:32:47,740
Van a cambiar la posición de ese objeto con respecto a donde estuviera una posición en cada actualización del update.

353
00:32:47,740 --> 00:33:09,019
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.

354
00:33:09,019 --> 00:33:13,779
vuelvo a hacerlo, se ve ahí muy pequeñito

355
00:33:13,779 --> 00:33:15,740
me voy a acercar un poco más, que se me ha ido un poco

356
00:33:15,740 --> 00:33:19,779
importante, cuando vayáis a hacer interacciones

357
00:33:19,779 --> 00:33:22,400
veis que yo tengo el panel de escena y el de juego

358
00:33:22,400 --> 00:33:25,480
para que el juego se ejecute

359
00:33:25,480 --> 00:33:28,940
y detecte las interacciones, aunque tengáis aquí abierta la escena

360
00:33:28,940 --> 00:33:31,619
que a mí me interesa mucho, para ver en el entorno

361
00:33:31,619 --> 00:33:34,380
este objeto, tenéis que clicar en juego

362
00:33:34,380 --> 00:33:36,700
hasta que no cliquéis en juego, yo aunque le dé a la D

363
00:33:36,700 --> 00:33:40,380
no se movería, porque no está en el área

364
00:33:40,380 --> 00:33:41,900
del editor de Unity

365
00:33:41,900 --> 00:33:44,140
es necesario para que

366
00:33:44,140 --> 00:33:45,700
se pueda interactuar, ¿vale?

367
00:33:46,700 --> 00:33:48,500
¿Hasta aquí me vais siguiendo?

368
00:33:49,299 --> 00:33:50,359
Perdona que pregunte

369
00:33:50,359 --> 00:33:52,240
tanto esto, pero es que quiero saber

370
00:33:52,240 --> 00:33:54,339
si me vais siguiendo, porque si no me pongo

371
00:33:54,339 --> 00:33:56,220
aquí a hablar... Vale, perfecto. Importante

372
00:33:56,220 --> 00:33:58,259
que a veces decís, no me funciona

373
00:33:58,259 --> 00:33:59,960
nada de esto, y es porque estáis

374
00:33:59,960 --> 00:34:02,019
clicando en escena mismamente,

375
00:34:02,160 --> 00:34:04,299
lógico, en escena podéis mover

376
00:34:04,299 --> 00:34:05,839
los elementos vosotros como queráis,

377
00:34:06,299 --> 00:34:08,280
¿vale? En reproducción para comprobar

378
00:34:08,280 --> 00:34:13,599
cosas vale pero lo que son las interacciones tenéis que dar clic a game y ya ahí funciona y

379
00:34:13,599 --> 00:34:19,739
fijaos que yo puedo volver a poner aquí el objeto que le doy a la tecla de vale y se mueve en el eje

380
00:34:19,739 --> 00:34:25,199
x hacia la derecha porque pues porque hemos dicho la tecla de pues se va moviendo con respecto a

381
00:34:25,199 --> 00:34:31,440
donde esté le va sumando digamos al valor que ya tenga uno en cada fotograma vale y estos dos los

382
00:34:31,440 --> 00:34:38,000
deja igual porque son cero de hecho lo que hemos dicho antes si yo pongo un vector 3 solo con dos

383
00:34:38,000 --> 00:34:43,460
valores también me lo coge y va a ser equivalente a esto vale simplemente que veáis que eso puede

384
00:34:43,460 --> 00:34:50,260
ocurrir qué problema surge de esto es estable este movimiento pues no porque por lo que viene

385
00:34:50,260 --> 00:34:57,760
en el tema también el problema del update o la ventaja según como se vea es que está esta orden

386
00:34:57,760 --> 00:35:03,099
digamos este método se ejecuta en cada fotograma de reproducción del juego pero esto no significa

387
00:35:03,099 --> 00:35:11,079
que el ordenador tenga constantemente la misma velocidad de reproducción vale va a ir digamos

388
00:35:11,079 --> 00:35:17,780
si abrís 85 programas a la vez irá más despacio el ordenador tendrá menos capacidad de computación

389
00:35:17,780 --> 00:35:25,539
que si pues sólo estamos con unity con este juego vale puede variar no entonces qué ocurre que si

390
00:35:25,539 --> 00:35:32,880
en cada update yo muevo uno que os asegura que se mueva a la misma distancia en un segundo que

391
00:35:32,880 --> 00:35:43,079
En el siguiente, me explico, si en un segundo el ordenador ha tenido la capacidad de reproducir 15 fotogramas,

392
00:35:43,079 --> 00:35:51,179
se moverá 15 posiciones, pero si en el siguiente segundo ha podido reproducir 20 fotogramas,

393
00:35:51,340 --> 00:35:55,019
se habrá movido 20 posiciones en un segundo.

394
00:35:55,559 --> 00:35:59,659
Esto no tiene sentido porque el objeto se debería mover siempre a la misma velocidad.

395
00:35:59,659 --> 00:36:03,880
Por eso, ahora mismo este objeto no es estable

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

397
00:36:08,719 --> 00:36:11,820
Vais a ver que puede ir dando como saltitos

398
00:36:11,820 --> 00:36:16,460
Porque en un fotograma tarda más que otro en reproducirse

399
00:36:16,460 --> 00:36:19,960
Entonces, bueno, es que, a ver, voy a alejarme

400
00:36:19,960 --> 00:36:22,179
Que como se ve el gizmo, me voy a alejar

401
00:36:22,179 --> 00:36:24,380
Y a lo mejor veis algún salto, ¿vale?

402
00:36:24,719 --> 00:36:25,699
Normalmente va a ser mínimo

403
00:36:25,699 --> 00:36:27,920
Pero a veces se ven como tirones

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

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

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

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

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

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

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

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

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

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

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

415
00:39:09,070 --> 00:39:14,030
Y veis que al final equilibra para que la duración de todos sea siempre al final de 1.

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

417
00:39:19,150 --> 00:39:22,730
Entonces, aquí está, digamos, equilibrando en todo momento, ¿vale?

418
00:39:22,769 --> 00:39:27,469
Porque está cambiando este valor realmente, en todo momento, este valor, o los que hay aquí,

419
00:39:27,550 --> 00:39:29,889
aquí como estos son cero, pues la multiplicación da cero,

420
00:39:30,409 --> 00:39:35,090
pero se está variando de manera dinámica cuántas posiciones se tiene que mover

421
00:39:35,090 --> 00:39:37,730
para que sea equilibrada, ¿vale?

422
00:39:37,909 --> 00:39:42,949
Esto es algo muy propio de cuando se hacen movimientos en el update.

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

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

425
00:40:08,909 --> 00:40:14,730
vale pues se pone que es 0.2 y todo lo que se ejecuta tarda 0.2 vale si el

426
00:40:14,730 --> 00:40:18,690
ordenador no le da tiempo habrá que subir esta velocidad bajar hacer más

427
00:40:18,690 --> 00:40:21,869
lenta esta velocidad para que le dé tiempo pero está pensado para que sea

428
00:40:21,869 --> 00:40:27,869
fijo y estable vale pero el update tiene una ventaja que es intentar aunque luego

429
00:40:27,869 --> 00:40:32,489
lo estabilicemos en algunos valores que no nos interese intentar captar también

430
00:40:32,489 --> 00:40:36,929
por ejemplo una interacción lo antes posible vamos a ver que cuando nosotros

431
00:40:36,929 --> 00:40:42,809
pulsemos una tecla vale al final vamos a poner en el ate que es el que está todo el rato escuchando

432
00:40:42,809 --> 00:40:47,849
cuando sucede algo vamos a poner que capte esa interacción aquí por ejemplo si os fijáis

433
00:40:47,849 --> 00:40:54,809
mismamente si pusiera aquí down para para que sólo capte el momento en el que pulso la tecla

434
00:40:54,809 --> 00:41:01,650
de vale va a haber un momento en el que digamos unity entiende que se ha pulsado cuanto antes sea

435
00:41:01,650 --> 00:41:06,750
ese momento es decir relacionándolo con en cuanto haya otro momento de reproducción cáptalo vale

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

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

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

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

440
00:41:35,369 --> 00:41:37,829
pero yo que sé, puedo convertir una booleana

441
00:41:37,829 --> 00:41:39,610
en falsa en este segundo y eso sí

442
00:41:39,610 --> 00:41:41,389
queda igual, eso cuanto antes también

443
00:41:41,389 --> 00:41:43,730
pues lo pondremos aquí

444
00:41:43,730 --> 00:41:45,469
si esta booleana

445
00:41:45,469 --> 00:41:48,590
cambiar, yo que sé

446
00:41:48,590 --> 00:41:51,510
la queremos convertir en falsa, no sé

447
00:41:51,510 --> 00:41:53,610
estoy haciendo aquí una chorrada, en cuanto le dé

448
00:41:53,610 --> 00:41:55,349
a la tecla D, quiero que suceda eso

449
00:41:55,349 --> 00:41:57,469
ahí no voy a poner un tema en delta time

450
00:41:57,469 --> 00:41:59,510
pues que suceda cuanto más rápido mejor

451
00:41:59,510 --> 00:42:00,809
¿sí?

452
00:42:02,250 --> 00:42:03,030
entonces, bueno

453
00:42:03,030 --> 00:42:04,829
¿qué problema tiene también

454
00:42:04,829 --> 00:42:07,750
y vuelvo a ponerlo como estaba para que lo mantenga

455
00:42:07,750 --> 00:42:09,869
porque, ojo, si dejo

456
00:42:09,869 --> 00:42:10,769
este down, ¿vale?

457
00:42:11,309 --> 00:42:12,010
entiendo que esto

458
00:42:12,010 --> 00:42:15,949
me estáis siguiendo, pero si pongo

459
00:42:15,949 --> 00:42:17,409
que solo sea un get key down

460
00:42:17,409 --> 00:42:19,469
aunque yo mantenga la tecla D

461
00:42:19,469 --> 00:42:21,150
¿vale? me meto aquí

462
00:42:21,150 --> 00:42:23,610
y selecciono el cubo para que se vea, le doy a la tecla D

463
00:42:23,610 --> 00:42:25,630
ahora mismo, y la estoy manteniendo pulsada

464
00:42:25,630 --> 00:42:27,789
bueno, no, en realidad la estoy manteniendo

465
00:42:27,789 --> 00:42:30,010
pulsada y confiada en mí, y no se mueve

466
00:42:30,010 --> 00:42:31,949
se ha movido una fraccioncita

467
00:42:31,949 --> 00:42:33,590
la primera vez, ¿por qué?

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

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

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

471
00:43:18,329 --> 00:43:34,090
¿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.

472
00:43:34,090 --> 00:43:44,849
¿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.

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

474
00:44:03,949 --> 00:44:06,349
pues luego ya lo multiplico

475
00:44:06,349 --> 00:44:08,230
para que vaya más rápido, yo no quiero que vaya tan lento

476
00:44:08,230 --> 00:44:09,530
pero ya lo va a hacer

477
00:44:09,530 --> 00:44:12,369
en base a una velocidad

478
00:44:12,369 --> 00:44:14,269
digamos, estabilizada

479
00:44:14,269 --> 00:44:16,469
y proporcional, con esto yo lo aumento

480
00:44:16,469 --> 00:44:18,030
por eso ahora cuando yo le de

481
00:44:18,030 --> 00:44:20,110
ahora que le he puesto una speed de 100

482
00:44:20,110 --> 00:44:21,530
que multiplicaba bastante

483
00:44:21,530 --> 00:44:24,170
y 100 está bien si solo estáis poniendo

484
00:44:24,170 --> 00:44:25,789
el time delta time, porque fijaos

485
00:44:25,789 --> 00:44:28,190
bueno, de hecho sería 1000, pero si ponemos 100

486
00:44:28,190 --> 00:44:30,170
básicamente volvemos a recuperar

487
00:44:30,170 --> 00:44:31,309
la unidad, entonces

488
00:44:31,309 --> 00:44:33,429
digamos que es lo más equilibrado

489
00:44:33,429 --> 00:44:44,750
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.

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

491
00:44:52,329 --> 00:44:55,969
Que vaya, que a veces va a haber que multiplicarlo por mil o por más.

492
00:44:55,969 --> 00:44:59,510
y bueno, se va sumando en cada fotograma

493
00:44:59,510 --> 00:45:01,329
porque recordad que he quitado el getKeyDown

494
00:45:01,329 --> 00:45:02,889
o getKeyUp y entonces

495
00:45:02,889 --> 00:45:05,389
es el tiempo que yo mantenga esa tecla

496
00:45:05,389 --> 00:45:05,929
pulsada

497
00:45:05,929 --> 00:45:09,429
os queda más o menos

498
00:45:09,429 --> 00:45:11,489
claro por qué es este time delta time

499
00:45:11,489 --> 00:45:13,570
lo de poder multiplicar

500
00:45:13,570 --> 00:45:14,969
valores por sí mismos

501
00:45:14,969 --> 00:45:17,710
bueno, por sí mismos, entre sí, de qué forma

502
00:45:17,710 --> 00:45:20,059
vale

503
00:45:20,059 --> 00:45:22,880
sigamos

504
00:45:22,880 --> 00:45:24,980
vale, esta primera parte

505
00:45:24,980 --> 00:45:25,760
hecha

506
00:45:25,760 --> 00:45:27,500
voy a la siguiente

507
00:45:27,500 --> 00:45:30,340
vale, sí es denso

508
00:45:30,340 --> 00:45:31,360
pero realmente

509
00:45:31,360 --> 00:45:33,659
de mejor o peor manera

510
00:45:33,659 --> 00:45:35,659
yo intento que esto es complicado

511
00:45:35,659 --> 00:45:37,599
ponerlo en el tema en textos

512
00:45:37,599 --> 00:45:39,480
y bueno, también están los vídeos de Álvaro y tal

513
00:45:39,480 --> 00:45:40,519
es complicado

514
00:45:40,519 --> 00:45:43,760
pero por eso estoy repasándolo

515
00:45:43,760 --> 00:45:46,159
por verlo un poco más

516
00:45:46,159 --> 00:45:46,800
en detalle

517
00:45:46,800 --> 00:45:49,800
sí que es verdad que a medida que vaya pasando el curso

518
00:45:49,800 --> 00:45:51,199
me iré deteniendo menos

519
00:45:51,199 --> 00:45:53,119
en explicaciones como concretas

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

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

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

523
00:46:40,940 --> 00:46:45,159
hacen lo que se llama, y creo que no he equivocado, pero lo que se llama pseudocódigo.

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

525
00:46:52,039 --> 00:46:58,420
Significa que hay que intentar ir descomponiendo cada acción que vamos a hacer en una frase.

526
00:46:58,579 --> 00:47:01,699
Pues, por ejemplo, aquí quiero, es lo que estoy haciendo aquí con los argumentos,

527
00:47:02,380 --> 00:47:07,420
ir escribiendo qué quiero conseguir yo y ir poniendo, pues al arrancar el juego,

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

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

530
00:47:26,639 --> 00:47:29,619
ya es ir buscando la forma de hacer esa línea, ¿vale?

531
00:47:29,659 --> 00:47:36,679
Pero al principio abruma mucho intentar hacer todo, porque hay que ir realmente pasito a pasito

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

533
00:47:49,380 --> 00:47:54,679
Y esto tiene algo que ver con lo que voy a explicar ahora de poder declarar nuestros propios métodos.

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

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

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

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

538
00:48:39,260 --> 00:48:44,480
al final va a dar errores o no vais a saber luego que se conecte con esto.

539
00:48:44,480 --> 00:48:46,679
pero sí que es verdad que para que os dé sugerencias

540
00:48:46,679 --> 00:48:48,460
de por dónde tirar si os quedáis atascados

541
00:48:48,460 --> 00:48:50,420
aparte de preguntarme a mí, por supuesto, también

542
00:48:50,420 --> 00:48:52,559
es muy útil

543
00:48:52,559 --> 00:48:54,639
porque además explica

544
00:48:54,639 --> 00:48:56,380
los códigos muy bien si le ponéis algo

545
00:48:56,380 --> 00:48:58,960
entonces, bueno, si en algún momento os quedáis muy atascados

546
00:48:58,960 --> 00:49:01,000
y es algo que sabéis pero no sabéis por dónde tirar

547
00:49:01,000 --> 00:49:02,519
que es la gran

548
00:49:02,519 --> 00:49:04,239
complejidad que tiene este módulo, ¿vale?

549
00:49:04,239 --> 00:49:05,320
que yo voy a dar muchas

550
00:49:05,320 --> 00:49:08,619
todo lo que yo sé y pueda lo voy a ir

551
00:49:08,619 --> 00:49:10,519
dando, pero como bien han dicho, luego hay que

552
00:49:10,519 --> 00:49:12,199
irlo combinando para ir consiguiendo

553
00:49:12,199 --> 00:49:14,440
distintas cosas. En eso es algo

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

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

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

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

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

559
00:50:20,199 --> 00:50:21,400
vale

560
00:50:21,400 --> 00:50:24,179
vale, sigo

561
00:50:24,179 --> 00:50:26,440
sobre lo que os he dicho precisamente

562
00:50:26,440 --> 00:50:26,860
de

563
00:50:26,860 --> 00:50:30,239
a ver, me ponen una duda

564
00:50:30,239 --> 00:50:32,880
voy a aprovechar

565
00:50:32,880 --> 00:50:34,880
para quitarme la sudadera, mientras me la escribes

566
00:50:34,880 --> 00:50:36,139
o me la planteas

567
00:50:36,139 --> 00:50:51,000
la guía de Unity

568
00:50:51,000 --> 00:50:53,260
que nos recomiendas

569
00:50:53,980 --> 00:50:54,820
está en formato PDF

570
00:50:54,820 --> 00:50:56,360
por tener una copia independiente

571
00:50:56,360 --> 00:50:58,679
no sé si está, pero

572
00:50:58,679 --> 00:51:01,199
la verdad es que no tiene mucho sentido, y me explico

573
00:51:01,199 --> 00:51:02,980
lo pone en los apuntes

574
00:51:02,980 --> 00:51:04,880
pero existen dos cosas

575
00:51:04,880 --> 00:51:07,059
el manual, cuando metéis en la documentación

576
00:51:07,059 --> 00:51:08,199
de Unity pone el manual

577
00:51:08,199 --> 00:51:10,380
y la API de scripting

578
00:51:10,380 --> 00:51:13,179
lo primero también es importante

579
00:51:13,179 --> 00:51:15,099
definir la versión que estáis usando

580
00:51:15,099 --> 00:51:16,719
por defecto va a salir la 6

581
00:51:16,719 --> 00:51:19,039
que todavía está como en desarrollo

582
00:51:19,039 --> 00:51:20,980
bueno, ya ha salido pero

583
00:51:20,980 --> 00:51:23,179
todavía puede estar mejor

584
00:51:23,179 --> 00:51:24,880
nosotros estamos usando esta

585
00:51:24,880 --> 00:51:26,940
la 2022.3 que es la última

586
00:51:26,940 --> 00:51:28,659
que yo creo que se puede usar

587
00:51:28,659 --> 00:51:30,219
sin experimentos todavía

588
00:51:30,219 --> 00:51:32,139
entonces, bueno, lo ponéis ahí

589
00:51:32,139 --> 00:51:34,059
y el manual sí que es como un manual

590
00:51:34,059 --> 00:51:36,099
que intenta ir explicando qué hace cada cosa

591
00:51:36,099 --> 00:51:38,500
y ves que tiene secciones, pues mira, me voy a meter en el apartado

592
00:51:38,500 --> 00:51:40,820
de physics, vale, tiene tantos

593
00:51:40,820 --> 00:51:42,579
hipervínculos, vale

594
00:51:42,579 --> 00:51:44,659
que tener un pdf de texto

595
00:51:44,659 --> 00:51:46,559
no es muy operativo

596
00:51:46,559 --> 00:51:48,639
porque la gracia de esto es que se puede

597
00:51:48,639 --> 00:51:49,960
ir saltando de una cosa a otra

598
00:51:49,960 --> 00:51:52,699
e irla viendo, y luego en el scripting

599
00:51:52,699 --> 00:51:54,500
pasa un poco lo mismo, en el scripting

600
00:51:54,500 --> 00:51:56,079
lo que se describe es

601
00:51:56,079 --> 00:51:58,440
los métodos, o digamos

602
00:51:58,440 --> 00:52:00,519
el lenguaje que se ha aplicado, aunque se

603
00:52:00,519 --> 00:52:02,460
parta de C-SARP, ¿vale? Pues como

604
00:52:02,460 --> 00:52:03,960
se ha ido desarrollando distintas

605
00:52:03,960 --> 00:52:06,239
métodos, distintas propiedades,

606
00:52:06,360 --> 00:52:08,360
distintos todos, que son las que luego nosotros

607
00:52:08,360 --> 00:52:10,019
podemos usar en nuestro código, ¿no?

608
00:52:10,480 --> 00:52:12,380
Entonces, la gracia aquí es poder

609
00:52:12,380 --> 00:52:14,400
poner Translate y

610
00:52:14,400 --> 00:52:16,440
te lleva a Translate. Si tú tienes que buscar eso en un

611
00:52:16,440 --> 00:52:18,139
PDF, te cuesta.

612
00:52:18,139 --> 00:52:20,159
Y entender, por ejemplo, el Translate que vamos a

613
00:52:20,159 --> 00:52:21,900
ver ahora, no es ninguno de estos.

614
00:52:22,079 --> 00:52:24,119
Bueno, esto

615
00:52:24,119 --> 00:52:25,880
por ejemplo, es la explicación de que hace

616
00:52:25,880 --> 00:52:27,900
la traslación. Si te metes aquí,

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

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

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

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

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

622
00:53:20,940 --> 00:53:30,719
Entonces, la copia es tenerlo en internet. Vale, vamos con lo que iba.

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

624
00:53:51,380 --> 00:53:55,619
de help se puede acceder a estas dos funcionalidades pero te lo abre en un

625
00:53:55,619 --> 00:54:01,900
navegador vale entonces bueno por lo que el abierto aquí entonces no no que yo

626
00:54:01,900 --> 00:54:06,659
sepa no está pero es que ya te digo que ni siquiera creo que tenga

627
00:54:06,659 --> 00:54:12,820
mucho sentido que te lo den así vale cálculos durante me meto ahí otra

628
00:54:12,820 --> 00:54:18,940
vez perdonadas lo tengo por aquí cálculos durante hay un último operador

629
00:54:18,940 --> 00:54:26,860
que quiero que veamos que es el que se llama módulo vale y el módulo en ocasiones puede ser

630
00:54:26,860 --> 00:54:32,420
útil y de hecho cuando vayamos hablando voy a quitar los de barlos para que no distraigan vale

631
00:54:32,420 --> 00:54:38,119
y me centro en el start me voy aquí abajo y sigo vale el módulo es un operador igual que el de

632
00:54:38,119 --> 00:54:44,840
sumar el de restar el de multiplicar y el de dividir vale que ya tenemos vistos que es con

633
00:54:44,840 --> 00:54:48,619
el porcentaje. Esto es otro operador. ¿Y qué es lo que hace el módulo?

634
00:54:48,880 --> 00:54:52,460
Devolver el resto de una división. Es decir, hace una división,

635
00:54:52,940 --> 00:54:56,119
sabemos lo que hace una división, y si

636
00:54:56,119 --> 00:55:00,900
no da decimales, digamos, ese número, dará cero, y si da decimales, pues dará el resto.

637
00:55:01,880 --> 00:55:05,099
Entonces, por ejemplo, voy a poner aquí un float

638
00:55:05,099 --> 00:55:06,579
que lo voy a llamar módulo.

639
00:55:10,139 --> 00:55:14,670
Resultante, resultante...

640
00:55:14,670 --> 00:55:18,469
y aquí lo que vamos a hacer es

641
00:55:18,469 --> 00:55:20,469
que módulo, esperad que lo planteo

642
00:55:20,469 --> 00:55:22,429
un segundo, que lo tenía para explicarlo

643
00:55:22,429 --> 00:55:24,489
de otra forma, pero quiero verlo aquí primero

644
00:55:24,489 --> 00:55:26,030
módulo resultante

645
00:55:26,030 --> 00:55:27,409
es igual a

646
00:55:27,409 --> 00:55:28,650
9

647
00:55:28,650 --> 00:55:31,210
de 3

648
00:55:31,210 --> 00:55:34,550
y aquí lo que vamos a hacer

649
00:55:34,550 --> 00:55:36,710
es un debug log para ver el resultado

650
00:55:36,710 --> 00:55:37,690
que nos está devolviendo

651
00:55:37,690 --> 00:55:40,429
que va a dar

652
00:55:40,429 --> 00:55:42,309
lo que valga módulo resultante

653
00:55:42,309 --> 00:55:42,650
¿vale?

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

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

656
00:56:02,210 --> 00:56:04,170
¿Este concepto del resto lo tenemos claro?

657
00:56:07,579 --> 00:56:11,500
A ver, que miro el chat. Tengo yo aquí más pantallas abiertas que...

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

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

660
00:56:48,989 --> 00:56:49,789
¿Os acordáis de eso?

661
00:56:52,050 --> 00:56:54,230
Vale, vamos a hacer otro ejemplo.

662
00:56:54,889 --> 00:57:00,369
Si hacemos 10 entre 3, ¿cuál sería el resto?

663
00:57:00,889 --> 00:57:01,530
El resto.

664
00:57:07,079 --> 00:57:07,559
Os lo digo yo.

665
00:57:07,940 --> 00:57:10,000
10 entre 3 no da un resultado.

666
00:57:11,099 --> 00:57:16,000
Sí, esto está en los apuntes, pero todavía nadie me lo ha contestado bien,

667
00:57:16,000 --> 00:57:17,360
así que entiendo que no...

668
00:57:17,360 --> 00:57:19,139
No, hay que hacer una división, ¿vale?

669
00:57:19,159 --> 00:57:20,679
Esto lo que está diciendo es una división.

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

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

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

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

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

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

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

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

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

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

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

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

682
01:00:18,630 --> 01:00:24,510
Siempre el resto va a estar vinculado a eso, a que el resultado sea un número entero

683
01:00:24,510 --> 01:00:30,210
Y luego va a haber determinados valores hasta llegar el divisor

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

685
01:00:34,510 --> 01:00:39,070
Por eso cuando ponemos aquí 4, el resto máximo que puede tener es de 3

686
01:00:39,070 --> 01:00:45,809
Porque si pongo 12 es 0 el resto, si pongo 15 el resto es 3

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

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

689
01:00:55,730 --> 01:00:57,130
Y hay valores intermedios.

690
01:00:58,150 --> 01:01:04,730
Sobre todo, de momento, por ejemplo, nos sirve esto de saber si esto es un valor par o impar

691
01:01:04,730 --> 01:01:14,010
porque luego podemos decir que si módulo resultante es igual a 0 o a 1, ¿vale?

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

693
01:01:24,510 --> 01:01:28,969
Si pongo esto, significa que este número es par, ¿vale?

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

695
01:01:37,510 --> 01:01:38,150
En ese condicional.

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

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

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

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

700
01:02:34,219 --> 01:02:40,940
vale entonces vamos a seguir porque si no nos detenemos pero no entendí pero formule parte

701
01:02:40,940 --> 01:02:47,719
de la pregunta pero vale sí que está más o menos resulta perfecto vamos a este código de aquí vamos

702
01:02:47,719 --> 01:02:53,300
aquí que aquí yo he puesto lo que es un método y voy a poner voy a seguir en esta en este que

703
01:02:53,300 --> 01:03:03,800
tengo aquí que lo tengo más recogido cuando vosotros empleáis después de una clase ponéis

704
01:03:03,800 --> 01:03:07,500
un punto, os va a poner que es un método, que son estos

705
01:03:07,500 --> 01:03:12,039
translate, por ejemplo, getKey en este caso, primero tienen una clase

706
01:03:12,039 --> 01:03:15,739
como transformInput y luego estos métodos que si veis vienen marcados

707
01:03:15,739 --> 01:03:19,619
de amarillo y siempre están continuados por un paréntesis

708
01:03:19,619 --> 01:03:23,460
que puede llevar cosas o no llevar cosas. De hecho, si os fijáis

709
01:03:23,460 --> 01:03:26,400
los momentos de ejecución tienen

710
01:03:26,400 --> 01:03:31,960
son métodos, sí que es verdad que no los llamamos porque ya vienen aquí declarados

711
01:03:31,960 --> 01:03:38,280
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.

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

713
01:03:46,079 --> 01:03:51,400
Y los métodos tienen principalmente dos usos.

714
01:03:52,440 --> 01:04:01,119
Uno, estructurar mejor el código, permitir hacer capítulos, mejor que capítulos, secciones de código

715
01:04:01,119 --> 01:04:05,280
que van ejecutando órdenes y otra es para hacer operaciones en su interior.

716
01:04:06,099 --> 01:04:10,559
Como esto de primeras entiendo que igual no se entiende, vamos a verlo en uso.

717
01:04:12,320 --> 01:04:17,159
Esto viene del tema cero. No sé si le habéis echado un ojo y que igual me decís todos.

718
01:04:17,300 --> 01:04:26,380
Yo ya sabemos cómo se declaran métodos y para qué. ¿Lo vemos? ¿O pasó la tarea?

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

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

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

722
01:05:22,449 --> 01:05:29,670
si ponemos fuera es decir fuera de otro método que haya vale la declaración de

723
01:05:29,670 --> 01:05:34,309
métodos si os fijáis aquí está voy de start vamos y esa llave cierra y aquí

724
01:05:34,309 --> 01:05:39,469
dentro habrá unas instrucciones luego se abre otro void que cierra en sí mismo y

725
01:05:39,469 --> 01:05:42,690
tendrá sus instrucciones nosotros vamos a hacer ahora otro conjunto de

726
01:05:42,690 --> 01:05:47,170
instrucciones y luego lo voy a unir con lo del módulo que estoy hablando de

727
01:05:47,170 --> 01:05:54,809
algunas cosas para luego juntarlas. Podemos hacer un método que se llame

728
01:05:55,050 --> 01:06:01,369
recogeCódigo. ¿Vale? Veis que cuando escribimos después de

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

730
01:06:06,090 --> 01:06:11,289
primera letra, ¿vale? Y bueno, con Pascal case, ¿no? Y posteriormente se pone este

731
01:06:11,289 --> 01:06:16,449
paréntesis. La sintaxis continúa con unas llaves. ¿Qué

732
01:06:16,449 --> 01:06:21,550
lo que acabamos de hacer hemos hecho un método que lo que hace es en base a este nombre vamos

733
01:06:21,550 --> 01:06:26,489
a poder ejecutar un código que va a estar aquí dentro y lo vamos a poder llamar siempre que

734
01:06:26,489 --> 01:06:31,929
queramos igual que aquí cuando ponemos translate o el otro día poníamos instancia vale que es otro

735
01:06:31,929 --> 01:06:37,750
método instancia y por eso vais a ver también que se pone en amarillo vale falta poner lo que nos

736
01:06:37,750 --> 01:06:44,349
pide pero ahí está vale este código una vez se ha declarado así con este void pues yo puedo ahora

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

738
01:06:49,030 --> 01:06:55,670
están los métodos de ejecución, el Start, el Update, el Fixed Update, el Awake, hay distintos.

739
01:06:56,489 --> 01:07:02,469
Pero dentro del Update yo voy a decir, quiero que se ejecute en cada fotograma, recoge código.

740
01:07:02,789 --> 01:07:05,809
Bueno, ahora mismo se ejecutará además si pulsamos la tecla D.

741
01:07:05,809 --> 01:07:09,070
Yo lo voy a poner que sea en cada fotograma impepinablemente.

742
01:07:09,070 --> 01:07:17,110
esto qué significa que yo todo lo que ponga aquí cuando llegue cada vuelta de cada fotograma y se

743
01:07:17,110 --> 01:07:21,789
reproduzca lo que hay dentro de update va a ejecutar lo que hay aquí dentro vale imaginaos

744
01:07:21,789 --> 01:07:30,869
que vamos a poner en vez de recoger código voy a poner un nombre más concreto disparo o salto

745
01:07:30,869 --> 01:07:32,750
o una acción, ¿vale?

746
01:07:34,670 --> 01:07:37,789
Y bueno, como lo he cambiado, pues disparo.

747
01:07:39,309 --> 01:07:42,469
Aquí en cada fotograma se va a ejecutar lo que haya en este disparo.

748
01:07:42,550 --> 01:07:46,670
Si yo pongo que en disparo me ponga debug log,

749
01:07:48,489 --> 01:07:57,050
he disparado, ¿vale?

750
01:07:57,269 --> 01:07:58,369
¿Qué es lo que va a ocurrir?

751
01:07:58,730 --> 01:08:01,250
Que esta orden se va a ejecutar,

752
01:08:01,389 --> 01:08:02,789
porque lo he puesto dentro del update,

753
01:08:02,789 --> 01:08:05,510
en cada fotograma, ¿vale?

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

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

756
01:08:40,789 --> 01:08:45,710
con los métodos va a suceder algo parecido

757
01:08:45,710 --> 01:08:48,270
se pueden ir incorporando entre otros métodos

758
01:08:48,270 --> 01:08:50,409
ya os he dicho que para declarar un método

759
01:08:50,409 --> 01:08:53,409
lo suyo es hacerlo fuera de los métodos de ejecución

760
01:08:53,409 --> 01:08:56,810
porque si no se estará creando también en ese momento de ejecución

761
01:08:56,810 --> 01:08:57,630
y no es lo que queremos

762
01:08:57,630 --> 01:09:00,850
lo vamos a declarar en un punto aparte

763
01:09:00,850 --> 01:09:04,170
y aquí podemos ir haciendo el void salto

764
01:09:04,170 --> 01:09:09,430
y dentro de esto yo puedo ir metiendo aquí las instrucciones de salto

765
01:09:09,430 --> 01:09:11,949
otro que va a ser

766
01:09:11,949 --> 01:09:13,069
voy a ir

767
01:09:13,069 --> 01:09:15,829
correr, yo que sé, os estoy poniendo ejemplos

768
01:09:15,829 --> 01:09:17,289
que ya vais a usar

769
01:09:17,289 --> 01:09:19,810
incluso en esta práctica lo podéis hacer

770
01:09:19,810 --> 01:09:21,750
y con esto lo que conseguimos es ir

771
01:09:21,750 --> 01:09:23,810
las distintas acciones

772
01:09:23,810 --> 01:09:25,409
irlas segmentando

773
01:09:25,409 --> 01:09:27,770
y que en cierto momento cuando pulso

774
01:09:27,770 --> 01:09:29,409
la tecla D, quiero que haga un salto

775
01:09:29,409 --> 01:09:31,970
pues en vez de poner todo el código del salto

776
01:09:31,970 --> 01:09:33,550
pongo esta

777
01:09:33,550 --> 01:09:35,649
digamos esta llamada

778
01:09:35,649 --> 01:09:37,890
al método y lo buscará y ejecutará

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

780
01:09:42,689 --> 01:09:49,069
ese salto un código de 87 líneas y aquí estamos dando las distintas opciones que configuran

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

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

783
01:10:00,250 --> 01:10:04,649
Entonces sería muy farragoso porque al final el código sería muy largo y luego otras

784
01:10:04,649 --> 01:10:10,590
87 líneas para hacer el disparo igual disparo cuando me agacho cuando apunto y cuando tal no

785
01:10:10,590 --> 01:10:14,649
y se van dando muchas condiciones entonces ir copiando todo el rato el mismo código es un

786
01:10:14,649 --> 01:10:20,850
tostón que conseguimos con esto que simplemente poniendo la llamada el disparo pues lo pongo aquí

787
01:10:20,850 --> 01:10:25,470
y que luego aquí hay otra condición que disparó por la copia aquí y que tengo que cambiar algo

788
01:10:25,470 --> 01:10:32,909
de disparo por de manera tal lo cambio aquí si me seguís no entiendo entonces es una forma de ir

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

790
01:10:48,569 --> 01:10:54,890
organizar y conseguir ir encapsulando instrucciones que pueden ser de muchísimas líneas para

791
01:10:54,890 --> 01:11:01,189
que solo con una llamada a ese método se ejecute lo que hay adentro. Luego empieza

792
01:11:01,189 --> 01:11:07,489
complicarse porque como hemos dicho antes los métodos entre sus paréntesis pueden pedir cosas

793
01:11:07,489 --> 01:11:12,189
de hecho yo no puedo poner un translate sin poner nada estoy llamando un método como aquí disparo

794
01:11:12,189 --> 01:11:18,470
y ves que éste no da problemas y éste sí y hay por qué porque cuando se declara el método aquí

795
01:11:18,470 --> 01:11:24,189
vale yo puedo decirle que obligatoriamente haya que pasarle entre estos paréntesis que digamos

796
01:11:24,189 --> 01:11:30,770
que se conecta con el de la declaración con el paréntesis luego de la llamada vale y requiere

797
01:11:30,770 --> 01:11:33,470
que se pase algún valor.

798
01:11:35,229 --> 01:11:36,350
¿Esto cómo se hace?

799
01:11:37,130 --> 01:11:38,989
Y es simple, en realidad, si lo pensamos.

800
01:11:39,310 --> 01:11:40,850
De primeras puede costar, pero es simple.

801
01:11:41,289 --> 01:11:42,630
Igual que declaramos variables

802
01:11:42,630 --> 01:11:45,130
y primero hay que decir de qué tipo es la variable

803
01:11:45,130 --> 01:11:46,430
y luego el nombre de la variable,

804
01:11:47,069 --> 01:11:49,470
aquí también podemos estar pidiendo

805
01:11:49,470 --> 01:11:51,069
lo que se llaman parámetros.

806
01:11:52,010 --> 01:11:54,609
Dentro del método se pueden pedir parámetros.

807
01:11:55,430 --> 01:11:57,590
Y en disparo, ¿qué nos puede interesar?

808
01:11:57,590 --> 01:12:00,250
pues por ejemplo

809
01:12:00,250 --> 01:12:03,329
yo que sé, voy a poner cosas un poco abstractas

810
01:12:03,329 --> 01:12:05,090
pero por ejemplo

811
01:12:05,090 --> 01:12:06,409
puedo pedir

812
01:12:06,409 --> 01:12:08,310
el tipo de

813
01:12:08,310 --> 01:12:10,970
de arma, no sé

814
01:12:10,970 --> 01:12:13,010
¿vale? entonces

815
01:12:13,010 --> 01:12:14,529
para que

816
01:12:14,529 --> 01:12:19,329
voy a, dejadme poner el código

817
01:12:19,329 --> 01:12:19,930
luego lo vemos

818
01:12:19,930 --> 01:12:23,350
tipo de arma, vale, cuando creamos

819
01:12:23,350 --> 01:12:24,869
este string estamos diciendo

820
01:12:24,869 --> 01:12:27,289
que cuando llegue a este momento y veis que ahora

821
01:12:27,289 --> 01:12:29,270
da fallo porque hemos

822
01:12:29,270 --> 01:12:34,649
pedido un parámetro, cuando se declara se llaman parámetros y cuando luego nos lo pida

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

824
01:12:40,449 --> 01:12:44,590
parámetro, que sepáis que se refiere básicamente en dos puntos distintos a lo que hay entre

825
01:12:44,590 --> 01:12:53,949
paréntesis. Pero veis que en cuanto yo ya declaro un tipo de parámetro, ya obligatoriamente,

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

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

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

829
01:13:41,890 --> 01:13:49,810
tiene dos formas de actuar y bueno y si seguimos bajando de hecho tenemos dos luego hay otra aquí

830
01:13:49,810 --> 01:13:58,210
otras dos más luego hay otra aquí ya llevamos cinco otra aquí seis vale seis y de hecho vais

831
01:13:58,210 --> 01:14:06,829
a ver que cuando yo me pongo aquí pone esa forma de usar el método vale más cinco sobrecargas si

832
01:14:06,829 --> 01:14:09,270
Fijáis, está una más cinco, las seis que tienen.

833
01:14:09,689 --> 01:14:15,970
Porque al programar, al declarar, quien haya hecho el código de MonoBehaviour o de CISAR para Unity,

834
01:14:16,789 --> 01:14:23,149
Translate dijo, va a haber cinco formas de pasar valores, de pasar argumentos a este método

835
01:14:23,149 --> 01:14:25,470
para que luego los ejecute de una forma u otra.

836
01:14:25,750 --> 01:14:31,069
¿Os acordáis cuando en la tarea, sí, es decir, han puesto en el chat,

837
01:14:31,250 --> 01:14:34,710
sobrecargas igual a formas diferentes de ejecutar ese método?

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

839
01:14:54,029 --> 01:15:01,229
y según de lo que pusiéramos en la instancia se hacía hija del GameObjectPadre

840
01:15:01,229 --> 01:15:03,890
o no se cogía otra referencia.

841
01:15:03,890 --> 01:15:07,670
Eso significa, porque cuando se diseñó ese InstanceAid,

842
01:15:09,250 --> 01:15:10,890
si nos metemos en ObjectInstanceAid,

843
01:15:12,489 --> 01:15:15,010
bueno, había dos más, pero había estas tres primeras,

844
01:15:15,449 --> 01:15:19,449
bueno, eran estas dos primeras y esta cuarta, las que hemos usado.

845
01:15:19,449 --> 01:15:21,909
están declaradas

846
01:15:21,909 --> 01:15:24,369
todas estas variables de distintas

847
01:15:24,369 --> 01:15:26,329
formas, ¿vale? Y todas son válidas

848
01:15:26,329 --> 01:15:28,270
y apelan a un mismo nombre, Instanced

849
01:15:28,270 --> 01:15:30,729
pero dependiendo del tipo de

850
01:15:30,729 --> 01:15:32,649
parámetro que pasemos

851
01:15:32,649 --> 01:15:34,289
¿vale? Y cuántos pasemos

852
01:15:34,289 --> 01:15:35,890
que también es un valor importante

853
01:15:35,890 --> 01:15:37,930
se ejecutará de una forma u otra

854
01:15:37,930 --> 01:15:40,569
y eso es lo que se llaman sobrecargas

855
01:15:40,569 --> 01:15:42,489
este método tiene

856
01:15:42,489 --> 01:15:44,590
a ver, bueno, es que tiene un montón

857
01:15:44,590 --> 01:15:46,170
si os fijáis, fijaos todo lo que tiene

858
01:15:46,170 --> 01:15:47,710
¿vale? Por eso dependiendo

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

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

861
01:16:14,369 --> 01:16:20,130
Primero, que aquí lo que pongamos obliga a que luego haya que cumplir al llamar ese método.

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

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

864
01:16:48,310 --> 01:17:01,850
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?

865
01:17:01,869 --> 01:17:12,649
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.

866
01:17:12,649 --> 01:17:13,789
Le voy a dar

867
01:17:13,789 --> 01:17:15,989
Y que pone dos veces

868
01:17:15,989 --> 01:17:17,310
Bueno, como está en el update

869
01:17:17,310 --> 01:17:19,630
Pues sale dos veces en cada fotograma

870
01:17:19,630 --> 01:17:20,409
Sin argumentos

871
01:17:20,409 --> 01:17:21,930
Si yo por contra

872
01:17:21,930 --> 01:17:25,550
En esta primera lo dejo como está

873
01:17:25,550 --> 01:17:27,130
Que va a poner sin argumentos

874
01:17:27,130 --> 01:17:27,850
Esta me la voy a cargar

875
01:17:27,850 --> 01:17:29,989
Aunque si no pulsamos la D no ocurriría

876
01:17:29,989 --> 01:17:32,510
Esta pondría sin argumentos

877
01:17:32,510 --> 01:17:33,569
Y en esta voy a decir

878
01:17:33,569 --> 01:17:36,090
El disparo voy a poner

879
01:17:36,090 --> 01:17:38,069
Como lo que me está pidiendo es un string

880
01:17:38,069 --> 01:17:39,189
Hay que pasarlo en string

881
01:17:39,189 --> 01:17:41,430
Y voy a poner, no sé, una colt

882
01:17:41,430 --> 01:17:42,630
Creo que es un tipo de arma

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

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

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

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

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

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

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

890
01:19:16,130 --> 01:19:21,829
entonces hasta que no pongamos en este caso un número vale pues da error

891
01:19:21,829 --> 01:19:25,590
nuevamente porque no cuadra con ninguno busca y dice no hay ninguno que se llame

892
01:19:25,590 --> 01:19:31,729
disparo y tenga dos argumentos de estos tipos que ojo y por eso es importante el

893
01:19:31,729 --> 01:19:38,270
orden de los métodos si yo pongo 5 y colt aunque en teoría estamos haciendo lo

894
01:19:38,270 --> 01:19:42,090
mismo da error porque tiene que ir en el mismo orden en el que se están

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

896
01:19:50,569 --> 01:19:55,909
de lo que pasemos, en este caso, en cada uno de estos dos valores, pues luego el resultado

897
01:19:55,909 --> 01:20:05,010
va a ser distinto, ¿vale? Porque aquí, por ejemplo, va a coger que es colt y más del

898
01:20:05,010 --> 01:20:08,909
calibre y en vez de numerazo voy a llamarlo calibre, ¿vale? Porque me interesa para luego

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

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

901
01:20:27,329 --> 01:20:33,869
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í.

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

903
01:20:52,789 --> 01:20:59,890
Entonces vais a ver que eso se está todo el rato ejecutando así

904
01:20:59,890 --> 01:21:04,369
Y veis que de manera interactiva se están adaptando los valores

905
01:21:04,369 --> 01:21:09,220
A ver, me indican en el chat

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

907
01:21:12,659 --> 01:21:14,659
Sino que lo cambias cuando lo llamas en otra parte del código

908
01:21:14,659 --> 01:21:15,100
¿Me equivoco?

909
01:21:15,399 --> 01:21:16,300
Sí, efectivamente

910
01:21:16,300 --> 01:21:18,119
Tú lo puedes llamar

911
01:21:18,119 --> 01:21:22,439
Claro, todo esto es, pensad, para usarlo a nuestros intereses

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

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

914
01:22:05,810 --> 01:22:07,310
Disparo sería

915
01:22:07,310 --> 01:22:10,050
Espada, vale, y el valor

916
01:22:10,050 --> 01:22:12,050
De daño que quita, vale, la da con la espada

917
01:22:12,050 --> 01:22:14,210
Y el valor que quita de vida es 10

918
01:22:14,210 --> 01:22:15,189
Vale

919
01:22:15,189 --> 01:22:17,829
Si no, yo que sé

920
01:22:17,829 --> 01:22:19,930
Imaginaos que si no, la otra variable es

921
01:22:19,930 --> 01:22:21,210
Si le golpea

922
01:22:21,210 --> 01:22:24,029
O si no, si le golpea

923
01:22:24,029 --> 01:22:24,310
Con

924
01:22:24,310 --> 01:22:28,329
Martillo

925
01:22:28,329 --> 01:22:28,829
Yo que sé

926
01:22:28,829 --> 01:22:31,350
Que hace más daño

927
01:22:31,350 --> 01:22:32,170
Pues aquí

928
01:22:32,170 --> 01:22:34,930
Lo que pondríamos es

929
01:22:34,930 --> 01:22:57,609
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.

930
01:22:57,609 --> 01:23:00,149
Pensad otra vez en el instant seat

931
01:23:00,149 --> 01:23:01,649
El instant seat es un método

932
01:23:01,649 --> 01:23:03,970
Que luego hará lo que sea con los elementos

933
01:23:03,970 --> 01:23:05,449
Que le vamos dando en sus paréntesis

934
01:23:05,449 --> 01:23:07,850
Que en cada ocasión, en este caso es una nave

935
01:23:07,850 --> 01:23:10,310
Pero podría ser un prefab de una casa

936
01:23:10,310 --> 01:23:12,210
O de los pivotes

937
01:23:12,210 --> 01:23:12,909
Que hay ahora en esta

938
01:23:12,909 --> 01:23:15,310
Tarea que hay que esquivar

939
01:23:15,310 --> 01:23:17,510
Eso es para lo que sirve

940
01:23:17,510 --> 01:23:19,989
Definir que cada vez que llamemos

941
01:23:19,989 --> 01:23:22,109
Al método, según el momento en el que estemos

942
01:23:22,109 --> 01:23:24,170
Con un mismo nombre de método

943
01:23:24,170 --> 01:23:25,750
Podemos pasar un montón de

944
01:23:25,750 --> 01:23:30,130
diferentes datos, elementos, variables, lo que queramos.

945
01:23:34,050 --> 01:23:35,770
Voy a parar un segundo.

946
01:23:36,869 --> 01:23:38,369
¿Me seguís más o menos?

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

948
01:23:43,949 --> 01:23:45,590
Solo que los podemos hacer nosotros mismos.

949
01:23:49,520 --> 01:23:51,479
Por ejemplo, voy a hacer otro ejemplo.

950
01:23:53,199 --> 01:23:55,539
Voy a hacer una pequeña calculadora.

951
01:23:55,539 --> 01:23:59,850
¿Vale? Voy a borrar todo esto

952
01:23:59,850 --> 01:24:01,310
Bueno, no

953
01:24:01,310 --> 01:24:04,270
Voy a comentar el update

954
01:24:04,270 --> 01:24:05,970
Porque lo voy a hacer todo en el start

955
01:24:05,970 --> 01:24:08,270
Si me seguís

956
01:24:08,270 --> 01:24:09,670
Digo, o...

957
01:24:09,670 --> 01:24:16,739
A ver, esto por qué no lo...

958
01:24:16,739 --> 01:24:18,100
Me seguís, entiendo que

959
01:24:18,100 --> 01:24:20,560
Solo veo una persona y me da un poco de cosa

960
01:24:20,560 --> 01:24:21,939
Que el resto no me sigáis

961
01:24:21,939 --> 01:24:23,520
Me voy a cargar todo esto

962
01:24:23,520 --> 01:24:25,899
Y voy a hacer

963
01:24:25,899 --> 01:24:28,100
Otro método

964
01:24:28,100 --> 01:24:28,859
Vale

965
01:24:28,859 --> 01:24:32,659
y claro que hablo tanto aquí que sin veros

966
01:24:32,659 --> 01:24:34,500
a veces no sé si estáis poniendo

967
01:24:34,500 --> 01:24:35,819
cara de que me cuenta este tío

968
01:24:35,819 --> 01:24:37,199
o de todo bien

969
01:24:37,199 --> 01:24:40,020
por eso necesito confirmación a veces

970
01:24:40,020 --> 01:24:40,319
vale

971
01:24:40,319 --> 01:24:44,020
vale

972
01:24:44,020 --> 01:24:45,920
bueno he dejado todo muy virgen

973
01:24:45,920 --> 01:24:47,079
está todo comentado

974
01:24:47,079 --> 01:24:50,180
lo único es que como ya lo tengo

975
01:24:50,180 --> 01:24:51,739
ahí aplicado pues

976
01:24:51,739 --> 01:24:52,739
vamos a ello

977
01:24:52,739 --> 01:24:54,880
y esto también me lo voy a cargar

978
01:24:54,880 --> 01:24:57,600
me cargo todo que ya estas partes

979
01:24:57,600 --> 01:24:59,680
yo creo que de momento están explicadas

980
01:24:59,680 --> 01:25:02,960
fuera todo, ya está

981
01:25:02,960 --> 01:25:05,520
me he cansado, perdonad

982
01:25:05,520 --> 01:25:08,319
vale, vamos a hacer una pequeña calculadora

983
01:25:08,319 --> 01:25:10,560
sí

984
01:25:10,560 --> 01:25:12,720
¿ha sido sin querer?

985
01:25:13,619 --> 01:25:14,520
sí, ha sido sin querer

986
01:25:14,520 --> 01:25:17,260
baja la mano y sigo, genial

987
01:25:17,260 --> 01:25:21,020
vale

988
01:25:21,020 --> 01:25:22,939
voy a hacer una pequeña calculadora

989
01:25:22,939 --> 01:25:25,619
y entonces lo que voy a hacer

990
01:25:25,619 --> 01:25:26,260
es declarar

991
01:25:26,260 --> 01:25:29,060
un método llamado

992
01:25:29,060 --> 01:25:41,170
calculadora de momento sin nada de parámetros de argumentos vale entonces al arrancar yo lo

993
01:25:41,170 --> 01:25:49,029
que voy a hacer es decir aquí podría decir bueno pues número una variable un int que sea número

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

995
01:26:04,090 --> 01:26:23,029
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.

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

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

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

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

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

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

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

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

1004
01:28:27,750 --> 01:28:30,170
Aquí estamos referenciando a número A y número B, ¿vale?

1005
01:28:30,310 --> 01:28:35,250
Cuidado cuando llaméis a una variable porque lo que está referenciando es a la que se llama igual.

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

1007
01:28:40,149 --> 01:28:57,989
¿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?

1008
01:28:58,949 --> 01:29:02,170
Cuidado, tiene que ser del mismo tipo de variable, ¿vale?

1009
01:29:02,670 --> 01:29:03,449
Del mismo variable.

1010
01:29:03,630 --> 01:29:10,250
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?

1011
01:29:10,250 --> 01:29:13,869
Si quisiéramos un float, habría que poner aquí que esto sea un float, ¿vale?

1012
01:29:13,869 --> 01:29:14,630
Y ahí no da problema.

1013
01:29:15,510 --> 01:29:15,649
Vale.

1014
01:29:16,149 --> 01:29:19,409
Entonces, 7 y 9.

1015
01:29:20,090 --> 01:29:20,529
Vale.

1016
01:29:20,949 --> 01:29:22,170
¿Qué va a hacer ahora calculadora?

1017
01:29:22,250 --> 01:29:22,810
¿Qué va a devolver?

1018
01:29:32,079 --> 01:29:33,439
A ver si alguien se atreve.

1019
01:29:34,859 --> 01:29:36,199
No, algo va a devolver.

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

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

1022
01:30:27,960 --> 01:30:45,520
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?

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

1024
01:31:06,979 --> 01:31:25,060
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.

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

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

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

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

1029
01:32:43,640 --> 01:32:46,560
¿vale? entiendo que con esto

1030
01:32:46,560 --> 01:32:48,560
veis que si esto luego se aplica

1031
01:32:48,560 --> 01:32:50,399
a vidas o a objetos que se instancian

1032
01:32:50,399 --> 01:32:51,899
o a lo que sea, pues

1033
01:32:51,899 --> 01:32:54,479
con una sola línea podemos

1034
01:32:54,479 --> 01:32:56,399
referenciar a, y este código es muy simple

1035
01:32:56,399 --> 01:32:58,800
pero podríamos tener uno súper complejo

1036
01:32:58,800 --> 01:33:00,399
en el que luego el número D cambie

1037
01:33:00,399 --> 01:33:02,680
metamos el número A y le restamos

1038
01:33:02,680 --> 01:33:04,600
el C, que ahí sí que está cogiendo

1039
01:33:04,600 --> 01:33:06,300
un valor global de todo el juego

1040
01:33:06,300 --> 01:33:08,539
con el que estamos pasando por los

1041
01:33:08,539 --> 01:33:10,680
argumentos, ¿vale? y va operando en base a eso

1042
01:33:10,680 --> 01:33:12,279
¿vale?

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

1044
01:33:33,760 --> 01:33:36,140
casi mejor que te la digo por mí

1045
01:33:36,140 --> 01:33:38,220
creo que es una duda así que me ha surgido

1046
01:33:38,220 --> 01:33:40,520
la clase

1047
01:33:40,520 --> 01:33:42,220
esta que es pública

1048
01:33:42,220 --> 01:33:44,140
pero no es pública y puedes poner parámetros

1049
01:33:44,140 --> 01:33:46,159
que es la que hemos utilizado para

1050
01:33:46,159 --> 01:33:48,039
poner algún objeto, para poder poner

1051
01:33:48,039 --> 01:33:50,180
algún parámetro, ¿se podría hacer

1052
01:33:50,180 --> 01:33:52,079
una calculadora utilizando ese

1053
01:33:52,079 --> 01:33:53,539
tipo de clase? en plan

1054
01:33:53,539 --> 01:33:56,479
poner dos valores para que se sumen, ese resultado

1055
01:33:56,479 --> 01:33:58,100
se multiplica con otro

1056
01:33:58,100 --> 01:33:59,119
número, entonces

1057
01:33:59,119 --> 01:34:01,859
podrías poner en

1058
01:34:01,859 --> 01:34:06,640
En esas cajitas pones 5 y 2, que es lo que se suma, y el resultado que es 7.

1059
01:34:06,739 --> 01:34:12,220
Tú no pones 7, sino que pones resultado suma más resultado lo que sea o un valor.

1060
01:34:12,680 --> 01:34:15,760
Claro, ahora mismo el problema que hay es que está muy cerrado.

1061
01:34:15,880 --> 01:34:18,520
Aquí se pueden ir añadiendo más métodos.

1062
01:34:18,600 --> 01:34:21,039
Si yo, por ejemplo, aquí hago... A ver si te contesto con esto.

1063
01:34:21,340 --> 01:34:23,159
De todos modos, creo que es lo siguiente que iba a explicar.

1064
01:34:23,159 --> 01:34:28,840
Pero si yo pongo aquí número E y yo programo para que el resultado luego sea...

1065
01:34:28,840 --> 01:34:37,539
y voy a poner otro float que es resultado tras multiplicar, ¿vale?

1066
01:34:38,119 --> 01:34:43,380
Si yo aquí a resultado, luego digo, vale, resultado ya lo tengo aquí,

1067
01:34:43,500 --> 01:34:46,220
entonces voy a hacer otro que se llama resultado tras multiplicar,

1068
01:34:46,220 --> 01:34:51,560
que va a ser igual a lo que ya teníamos en resultado por el número e,

1069
01:34:51,760 --> 01:34:53,260
que es el siguiente valor, ¿vale?

1070
01:34:53,260 --> 01:35:13,460
Ahora el problema que va a haber es que necesitamos poner otro argumento, porque este sería 2, por ejemplo. Y aquí 2 también, y aquí 2 para que se vea. Y aquí habría que poner que lo que muestra es resultado tras multiplicar.

1071
01:35:13,460 --> 01:35:14,859
aquí lo que hemos conseguido

1072
01:35:14,859 --> 01:35:17,939
es que se vayan haciendo más operaciones

1073
01:35:17,939 --> 01:35:19,439
¿qué ocurre?

1074
01:35:19,479 --> 01:35:21,439
que si alguna no la quieres o la quieres vacía

1075
01:35:21,439 --> 01:35:23,619
pues dale este error que hay aquí

1076
01:35:23,619 --> 01:35:25,880
sin embargo había una forma

1077
01:35:25,880 --> 01:35:27,779
a ver si recuerdo cómo era

1078
01:35:27,779 --> 01:35:29,399
para poner un valor

1079
01:35:29,399 --> 01:35:31,239
que no es obligatorio poner

1080
01:35:31,239 --> 01:35:33,260
esto si no me equivoco era

1081
01:35:33,260 --> 01:35:34,119
a ver si me acuerdo

1082
01:35:34,119 --> 01:35:37,380
un segundo

1083
01:35:37,380 --> 01:35:40,210
¿pero?

1084
01:35:41,210 --> 01:35:41,729
¿con Z?

1085
01:35:42,609 --> 01:35:44,050
¿el qué?

1086
01:35:44,789 --> 01:35:49,069
0 con Z, o sea, para poner valor en 0, sin que necesite poner valor en...

1087
01:35:49,069 --> 01:35:54,529
Ah, vale. No, me acabas de dar la respuesta. ¿Te refieres a esto?

1088
01:35:55,689 --> 01:35:58,909
Pero no con 0, 0, sino 0 escrito en inglés.

1089
01:35:59,729 --> 01:36:00,569
¿Pero dónde? ¿Aquí?

1090
01:36:03,729 --> 01:36:06,430
No, en int número E igual 0.

1091
01:36:08,170 --> 01:36:10,470
Sí, eso es. Sí, sí, sí. Eso sí.

1092
01:36:10,470 --> 01:36:13,310
Con esto lo que hacemos es

1093
01:36:13,310 --> 01:36:15,350
Que sea obligatorio pasar un

1094
01:36:15,350 --> 01:36:18,010
Es decir, estas dos son obligatorias

1095
01:36:18,010 --> 01:36:19,590
Pasarla, pero esta que hay aquí

1096
01:36:19,590 --> 01:36:21,069
Si no pasa nada

1097
01:36:21,069 --> 01:36:22,949
Lo va a asumir que es un 0

1098
01:36:22,949 --> 01:36:25,189
Y no da error, efectivamente, así es

1099
01:36:25,189 --> 01:36:27,770
Lo único es que si pones 0 va a dar 0

1100
01:36:27,770 --> 01:36:29,890
Lo suyo igual es 1, en este caso

1101
01:36:29,890 --> 01:36:30,909
¿Vale? Pero

1102
01:36:30,909 --> 01:36:33,609
Sí, exacto, si pones un igual

1103
01:36:33,609 --> 01:36:35,689
Y un valor, por defecto, si no se pone

1104
01:36:35,689 --> 01:36:37,130
Nada, pues

1105
01:36:37,130 --> 01:36:39,369
Toma ese, el valor

1106
01:36:39,369 --> 01:36:57,170
Y por eso ahora mismo, 7 más 9, que es lo que tenemos aquí, daría 16. Y por 1, aunque no haya puesto nada, sería 16. Si aquí ya ponemos otro valor y ponemos 2, daría 32. Entonces sí, así se podría hacer.

1107
01:36:57,170 --> 01:37:24,710
Y luego dentro de un método puedes meter otro método también, es decir, que uno se ocupe de la suma y otro de la multiplicación. En caso de que haya un if, claro, esto ya lo puedes hacer más complejo, ir metiendo método, porque tú puedes hacer aquí, por ejemplo, un disparo, que tenga lo que sea dentro, y tú luego aquí también puedes llamar a disparo.

1108
01:37:24,710 --> 01:37:43,630
Entonces, si se cumple tal cosa, pues disparo ocurre tal, si no, la otra. ¿Entendéis lo que quiero decir? Que se pueden ir intrincando ya muchas operaciones. Sí que es verdad que hay que intentar ir haciéndolo lo más limpio y por fragmentos posible, porque si no esto se convierte en un jaleo grande.

1109
01:37:43,630 --> 01:38:08,689
¿Sí? Entonces, por poder se puede. Y efectivamente, si aquí, y esto es lo que si vemos en este caso, vais a ver momentos en el que pone precisamente eso. En estos casos no, pero por ejemplo, uno que me acuerdo ahora mismo, que ahora mismo no sabemos qué es, pero lo que me importa es ver la sintaxis.

1110
01:38:08,689 --> 01:38:29,310
Si os fijáis, este método tiene un montón de parámetros, un vector 3 que se llama origin, otro vector 3, direction. Y luego ya a partir de aquí, todos los que hay son opcionales. Los podemos poner o no en este orden. Si no ponemos nada, se entiende que este de aquí será un infinity, el layer más será el que hay por defecto y este usa global.

1111
01:38:29,310 --> 01:38:44,979
¿Vale? Pero es justo lo que ha dicho el compañero, no me acordaba. Con este igual se define un valor en caso de que no se especifique ese argumento. ¿Vale? Eso es. Bueno, eso es. ¿Vale?

1112
01:38:44,979 --> 01:38:46,340
A lo que iba

1113
01:38:46,340 --> 01:38:47,819
Y voy a la siguiente cosa

1114
01:38:47,819 --> 01:38:51,000
Perdonad que me estoy enrollando mucho

1115
01:38:51,000 --> 01:38:52,119
Pero es que creo que

1116
01:38:52,119 --> 01:38:54,619
Os está aclarando esto cosas

1117
01:38:54,619 --> 01:38:56,479
O ya más o menos las conocíais

1118
01:38:56,479 --> 01:38:59,500
Porque es verdad que esto está en los apuntes

1119
01:38:59,500 --> 01:39:00,920
Pero bueno, lo mismo

1120
01:39:00,920 --> 01:39:01,560
Está un poco

1121
01:39:01,560 --> 01:39:03,640
Sin desarrollar

1122
01:39:03,640 --> 01:39:05,420
Yo voy a ir poniendo otra cosita mientras

1123
01:39:05,420 --> 01:39:08,380
Si me dejáis algún comentario

1124
01:39:08,380 --> 01:39:10,079
Os lo agradeceré

1125
01:39:10,079 --> 01:39:10,460
A ver

1126
01:39:10,460 --> 01:39:18,470
Vale

1127
01:39:19,449 --> 01:39:28,210
Luego, que también lo ponen en los apuntes, no siempre tienen que ser los métodos de tipo void, pueden ser también un tipo de variable, ¿vale?

1128
01:39:28,210 --> 01:39:32,149
Si es void, es lo que hemos dicho, va a ejecutar en su interior lo que haya entre estas llaves.

1129
01:39:32,329 --> 01:39:39,010
Que hay parámetros y argumentos, los aplican estas llaves como se haya definido.

1130
01:39:39,569 --> 01:39:47,329
Pero calculadora, ¿vale? Si yo la llamo, también se puede decir, vale, calculadora, y con esto se restringe también el tipo de resultado que va a dar,

1131
01:39:47,329 --> 01:40:08,880
Se puede decir que sea un int, ¿vale? Y hay que poner que es público, ¿vale? Cuando es void no hace falta, pero cuando es privado sí. A ver, un segundillo, ¿por qué no me está dando esto?

1132
01:40:08,880 --> 01:40:12,380
calculadora, calculadora, no existe

1133
01:40:12,380 --> 01:40:16,760
un segundete, una cosa, perdona, que ahora mismo estoy dudando

1134
01:40:16,760 --> 01:40:20,680
de una historia y no quiero explicarla mal, un segundito

1135
01:40:20,680 --> 01:40:32,409
que mire una cosa, vale, vale, sí

1136
01:40:32,409 --> 01:40:36,310
incalculadora, vale, esto también sale

1137
01:40:36,310 --> 01:40:40,670
cuando tenemos un método declarado para que devuelva

1138
01:40:40,670 --> 01:40:43,909
un tipo de valor, vale, significa que en este

1139
01:40:43,909 --> 01:40:52,270
cuando salgamos de este método, no es que recoja y ejecute lo que hay en su interior, sino que va a dar un resultado concreto, ¿vale?

1140
01:40:52,270 --> 01:41:00,069
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?

1141
01:41:00,069 --> 01:41:18,029
Entonces, la diferencia de sintaxis de esto es que, claro, cuando es un número entero, también hay que declarar algún tipo de argumento, de parámetro.

1142
01:41:18,029 --> 01:41:39,520
A ver, ahí, ¿vale? Cuando luego llamamos a esta variable, cuando tenemos una, que es lo que pone, cuando tenemos una que dice que es de un tipo, hay una sutileza que es que tiene que acabar con un return algo, ¿vale?

1143
01:41:39,520 --> 01:41:54,319
Tiene que acabar con un valor, por ejemplo, número C en este caso. Si ponemos esto, que es cuando ya no da valor, podemos hacer una calculadora que al final lo que vale no tiene que ser reflejado en otra variable, sino que directamente es el resultado lo que da.

1144
01:41:54,319 --> 01:42:14,579
Es decir, si yo pongo aquí un debug log y le digo que me muestre lo que devuelva calculadora con un 5 y un 2, lo que estamos haciendo aquí es que nuevamente estamos conectando esta calculadora,

1145
01:42:14,579 --> 01:42:25,939
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.

1146
01:42:26,119 --> 01:42:34,340
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.

1147
01:42:34,979 --> 01:42:43,020
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.

1148
01:42:43,020 --> 01:43:00,600
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í?

1149
01:43:00,600 --> 01:43:23,340
Return. Vale. Y atención, cuando estamos trabajando y tiene que devolver un valor, ¿vale? El valor tiene que ser de ese tipo. Fijaos que suma, yo lo he declarado como un float. Y por eso da error, porque no puede mostrar, si os recordáis al principio, un float es más específico que un int y no lo puede mostrar. Tendría que ser un int, que eso sí que es lo que devuelve.

1150
01:43:23,340 --> 01:43:41,939
Entonces, ¿qué devolvería aquí? Nuevamente un 7. Pero no es porque se haya ejecutado el debug log dentro del método, sino porque es que cuando llamo a calculadora, tal y como ha sido declarado aquí, vale un 7. Se sustituye por un 7. No es que esté haciendo otras operaciones, es que el propio método es el resultado de una operación.

1151
01:43:41,939 --> 01:43:50,300
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.

1152
01:43:50,920 --> 01:43:59,060
Y ahora si nos fijamos, lo que va a devolver la consola es un 7.

1153
01:44:00,500 --> 01:44:06,539
Esto en cierto momento también tiene sentido, porque lo que vamos a hacer, y esto es un poco lo que apuntaba antes el compañero,

1154
01:44:07,060 --> 01:44:10,600
podemos querer operaciones que luego se convierten en operaciones.

1155
01:44:10,600 --> 01:44:32,600
Entonces, a lo mejor en un cierto momento podemos meter una variable, un método dentro como resultado de otro método. Entonces, incluso pedirlo como un parámetro. Esto ya es más enrevesado, pero por ejemplo, también puede ser, y es lo que tenía preparado aquí,

1156
01:44:32,600 --> 01:44:38,100
que podemos ir declarando una variable de tipo booleano,

1157
01:44:38,100 --> 01:44:41,100
perdón, una variable no, un método de tipo booleano

1158
01:44:41,100 --> 01:44:44,079
que vaya a devolver si algo es verdadero o falso.

1159
01:44:44,500 --> 01:44:47,600
A ver, un segundito, que me estoy quedando...

1160
01:44:48,159 --> 01:44:51,560
Un segundo, me estoy cayendo de la silla.

1161
01:44:55,260 --> 01:44:56,119
Vale, eso.

1162
01:44:56,399 --> 01:45:01,500
Veis que aquí tengo un método que devuelve un valor

1163
01:45:01,500 --> 01:45:02,479
y por eso es un return.

1164
01:45:02,479 --> 01:45:26,319
Por ejemplo, aquí si os fijáis, cuando llame a spar en distintos momentos, spar llama una función con argumento y le pasas un valor que se llama ínteger, que es 7. Si al llamar a esta variable spar le pasamos un 7, que es de tipo numérico, si 7 su resto es igual a 0, devuelvo verdadero.

1165
01:45:26,319 --> 01:45:29,880
si no es falso, esto en realidad está al revés

1166
01:45:29,880 --> 01:45:31,680
porque debería ser, si no es 0

1167
01:45:31,680 --> 01:45:32,960
es falso porque no es par

1168
01:45:32,960 --> 01:45:35,699
pero veis que con esto ya se puede ir definiendo

1169
01:45:35,699 --> 01:45:37,739
luego si es par y da tal cosa

1170
01:45:37,739 --> 01:45:39,680
mi mensaje, la variable es

1171
01:45:39,680 --> 01:45:41,479
es par o es igual a 10

1172
01:45:41,479 --> 01:45:43,880
por ejemplo aquí, lo que tenemos aquí

1173
01:45:43,880 --> 01:45:45,960
voy a copiar esta y lo voy a

1174
01:45:45,960 --> 01:45:46,720
pegar aquí

1175
01:45:46,720 --> 01:45:49,619
en el otro que teníamos y así lo vamos a ver más claro

1176
01:45:49,619 --> 01:45:51,500
tu tu y

1177
01:45:51,500 --> 01:45:52,479
tu tu

1178
01:45:52,479 --> 01:45:55,260
vale, en start

1179
01:45:55,260 --> 01:45:58,659
Spark y lo copio

1180
01:45:58,659 --> 01:46:00,159
de aquí, que la tenía

1181
01:46:00,159 --> 01:46:02,619
que estaba preparada, fijaos en este ejemplo

1182
01:46:02,619 --> 01:46:05,760
vale

1183
01:46:05,760 --> 01:46:08,520
y voy a poner

1184
01:46:08,520 --> 01:46:10,560
que integer, voy a hacer otra variable

1185
01:46:10,560 --> 01:46:12,619
llamada integer, que es como se llama aquí

1186
01:46:12,619 --> 01:46:14,439
que en principio vale

1187
01:46:14,439 --> 01:46:15,140
5

1188
01:46:15,140 --> 01:46:18,579
vale, y bueno, luego hay mi mensaje

1189
01:46:18,579 --> 01:46:20,539
que es, bueno, vamos a ver

1190
01:46:20,539 --> 01:46:22,420
como unos métodos se intrincan

1191
01:46:22,420 --> 01:46:23,600
en otros, viene bien

1192
01:46:23,600 --> 01:46:25,619
el mensaje, vale

1193
01:46:25,619 --> 01:46:53,439
Vamos a ver así rápido esto. Yo tengo un código que he creado dos métodos o funciones para llamarlos cuando me interese. Entonces tenemos el método 1 que va a devolver si lo que le pasemos como número, porque queremos comprobarlo, es par o no, definiendo como puede ser o sí o no, porque puede ser par o no, lo hacemos con un booleano en este caso.

1194
01:46:53,439 --> 01:47:02,899
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.

1195
01:47:04,199 --> 01:47:16,140
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.

1196
01:47:16,140 --> 01:47:32,100
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.

1197
01:47:32,100 --> 01:47:43,579
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.

1198
01:47:43,819 --> 01:47:50,180
Es decir, en este momento pondría true. Esto sería igual, en este caso, lo que devolvería es un true.

1199
01:47:51,520 --> 01:47:53,300
Si no, pues devolvería false.

1200
01:47:53,300 --> 01:47:55,140
vale, pues ya

1201
01:47:55,140 --> 01:47:57,100
espar, que como hemos visto

1202
01:47:57,100 --> 01:47:59,180
no es un vacío, sino que se queda como

1203
01:47:59,180 --> 01:48:00,779
un valor, que en este caso es true

1204
01:48:00,779 --> 01:48:03,220
va a valer ahora para seguir trabajando

1205
01:48:03,220 --> 01:48:03,960
si

1206
01:48:03,960 --> 01:48:06,779
este espar, vale, este true

1207
01:48:06,779 --> 01:48:09,239
es así, vale, si esto es

1208
01:48:09,239 --> 01:48:11,279
true, el mensaje que se va a pasar

1209
01:48:11,279 --> 01:48:13,020
es my integer

1210
01:48:13,020 --> 01:48:15,199
is par, vale, aquí es

1211
01:48:15,199 --> 01:48:17,159
lo que he dicho antes, está al revés y esto

1212
01:48:17,159 --> 01:48:18,520
debería ser false y esto true

1213
01:48:18,520 --> 01:48:20,399
vale, ahora

1214
01:48:20,399 --> 01:48:23,180
ahora esto es

1215
01:48:23,180 --> 01:48:53,159
false. Ahora sí tiene sentido con respecto a que sea par o no sea par. Si mi íntegra es par, va a entrar aquí y va a decir si este resultado es falso, me meto aquí y digo voy a llamar a otro método que tengo aquí y que sea el mensaje que yo pongo aquí, que luego lo voy a reciclar en cada uno porque este sí que es un vacío que no es que devuelva un valor cerrado, sino lo que yo esté procesando en este y que va a coger el mensaje que

1216
01:48:53,159 --> 01:48:57,960
pongamos aquí que es una string para luego devolverlo en este barlog y al

1217
01:48:57,960 --> 01:49:02,220
llamarlo pues lo devuelve vale entonces ahora mismo por poner que

1218
01:49:02,220 --> 01:49:10,399
este valor es 5 va a demostrar que mi mensaje myInteger es impar vamos a

1219
01:49:10,399 --> 01:49:17,100
verlo y yo ahora veo esto y aquí vemos myInteger es par vale porque está

1220
01:49:17,100 --> 01:49:25,939
haciendo esto. Si myInteger es par, me vuelvo falso. Y aquí habría que hacer otra vez.

1221
01:49:26,439 --> 01:49:32,720
Si esto, bueno, lo voy a poner así verbalizado. Si esto es falso, y ahora sí que va a ir

1222
01:49:32,720 --> 01:49:42,220
bien. Si ínteger es igual a falso, es decir, esto es un valor booleano. Si este es igual

1223
01:49:42,220 --> 01:49:49,659
que éste va a decir que esto está al revés también es impar y si no que es par entonces

1224
01:49:49,659 --> 01:49:57,039
ahora cuando yo vaya aquí pues nuevamente la íntegra es paro bueno estoy todo el rato como

1225
01:49:57,039 --> 01:50:06,520
dando vueltas porque si lo que pasamos a ti es igual a cero falso vale si interés falso

1226
01:50:06,520 --> 01:50:11,199
Pues debería estar bien

1227
01:50:11,199 --> 01:50:13,279
Algo estoy haciendo así, que está al revés

1228
01:50:13,279 --> 01:50:15,600
Ah, bueno, claro

1229
01:50:15,600 --> 01:50:16,880
Joder, la que se cumple es esa

1230
01:50:16,880 --> 01:50:17,720
Y aquí esta

1231
01:50:17,720 --> 01:50:22,829
Vale, ahora sí que va a ir bien

1232
01:50:22,829 --> 01:50:24,890
Vamos, esto es, eso es

1233
01:50:24,890 --> 01:50:27,909
Si yo por en cambio, ahora pongo que esto sea 6

1234
01:50:27,909 --> 01:50:29,050
Por poner un valor par

1235
01:50:29,050 --> 01:50:32,050
Ahora es cuando yo sí que voy a poder decir

1236
01:50:32,050 --> 01:50:33,670
Que algo

1237
01:50:33,670 --> 01:50:35,170
Que este valor es par

1238
01:50:35,170 --> 01:50:37,329
¿Vale? Entonces, con esta operación

1239
01:50:37,329 --> 01:50:47,409
lo que hacemos, por ejemplo, es por un lado definir si esto es verdadero o falso, una booleana, porque aquí estamos llevándolo a esto de que sea algo verdadero o falso en relación a si es par o impar,

1240
01:50:47,510 --> 01:50:56,649
pero se podría programar en base a lo que queramos, ¿vale? Y ojo con poner la palabra return cuando no es un void. Y una vez se comprueba ese valor, ¿vale?

1241
01:50:56,649 --> 01:51:03,909
que en realidad se podría poner aquí, porque también se llama aquí, si lo que devuelve este método es falso en este caso,

1242
01:51:04,449 --> 01:51:09,289
llamo a otro método, en vez de poner el debug log aquí directamente, porque se podrían poner más operaciones,

1243
01:51:10,289 --> 01:51:13,489
que conecte con ese mensaje que es el que va a mostrar.

1244
01:51:19,739 --> 01:51:22,859
¿Qué tal? Está aquí. Y ya esto lo dejo y vamos a la tarea.

1245
01:51:24,640 --> 01:51:29,159
Si más o menos me vais entendiendo, sé que se han revezado, pero si más o menos me vais siguiendo,

1246
01:51:29,159 --> 01:51:32,079
funciona así, es pensarlo y darle vueltas

1247
01:51:32,079 --> 01:51:33,520
y ya os digo que yo

1248
01:51:33,520 --> 01:51:35,779
me equivoco mucho también, pero es ir

1249
01:51:35,779 --> 01:51:38,159
viendo las lógicas, todo esto es ir viendo las lógicas

1250
01:51:38,159 --> 01:51:39,699
y poco a poco ir analizando

1251
01:51:39,699 --> 01:51:41,420
qué estamos haciendo en cada momento

1252
01:51:41,420 --> 01:51:45,279
vale, me preguntan, el triple igual

1253
01:51:45,279 --> 01:51:47,500
sé para qué sirve, pero no le veo una función

1254
01:51:47,500 --> 01:51:48,659
concreta o que sea útil

1255
01:51:48,659 --> 01:51:50,539
bueno, pues imagínate

1256
01:51:50,539 --> 01:51:53,020
vale, tampoco te voy a poner

1257
01:51:53,020 --> 01:51:55,199
un super ejemplo así de primeras, pero bueno

1258
01:51:55,199 --> 01:51:57,119
el compañero dice que también puede ser

1259
01:51:57,119 --> 01:51:59,340
un triple igual, vale, el triple igual

1260
01:51:59,340 --> 01:52:01,100
lo que hace, y mira aquí da error

1261
01:52:01,100 --> 01:52:02,680
precisamente por esto seguramente

1262
01:52:02,680 --> 01:52:05,000
es que aparte de que

1263
01:52:05,000 --> 01:52:07,239
en el comparativo sea igual, tiene que ser

1264
01:52:07,239 --> 01:52:09,100
del mismo tipo y como

1265
01:52:09,100 --> 01:52:10,739
aquí, a ver

1266
01:52:10,739 --> 01:52:12,479
qué mensaje me devuelve esto

1267
01:52:12,479 --> 01:52:16,699
mensaje

1268
01:52:16,699 --> 01:52:18,720
sí, número

1269
01:52:18,720 --> 01:52:21,720
pues debería

1270
01:52:21,720 --> 01:52:22,520
funcionar

1271
01:52:22,520 --> 01:52:25,600
y por qué no me deja

1272
01:52:25,600 --> 01:52:27,680
bueno, yo la verdad es que tampoco

1273
01:52:27,680 --> 01:52:29,840
lo uso nunca, pero sirve para decir que

1274
01:52:29,840 --> 01:52:32,000
aparte, cuando hay una variable

1275
01:52:32,000 --> 01:53:05,479
Por ejemplo, es que esto, claro, sí es numérico, pero aquí ahora... A ver, por ejemplo, si ínteger es igual a resultado, ¿vale? A ver, da error porque resultado es...

1276
01:53:05,479 --> 01:53:09,359
Permitid que lo pruebe porque ya te digo que no lo suelo usar

1277
01:53:09,359 --> 01:53:15,029
Sí, es que esto no sé por qué no lo está cogiendo

1278
01:53:15,029 --> 01:53:18,609
Pero vamos, básicamente es que tampoco lo uso yo nunca

1279
01:53:18,609 --> 01:53:22,909
Entonces, lo que quiere decir es que aparte de que sea igual para que el comparativo se dé

1280
01:53:22,909 --> 01:53:28,710
Tienen que ser del mismo tipo, es decir, si uno es entero, el otro también tiene que ser entero

1281
01:53:28,710 --> 01:53:33,010
Y aquí se está cumpliendo, por eso me extraña que no esté dando

1282
01:53:33,010 --> 01:53:36,210
Eso en qué apartado aparecía en los apuntes

1283
01:53:36,210 --> 01:53:39,029
digo, porque esto entiendo que lo has visto

1284
01:53:39,029 --> 01:53:41,590
que no me acuerdo donde explicaba eso

1285
01:53:41,590 --> 01:53:43,170
supongo que en operadores

1286
01:53:43,170 --> 01:53:48,470
lo pondré, ah vale

1287
01:53:48,470 --> 01:53:50,590
sí, en el 0, 3, 2

1288
01:53:50,590 --> 01:53:56,289
bueno, pues no

1289
01:53:56,289 --> 01:53:58,670
no da buen resultado

1290
01:53:58,670 --> 01:53:59,909
a ver, float

1291
01:53:59,909 --> 01:54:02,569
resultado, claro, también porque

1292
01:54:02,569 --> 01:54:04,529
esto, a ver, igual

1293
01:54:04,529 --> 01:54:05,430
a 5

1294
01:54:05,430 --> 01:54:08,510
esto, y aquí voy a poner

1295
01:54:08,510 --> 01:54:10,710
Resultado igual a 7

1296
01:54:10,710 --> 01:54:13,149
Y esto lo pongo como resultado

1297
01:54:13,149 --> 01:54:16,210
Y sigue dando error

1298
01:54:16,210 --> 01:54:18,689
Pues no sé si es que han cambiado algo

1299
01:54:18,689 --> 01:54:20,850
La sintaxis, pero sí debería ser

1300
01:54:20,850 --> 01:54:23,229
Debería ser así

1301
01:54:23,229 --> 01:54:26,149
Ah, esto

1302
01:54:26,149 --> 01:54:33,079
No, la verdad es que no lo sé

1303
01:54:33,079 --> 01:54:34,699
Lo pone y es así

1304
01:54:34,699 --> 01:54:36,300
Porque eso es así, pero

1305
01:54:36,300 --> 01:54:42,960
a ver, claro, esto igual se usaba para los strings

1306
01:54:42,960 --> 01:54:46,979
string, nombre usuario

1307
01:54:46,979 --> 01:54:49,760
yo que sé, vale, si

1308
01:54:49,760 --> 01:54:56,670
nombre usuario es igual a

1309
01:54:56,670 --> 01:55:04,390
bueno, pp, voy a poner, pues ejecuta eso, vale

1310
01:55:04,390 --> 01:55:08,430
si yo pongo aquí otro igual, pues no sé, no sé porque

1311
01:55:08,430 --> 01:55:11,310
lo investigaré, pero vamos

1312
01:55:11,310 --> 01:55:13,050
yo os digo que este no se usa mucho

1313
01:55:13,050 --> 01:55:14,510
de hecho en los apuntes viene bastante

1314
01:55:14,510 --> 01:55:17,109
su número de cadenas

1315
01:55:17,109 --> 01:55:17,789
es igual a otro

1316
01:55:17,789 --> 01:55:20,289
no sé

1317
01:55:20,289 --> 01:55:22,810
sí que funciona así, pero no estoy

1318
01:55:22,810 --> 01:55:24,430
consiguiendo que funcione, entonces bueno

1319
01:55:24,430 --> 01:55:26,270
no quiero darle más vueltas a esto

1320
01:55:26,270 --> 01:55:27,869
para la siguiente lo

1321
01:55:27,869 --> 01:55:30,770
lo vemos otro día, ¿vale?

1322
01:55:31,550 --> 01:55:32,649
me lo recordáis

1323
01:55:32,649 --> 01:55:33,689
vale

1324
01:55:33,689 --> 01:55:35,930
vamos a lo de la tarea

1325
01:55:35,930 --> 01:55:47,989
Ahora, básicamente, a ver, y voy a ir pasando rápido por ciertas cosas que si no, si tenéis dudas me decís, ¿vale?

1326
01:55:48,470 --> 01:55:54,630
Porque para agilizar, que ya ha pasado bastante rato y no hemos empezado con la tarea.

1327
01:55:55,489 --> 01:55:59,250
A ver, esto me está dando error, lo borro.

1328
01:56:01,859 --> 01:56:05,880
Joder, me quedo con esa duda porque en realidad sí que debería funcionar bien, pero bueno.

1329
01:56:05,880 --> 01:56:30,890
Bueno, no me acuerdo por qué. Vale, volvemos aquí y voy a ir a una escena que yo tenía aquí preparada con la nave. Aquí estamos. Cosas a tener en cuenta.

1330
01:56:30,890 --> 01:56:33,949
entiendo que ya todos tenéis claro

1331
01:56:33,949 --> 01:56:35,989
pues como se instancia un objeto, aquí no hace falta

1332
01:56:35,989 --> 01:56:38,170
que instancieis, la nave puede estar ya desde el principio

1333
01:56:38,170 --> 01:56:39,390
en el espacio

1334
01:56:39,390 --> 01:56:41,689
aquí preparada, porque

1335
01:56:41,689 --> 01:56:43,989
en su momento era yo tan pesado con que

1336
01:56:43,989 --> 01:56:44,770
el prefab

1337
01:56:44,770 --> 01:56:48,090
estuviera en el 0, 0, 0

1338
01:56:48,090 --> 01:56:49,909
porque así al empezar

1339
01:56:49,909 --> 01:56:52,189
el juego si está centrado y lo instanciamos

1340
01:56:52,189 --> 01:56:52,850
en el centro

1341
01:56:52,850 --> 01:56:56,090
si toda rotación

1342
01:56:56,090 --> 01:56:58,210
la hacemos en base a su centro

1343
01:56:58,210 --> 01:57:00,029
no va a dar problemas

1344
01:57:00,029 --> 01:57:02,149
de que a lo mejor pongamos el

1345
01:57:02,149 --> 01:57:04,029
el guitmo, el elemento de referencia

1346
01:57:04,029 --> 01:57:05,630
en un ala y gire como

1347
01:57:05,630 --> 01:57:07,869
desviado un poco, ¿vale? Entonces

1348
01:57:07,869 --> 01:57:09,529
cuando hagamos cualquier elemento

1349
01:57:09,529 --> 01:57:11,289
no solo este, sino cualquiera

1350
01:57:11,289 --> 01:57:13,989
en sí el prefab, ¿vale? A no ser que lo hagamos

1351
01:57:13,989 --> 01:57:15,970
a posta, debería tener, igual

1352
01:57:15,970 --> 01:57:18,029
que cuando trabajáis en 3D al modelar

1353
01:57:18,029 --> 01:57:19,930
etcétera, ponéis el punto de ancla

1354
01:57:19,930 --> 01:57:21,989
en donde queréis que gire

1355
01:57:21,989 --> 01:57:23,949
pues hay que tenerlo en cuenta también para

1356
01:57:23,949 --> 01:57:26,010
que esté en ese punto y el

1357
01:57:26,010 --> 01:57:27,890
giro se haga con respecto a donde queráis, ¿no?

1358
01:57:28,170 --> 01:57:29,869
Si por ejemplo modeláis una muñeca y

1359
01:57:29,869 --> 01:57:34,149
el punto de ancla con el que gira está en el hombro, pues va a girar mal. Estos son

1360
01:57:34,149 --> 01:57:40,170
conceptos que entiendo que del módulo animación tenéis claros. Y para simplificar ahora ciertas

1361
01:57:40,170 --> 01:57:45,569
acciones, lo suyo es que hagáis esta nave, la situéis, esta nave que recordemos no se

1362
01:57:45,569 --> 01:57:50,130
va a mover en profundidad sino hacia arriba, abajo, izquierda, derecha, que la situéis

1363
01:57:50,130 --> 01:57:59,010
en el cero en todos los ejes menos en el Y porque va a subir y bajar o en el X, pero

1364
01:57:59,010 --> 01:58:08,970
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?

1365
01:58:09,470 --> 01:58:24,869
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?

1366
01:58:24,869 --> 01:58:36,890
Que algún compañero me ha dicho, ¿se puede cambiar por otra nave o por otro pivote? Sí, siempre y cuando eso, tengáis en cuenta que los puntos de ancla están donde tienen que estar, porque si no va a ser problemático, ¿vale?

1367
01:58:36,890 --> 01:58:58,270
¿Qué habrá que hacer? Bueno, aparte hay que crear un suelo que nuevamente los suyos que estén situados en posiciones cercanas al 0, ¿vale? He generado un suelo que es en esencia un plano, ¿vale? Si generamos un plano y lo situamos en el 0, 0, 0, ¿vale? Como tenemos la nave bien ubicada, al resetearla se genera ahí.

1368
01:58:58,270 --> 01:59:18,029
¿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.

1369
01:59:18,029 --> 01:59:22,609
pero al menos nos da una relación de dónde van a salir esos pivotes, etc.

1370
01:59:24,909 --> 01:59:29,210
Os explico una cosa muy rápida también para que no sea todo tan blanco y se vea mejor

1371
01:59:29,210 --> 01:59:33,989
que es que para dar color, esto ya se verá más adelante en más detalle

1372
01:59:33,989 --> 01:59:38,210
pero para darle un color a un elemento, por ejemplo al suelo y que no sea igual que la nave

1373
01:59:38,210 --> 01:59:42,750
en este blanco impoluto, en una carpeta lo suyo de materiales o de lo que queráis

1374
01:59:42,750 --> 01:59:46,970
con clic derecho podemos crear entre otros elementos un material

1375
01:59:46,970 --> 01:59:52,229
un material que en este caso es físico, es para la visualización de un objeto

1376
01:59:52,229 --> 01:59:55,930
entonces el material voy a llamar suelo, este es el material

1377
01:59:55,930 --> 01:59:59,989
con el que vamos a colorear el suelo, cuando metéis en un material

1378
01:59:59,989 --> 02:00:03,590
que salen con este icono que tenemos aquí, estoy ampliando y reduciendo

1379
02:00:03,590 --> 02:00:07,590
con este slider o con control y la ruleta, se hacen más

1380
02:00:07,590 --> 02:00:11,590
grandes o más pequeños, entre sus parámetros, que hay muchos

1381
02:00:11,590 --> 02:00:15,189
ya lo veremos, hay uno que dice el albedo, que esto imagino que os suena también

1382
02:00:15,189 --> 02:00:22,069
de el módulo de color el albedo que es el color base digamos antes de ser afectado por reflejos

1383
02:00:22,069 --> 02:00:28,270
por metalicidad etcétera podemos cambiarlo de color y decir que sea en este caso lo voy a poner

1384
02:00:28,270 --> 02:00:35,229
un gris un gris azulado da igual si es para que se distinga vale veis que esta bola que muestra

1385
02:00:35,229 --> 02:00:41,810
el material va cambiando en relaciona lo que indique es aquí pues si se pone rojo pues rojo

1386
02:00:41,810 --> 02:00:45,550
Podéis toquetear más cosas

1387
02:00:45,550 --> 02:00:46,970
Ya os digo, no es lo que me interesa ahora

1388
02:00:46,970 --> 02:00:48,310
Y para aplicar un material

1389
02:00:48,310 --> 02:00:50,510
Cuando vais por ejemplo al plane

1390
02:00:50,510 --> 02:00:52,489
Que parece avión pero voy a poner el suelo

1391
02:00:52,489 --> 02:00:53,430
A este GameObject

1392
02:00:53,430 --> 02:00:57,630
Si arrastráis este material al propio GameObject

1393
02:00:57,630 --> 02:00:59,250
O visualmente aquí

1394
02:00:59,250 --> 02:01:00,510
A la pantalla

1395
02:01:00,510 --> 02:01:03,010
Veis que se colorea de ese material

1396
02:01:03,010 --> 02:01:04,890
En esencia lo que está haciendo

1397
02:01:04,890 --> 02:01:06,850
Es que

1398
02:01:06,850 --> 02:01:09,149
Los GameObjects por lo general tienen

1399
02:01:09,149 --> 02:01:11,270
Un componente que se llama

1400
02:01:11,270 --> 02:01:16,550
es renderer que es lo que renderiza esa malla y que tiene un material que se cambia de esta forma

1401
02:01:16,550 --> 02:01:22,329
vale veis que cuando lo pongo coge ese material vale una forma muy rápida ya si queréis tener

1402
02:01:22,329 --> 02:01:28,390
cosas un poquito más vistosas para ir coloreando elementos vale así rápido no es lo que me voy a

1403
02:01:28,390 --> 02:01:34,310
meter ahora sí pero que no sé si a lo mejor me escribís algo en el chat no vale entonces

1404
02:01:34,310 --> 02:02:01,060
Entonces tenemos esta nave. ¿Qué es lo que habrá que hacer ahora con la nave? Pues tenemos aquí este prefab, ya os digo, no lo voy a instanciar, y bueno, yo tengo aquí ya vinculado un script que, bueno, tengo hecho, vamos a empezarlo un poco de cero, pero voy a ir rápido porque, bueno, a ver, durante, durante, pues voy a hacer un script que va a ser el movimiento de la nave.

1405
02:02:01,060 --> 02:02:10,930
movimiento nave vale y ya antes como hemos visto en la estructura de de

1406
02:02:13,470 --> 02:02:18,890
de cómo se hace un transform no vamos a ir a ello vamos a poner esto escribe en esta nave

1407
02:02:18,890 --> 02:02:25,890
que va a definir la nave y nos metemos vamos allá movimiento nave aquí está voy a ir rápido

1408
02:02:25,890 --> 02:02:29,590
vale porque también quiero que le deis vuelta pues luego vosotros con esto que hemos visto

1409
02:02:29,590 --> 02:02:36,069
visto y con lo del tema os digo una forma rápida para hacer la rotación y con esto a ver si vais

1410
02:02:36,069 --> 02:02:40,510
desenvolviendo la tarea durante las navidades etcétera a la vuelta de navidades también si

1411
02:02:40,510 --> 02:02:45,729
me preguntáis cosas concretas en el foro lo vemos vale pero más o menos yo creo que se va a ir en

1412
02:02:45,729 --> 02:02:52,270
caminando con las lógicas que vamos viendo aquí si yo tengo esta nave lo que quiero es que en todo

1413
02:02:52,270 --> 02:02:58,930
momento se vayan captando e interacciones que vayan definiendo que esta nave vaya para arriba

1414
02:02:58,930 --> 02:03:07,890
o para abajo. Las interacciones, igual que se hace con cualquier variable, se pueden

1415
02:03:07,890 --> 02:03:15,750
ir guardando como vectores o como posiciones que tienen valores. ¿Qué es lo que vamos

1416
02:03:15,750 --> 02:03:20,470
a hacer en este caso? Vamos a digregar por un lado los movimientos horizontales y por

1417
02:03:20,470 --> 02:03:27,010
otro lado los movimientos verticales, porque vamos a tener dos ejes de interacción. Hay

1418
02:03:27,010 --> 02:03:32,949
otro tipo de input que son el graxis que sirve esto no lo explica y debería que

1419
02:03:32,949 --> 02:03:38,890
sirve para estar en el tema para en vez de sólo dar un valor que va de 0 a 1 o

1420
02:03:38,890 --> 02:03:44,909
de 0 a activos vale como una booleana que tenga dos ejes contrapuestos pues

1421
02:03:44,909 --> 02:03:48,729
por ejemplo como en una cruceta o en un joystick que tienes una posición hacia

1422
02:03:48,729 --> 02:03:52,510
arriba y otra hacia abajo y son contrapuestas vale lo cual nos puede ser

1423
02:03:52,510 --> 02:03:59,550
muy útil para hacer las posibilidades de movimientos contradictorios o contrarios, ¿no?

1424
02:04:01,310 --> 02:04:10,189
Voy a volver un momento a la escena anterior, ¿vale? Porque teníamos este cubo con cálculos

1425
02:04:10,189 --> 02:04:15,949
durante, que no sé si me cargué, a ver, espera, lo abro, si me cargué lo de la D, creo que sí,

1426
02:04:15,949 --> 02:04:50,840
pero lo tenía por aquí, si no, a ver, tenía otro, es que esto también es importante, porque si no además os ponéis a escribir un montón de código que no es necesario, vale, voy a cálculo durante, a este código que teníamos, aplicado a ese cubo, aquí está, vale, bueno, borro todo lo que había a esto de los cálculos, etcétera, porque nos da un poco igual para este propósito, ahí está y fuera,

1427
02:04:52,279 --> 02:05:09,060
Vale, y vuelvo a hacer un update. Vale, y antes hemos visto qué pasaba si le damos a la tecla D, ¿no? Y bueno, me falta aquí una variable tipo speed, pues speed, por ejemplo, y es 100. Vale, ahí está, ya no da error.

1428
02:05:09,060 --> 02:05:22,239
Antes hemos dicho que si pulsábamos la D, este vector 3 en horizontal, ¿no?, que es el eje X, pues a medida que mantengamos pulsado con este get key la D, se irá moviendo hacia la derecha, ¿vale?

1429
02:05:22,279 --> 02:05:33,699
Inciso rápido. Perdona que haya tantos incisos, pero es que hay tantas cosas. En los apuntes va a poner que hay maneras simplificadas de hablar de estos vectores 3 normalizados.

1430
02:05:33,699 --> 02:05:43,699
Es decir, que solo tenga un valor de 1 en alguno de los ejes, o de 0 incluso en los 3 ejes. Porque en muchas ocasiones, en vez de crear un nuevo vector, podemos decir...

1431
02:05:43,699 --> 02:06:03,539
Y esto está en los apuntes, por eso no me voy a meter mucho, pero es muy útil para marcar direcciones. A ver, vector3.write, que si lo veis, esto también está en los apuntes, es un atajo para escribir vector3, 1, 0, 0, porque el 1, el positivo en horizontal, es hacia la derecha.

1432
02:06:03,539 --> 02:06:24,699
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.

1433
02:06:24,699 --> 02:06:46,899
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.

1434
02:06:46,899 --> 02:06:54,720
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.

1435
02:06:55,180 --> 02:06:59,939
¿Esto qué tal? ¿Lo habéis visto la utilidad? Esto, por ejemplo, en el vídeo de Álvaro lo explica.

1436
02:07:00,380 --> 02:07:05,359
Entonces, no sé si rápido o no, pero es fundamental que entendamos cómo funcionan los getAxis.

1437
02:07:09,039 --> 02:07:12,859
Lo explico rápido, porque entiendo que algunos sí, a lo mejor otros no lo han visto.

1438
02:07:12,859 --> 02:07:32,380
Cuando ponemos un getAxis, lo que hacemos es, lo primero ya no sería un getKey, sino un getAxis, que es otro que tenemos aquí, y entre sus paréntesis, su método, y este sí que pide cosas, nos ponemos encima y nos pide un string, que sea el nombre del axis, podemos decir un eje.

1439
02:07:32,380 --> 02:08:02,739
Y el otro día, si no me equivoco, un compañero lo apuntó. Existen distintos tipos de ejes. También cuando salga un error, si le dais a esta llavecita, os puede dar una solución, pero esta no es la solución.

1440
02:08:02,739 --> 02:08:28,960
Ahora vemos por qué pasa eso. Pero el axis lo que hace referencia es, también vienen los apuntes, si os metéis en Edit, Project Settings, os abre este menú, los axes son los ejes que tiene configurado el juego, el proyecto ya para funcionar.

1441
02:08:28,960 --> 02:08:43,880
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.

1442
02:08:43,880 --> 02:09:03,579
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.

1443
02:09:03,579 --> 02:09:19,180
¿Vale? El negativo será el menos 1, el positivo será el d, y si no lo pulsamos, el positivo será el d, que valdrá 1, ¿vale? Y hay un rango intermedio entre el menos 1 y el 1. ¿Sí? Esto el otro día más o menos lo apunté.

1444
02:09:19,180 --> 02:09:42,909
Aquí debería de permitir coger el axis, input getaxis, a ver qué está pasando, ah bueno, claro, sí, perdón, cuando estamos haciendo, y vuelvo para atrás, cuando estamos poniendo una tecla, ¿vale?

1445
02:09:42,909 --> 02:09:53,850
Un key down, un key, ¿vale? Al final esos valores devuelven un booleano de pulsado o no pulsado, ¿vale? Es un booleano. Este if al final lo que está pidiendo es un booleano.

1446
02:09:53,850 --> 02:10:04,569
Aquí es donde tenemos que ir creando también variables que lo que hagan sea recoger el movimiento, por ejemplo, movimiento horizontal.

1447
02:10:06,529 --> 02:10:13,430
Y lo dejamos ahí como variable global y otro que sea movimiento vertical.

1448
02:10:13,430 --> 02:10:16,409
os acabo de decir que es un eje

1449
02:10:16,409 --> 02:10:18,189
lo que vamos a llamar ahora

1450
02:10:18,189 --> 02:10:20,670
es un eje que va a ir

1451
02:10:20,670 --> 02:10:21,949
entre el menos uno y el uno

1452
02:10:21,949 --> 02:10:24,010
pasando por los distintos valores

1453
02:10:24,010 --> 02:10:26,350
si tenemos aquí

1454
02:10:26,350 --> 02:10:28,670
la a, la d, lo que os he dicho

1455
02:10:28,670 --> 02:10:30,569
el que sale como negativo

1456
02:10:30,569 --> 02:10:32,510
es el menos uno y el positivo

1457
02:10:32,510 --> 02:10:34,630
el uno, si nos

1458
02:10:34,630 --> 02:10:36,710
fijamos, aquí lo que vamos

1459
02:10:36,710 --> 02:10:38,369
a hacer en el update y por eso os he dicho antes

1460
02:10:38,369 --> 02:10:40,050
que era bueno el update para captar

1461
02:10:40,050 --> 02:10:42,510
interacciones, es que vamos a guardar

1462
02:10:42,510 --> 02:10:46,710
en una variable de tipo numérico, un float que cogerá los decimales

1463
02:10:46,710 --> 02:10:49,869
entre el menos uno y el uno para tener los valores intermedios.

1464
02:10:50,350 --> 02:10:56,170
Si por ejemplo estamos usando un joystick, pues no es pulsar una tecla A o D

1465
02:10:56,170 --> 02:10:59,430
que siempre es un número entero, porque está dando esa señal,

1466
02:10:59,770 --> 02:11:02,510
sino que puede haber valores intermedios a medida que movemos el joystick,

1467
02:11:03,229 --> 02:11:05,210
en este caso representados como decimales.

1468
02:11:05,210 --> 02:11:25,130
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,

1469
02:11:25,130 --> 02:11:41,170
sino que el condicional, digamos, que va a funcionar el propio código, lo que vamos a conseguir aquí, si multiplicamos por este moveHorizontal, lo escribo y ahora lo analizamos,

1470
02:11:41,170 --> 02:11:59,909
¿Vale? Es, y ojo a la jugada, tenemos una variable que funciona en todo el código porque es global para los valores horizontales, ¿vale? Que va a ir guardando en cada fotograma según lo pulsemos en qué punto de este eje estamos interactuando, ¿vale?

1471
02:11:59,909 --> 02:12:14,310
Si estamos pulsando, en este caso, la A o la D, ¿vale? Que son los que están configurados, ¿vale? Entonces, aquí, si pulsamos la D, se estará guardando un 1. Si pulsamos la A, se estará guardando en move horizontal un menos 1.

1472
02:12:14,310 --> 02:12:38,890
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.

1473
02:12:39,630 --> 02:12:50,369
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.

1474
02:12:51,010 --> 02:13:04,170
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,

1475
02:13:04,170 --> 02:13:14,010
no como con cero, porque todo lo que se multiplica por cero es igual a cero, aquí estamos siempre controlando una variación de movimiento en el eje X, en el horizontal.

1476
02:13:14,850 --> 02:13:24,130
Luego hay un time delta time que siempre va a estar devolviendo resultados en cuanto se reproduce, como hemos visto, y un speed que, a no ser que nosotros configuremos en cero,

1477
02:13:24,130 --> 02:13:32,010
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

1478
02:13:32,010 --> 02:13:43,729
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,

1479
02:13:43,729 --> 02:13:58,729
Si es un menos uno, valdrá un menos uno. Por eso los axis son tan interesantes, porque al jugar, digamos, si yo pulso solo con esa línea, la tecla D va hacia la derecha, si pulso la A va hacia la izquierda.

1480
02:14:00,550 --> 02:14:11,270
Entonces ahí podemos ir teniendo en un axis este movimiento. Esto ya se podría poner directamente en la nave. Y de hecho lo vamos a hacer ahora mismo.

1481
02:14:11,270 --> 02:14:30,170
Veo una duda por ahí, pero dame un segundo que voy a volcar esto en la que estábamos haciendo de la nave. Si yo al código que estoy haciendo en la nave ya le digo exactamente esto, y tengo movimiento nave aquí, a ver, ¿dónde lo tengo?

1482
02:14:30,170 --> 02:14:43,329
que aquí tengo muchas pestañas, movimiento nave, aquí estaría, vale, voy a copiar estos mismos valores, vale, un segundo, voy a copiar estos mismos valores

1483
02:14:43,329 --> 02:14:56,210
que tengo aquí y los voy a volcar, espera que voy a también poner esto aquí, vale, vale, como variable global estos, vale, vuelco un poco lo que tenía,

1484
02:14:56,210 --> 02:14:57,670
no estoy haciendo otra cosa

1485
02:14:57,670 --> 02:15:01,979
en el update, vale, y este de cálculo

1486
02:15:01,979 --> 02:15:03,800
durante yo lo puedo cerrar y este lo guardo

1487
02:15:03,800 --> 02:15:05,640
vale, es lo mismo

1488
02:15:05,640 --> 02:15:07,520
se lo estoy aplicando a la nave

1489
02:15:07,520 --> 02:15:09,699
¿no? entonces el movimiento horizontal

1490
02:15:09,699 --> 02:15:11,720
de la nave, si voy aquí

1491
02:15:11,720 --> 02:15:12,600
y le doy a play

1492
02:15:12,600 --> 02:15:15,579
pues si le doy a la A

1493
02:15:15,579 --> 02:15:17,880
a la D va a la derecha y si le doy a la A

1494
02:15:17,880 --> 02:15:19,579
va a la izquierda, vale

1495
02:15:19,579 --> 02:15:20,979
ahora mismo se está moviendo

1496
02:15:20,979 --> 02:15:22,600
bueno, claro, es que estoy

1497
02:15:22,600 --> 02:15:25,460
en una escena que

1498
02:15:25,460 --> 02:15:27,220
ya tiene muchas cosas configuradas

1499
02:15:27,220 --> 02:15:40,840
Voy a quitar el follow. Por defecto, y esto es una práctica buena, cuando empecéis a trabajar la cámara va a quedarse quieta porque nada está diciendo que siga a la nave.

1500
02:15:40,840 --> 02:16:00,659
Vale, entonces, de momento, bueno, es otra de las cosas que se os pide en la tarea, de momento, alejadla todo lo posible para ir viendo los movimientos o abrir la ventana de escena que podemos navegar aquí para ir viendo estas interacciones, ¿vale? Porque la cámara se va a ir viendo según ubiquemos la cámara.

1501
02:16:00,659 --> 02:16:24,039
Si está en un punto que no están viendo al objeto, pues no se ve. Ahora mismo el código que hemos cambiado, que no hay otro previo, es el de la nave y ya podemos ir izquierda a derecha. De esta forma, de una forma más o menos rápida, lo que podemos hacer es ir a los Project Settings y buscar.

1502
02:16:24,579 --> 02:16:29,720
Tenemos algún valor, si vamos abriendo cada uno de estos, que sirva para subir y bajar la nave.

1503
02:16:30,100 --> 02:16:37,719
Y aquí tenemos uno que, tanto las teclas W y S, como las de arriba y abajo de la cruceta, ya vendrá configurada como vertical.

1504
02:16:38,260 --> 02:16:39,200
Vamos a usar ese axis.

1505
02:16:39,200 --> 02:16:44,319
Que, ojo, nosotros podemos ir cambiando los axis e ir creando más si añadimos aquí más números.

1506
02:16:44,959 --> 02:16:49,920
Pero vamos a aprovechar esto que se llama vertical para hacer lo mismo con el movimiento vertical.

1507
02:16:49,920 --> 02:17:03,819
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.

1508
02:17:03,819 --> 02:17:19,319
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.

1509
02:17:19,920 --> 02:17:35,440
¿Vale? Entonces, a ver, un segundito, que tengo aquí molestándome una ventana. Vale, entonces, lo que vamos a hacer es, bueno, pues el movimiento horizontal ya lo teníamos y aquí vamos a hacer otro movimiento vertical, ¿vale?

1510
02:17:35,440 --> 02:17:58,700
La diferencia es que va a ir controlando el movimiento vertical, que es el eje Y, por tanto ponemos aquí el 1, porque vamos a afectar al movimiento vertical, y va a ir trasladando, lo voy a poner bien porque si no va a dar error, lo que yo vaya interactuando en este eje entre WS o la cruz de arriba o de abajo de la cruceta.

1511
02:17:58,700 --> 02:18:13,180
Entonces, este número que estamos recogiendo está aquí, como move vertical. Entonces, ahora por separado vamos a tener un movimiento que se va a ocupar de lo horizontal y otro movimiento que se va a ocupar de lo vertical.

1512
02:18:14,020 --> 02:18:21,620
Si vamos aquí a esto, y el instanciador lo voy a desbloquear para no ver cosas que no hemos hecho,

1513
02:18:24,079 --> 02:18:28,840
yo ya puedo subir y bajar la nave y ir a la derecha e izquierda con estas teclas que tenemos.

1514
02:18:29,540 --> 02:18:33,979
Sin ningún tipo de límite, puedo atravesar el suelo, etc., porque no hay nada que lo impida.

1515
02:18:37,950 --> 02:18:40,729
Entonces, con esto podemos ir viendo esto.

1516
02:18:40,729 --> 02:19:04,370
Es mucho más rápido y por eso os decía antes, poner un vector 3 right cuando vayamos a hacer instrucciones horizontales y otra cuando sean instrucciones, un vector 3 up, que es la forma simplificada de poner el eje vertical para hacer esta subida y bajada.

1517
02:19:04,370 --> 02:19:27,709
¿Vale? Como tampoco tengo ya mucho tiempo de tutoría y la compañera parecía que esto sí lo había hecho y habrá otra tutoría antes de la entrega de esta tarea, ¿vale? Me podéis preguntar en el foro. Voy a decir el método más rápido para hacer... Es que quería explicar lo que he explicado y lo quería dejar ya explicado porque así nos quitamos dudas futuras.

1518
02:19:27,709 --> 02:19:31,909
Voy a hablar de cómo hacer la rotación

1519
02:19:31,909 --> 02:19:33,370
La forma más simple que hay

1520
02:19:33,370 --> 02:19:34,950
Vamos a ello

1521
02:19:34,950 --> 02:19:37,309
Para hacer esto

1522
02:19:37,309 --> 02:19:39,790
La lógica que voy a seguir

1523
02:19:39,790 --> 02:19:40,670
Es un poco la misma

1524
02:19:40,670 --> 02:19:44,030
Voy a hacer otra variable

1525
02:19:44,030 --> 02:19:45,629
Otro float

1526
02:19:45,629 --> 02:19:48,389
Que voy a llamar, yo que sé, rotate data

1527
02:19:48,389 --> 02:19:52,409
Que preparo aquí

1528
02:19:52,409 --> 02:19:54,069
Y luego en el update

1529
02:19:54,069 --> 02:19:56,030
Voy a hacer otro axis

1530
02:19:56,030 --> 02:19:57,950
Que sirva para indicar que el menos uno

1531
02:19:57,950 --> 02:20:05,870
vaya a la izquierda la rotación y a la derecha la rotación con la E, por ejemplo, o con otra tecla, ¿vale?

1532
02:20:06,069 --> 02:20:11,450
Entonces, lo que voy a hacer es guardar nuevamente en el update, a medida que se van haciendo las actualizaciones,

1533
02:20:12,770 --> 02:20:18,489
pues un input getAxis, que en este caso no va a venir creado, ¿vale?

1534
02:20:18,709 --> 02:20:23,290
No va a haber uno que defina nuestras interacciones como queremos.

1535
02:20:23,290 --> 02:20:42,049
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?

1536
02:20:42,049 --> 02:20:57,290
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.

1537
02:20:57,290 --> 02:21:08,270
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.

1538
02:21:08,829 --> 02:21:23,870
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.

1539
02:21:23,870 --> 02:21:39,889
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?

1540
02:21:39,889 --> 02:22:03,229
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.

1541
02:22:03,229 --> 02:22:20,049
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.

1542
02:22:20,049 --> 02:22:37,709
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.

1543
02:22:37,709 --> 02:22:42,870
Perdonad si a veces digo cosas que tengo la cabeza un poco frita de tanto hablar.

1544
02:22:43,450 --> 02:22:51,190
Entonces, el problema que os habréis encontrado es que, claro, igual que aquí usamos el transform translate,

1545
02:22:51,670 --> 02:22:54,510
había otro método que se llama transform rotate.

1546
02:22:56,709 --> 02:22:58,209
Lo tengo aquí.

1547
02:22:58,209 --> 02:23:08,030
Igual que el transform translate, si nos ponemos encima, da error porque pide argumentos.

1548
02:23:08,770 --> 02:23:20,549
Entonces, ¿cómo se puede hacer una forma rápida de que gire una nave hasta la izquierda y la derecha?

1549
02:23:20,549 --> 02:23:41,729
Que entiendo que si yo dejo esto aquí y digo vector 3, voy a hacer lo equivalente a lo que acabamos de hacer con el translate. Pongo vector 3 y en este caso el eje de rotación es el del horizonte. Por tanto, es forward. Se gira en relación al eje que está mirando.

1550
02:23:41,729 --> 02:23:46,629
Entonces, si queremos que gire hacia derecha o izquierda, el eje es el que va en profundidad.

1551
02:23:46,969 --> 02:23:48,750
Esto también lo ponen los apuntes, entiendo.

1552
02:23:49,290 --> 02:23:56,750
Y lo que vamos a hacer es un poco la misma lógica, que se multiplique por el valor que estemos dando a rotate data.

1553
02:23:57,450 --> 02:24:02,530
Y también debería estar por un time delta time, para que sea estable, como hemos hablado,

1554
02:24:02,709 --> 02:24:06,729
y por una velocidad que lo suyo sería que fuera diferente a la de...

1555
02:24:06,729 --> 02:24:23,870
De hecho, la voy a hacer aquí. Float Speed, pero de rotación. Y le voy a poner que esta sea... Yo qué sé. Esto es ir probando e ir ajustando. 50, ¿vale? Ahora mismo, si vamos al juego, ¿vale? Guardo.

1556
02:24:23,870 --> 02:24:27,750
teóricamente, cuando yo dé a las teclas U e I

1557
02:24:27,750 --> 02:24:30,790
igual que muevo arriba y abajo con las que ya había definido

1558
02:24:30,790 --> 02:24:33,670
con U y con I

1559
02:24:33,670 --> 02:24:35,450
veis que va rotando

1560
02:24:35,450 --> 02:24:38,569
entonces con eso ya

1561
02:24:38,569 --> 02:24:41,190
yo puedo estar con las teclas que he definido antes

1562
02:24:41,190 --> 02:24:44,290
moviendo la nave hacia arriba y hacia abajo

1563
02:24:44,290 --> 02:24:47,469
y con la rotación vamos rotando

1564
02:24:47,469 --> 02:24:49,450
hasta aquí una forma

1565
02:24:49,450 --> 02:24:52,370
esto ahora tiene dos peros que os digo ahora mismo

1566
02:24:52,370 --> 02:24:53,709
¿hasta aquí me seguís?

1567
02:24:53,870 --> 02:25:24,590
Más o menos. La tarea se entrega el miércoles que viene. ¿Esta tarea está para el miércoles que viene? A ver. Porque si no, la retraso. No pasa nada. A ver. Fecha máxima para el 18 de diciembre. Sí, efectivamente. La voy a retrasar, ¿vale? A después de Navidades. ¿Vale? Porque sí que es verdad que depende un poco del ritmo. El año pasado la recogí en enero, así que no pasa nada.

1568
02:25:24,590 --> 02:25:28,250
pero bueno, os comento

1569
02:25:28,250 --> 02:25:30,129
como hacerlo, si lo que me importa es que sepáis

1570
02:25:30,129 --> 02:25:32,149
hacerlo, pero la traslado

1571
02:25:32,149 --> 02:25:33,590
a...

1572
02:25:33,590 --> 02:25:34,969
voy a abrir aquí un calendario

1573
02:25:34,969 --> 02:25:38,170
luego la cambio, pues si volvemos de navidad

1574
02:25:38,170 --> 02:25:39,989
es como el

1575
02:25:39,989 --> 02:25:42,110
8 de enero

1576
02:25:42,110 --> 02:25:43,969
la voy a poner para la semana

1577
02:25:43,969 --> 02:25:45,889
siguiente, vale, el problema

1578
02:25:45,889 --> 02:25:47,409
de esto es que se va, a ver

1579
02:25:47,409 --> 02:25:49,329
un segundo, cuando tengo yo prevista

1580
02:25:49,329 --> 02:25:51,170
una cosa, perdón

1581
02:25:51,170 --> 02:25:56,379
vale, retrasaré también un poco la siguiente

1582
02:25:56,379 --> 02:26:18,840
Vale, ok. La retraso ya después de enero, no hay problema. Vale, pero bueno, me vais siguiendo esto de la rotación, ¿no? Vale, el problema que podéis tener es que, claro, cuando luego subís y bajáis, lo hace en relación a dónde está mirando la rotación.

1583
02:26:18,840 --> 02:26:51,639
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,

1584
02:26:51,639 --> 02:27:03,719
hay otro de tipo space, ¿vale? Que por defecto, como hemos dicho, está sobre sí mismo, ¿vale? Pero hay otra versión que es space con respecto al mundo.

1585
02:27:04,020 --> 02:27:13,420
¿Qué cambia eso? Que en este caso es fundamental para que sea más sencillo. Que nosotros aquí estamos todo el rato operando para tener el primer argumento parámetro

1586
02:27:13,420 --> 02:27:27,639
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.

1587
02:27:27,860 --> 02:27:36,780
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.

1588
02:27:36,780 --> 02:27:53,360
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.

1589
02:27:56,879 --> 02:28:02,219
Ahora mismo estamos aquí, muevo, con la U giro y esto está invertido.

1590
02:28:02,579 --> 02:28:07,000
Cuando doy a la U está yendo hacia la izquierda y a la I a la derecha.

1591
02:28:07,780 --> 02:28:12,959
Entonces yo ahora cuando le doy arriba, sí que lo hace, veis que lo hace con respecto al mundo.

1592
02:28:13,620 --> 02:28:15,219
Da igual hacia dónde esté mirando la nave.

1593
02:28:15,219 --> 02:28:33,239
¿Vale? Entonces, con esto ya resolvemos ese problema de tener distinta orientación, ¿vale? Que también nos puede interesar llegar al punto que la subida y bajada sea en relación a donde esté mirando la nave, ¿sí?

1594
02:28:33,239 --> 02:28:35,920
la compañera que al principio

1595
02:28:35,920 --> 02:28:38,579
esto le vamos a dar más vueltas en el futuro

1596
02:28:38,579 --> 02:28:40,319
¿vale? de momento

1597
02:28:40,319 --> 02:28:42,280
para la entrega, bueno

1598
02:28:42,280 --> 02:28:44,159
lo que son la distanciación de los pivotes

1599
02:28:44,159 --> 02:28:45,780
y el movimiento continuo y el destroy

1600
02:28:45,780 --> 02:28:48,219
quienes lo hayáis intentado

1601
02:28:48,219 --> 02:28:49,180
lo tenéis claro

1602
02:28:49,180 --> 02:28:52,120
ya os digo, vais a tener navidades

1603
02:28:52,120 --> 02:28:53,920
también para hacer esta tarea, que lo voy a alargar

1604
02:28:53,920 --> 02:28:56,219
pensaba que estaba para enero, de todo modo

1605
02:28:56,219 --> 02:29:04,340
vale

1606
02:29:04,340 --> 02:29:06,559
pues vamos a hacer esa cosa

1607
02:29:06,559 --> 02:29:08,399
lo vamos a dejar por aquí

1608
02:29:08,399 --> 02:29:25,459
Pero lo de la rotación con esto te vale. Es verdad que me gustaría, pero no va a ser esencial para el apto o no apto, que no solo la rotación fuera libremente así como tenemos para que sea todo el giro, sino que a los 90 grados se restrinja.

1609
02:29:25,459 --> 02:29:46,639
Pero eso tiene varios peros. Pero de momento podéis ir gestionándolo así. Lo de los pivotes, etc. Intentadlo. Hay pistas en el enunciado, se habla del destroy. Es poner una condicional de cuando se sobrepase una cierta distancia al moverse el pivote hacia cámara, que se destruya ese objeto.

1610
02:29:46,639 --> 02:29:49,500
Lo tendréis que poner en el script del propio objeto

1611
02:29:49,500 --> 02:29:54,020
Creo que más o menos está elaborado en la tarea

1612
02:29:54,020 --> 02:29:59,639
Lo voy a dejar aquí a menos que me digáis algo concreto que queráis ver

1613
02:29:59,639 --> 02:30:04,379
Porque también, a ver, hacer un nuevo input para la rotación

1614
02:30:04,379 --> 02:30:06,860
Claro, voy a ello

1615
02:30:06,860 --> 02:30:09,860
Lo que hemos hecho aquí, lo que he hecho

1616
02:30:09,860 --> 02:30:13,559
A ver, esperad, que lo tengo acá

1617
02:30:13,559 --> 02:30:17,020
y aquí ya que estamos

1618
02:30:17,020 --> 02:30:18,219
por si lo estáis viendo

1619
02:30:18,219 --> 02:30:19,899
vamos a darle una rotación propia

1620
02:30:19,899 --> 02:30:23,040
a una velocidad propia

1621
02:30:23,040 --> 02:30:23,659
de la rotación

1622
02:30:23,659 --> 02:30:26,920
básicamente es hacer un eje

1623
02:30:26,920 --> 02:30:28,819
que se va a ocupar

1624
02:30:28,819 --> 02:30:31,180
de recoger en una variable de tipo float

1625
02:30:31,180 --> 02:30:33,020
el menos uno o el uno

1626
02:30:33,020 --> 02:30:34,739
que capture con

1627
02:30:34,739 --> 02:30:37,020
los inputs horizontales

1628
02:30:37,760 --> 02:30:39,299
es decir, con la A o con la B

1629
02:30:39,299 --> 02:30:40,860
en este caso

1630
02:30:40,860 --> 02:30:43,440
porque es lo que está configurado en el input manager

1631
02:30:43,440 --> 02:30:54,180
Se puede cambiar. Luego, otra variable distinta que se llama moveVertical y va a coger el 1 y el menos 1 de la W y la S, las teclas de subir y bajar normalmente.

1632
02:30:54,860 --> 02:31:06,299
Y luego va a haber otra, que es este eje que hemos creado nosotros, que hemos customizado, que es el rotateData o se podría llamar moveRotation, no sé,

1633
02:31:06,600 --> 02:31:11,040
que lo que va a coger es el menos 1 o el 1, en este caso de la U y la I, porque son las teclas que he hecho.

1634
02:31:11,920 --> 02:31:19,299
Luego, igual que hemos hecho que haya un vector normalizado, un 1, 0, 0 en el eje que queramos mover,

1635
02:31:19,799 --> 02:31:23,239
que es el que se multiplica por este input, que si no tocamos nada es 0.

1636
02:31:23,659 --> 02:31:26,139
Por eso si no tocamos nada, esto no actúa nada.

1637
02:31:26,559 --> 02:31:32,459
Hasta que no varíe alguno de estos valores que siempre están multiplicando, no va a haber una interacción.

1638
02:31:33,079 --> 02:31:36,219
Luego todos, como están en el update y son movimientos para que sean estables,

1639
02:31:36,219 --> 02:31:40,879
se multiplican por el time delta time y se multiplica también por una velocidad

1640
02:31:40,879 --> 02:31:46,700
que lo que hace es aumentar el detrimento, la reducción que se ha tenido por estos valores

1641
02:31:46,700 --> 02:31:51,020
que antes hemos visto que eran decimales, que genera el time delta time, ¿vale?

1642
02:31:51,260 --> 02:31:59,420
Y por último, si es necesario, hay otro parámetro dentro del translate y en el rotate también,

1643
02:31:59,680 --> 02:32:05,520
que es que los movimientos se hagan en base a sí mismo, en cuyo caso aquí pondría space.self,

1644
02:32:06,219 --> 02:32:15,739
¿Vale? O con respecto al mundo, que es lo que nos interesa aquí para que no considere la rotación que está teniendo el objeto cuando lo vamos rotando, que es que lo hago en torno al mundo.

1645
02:32:16,059 --> 02:32:29,079
¿Vale? Y la rotación es lo mismo. Lo hace con respecto al eje de profundidad, ¿vale? Y nuevamente esto es lo mismo que escribir vector 3, 0, 0, 1, ¿vale?

1646
02:32:29,079 --> 02:32:32,819
Porque en este caso el eje sobre el que gira es el de profundidad, ¿vale?

1647
02:32:33,319 --> 02:32:38,739
Y lo multiplica por el valor que está recogiendo en este float de rotador, ¿vale?

1648
02:32:38,799 --> 02:32:41,540
Igual lo equilibramos y le damos una velocidad mayor,

1649
02:32:42,040 --> 02:32:46,540
que para que no sea exactamente la del movimiento, pues he hecho otra variable con otro valor.

1650
02:32:46,639 --> 02:32:48,659
Pero vamos, podría ser también la del movimiento.

1651
02:32:48,799 --> 02:32:54,479
Eso es por tener, digamos, un poco desgregadas las opciones, ¿vale?

1652
02:32:54,479 --> 02:33:16,899
Esta se puede hacer de muchas formas y luego lo mismo, lo suyo probablemente sería de las dates que se vayan cogiendo los inputs y para hacer los límites hacer voids en plan movimiento nave, ¿vale?

1653
02:33:16,899 --> 02:33:19,899
y yo aquí meto todo lo que sea del movimiento nave.

1654
02:33:20,040 --> 02:33:22,340
Por ejemplo, estas líneas las meto aquí.

1655
02:33:23,340 --> 02:33:27,799
Y aquí en todo momento está mirando, está buscando movimiento nave.

1656
02:33:28,940 --> 02:33:30,819
A ver, ¿por qué no me lo coge?

1657
02:33:33,260 --> 02:33:33,899
¿Por qué?

1658
02:33:39,340 --> 02:33:40,979
¿Qué he llamado yo movimiento nave?

1659
02:33:41,399 --> 02:33:45,399
Bueno, movimiento nave, sí.

1660
02:33:48,280 --> 02:33:49,340
Ah, vale, sí.

1661
02:33:49,340 --> 02:34:05,459
Pero nada, bueno, esto veis que conflicto, como se llama igual el método que he creado que la clase, que es su padre, no se puede, ¿vale? Pues la voy a llamar moverNave, fijaos porque está dando ese error, ¿vale? MoverNave, ¿vale? Ahí sí está.

1662
02:34:05,459 --> 02:34:30,819
Y luego otro que sea RotarNave, que esto es lo de siempre. Luego dentro de estas llaves podemos irlo complicando. Esto es un void y aquí meto esto y aquí hay un RotarNave.

1663
02:34:30,819 --> 02:34:58,659
Aquí, si os fijáis, estoy usando esa forma de emplear los métodos para recopilar código, ¿vale? Entonces, bueno, con esto, simplemente para que veáis que acabamos con algo que funciona, ya tendríamos el movimiento de la nave, ¿vale? Y si doy a la I y a la U, ahora va más lento porque he cambiado la speed rotation, que la he hecho a la mitad, ¿vale? Con la I y la U, pues voy haciendo que rote, ¿vale?

1664
02:35:00,819 --> 02:35:04,579
Entonces, más o menos, el movimiento estaría.

1665
02:35:04,579 --> 02:35:13,920
Luego, lo que habrá que hacer es que estos movimientos solo se ejecuten cuando no se traspasen ciertas coordenadas.

1666
02:35:14,120 --> 02:35:22,979
En plan, si la altura es mayor de donde está la nave, si es mayor que 10 en i,

1667
02:35:23,739 --> 02:35:27,780
pues entonces que este movimiento deje de producirse.

1668
02:35:28,120 --> 02:35:30,059
Y con eso podemos ir definiendo también límites.

1669
02:35:30,819 --> 02:35:45,299
Pero bueno, eso os dejo probarlo a vosotros. De momento, para ir ya realizando el movimiento de la nave, etc. Ah, vale, me habíais escrito. ¿Cómo has creado el Input Get Axis que has llamado rotador?

1670
02:35:45,299 --> 02:35:53,780
Vale, lo llamas rotador, como se puede llamar de cualquier forma, y es en Edit, Project Settings, y hay un apartado de Input Manager, ¿vale?

1671
02:35:53,819 --> 02:36:01,159
Donde están los axis, los diferentes. Pues tú aquí, para crear uno nuevo, si el número que tengas le sumas otro.

1672
02:36:01,479 --> 02:36:06,579
Lo que va a hacer es añadir otro axis llamado como el último que haya, ¿vale?

1673
02:36:06,719 --> 02:36:11,360
Ahí, perdona. Vale, me ha creado uno. Con esto es el número que hay. Ahora se va a quitar cuando ponga 19.

1674
02:36:11,360 --> 02:36:25,620
Si ya tienes alguno en el que quieres basarte, al darle clic derecho se puede duplicar ese elemento y aquí te metes y dices, pues este se va a llamar rotador y aquí las teclas son la U y la I, ¿vale? Etcétera.

1675
02:36:25,620 --> 02:36:47,020
Y aquí va modificando estos valores, ¿vale? Esto lo voy a borrar, que es el que tenía ahí. Vale, importante. Una cosa importante, cuando puedes reiniciar los valores de los access, no. Hasta donde yo sé, no.

1676
02:36:47,020 --> 02:36:51,770
ya te vienen por defecto

1677
02:36:51,770 --> 02:36:53,489
y que yo sepa

1678
02:36:53,489 --> 02:36:55,489
no te deja reiniciar

1679
02:36:55,489 --> 02:36:57,190
a ver, pues mira

1680
02:36:57,190 --> 02:36:58,809
si le das a input manager

1681
02:36:58,809 --> 02:37:01,209
reset, lo reinicias

1682
02:37:01,209 --> 02:37:02,989
por defecto

1683
02:37:02,989 --> 02:37:05,290
y por tanto, rotador me lo he cargado

1684
02:37:05,290 --> 02:37:11,209
vale, ahí lo voy a dejar

1685
02:37:11,209 --> 02:37:13,329
que si no, para el próximo día si continuamos de aquí

1686
02:37:13,329 --> 02:37:15,409
vale, y como está

1687
02:37:15,409 --> 02:37:17,250
girando al revés, lo que voy a hacer es

1688
02:37:17,250 --> 02:37:18,709
cambiar aquí la I y la U

1689
02:37:18,709 --> 02:37:20,370
y ahora ya sí va a girar como quiero

1690
02:37:20,370 --> 02:37:32,129
Vale, algo más así, iré estudiando, abriré el tema 3, el 18 de hecho, no sé por qué lo hice coincidir, pero bueno, con la entrega de la 2.

1691
02:37:32,129 --> 02:37:42,229
Y irle echando un ojo, ¿vale? Poco a poco lo iremos viendo. Sé que es farragoso, sé que son muchas cosas, pero bueno, es que es así el proceso, vaya.

1692
02:37:42,229 --> 02:38:03,469
Pero bueno, hoy hemos terminado de ver un poco el plantamiento farragoso de las bases de programación, lo que está en el tema cero, yo creo. Así, sobre todo, lo más importante, que me faltaba hablar de cómo se creaban métodos, está ahí. Ya va a ser todo un poco más aplicado ya a los temas que vayan abriéndose.