Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Primeros pasos en Unity: comunicar GameObjects - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 25 de septiembre de 2024 por Alvaro H.

47 visualizaciones

Veremos cómo acceder a variables y métodos públicos entre scripts

Más información Transcripción

Descargar la transcripción

En este vídeo vamos a hacer un ejercicio que vamos a estar repitiendo a lo largo del curso, 00:00:07
que no es otra cosa que acceder a variables y métodos que están presentes en otras clases, 00:00:11
en otros GameObjects, pero que necesitamos para el script que estamos generando. 00:00:18
Es decir, por poner un ejemplo, imaginemos que tenemos un obstáculo que se mueve a una velocidad, 00:00:23
pero esa velocidad depende de una variable disponible, a lo mejor, en el script que tiene asociado el personaje. 00:00:28
Así que necesitamos acceder a esa variable. 00:00:34
igual que podemos necesitar acceder a los métodos que tienen esos scripts. 00:00:37
Así que vamos a aprender a eso, a comunicarnos entre scripts. 00:00:41
Para ello he creado una escena vacía. 00:00:44
Voy a generar a modo de ejemplo un cubo al cual voy a llamar personaje 00:00:46
y voy a crear, por ejemplo, una esfera a la que la voy a llamar obstáculo. 00:00:52
Bien, el dónde estén o cómo se coloquen, pues bueno, no me importa tanto 00:00:59
porque también voy a crear un elemento de User Interface, en este caso un texto, 00:01:03
para poder mostrar nuestros mensajes en pantalla. Eso me vale. 00:01:11
Bien, ¿y para qué he creado esto? Pues realmente para que nuestro personaje, por ejemplo, 00:01:14
le vamos a asociar un nuevo script. Le voy a llamar personaje script. 00:01:19
Como siempre, recuerdo organizar todo nuestro material. Es decir, voy a crear una carpeta solo para los scripts 00:01:25
donde voy a meter el que acabo de crear 00:01:32
y ahí está 00:01:35
también voy a crear una variable 00:01:36
ahora sí necesito que sea pública 00:01:38
de tipo número decimal 00:01:40
y le vamos a llamar energy 00:01:43
y esa es la energía que va a tener nuestro personaje 00:01:44
y para que veamos que todo funciona bien 00:01:48
voy a mandar a pantalla 00:01:51
es decir, al user interface 00:01:53
y le digo que el energy text 00:01:54
el texto que contenga 00:01:56
será una cadena de texto 00:01:58
Os recuerdo que si no ponemos una cadena de texto nos dará error porque es lo que está esperando. 00:02:01
Y le pongo energía, dos puntos, un espacio y concateno la variable energía. 00:02:06
Y para rizar el rizo le voy a poner incluso un símbolo de porcentaje al final. 00:02:14
Me vuelvo a Unity y antes que nada me voy a mi personaje donde voy a minimizar todos estos componentes. 00:02:19
y veo que me está pidiendo la variable EnergyText, el texto de la pantalla 00:02:26
y la variable energía que la voy a poner, por ejemplo, al 100%. 00:02:31
Y el texto es efectivamente el que aparece aquí en pantalla. 00:02:34
Lo puedo cambiar el nombre para también ser más rigurosos. 00:02:38
Lanzo la pantalla del juego y si todo va bien, aquí nos aparecerá que contamos con una energía efectivamente del 100%. 00:02:42
Y bien, no he hecho demasiado, solo he creado una variable energía que es pública, eso es lo importante, 00:02:49
y la he mostrado en pantalla. Nada más. 00:02:55
Pero ahora, ¿puedo acceder desde la esfera, es decir, desde lo que yo he llamado el obstáculo, 00:02:58
a esa variable de energía para, lo que hemos comentado antes, actuar en consecuencia? 00:03:03
Pues por supuesto que sí. Vamos a ver cómo. 00:03:07
Lo primero que voy a hacer es, efectivamente, añadir un componente también a la esfera, 00:03:10
es decir, un obstáculo. Le voy a llamar obstáculo script. 00:03:15
Ese script lo meto en la carpeta de scripts. 00:03:21
Antes de seguir, solo comentar una cosa 00:03:24
Veamos que a veces cuando yo quiero acceder a un GameObject 00:03:26
No accedo solo a las variables que tiene asociadas 00:03:29
Sino también a sus componentes, a los AudioSources, al RigidBody o a los Collider 00:03:32
Es decir, que realmente la forma idónea va a ser la que veremos más a continuación 00:03:37
Pero ahora vamos a ver una forma muy sencilla de acceder a las variables que tenemos ahí disponibles 00:03:43
¿Cómo? Pues declarando una variable pública 00:03:47
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. 00:03:50
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í. 00:04:03
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. 00:04:11
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. 00:04:22
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. 00:04:32
Así que se lo voy a arrastrar. Le voy a decir que este es el GameObject que tiene asociado ese script. 00:04:50
A partir de este momento ya están disponibles para mí las variables que tengo aquí. 00:04:57
Tengo una variable de tipo float pública llamada energy. 00:05:03
Lo voy a comprobar. 00:05:08
Le voy a decir que mande a consola. 00:05:09
Accedo a la variable que yo he creado, donde se supone que está. 00:05:14
Y le digo que me muestre la energía. 00:05:18
Y si todo va bien y lanzo el script, veremos que no solo nos lanza a pantalla la variable de la energía, 00:05:21
sino que también en consola como podemos ver nos saca el número 100 y esto y es lo importante lo 00:05:29
está diciendo el script que está asociado al obstáculo es decir acabamos de acceder a esa 00:05:36
variable no sólo podemos acceder a ella y leerla es que también podemos cambiarla y le decimos que 00:05:41
la energía de nuestro personaje en vez de 100 va a ser 50 y le voy a decir que me la vuelva 00:05:47
a mostrar. Así que si nos vamos a Unity, efectivamente me aparece como que la energía ha cambiado 00:05:56
a 50%. Primero era 100%, la he cambiado y efectivamente ahora es 50%. Conclusión, hemos 00:06:03
declarado una variable pública, eso es importante, en el script de nuestro personaje. Desde el 00:06:14
script de nuestro obstáculo hemos accedido a ese otro GameObject y hemos accedido a sus 00:06:19
variables y lo hemos podido modificar, con lo cual ya hemos comunicado los scripts. 00:06:25
Bueno, y como realmente nos vamos a hartar de usar este método de GetComponent para 00:06:37
acceder a los componentes de otro GameObject, no está de más ver algún ejemplo que nos 00:06:42
ayude a entender cómo funciona y de paso conocer también una forma distinta de acceder 00:06:47
a los componentes. Para este ejemplo lo que voy a hacer, he creado una escena que contiene 00:06:53
en una bola, le he dado un poco de material para que parezca de metal y le he añadido 00:06:58
un RigidBody, es decir, le he añadido un componente que ya conoceremos cuando estudiemos 00:07:02
las físicas de los objetos, pero no deja de ser un componente más, con sus propiedades. 00:07:06
Entre ellas, por ejemplo, la de usar la gravedad, que por ejemplo, si lanzo el juego, veremos 00:07:11
que esa bola, veremos que no se cae, queda suspendida en el aire, pero si yo activo la 00:07:16
gravedad, caerá. 00:07:20
La pregunta es, ¿puedo acceder yo desde un script asociado a otro GameObject a este componente? 00:07:22
La respuesta es sí. 00:07:29
Y no solo al componente, sino a todos los atributos de ese componente. 00:07:31
Entre ellos, por ejemplo, para comprobarlo me he creado un empty object, 00:07:35
al que le he llamado NeedGame, y le he asociado un script. 00:07:38
Y en él voy a hacer el mismo proceso que hemos hecho anteriormente, 00:07:41
pero de una forma un poco más ágil. 00:07:45
Acostumbrémonos a seguir este proceso. 00:07:47
Primero creo una variable de tipo GameObject. 00:07:49
ni serializada ni pública, es decir, ni siquiera voy a tener que acceder a ella 00:07:51
desde Unity. A la que le voy a llamar por ejemplo objeto bola para distinguirlo y 00:07:54
luego voy a crear otra variable. Pues y esto es lo importante, si voy a acceder 00:08:00
al componente Rigidbody de esa bola tengo que crear una variable de tipo 00:08:04
Rigidbody y de nuevo como antes le voy a llamar 00:08:09
Rigidbody bola para entender que va a ser el componente Rigidbody de ese 00:08:13
objeto. En los anteriores ejemplos, para asignarle a esta variable de tipo GameObject el GameObject 00:08:20
de la escena, nos íbamos a Unity y lo arrastrábamos. Algo que es muy práctico, muy visual, pero 00:08:25
primero, no es necesario y segundo, cuando conozcamos los prefabs, descubriremos que 00:08:30
los prefabs que instanciamos en la escena no están en la escena inicialmente, con lo 00:08:36
cual no le puedo arrastrar un GameObject que está en la escena. Eso ahora mismo no es 00:08:40
un problema que nos surja, pero nos surgirá más adelante. ¿Qué significa? Que yo tengo 00:08:44
que acceder a ese GameObject desde el código. ¿Puedo? Por supuesto que sí. ¿Cómo? Lo 00:08:48
vamos a comprobar. Le puedo decir que el objeto bola, esa variable de tipo GameObject, va 00:08:53
a ser un GameObject de la escena. ¿Y cómo lo encuentro? Mediante este método. Llamo 00:08:59
a la clase GameObject y tiene un método que es Find, al que yo le tengo que pasar el que, 00:09:04
como podemos ver ahí, un nombre 00:09:13
el de el objeto que tengo 00:09:15
en la escena. Y esto tiene exactamente el mismo 00:09:19
efecto que arrastrarlo a la casilla como hemos visto 00:09:22
antes. Ahora mismo esto ya tiene el GameObject 00:09:25
de la escena. Y como ya tiene el 00:09:28
GameObject de la escena, pues puedo hacer lo mismo que hacía anteriormente 00:09:31
que era a la variable que he creado de tipo RigidBody 00:09:34
le digo que acceda 00:09:37
a ese objeto y utilice el método 00:09:40
GetComponent. ¿Qué tipo de componente? Pues el RigidBody, efectivamente. Es decir, que 00:09:43
ahora tengo acceso a todos los atributos de ese RigidBody, por ejemplo, el de la gravedad. 00:09:51
Para comprobarlo voy a hacer un ejemplo muy sencillo que básicamente es decirle que cuando 00:09:55
yo apriete la barra espaciadora se active la gravedad. Vamos a comprobarlo. Esto ya 00:10:00
lo hemos visto anteriormente. Mediante el método input yo puedo comprobar si se ha 00:10:05
pulsado una tecla cual la barra espaciadora y si se hace efectivamente accedo a ese componente 00:10:11
que ya lo tengo capturado en esa variable y entre sus atributos veremos que tiene muchos 00:10:20
pues por ejemplo está el useGravity y si tengo dudas como siempre la página de referencia 00:10:27
de Unity me dará todos los atributos y todos los 00:10:35
métodos a los que puedo acceder en la clase RigidBody 00:10:39
y por ejemplo entre ellos está el UseGravity 00:10:42
que determina si se activa o no se desactiva la gravedad y donde nos dice que si lo pongo 00:10:44
en False, pues eso, como si estuviese en el espacio porque no tiene gravedad. Y ahora mismo efectivamente 00:10:51
está en False, pues le voy a poner en True 00:10:55
es igual a True. Actívate 00:10:58
resultado, si yo lanzo el juego 00:11:01
la bola no se ve afectada por la gravedad 00:11:05
pero si yo le doy a la barra espaciadora 00:11:08
se activa 00:11:09
y como eso, cualquier otro atributo 00:11:11
de cualquier componente 00:11:13
de cualquier GameObject que tenga en mi escena 00:11:15
Idioma/s:
es
Autor/es:
Álvaro Holguera
Subido por:
Alvaro H.
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
47
Fecha:
25 de septiembre de 2024 - 1:18
Visibilidad:
Público
Centro:
CFP JOSÉ LUIS GARCI
Duración:
11′ 18″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
193.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid