1
00:00:07,219 --> 00:00:11,460
En este vídeo vamos a hacer un ejercicio que vamos a estar repitiendo a lo largo del curso,

2
00:00:11,980 --> 00:00:18,480
que no es otra cosa que acceder a variables y métodos que están presentes en otras clases,

3
00:00:18,660 --> 00:00:23,039
en otros GameObjects, pero que necesitamos para el script que estamos generando.

4
00:00:23,160 --> 00:00:27,940
Es decir, por poner un ejemplo, imaginemos que tenemos un obstáculo que se mueve a una velocidad,

5
00:00:28,539 --> 00:00:34,600
pero esa velocidad depende de una variable disponible, a lo mejor, en el script que tiene asociado el personaje.

6
00:00:34,600 --> 00:00:36,520
Así que necesitamos acceder a esa variable.

7
00:00:37,219 --> 00:00:40,979
igual que podemos necesitar acceder a los métodos que tienen esos scripts.

8
00:00:41,159 --> 00:00:44,299
Así que vamos a aprender a eso, a comunicarnos entre scripts.

9
00:00:44,479 --> 00:00:46,240
Para ello he creado una escena vacía.

10
00:00:46,600 --> 00:00:52,140
Voy a generar a modo de ejemplo un cubo al cual voy a llamar personaje

11
00:00:52,140 --> 00:00:57,200
y voy a crear, por ejemplo, una esfera a la que la voy a llamar obstáculo.

12
00:00:59,700 --> 00:01:03,600
Bien, el dónde estén o cómo se coloquen, pues bueno, no me importa tanto

13
00:01:03,600 --> 00:01:10,439
porque también voy a crear un elemento de User Interface, en este caso un texto,

14
00:01:11,019 --> 00:01:14,659
para poder mostrar nuestros mensajes en pantalla. Eso me vale.

15
00:01:14,920 --> 00:01:18,879
Bien, ¿y para qué he creado esto? Pues realmente para que nuestro personaje, por ejemplo,

16
00:01:19,500 --> 00:01:25,579
le vamos a asociar un nuevo script. Le voy a llamar personaje script.

17
00:01:25,579 --> 00:01:32,099
Como siempre, recuerdo organizar todo nuestro material. Es decir, voy a crear una carpeta solo para los scripts

18
00:01:32,099 --> 00:01:35,019
donde voy a meter el que acabo de crear

19
00:01:35,019 --> 00:01:36,620
y ahí está

20
00:01:36,620 --> 00:01:38,120
también voy a crear una variable

21
00:01:38,120 --> 00:01:40,000
ahora sí necesito que sea pública

22
00:01:40,000 --> 00:01:43,000
de tipo número decimal

23
00:01:43,000 --> 00:01:44,640
y le vamos a llamar energy

24
00:01:44,640 --> 00:01:48,239
y esa es la energía que va a tener nuestro personaje

25
00:01:48,239 --> 00:01:51,500
y para que veamos que todo funciona bien

26
00:01:51,500 --> 00:01:53,659
voy a mandar a pantalla

27
00:01:53,659 --> 00:01:54,879
es decir, al user interface

28
00:01:54,879 --> 00:01:56,780
y le digo que el energy text

29
00:01:56,780 --> 00:01:58,420
el texto que contenga

30
00:01:58,420 --> 00:02:01,780
será una cadena de texto

31
00:02:01,780 --> 00:02:06,000
Os recuerdo que si no ponemos una cadena de texto nos dará error porque es lo que está esperando.

32
00:02:06,680 --> 00:02:12,979
Y le pongo energía, dos puntos, un espacio y concateno la variable energía.

33
00:02:14,360 --> 00:02:19,319
Y para rizar el rizo le voy a poner incluso un símbolo de porcentaje al final.

34
00:02:19,860 --> 00:02:26,460
Me vuelvo a Unity y antes que nada me voy a mi personaje donde voy a minimizar todos estos componentes.

35
00:02:26,460 --> 00:02:31,500
y veo que me está pidiendo la variable EnergyText, el texto de la pantalla

36
00:02:31,500 --> 00:02:34,479
y la variable energía que la voy a poner, por ejemplo, al 100%.

37
00:02:34,479 --> 00:02:38,539
Y el texto es efectivamente el que aparece aquí en pantalla.

38
00:02:38,759 --> 00:02:42,000
Lo puedo cambiar el nombre para también ser más rigurosos.

39
00:02:42,960 --> 00:02:49,340
Lanzo la pantalla del juego y si todo va bien, aquí nos aparecerá que contamos con una energía efectivamente del 100%.

40
00:02:49,340 --> 00:02:55,400
Y bien, no he hecho demasiado, solo he creado una variable energía que es pública, eso es lo importante,

41
00:02:55,400 --> 00:02:57,879
y la he mostrado en pantalla. Nada más.

42
00:02:58,020 --> 00:03:02,800
Pero ahora, ¿puedo acceder desde la esfera, es decir, desde lo que yo he llamado el obstáculo,

43
00:03:03,060 --> 00:03:07,620
a esa variable de energía para, lo que hemos comentado antes, actuar en consecuencia?

44
00:03:07,819 --> 00:03:09,900
Pues por supuesto que sí. Vamos a ver cómo.

45
00:03:10,300 --> 00:03:15,060
Lo primero que voy a hacer es, efectivamente, añadir un componente también a la esfera,

46
00:03:15,060 --> 00:03:19,419
es decir, un obstáculo. Le voy a llamar obstáculo script.

47
00:03:21,659 --> 00:03:24,199
Ese script lo meto en la carpeta de scripts.

48
00:03:24,199 --> 00:03:26,860
Antes de seguir, solo comentar una cosa

49
00:03:26,860 --> 00:03:29,719
Veamos que a veces cuando yo quiero acceder a un GameObject

50
00:03:29,719 --> 00:03:32,419
No accedo solo a las variables que tiene asociadas

51
00:03:32,419 --> 00:03:37,560
Sino también a sus componentes, a los AudioSources, al RigidBody o a los Collider

52
00:03:37,560 --> 00:03:43,120
Es decir, que realmente la forma idónea va a ser la que veremos más a continuación

53
00:03:43,120 --> 00:03:47,379
Pero ahora vamos a ver una forma muy sencilla de acceder a las variables que tenemos ahí disponibles

54
00:03:47,379 --> 00:03:50,400
¿Cómo? Pues declarando una variable pública

55
00:03:50,400 --> 00:04:03,159
Y si nos fijamos, ahora me voy al script del personaje, al haberlo creado se ha creado automáticamente una clase pública, es decir, que puedo acceder a ella desde cualquier otra clase llamada personaje script.

56
00:04:03,460 --> 00:04:11,479
Eso significa que si yo aquí empiezo a escribir créame una variable tipo personaje script, sí que me deja porque está disponible para mí.

57
00:04:11,479 --> 00:04:22,160
Y le voy a dar un nombre. Veréis que automáticamente nos sugiere escribir el mismo nombre de la clase, pero en minúscula, para identificar que esto es la instanciación de esa clase.

58
00:04:22,420 --> 00:04:32,019
Así que es muy habitual encontrarnos el nombre de la instancia igual que el nombre de la clase, solo que cambiando la primera letra entre mayúscula y minúscula.

59
00:04:32,019 --> 00:04:50,220
Antes de seguir, me voy a volver un momento y todo a Unity, porque al haber creado esa variable pública, si me voy a mi obstáculo, que es donde le he creado ese script, me fijo y esta variable que he creado me está solicitando el GameObject que contiene esa clase.

60
00:04:50,860 --> 00:04:57,300
Así que se lo voy a arrastrar. Le voy a decir que este es el GameObject que tiene asociado ese script.

61
00:04:57,300 --> 00:05:02,639
A partir de este momento ya están disponibles para mí las variables que tengo aquí.

62
00:05:03,819 --> 00:05:07,879
Tengo una variable de tipo float pública llamada energy.

63
00:05:08,240 --> 00:05:09,060
Lo voy a comprobar.

64
00:05:09,319 --> 00:05:10,819
Le voy a decir que mande a consola.

65
00:05:14,170 --> 00:05:17,529
Accedo a la variable que yo he creado, donde se supone que está.

66
00:05:18,629 --> 00:05:20,709
Y le digo que me muestre la energía.

67
00:05:21,370 --> 00:05:29,310
Y si todo va bien y lanzo el script, veremos que no solo nos lanza a pantalla la variable de la energía,

68
00:05:29,310 --> 00:05:36,149
sino que también en consola como podemos ver nos saca el número 100 y esto y es lo importante lo

69
00:05:36,149 --> 00:05:41,410
está diciendo el script que está asociado al obstáculo es decir acabamos de acceder a esa

70
00:05:41,410 --> 00:05:47,569
variable no sólo podemos acceder a ella y leerla es que también podemos cambiarla y le decimos que

