Tutorial de scripts para Unity 3d

FUNCIONES:

GetTypeFromControl:

function GetTypeForControl (controlID : int) : EventType


Esta función devuelve un tipo de evento que es filtrado para un determinado control cuya id pasamos como parámetro. Esta función es usada para implementar bloqueos de ratón y de focos de teclado.

El id del control para el que requerimos el tipo de evento se obtiene de GUIUtilty.GetControlID (), y en EventType podemos ver una lista de sus posibles valores.


Use:

function Use () : void


Evento ya utilizado. deberíamos llamar a este método cuando ya hemos usado un evento. El tipo de evento será colocado en EventType.Used, causando que otros elementos GUI lo ignoren.


VARIABLES DE CLASE:

current:

static var current : Event


El evento actual/corriente que está siendo procesado en este mismo momento.

Un ejemplo:

function OnGUI() {
   var miEvento : Event = Event.current;
   if(miEvento.type != EventType.repaint && miEvento.type != EventType.layout){
 Debug.Log("Current detected event: " + Event.current);
}
}

Salvamos y tras pulsar al play disparamos los eventos que deseemos. Detenemos el reproductor y accedemos a la consola donde se muestran los mensajes haciendo click sobre el último y ahí tendremos toda la información sobre teclas pulsadas, movimientos y clics del ratón, etc. Observaréis que descarté la impresión de eventos de tipo repaint y layout, que son los que se producen de manera automática y en un número mayor.

clickCount:

var clickCount : int


Cuántos clicks de ratón consecutivos hemos recibido.

Es usado en el evento EventType.MouseDown. Usadlo para diferenciar entre un click único y un doble click.

Un ejemplo:

private var numeroClicks : int = 0;

function OnGUI() {
  var miEvento : Event = Event.current;
  if (miEvento.isMouse) {
     numeroClicks +=miEvento.clickCount;
     Debug.Log("Mouse clicks: " + numeroClicks);
}
}

Si lo probamos, vemos que tenemos un contador de clicks que contabiliza cada actividad (down y up) del botón del ratón desde el inicio del juego. Es una adaptación del script que está en el manual de referencia. Si os fijáis, declaramos la variable numeroClicks fuera de la función onGUI, para que no nos contabilice (como hace en el manual de referencia) los clicks de cada frame, sino los totales. Por lo demás, el script no tiene mucho misterio: inicializamos una variable de tipo Event con el evento actual, nos aseguramos de que el evento tenga que ver con el ratón y pasamos a contar clicks.


character:

var character : char


El tipo de caracter.

function OnGUI() {
   var miEvento : Event = Event.current;
   if (miEvento.isKey) {
       Debug.Log("Pulsado caracter: " + miEvento.character);
}
}

commandName

var commandName : String


El nombre de un evento de tipo ExecuteCommand o Validate Command ("Copy", "Cut", "Paste", "Delete", "FrameSelected", "Duplicate", "SelectAll", etc)


keyCode:

var keyCode : KeyCode


El key code para eventos de teclado. Usado en los eventos EventType.KeyDown y EventType.KeyUp; devuelve el valor del KeyCode, por lo que se usa para manejar, por ejemplo, teclas de cursor, de funciones, etc.

Teclead este código y tras salvar y darle al play pulsad por ejemplo una de las flechas de desplazamiento del teclado:

function OnGUI() {
  var miEvento : Event = Event.current;
  if (miEvento.isKey) {
     Debug.Log("El key code es: " + miEvento.keyCode);
}
}

shift:

var shift : boolean


¿Está shift pulsado? (sólo lectura)


control:

var control : boolean


¿Está control pulsado? (sólo lectura)


alt:

var alt : boolean


¿Está alt pulsado? (Sólo lectura)


capsLock:

var capsLock : boolean


¿Está el bloqueo de mayúsculas pulsado? (sólo lectura)


numeric:

var numeric : boolean


¿Se está presionando alguna tecla del teclado numérico) (sólo lectura)


functionKey:

var functionKey : boolean


