#4 Colocar Prefab en una posición aleatoria

ACTUALIZACIÓN IMPORTANTE

PUBLICARÉ LOS ARCHIVOS DE ESTE PROYECTO CUANDO EL CANAL LLEGUE A 1000 SUSCRIPTORES

DEJO UNA COMPILACIÓN ACTUALIZADA PARA QUE PUEDAS PROBAR, PUEDE QUE TARDE UN POQUITO EN CARGAR
🔻

MOVIMIENTO: WASD CÁMARA: MOUSE

A PARTIR DE AQUÍ CONTINÚA EL ARTÍCULO ORIGINAL

Introducción

En este artícu­lo creamos el primer Script de pro­gra­mación que se va a encar­gar de colo­car al jugador en una posi­ción aleato­ria del esce­nario. El pre­fab­ri­ca­do que vamos a colo­car es el con­tro­lador de primera per­sona FPSCon­troller de Stan­dard Assets.

En el esce­nario habrá varias puer­tas de entra­da y sal­i­da, de modo que ele­gire­mos una de ellas de man­era aleato­ria y luego colo­care­mos al per­son­aje frente a la puer­ta elegida.

Página principal del proyecto

🟢 En el sigu­iente video puedes ver cómo se resuelve este prob­le­ma. Cómo colo­car Pre­fab en una posi­ción aleato­ria
 

En el sigu­iente video puedes ver cómo se resuelve este problema.

Tam­bién te dejo este video en el que hablo sobre Gen­eración de Datos Aleato­rios en Uni­ty, está divi­di­do en dos partes, en la primera vemos cómo gener­ar val­ores enteros y reales den­tro de uno o más inter­va­l­os y en la segun­da parte vemos cómo gener­ar otras estruc­turas de datos como Vector2, Vector3, Quater­nion y Color. 

🟢 GENERAR DATOS ALEATORIOS PARTE 1
 

🟢 GENERAR DATOS ALEATORIOS PARTE 2
 

Punto de aparición del personaje

Comen­zamos arman­do con los pre­fab­ri­ca­dos una esce­na como la que se obser­va en la figu­ra 1.

escena de unity 3d en la que se observa un suelo de cesped con margaritas y cuatro portales.
Fig. 1: Dis­posi­ción ini­cial de obje­tos en la escena.

Creamos un emp­ty GameOb­ject que vamos a usar para mar­car la posi­ción donde el jugador apare­cerá al comen­zar el juego.

crear empty game object en unity 3d. modelo 3d de un portal
Fig. 2: Se crea un nue­vo Emp­ty GameOb­ject para asig­nar el Script.

A este obje­to lo vamos a lla­mar "Spawn­Point".

unity 3d se observa un atardecer y un suelo de cesped con margaritas
Fig. 3: El nue­vo GameOb­ject ten­drá el nom­bre "Spawn­Point".

En el inspec­tor podemos ele­gir un ícono para poder visu­alizar mejor el GameOb­ject en la escena.

selección de ícono para gameobject en unity 3d
Fig. 4: Podemos asig­nar un ícono al GameOb­ject para visu­alizar­lo mejor en la escena.

empty gameobject en unity 3d con ícono asignado.
Fig. 5: El GameOb­ject aho­ra se mues­tra con la eti­que­ta seleccionada.

Vamos a crear un nue­vo Tag para asig­narle a este GameOb­ject. En la parte supe­ri­or del inspec­tor ten­emos un menú desple­gable lla­ma­do Tag, al hac­er clic nos per­mite ele­gir un Tag para asig­nar o crear uno nue­vo con "Add Tag". Hace­mos clic en esta opción.

menu para añadir tag en en unity 3d.
Fig. 6: Menú para asig­nar un Tag exis­tente o crear uno nuevo.

En la ven­tana que aparece hace­mos clic en el sig­no más y escribi­mos el nom­bre del Tag. Es impor­tante ten­er en cuen­ta el uso de mayúsculas.

crear nuevo tag en unity 3d.
Fig. 7: Creamos un nue­vo Tag lla­ma­do SpawnPoint.

Volve­mos a selec­cionar el GameOb­ject "Spawn­Point" de la jer­ar­quía y en el menú Tag selec­cionamos el Tag "Spawn­Point" que acabamos de crear.

seleccionar tag en unity 3d.
Fig. 8: Asig­namos el Tag crea­do al GameOb­ject "Spawn­Point".

Creación del primer Script

Final­mente vamos a empezar a pro­gra­mar en C#. Para empezar nece­si­ta­mos crear un Script C#, para esto hace­mos clic dere­cho en algu­na car­pe­ta del proyec­to (sug­iero la car­pe­ta Script que creamos para orga­ni­zarnos), luego vamos a Cre­ate > C# Script, como se obser­va en la figu­ra 9.

crear script c# en unity 3d.
Fig. 9: Menú de creación, selec­cionamos C# Script.

Vamos a nom­brar el archi­vo como "Game­Con­trol" debido a que se encar­gará de con­tro­lar los aspec­tos fun­da­men­tales de nue­stro juego. El archi­vo que se crea se puede obser­var en la figu­ra 10.

Para saber un poco más sobre Scripts haz clic aquí

script c# en unity
Fig. 10: El nue­vo Script lo lla­mamos Game­Con­trol sin espacios.

En pro­gra­mación se suele uti­liza una for­ma de escribir como la que se ve en la figu­ra 10, se la conoce como Camel Case y con­siste en elim­i­nar los espa­cios y dis­tin­guir las pal­abras uti­lizan­do mayúsculas.

Usamos esta notación para nom­bres de Scripts, vari­ables y métodos.

Antes de comen­zar a pro­gra­mar, vamos a selec­cionar un edi­tor de Scripts, hace­mos clic en Edit > Preferences.

ventana de preferencias de unity 3d
Fig. 11: Ven­tana de pref­er­en­cias de Uni­ty, selec­cionamos el edi­tor MonoDevelop.

Para la serie Mi Primer Juego en Uni­ty usamos el edi­tor de scripts Mon­oDe­vel­op, este edi­tor fue descon­tin­u­a­do, es por eso que en la Serie Fun­da­men­tal de Uni­ty se usa Visu­al Studio.

selección de editor de scripts en unity 3d.
Fig. 12: Se puede ele­gir el edi­tor que más nos guste, actual­mente el edi­tor por defec­to es Visu­al Studio.

Al abrir el Script para edi­tar nos encon­tramos con un poco de códi­go ya escrito.

En la figu­ra 10 las primeras 3 líneas que comien­zan con la pal­abra "using" sir­ven para impor­tar libr­erías que nos per­mi­tirán acced­er a deter­mi­na­da funcionalidad.

Luego viene la defini­ción de una clase que lle­va el nom­bre que le dimos al Script, en este caso Game­Con­trol. Además se indi­ca la super clase, es decir la clase de la cuál here­da su com­por­tamien­to, en este caso MonoBe­hav­iour. Osea que todos los atrib­u­tos y méto­dos de la clase MonoBe­hav­iour estarán disponibles para que utilicemos.

El pár­rafo ante­ri­or tiene var­ios con­cep­tos de pro­gra­mación ori­en­ta­da a obje­tos que no tiene sen­ti­do pro­fun­dizar en este artícu­lo, debido a que es un tema bas­tante exten­so. Sin embar­go con­sidero que la men­ción de pal­abras como "clase", "atrib­u­tos" o "super clase" puede des­per­tar curiosi­dad y ani­mar al lec­tor a inves­ti­gar más sobre el tema. En este momen­to no cuen­to con artícu­los sobre pro­gra­mación ori­en­ta­da a obje­tos, aunque es mi deseo escribir­los pronto.

Luego hay dos méto­dos definidos, el méto­do Start y el méto­do Update. El méto­do Start se eje­cu­tará automáti­ca­mente una úni­ca vez al ini­ciar el juego y el méto­do Update se eje­cu­tará automáti­ca­mente una vez en cada Frame del juego.

Clic aquí para saber más sobre métodos

script c# genérico en unity 3d.
Fig. 13: Vista de un Script recién creado.

En la región que se encuen­tra entre la defini­ción de la clase y la defini­ción dle méto­do Start vamos a colo­car todos los atrib­u­tos de la clase, es decir todos las vari­ables y obje­tos que uti­lizare­mos para que el Script cumpla su fun­cional­i­dad. Hace un tiem­po escribí un artícu­lo sobre los tipos bási­cos de vari­ables que vamos a uti­lizar en los tutoriales.

Clic para leer el artículo sobre variables

Vamos a escribir dos líneas de códi­go, la primera es "Seri­al­ize­Field" entre corchetes, esto sirve para indi­car­le a Uni­ty que lo que viene a con­tin­uación es un cam­po que se debe seri­alizar. Sin entrar en detalles esta línea hará que los cam­pos (vari­ables u obje­tos) pri­va­dos aparez­can en el inspector.

La sigu­iente instruc­ción es "pri­vate string tag", con esto esta­mos declaran­do una vari­able de tipo string de nom­bre "tag" con vis­i­bil­i­dad privada.

Vis­i­bil­i­dad tam­bién es un tema de pro­gra­mación ori­en­ta­da a obje­tos, se uti­liza para ocul­tar atrib­u­tos o méto­dos y que estos no sean acce­si­bles des­de un con­tex­to exter­no a la clase. Los atrib­u­tos o méto­dos con vis­i­bil­i­dad públi­ca son acce­si­bles des­de otras clases. 

script c# genérico en unity 3d. definir variables
Fig. 14: Se define una vari­able de tipo String lla­ma­da "tag".

Asignar Script a un GameObject

Para que el códi­go se eje­cute no bas­ta con crear un Script, debe­mos asig­narlo al menos a un GameOb­ject de la jerarquía.

Game­Con­trol se va a encar­gar de con­tro­lar los aspec­tos bási­cos del juego. En prin­ci­pio podría estar asig­na­do a cualquier GameOb­ject que esté pre­sente durante todo el juego, pero para una mejor orga­ni­zación vamos a crear un Emp­ty GameOb­ject que lla­mare­mos "Con­trol".

crear empty game object en unity 3d
Fig. 15: Creamos un nue­vo emp­ty GameObject.

Con el nue­vo GameOb­ject selec­ciona­do, arras­tramos el Script Game­Con­trol al inspec­tor para agre­gar­lo como componente.

renombrar game object en la jerarquía de unity 3d
Fig. 16: El nue­vo GameOb­ject se lla­mará Control.
asignar script c# en el inspector en unity 3d
Fig. 17: Podemos arras­trar el Script Game­Con­trol a la jer­ar­quía del obje­to Con­trol para asignárselo.

En la figu­ra 18 se obser­va que el Script ha sigo agre­ga­do como com­po­nente al Emp­ty GameOb­ject Control.

inspector en unity 3d
Fig. 18: El Script aho­ra es una com­po­nente del obje­to Control.

Otra for­ma de lograr esto es uti­lizan­do el botón Add Com­po­nent y bus­can­do el Script GameControl. 

add component en unity 3d
Fig. 19: Otra for­ma de asig­nar el Script es a través del botón Add Component.

La razón por la que en la figu­ra 18 no vemos el String "tag" que defin­i­mos es porque no guardamos los cam­bios en el Script. En la figu­ra 20 se ve que en la pes­taña del Script aparece un cír­cu­lo en lugar de una cruz, esto sig­nifi­ca que hay cam­bios sin guardar, se puede guardar fácil­mente pre­sio­n­an­do CTRL‑S.

Es recomend­able guardar con bas­tante fre­cuen­cia para que ante even­tuales fal­los no per­damos nue­stro trabajo.

definicion de variables que se encargarán de colocar el prefab aletoriamente unity 3d.
Fig. 20: El cír­cu­lo en la pes­taña indi­ca que hay cam­bios sin guardar.

Luego de guardar los cam­bios vemos en el inspec­tor el string "Tag". En este cam­po vamos a escribir "Spawn­Point" que es el nom­bre que le dimos al tag que asig­namos al GameOb­ject Spawn­Point (fig­uras 5 a 8).

Fig. 21: El string Tag seri­al­iza­do aparece en el inspector.
Fig. 22: Podemos escribir un val­or para el String.

Colocar prefab del personaje aleatoriamente

El per­son­aje en defin­i­ti­va va a ser un GameOb­ject, en par­tic­u­lar el Pre­fab FPSCon­troller de Stan­dard Assets. Ten­emos que indi­car­le a Uni­ty de algun modo cuál es el pre­fab que quer­e­mos pon­er en el escenario.

Para esto vamos a definir un GameOb­ject pri­va­do que lla­mare­mos "play­er­Pre­fab" y lo indi­care­mos como seri­al­iz­able para que aparez­ca en el inspector. 

En la figu­ra 23 se obser­van las dos instruc­ciones que per­miten hac­er esto.

definicion de variables que se encargarán de colocar el prefab aletoriamente unity 3d.
Fig. 23: Defin­i­mos un GameOb­ject para guardar el Pre­fab del per­son­aje a instanciar.

En videos ante­ri­ores habíamos crea­do un Pre­fab del FPSCon­troller y lo habíamos colo­ca­do en Assets > Pre­fabs > Per­son­aje. Este es el Pre­fab que vamos a colo­car en el escenario.

prefab a colocar aleatoriamente en unity 3d
Fig. 25: El pre­fab FPSCon­troller de Stan­dard Assets será nue­stro personaje.

Tomamos el Pre­fab FPSCon­troller y lo arras­tramos al nue­vo cam­po en el inspec­tor, como se obser­va en la figu­ra 24.

Fig. 24: Asig­namos el pre­fab en el nue­vo espa­cio en el inspector.

Es muy impor­tante que con­serve­mos la ref­er­en­cia del GameOb­ject del jugador, por ejem­p­lo para destru­ir­lo cuan­do la par­ti­da se ter­mine. Esto lo vamos a hac­er definien­do un nue­vo GameOb­ject pri­va­do que lla­mare­mos "play­er".

En este caso no mar­care­mos este cam­po como seri­al­iz­able, debido a que es para uso inter­no del Script GameControl.

definicion de variables que se encargarán de colocar el prefab aletoriamente unity 3d.
Fig. 26: Defin­i­mos un GameOb­ject pri­va­do para guardar la ref­er­en­cia del per­son­aje que colo­camos en la escena.

Luego ten­emos que saber dónde es que vamos a colo­car al per­son­aje en el esce­nario. Para esto creamos el Emp­ty GameOb­ject que lla­mamos Spawn­Point (fig­uras 2 a 5). vamos a hac­er que sea hijo de una puer­ta y creare­mos un Pre­fab de la puer­ta con el obje­to SpawnPoint.

De modo que cada puer­ta ten­drá su pro­pio Spawn­Point. Si ten­emos sólo una puer­ta en el esce­nario, el per­son­aje apare­cerá en ese lugar, pero si ten­emos cua­tro puer­tas (como será en nue­stro caso) el per­son­aje podrá apare­cer en cualquiera de ellas aleatoriamente.

Para empezar nece­si­ta­mos la ref­er­en­cia de los GameOb­ject Spawn­Point, ¿pero de cuán­tos?. Como no quer­e­mos lim­i­tar la fun­cional­i­dad de este Script a una can­ti­dad fija de puer­tas, sim­ple­mente hare­mos que detecte automáti­ca­mente cuán­tos pun­tos de apari­ción hay y eli­ja uno de ellos aleato­ri­a­mente con la mis­ma probabilidad. 

Vamos a definir un vec­tor o array de GameOb­jects, es decir una estruc­tura de datos que con­tiene var­ios GameOb­jects orde­na­dos, los cuales podremos acced­er con un val­or entero que indi­cará su posi­ción en el array.

Para definir este array usamos la pal­abra GameOb­ject segui­da de corchetes, como se ilus­tra en la figu­ra 27. Como este array con­tendrá todos los pun­tos de apari­ción del esce­nario lo voy a lla­mar "spawn­Points" y además lo definiré como pri­va­do y un cam­po Serializable.

definicion de variables que se encargarán de colocar el prefab aletoriamente unity 3d.
Fig. 27: Se define un Array de GameOb­jects para guardar la ref­er­en­cia de todos los pun­tos de apari­ción en la escena.

En el inspec­tor se obser­va cómo es esta estruc­tura de datos. Aparece como un menú desple­gable que tiene un val­or entero lla­ma­do "Size", el cual indi­cará el tamaño del array.

Como se obser­va en la figu­ra 29, si escribi­mos un número en esta vari­able, vemos que aparece esa can­ti­dad de cam­pos de GameObjects.

En este pun­to podríamos hac­er que la vari­able Size sea igual a 4 y asig­nar man­ual­mente todos los pun­tos de apari­ción, pero no quer­e­mos estar lim­i­ta­dos a eso, quer­e­mos lograr que cuan­do agregue­mos o quite­mos una puer­ta, la selec­ción del pun­to de apari­ción se haga automáticamente.

Fig. 28: Visu­al­ización del Array en el inspec­tor, podemos indicar el tamaño del Array.

Fig. 29: Al definir el tamaño del Array nos apare­cen los cam­pos para rel­lenar. Podríamos colo­car man­ual­mente los pun­tos de aparición.

Vamos a definir un nue­vo GameOb­ject que ten­drá la ref­er­en­cia del pun­to de apari­ción elegi­do, lo lla­mare­mos "select­edSpawn­Point" y lo hare­mos pri­va­do y seri­al­iz­able para poder obser­var­lo en el inspector.

definicion de variables que se encargarán de colocar el prefab aletoriamente unity 3d.
Fig. 30: Defin­i­mos un GameOb­ject para guardar la ref­er­en­cia del pun­to de apari­ción selec­ciona­do al azar.

Programación del comportamiento

Has­ta el momen­to estu­vi­mos definien­do los obje­tos que nece­sitare­mos, aho­ra comen­zare­mos a escribir instruc­ciones que son las que harán que las cosas ocur­ran en nue­stro juego.

En este momen­to no cuen­to con artícu­los sobre pro­gra­mación bási­ca de C#, eso que­da para más adelante.

La primera instruc­ción la colo­care­mos en el méto­do Start y se encar­gará de encon­trar todos los pun­tos de apari­ción que haya en el esce­nario y guardar­los en el array "spawn­Points".

En la figu­ra 31 se obser­va que el edi­tor nos ayu­da sugir­ién­donos códi­go a medi­da que vamos escri­bi­en­do. Si esto no ocurre podría ser por dos motivos, la opción "code-auto­com­plete" está desac­ti­va­da en la configuración. 

El otro moti­vo puede ser un fal­lo en el edi­tor, o que Uni­ty no está conec­ta­do con el edi­tor. Si esto últi­mo pasa hay tratar de solu­cionarlo porque no solo no ten­dremos la sug­eren­cia de códi­go sino que no ten­dremos análi­sis de sintaxis.

instrucciónes c# que se encarga de colocar el prefab aletoriamente unity 3d. findgameobjectwithtag
Fig. 31: A medi­da que escribi­mos códi­go el edi­tor nos va sugirien­do vari­ables o méto­dos que empiecen con lo que escribimos.

Para encon­trar las ref­er­en­cias de los pun­tos de apari­ción vamos a uti­lizar un méto­do de la clase GameOb­ject que nos per­mi­tirá encon­trar obje­tos uti­lizan­do su tag.

En las fig­uras 31 y 32 vemos que hay dos vari­antes de este méto­do, una nos devuelve un úni­co GameOb­ject (figu­ra 31) y la otra nos devuelve un array que con­tiene todos los GameOb­jects que tienen el tag que indicamos (figu­ra 32). 

Obser­ven cómo estos dos méto­dos sólo se difer­en­cian por una letra "s".

instrucciónes c# que se encarga de colocar el prefab aletoriamente unity 3d. findgameobjectwithtag
Fig. 32: Vamos a uti­lizar el méto­do Find­GameOb­jectsWith­Tag de la clase GameObject.

La instruc­ción entonces sería la siguiente:

spawnPoints=GameObject.FindGameObjectsWithTag(tag);

Los parámet­ros que uti­liza un méto­do se ingre­san entre parén­te­sis sep­a­ra­dos por coma, esto lo expli­co en el artícu­lo que escribí sobre qué es un méto­do en programación.

instrucciónes c# que se encarga de colocar el prefab aletoriamente unity 3d
Fig. 33: La instruc­ción en el méto­do Start se encar­ga de encon­trar todos los pun­tos de apari­ción del esce­nario y guardar­los en el Array spawnPoints.

En el segun­do video de la serie fun­da­men­tal de Uni­ty anal­i­zo esta for­ma de encon­trar las ref­er­en­cias de los GameOb­jects y otras cua­tro for­mas más. Tam­bién escribí un artícu­lo sobre ese video pro­fun­dizan­do la información.

En la figu­ra 34 se obser­va que al entrar en el modo juego, nue­stro array es de tamaño 1 y con­tiene la ref­er­en­cia del GameOb­ject Spawn­Point de la jer­ar­quía (resalta­do en amar­il­lo por el pro­pio Unity).

Fig. 34: Al entrar en el modo juego, vemos que en el inspec­tor está la ref­er­en­cia del pun­to de aparición. 

Vamos a crear algu­nas copias de este GameOb­ject con CTRL‑D y entrar nue­va­mente en el modo juego.

Fig. 35: Se cre­an copias de los pun­tos de aparición.

Aho­ra podemos ver que el array es de tamaño 4 y con­tiene todas las ref­er­en­cias de los GameObjects.

Fig. 36: Al entrar nue­va­mente en el modo juego, aho­ra el Array tiene cua­tro ele­men­tos y están todas las referencias.

Colo­camos un Spawn­Point en cada puerta.

colocar prefab aleatoriamente. posicionar empty objects
Fig. 37: Colo­camos un pun­to de apari­ción en cada puerta.

Seleccionar un elemento aleatorio del array

Para ele­gir un pun­to de apari­ción aleato­rio nece­si­ta­mos ele­gir aleato­ri­a­mente un ele­men­to del array. Esto lo hare­mos definien­do una vari­able entera de nom­bre "rand" que será igual a un número aleato­rio entre 0 y la can­ti­dad de ele­men­tos del array menos 1.

Esto últi­mo es así porque en C# el primer ele­men­to del array tiene la posi­ción 0 y el últi­mo la posi­ción "Length‑1" (tamaño del array menos 1).

Para gener­ar un número entero aleato­rio uti­lizamos el méto­do Range de la clase Ran­dom e indicamos dos parámet­ros, el ini­cio del inter­va­lo (val­or que se incluye) y el final del inter­va­lo (val­or que se excluye). Como se indi­ca en la figu­ra 38.

instrucciónes c# que se encarga de colocar el prefab aletoriamente unity 3d
Fig. 38: La segun­da instruc­ción gen­era un número entero aleato­rio entre 0 y la can­ti­dad de pun­tos de apari­ción menos 1.

Noten como el rago de val­ores de este número se ajus­tará automáti­ca­mente a la can­ti­dad de pun­tos de apari­ción que haya en la jerarquía.

El sigu­iente paso es obten­er la ref­er­en­cia del pun­to de apari­ción que se encuen­tra en la posi­ción que define ese entero aleato­rio. Para acced­er a la com­po­nente de un array uti­lizamos el nom­bre del array y entre corchetes el número entero de la posición.

El ele­men­to del array lo asig­namos al GameOb­ject select­edSpawn­Point pre­vi­a­mente definido. Esto y lo ante­ri­or lo podemos ver en la figu­ra 39.

instrucciónes c# que se encarga de colocar el prefab aletoriamente unity 3d
Fig. 39: En la ter­cer instruc­ción se selec­ciona el pun­to de apari­ción del array.

En las fig­uras 40 y 41 vemos dos prue­bas del juego en las cuales se ha elegi­do un pun­to de apari­ción distinto.

Fig. 40: En esta prue­ba el pun­to de apari­ción es el D.
Fig. 41: En esta prue­ba el pun­to de apari­ción es el B.

El sigu­iente paso es colo­car el pre­fab del per­son­aje en la posi­ción del pun­to de apari­ción seleccionado.

Para esto vamos a uti­lizar el méto­do Instan­ti­ate de la clase MonoBe­hav­iour (super clase de GameControl). 

El cuar­to video de la serie fun­da­men­tal de Uni­ty se tra­ta sobre el méto­do Instan­ti­ate, aunque ese video es algo extraño, en el artícu­lo se expli­ca en detalle cómo fun­ciona el método.

El méto­do Instan­ti­ate tiene varias ver­siones, vamos a uti­lizar una que requiere el Pre­fab a instan­ciar, la posi­ción en donde se va a colo­car y la rotación que tendrá.

Para el pre­fab habíamos definido el GameOb­ject "play­er­Pre­fab". Mien­tras que la posi­ción y la rotación la leer­e­mos del GameOb­ject "select­edSpawn­Point".

La eje­cu­ción del méto­do Instan­ti­ate devolverá un GameOb­ject el cual será la ref­er­en­cia del GameOb­ject crea­do, es decir la ref­er­en­cia del jugador. Vamos a guardar esta ref­er­en­cia en el GameOb­ject "play­er", porque prob­a­ble­mente la use­mos mas adelante. 

Lo que se explicó en los últi­mos tres pár­rafos se ilus­tran en la últi­ma instruc­ción de la figu­ra 42.

instrucciónes c# que se encarga de colocar el prefab aletoriamente unity 3d
Fig. 42: La cuar­ta y últi­ma instruc­ción colo­ca el pre­fab del per­son­aje en el pun­to de apari­ción elegido.

Como obser­vación se puede men­cionar el uso del oper­ador pun­to para acced­er a los atrib­u­tos posi­tion y rota­tion, los cuales se encuen­tran definidos en la com­po­nente Transform.

En prin­ci­pio no es tan sim­ple de enten­der, pero a medi­da que adquiramos prác­ti­ca y estudiemos un poco de pro­gra­mación va a pasar a ser algo trivial.

En las fig­uras 43 y 44 se mues­tran dos prue­bas del juego en las cuales el jugador aparece en dis­tin­tas posiciones.

Fig. 43: El per­son­aje aparece en la puer­ta de la esquina supe­ri­or izquierda.

Fig. 44: El per­son­aje aparece en la puer­ta de la esquina infe­ri­or derecha.

Modularización

Estas cua­tro instruc­ciones que hemos crea­do colo­can al per­son­jate en una de las puer­tas aleatoriamente.

Seria genial si tuviése­mos una instruc­ción que se llame "colo­car­AlPer­son­ajeE­nUna­Puer­taAleato­ria" y que haga todo el tra­ba­jo. Entonces podríamos pon­er una sola instruc­ción den­tro de start en lugar de cuatro.

Afor­tu­nada­mente podemos hac­er exac­ta­mente esto definien­do un nue­vo método.

script c# genérico en unity 3d, método que se encarga de colocar el prefab aletoriamente
Fig. 45: Se define un méto­do pri­va­do lla­ma­do "pla­ce­Play­er­Ran­dom­ly" que no requiere parámet­ros y no devuelve parámetros.

El méto­do se va a lla­mar "pla­ce­Play­er­Ran­dom­ly" (colo­car per­son­aje aleato­ri­a­mente), no va a requerir parámet­ros, no va a devolver datos y va a ser pri­va­do. La defini­ción de un méto­do con todas las car­ac­terís­ti­cas enun­ci­adas se ilus­tra en la figu­ra 45.

En los primeros dos videos de esta serie util­icé nom­bres en español, pero con­sidero que es mejor acos­tum­brarnos a uti­lizar nom­bres en inglés, además de que me facili­ta el tra­ba­jo de traducción.

script c# genérico en unity 3d, método que se encarga de colocar el prefab aletoriamente
Fig. 46: Move­mos las cua­tro instruc­ciones al méto­do placePlayerRandomly.

Vamos a selec­cionar las cua­tro instruc­ciones que pusi­mos en el méto­do Start, las vamos a cor­tar y a pegar en este nue­vo méto­do, como se obser­va en la figu­ra 46

