Tutorial de scripts para Unity 3d

Es una clase base para otras clases que vamos a introducir dentro de este apartado, para no disgregarlas mucho dado su pequeño tamaño.


CLASE WAITFORSECONDS:

Suspende la ejecución de una corrutina por una cantidad dada de segundos. Sólo puede usarse con una declaración yield en corrutinas. Por ejemplo:

print (Time.time);            //Esto imprimirá 0.

yield WaitForSeconds (5);     //Espera cinco segundos.

print (Time.time);            //Ahora imprime 5.0.

Esta clase sólo la compone su constructor:

static function WaitForSeconds (seconds : float) : WaitForSeconds


CLASE WAITFORFIXEDUPDATE:


Espera hasta la siguiente función de actualización de frames fijados

yield new WaitForFixedUpdate ();

CLASE COROUTINE:


MonoBehaviour.StartCoroutine devuelve una Coroutine. Las instancias de esta clase son usadas sólamente como referencia de esas coroutines y no tienen propiedades ni funciones.

Una coroutine es una function que puede suspender su ejecución (yield) hasta que la instrucción dada YieldInstruction acaba.

Como su nombre indica (y tal como ya hemos visto en algunos ejemplos previamente) esta clase nos permite utilizar características de gran utilidad relacionadas con el tiempo.



VARIABLES DE CLASE:

time:

static var time : float


Es el tiempo en segundos desde el inicio del juego (sólo lectura).

Cuando esta propiedad es llamada desde dentro de la función fixedUpdate devuelve la propiedad fixedTime.

function Update(){
  print(Time.time);
}

No hace falta mucha explicación: nos aparece en pantalla el tiempo transcurrido desde el inicio del juego.


timeSinceLevelLoad:

static var timeSinceLevelLoad : float


Tiempo en segundos desde que el último level ha sido cargado (sólo lectura)


deltaTime:

static var deltaTime : float


El tiempo en segundos que se tardó en completar el último frame (sólo lectura). Debemos usar esta propiedad para hacer que las cosas funcionen de manera independiente a la frecuencia de frames de casa ordenador. Así, cuando multiplicamos dentro de la función Update el movimiento de un objeto con Time.deltaTime estaremos queriendo decir: quiero mover este objeto 10 metros por segundo en lugar de 10 metros por frame.

Recordemos que si llamamos a esta propiedad desde dentro de FixedUpdate, devuelve el delta time de framerate fijo, para adaptarse a éste.

No debemos confiar en Time.deltaTime desde dentro de un onGUI, ya que OnGUI puede ser llamado múltiples veces por frame y delta time debe sostener el mismo valor cada llamada, hasta el siguiente frame en que será actualizado de nuevo.


fixedTime:

static var fixedTime : float


El tiempo desde que el último FixedUpdate comenzó (sólo lectura). Este es el tiempo en segundos desde el inicio del juego. Fixed time es actualizado en intervalos regulares (igual que fixedDeltaTime) hasta que la propiedad time es alcanzada.


maximumDeltaTime:

static var maximumDeltaTime : float


El máximo tiempo que un frame puede tomar. Physics y otras actualizaciones de frecuencia fija de frames (como FixedUpdate) trabajarán solo durante esta duración de tiempo por frame.


smoothDeltaTime:

static var smoothDeltaTime : float


Un Time.deltaTime suavizado.


timeScale:

static var timeScale : float


La escala en la cual el tiempo pasa. Puede ser usada para efectos de cámara lenta. Cuando está establecida en 1.0, el tiempo transcurre igual que en la vida real. Cuando está en 0.5 está el doble de lento que en la vida real. Si lo colocamos en cero el juego se pausa si todas las funciones son independientes del frame rate.

Si bajamos el timeScale es recomendable que también bajemos Time.fixedDeltaTime en la misma cantidad.

Las funcione dentro de FixedUpdate no serán llamadas cuando timeScale esté colocada a cero.


frameCount:

static var frameCount : int


El número total de frames que han pasado (sólo lectura)


realtimeSinceStartup:

static var realtimeSinceStartup : float


El tiempo real en segundos desde que el juego empezó (solo lectura). En casi todos los casos, no obstante, debemos usar Time.time en lugar de esto.


captureFramerate:

static var captureFramerate : int


Si está establecida en un valor superior a 0, el tiempo avanzará en (1.0 / captureFramerate) por frame sin tener en cuenta el tiempo real. Esto es útil si quieres capturar una película donde necesitas una frecuencia de frames constante.

Acceso a la pantalla de información. Esta clase puede ser usada para obtener la lista de las resoluciones soportadas, cambiar la resolución actual, esconder o mostrar el puntero de ratón del sistema, etc.



VARIABLES DE CLASE:

resolutions:

static var resolutions : Resolution[]


Devuelve todas las resoluciones de pantalla completa soportadas por el monitor (read only). Las resoluciones retornadas se ordenan por anchura, empezando por las resoluciones más bajas.

El tipo Resolucion es una estructura con las siguientes variables:

width           Anchura de la resolución en píxeles.
height         Altura de la resolución en píxeles.
refreshRate Tipo de refresco de resolución vertical en Hz. 

currentResolution:

static var currentResolution : Resolution


Variable de sólo lectura que devuelve la resolución de pantalla actual. Si el jugador está corriendo en modo windows, esto devuelve la resolución actual del escritorio.


showCursor:

static var showCursor : boolean


¿Debe el cursor ser visible?

Es enteramente posible implementar un cursor personalizado en lugar del que tiene el sistema. Para hacer esto debemos esconder el del sistema, seguir la posición o movimiento de ratón y mostrar nuestra propia imagen en el lugar preciso.


Vamos a hacer desaparecer nuestro cursor. Para ello previamente eliminamos la luz que creamos en la lección anterior, y luego editamos nuestro Script (que recordaremos que tenemos vinculado a PortaScripts)

Screen.showCursor = false;

Observaremos que cuando pasamos el cursor por encima de la ventana Game, éste se torna invisible.


lockCursor:

static var lockCursor : boolean


¿Debe el cursor ser bloqueado?

El cursor será ocultado automáticamete, centrado en la vista y haciendo que no se pueda abandonar ésta.

Si estamos realizando un juego de navegador web, el cursor podrá sólo ser bloqueado después de que el usuario haya hecho click en el contenido y siempre que éste no abandone la vista presionando escape o cambiando a otra aplicación, ya que en estos casos el cursor será automáticamente desbloqueado. El bloqueo del cursor también se perderá cuando se salga del modo de pantalla completa.

Se puede consultar si el cursor está actualmente bloqueado consultando el estado de lockCursor. Para proveer una buena experiencia de usuario es recomendable sólo bloquear el cursor como resultado de apretar un botón. También debemos consultar si el cursor se desbloquea en orden a pej pausar el juego o hacer surgir un menú del juego. En el Web Player y Editor el cursor automáticamente se desbloqueará cuando aprietes escape. En el Standalone Player tienes control pleno sobre el bloqueo del ratón de manera que no perderás automáticamente el bloqueo del mismo a menos que cambies de aplicación.


width:

static var width : int


La anchura actual de la ventana en la pantalla en píxeles (sólo lectura).

Esta es la actual anchura de la ventana del jugador (en pantalla completa es también la resolución actual)


height:

static var height : int


La altura actual de la ventana en la pantalla en píxeles (sólo lectura)

Esta es la actual altura de la ventana del jugador (en pantalla completa es tambén la resolución corriente)


fullScreen:

static var fullScreen : boolean


¿Está el juego corriendo en pantalla completa?

Es posible intercambiar al modo de pantalla completa cambiando esta propiedad.


sleepTimeout:

static var sleepTimeout : float


Un ajuste de ahorro de energía, permitiendo la atenuación de la pantalla algún tiempo después de la interacción del último usuario activo. Es muy útil para dispositivos táctiles, permitiendo el ahorro de la batería.

SleepTimeout es medido en segundos, donde 0 significa que nunca duerme. El valor por defecto varía de plataforma en plataforma, siendo generalmente distinto a cero el dispositivos móviles.

En dispositivos móviles sería útil colocar esta variable a cero para juegos que usen acelerómetros como principal fuente de entrada. Sin embargo, estos juegos deberían permitir la atenuación de la pantalla mientras están en la pantalla del menú o pausados.


FUNCIONES DE CLASE:

SetResolution:

static function SetResolution (width : int, height : int, fullscreen : boolean, preferredRefreshRate : int = 0) : void


Cambia la resolución de pantalla. Se usará una resolución de anchura por altura dada. Si la resolución indicada no existe o no es soportada por nuestro dispositivo, se usará la mas cercana a la indicada.

Si el parámetro preferredRefreshRate es 0 (default) Unity cambiará a la mayor velocidad de actualización soportada por el monitor.

Si preferredRefreshRate no es cero, Unity la usará si el monitor la soporta, y en otro caso encontrará la más alta soportada.

En la web player sólo podemos cambiar de resolución depués de que el usuario ha hecho click en el contenido. La manera recomendada de hacer esto es cambiar la resolución sólo cuando el usuario haga clic en un botón designado a tal efecto.
El cambio de resolución no sucede inmediatamente, sino cuando el frame actual acaba.

Esta clase se corresponde con las variables que podemos encontrar en el inspector si nos vamos al menú=>edit=>Render Settings.

Contiene valores para un rango de elementos visuales en tu escena, como niebla y luz de ambiente.


VARIABLES DE CLASE:

fog:

static var fog : boolean


¿Está habilitada la niebla?


fogMode:

static var fogMode : FogMode


Modo de niebla a usar. FogMode es una enumeración que admite los siguientes valores:

Linear                Niebla lineal.
Exponential           Niebla exponencial.
ExponentialSquared    Niebla exponencial al cuadrado (por defecto).

fogColor:

static var fogColor : Color


El color de la niebla.


fogDensity:

static var fogDensity : float


