1
00:00:07,410 --> 00:00:16,980
De hecho, voy a hacer una cosa también para que sepamos que un vector, el que he creado antes, es privado.

2
00:00:17,379 --> 00:00:23,719
Yo no tengo acceso a él, pero yo puedo crear uno que sea no público, pero sí que puedo acceder a él a través de la interfaz de Unity, como ya vimos.

3
00:00:25,800 --> 00:00:34,420
Una variable serializada de tipo vector3, que le voy a llamar destinationPosition, es decir, hacia dónde se dirigirá.

4
00:00:35,420 --> 00:00:38,079
Y ya está. Y no le doy nada más, no le doy ningún valor. ¿Por qué?

5
00:00:39,619 --> 00:00:48,159
Y esto es lo bueno de las variables serializadas, igual que de las variables públicas, ya lo tenemos que saber, es que me permite dar los valores directamente en el inspector.

6
00:00:48,439 --> 00:00:54,579
Vemos que aquí nos aparece esa variable creada y como es de tipo vector3 nos aparece con sus tres parámetros. Maravilloso.

7
00:00:55,700 --> 00:01:04,700
¿Eso qué significa? Que yo le voy a decir, por ejemplo, desplázate 1 en x, 0 en y y 0 en z. De hecho voy a poner mi cubo en la posición 0, 0, 0.

8
00:01:04,700 --> 00:01:13,340
Si yo cojo el vector en el que estoy ahora mismo y le sumo este otro vector, ¿qué me dará?

9
00:01:13,459 --> 00:01:18,599
Pues vamos a comprobarlo. Y así comprobamos que efectivamente podemos sumar vectores.

10
00:01:19,599 --> 00:01:26,859
De hecho, voy a crear otro vector que es final position, por ejemplo, de tipo vector 3.

11
00:01:26,859 --> 00:01:29,340
se va a llamar final position

12
00:01:29,340 --> 00:01:34,750
entonces, aquí tengo

13
00:01:34,750 --> 00:01:40,650
la posición inicial es el vector 3 en el que estoy cuando arranco

14
00:01:40,650 --> 00:01:44,769
pues la posición final, que es otro vector 3

15
00:01:44,769 --> 00:01:50,480
va a ser la suma de la posición inicial

16
00:01:50,480 --> 00:01:54,019
más, es decir, tengo la posición inicial

17
00:01:54,019 --> 00:01:55,920
que va a ser en la que empieza el objeto

18
00:01:56,760 --> 00:02:02,700
Tengo la de destino, que esa la voy a añadir a través de la interfaz de Unity, que es la que se va a sumar.

19
00:02:03,480 --> 00:02:08,539
Y tengo la posición final, que va a ser la suma de una y otra.

20
00:02:09,460 --> 00:02:12,360
¿Y cuál va a ser esta? Pues lo vamos a comprobar ahora mismo, porque lo voy a mandar a pantalla.

21
00:02:12,939 --> 00:02:17,280
Si lo lanzo, recordamos, nuestro cubo está en posición 0, 0, 0.

22
00:02:18,560 --> 00:02:21,340
La de destino será 1, 0, 0, 0.

23
00:02:23,080 --> 00:02:25,460
¿Y cuál es la posición final?

24
00:02:25,460 --> 00:02:54,419
Pues ahí me lo dice. 1, 0, 0. Es la suma entre uno y otro. De hecho, si yo por ejemplo le digo que el vector que voy a sumar va a ser de 10, 5, 2 y la posición inicial es de 2, 1, 0, pues si lanzo, ¿cuál es mi vector final? 12, 6, 2. ¿Por qué? Porque es la suma de 2 más 10, de 1 más 5, de 0 a 2.

25
00:02:54,419 --> 00:03:00,840
Si yo quiero mover un objeto, no tengo que hacer más que una cosa, que es tomar la posición en la que está el objeto,

26
00:03:01,520 --> 00:03:05,960
determinar otro vector al que quiero moverlo, sumarle un vector, eso me da otra posición,

27
00:03:06,759 --> 00:03:10,599
y lo que tengo que decirle es, vale, ahora te mueves tu posición a esa nueva posición.

28
00:03:11,259 --> 00:03:16,800
Y vuelvo otra vez a empezar el bucle. Vamos a comprobarlo y vamos a comprobar cómo efectivamente podemos animar ese cubo.

29
00:03:17,199 --> 00:03:22,419
Lógicamente el bucle es algo que se ejecuta en cada fotograma, con lo cual yo le digo que en cada fotograma

30
00:03:24,419 --> 00:03:28,680
primero que obtenga la posición en la que está el objeto, porque lógicamente va a ir cambiando.

31
00:03:29,159 --> 00:03:31,979
Entonces necesito obtenerla de nuevo en cada fotograma, en cada actualización.

32
00:03:32,699 --> 00:03:34,960
Le voy a decir dónde se tiene que desplazar.

33
00:03:35,039 --> 00:03:36,060
¿Y dónde se tiene que desplazar?

34
00:03:37,300 --> 00:03:41,740
A la posición final, que es un vector 3 resultante de sumar su posición inicial

35
00:03:41,740 --> 00:03:48,659
más este vector que he creado yo aquí, que además como está serializado lo puedo poner manualmente.

36
00:03:48,659 --> 00:03:49,860
¿Y ahora qué es lo que me queda?

37
00:03:50,240 --> 00:03:52,060
Decirle que se mueva, como hemos hecho antes.

38
00:03:52,060 --> 00:03:57,520
Como hemos hecho al principio, que le decíamos que se pusiese al comenzar el script, pero ahora se lo vamos a decir cada fotograma.

39
00:03:57,520 --> 00:04:05,490
Donde decimos transformPosition es igual a este vector3 resultante.

40
00:04:09,180 --> 00:04:10,219
Esto ya no me hace falta.

41
00:04:11,520 --> 00:04:19,660
Cuando lance el juego, en cada fotograma, y eso tenemos que recordarlo, va a obtener la posición inicial del cubo.

42
00:04:19,720 --> 00:04:20,920
Lo voy a empezar en 0, 0, 0.

43
00:04:22,759 --> 00:04:26,240
A esa posición inicial le va a sumar un vector. ¿Cuál? El que tengo aquí.

44
00:04:26,240 --> 00:04:30,519
Y, por ejemplo, le voy a decir que se desplace 1 en X, 0 en Y y 0 en Z.

45
00:04:30,639 --> 00:04:32,100
Es decir, se va a mover en el eje X.

46
00:04:32,279 --> 00:04:35,959
Y le va a dar un vector resultante, es decir, ahora mismo le daría 1, 0, 0.

47
00:04:36,399 --> 00:04:39,180
Pero es que en el siguiente fotograma mi cubo está en el 1, 0, 0.

48
00:04:39,500 --> 00:04:41,839
Así que le dirá, bueno, pues ahora muévete al 2, 0, 0.

49
00:04:42,100 --> 00:04:44,279
Y ahora al 3, 0, 0. Y ahora al 4, 0, 0.

50
00:04:44,680 --> 00:04:46,759
Resultado, pues un cubo a la fuga.

51
00:04:48,279 --> 00:04:48,620
Ahí está.

52
00:04:49,720 --> 00:04:50,759
Ha salido disparado.

53
00:04:50,759 --> 00:04:52,860
Aquí es cuando necesitaría una cámara que lo siguiese.

54
00:04:53,339 --> 00:04:58,300
Pero, antes de seguir, vamos con un concepto que vamos a manejar mucho a lo largo del curso, que es

55
00:04:58,300 --> 00:05:00,160
¿cuánto se está moviendo este cubo?

56
00:05:01,399 --> 00:05:05,079
Pues bien, para responder a esa pregunta, lógicamente, tenemos que pensar en fórmulas matemáticas,

57
00:05:05,180 --> 00:05:09,300
en el sentido de que, si le he dicho que cada fotograma se desplace 1 en X,

58
00:05:09,699 --> 00:05:12,660
y yo, por ejemplo, me estoy moviendo a 48 fotogramas por segundo,

59
00:05:12,920 --> 00:05:15,720
significa que cada segundo se va a desplazar 48 en X.

60
00:05:15,879 --> 00:05:19,779
Pero, ¿qué pasa si mi ordenador va lento y bajo el número de fotogramas por segundo?

61
00:05:19,779 --> 00:05:25,459
Paso a 24. Pues entonces mi objeto se moverá a 24 unidades por segundo en X.

62
00:05:26,420 --> 00:05:29,279
Conclusión, se mueve más lento. Eso es inasumible.

63
00:05:30,100 --> 00:05:33,160
Así que tenemos que buscar una fórmula en la que la velocidad de movimiento

64
00:05:33,160 --> 00:05:35,680
dependa del número de fotogramas por segundo.

65
00:05:36,220 --> 00:05:40,420
¿Eso cómo lo conseguimos? Pues con un parámetro muy interesante

66
00:05:40,420 --> 00:05:44,060
que se llama Time, Delta Time.

67
00:05:44,319 --> 00:05:47,439
Para que vayamos acostumbrándonos, si yo le pregunto a Unity

68
00:05:47,439 --> 00:05:53,139
que me busque todo lo que tiene de time, veréis que hay muchas cosas que nos

69
00:05:53,139 --> 00:05:59,680
permite jugar con el tiempo. Y entre ellas una de las más importantes, esta. Y

70
00:05:59,680 --> 00:06:05,480
si le preguntamos qué es, nos dice que es cuánto tiempo ha pasado desde nuestro

71
00:06:05,480 --> 00:06:09,699
último fotograma. ¿Qué significa? Que si yo me estoy moviendo a un fotograma por

72
00:06:09,699 --> 00:06:14,740
segundo y le pregunto a time delta time, me dirá que 1, ha pasado un segundo entre

73
00:06:14,740 --> 00:06:18,519
mi último fotograma, pero si me estoy moviendo a dos fotogramas por segundo, me dirá que

74
00:06:18,519 --> 00:06:22,319
ha pasado medio segundo, uno partido de dos. Y si me estoy moviendo a diez fotogramas por

75
00:06:22,319 --> 00:06:26,199
segundo, pues una décima de segundo. Y esto es muy importante porque si yo multiplico

76
00:06:26,199 --> 00:06:33,079
mi movimiento por ese parámetro y compensará en función del rendimiento del juego. Vamos

77
00:06:33,079 --> 00:06:41,199
a comprobarlo. Si yo a esta final position le digo que es esto, pero multiplicado por

78
00:06:41,199 --> 00:06:47,459
lo que hemos visto, el deltaTime, estoy consiguiendo lo que acababa de decir.

79
00:06:48,000 --> 00:06:50,959
Se mueve a más o menos velocidad. ¿Veis?

80
00:06:52,160 --> 00:06:54,980
¿Queremos que se mueva más rápido? Pues nada, queremos una variable

81
00:06:54,980 --> 00:06:58,180
a la que pueda acceder de tipo float

82
00:06:58,180 --> 00:07:02,680
llamada speed. Cubo yo valor inicial sea 0.

83
00:07:04,019 --> 00:07:05,819
¿Eso qué significa? Que si yo

84
00:07:05,819 --> 00:07:10,720
a mi posición final, que es un vector 3,

85
00:07:10,720 --> 00:07:20,439
Lo multiplico por deltaTime, pero a su vez eso lo multiplico por mi variable de velocidad, que además es una variable pública.

86
00:07:21,680 --> 00:07:23,800
¿Qué es lo que obtengo? Ahí está.

87
00:07:24,079 --> 00:07:28,279
Si ahora le doy al play veréis que no se mueve. ¿Por qué? Porque lo estoy multiplicando por cero.

88
00:07:28,740 --> 00:07:29,939
La velocidad es cero.

89
00:07:30,279 --> 00:07:35,060
Pero de nuevo, lo maravilloso de poder modificar los parámetros en el tiempo de ejecución.

90
00:07:35,060 --> 00:07:37,620
podemos ponernos encima de la variable

91
00:07:37,620 --> 00:07:39,560
veréis que salen dos flechitas indicando

92
00:07:39,560 --> 00:07:41,360
que podemos cambiar su valor y ahí vamos

93
00:07:41,360 --> 00:07:43,540
sube la velocidad y vemos que

94
00:07:43,540 --> 00:07:45,699
el cubo se acelera, se acelera más

95
00:07:45,699 --> 00:07:47,540
o incluso si le doy un valor

96
00:07:47,540 --> 00:07:48,019
negativo

97
00:07:48,019 --> 00:07:51,680
pues lógicamente estoy multiplicando un vector por un número

98
00:07:51,680 --> 00:07:53,160
negativo, es decir, su inversa

99
00:07:53,160 --> 00:07:55,399
y como casi siempre ocurre

100
00:07:55,399 --> 00:07:57,259
hay una forma mejor de hacer las cosas

101
00:07:57,259 --> 00:07:59,379
y en ese sentido recomiendo siempre

102
00:07:59,379 --> 00:08:01,519
explorar el scripting reference

103
00:08:01,519 --> 00:08:03,740
el manual de referencia de los scripts

104
00:08:03,740 --> 00:08:09,379
de Unity para descubrir o buscar si lo que estamos haciendo lo estamos haciendo bien

105
00:08:09,379 --> 00:08:10,860
o lo podemos hacer mejor.

106
00:08:11,040 --> 00:08:15,100
Lo que hemos aprendido para mover objetos no es la forma adecuada de mover objetos.

107
00:08:15,300 --> 00:08:19,779
Sencillamente lo he usado para también aprender otros conceptos como es los vectores, la suma

108
00:08:19,779 --> 00:08:23,180
de vectores o incluso para empezar a movernos con soltura en el código.

109
00:08:23,639 --> 00:08:29,040
Pero si nos vamos, por ejemplo, a la página, como he dicho, de Unity y buscamos el método

110
00:08:29,040 --> 00:08:33,600
transform veremos que tiene por supuesto unas propiedades asociadas y unos

111
00:08:33,600 --> 00:08:37,899
métodos que si no son son útiles pues los podemos usar son públicos y están

112
00:08:37,899 --> 00:08:42,299
hechos para facilitarnos la vida y de hecho entre ellos si buscamos hay muchos

113
00:08:42,299 --> 00:08:46,980
pero veremos que hay uno que es el método translate y qué es lo que hace

114
00:08:46,980 --> 00:08:51,519
ese método mover el objeto es decir que eso que hemos hecho vamos a decir un

115
00:08:51,519 --> 00:08:56,220
poco a lo bruto pues unity lo tiene ya resuelto para que lo hagamos de forma

116
00:08:56,220 --> 00:09:01,620
más fácil y lo vamos a comprobar. Si me voy al código que tenía asociado a mi cubo manteniendo

117
00:09:01,620 --> 00:09:05,759
la variable de velocidad, fijémonos que eso que antes he hecho con varias líneas y además con un

118
00:09:05,759 --> 00:09:12,139
poco de comedura de coco, pues lo voy a hacer sólo en una sola línea. ¿Cómo? Accediendo efectivamente

119
00:09:12,139 --> 00:09:18,740
a la clase de transform de mi objeto, en este caso a mi componente transform y siempre os recuerdo

120
00:09:18,740 --> 00:09:24,000
que aquí os aparecerán una serie de métodos y atributos y entre los métodos por supuesto está

121
00:09:24,000 --> 00:09:30,419
el método translate. Y ese método nos pide

122
00:09:30,419 --> 00:09:34,220
que un vector, hacia dónde voy a

123
00:09:34,220 --> 00:09:38,299
desplazarlo, y ahí es donde yo tendría que darle un vector al que me

124
00:09:38,299 --> 00:09:42,480
desplazo. Podría incluso declararlo aquí y decirle new vector 3

125
00:09:42,480 --> 00:09:46,360
pero no lo voy a hacer. ¿Por qué? Porque de nuevo vuelvo a recordar lo que

126
00:09:46,360 --> 00:09:49,879
acabo de decir. Siempre hay una forma mejor de hacerlo, o casi siempre.

127
00:09:50,100 --> 00:09:53,580
Y si me voy al scripting reference de Unity y le pregunto

128
00:09:54,440 --> 00:09:56,879
¿Qué métodos tengo yo para mi vector 3?

129
00:09:57,379 --> 00:10:04,309
Lo busco, me voy a sus propiedades, a sus atributos, y fijaros lo que encuentro aquí.

130
00:10:05,049 --> 00:10:12,070
Yo puedo definir un vector 3 al vuelo y pasarle directamente un parámetro, decirle back,

131
00:10:12,230 --> 00:10:17,190
pues entonces él va a generar un vector 3 que esté en esa posición, o en esta,

132
00:10:17,889 --> 00:10:21,350
si quiero que vaya hacia abajo, o hacia adelante, o hacia la izquierda,

133
00:10:21,350 --> 00:10:25,190
o incluso que se desplace uno en todos los sentidos

134
00:10:25,190 --> 00:10:30,429
o incluso uno que es un vector 3 en 0, 0, 0

135
00:10:30,429 --> 00:10:32,169
¿qué es lo que quiero ahora mismo?

136
00:10:32,269 --> 00:10:34,590
pues que se desplace por ejemplo hacia la derecha

137
00:10:34,590 --> 00:10:39,210
con lo cual yo puedo directamente en mi Unity decirle

138
00:10:39,210 --> 00:10:41,250
muévete en un vector 3, ¿cuál?

139
00:10:41,769 --> 00:10:43,389
el que te voy a crear ahora mismo

140
00:10:43,389 --> 00:10:45,690
punto, dándote un atributo

141
00:10:45,690 --> 00:10:47,269
¿cuál? right

142
00:10:47,269 --> 00:10:48,350
ahí está

143
00:10:49,330 --> 00:10:54,250
Y lo dicho, igual que le digo derecha, le puedo decir arriba, abajo, hacia adelante, hacia atrás.

144
00:10:54,470 --> 00:10:56,250
Y aquí se aplica lo mismo que hemos visto antes.

145
00:10:56,669 --> 00:11:04,190
Por la velocidad, por el atributo time, deltaTime.

146
00:11:06,629 --> 00:11:18,440
Y si nos vamos a Unity y lanzamos este script, veremos que, modificando la velocidad, el efecto es exactamente el mismo que habíamos conseguido antes.

147
00:11:18,440 --> 00:11:25,370
pero eso sí, usando una sola línea de código

148
00:11:25,370 --> 00:11:27,549
así que de nuevo, repito

149
00:11:27,549 --> 00:11:32,889
investigad porque a menudo las cosas son más fáciles de lo que pensamos

150
00:11:32,889 --> 00:11:35,830
bueno, y con esto la verdad es que ya le podemos echar imaginación

151
00:11:35,830 --> 00:11:37,769
nos faltaría añadir interactividad

152
00:11:37,769 --> 00:11:40,149
que eso lo dejaré para un siguiente cursillo

153
00:11:40,149 --> 00:11:41,870
donde veamos, por ejemplo, decir

154
00:11:41,870 --> 00:11:44,429
pues cuando le doy a la izquierda se mueve a la izquierda

155
00:11:44,429 --> 00:11:45,909
cuando le doy a la derecha se mueve a la derecha

156
00:11:45,909 --> 00:11:49,970
o cuando le doy a mis cursores acelera o decelera

157
00:11:49,970 --> 00:11:52,330
con un máximo o con un mínimo, como hemos visto

158
00:11:52,330 --> 00:11:53,950
en fin, pues eso, que ya

159
00:11:53,950 --> 00:11:55,649
casi podemos hacer un videojuego