Luego en el méto­do Start hace­mos la lla­ma­da al méto­do pla­ce­Play­er­Ran­dom­ly, como vemos en la figu­ra 47.

script c# genérico en unity 3d, método que se encarga de colocar el prefab aletoriamente
Fig. 47: Hace­mos la lla­ma­da a pla­ce­Play­er­Ran­dom­ly en el méto­do Start.

Reiniciar escena

Para pro­bar fácil­mente la fun­ción de colo­car al jugador en una posi­ción aleato­ria, voy a hac­er que la esce­na se reini­cie
al pul­sar la tecla R.

Para esto nece­si­ta­mos agre­gar el Name­space UnityEngine.SceneManagement, un Name­space es sim­ple­mente una colec­ción de clases agru­padas bajo un nom­bre, en este caso se tra­ta de clases rela­cionadas al mane­jo de las esce­nas en Unity.

Agreg­amos el Name­space en la línea 4 que se obser­va en la figu­ra 48.

script c# genérico en unity 3d. definir variables y métodos. scenemanagement
Fig. 48: Impor­ta­mos la libr­ería SceneManagement.

Para hac­er la lec­tura del tecla­do usamos una sen­ten­cia if y la clase Input. El video 1 de la Serie Fun­da­men­tal de Uni­ty se tra­ta sobre leer las entradas del tecla­do y el mouse, en el artícu­lo del video se pro­fun­diza la información.

Den­tro de la sen­ten­cia if eje­cu­ta­mos el méto­do estáti­co Load­Scene de la clase Scene­M­an­ag­er y pasamos como parámetro el número cero, indi­can­do que se car­gue la esce­na 0. Esta esce­na sería la primer esce­na declar­a­da en la ven­tana Build Set­tings. En nue­stro caso solo ten­emos una esce­na así que sim­ple­mente se reiniciará.

script c# genérico en unity 3d. definir variables y métodos. loadscene
Fig. 49: En el méto­do Update hace­mos la lec­tura de la tecla R y si es pul­sa­da carg­amos la esce­na 0.

Correcciones finales

Lo últi­mo que hare­mos será mod­i­ficar la rotación de los Emp­ty GameOb­jects Spawn­Point, de tal for­ma que la flecha azul que indi­ca la direc­ción, apunte en direc­ción opues­ta a la puerta.

Con la tecla E selec­cionamos la her­ramien­ta de rotación y man­te­nien­do pul­sa­da la tecla SHIFT hace­mos que las mod­i­fi­ca­ciones del ángu­lo sean con paso fijo, si no me equiv­o­co de 15 gra­dos. De esa for­ma si la el ángu­lo del eje Y es por ejem­p­lo 0 gra­dos, podemos lle­var­lo exac­ta­mente a 90 gra­dos gra­cias a ese paso fijo.

Fig. 50: Rotación de los pun­tos de apari­ción para que el per­son­aje aparez­ca como si hubiese entra­da por la puerta.

Fig. 51: En este caso el eje azul indi­ca la direc­ción a la que aparece miran­do el per­son­aje. En este caso hay que girar­lo 90 gra­dos en sen­ti­do horario.

Para con­cluir hace­mos una com­pi­lación. En las fig­uras 53 y 54 se obser­van dos ini­cios dis­tin­tos del juego, en cada uno el jugador aparece en una puer­ta distinta.

colocar prefab aleatoriamente. el personaje aparece en una de las puertas
Fig. 53: Prue­ba de com­pi­lación 1.

colocar prefab aleatoriamente. el personaje aparece en una de las puertas
Fig. 54: Prue­ba de com­pi­lación 2.

Conclusión

En este artícu­lo vimos cómo crear el primer Script C# que se encar­gará de colo­car al per­son­aje en una posi­ción aleato­ria del escenario.

Se analizaron todos los atrib­u­tos para cumplir el obje­ti­vo y se explicó para qué se usa­ba cada uno.

La mod­u­lar­ización es una her­ramien­ta útil para orga­ni­zar nue­stro códi­go y hac­er­lo más intuitivo.

guest
0 Comments
Inline Feedbacks
View all comments
YouTube
Scroll al inicio
Secured By miniOrange