¿Es la tecla presionada una tecla de función (alt, ctrl, shift, etc)? (Sólo lectura)


isKey:

var isKey : boolean


¿Es este evento un evento de teclado? (sólo lectura)


isMouse:

var isMouse : boolean


¿Es este evento un evento de ratón? (sólo lectura)

Tipos de teclas modificadores que pueden estar activos durante un proceso de pulsación de tecla.

Los eventos pueden corresponder a entradas de usuario (teclas presionadas, acción de ratón) o bien ser distribuciones (layers) de unityGUI o eventos de renderizado. Asi como OnGUI es potencialmente llamado multiples veces por frame. Event.current corresponde al actual evento dentro de la llamada a OnGUI.


VARIABLES:

type:

var type : EventType


Variable que indica el tipo de evento. Es de tipo EventType, que es una enumeración que permite los siguientes valores:

MouseDown           Un botón del ratón ha sido presionado. 
MouseUp             Un botón del ratón ha sido liberado. 
MouseMove           El ratón se ha movido (sólo en vista de edición).
MouseDrag           El ratón fue arrastrado.
KeyDown             Una tecla del teclado fue presionada. 
KeyUp               Una tecla del teclado fue liberada. 
ScrollWheel         La rueda del ratón se movió.
Repaint             Un evento de repintado. Se envía uno cada frame. 
Layout              Un evento de distribución.
DragUpdated         Solo en editor: operación de drag & drop actualizada.
DragPerform         Sólo en editor: operación de drag & drop realizada.
DragExited          Sólo en editor: operacion de drag & drop finalizada.
Ignore              el evento debe ser ignorado.
Used                Evento ya procesado.
ValidateCommand     Valida un comando especial (p.ej. copy & paste)
ExecuteCommand      Ejecuta un comando especial (p.ej. copy & paste)
ContextClick        El usuario ha hecho click con el botón derecho.

Pongamos un breve ejemplo:

function OnGUI () {
 Debug.Log("Current event detected: " + Event.current.type);
 }

Este script meramente imprime el evento que está teniendo lugar cada frame. Prueba, tras pulsar play, a hacer click con diferentes botones del ratón, pulsa distintas teclas, mueve el ratón, etc. Luego detén el reproductor y haz click sobre el último mensaje de la consola para que te aparezca el pop up. Verás una lista enorme de eventos que han tenido lugar, la mayoría de repintado y distribución, pero entre ellos estarán los que hayas provocado durante ese tiempo.


mousePosition:

var mousePosition : Vector2


La posición del ratón. Variable usada en los eventos EventType.MouseMove y EventType.MouseDrag.


delta:

var delta : Vector2


El movimiento relativo del ratón comparado con el último evento.


button:

var button : int


Qué botón del ratón ha sido presionado.

Apliquemos un ejemplo:

function OnGUI() {
  var miEvento : Event = Event.current;
  if(miEvento.button == 0 && miEvento.isMouse){
     Debug.Log("Botón izquierdo");
  } else if(miEvento.button == 1) {
     Debug.Log("Botón derecho");
  } else if (miEvento.button == 2) {
     Debug.Log("Botón del centro"); 
} 
}

Creamos primero una instancia de la clase Event, que contendrá el evento actual. Si dicho evento es un evento de ratón (isMouse, que estudiaremos de aquí a un momento) y button vale cero (esto es, button vale cero pese a haber un evento de ratón, ya que si no hay evento de ratón button también vale cero, no sé si me estoy explicando)
se imprime un mensaje, y así sucesivamente (con valores de button en uno y dos no hace falta descartar la posibilidad de que no se esté produciendo un evento de ratón por lo anteriormente explicado.


modifiers:

var modifiers : EventModifiers

Qué tecla modificadora está siendo pulsada( ahift, ctrl, alt...)

function OnGUI() {
  var miEvento : Event = Event.current;
  Debug.Log(miEvento.modifiers);
}

Probad a pulsar las teclas modificadoras y las veréis impresas, a diferencia de las que no tienen esa condición.