1
00:00:07,019 --> 00:00:12,359
fijaos en este código que yo tengo aquí distintos métodos no sé por qué aquí me

2
00:00:12,359 --> 00:00:16,019
ha dado error ahora no debería bueno sí porque tiene falta otra línea de

3
00:00:16,019 --> 00:00:22,120
comentario vale ahí lo dejo yo voy viendo que aquí tengo un montón de

4
00:00:22,120 --> 00:00:27,960
métodos preparados pero cuando sale además con esta palabra en gris vamos

5
00:00:27,960 --> 00:00:31,320
gris es amarillo pero está como sombreado significa que no está

6
00:00:31,320 --> 00:00:35,780
usándose pero yo tengo este código aquí preparado por si lo que quisiera usar e

7
00:00:35,780 --> 00:00:48,179
Incluso veréis que cuando tenéis un script, y fijaos también en el número de las líneas, tenéis hasta flechitas para reducir, para ir compactando estos scripts.

8
00:00:48,420 --> 00:00:52,960
Así de primeras a lo mejor no es lo más óptimo, pero si dice, vale, estos no los estoy usando, pero los quiero aquí.

9
00:00:53,079 --> 00:00:55,100
Fijaos que hay saltos de línea y los habéis encogido.

10
00:00:55,920 --> 00:01:00,560
Estos son códigos que yo tengo aquí comentados porque no quiero usar, porque a lo mejor los he probado y no me funcionan,

11
00:01:00,560 --> 00:01:04,579
o porque es una funcionalidad que no tengo claro si va bien o si la voy a usar.

12
00:01:04,579 --> 00:01:09,739
Bueno, yo puedo tener un montón de métodos, por ejemplo, aquí preparados

13
00:01:09,739 --> 00:01:14,019
Entonces podéis comentar y llegar de distintas formas

14
00:01:14,019 --> 00:01:18,140
Así que es verdad que para las entregas intentad dejarme la solución

15
00:01:18,140 --> 00:01:20,980
Sin mucha, lo voy a decir así rápido, morralla

16
00:01:20,980 --> 00:01:23,680
Porque si no me vuelvo loco de qué estáis intentando entregar

17
00:01:23,680 --> 00:01:28,000
Y otra cosa importante es en las tareas

18
00:01:28,000 --> 00:01:30,379
Y vais a ver que ya son amplias y se piden muchas cosas

19
00:01:30,379 --> 00:01:33,379
Os pido por favor que intentéis resolver lo que se os pide en la tarea

20
00:01:33,379 --> 00:01:38,000
luego vosotros si queréis complicar las todo lo que queráis o seguir pues por supuesto hacerlo

21
00:01:38,000 --> 00:01:44,120
pero de cara a la tarea no uséis por ejemplo si se pide el input manager no uséis el input

22
00:01:44,120 --> 00:01:48,140
system que es bastante más complicado el input system por ejemplo se explica para que lo conozcáis

23
00:01:48,140 --> 00:01:54,480
y porque es relevante pero con todas las cosas que hay que dar no no es asumible pasar mucho

24
00:01:54,480 --> 00:01:58,859
tiempo con el input system pero hay tantas cosas que vamos a ir a por lo que hay que sacar vale

25
00:01:58,859 --> 00:02:00,420
Que no es poca cosa, ¿vale?

26
00:02:00,420 --> 00:02:02,700
El otro día, entiendo que todos los que lo habéis hecho,

27
00:02:03,159 --> 00:02:05,879
lo que habéis, la que le estáis entregando, la estáis acabando,

28
00:02:06,000 --> 00:02:09,560
básicamente lo que habéis hecho es usar el método rotate del transform, ¿vale?

29
00:02:09,560 --> 00:02:10,360
Como aquí, ¿vale?

30
00:02:10,400 --> 00:02:15,819
En base al eje Z, los que dijimos que gira en base a ese eje, ¿vale?

31
00:02:15,860 --> 00:02:18,500
Entonces, pues rotará hacia los lados realmente con el eje Z.

32
00:02:19,060 --> 00:02:26,199
Y bueno, pues con lo que se va capturando de los inputs, ¿vale?

33
00:02:26,199 --> 00:02:44,819
Que ya, bueno, pues hablamos de los axis y cómo crearlo y ese menos uno y uno como límites de un eje entre un valor positivo y negativo para transmitir esa información, ese dato, por ejemplo, a un cambio de posición o de rotación, ¿vale? Esto era una forma de hacer que la nave rotara.

34
00:02:44,819 --> 00:03:03,620
Y de hecho, yo si comentara todo esto hasta aquí, y este es el método que estoy usando, entonces con este rotate, básicamente, esta nave, si le doy hacia la derecha, rotará indefinidamente, si doy a la izquierda, rota indefinidamente también.

35
00:03:03,620 --> 00:03:27,120
Y además, como el transform lo hemos puesto, recordad, el translate, perdón, como que use el espacio, el mundo, en vez del self, recordad esto que teníamos por aquí, que el space sea el world y no el propio objeto en sí, pues da igual lo que giremos, que siempre el arriba va a ser el arriba del mundo o el abajo del mundo, etc.

36
00:03:27,120 --> 00:03:42,699
¿Vale? ¿Qué ocurre? Que a lo mejor, y yo en mi planteamiento seguramente sería este al hacer el juego, es que la nave rote hasta este punto o hasta este punto, ¿vale? Y no pase de ahí. ¿Qué ocurre? Que no estamos haciendo ningún límite para que esto deje de hacerlo así.

37
00:03:42,699 --> 00:04:02,360
Entonces ahora la nave de pronto la podemos poner boca abajo o boca arriba, o como nos dé la gana, porque rota indefinidamente y ya está. Aquí no se pedía explícitamente que limitáramos esos movimientos, pero os quería contar un par de cosas sobre cómo se podría hacer, porque también nos da ideas de cómo podríamos hacer esto.

38
00:04:02,360 --> 00:04:15,879
Voy a poner la otra, que es una muy simple realmente y vais a ver que ahora mismo he activado otro método que tenía aquí de rotar nave, que si bajamos hace una cosa muy simple y que vais a ver cómo funciona.

39
00:04:15,879 --> 00:04:44,959
Lo que estoy consiguiendo es, en el update, recordad que esto está dentro del update, voy a ampliar esto para que se vea más, en el update lo que estoy diciendo es que, y recordad que los ángulos en Unity, si usáramos lo que a priori sería lo lógico, que es un parámetro que se llamara rotation, igual que hacemos position, si usamos rotation, y bueno, lo pone en el propio tema, etc., está usando esta clase quaternion,

40
00:04:44,959 --> 00:04:50,199
que se basa en cuatro ejes, que es poco comprensible para el ser humano, aunque tiene su explicación de uso, etc.

41
00:04:50,620 --> 00:05:01,319
Y nosotros nos deberíamos ceñir más a lo que son los ángulos Euler, que se basan en grados, en degrees, y se basan además en tres dimensiones.

42
00:05:01,319 --> 00:05:10,199
Hace una traslación, si me meto en el transform, nuestra forma de entender la rotación en los software 3D, etc., se basan en estas tres dimensiones.

43
00:05:10,199 --> 00:05:26,199
Entonces, digamos que lo que hacemos aquí es decir, vale, pasamos, entre comillas, queremos que la traslación del quaternion la usemos dentro de esta forma que nosotros sabemos usar,

44
00:05:26,379 --> 00:05:38,199
que son estos tres ejes de X y Z, y le vamos a decir, básicamente, que la posición o el valor que tengan estos ángulos Euler recojan un vector nuevo que estamos creando en ese momento,

45
00:05:38,199 --> 00:05:44,000
que no interfiera, es decir, que siempre mantenga en cero la rotación de X e Y,

46
00:05:44,360 --> 00:05:47,079
porque no nos interesa, porque la nave no va a inclinarse hacia abajo

47
00:05:47,079 --> 00:05:50,319
ni hacia... no sé cuál sería el otro eje.

48
00:05:51,620 --> 00:05:54,699
Que haga un derecha-izquierda en el sentido de que lo haga en torno al eje Y.

49
00:05:55,800 --> 00:05:59,240
Entonces, el que nos interesa en esta práctica, porque lo que estamos pidiendo

50
00:05:59,240 --> 00:06:01,740
es que rote en torno al eje Z, ¿verdad?

51
00:06:02,519 --> 00:06:06,459
Entonces, podemos decir, vale, lo que vamos a hacer es poner un rotate data,

52
00:06:06,459 --> 00:06:17,519
que básicamente es este input axis, que puede dar como máximo 1 o menos 1, recordad, según los dos extremos, y multiplicarlo por 90 o por menos 90.

53
00:06:17,860 --> 00:06:26,220
Bueno, podría ser 90 o menos 90, cuando se invierten a veces los valores es simplemente porque el eje ya es o positivo o negativo,

54
00:06:26,459 --> 00:06:31,360
si vemos que va en la dirección contraria a la que nos interesa, como al final esto lo que está dando es valores de rotación,

55
00:06:31,360 --> 00:06:34,699
que queremos que vayan hacia un lado que es positivo o negativo,

56
00:06:34,839 --> 00:06:36,879
aunque esto luego os voy a contar que tiene trampa, ¿vale?

57
00:06:37,519 --> 00:06:40,319
Va entre o a 90 o a menos 90, ¿no?

58
00:06:40,360 --> 00:06:44,560
Entonces, si es 1, pues será menos 90, si es menos 1 será más 90, ¿no?

59
00:06:45,180 --> 00:06:49,060
Y, bueno, pues si ponemos este menos es porque nos interesa invertir la dirección, simplemente.

60
00:06:49,519 --> 00:06:50,560
¿Qué significa esto?

61
00:06:51,180 --> 00:06:55,199
Que si pulsamos en un teclado, que además un teclado, como ya hemos hablado,

62
00:06:55,199 --> 00:06:59,860
no es como un gamepad, un joystick, que tiene un recorrido entre el 0 y el 1, ¿no?

63
00:06:59,860 --> 00:07:06,279
en esa mitad del eje, sino que es pulsar una tecla y es de pronto 1, de pronto 0 o de pronto menos 1, si es la del eje negativo,

64
00:07:06,920 --> 00:07:13,720
pues de un momento a otro, porque esto es en el update, de un fotograma al siguiente, de pronto se encuentra que es o más 90 o menos 90.

65
00:07:14,500 --> 00:07:20,480
Si ahora tengo activado este RotarNave, y os vuelvo a decir, si veis que está el nombrecito en amarillo vibrante,

66
00:07:21,339 --> 00:07:25,939
significa que esto lo está usando, si nos ponemos encima, lo está usando algún punto del código.

67
00:07:25,939 --> 00:07:35,000
Si tenemos aquí preparado y está así desvanecido, significa que está preparado, está planteado este método, pero no se está usando.

68
00:07:36,360 --> 00:07:40,180
Problema y beneficio que hemos encontrado con esta solución de una línea.

69
00:07:40,519 --> 00:07:51,920
Ahora sí que conseguimos que la nave solo va a rotar hacia un lado, cuando suelto, como no estoy dando ni más uno ni menos uno, sino que es cero,

70
00:07:51,920 --> 00:08:10,139
Se vuelve a su posición estática, ¿vale? Y fijaros en el Z, en la rotación de Z, si yo giro hacia la izquierda, pues es 90, suelto, es 0, doy al botón de la derecha y es menos 90, ¿vale? Lo que no hay es valores intermedios. Hace esto, que es así, de rápido.

71
00:08:10,139 --> 00:08:40,120
¿Qué pasa? Que hay una forma, y así también entendéis este concepto, hay una forma de, digamos, al pulsar un input, aunque sea una tecla que da un valor de 1 o menos 1 repentino, recordad, y si veis los apuntes lo pone, que cada uno de estos, ¿vale?

72
00:08:40,120 --> 00:08:43,019
es el que me interesaba, que fuera específico de esto, ¿no?

73
00:08:43,019 --> 00:08:47,139
Que era el rotador, el eje que recogía este rotate data, ¿vale?

74
00:08:47,860 --> 00:08:53,740
Que yo lo he creado y le he dicho, vale, cuando pulso, yo he puesto estas teclas,

75
00:08:53,960 --> 00:08:56,740
cada uno puede poner las que considere, ¿vale?

76
00:08:57,779 --> 00:09:01,100
Aunque, bueno, poner unas lógicas también para un juego, ¿vale?

77
00:09:01,179 --> 00:09:05,600
Yo estas, si poner la mano derecha en la U y la I, más o menos tiene ese espacio

78
00:09:05,600 --> 00:09:10,179
para la cruceta del WASH y para la rotación, para esta rotación en este caso.

79
00:09:10,779 --> 00:09:14,299
Valor negativo para que vaya a la izquierda la U, para que vaya a la derecha la I latina.

80
00:09:14,940 --> 00:09:17,580
Y tenemos estos valores de Gravity y Sensibility.

81
00:09:18,259 --> 00:09:21,940
Y si nos ponemos encima es, por un lado, la sensibilidad,

82
00:09:22,340 --> 00:09:28,940
sensibilidad, mejor dicho, que tiene el input según se pulsa hasta que llega a su valor máximo,

83
00:09:29,100 --> 00:09:33,779
que sería este 1 o más 1, más 1 o menos 1, y hay de 1000, es súper rápido.

84
00:09:33,779 --> 00:09:54,639
Pero eso no significa que yo este valor no lo pueda cambiar. Esto significa que si yo le digo que la sensibilidad sea de 5 y lo pruebo, ahora vais a ver que yo le doy al play que va a llegar a ese más 1 y menos 1 de una forma progresiva.

85
00:09:54,639 --> 00:10:15,679
Al soltar veis que vuelve, al volver a relajar y que sea el cero, vuelve inmediatamente, pero veis que con esto ya hemos conseguido que los valores máximos y mínimos sea porque aunque sea una tecla el input haya un cierto periodo de, digamos, de interpolación, no es la palabra, de recorrido hasta llegar a ese punto.

86
00:10:15,679 --> 00:10:26,379
Lo mismo pasa si lo alteramos aquí con la contraria que es al soltar cuánto tiempo vuelve a la situación de origen.

87
00:10:26,580 --> 00:10:36,860
Si yo en gravedad pongo 5, por ejemplo, un valor mucho más pequeño que este 1000, lo que vamos a conseguir es que aparte de que cuando giremos haya esta interpolación,

88
00:10:36,860 --> 00:10:39,220
Cuando soltemos y vuelva al valor neutro

89
00:10:39,220 --> 00:10:40,600
Porque ahora hay un valor neutro de 0

90
00:10:40,600 --> 00:10:42,139
Cuando no estamos pulsando nada

91
00:10:42,139 --> 00:10:45,899
Veis que vuelve a ese valor relajado

92
00:10:45,899 --> 00:10:49,059
Entonces, bueno, aparte de subir, bajar, ir a la derecha, etc

93
00:10:49,059 --> 00:10:50,980
Pues tiene esta interpolación

94
00:10:50,980 --> 00:10:52,840
Y, ojo, tiene unos límites

95
00:10:52,840 --> 00:10:55,519
Ahora no hace este giro continuo

96
00:10:55,519 --> 00:10:57,240
Que teníamos en la anterior opción

97
00:10:57,240 --> 00:10:59,179
Esto siempre es según lo que se busque

98
00:10:59,179 --> 00:11:01,639
A lo mejor en el juego quiero que la nave rote sin parar

99
00:11:01,639 --> 00:11:04,659
Pero, bueno, es una forma también para que veáis

100
00:11:04,659 --> 00:11:06,419
Que aunque usemos teclas

101
00:11:06,419 --> 00:11:33,659
Hay valores relacionados con que no sean repentinos estos inputs. Esto es una solución para llegar a estos límites máximos usando esta suavidad de los inputs.

102
00:11:33,659 --> 00:11:46,720
Hay otra solución más compleja, por ejemplo, otra alternativa, y aquí es donde voy a comentar este método y voy a poner esto de rotarNav y fijar, que es la que antes había comentado.

103
00:11:46,720 --> 00:12:04,659
Que básicamente es seguir empleando, por poner un valor que hemos creado aquí una variable para que sea más o menos rápida, este rotate. Solo que se han añadido unas cuantas líneas más para que ese rotate también tenga una limitación de esa rotación.

104
00:12:04,659 --> 00:12:26,100
Y esto lo voy a explicar para que veamos la trampa que tienen estos Euler angles, porque al final lo que estamos variando a veces, aunque estemos viendo una cosa en el inspector, cuando vemos aquí esta nave que vaya girando en Z, realmente la traslación de los Euler angles no es tal.

105
00:12:26,100 --> 00:12:42,700
Me explico, yo si cojo esta nave y empiezo aquí a girarla con el inspector y empiezo a girar, a girar, a girar, veis que hay valores que superan los 360 grados que tiene una rotación completa y que es que cada 360 grados básicamente está volviendo a empezar otra vez la rotación.

106
00:12:42,700 --> 00:13:12,519
Creo que hasta aquí es lo que ya sabemos y del mismo modo en negativo, que rotará en la otra dirección. ¿Qué ocurre? Que si yo llego a este punto, que estoy haciendo esta rotación de la nave y le digo, voy a crear otra variable, un float, que coja la rotación actual de esta nave, que básicamente es de este objeto, la nave, voy a coger el valor del eje Z, que es el que estamos cambiando y el que nos interesa,

107
00:13:12,700 --> 00:13:15,320
en su valor de ángulo

108
00:13:15,320 --> 00:13:17,399
seuler, ¿vale? y justo a continuación

109
00:13:17,399 --> 00:13:19,080
¿vale? esto de momento lo omitimos

110
00:13:19,080 --> 00:13:21,100
pero justo a continuación vamos a ver

111
00:13:21,100 --> 00:13:23,460
el valor que está mostrando esto

112
00:13:23,460 --> 00:13:25,419
y vais a ver que no es concordante siempre

113
00:13:25,419 --> 00:13:27,259
bueno, voy a comentar de hecho

114
00:13:27,259 --> 00:13:28,580
esto que tenemos aquí

115
00:13:28,580 --> 00:13:30,039
vale

116
00:13:30,039 --> 00:13:33,440
vale, tenemos estas líneas

117
00:13:33,440 --> 00:13:35,600
en principio está bien, guardo y vamos a ver

118
00:13:35,600 --> 00:13:37,039
que yo cuando

119
00:13:37,039 --> 00:13:39,559
vamos mostrando ese eje Z

120
00:13:39,559 --> 00:13:41,240
simplemente en la consola

121
00:13:41,240 --> 00:13:42,679
¿vale?

122
00:13:42,700 --> 00:14:06,000
a ver que esto se quite, yo empiezo a dar aquí y veis que si yo pongo aquí la nave prefab, aquí pone z menos 61 y sin embargo si vemos la consola pone 298 y vais a ver que este valor siempre está entre el 0 y el 360 mostrando una rotación de una sola vuelta,

123
00:14:06,000 --> 00:14:27,639
Y yo sigo haciendo esta rotación, veis que nunca es negativo el valor y aquí sí estamos viendo negativos. ¿Qué significa? Que aunque en el inspector no lo muestre con valores negativos, realmente en el código y como está funcionando por debajo esto de los ángulos Euler es siempre en un valor que muestra entre el 0 y el 360 en positivo.

124
00:14:27,639 --> 00:14:46,879
Esto implica muchas dificultades porque si por ejemplo yo quiero decirle que esta nave me la mueva al menos 4, realmente por detrás lo que está gestionando es un 356, que son los 360 menos los 4.

125
00:14:46,879 --> 00:15:02,419
Entonces, si yo quiero girar la nave con algo que sea directamente usar los ángulos Euler, manipulando estos valores directamente, hay que hacer operaciones intermedias o conversiones para que esto no dé problema.

126
00:15:02,419 --> 00:15:20,039
Porque si ponemos valores negativos, lo que va a hacer es saltar directamente al final del recorrido del siguiente, ¿vale? Porque pasará de 0 a 300 y pico, yo que sé, y va a haber saltos y va a haber problemas y para limitar también pueden surgir ciertos inconvenientes, ¿vale?

127
00:15:20,039 --> 00:15:31,600
Por eso os doy aquí un planteamiento, hay más, etcétera, que quiero comentar para que veáis también el uso que se puede dar a este operador módulo del que hablamos el otro día.

128
00:15:32,840 --> 00:15:43,700
Entonces, esta línea ya, por ejemplo, la voy a dejar ahí que en todo momento nos enseñe el valor del angular Euler de z según estamos haciendo esta rotación,

129
00:15:43,700 --> 00:16:01,519
Pero lo que vamos a hacer es esta operación, que de primeras puede costar, pero es esta variable de current rotation, que en su momento valía este valor, siempre positivo, hemos dicho, de 0 a 360. Voy a hacer que se guarde y opero, que esto se puede hacer también.

130
00:16:01,519 --> 00:16:10,840
Y es algo que vimos cuando se usaba la suma, por ejemplo, que se podía hacer este current rotation es igual a current rotation más 1, ¿vale?

131
00:16:11,779 --> 00:16:21,259
Recordad que se puede operar, esto es un ejemplo, se puede guardar en una variable un valor que apele a esa variable y luego más operaciones aritméticas, ¿vale?

132
00:16:21,620 --> 00:16:26,919
Que digo que a veces parece un poco intuitivo decir current rotation es igual a current rotation extrajosa, ¿vale?

133
00:16:26,919 --> 00:16:37,940
Lo que está haciéndose aquí es guardar un contenido que estamos designando aquí y estamos apelando en este momento, en el que todavía no se ha guardado, está en esa operación, este valor que se había puesto.

134
00:16:38,659 --> 00:16:52,799
Entonces, imaginaos que yo he rotado 4 a la izquierda, ¿vale? Ese menos 4 que se ve en el inspector, pero que a nivel interno el código realmente aquí está viendo reflejado como un 356, ¿vale?

135
00:16:52,799 --> 00:17:13,380
¿Qué es lo que vamos a hacer aquí? Poner siempre que este valor sea mayor a 360, ¿vale? Es decir, si yo tengo una current rotation, bueno, en realidad no es que sea siempre mayor que 360, es que esté en un rango, ¿vale?

136
00:17:13,380 --> 00:17:15,619
Que se mueva entre 180 y menos 180.

137
00:17:16,200 --> 00:17:17,140
¿Qué conseguimos aquí?

138
00:17:17,240 --> 00:17:23,700
Que este valor que tengamos aquí, al dividirlo entre 360 y dar el módulo, ¿vale?

139
00:17:24,519 --> 00:17:27,519
Básicamente estoy diciendo qué grados hay, ¿vale?

140
00:17:27,779 --> 00:17:28,700
En una sola vuelta.

141
00:17:28,880 --> 00:17:29,099
¿Por qué?

142
00:17:29,099 --> 00:17:36,279
Porque si, por ejemplo, habíamos hecho que en este valor fuera en vez de menos 4, menos 364, ¿vale?

143
00:17:37,000 --> 00:17:42,180
Como hemos dicho que los ángulos Euler solo operan en un giro, es decir,

144
00:17:42,180 --> 00:17:50,440
de 0 a 360 y no pasa de ahí, pues al hacer este módulo estamos diciendo, oye, al dividirlo entre 360, ¿cuántas vueltas hemos dado?

145
00:17:51,420 --> 00:18:00,619
Entonces se le suma a ese ángulo estos 180, se divide ese valor entre las vueltas que puede tener y luego esa compensación,

146
00:18:00,960 --> 00:18:08,319
es decir, esos 180 que se habían contado, al final el resultado de esto puede ser 0, 1, 2, que es el número de vueltas,

147
00:18:08,319 --> 00:18:15,359
que es lo que estamos consiguiendo con esta operación. Si es positivo, se estabiliza con esto para que llegue a cero.

148
00:18:15,539 --> 00:18:24,619
Si, por ejemplo, hemos girado 180 y al girar 180 le sumamos 180 y lo llevemos entre 360, el módulo va a ser cero

149
00:18:24,619 --> 00:18:31,859
y al restarle este 180 se va a quedar en el valor negativo. Con esta operación lo que estamos haciendo en todo momento

150
00:18:31,859 --> 00:18:58,920
es compensar el número de vueltas que hay y también restringir que los valores que dé esto sea entre menos 180 y 180, porque si tiene el valor máximo, que va a ser 0, va a dar menos 180, y si está entre 159, cuando se le resta 180, pues va a estar en los valores positivos, del comienzo del giro, digamos.

151
00:18:59,920 --> 00:19:10,880
Básicamente, si yo me meto ahora en el código, y esto me sirve sobre todo para hablaros de estas discordancias que hay entre el eje Z y lo que va mostrando la consola.

152
00:19:11,559 --> 00:19:23,779
Vais a ver que está todo el rato, a ver, aquí lo voy dando, va a estar en todo momento yendo entre los valores de 180 positivos y luego automáticamente pasa a menos 180.

153
00:19:23,779 --> 00:19:46,160
Y una vez tenemos esto preparado, lo que podemos ir haciendo y haberlo convertido ya a una rotación que va entre menos 180 y más 180, que no es lo que hace por defecto los Euler angles, sí que podemos crear otras variables y poner unos límites nosotros, que es menos 90 como máximo de giro hacia la izquierda y más 90 de máximo de giro a la derecha.

154
00:19:46,160 --> 00:20:08,660
Y con esta conversión hecha entre 180 y menos 180, es decir, si esta rotación es menor al mínimo o mayor, recordad que este operador de las dos líneas es una condición o la otra, o mayor a estos 90 grados, es decir, dicho de otra manera, si sale dentro de los rangos que queremos definir aquí,

155
00:20:08,660 --> 00:20:31,839
Y lo que vamos a hacer es decir que esta rotación, este valor que puede estar por encima de 90 o de menos 90, si está en alguna de esas dos situaciones que se sale del rango que queremos, vamos a limitarlo y vamos a hacer que este giro se encuentre dentro de unos límites.

156
00:20:31,839 --> 00:20:51,299
Para ello, este método no está en los contenidos. Esto es de ampliación lo que os estoy contando todo. Hay una operación, un método que se llama el MathF, que es una clase que hay en Unity para operaciones matemáticas.

157
00:20:51,299 --> 00:21:16,619
Y este clamp, que significa o sirve o se usa en Unity, nos metemos, dice, vale, existe esta clase que si nos fijamos con esto se puede dar el valor que tengamos o que queramos evaluar y queremos que lo que devuelva este método sea siempre o esté limitado a un número mínimo o a un número máximo.

158
00:21:16,619 --> 00:21:33,720
Es decir, que aquí ahora mismo, si estamos pasándole una rotación de 0 o de 10 o de 50 o de menos 50, como está dentro de los mínimos y máximos que estamos marcando en los otros dos argumentos, pues no lo va a cambiar.

159
00:21:33,720 --> 00:21:55,319
Pero si este valor de pronto valiera 180 o 150, porque se sale del máximo que hemos marcado, lo pondrá en el máximo. Es decir, lo restringirá ese máximo. Lo dejará que como máximo de aquí salga un valor de 90 y como mínimo uno de menos 90. Y lo guarda en current rotation de nuevo.

160
00:21:55,319 --> 00:22:15,700
Y ya por último, lo que decimos es, este valor de Euler-Engels directamente lo modificamos, es decir, estamos como tocando el transform, estos valores que tenemos aquí, para que el X y el Y de esa rotación se mantengan estables, no las estamos afectando.

161
00:22:15,700 --> 00:22:29,579
Esto lo expliqué el otro día, que si ponemos el nombre del eje, pues se mantiene, no está habiendo ninguna perturbación de ella, y coja este valor, que va a estar siempre entre máximo 90 o menos 90, y lo ponga en el Euler-Angels.

162
00:22:29,579 --> 00:22:45,160
Entonces, básicamente estamos haciendo este rotate como veníamos haciendo y con todo esto lo que hemos hecho es, por un lado, recoger el eje Z, hacer con esta operación que se mantenga entre el menos 180 y el 180,

163
00:22:45,160 --> 00:23:13,279
Porque lo que hace es dar unos valores que al darse entre 0 y 360 se estabilizan restándole 180, ¿vale? Y si es un 0 se queda en el menos 180 y si al dar un máximo de grados posibles de 360 al resultado de esto antes de su operación, antes de restarle 180, si el máximo es 360 al restarle 180 se queda en 180 y si es 0, ¿vale?

164
00:23:13,279 --> 00:23:19,380
Es decir, ha comenzado una rotación nueva, un ciclo de rotación, al restarle menos 180 se queda en el mínimo de 180.

165
00:23:19,539 --> 00:23:29,299
Entonces, digamos que el rango de esos 360 grados, en vez de ir de 0 a 360, con esto hemos conseguido que se quede en un rango de menos 180 a 180,

166
00:23:29,599 --> 00:23:35,319
que es lo que nos interesa para operar a nosotros con valores negativos, que es lo que nosotros vemos en ese transform.

167
00:23:36,000 --> 00:23:39,740
Aquí fijamos esta rotación máxima o mínima, que es la que hemos establecido.

168
00:23:39,740 --> 00:23:55,759
Ya os digo, si quisiera que fuera menos 120 y 120, con esto, siempre y cuando esté dentro de este rango, porque si no ya estamos volviendo a salirnos de rango, podemos marcar una rotación máxima y mínima.

169
00:23:55,759 --> 00:24:08,099
Y con esto, al final lo que decimos, esta rotación que hemos dado, al final que se traduzca y que se ponga en el transform dentro de este rango que se ha puesto aquí limitado por este clamp.

170
00:24:09,279 --> 00:24:13,359
Esta sería un poco la lógica. Esto se puede hacer de más formas, evidentemente, hay muchas.

171
00:24:13,359 --> 00:24:38,799
Pero bueno, esta es una que me sirve para explicar también esto del módulo y veis, ahora el máximo es 120, a ver, 120, 120, esperad que aquí voy a quitar, igual lo está volviendo un poco loquer, que es, vale, yo giro y se queda en 120, vale, sobrepasa un poco los 90 y 120, vale.

172
00:24:38,799 --> 00:25:01,140
Entonces ahora, es verdad que esta rotación es un poco rara porque se queda como mirando para abajo, voy a poner 45-45 y con esto ya tengo una rotación preparada para tener límites, ¿vale? Y en principio más o menos debería funcionar en cualquier, ¿vale? Más 45 menos 45, se queda ahí en un grado intermedio.

173
00:25:01,140 --> 00:25:10,980
Y ahí sí que, además, al ser un rotate, sí que tiene ese suavizado independientemente de que aquí tenga un input que tarde más o menos en captarse, ¿vale?

174
00:25:11,400 --> 00:25:18,559
Que, ojo, si vamos a hacer esta, yo lo llamo interpolación, esta suavidad, mejor dicho, ¿vale?

175
00:25:18,599 --> 00:25:24,680
Y queremos que sea todo en base al código, aquí lo más correcto sería nuevamente poner un valor muy alto, ¿vale?

176
00:25:24,700 --> 00:25:27,640
Porque no queremos que tarde en recoger el valor del input.

177
00:25:27,640 --> 00:25:31,839
Queremos que vuelva a ser, como viene por defecto, por ejemplo, este 1000 y 1000, ¿vale?

178
00:25:31,839 --> 00:25:38,720
Y, bueno, pues ahora la rotación empieza y se hace con el rotate, básicamente, ¿vale?

179
00:25:39,279 --> 00:25:44,440
No sería ninguna tontería poner un time, delta time, ¿vale?

180
00:25:44,440 --> 00:25:51,839
Para hacer esta estabilización que hablamos de la rotación, de los tiempos de ejecución de la date, ¿vale?

181
00:25:51,859 --> 00:25:52,740
A lo largo del tiempo.

182
00:25:52,740 --> 00:26:12,460
Entonces, una cosa es esta estabilización que se hace en el momento de la rotación con que luego estemos en todo momento recuperando un valor de los Euler angles, que es básicamente leer, en este caso cuando lo estamos recogiendo, leer lo que pone en el componente transform del objeto.

183
00:26:12,460 --> 00:26:25,720
Y si estás aplicando estos Euler angles, básicamente lo que estás haciendo es pasar una posición, una coordenada que ya tienes.

184
00:26:26,200 --> 00:26:32,920
Por eso en este caso no habría que poner time delta time, porque ya está dando valores automáticamente.

185
00:26:33,440 --> 00:26:40,200
Tendrás que estabilizar en todo caso lo que da ese valor para que llegue a los Euler angles.

186
00:26:40,200 --> 00:26:50,559
una duda ya que mañana no podría asistir a tutoría bueno tenía el mismo problema y básicamente tiene

187
00:26:50,559 --> 00:26:56,079
un problema en la unidad 2 en la tarea que es que tiene un elemento que está instanciando los

188
00:26:56,079 --> 00:27:04,420
obstáculos no recordemos que básicamente en esta tarea tenemos esta nave que se va moviendo etcétera

189
00:27:04,420 --> 00:27:12,880
y bueno poder rotar etcétera ahora vemos algunas posibilidades pero que llega un momento que no se

190
00:27:12,880 --> 00:27:20,759
siguen instanciando estos obstáculos, ¿vale? Ella indica que tiene, igual que yo, de otra forma, pero ha llegado a la solución correcta,

191
00:27:20,819 --> 00:27:31,720
tiene un código que sirve para instanciar, igual que hacíamos en la primera tarea, que sirve para instanciar un obstáculo que está capturando

192
00:27:31,720 --> 00:27:36,980
por este serialized field como un GameObject, ¿vale? Igual que hacíamos en la primera tarea, y lo tiene ahí.

193
00:27:36,980 --> 00:27:38,579
¿Qué problema está teniendo?

194
00:27:39,140 --> 00:27:39,319
¿Vale?

195
00:27:39,380 --> 00:27:42,619
Es importante, porque es verdad que esto se olvida a veces rápido,

196
00:27:43,460 --> 00:27:47,279
pero es que ella ha puesto que el GameObject, que es instancia,

197
00:27:47,400 --> 00:27:50,700
que está juntando aquí, no es el prefab en sí, ¿vale?

198
00:27:50,819 --> 00:27:53,240
No es este prefab que tenemos en el área de proyecto,

199
00:27:54,200 --> 00:27:57,539
sino que lo que ha incorporado es que ella metió un obstáculo ya

200
00:27:57,539 --> 00:27:59,640
para tenerlo aquí de referencia, imagino, ¿vale?

201
00:27:59,640 --> 00:28:03,200
Y dijo, este es el obstáculo, a ver, este es el obstáculo,

202
00:28:03,200 --> 00:28:05,339
me pongo en instanciador

203
00:28:05,339 --> 00:28:07,900
y este es el obstáculo que lo ha arrastrado

204
00:28:07,900 --> 00:28:10,119
y parece el mismo, pero que hay problema

205
00:28:10,119 --> 00:28:11,980
hay, que ella en cierto momento

206
00:28:11,980 --> 00:28:14,240
con todos los obstáculos, dentro del script del obstáculo

207
00:28:14,240 --> 00:28:15,339
si me meto en el obstáculo

208
00:28:15,339 --> 00:28:17,940
se está moviendo y también se destruye

209
00:28:17,940 --> 00:28:19,539
a sí mismo, que es lo que se pide

210
00:28:19,539 --> 00:28:21,160
con la función destroy

211
00:28:21,160 --> 00:28:23,480
que pasa, que como el instanciador

212
00:28:23,480 --> 00:28:25,500
está cogiendo este

213
00:28:25,500 --> 00:28:27,339
obstáculo de la jerarquía

214
00:28:27,339 --> 00:28:29,700
si yo doy play al juego

215
00:28:29,700 --> 00:28:31,920
vais a ver que se están

216
00:28:31,920 --> 00:28:35,200
que se están reproduciendo

217
00:28:35,200 --> 00:28:36,759
los obstáculos y en cuanto se destruye

218
00:28:36,759 --> 00:28:39,319
ahora está ya otro, aquí no aparece

219
00:28:39,319 --> 00:28:40,900
es decir, se ha perdido porque

220
00:28:40,900 --> 00:28:43,380
se ha borrado ese obstáculo que teníamos en la jerarquía

221
00:28:43,380 --> 00:28:44,980
que es este que está

222
00:28:44,980 --> 00:28:46,920
cogiendo como referencia y cuando

223
00:28:46,920 --> 00:28:49,019
se destruye, porque es cuando pasa

224
00:28:49,019 --> 00:28:50,700
la cámara, donde lo he configurado se ha destruido

225
00:28:50,700 --> 00:28:52,920
solo ha dado tiempo a hacer un clon

226
00:28:52,920 --> 00:28:55,000
una instancia y aquí de pronto aparece

227
00:28:55,000 --> 00:28:56,720
este mensaje de missing y ya no sabe

228
00:28:56,720 --> 00:28:59,059
que seguir instanciando y ya no hay copias

229
00:28:59,059 --> 00:29:00,940
¿vale? es la diferencia con

230
00:29:00,940 --> 00:29:18,319
Si yo borro y a este instanciador le digo que sea este obstáculo, que al estar fuera de la jerarquía, está como en un nivel superior porque está en el proyecto, pues yo si arrastro este, este nunca se va a borrar. Fijaos que yo me estoy fijando aquí en obstáculo, no está en ningún lado, pero se están haciendo estas copias.

231
00:29:18,319 --> 00:29:21,220
el tiempo con la corrutina

232
00:29:21,220 --> 00:29:23,099
como está pedido en la tarea

233
00:29:23,099 --> 00:29:26,000
pero este obstáculo aquí no se borra

234
00:29:26,000 --> 00:29:27,799
por tanto siempre el instanciador

235
00:29:27,799 --> 00:29:29,460
va a tener la referencia de qué objeto

236
00:29:29,460 --> 00:29:30,579
instanciar

237
00:29:30,579 --> 00:29:33,640
¿qué tal esto? entiendo que lo que es la

238
00:29:33,640 --> 00:29:35,259
instanciación más o menos la entendéis

239
00:29:35,259 --> 00:29:37,640
con este detalle de que os puede

240
00:29:37,640 --> 00:29:39,460
interesar en muchas ocasiones

241
00:29:39,460 --> 00:29:40,059
que el

242
00:29:40,059 --> 00:29:43,400
elemento que estemos llevando

243
00:29:43,400 --> 00:29:45,559
o recogiendo en una variable de tipo GameObject

244
00:29:45,559 --> 00:29:47,700
no sea un prefab de la jerarquía

245
00:29:47,700 --> 00:30:03,140
sino que normalmente nos va a interesar más que sea el prefab del proyecto en sí, ajeno a que se borre o no de una jerarquía uno de estos dos elementos.

246
00:30:04,660 --> 00:30:11,960
De hecho hay otro método del que se ha hablado un poco por encima que es, y pensarlo, ahora mismo no tengo un ejemplo, me ha venido así de pronto,

247
00:30:11,960 --> 00:30:38,059
Pero tened en cuenta que a lo mejor en un start, ¿vale? Instanciáis o recogéis un elemento que todavía no se ha creado en la jerarquía, ¿vale? Y todavía no está aquí y bueno, pues un poco dicho lo mismo, si yo la opción que dijera es este es el obstáculo que voy a instanciar, ¿vale? Lo que estábamos hablando antes, lo voy a cambiar el nombre para que sea más notorio el cambio entre uno y otro, lo voy a llamar en español obstáculo, ¿vale?

248
00:30:38,059 --> 00:31:00,980
Y el que estoy incorporando al instanciador es obstáculo, ¿vale? Si yo este elemento a lo mejor lo genero en algún momento que es en el start, ¿vale? Y en ocasiones puede suceder que tengo aquí un, digamos que estoy incorporando un elemento a un serialized field, ¿vale?

249
00:31:00,980 --> 00:31:14,000
En ocasiones, en vez de coger ese elemento, cargar ese GameObject, esa variable, en el momento de start, existe otro método que se ejecuta y está preparado antes de que se lance el script, que es este Awake.

250
00:31:14,000 --> 00:31:17,440
Esto lo dejo ahí un poco planteado

251
00:31:17,440 --> 00:31:22,099
Pero si en alguna ocasión os encontráis en la circunstancia

252
00:31:22,099 --> 00:31:24,980
De que aquí queréis rellenar por código

253
00:31:24,980 --> 00:31:27,819
Un GameObject que todavía no se ha generado

254
00:31:27,819 --> 00:31:30,640
En la jerarquía

255
00:31:30,640 --> 00:31:34,759
En ocasiones se puede cargar previamente con esta Wake

256
00:31:34,759 --> 00:31:42,299
Veis que eso, que cuando la cámara para

257
00:31:42,299 --> 00:31:45,079
Desde que para hasta que se coloca la cámara

258
00:31:45,079 --> 00:31:46,240
Hay un pequeño tirón

259
00:31:46,240 --> 00:31:51,619
Es algo que se pedía o que es recomendable.

260
00:31:51,980 --> 00:31:56,160
Entonces, en esa cámara, para que lo veáis, tengo un script llamado cameraFollow,

261
00:31:56,539 --> 00:32:01,900
como se puede llamar seguimiento cámara, ya sabemos que eso es una convención que usemos nosotros.

262
00:32:02,839 --> 00:32:07,960
Y vais a ver que lo que estoy buscando, las dos variables públicas o serializadas,

263
00:32:07,960 --> 00:32:15,819
que las tenemos aquí, básicamente, tenemos por un lado, y son estas dos,

264
00:32:15,819 --> 00:32:19,880
Una que tiene el objetivo al que tiene que estar siguiendo

265
00:32:19,880 --> 00:32:22,039
Que tenemos mejor dicho de referencia

266
00:32:22,039 --> 00:32:25,500
Para que la cámara lo haga en relación a ese objeto

267
00:32:25,500 --> 00:32:27,200
Básicamente lo que estamos haciendo

268
00:32:27,200 --> 00:32:29,660
Si lo decimos incluso verbalmente es

269
00:32:29,660 --> 00:32:34,819
La cámara se va a mover X en relación a la nave

270
00:32:34,819 --> 00:32:36,940
Entonces siempre hay que tener esa relación a la nave

271
00:32:36,940 --> 00:32:38,799
Aquí en vez de tener el GameObject

272
00:32:38,799 --> 00:32:42,259
Lo que cojo son, que esto lo vimos también en la primera tarea

273
00:32:42,259 --> 00:32:43,160
Os hablo de ello

274
00:32:43,160 --> 00:32:45,160
la variable transform para recoger

275
00:32:45,160 --> 00:32:47,559
los valores de este

276
00:32:47,559 --> 00:32:48,940
componente, lo guarda

277
00:32:48,940 --> 00:32:50,819
y yo lo que le he dicho a la nave es

278
00:32:50,819 --> 00:32:52,980
oye, tú sigue a esta nave prefab

279
00:32:52,980 --> 00:32:54,259
es la referencia

280
00:32:54,259 --> 00:32:56,779
y vais a ver que lo que hago es

281
00:32:56,779 --> 00:32:58,640
en el primer momento, según arranca el juego

282
00:32:58,640 --> 00:33:00,420
es la posición actual

283
00:33:00,420 --> 00:33:02,180
esto que se llama current post

284
00:33:02,180 --> 00:33:04,859
la posición actual

285
00:33:04,859 --> 00:33:06,680
en la que debería estar la nave

286
00:33:06,680 --> 00:33:08,819
la cámara, perdonad, este objeto que tiene

287
00:33:08,819 --> 00:33:10,180
el script

288
00:33:10,180 --> 00:33:12,140
que coja

289
00:33:12,140 --> 00:33:13,940
la posición

290
00:33:13,940 --> 00:33:16,619
de origen que tengo yo aquí

291
00:33:16,619 --> 00:33:18,660
¿vale? ¿por qué? porque si yo

292
00:33:18,660 --> 00:33:20,599
y esto además, si no da

293
00:33:20,599 --> 00:33:22,500
tirones, si yo pongo aquí

294
00:33:22,500 --> 00:33:24,359
la cámara, vais a ver que cuando le doy al play

295
00:33:24,359 --> 00:33:26,500
da ese tirón

296
00:33:26,500 --> 00:33:28,500
y se coloca, ¿vale? esto da este

297
00:33:28,500 --> 00:33:30,400
efecto de que se va moviendo hacia ese punto, pero

298
00:33:30,400 --> 00:33:32,519
básicamente, yo voy a estar en todo

299
00:33:32,519 --> 00:33:34,000
momento partiendo de una posición

300
00:33:34,000 --> 00:33:36,480
que marco y que deberíamos poner aquí

301
00:33:36,480 --> 00:33:37,859
como centrada

302
00:33:37,859 --> 00:33:40,519
para que coja esa de comienzo, y luego en el

303
00:33:40,519 --> 00:33:44,480
update, voy a estar diciendo, creo una variable que está aquí,

304
00:33:44,559 --> 00:33:48,380
de un vector 3, dado que hablamos ya de posiciones,

305
00:33:48,480 --> 00:33:52,960
rotaciones, escala, que se basan en tres valores, voy a crear

306
00:33:52,960 --> 00:33:57,519
un valor que se llama targetPos, que de momento simplemente

307
00:33:57,519 --> 00:34:02,099
guarda este vector, que va a coger la posición en los tres

308
00:34:02,099 --> 00:34:08,019
ejes de donde está la nave. Por eso pongo target y no es el

309
00:34:08,019 --> 00:34:32,860
Transform, a diferencia de aquí, si os fijáis, pongo coge la posición de esta nave en X, ¿vale? En X, básicamente, no quiero que haya un offset, no quiero que haya un offset lateral con respecto a la nave, quiero que haya un offset hacia arriba, ¿vale? Y en profundidad hacia atrás, ¿no? Para que esté alejado hacia atrás y hacia arriba, porque básicamente, pues es eso, me quiero alejar hacia atrás y subirla un poco para angularlo hacia abajo.

310
00:34:33,400 --> 00:34:46,039
¿Qué hago y qué se puede hacer? Crear una variable, igual que se podría poner aquí un número a pelo, pero mejor si lo agrupamos en una variable, que uno indique cuánto va a ser ese offset en el eje Z y cuánto va a ser el offset en el eje Y.

311
00:34:46,039 --> 00:34:51,420
vale y le digo vale el offset en el eje y va a ser pues que va a coger la

312
00:34:51,420 --> 00:34:56,920
posición de la nave y si está en 10 pues se va a poner la cámara en 25 más arriba

313
00:34:56,920 --> 00:35:02,599
y del z vale pues si la nave está en cero pues se va a ir hacia atrás va a ir

314
00:35:02,599 --> 00:35:06,860
hacia menos 6 porque lo que puesto aquí con esto al ir cambiando estos números

315
00:35:06,860 --> 00:35:12,199
el offset va a ser mayor o menor aquí todavía no lo estamos aplicando vale lo

316
00:35:12,199 --> 00:35:17,260
tengo guardado y aquí me está dando la posición donde debería estar la cámara

317
00:35:17,260 --> 00:35:22,280
en relación al target que es la nave y luego le digo ya sí efectivamente ojo

318
00:35:22,280 --> 00:35:28,460
quiero que la nave esté se podría hacer directamente se podría decir oye quiero

319
00:35:28,460 --> 00:35:31,840
que la nave esté en

320
00:35:33,380 --> 00:35:39,039
quiero que esté en target post pero voy a hacer otra cosa

321
00:35:39,039 --> 00:35:41,780
Que si no, veo que la lío, que se me olvida.

322
00:35:41,940 --> 00:35:43,460
Voy a hacer que esto es buena práctica.

323
00:35:43,559 --> 00:35:45,239
Digo, aquí tengo algo seguro que me funcionaba.

324
00:35:45,340 --> 00:35:48,260
Lo comento y ahora digo, quiero que esté en target post.

325
00:35:49,340 --> 00:35:51,239
Target punto post.

326
00:35:53,860 --> 00:35:55,199
No, no, yo quiero post.

327
00:35:56,420 --> 00:36:00,099
Y quiero que en todo momento la posición de este objeto, ¿vale?

328
00:36:00,400 --> 00:36:03,039
Cuando ponemos transform y posición nos hablamos de lo...

329
00:36:03,039 --> 00:36:04,579
Perdona que a veces sea redundante, ¿vale?

330
00:36:04,579 --> 00:36:08,579
Pero es un poco para ir repitiendo y que vaya sentándose cosas.

331
00:36:09,039 --> 00:36:17,079
Quiero que la posición de este objeto sea la del target post, que es básicamente la que hemos guardado aquí con ya los offsets aplicados.

332
00:36:17,300 --> 00:36:23,320
Si yo es esto lo que aplico a esta cámara, pues vamos a ver que no va a haber este retardo.

333
00:36:23,460 --> 00:36:32,059
Simplemente la cámara va a tener ese offset y se va a mover con la cámara, como si estuviera anclada en este caso a la nave a cierta distancia y se moviera con la nave.

334
00:36:32,380 --> 00:36:32,880
Vale, pues ya está.

335
00:36:32,880 --> 00:36:39,179
Si yo el offset le digo que en vez de Z sea, bueno, antes se lo he dicho al revés, que era Z y tal

336
00:36:39,179 --> 00:36:45,780
Bueno, si le digo que en vez de a 15 unidades por detrás, esté a 50, simplemente con cambiar ese valor

337
00:36:45,780 --> 00:36:50,840
Vais a ver que va a estar anclada igual, pero bastante más lejos

338
00:36:50,840 --> 00:36:59,599
Ya hablamos que existe, ¿vale? Y esto en la instanciación lo hablamos a colación de que también se creaba, se podía crear una variable de tipo transform

339
00:36:59,599 --> 00:37:21,360
Y fijaos que aquí se refiere a la clase transform con la T mayúscula, ¿vale? Normalmente, y lo vais a ver en el tema 3, cuando queremos hacer cambios en un componente, es decir, recordad que los componentes son estos distintos bloques que proporcionan propiedades a los GameObjects, ¿no?

340
00:37:21,360 --> 00:37:23,619
hay uno que se llama Transform que está siempre

341
00:37:23,619 --> 00:37:25,619
en todos los GameObjects

342
00:37:25,619 --> 00:37:26,679
a excepción de algunos de

343
00:37:26,679 --> 00:37:29,539
la UserInterface, bueno, algunos

344
00:37:29,539 --> 00:37:31,320
puntuales que no lo tienen, pero en general

345
00:37:31,320 --> 00:37:33,559
todos tienen este Transform porque todos se ubican en el espacio

346
00:37:33,559 --> 00:37:35,340
y tienen una rotación y una escala, ¿vale?

347
00:37:35,619 --> 00:37:36,920
impepinablemente, entonces

348
00:37:36,920 --> 00:37:39,539
a diferencia de por ejemplo lo que tendremos que hacer

349
00:37:39,539 --> 00:37:41,719
en la siguiente tarea cuando queramos

350
00:37:41,719 --> 00:37:43,219
cambiar, por ejemplo

351
00:37:43,219 --> 00:37:45,380
estoy poniendo uno de los valores

352
00:37:45,380 --> 00:37:46,820
una de las propiedades

353
00:37:46,820 --> 00:37:49,599
del componente RigidBody que no se va a poder

354
00:37:49,599 --> 00:38:04,599
poner directamente RigidBody.más para cambiarlo, a diferencia de eso, en Transform se considera que al ser tan universal, se puede apelar a él directamente sin tener que recogerlo.

355
00:38:05,539 --> 00:38:13,940
Esto cuando veáis la unidad 2, vais a ver eso, que por ejemplo, si yo quiero cambiar, vamos a hacer el ejemplo de hecho, una de las propiedades de un RigidBody es la masa,

356
00:38:13,940 --> 00:38:25,679
¿Vale? El más. Y lo podemos querer cambiar. Y yo digo, voy a crear un RigidBody, lo llamo RB, ahora os explico esto un poco más en detalle.

357
00:38:25,880 --> 00:38:35,880
Aunque ya os digo que esto se explica en la unidad 3. Pero si yo capturo este RigidBody, lo escribo y ahora lo voy explicando, que va a ser más sencillo.

358
00:38:35,880 --> 00:38:44,000
Y yo, uy va, aquí me ha hecho lo que ha querido, digo quiero meterme en la masa y decirle que esto es igual a 10, ¿vale?

359
00:38:45,159 --> 00:38:55,420
Básicamente con este código lo que estoy diciéndole es, este objeto que tiene este script incluido, que es la cámara, ¿vale?

360
00:38:55,420 --> 00:39:19,599
Al final un script se incorpora en un GameObject como un componente, ¿vale? Si yo este componente, este objeto que tiene esta clase CameraFollow, quiero cambiar sus valores, ¿vale? Al final lo que tengo que hacer es crear una clase que se llame como el componente.

361
00:39:19,599 --> 00:39:28,840
Y vais a ver que para ir accediendo a los distintos componentes, básicamente va a haber que hacer una variable de ese tipo de componente.

362
00:39:29,380 --> 00:39:35,079
Por ejemplo, si yo quiero variar los valores de cámara, aquí habrá una clase que se llama cámara.

363
00:39:35,659 --> 00:39:42,820
Si quiero variar los de audio listener, va a haber una clase que se llama audio listener.

364
00:39:42,820 --> 00:40:03,079
Y esta creación de clases, clase manipulador, audio listener. Tendremos que ir, para poder apelar a qué estamos haciendo los cambios, va a haber siempre que crear una variable con el tipo de variable llamada como el componente.

365
00:40:03,079 --> 00:40:17,940
A veces pueden cambiar un poco los nombres, pero fijáis que, no me lo sé de memoria, sé que como hay uno que se llama AudioListener, yo lo pongo ahí y es un tipo de clase posible, ¿vale? Que se puede crear como variable. Y ya a partir de aquí lo usaremos con el nombre que hayamos atribuido a esa variable, ¿vale?

366
00:40:17,940 --> 00:40:39,699
Entonces, ¿qué ocurre? Que hay un proceso intermedio, que es que aunque pongamos que aquí vamos a trabajar con una variable de tipo RigidBody, hasta que no le digamos a qué RigidBody se refiere, que es lo que se hace con esta operación, ahora la explicamos en más detalle, no va a poder hacer ningún cambio.

367
00:40:39,699 --> 00:40:50,099
Fijaos, ¿vale? Bueno, primero, para que veáis que esto ocurre, si como yo le he dicho que la masa me la cambia a 10, yo cuando guardo y ejecuto este código, ¿vale?

368
00:40:50,099 --> 00:40:59,000
Vais a ver que efectivamente está cambiando la masa a 10. ¿Veis que se ha puesto 10 al lanzarse? ¿Vale? Que sí que está habiendo este cambio mediante código.

369
00:40:59,940 --> 00:41:01,480
¿Qué pasa si yo borro esta línea?

370
00:41:03,420 --> 00:41:09,980
Aparentemente no pasa nada, pero vais a ver que solo por borrar esa línea que ahora explicábamos,

371
00:41:10,860 --> 00:41:14,099
yo le doy a play y este cambio no se realiza, no se pone a 10.

372
00:41:14,099 --> 00:41:25,860
Y dices, pero según la lógica, yo estoy diciendo que la variable RB se opere con los contenidos de este componente RigidBody

373
00:41:25,860 --> 00:41:33,199
y me cambie el parámetro, RB, pues dentro tiene propiedades, que es el de masa, que me lo cambia a 10.

374
00:41:33,579 --> 00:41:38,980
¿Por qué no está haciendo esto? Porque hay que usar la captura de componentes.

375
00:41:39,099 --> 00:41:45,960
La captura de componentes básicamente es un paso, a veces un poco tedioso, que es igual que cuando decimos que esto es un transform

376
00:41:45,960 --> 00:41:53,219
y ponemos un serialize field y hasta que no arrastramos en el inspector cuál es ese elemento,

377
00:41:53,219 --> 00:41:55,300
no sabe a qué elemento tiene que influir

378
00:41:55,300 --> 00:41:56,599
o cuál tiene que guardar aquí

379
00:41:56,599 --> 00:42:00,539
voy a hacer el ejemplo de decir

380
00:42:00,539 --> 00:42:03,659
serializeFill y esto lo pongo como un serializeFill

381
00:42:03,659 --> 00:42:07,559
y tengo aquí ese serializeFill

382
00:42:07,559 --> 00:42:09,800
y como lo he generado como un serializeFill

383
00:42:09,800 --> 00:42:11,860
cuando yo voy

384
00:42:11,860 --> 00:42:12,800
a esta cámara

385
00:42:12,800 --> 00:42:15,679
vais a ver que se ha generado

386
00:42:15,679 --> 00:42:17,800
un serializeFill de esta variable

387
00:42:17,800 --> 00:42:19,880
llamada RB que está pidiendo

388
00:42:19,880 --> 00:42:21,579
ahora está vacío, está pidiendo

389
00:42:21,579 --> 00:42:22,920
que le incorporemos un RigidBody

390
00:42:22,920 --> 00:42:25,579
¿qué quiere decir esto por defecto?

391
00:42:26,260 --> 00:42:27,820
que hasta que no arrastremos aquí

392
00:42:27,820 --> 00:42:29,860
un GameObject con

393
00:42:29,860 --> 00:42:32,219
RigidBody, como por ejemplo este mismo

394
00:42:32,219 --> 00:42:34,320
si yo arrastro MainCamera, tiene un RigidBody

395
00:42:34,320 --> 00:42:36,360
entonces me coge el RigidBody de MainCamera

396
00:42:36,360 --> 00:42:38,039
y sabe que tiene que cambiar

397
00:42:38,039 --> 00:42:40,159
RB tiene que cambiar este RigidBody

398
00:42:40,159 --> 00:42:41,139
y no otro

399
00:42:41,139 --> 00:42:43,940
pero hasta que no lo captura

400
00:42:43,940 --> 00:42:46,340
o no se lo determinaba de una forma explícita

401
00:42:46,340 --> 00:42:47,820
esto está vacío

402
00:42:47,820 --> 00:42:49,780
simplemente ha creado una variable

403
00:42:49,780 --> 00:42:51,360
que es de tipo RigidBody

404
00:42:51,360 --> 00:43:09,940
Y esto también lo comenté al principio, pero la gracia que tiene que haya distintas clases con los nombres de los componentes es que aquí si nos metemos, ¿vale? Ya os dije que si dais a la tecla control sobre el nombre de las variables, o mejor dicho, de las clases, ¿vale?

405
00:43:09,940 --> 00:43:31,780
Lo que nos metemos es en un código que ya alguien ha hecho en Unity o no sé quién desarrolla esto, sinceramente, con todo lo que se ocupa ese componente, ¿vale? Por eso ya aparecen estas variables, estos campos serializados, por eso básicamente un componente tiene unas propiedades y no otras, ¿vale? Y unos comportamientos y no otros, ¿vale?

406
00:43:31,780 --> 00:43:45,920
Entonces, recordad que básicamente tenemos preparado que queremos afectar a un componente, y por eso ponemos su nombre, pero hasta que no le digamos qué componente de los que hay en la escena es, básicamente Unity no sabe con cuál tiene que hacer nada.

407
00:43:45,920 --> 00:43:48,780
a ver

408
00:43:48,780 --> 00:43:51,400
ahí estamos

409
00:43:51,400 --> 00:43:52,960
otra vez, ¿vale? entonces

410
00:43:52,960 --> 00:43:55,219
¿cómo se hace esto? se puede hacer

411
00:43:55,219 --> 00:43:57,260
o mediante un serialize fill y decírselo

412
00:43:57,260 --> 00:43:59,139
a través del editor, que es lo que hemos hecho

413
00:43:59,139 --> 00:44:00,639
con este target, ¿vale?

414
00:44:01,019 --> 00:44:02,820
o podemos hacerlo por código

415
00:44:02,820 --> 00:44:05,000
lo que hay que hacer es, una vez se ha creado esta caja

416
00:44:05,000 --> 00:44:07,280
recordad esta variable, que a partir de ahora

417
00:44:07,280 --> 00:44:08,840
aunque sea de tipo rigibody

418
00:44:08,840 --> 00:44:11,119
su nombre que le hemos puesto es

419
00:44:11,119 --> 00:44:13,059
rb, como podríamos poner

420
00:44:13,059 --> 00:44:14,800
joaquín, yo que sé, cualquiera

421
00:44:14,800 --> 00:44:27,699
Yo puedo decirle, vale, rb, esta variable, esta caja, lo que tiene que usar es coger este componente y la sintaxis es la que sigue. Se abren estas llavecitas y paréntesis.

422
00:44:27,699 --> 00:44:46,480
¿Vale? El paréntesis aquí, por defecto, en los usos que vamos a dar nosotros, sirve, y recordad que cuando estamos llamando, esto lo hacíamos, por ejemplo, en el que hemos visto antes de mover el objeto, ¿vale?

423
00:44:46,480 --> 00:44:53,420
Para que se sepa que un método al que estamos llamando es un método y no otra cosa, hay que poner esos paréntesis, ¿vale?

424
00:44:53,500 --> 00:45:02,539
Si no, no es un método, ¿vale? Siempre que veáis unos paréntesis llenos o vacíos después de un nombre, suele ser porque es un método al que estamos apelando.

425
00:45:03,079 --> 00:45:11,559
Entonces, GetComponent es un método, ¿vale? Pero funciona de una forma diferente a otras ocasiones, que es que en estas llaves es donde ponemos el nombre del componente, ¿vale?

426
00:45:11,559 --> 00:45:13,900
con esta línea lo que estamos

427
00:45:13,900 --> 00:45:15,940
haciendo es que esta caja que abrimos aquí

428
00:45:15,940 --> 00:45:17,840
de tipo RigidBody, porque vamos a usar

429
00:45:17,840 --> 00:45:19,659
las propiedades que

430
00:45:19,659 --> 00:45:21,539
se han ya programado previamente

431
00:45:21,539 --> 00:45:23,860
de ese componente

432
00:45:23,860 --> 00:45:25,619
llamado RigidBody, es decirle, vale

433
00:45:25,619 --> 00:45:27,920
yo quiero que guardes en esa caja

434
00:45:27,920 --> 00:45:29,559
el componente RigidBody

435
00:45:29,559 --> 00:45:31,099
de este objeto que tiene el script

436
00:45:31,099 --> 00:45:33,800
es decir, ahora mismo en RB

437
00:45:33,800 --> 00:45:35,860
como este es el script

438
00:45:35,860 --> 00:45:37,800
que tiene este código

439
00:45:37,800 --> 00:45:39,639
al lanzarse en el start

440
00:45:39,639 --> 00:45:49,579
dice, vale, me meto y le digo, a ver, bueno, esto ya lo puedo cerrar, me meto y dice, a ver, me meto y cojo el componente que hay en este objeto,

441
00:45:49,679 --> 00:45:57,380
porque no le estoy diciendo que sea en otro, RigidBody, vale, y lo meto, me ha dicho en, este ya también me lo voy a mover,

442
00:45:58,059 --> 00:46:07,559
y me ha dicho que lo meta en RB, ¿vale? Y a partir de ahora RB sí que se va a estar refiriendo en todo caso a ese componente que está en este objeto, ¿vale?

443
00:46:07,559 --> 00:46:28,119
Y por eso, a partir de ahí, sí podemos entrar en las propiedades. Yo ahora pongo RB y al dar a punto, ¿vale? Y ver las propiedades, vais a ver que hay muchas propiedades, pero básicamente es Kinematic, quedad con estos nombres, es Kinematic, más, si voy arriba estará Drag, por ejemplo, Angular Drag, Drag, ¿vale?

444
00:46:28,119 --> 00:46:56,159
Todo esto son propiedades que, si os fijáis, lo que hacen es alterar el contenido de este componente, ¿vale? Es la forma de acceder. Si yo aquí pongo drag y le digo que drag es igual a 10, nuevamente, ¿vale? Cuando guardo, estoy diciendo, vale, capturo en una variable de tipo rigidbody, mediante esta operación, este rigidbody, ya puedo acceder directamente a las propiedades de este rigidbody, entre una de ellas es drag, ¿vale?

445
00:46:56,159 --> 00:47:00,000
Al darle a reproducir vais a ver que drag se pone a 10.

446
00:47:00,920 --> 00:47:04,480
Esta es la forma de acceder por código a las propiedades de cada componente.

447
00:47:06,940 --> 00:47:09,139
Vuelvo rápidamente y luego volvemos a esto.

448
00:47:09,719 --> 00:47:11,179
¿Qué sucede con el transform?

449
00:47:11,739 --> 00:47:19,460
Que si esto hubiera que hacerlo con el transform para cambiar la posición, para acceder a position, sería un rollo, por decirlo así rápido.

450
00:47:19,460 --> 00:47:35,920
Habría que hacer transform, darle el target o el nombre que fuera, luego target, luego igual a get component, transform, ¿vale? Y esto sería para preparar que target funcionara como transform y ya pudiera entrar a position o a lo que fuera.

451
00:47:35,920 --> 00:47:56,179
¿Qué han hecho? Se ha simplificado porque transform se usa tanto que sin necesidad de hacer nada de todo esto que hemos hecho para, por ejemplo, rb o acceder a cualquier otro. Y esto es cualquier otro de los componentes en los que queramos cambiar parámetros o propiedades, pues directamente al dar a transform ya se ha hecho toda esa operación.

452
00:47:56,179 --> 00:48:00,239
es un atajo, digamos, a este componente transform, ¿vale?

453
00:48:00,239 --> 00:48:02,559
Lo veis, transform es la clase donde está todo el código,

454
00:48:03,119 --> 00:48:05,320
pero hay un atajo que es, con este transform ya,

455
00:48:05,440 --> 00:48:07,780
que apela directamente a todo este recorrido que hemos hecho.

456
00:48:08,199 --> 00:48:11,719
Y por eso ya podemos acceder al position, al Euler angles,

457
00:48:12,360 --> 00:48:15,480
a la escala local, ¿vale?

458
00:48:16,860 --> 00:48:18,920
Por eso es esa diferencia entre transform

459
00:48:18,920 --> 00:48:23,480
o otros tipos de componentes, ¿vale?

460
00:48:23,820 --> 00:48:25,179
¿Qué pasa? Que cuando damos a transform,

461
00:48:25,179 --> 00:48:31,099
básicamente en una línea estamos diciendo que está refiriéndose al transform de ese objeto, no de otro, de ese objeto.

462
00:48:32,039 --> 00:48:38,219
Por eso, a diferencia de cuando usamos el transform capturado por un serialize field llamado target,

463
00:48:38,380 --> 00:48:43,260
aquí al decirle target.position, no estamos accediendo a las propiedades del transform de ese objeto,

464
00:48:43,699 --> 00:48:48,260
estamos accediendo a las propiedades de transform de ese objeto al que hemos referenciado aquí.

465
00:48:49,260 --> 00:48:54,579
Y por eso ese target.position no se refiere a la posición del mismo objeto que tiene el script,

466
00:48:54,579 --> 00:49:03,239
sino a la posición, ahí está accediendo al transform de este objeto, aquí.

467
00:49:04,559 --> 00:49:09,219
Esto también lo expliqué, pero creo que no es de más.

468
00:49:09,420 --> 00:49:12,260
Cuando creamos un objeto vacío, ves que ya viene con el transform, ¿vale?

469
00:49:12,599 --> 00:49:17,860
Otra pista de que el transform es tan universal que ya se hacen atajos para acceder a él.

470
00:49:18,260 --> 00:49:21,099
Pero que al final lo que proporciona que un objeto sea de una forma u otra

471
00:49:21,099 --> 00:49:24,260
es los diferentes componentes que vamos incorporando.

472
00:49:24,260 --> 00:49:29,500
esos bloques de código que ya están prehechos con sus configuraciones, comportamientos, etc.

473
00:49:29,760 --> 00:49:34,719
Entonces, básicamente, todo lo que vamos a ir haciendo es ir cambiando los distintos componentes de cada objeto.

474
00:49:37,059 --> 00:49:43,639
Si queremos cambiar los valores de un componente, como acabamos de decir,

475
00:49:44,000 --> 00:49:48,420
habrá que hacer ese tipo de variable con el nombre del componente y guardarlo en una variable.

476
00:49:48,420 --> 00:49:53,420
Y ojo, porque también os he dicho que los scripts, a su modo, también son componentes.

477
00:49:54,260 --> 00:50:00,719
Ya os he dicho, esto al final, aunque es un script, se llama CameraFollow y es un componente, lo hemos incorporado como cualquier otro componente.

478
00:50:01,139 --> 00:50:04,440
Por eso hay que arrastrar al GameObject, porque hay que incorporarlo como componente.

479
00:50:05,480 --> 00:50:09,960
A estos scripts se puede hacer desde otros scripts también poniendo su nombre.

480
00:50:10,199 --> 00:50:22,900
Si yo pongo aquí CameraFollow, ¿vale? Veis que esto no existía por defecto, esto se llama así porque hay un componente que he creado yo, en este caso, que se llama CameraFollow y por eso sale aquí.

481
00:50:22,900 --> 00:50:37,820
Si yo desde otro código, y este ya os digo que es el que tiene el código, pero si yo me meto en otro de los scripts que estoy usando, a ver, aquí tengo scripts, pues yo que sé, el de instanciar, lo pongo aquí, yo que sé.

482
00:50:38,519 --> 00:50:46,579
Y yo quisiera cambiar algo de ese otro script que he creado yo, yo si me meto y busco camera follow, veis que está aquí.

483
00:50:46,579 --> 00:51:03,280
En parte porque cuando, esto lo hace automáticamente Unity, pero cuando generamos esta clase, que es en el fondo el componente, veréis que es pública por defecto. Entonces, al ser pública, podemos acceder de otros códigos. Si recordáis, el ámbito es público, es general, se puede acceder de otros puntos.

484
00:51:03,280 --> 00:51:28,820
Por eso, si yo ahora quiero acceder a Camera Follow y le digo, vale, este se va a llamar CF, ¿qué problema hay? Que yo, si luego en el Start digo Camera Follow, y he puesto, bueno, habría que hacer alguna variable, pero, a ver, dejadme que me meta.

485
00:51:28,820 --> 00:51:30,780
Espera, que ya no sé dónde tengo cada código.

486
00:51:31,079 --> 00:51:32,039
Aquí, ¿vale?

487
00:51:32,039 --> 00:51:33,960
Lo voy a unir al otro para tenerlo ahí pegahico.

488
00:51:34,400 --> 00:51:39,860
Igual que tengo propiedades, a lo mejor yo quiero acceder al Offset Camera Z de Camera Follow, ¿vale?

489
00:51:39,860 --> 00:51:40,820
Que es una de sus propiedades.

490
00:51:41,260 --> 00:51:43,699
Si doy aquí a, ¿cómo se llama?

491
00:51:43,840 --> 00:51:44,619
Offset Camera, ¿no?

492
00:51:45,039 --> 00:51:46,480
Sí, a Offset Camera.

493
00:51:48,260 --> 00:51:52,219
No sale aquí en primer punto porque no es público, ¿vale?

494
00:51:52,219 --> 00:51:55,880
Para que sea público hay que ponerlo aquí y hay que ponerlo como público.

495
00:51:56,079 --> 00:51:57,440
Si no, se encapsula.

496
00:51:57,440 --> 00:52:13,119
Si yo ahora pongo punto, ¿aparecerá offset cámara? No. ¿Por qué? Porque nuevamente nos falta una operación, que es decir, ¿cuál es este camera follow?

497
00:52:13,119 --> 00:52:32,260
En principio habrá que decirle que CF capture el CameraFollow, con el problema de que si ponemos esto así, va a buscar dentro de sus componentes ese CameraFollow.

498
00:52:32,260 --> 00:52:49,239
Y Camera Follow no está dentro de los componentes del objeto, del GameObject que tiene instanciar obstáculos. Es decir, yo voy al Instanciador que es el que tiene instanciar obstáculos y no tiene ningún componente llamado Camera Follow.

499
00:52:49,239 --> 00:52:50,699
está en

500
00:52:50,699 --> 00:52:54,019
main camera ¿vale? es un poco lo mismo

501
00:52:54,019 --> 00:52:55,920
de antes ¿qué hay que hacer?

502
00:52:56,340 --> 00:52:57,119
pues hay dos formas

503
00:52:57,119 --> 00:53:00,099
o hacer que esto sea un serialize field

504
00:53:00,099 --> 00:53:03,960
¿vale? y le decimos

505
00:53:03,960 --> 00:53:05,840
arrastrando en el editor, esto lo voy a comentar

506
00:53:05,840 --> 00:53:06,900
porque si no igual da fallo

507
00:53:06,900 --> 00:53:09,860
arrastrar cuál es el game object

508
00:53:09,860 --> 00:53:11,780
que si tiene ese camera follow y ya sí que

509
00:53:11,780 --> 00:53:13,739
al poner cf podremos acceder

510
00:53:13,739 --> 00:53:15,159
a sus variables

511
00:53:15,159 --> 00:53:17,760
¿vale? y primero tenemos

512
00:53:17,760 --> 00:53:19,599
que ir ¿vale? instanciador

513
00:53:19,599 --> 00:53:21,099
a ver, tengo que guardar primero

514
00:53:21,099 --> 00:53:38,000
Y ahora en el instanciador veis que está esperando que le digamos, vale, pero ¿este camera follow de dónde sale? Porque ojo, el camera follow es un script que hemos incorporado a main camera, pero podemos haber arrastrado más objetos, también tiene esa lógica de determinar a qué objeto y qué main camera es el que cambiamos.

515
00:53:38,000 --> 00:53:57,400
Si ahora vamos a instanciador, le decimos, vale, el camera follow del que hablamos es este, el de main camera. Hemos arrastrado main camera y él ya sabe que tiene que buscar el script porque es de tipo camera follow, que realmente es de tipo script. Por eso sale ese iconito de script y no el de prefab, por ejemplo.

516
00:53:57,400 --> 00:54:25,699
Ahora, ¿qué ocurre? Que cuando vamos a este código, al código en el que hemos llamado a Camera Follow, que lo tengo aquí, ahora sí que cuando yo, sin hacer que se componen, porque se lo hemos pasado de forma explícita por el editor, cuando damos a CF, al dar punto, sí que aparecerán, a ver, Offset Camera, Offset Camera Z, Smooth Time, que son las variables o propiedades, ¿vale?

517
00:54:25,699 --> 00:54:31,780
que sí hemos creado en esta clase, en este script.

518
00:54:32,880 --> 00:54:33,880
¿Esto qué significa?