71
00:05:47,569 --> 00:05:56,110
la energía de nuestro personaje en vez de 100 va a ser 50 y le voy a decir que me la vuelva

72
00:05:56,110 --> 00:06:03,889
a mostrar. Así que si nos vamos a Unity, efectivamente me aparece como que la energía ha cambiado

73
00:06:03,889 --> 00:06:14,110
a 50%. Primero era 100%, la he cambiado y efectivamente ahora es 50%. Conclusión, hemos

74
00:06:14,110 --> 00:06:19,449
declarado una variable pública, eso es importante, en el script de nuestro personaje. Desde el

75
00:06:19,449 --> 00:06:25,870
script de nuestro obstáculo hemos accedido a ese otro GameObject y hemos accedido a sus

76
00:06:25,870 --> 00:06:30,189
variables y lo hemos podido modificar, con lo cual ya hemos comunicado los scripts.

77
00:06:37,139 --> 00:06:42,480
Bueno, y como realmente nos vamos a hartar de usar este método de GetComponent para

78
00:06:42,480 --> 00:06:47,120
acceder a los componentes de otro GameObject, no está de más ver algún ejemplo que nos

79
00:06:47,120 --> 00:06:53,899
ayude a entender cómo funciona y de paso conocer también una forma distinta de acceder

80
00:06:53,899 --> 00:06:58,339
a los componentes. Para este ejemplo lo que voy a hacer, he creado una escena que contiene

81
00:06:58,339 --> 00:07:02,339
en una bola, le he dado un poco de material para que parezca de metal y le he añadido

82
00:07:02,339 --> 00:07:06,779
un RigidBody, es decir, le he añadido un componente que ya conoceremos cuando estudiemos

83
00:07:06,779 --> 00:07:11,439
las físicas de los objetos, pero no deja de ser un componente más, con sus propiedades.

84
00:07:11,819 --> 00:07:16,000
Entre ellas, por ejemplo, la de usar la gravedad, que por ejemplo, si lanzo el juego, veremos

85
00:07:16,000 --> 00:07:20,120
que esa bola, veremos que no se cae, queda suspendida en el aire, pero si yo activo la

86
00:07:20,120 --> 00:07:21,379
gravedad, caerá.

87
00:07:22,240 --> 00:07:29,220
La pregunta es, ¿puedo acceder yo desde un script asociado a otro GameObject a este componente?

88
00:07:29,360 --> 00:07:30,660
La respuesta es sí.

89
00:07:31,439 --> 00:07:35,319
Y no solo al componente, sino a todos los atributos de ese componente.

90
00:07:35,459 --> 00:07:38,259
Entre ellos, por ejemplo, para comprobarlo me he creado un empty object,

91
00:07:38,519 --> 00:07:41,139
al que le he llamado NeedGame, y le he asociado un script.

92
00:07:41,540 --> 00:07:45,240
Y en él voy a hacer el mismo proceso que hemos hecho anteriormente,

93
00:07:45,420 --> 00:07:47,060
pero de una forma un poco más ágil.

94
00:07:47,639 --> 00:07:48,959
Acostumbrémonos a seguir este proceso.

95
00:07:49,079 --> 00:07:51,279
Primero creo una variable de tipo GameObject.

96
00:07:51,379 --> 00:07:54,980
ni serializada ni pública, es decir, ni siquiera voy a tener que acceder a ella

97
00:07:54,980 --> 00:08:00,000
desde Unity. A la que le voy a llamar por ejemplo objeto bola para distinguirlo y

98
00:08:00,000 --> 00:08:04,220
luego voy a crear otra variable. Pues y esto es lo importante, si voy a acceder

99
00:08:04,220 --> 00:08:09,040
al componente Rigidbody de esa bola tengo que crear una variable de tipo

100
00:08:09,040 --> 00:08:13,980
Rigidbody y de nuevo como antes le voy a llamar

101
00:08:13,980 --> 00:08:20,240
Rigidbody bola para entender que va a ser el componente Rigidbody de ese

102
00:08:20,240 --> 00:08:25,620
objeto. En los anteriores ejemplos, para asignarle a esta variable de tipo GameObject el GameObject

103
00:08:25,620 --> 00:08:30,920
de la escena, nos íbamos a Unity y lo arrastrábamos. Algo que es muy práctico, muy visual, pero

104
00:08:30,920 --> 00:08:36,139
primero, no es necesario y segundo, cuando conozcamos los prefabs, descubriremos que

105
00:08:36,139 --> 00:08:40,120
los prefabs que instanciamos en la escena no están en la escena inicialmente, con lo