La densidad de la niebla exponencial.

Resumamos lo visto con un ejemplo:

RenderSettings.fog = true;
RenderSettings.fogColor = Color.blue;
RenderSettings.fogDensity = 0.1;

Pulsamos play y habremos activado la niebla, que será de color azul y con una densidad de 0.1.


fogStartDistance:

static var fogStartDistance : float


La distancia inicial de la niebla lineal. Las distancias de inicio y final de la niebla son usadas por el modo de niebla Linear.


fogEndDistance:

static var fogEndDistance : float


La distancia final de la niebla lineal (sólo para modo Linear).


ambientLight:

static var ambientLight : Color


Color de la luz de ambiente de la escena.


haloStrength:

static var haloStrength : float


Tamaño del halo de luz. Para cualquier luz, el tamaño del halo es este valr multiplicado por Light.range.


flareStrength:

static var flareStrength : float


La intensidad de las llamas/destellos en la escena.

Vamos a hacer un ejemplo progresivo de la utilidad de estas últimas variables. En primer lugar, eliminamos el script que tenemos vinculado al cubo. Acto seguido editamos MiPrimerScript como sigue:

RenderSettings.ambientLight = Color.green;          

Salvamos y arrastramos a PortaScipts. Al darle al play deberíamos tener una luz de ambiente así:



Démonos cuenta que no ha sido preciso vincularle el script a la luz principal para que tenga efecto.

Ahora nos vamos al menú=>Gameobject=>Create other=>SpotLight. Ubicamos nuestra nueva luz en las coordenadas 0,3,0, con una rotación de 90,0,0, para que se note claramente su efecto y los posteriores cambios. En el inspector, asimismo, marcar la casilla que pone "draw hallo".

Ya que al inicio de este repaso por las clases no cargamos ningún asset, nos faltará uno para completar nuestro ejemplo, así que vamos a menú=>assets=>import Package=>Light Flares. Importamos.

Ahora, de nuevo en el inspector de nuestra spotlight hacemos click en la pequeña fleha que encontramos junto a Flare y seleccionamos Small Flare.

Podemos ya reescribir nuestro script:

RenderSettings.ambientLight = Color.green;
yield WaitForSeconds(5);
RenderSettings.haloStrength = 0.2;
RenderSettings.flareStrength = 0.2;

Dadle al play y observar los cambios transcurridos 5 segundos. HaloStrength afectará al diámetro del haz de luz que pega contra el suelo (la galleta o cookie, que dicen los anglosajones). FlareStrength en cambio se refiere a ese tipo de brillo que emite la fuente de la luz en su origen.


skybox:

static var skybox : Material


El skybox global en uso.

Variables y funciones para la creación y manejo de un rectángulo 2D definido por la posición x,y y anchura, altura. La estructura Rect es principalmente usada para operaciones 2D; el sistema UnityGUI la usa extensamente, además del posicionado de cámaras en la pantalla.


VARIABLES:

x:

var x : float


Coordenada izquierda del rectángulo (a lo largo del eje X).


y:

var y : float


Coordenada superior del rectángulo.



width:

var width : float


Anchura del rectángulo.



height:

var height : float


Altura del rectángulo.


xMin:

var xMin : float


Coordenada izquierda del rectángulo. Cambiando este valor conservamos el lado derecho del rectángulo (así width cambia también)


yMin:

var yMin : float


Coordenada superior del rectángulo. Cambiando este valor conservamos el lado inferior del rectángulo (así height cambiará también)


xMax:

var xMax : float


Coordenada derecha del rectánculo. Cambiando este valor seguimos conservando el lado izquierdo del rectángulo, por lo que la anchura cambiará también.


yMax:

var yMax : float


Coordenada inferior del rectángulo. Cambiando este valor seguimos conservando el lado superior del rectángulo, así que la altura cambiará también.



FUNCIONES:

Rect:

static function Rect (left : float, top : float, width : float, height : float) : Rect


Crea un nuevo rectángulo.


Contains:

function Contains (point : Vector2) : boolean
function Contains (point : Vector3) : boolean


Devuelve true si los componentes x e y del parámetro point conforman un punto dentro del rectángulo

Un breve ejemplo explicativo:

function Update () {
var rect = Rect (0, 0, 150, 150);

if (rect.Contains(Input.mousePosition))
  print("Dentro del rectángulo");

else
  print ("Fuera del rectángulo");
}

Hemos creado primero un plano a partir de las coordenadas 0(izquierda), 0(abajo), con 150 metros/unidades de ancho (a contar desde la izquierda) y otras tantas de alto(contadas desde abajo). Por lo tanto si el ratón lo ubicamos hacia la zona superior derecha se nos mostrará el mensaje de que estamos fuera del rectángulo y si hacemos lo propio hacia la zona inferior izquierda estaremos dentro del rectángulo.


FUNCIONES DE CLASE:

MinMaxRect:

static function MinMaxRect (left : float, top : float, right : float, bottom : float) : Rect


Crea un rectángulo entre min/max valores de coordenadas.