En ciertas ocasiones vas a requerir que tus instancias realicen una acción dependiendo del valor particular de una variable. Esto se puede lograr utilizando una serie consecutiva de sentencias "if", pero cuando las posibles opciones sobrepasan los dos o tres casos, usualmente es más fácil utilizar la sentencia "switch". Una sentencia switch tiene la siguiente forma:
switch (<expresión>)
{
case <expresión1>: <sentencia1>; ... ; break;
case <expresión2>: <sentencia2>; ... ; break;
...
default: <sentencia>;
}
Funciona de la siguiente manera:
Es importante notar que se pueden colocar múltiples sentencias "case" dentro de la misma sentencia "switch". La sentencia "break" tampoco es requerida, y si no se encuentra la sentencia "break" la ejecución del código continuará hasta la siguiente sentencia "case". Esto significa que puedes tener una jerarquía dentro de la sentencia "switch" en la que diferentes secciones de código se ejecutan dependiendo del valor de entrada. Enseguida se muestra un típico "switch" de un juego:
{
switch (keyboard_key)
{
case vk_left:
case ord("A"):
x -= 4;
break;
case vk_right:
case ord("D"):
x += 4;
break;
case vk_up:
case ord("W"):
y -= 4;
break;
case vk_down:
case ord("S"):
y += 4;
break;
}
}
El código anterior utiliza la sentencia "switch" para verificar los eventos del teclado y luego compararlos a las sentencias "case" que se han listado. Si se encuentra algún valor requerido, entonces se ejecuta el código correspondiente. Nótese cómo hemos hecho que el "switch" compare múltiples casos y continúe ejecutando si no se encuentra ningún "break", para permitir que varias teclas sean utilizadas para conseguir el mismo resultado. Este es un ejemplo que ilustra una de las muchas maneras en que puedes crear configuraciones de teclas múltiples para el movimiento o "especiales" en tu juego.
"break" se usa para terminar prematuramente la ejecución de ciclos for, repeat, while , do... until o para indicar que una sentencia switch finalice en ese punto. A continuación se muestran ejemplos de su uso, aunque es bastante simple, ya que su forma consiste solamente en:
break;
"break" en un ciclo FOR:
{
var i;
for (i = 0; i < 10; i += 1)
{
if array[i] = 234 break;
}
num = i;
}
"break" en un ciclo REPEAT:
{
var i, temp;
i = 0;
temp = 0;
repeat (10)
{
temp += array[i];
if temp > max_total break else i += 1;
}
}
"break" en un ciclo WHILE:
{
var i;
i = 0;
while (!place_free(x, y))
{
x = random(room_width);
y = random(room_height);
if i > 50 break else i+=1;
}
}
continue
Si se usa dentro de un ciclo (repeat, while, do... until or for), el flujo de ejecución saltará de inmediato al comienzo del ciclo, como si la iteración se hubiera completado totalmente y se regresara al principio. Si se usa fuera de un ciclo, continue actúa como si se tratase de una sentencia exit, dando por terminado el evento. A continuación se muestra su uso dentro de un ciclo for:
{
var i;
for (i = 0; i < 10; i += 1)
{
if array[i] = "" continue;
array[i] = "";
}
}
El código anterior saltará al inicio del ciclo si el valor array[i] es una cadena vacía.
La sentencia exit tiene la forma:
exit;
"Exit" simplemente termina la ejecución del script o evento actual. Se debe notar que si se usa exit en un script, símplemente saldrá del script y se volverá al código que llamó al script. sin embargo, si se usa esta sentencia en un bloque de código dentro de un objeto, el flujo saldrá enteramente del evento aun cuando haya distintos bloques de código separados después de que la función se haya llamado. Por lo regular se usa para impedir que una instancia ejecute cierto bloque de código, por ejemplo, un evento de colisión. El código siguiente proporciona un ejemplo:
{
if invisible exit:
while (place_meeting(x, y))
{
x -= lengthdir_x(1, direction - 180);
y -= lengthdir_y(1, direction - 180);
}
}
El código anterior prueba una variable, y si resulta verdadera, entonces se sale del bloque de código, de otra manera continúa ejecutando el código restante.
Una definición popular de una función es que es un bloque de código que tiene una entrada y arroja una salida, y la salida está relacionada de alguna manera con la entrada. En GameMaker:Studio las funciones se usan como parte de un programa para realizar muy diversas tareas, y hay un gran número de funciones GML disponibles, todas ellas explicadas en el manual.
En GML, una función tiene la forma de un nombre de función, seguido por los argumentos de entrada entre paréntesis y separados por comas (si la función no tiene argumentos de entrada, se usan sólo los paréntesis). La estructura general de una función tiene la forma:
<function>(<arg0>, <arg1> ,... <arg15>);
Hay dos tipos de funciones. Una es la vasta colección de funciones predefinidas usadas para controlar casi cualquier aspecto del juego, y la otra son los scripts creados por el usuario, que en ocasiones (no siempre) pueden ser usados como una función.
Algunas funciones devuelven valores que pueden ser usados en expressiones, otras simplemente ejecutan una serie de comandos. Se debe notar el hecho de que no es posible usar una función como el miembro izquierdo de una asignación, es decir, no puedes escribir algo como:
instance_nearest(x, y, obj).speed = 0;
pues el valor devuelto (de la función) es un número real, y por lo tanto debe encerrarse entre paréntesis (para mayor información, consulta la sección Accediendo a variables desde otras instancias), por lo que el código debe ser reescrito como:
(instance_nearest(x,y,obj)).speed = 0;