106
00:08:40,120 --> 00:08:44,419
cual no le puedo arrastrar un GameObject que está en la escena. Eso ahora mismo no es

107
00:08:44,419 --> 00:08:48,179
un problema que nos surja, pero nos surgirá más adelante. ¿Qué significa? Que yo tengo

108
00:08:48,179 --> 00:08:53,259
que acceder a ese GameObject desde el código. ¿Puedo? Por supuesto que sí. ¿Cómo? Lo

109
00:08:53,259 --> 00:08:59,860
vamos a comprobar. Le puedo decir que el objeto bola, esa variable de tipo GameObject, va

110
00:08:59,860 --> 00:09:04,580
a ser un GameObject de la escena. ¿Y cómo lo encuentro? Mediante este método. Llamo

111
00:09:04,580 --> 00:09:13,620
a la clase GameObject y tiene un método que es Find, al que yo le tengo que pasar el que,

112
00:09:13,620 --> 00:09:15,899
como podemos ver ahí, un nombre

113
00:09:15,899 --> 00:09:19,840
el de el objeto que tengo

114
00:09:19,840 --> 00:09:22,620
en la escena. Y esto tiene exactamente el mismo

115
00:09:22,620 --> 00:09:25,600
efecto que arrastrarlo a la casilla como hemos visto

116
00:09:25,600 --> 00:09:28,779
antes. Ahora mismo esto ya tiene el GameObject

117
00:09:28,779 --> 00:09:31,580
de la escena. Y como ya tiene el

118
00:09:31,580 --> 00:09:34,679
GameObject de la escena, pues puedo hacer lo mismo que hacía anteriormente

119
00:09:34,679 --> 00:09:37,779
que era a la variable que he creado de tipo RigidBody

120
00:09:37,779 --> 00:09:40,820
le digo que acceda

121
00:09:40,820 --> 00:09:43,500
a ese objeto y utilice el método

122
00:09:43,500 --> 00:09:51,279
GetComponent. ¿Qué tipo de componente? Pues el RigidBody, efectivamente. Es decir, que

123
00:09:51,279 --> 00:09:55,240
ahora tengo acceso a todos los atributos de ese RigidBody, por ejemplo, el de la gravedad.

124
00:09:55,360 --> 00:10:00,500
Para comprobarlo voy a hacer un ejemplo muy sencillo que básicamente es decirle que cuando

125
00:10:00,500 --> 00:10:05,320
yo apriete la barra espaciadora se active la gravedad. Vamos a comprobarlo. Esto ya

126
00:10:05,320 --> 00:10:11,299
lo hemos visto anteriormente. Mediante el método input yo puedo comprobar si se ha

127
00:10:11,299 --> 00:10:20,279
pulsado una tecla cual la barra espaciadora y si se hace efectivamente accedo a ese componente

128
00:10:20,279 --> 00:10:27,320
que ya lo tengo capturado en esa variable y entre sus atributos veremos que tiene muchos

129
00:10:27,320 --> 00:10:35,159
pues por ejemplo está el useGravity y si tengo dudas como siempre la página de referencia

130
00:10:35,159 --> 00:10:39,159
de Unity me dará todos los atributos y todos los

131
00:10:39,159 --> 00:10:42,279
métodos a los que puedo acceder en la clase RigidBody

132
00:10:42,279 --> 00:10:44,980
y por ejemplo entre ellos está el UseGravity

133
00:10:44,980 --> 00:10:51,179
que determina si se activa o no se desactiva la gravedad y donde nos dice que si lo pongo

134
00:10:51,179 --> 00:10:55,340
en False, pues eso, como si estuviese en el espacio porque no tiene gravedad. Y ahora mismo efectivamente

135
00:10:55,340 --> 00:10:58,740
está en False, pues le voy a poner en True

136
00:10:58,740 --> 00:11:01,679
es igual a True. Actívate

137
00:11:01,679 --> 00:11:05,019
resultado, si yo lanzo el juego

138
00:11:05,019 --> 00:11:08,100
la bola no se ve afectada por la gravedad

139
00:11:08,100 --> 00:11:09,779
pero si yo le doy a la barra espaciadora

140
00:11:09,779 --> 00:11:11,220
se activa

141
00:11:11,220 --> 00:11:13,919
y como eso, cualquier otro atributo

142
00:11:13,919 --> 00:11:15,899
de cualquier componente

143
00:11:15,899 --> 00:11:17,840
de cualquier GameObject que tenga en mi escena