519
00:54:34,460 --> 00:54:38,039
Que de una forma ya que nos permite cambiar

520
00:54:38,039 --> 00:54:39,820
casi cualquier valor de un componente,

521
00:54:40,420 --> 00:54:43,239
si en el start, o lo voy a poner en el update,

522
00:54:43,559 --> 00:54:44,900
en el update, yo qué sé,

523
00:54:45,559 --> 00:54:47,739
si yo ahora le digo, vale, quiero,

524
00:54:48,139 --> 00:54:54,900
yo ahora todo lo que ponga cf me estoy refiriendo a ese componente

525
00:54:54,900 --> 00:54:56,800
cameraFollow al otro script, básicamente

526
00:54:56,800 --> 00:54:58,340
a lo que tengo aquí, ¿vale?

527
00:54:58,440 --> 00:55:00,019
Y le voy a decir que, por ejemplo,

528
00:55:00,719 --> 00:55:02,199
el cameraOffset

529
00:55:02,199 --> 00:55:04,860
en Z, ¿vale? En vez de ponerlo en su

530
00:55:04,860 --> 00:55:06,280
código, voy a decirle es 50.

531
00:55:07,420 --> 00:55:08,380
¿Y ahora qué va a pasar?

532
00:55:08,599 --> 00:55:10,800
Que cuando empezamos el juego, cuando llegue

533
00:55:10,800 --> 00:55:12,739
a este punto, le estamos diciendo

534
00:55:12,739 --> 00:55:14,639
por un código que cambie otro de

535
00:55:14,639 --> 00:55:16,719
nuestros códigos, ni siquiera es uno de los componentes

536
00:55:16,719 --> 00:55:18,599
que ya viene por Unity, sino uno de nuestros códigos

537
00:55:18,599 --> 00:55:20,420
y aunque aquí hubiéramos puesto

538
00:55:20,420 --> 00:55:22,360
el offset de Z a 15,

539
00:55:22,800 --> 00:55:24,659
vais a ver que se va a poner en 50, es decir,

540
00:55:24,900 --> 00:55:41,079
Que igual que hemos hablado antes, se va a poner a 50 de distancia la cámara. Lo ponemos aquí y vais a fijaros, bueno, a ver, que está alejado. A ver, 50, 50, ¿por qué no me está cogiendo el offset?

541
00:55:41,079 --> 00:56:01,900
Y ha puesto aquí unas cuantas cosas. Ah, vale, espera. Si le doy a este offset, vais a ver que aquí el camera offset de pronto se ha puesto en 50. Y no está en el objeto instanciador, que es en el que tenemos ese script, sino en el de main camera. Y aquí se ha puesto el 50.

542
00:56:01,900 --> 00:56:05,440
otra forma

543
00:56:05,440 --> 00:56:06,659
y ya la última

544
00:56:06,659 --> 00:56:08,699
esto que hemos hecho aquí

545
00:56:08,699 --> 00:56:11,420
con un serialize fill

546
00:56:11,420 --> 00:56:13,519
hablar de otro camera follow

547
00:56:13,519 --> 00:56:16,300
si en vez de hacerlo con un serialize fill

548
00:56:16,300 --> 00:56:17,780
lo queremos hacer

549
00:56:17,780 --> 00:56:18,920
por código

550
00:56:18,920 --> 00:56:21,019
el problema que tenemos aquí es

551
00:56:21,019 --> 00:56:23,320
que decimos lo que hemos dicho antes

552
00:56:23,320 --> 00:56:24,820
he preparado que recoja

553
00:56:24,820 --> 00:56:26,519
este script de camera follow

554
00:56:26,519 --> 00:56:28,820
pero en un objeto que no tiene camera follow

555
00:56:28,820 --> 00:56:30,980
entonces al hacer

556
00:56:30,980 --> 00:56:38,099
la captura de componente esta línea es incorrecta porque aquí le estamos diciendo en el script en

557
00:56:38,099 --> 00:56:42,139
este script en el objeto mejor dicho que tiene este script que es instancia los obstáculos y

558
00:56:42,139 --> 00:56:47,780
es instancia dor vale busca o captura el componente llamado camera follow y aquí no

559
00:56:47,780 --> 00:56:55,059
está por tanto esto basta va a dar errores decir no va a ser no de hecho si intento darle a play

560
00:56:55,059 --> 00:57:00,539
vais a ver que lo que ocurre es que da un error porque dice no encuentro la referencia al objeto

561
00:57:00,539 --> 00:57:03,599
que me estás pidiendo que capture vale porque aquí no hay nada que se llame

562
00:57:03,599 --> 00:57:08,199
cámara follow vale en ese caso ya esto es por complicarse a lo mejor lo rápido

563
00:57:08,199 --> 00:57:12,579
aquí nuestro nivel es poner un serie de fil arrastrar y se lo decimos pero aquí

564
00:57:12,579 --> 00:57:18,320
lo que podemos hacer es decirle hay distintos de hecho si nos metemos

565
00:57:18,320 --> 00:57:22,500
esto ya de momento más avanzado y hay uno de los vídeos de álvaro holguera que

566
00:57:22,500 --> 00:57:26,360
si no me equivoco está en la unidad 3 que habla de esto específicamente pero

567
00:57:26,360 --> 00:57:37,239
Hay distintos. Si nos ponemos en la API de Unity Documentation y damos a GetComponent, vais a ver que hay GetComponent a pelo, que es este que estamos usando.

568
00:57:38,000 --> 00:57:42,260
Este de cógeme el componente llamado tal y me lo guardas en una variable de este tipo.

569
00:57:42,840 --> 00:57:47,800
De hecho, veis que suele haber esta rima de que el tipo de variable luego es la que se busca aquí. Se llaman igual.

570
00:57:49,199 --> 00:57:55,039
Aquí lo ha hecho en una sola línea, pero es exactamente lo mismo que hemos hecho la lógica que hemos usado en los ejemplos.

571
00:57:55,039 --> 00:58:17,500
Pero si vais viendo, hay otros que se llaman GetComponentInChildren, GetComponentInParent. Hay otro tipo de métodos, como este Define, si lo buscamos aquí, que es buscar un objeto por distintas tipologías o distintas criterios que demos.

572
00:58:17,500 --> 00:58:20,360
Podemos buscarlo por el tipo de objeto que sea

573
00:58:20,360 --> 00:58:21,420
Por el nombre

574
00:58:21,420 --> 00:58:24,039
Por el index que tenga

575
00:58:24,039 --> 00:58:26,360
Por ejemplo, si vemos este transform

576
00:58:26,360 --> 00:58:27,300
Find

577
00:58:27,300 --> 00:58:29,619
No, mejor dicho, GameObjectFind

578
00:58:29,619 --> 00:58:32,099
Lo que hace será buscar un GameObject

579
00:58:32,099 --> 00:58:34,099
En la jerarquía

580
00:58:34,099 --> 00:58:35,760
Pero por código, ojo

581
00:58:35,760 --> 00:58:38,239
Entonces con esto lo que podemos hacer es poner

582
00:58:38,239 --> 00:58:40,320
Poniendo esta operación

583
00:58:40,320 --> 00:58:41,599
De GameObject.find

584
00:58:41,599 --> 00:58:44,000
Y poniéndole un nombre

585
00:58:44,000 --> 00:58:46,260
Vamos a decirle, oye, búscame

586
00:58:46,260 --> 00:58:48,599
dentro de la jerarquía un objeto que se llame

587
00:58:48,599 --> 00:58:50,559
de tal manera y de ese objeto

588
00:58:50,559 --> 00:58:52,440
ya dentro me buscas el componente

589
00:58:52,440 --> 00:58:53,860
que se llame CameraFollow, ¿vale?

590
00:58:54,199 --> 00:58:56,019
Por ejemplo, nos vamos a quedar que aquí hay un

591
00:58:56,019 --> 00:58:58,460
GameObject que se llama MainCamera que es el que tiene el

592
00:58:58,460 --> 00:59:00,340
CameraFollow. Entonces vamos ahí

593
00:59:00,340 --> 00:59:01,679
y le decimos

594
00:59:01,679 --> 00:59:04,159
¿vale? Quiero que me hagas...

595
00:59:04,159 --> 00:59:06,679
Bueno, borro esto de... Bueno, el GameComponent lo dejo ahí.

596
00:59:07,400 --> 00:59:08,420
Es dentro

597
00:59:08,420 --> 00:59:10,340
de la clase GameObject

598
00:59:10,340 --> 00:59:12,320
que es una genérica que guarda

599
00:59:12,320 --> 00:59:14,260
un montón de código relacionado con

600
00:59:14,260 --> 00:59:16,679
la gestión de los game objects

601
00:59:16,679 --> 00:59:17,539
vale

602
00:59:17,539 --> 00:59:19,679
le decimos find

603
00:59:19,679 --> 00:59:21,920
y vamos a decirle que en vez de por

604
00:59:21,920 --> 00:59:23,940
se puede buscar por las etiquetas que ya lo veremos

605
00:59:23,940 --> 00:59:26,559
por los tipos, hay muchos tipos de búsqueda

606
00:59:26,559 --> 00:59:28,039
pero el básico

607
00:59:28,039 --> 00:59:30,699
si le damos aquí entre paréntesis

608
00:59:30,699 --> 00:59:32,079
el nombre de lo que tiene que buscar

609
00:59:32,079 --> 00:59:34,420
que es main camera hemos dicho

610
00:59:34,420 --> 00:59:36,219
al ser un string hay que meterlo tal cual

611
00:59:36,219 --> 00:59:38,059
lo que va a hacer es

612
00:59:38,059 --> 00:59:39,579
en este punto de código va a buscar

613
00:59:39,579 --> 00:59:42,599
un objeto de la jerarquía llamado main camera

614
00:59:42,599 --> 01:00:11,500
es decir, llegará aquí, al primero que encuentre, se llama así, si hay varios llamados de distinta forma, solo cogería el primero en este caso, y ya una vez encontrado, seguimos enlazando, quiero que de ese objeto que has llegado hasta ahí, me cojas el componente llamado cameraFollow, y ahí sí que está cogiendo el componente de otro objeto, en vez de hacerlo por un serialize fila arrastrando, aquí estamos diciendo busca este objeto y me coges el componente,

615
01:00:11,500 --> 01:00:28,440
Por eso ahora, aunque estemos haciéndolo a través, sin serialize fill, del instanciador, de este script que tenemos en el instanciador, vais a ver que va a cambiar el valor del offset de cámara Z a 50, porque estamos apelando a otro objeto y a otro código.

616
01:00:28,440 --> 01:00:46,380
Entonces yo ahora si ejecuto el juego vais a ver que aquí se ponen 50. Desde el script de un GameObject estamos buscando el componente en otro GameObject y cambiamos una de sus propiedades. Esto es como la base para interconectar distintos scripts.