Tutorial de scripts para Unity 3d

Bueno, tras un par de capítulos con los prolegómenos, creo que ya podemos entrar en materia, para lo cual vamos a abrir Unity.

Nota: En principio, y salvo que diga lo contrario, todas las características y scripts que vamos a utilizar sirven para la versión free como para la PRO, así que me da igual la versión que tengáis.

Vamos a crear un proyecto nuevo, que podéis llamar como os dé la gana y guardar donde queráis, que para eso e ordenador es vuestro. No vamos a importar de momento ningún asset, así que dejamos desmarcadas todas las casillas y creamos el proyecto.

Lo único que nos aparecerá en la interfaz, por tanto, será la cámara principal. La marcamos y en el inspector, la colocamos en las siguientes coordenadas: X=0, Y=1, Z =-5.

Ahora vamos a introducir un cubo en la escena. Nos vamos al menú superior, Gameobject => Create other => Cube. Al cubo primero lo vamos a castellanizar, y en consecuencia le llamaremos Cubo. Le podemos cambiar el nombre en el inspector, o bien pulsando F2 en la jerarquía con Cube seleccionado. Vamos a ubicar nuestro cubo en las coordenadas 0,0,0.

Vamos a salvar la escena. File =>Save Scene. Para no liarnos, recomiendo que le pongáis el mismo nombre que yo, esto es, Ejemplo_1.

Si todo ha ido bien, debéis tener algo parecido a esto:



Ahora, en la vista Project, en un espacio libre debajo de donde está la escena guardada, hacemos click derecho con el ratón, y en el menú emergente seleccionamos Create => Folder. A la carpeta que aparecerá le llamaremos Mis scripts. Con el puntero del ratón sobre dicha carpeta vamos a hacer de nuevo click derecho, y esta vez seleccionamos Create=>Javascript. Nos aparecerá un icono representando al nuevo script con el nombre por defecto "NewBehaviourScript". Lo renombramos, llamándolo MiPrimerScript, y le damos a return para que nos conserve el cambio.



Como podemos observar, en el inspector al seleccionar nuestro script aparece una función por defecto, la cual nos será útil en un buen número de casos. Sería lo que se conoce como una función sobreescribible, que quiere decir que Unity decide cuándo se va a llamar (la función Update, que es la que sale por defecto, es llamada por Unity cada frame) y nosotros decidimos qué hará cuando sea llamada, introduciendo código en su interior.

Para poder editar y/o crear nuestros scripts, hemos de acceder al editor que viene con Unity, y la mejor manera para hacerlo es hacer doble click sobre el nombre de nuestro script. Se nos abrirá (en windows) esto:



Vamos a aprovechar que tenemos el editor abierto para explicar otra característica de los scripts en Unity. Unity permite asignar/modificar los valores a las variables globales desde la propia interfaz de usuario, y concretamente desde el inspector, bien asignando esos valores "a mano", o bien arrastrando un objeto o componente del tipo de dicha variable global. Para que podamos hacer eso es preciso, como digo, que la variable tenga un ámbito global, y para ello es preciso que la misma se declare fuera de cualquier función.

Lo veremos mejor con un ejemplo: en el editor de scripts, encima de donde pone function Update, escribiremos lo siguiente:

var camaraDeSeguridad : Camera;
camaraDeSeguridad.name = "Mi camara";
Debug.Log(camaraDeSeguridad.name);

Es un miniscript parecido al que veíamos en el capítulo anterior. En él declaramos una variable global (está fuera de cualquier función) de tipo "Camera", y lo que hacemos a continuación es -vía herencia- asignarle un nombre a la variable, que será "Mi camara". La tercera declaración de momento nos basta con saber que muestra en pantalla (imprime) el valor de lo que esté entre sus paréntesis.

Guardamos el script (si no, no funcionará) en el editor de scipts. De vuelta a la interfaz de Unity, si seleccionamos el nombre del script vemos que en el inspector se ha actualizado dicho script con el código que hemos introducido.

No obstante, nuestro script aún no es funcional, ya que no lo hemos vinculado a ningún objeto de nuestra escena. Pensemos que los scripts por sí sólos no hacen nada, de la misma forma que cualquier asset que está en la carpeta/vista del proyecto (por ejemplo, una textura) no participará de alguna manera en una escena de nuestro juego si no lo arrastramos a esa escena, convirtiéndolo en parte de cualquier gameobject.

En consecuencia, vamos a vincular nuestro script a uno de los game objects de nuestra escena, y en concreto al cubo. Para hacer eso meramente hemos de arrastrar el script desde la vista de proyecto hasta el propio objeto cubo, bien sea sobre su nombre en la jerarquía, bien sobre la propia imagen del cubo en la escena.

Tras arrastrar el script, y con el cubo seleccionado en la jerarquia, en el inspector deberíamos estar viendo lo siguiente:



Obsérvese que en el inspector aparece ahora el nombre de nuestro script como una parte más del Cubo que tenemos en la escena. Y daros cuenta de que la variable global queda expuesta en el inspector, de tal forma que no necesitamos ir al editor de scripts para asignarle un valor. Si la variable hubiera sido, por ejemplo, de tipo float, podríamos haber introducido o cambiado su valor meramente escbibiéndolo en el inspector. Si en cambio la variable fuera de tipo bool, nos aparecería en el inspector con un checkbox al lado del nombre, bien marcado (true) o sin marcar (false) para que lo cambiáramos a conveniencia.

Pero como en este caso la variable es de tipo Camera, lo único que podemos hacer para inicializarla es proveerla de un objeto de ese tipo. Dado que en nuestra escena precisamente tenemos una cámara (la main camera), meramente tendremos que arrastrarla desde la jerarquía hasta el lugar del inspector donde se consigna el valor de la variable,y que ahora mismo pone "none".

Tras arrastrar la cámara, el inspector lucirá así:



Ya tenemos, por lo tanto, nuestro script asignado a un gameobject (nuestro cubo) y la única variable global inicializada con otro object (la cámara principal). Procedamos ahora a darle al play y ver qué sucede.

Si nos fijamos, debajo de la ventana game nos aparecerá impreso el nombre que le asignamos a nuestra cámara.



Antes de acabar me gustaría que practicáramos un pequeño ejercicio que nos permitirá comprender las diferentes maneras (correctas e incorrectas) en que se puede declarar una variable. Borremos todo el contenido de nuestro script MiPrimerScript y tecleemos lo siguiente:

var sinTipoNiIni;
var conTipoSinIni : int;
var sinTipoConIni = 10;
var conTipoConIni : int = 10;
var aPlazos : int;
aPlazos = 10;
private var miSecreto : int;
var arrastrame : GameObject;
function Update() {
var enLaFuncion : int;
}

Salvamos el script y, con el Cubo seleccionado (recordemos que este script está todavía vinculado al cubo que tenemos en la escena) echamos un vistazo al inspector. Podemos de manera empírica llegar a las siguientes conclusiones para cada manera de declarar una variable:

La variable sinTipoNiIni, que como su nombre apunta hemos declarado sin indicar ni el tipo de datos que debería contener, ni la hemos inicializado conjuntamente con la declaración, no aparece en el inspector, porque éste no tiene forma de saber qué tipo de variable estamos declarando.

La variable conTipoSinIni sí es tenida en cuenta por el inspector, ya que aunque no la hemos inicializado, sí que hemos indicado el tipo de dato que queremos almacenar en ella.

La variable sinTipoConIni sí aparece en el inspector, ya que aunque no hemos declarado el tipo que contendrá, al estar inicializada permitimos a Unity deducir en base al valor en tipo de variable apropiado. Fijémonos que además de aparecer la variable en el inspector, lo hace con el valor inicial que le hemos dado.

La variable conTipoConIni aparece obviamente en el inspector.

La variable aPlazos aparece en el inspector, pero sin inicializar. En cambio, si pulsamos play observaremos que automáticamente le es asignado el valor 10 que le dimos en segunda declaración.

La variable miSecreto no es accesible desde el inspector porque es privada. De hecho, esa variable no podrá se accedida desde ningún script distinto del que la contiene.

La variable arrastrame es recogida en el inspector, y al ser de un tipo propio de Unity, nos aparecerá con una flechita diminuta en la derecha que nos indica que podemos importar del juego cualquier componente de ese tipo para asignar un valor a la misma, bien usando el menú que emerge al clickar dicha flecha, bien vía arrastrar el objeto o componente desde las carpetas de proyecto o jerarquía.

Por último, la variable enLaFunción no aparece en el inspector, ya que al ser declarada dentro de una función no tiene carácter público.


Bueno, pues con esto ya debería quedar un poco más clara la manera en que las variables y los scripts son tratados en Unity. Para la próxima lección empezaremos a analizar clase por clase de la API.

Hasta pronto.