Saltar navegación

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

Primeros pasos en Unity: instanciar prefabs - 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.

110 visualizaciones

Continuamos aprendiendo a usar los prefabs en Unity, en esta ocasión creando instancias mediante código.

Más información Transcripción

Descargar la transcripción

Bien, hemos visto como un elemento prefab lo hemos cargado en la escena de forma manual, pero eso no es lo ideal o por lo menos no es lo más práctico, porque imaginémonos que voy a tener un NPC con toda su complejidad, sus hijos, su jerarquía, sus scripts asociados y voy a crear 100 NPCs en la escena y además les voy a decir que vayan saliendo de forma aleatoria. 00:00:06
lógicamente eso no lo puedo hacer manualmente 00:00:28
así que tengo que recurrir a código 00:00:30
vamos entonces a aprender 00:00:33
a cómo instanciar 00:00:35
prefabs directamente desde código 00:00:36
y es bastante fácil porque hay una función en Unity 00:00:38
que hace exactamente eso 00:00:40
pero no quiero asociar este script a un GameObject 00:00:42
en concreto porque lo que quiero hacer es crear 00:00:45
prefabs, no quiero 00:00:47
afectar a un GameObject en concreto por eso 00:00:48
y aquí es donde nos viene bien y lo usaremos muy a menudo 00:00:50
como ya he comentado alguna vez, los EntityObjects 00:00:52
los CreateEntity, te voy a llamar 00:00:54
prefab generator, bueno, lo podéis llamar 00:00:56
como queráis, pero esto se me sirve a mí para indicar 00:00:59
que esto no es más que un objeto vacío que sirve 00:01:00
para generar prefabs. Luego le asocio 00:01:03
un script, le he llamado igual que al GameObject 00:01:05
pero vamos, no tiene por qué llamarse igual 00:01:10
y voy a asociar ese script 00:01:11
como un componente de ese objeto vacío 00:01:13
vale, voy a 00:01:16
eliminar la función de update porque no voy 00:01:18
a generar prefabs en cada fotograma 00:01:20
eso sería una locura, para eso veremos las corrutinas en otro vídeo 00:01:21
pero sí que lo voy a hacer al principio, es decir 00:01:24
que cargue cuando empiece el script 00:01:25
entonces, ¿cómo se crea un prefab? pues bien 00:01:27
un proceso bastante sencillo, primero le tenemos que decir 00:01:29
cuál es nuestro prefab, es decir, cuál es el GameObject que contiene 00:01:31
el prefab, y para eso pues 00:01:33
crearemos una variable, en este caso 00:01:35
de tipo serializada, porque quiero acceder a ella desde Unity 00:01:37
de tipo GameObject, por supuesto, y le damos 00:01:39
un nombre, me da igual como MyPrefab 00:01:41
indicando que este es el prefab que vamos a 00:01:43
instanciar, lógicamente al ser serializada 00:01:45
si fuese pública también 00:01:47
ocurriría lo mismo, pues 00:01:49
efectivamente veremos, voy a 00:01:51
acceder, ahí está 00:01:53
me está pidiendo que cabre aquí un GameObject 00:01:54
que ya hemos visto varias veces, que realmente podemos buscarlo 00:01:57
o arrastrarlo, y en este caso lo voy a arrastrar 00:01:59
desde la ventana de proyecto, indicando 00:02:01
que este es el GameObject 00:02:03
que necesito 00:02:05
instanciar, y una vez que ya está vinculado 00:02:06
a esta variable, pues ya podemos usar 00:02:09
el método que viene por defecto en Unity 00:02:11
que es 00:02:13
instanciar, bueno, no lo voy a pronunciar porque 00:02:13
no quiero hacer el ridículo, pero es instanciar 00:02:16
en inglés, ahí lo tenemos 00:02:19
y bien, nos pide 00:02:20
el objeto que queremos instanciar 00:02:21
pues ahí lo tenemos, el que acabamos de crear 00:02:24
si le doy a play 00:02:26
si todo va bien 00:02:28
de repente aparecerá mi prefab aquí en el centro 00:02:29
ahí lo tenéis y para ahí de aquí se va 00:02:32
de hecho lo voy a repetir 00:02:34
fijémonos en la ventana de jerarquía como de repente 00:02:36
aparece el solo una instancia 00:02:38
ahí 00:02:40
eso ya está bien, pero lógicamente lo ideal es 00:02:41
decirle dónde quiero que lo instancie 00:02:44
para eso el método de hacerlo 00:02:46
es un poco dando una vuelta 00:02:48
pero el prefab necesita un objeto de referencia 00:02:50
es decir, decirle dónde tiene que instanciarse 00:02:52
y para eso necesita algún objeto 00:02:55
en la escena. Yo ya lo tengo. 00:02:56
Tengo este empty object, que realmente 00:02:58
no hace nada. Pues le puedo decir que una instancia aquí. 00:03:00
Para eso necesito su posición. 00:03:02
Y la posición en 00:03:04
Unity lo marca el componente 00:03:06
transformPosition. 00:03:08
Pues vamos a ello. 00:03:10
Voy a crear en el empty object, en el script 00:03:12
que genera el prefab. 00:03:14
De nuevo, también una variable 00:03:16
serializada para poder acceder a ella. 00:03:18
Y esta vez no es de tipo gameObject, sino de tipo transform. 00:03:20
Es decir, no necesito 00:03:22
un objeto completo, sino solo sus parámetros. 00:03:24
transform. Y le voy a llamar, por ejemplo, initPos, de posición inicial. Y ahora, aquí, 00:03:26
donde le he dicho que instancia el prefab, le digo coma y automáticamente me pide una 00:03:37
variable de tipo transform, que la tengo aquí, aunque todavía no la he asociado a ningún 00:03:42
objeto. Lo voy a hacer ahora, es decir, veis que aquí, donde ya había asociado el cubo, 00:03:47
ahora aparece una nueva variable que es posición inicial, una variable de tipo transform, y 00:03:53
le voy a decir qué parámetros de transform, pues el que tiene este objeto, y lo arrastro. 00:03:56
Es decir, que ahora mismo esa variable tiene las coordenadas bien y eso significa que ahora mismo si lanzo el juego veremos que la instancia aparecerá justo donde está ese objeto. 00:04:00
Ahí está. Y ya sale disparado. 00:04:10
Comprobación. Voy a mover mi objeto de referencia. Lo voy a poner aquí. 00:04:13
Pues ahora mismo si lo lanzo veremos que efectivamente se instancia ahí. 00:04:17
Pero vamos a hacer un pequeño truco de magia. 00:04:23
Yo he instanciado un objeto, pero ¿y si quiero instanciar, por ejemplo, 10 objetos cada uno en su posición? 00:04:26
Bien, ahora mismo le hemos dado dos parámetros al método de instanciar, que es qué objeto, qué prefab quiero instanciar y el segundo parámetro que era de tipo transform, indicándole todos los parámetros que tiene transform, es decir, el objeto de referencia, su posición y su rotación principalmente. 00:04:30
principalmente. Pero el método de instanciar permite otra modalidad, que es con tres parámetros. 00:04:48
El primero, el prefab que quiero instanciar. El segundo, ya no es un objeto de tipo transform, 00:04:56
sino un vector 3, es decir, una posición concreta en el espacio. Y tercero, una rotación 00:05:03
concreta en el espacio, en esta casa medido con cuaterniones, que los veremos más adelante, 00:05:11
pero que ahora nos tenemos que enfrentar a ellos. 00:05:15
Vamos a ver cómo podemos, por ejemplo, crear un objeto en la posición donde está el objeto de referencia, 00:05:18
un poquito más a la derecha, otro poquito más a la derecha, otro poquito más a la derecha, 00:05:25
así 10 prefabs seguidos que lógicamente se moverán a la par. 00:05:28
Vamos a hacerlo. En este caso, me voy un momentito al código, 00:05:31
y algo que tenemos que entender es que esto que le he pasado aquí como segundo parámetro 00:05:34
es una variable de tipo transform, es decir, que tiene tanto la posición como en rotación, escala, 00:05:37
es decir, que tiene todos esos parámetros. 00:05:42
Pero si yo le digo un atributo que es el de posición, esto ahora mismo es un vector 3. 00:05:45
Así que me está pidiendo ahora otro parámetro, porque le he dicho dónde está la posición, 00:05:50
pero le tengo que decir también cómo está la rotación. 00:05:53
Eso, insisto, es un cuaternión. 00:05:55
De momento, quedémonos en que la clase cuaternión admite un método muy práctico, 00:05:57
que es el de identity, que significa sin rotación. 00:06:04
Es decir, como si le pasásemos un objeto de tipo cuaternión, pero vacío, sin ningún tipo de rotación. 00:06:08
Si yo ahora mismo lanzo, veremos que la instancia aparecerá efectivamente en el objeto referencial. 00:06:14
Pues vale, y ahora quiero que prestemos atención que esto es un vector3. 00:06:19
Entonces, vamos a jugar con ello. 00:06:24
Voy a crear una variable, en este caso no me importa que sea privada, de tipo vector3. 00:06:26
Le voy a llamar newPosition, es decir, donde se va a desplazar en cada vuelta. 00:06:30
Y ya está. 00:06:35
Y ahora, vamos a aplicar algo de lo aprendido anteriormente en programación, 00:06:37
que es, por ejemplo, un bucle, mientras n sea 0, n sea menor que 10, súmale 1 a n, 00:06:41
si yo ahora mismo pegase esta línea tal cual está a ese bucle, 00:06:54
crearía 10 instancias, pero en el mismo sitio. 00:07:00
Vamos a comprobarlo y además lo vamos a mirar aquí fijándonos en la jerarquía, 00:07:03
porque de repente aparecerán 10, ahí están, mis 10 instancias, todas allí corriendo. 00:07:07
Lógicamente eso no es lo que yo quiero. 00:07:10
Lo que yo quiero es que en cada vuelta de mi bucle se cree una nueva posición. 00:07:11
El newPosition, por ejemplo, es igual a la posición inicial. 00:07:17
Por ejemplo, mi objeto en cada vuelta necesito sumarle una cantidad que vaya subiendo. 00:07:25
Pero es que ya la tengo aquí. 00:07:30
Porque aquí n vale 0, en la siguiente vuelta valdrá 1, en la siguiente vuelta valdrá... 00:07:31
Entonces, lo único que tengo que hacer es crear un vector3, una nueva instancia. 00:07:35
le voy a llamar cambio de posición 00:07:40
y esto es un nuevo vector 3 00:07:42
cuyo valor es 00:07:45
n, 0 y 0 00:07:48
que acabo de crear 00:07:50
un vector 3 en el que en la primera vuelta 00:07:51
valdrá 1, 0, 0 00:07:54
en la segunda vuelta valdrá 1, 0, 0 00:07:55
en la tercera 2, 0, 0 00:07:57
que significa que si yo a la posición inicial 00:07:58
le sumo ese vector 3 00:08:01
que acabo de crear en cada vuelta 00:08:04
pues en cada ciclo 00:08:05
se moverá 1 en x 00:08:08
la zona donde se instancia 00:08:09
mi prefab, y lógicamente cuando le hemos dicho 00:08:11
donde se tiene que instanciar 00:08:14
pues ya no es la posición del 00:08:15
objeto de referencia, sino 00:08:17
la nueva posición 00:08:19
vamos allá 00:08:21
si todo va bien, se instanciarán 00:08:24
10 prefabs 00:08:26
cada uno desplazado, uno en x 00:08:27
vamos a comprobarlo, ahí están 00:08:29
mira, parece un tren 00:08:31
en este caso he usado el valor 00:08:32
de n porque lo tenía aquí, pero de nuevo 00:08:36
Pero hemos aprendido cómo son los bucles, es decir, que si n no me gusta, pues yo puedo crear mi propia variable. 00:08:37
Es decir, que decirle que la variable y es igual a 0 y en cada vuelta de ciclo le digo que y es y más 2. 00:08:43
Os recuerdo que esto es un atajo de decirle que sume 2 a y. 00:08:53
Así que aquí en vez de decirle n, pues le puedo decir y y ahora mismo se instanciarán con 2 de diferencia en el eje x. 00:08:57
Vamos a ver. Ahí están. 00:09:04
y todos dos desplazándose a la misma velocidad. 00:09:07
Espero que entendamos toda la potencialidad que tiene esto, 00:09:11
porque imaginemos que, por ejemplo, tenemos un juego de plataformas 00:09:14
en las que lo que tengo que hacer es que cada cierto tiempo aparezca una plataforma nueva, 00:09:18
o un juego en el que tenemos que evitar obstáculos, 00:09:22
en los que les puedo decir que cada cierto tiempo aparezca un nuevo obstáculo, 00:09:25
pero necesito ponerlo en una situación, a lo mejor, aleatoria. 00:09:28
Me interesa que quede muy claro cómo es un prefab, sus potencialidades y cómo se instancia. 00:09:33
Y ya veremos qué de cosas podemos hacer con ello. 00:09:38
Idioma/s:
es
Autor/es:
Álvaro Holguera
Subido por:
Alvaro H.
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
110
Fecha:
25 de septiembre de 2024 - 0:30
Visibilidad:
Público
Centro:
CFP JOSÉ LUIS GARCI
Duración:
09′ 42″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
246.45 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid