Estas son las funciones disponibles para trabajar con números reales:

random(x) Devuelve un valor entre 0 y X. El valor devuelto es siempre menor que X.

choose(val1,val2,val3,...) Devuelve uno de argumentos de forma aleatoria. La función acepta un máximo de 16 argumentos.

abs(x) Devuelve el valor absoluto de X.

sign(x) Devuelve el signo de X (-1, 0 o 1).

round(x) Devuelve el valor de X  redondeado al valor entero más cercano.

floor(x) Devuelve el valor de X redondeado hacia abajo.

ceil(x) Devuelve el valor de X redondeado hacia arriba.

frac(x) Devuelve la parte fraccional de X,  que es la parte situada tras el punto decimal.

sqrt(x) Devuelve la raíz cuadrada de X.  El valor no debe ser negativo.

sqr(x) Devuelve el cuadrado de X.

power(x,n) Devuelve X elevado a la potencia N.

exp(x) Devuelve  E elevado a X.

ln(x) Devuelve el logaritmo neperiano (natural) de X.

log2(x) Devuelve el logaritmo en base 2 de X.

log10(x) Devuelve el logaritmo en base 10 de X.

logn(n,x) Devuelve el logaritmo en base N de X.

sin(x) Devuelve el seno de X (X en radianes).

cos(x) Devuelve el coseno de X (X en radianes).

tan(x) Devuelve la tangente de X (X en radianes).

arcsin(x) Devuelve el arcoseno de X.

arccos(x) Devuelve el arcocoseno de X.

arctan(x) Devuelve la arcotangente de X.

arctan2(y,x) Calcula la arcotangente de (Y/X), y devuelve un ángulo en el cuadrante correcto.

degtorad(x) Convierte grados a radianes.

radtodeg(x) Convierte radianes a grados.

min(val1,val2,val3,...) Devuelve el menor de los valores. La función soporta 16 argumentos. Deben ser todos números reales o cadenas de texto.

max(val1,val2,val3,...) Devuelve el mayor de los valores. La función soporta 16 argumentos. Deben ser todos números reales o cadenas de texto.

mean(val1,val2,val3,...) Devuelve el promedio de los valores. La función soporta 16 argumentos. Deben ser todos números reales.

median(val1,val2,val3,...) Devuelve el valor intermedio de los argumentos introducidos. (Cuando el número de argumentos  es parejo, el menor de los dos valores intermedios, es el que devuelve la función. La función soporta 16 argumentos. Deben ser todos números reales.

point_distance(x1,y1,x2,y2) Devuelve la distancia existente entre el punto situado en (x1,y1) y el situado en (x2,y2).

point_direction(x1,y1,x2,y2) Devuelve la dirección desde el punto (x1,y1) hacia el punto (x2,y2) en grados.

lengthdir_x(len,dir) Devuelve la componente horizontal (x) del vector determinado por  la longitud y dirección indicadas.

lengthdir_y(len,dir) Devuelve la componente vertical (y) del vector determinado por  la longitud y dirección indicadas.

is_real(x) Averigua cuando X es un valor real.  (diferenciándolo de una cadena de texto).

is_string(x) Averigua cuando X es una cadena de texto.  (diferenciándolo de un número real).

CADENAS DE TEXTO

Estas son las funciones disponibles para trabajar con cadenas de texto:

chr(val) Devuelve una cadena con el carácter al que hace referencia el código asci VAL.

ord(str) Devuelve el código asci del primer carácter de la cadena de texto STR.

real(str) Convierte una cadena de texto  en un número real. STR puede contener signos negativos,  puntos decimales o una parte exponencial.

string(val) Convierte el número real en una cadena de texto utilizando el formato estándar (sin decimales cuando se trata de un número entero y un máximo de dos dígitos decimales en cualquier otro caso).

string_format(val,tot,dec) Convierte VAL en una cadena de texto utilizando nuestro propio formato: TOT indica el máximo de dígitos y DEC el número de dígitos decimales.

string_length(str) Devuelve el número de caracteres de la cadena.

string_pos(substr,str) Devuelve la posición de SUBSTR en STR (0 No encontrado).

string_copy(str,index,count) Devuelve una subcadena de STR, partiendo de la posición INDEX y de una longitud definida por COUNT.

string_char_at(str,index) Devuelve el carácter  situado en la posición INDEX de la cadena STR.

string_delete(str,index,count) Devuelve una copia de la cadena STR con una parte borrada, que empieza en INDEX y de una longitud definida por COUNT.

string_insert(substr,str,index) Devuelve una copia de la cadena STR con la subcadena SUBSTR añadida en la posición INDEX.

string_replace(str,substr,newstr) Devuelve una copia de STR con la primera ocurrencia de SUBSTR reemplazada por NEWSTR.

string_replace_all(str,substr,newstr) Devuelve una copia de STR con todas las ocurrencias encontradas de SUBSTR reemplazadas por la subcadena NEWSTR.

string_count(substr,str) Devuelve el número de ocurrencias de la subcadena SUBSTR existentes en STR.

string_lower(str) Devuelve una copia en minúsculas de la cadena STR.

string_upper(str) Devuelve una copia en mayúsculas de la cadena STR.

string_repeat(str,count) Devuelve una cadena con un número de copias de la cadena STR definido por COUNT.

string_letters(str) Devuelve una cadena de texto que solo contiene las letras de la cadena STR.
string_digits(str) Devuelve una cadena que solo contiene los números de la cadena STR.

string_lettersdigits(str) Devuelve una cadena que solo contiene los números y las letras de la cadena STR.

TIEMPO Y FECHA

Game Maker dispone de varias funciones para trabajar con fechas y horas. La fecha y la hora se almacenan como un número real. La parte entera es el número de días que han pasado desde 12/30/1899 y parte decimal de este valor es la fracción de un día de 24 horas que ha transcurrido hasta el momento. Estas son las funciones disponibles:

date_current_datetime()Devuelve fecha y hora actual.
date_current_date()Devuelve fecha actual ignorando la hora

.date_current_time()Devuelve hora actual ignorando la fecha.
date_create_datetime(year,month,day,hour,minute,second) Crea un valor fecha-hora correspondiente a la fecha y hora indicados.
date_create_date(year,month,day) Crea un valor fecha-hora correspondiente a la fecha indicada.
date_create_time(hour,minute,second) Crea un valor fecha-hora correspondiente a la hora indicada.
date_valid_datetime(year,month,day,hour,minute,second) Muestra si la hora y fecha indicados son válidos.
date_valid_date(year,month,day) Muestra si la fecha indicada es válida.
date_valid_time(hour,minute,second) Muestra si la hora indicada es válida.
date_inc_year(date,amount) Devuelve una nueva fecha N años después de la fecha indicada. N debe ser un número entero.
date_inc_month(date,amount) Devuelve una nueva fecha N meses después de la fecha indicada. N debe ser un número entero.
date_inc_week(date,amount) Devuelve una nueva fecha N semanas después de la fecha indicada. N debe ser un número entero.
date_inc_day(date,amount) Devuelve una nueva fecha N días después de la fecha indicada. N debe ser un número entero.
date_inc_hour(date,amount) Devuelve una nueva fecha  N horas después de la fecha indicada. N debe ser un número entero.
date_inc_minute(date,amount) Devuelve una nueva fecha N minutos después de la fecha indicada. N debe ser un número entero.
date_inc_second(date,amount) Devuelve una nueva fecha N segundos después de la fecha indicada. N debe ser un número entero.
date_get_year(date) Devuelve el año actual.
date_get_month(date) Devuelve el mes actual.

date_get_week(date) Devuelve la semana actual.
date_get_day(date) Devuelve el día actual.
date_get_hour(date) Devuelve la hora actual.
date_get_minute(date) Devuelve el minuto actual.
date_get_second(date) Devuelve el segundo actual.
date_get_weekday(date) Devuelve el día de la semana actual.
date_get_day_of_year(date) Devuelve el día del año especificado.
date_get_hour_of_year(date) Devuelve la hora del año especificado.
date_get_minute_of_year(date) Devuelve el minuto del año especificado.
date_get_second_of_year(date) Devuelve el segundo del año especificado.
date_year_span(date1,date2) Devuelve el número de años que hay entre las dos fechas. Reporta los años incompletos como una fracción.
date_month_span(date1,date2) Devuelve el número de meses que hay entre las dos fechas. Reporta los meses incompletos como una fracción.
date_week_span(date1,date2) Devuelve el número de semanas que hay entre las dos fechas. Reporta las semanas incompletas como una fracción.
date_day_span(date1,date2) Devuelve el número de días que hay entre las dos fechas. Reporta los días incompletos como una fracción.
date_hour_span(date1,date2) Devuelve el número de horas que hay entre las dos fechas. Reporta las horas incompletas como una fracción.
date_minute_span(date1,date2) Devuelve el número de minutos que hay entre las dos fechas. Reporta los minutos incompletos como una fracción.
date_second_span(date1,date2) Devuelve el número de segundos que hay entre las dos fechas. Reporta los segundos incompletos como una fracción.
date_compare_datetime(date1,date2) Compara los dos valores fecha-hora. Devuelve -1, 0, ó 1 dependiendo en si la primera fecha es anterior, igual, o posterior que  la segunda. 
date_compare_date(date1,date2) Compara los dos valores fecha-hora tomando en cuenta sólo la parte de la fecha. Devuelve -1, 0, ó 1 dependiendo en si la primera es anterior, igual, o posterior que la segunda.
date_compare_time(date1,date2) Compara los dos valores fecha-hora tomando en cuenta sólo la parte de la hora. Devuelve -1, 0, ó 1 dependiendo en si la primera es anterior, igual, o posterior que la segunda.
date_date_of(date) Devuelve la parte de la fecha del valor fecha-hora indicado, estableciendo la hora a 0.
date_time_of(date) Devuelve la hora del valor fecha-hora indicado, estableciendo la fecha a 0.

date_datetime_string(date) Devuelve una cadena indicando la fecha y hora definidos, en el formato predeterminado para el sistema.
date_date_string(date) Devuelve una cadena indicando la fecha definida en el formato predeterminado para el sistema.
date_time_string(date) Devuelve una cadena indicando la hora definida en el formato predeterminado para el sistema.
date_days_in_month(date) Devuelve el número de días que hay en el mes indicado.
date_days_in_year(date) Devuelve el número de días que hay en el año indicado.
date_leap_year(date) Define si el año indicado es un año bisiesto.
date_is_today(date) Define si la fecha indicada es la actual.

GAME PLAY

MOVIENDOSE

Obviamente, un aspecto importante de los juegos es el movimiento de las instancias de los objetos. Cada instancia tiene dos variables internas x e y que indican la posición de la instancia. (Para ser precisos, indican el lugar donde se encuentra el punto de origen del sprite). La posición (0,0) es la esquina superior izquierda del cuarto. Puedes cambiar la posición de la instancia al cambiar los valores de sus variables x e y. Es lo que debes hacer si deseas movimientos más complicados. Este código normalmente se coloca en el evento step del objeto.

Si el objeto se mueve con velocidad y dirección constantes, hay una manera más fácil de lograrlo. Cada instancia tiene una velocidad horizontal (hspeed) y vertical (vspeed). Ambas se indican en píxeles por paso (step). Una velocidad horizontal positiva indica movimiento a la derecha, una velocidad horizontal negativa indica movimiento a la izquierda. La velocidad vertical positiva es movimiento hacia abajo y la negativa indica movimiento hacia arriba. Por lo que sólo debes establecer estos valores una vez (por ejemplo en el evento de creación) para dar al objeto un movimiento constante.

Hay otra manera muy diferente de especificar el movimiento, usando dirección (en grados 0-359), y velocidad (no debe ser negativa). Puedes configurar y leer estas variables para especificar un movimiento arbitrario. (Internamente se convierte a valores de hspeed y vspeed). También tenemos la fricción y la gravedad, y la dirección de la gravedad.

Finalmente, tenemos la función motion_add(dir,speed) para agregar movimiento al actual.

Para concluir, cada instancia tiene las siguientes variables y funciones referentes a su posición y movimiento:

x Su posición x.

y Su posición y.

xprevious Su posición x anterior.

yprevious Su posición y previa.

xstart Su posición x inicial en el cuarto.

ystart Su posición y inicial en el cuarto.

hspeed Componente horizontal de la velocidad.

vspeed Componente vertical de la velocidad.

direction Su dirección actual (0-360, contra las manecillas del reloj, 0 = a la derecha).

speed Su velocidad actual (píxeles por step).

friction Fricción actual (píxeles por step).

gravity Cantidad actual de gravedad (píxeles por paso).

gravity_direction Dirección de la gravedad (270 es hacia abajo).

motion_set(dir,speed) Establece el movimiento a la velocidad speed y la dirección dir.

motion_add(dir,speed) Agrega el movimiento al movimiento actual (como una suma vectorial).

Existe  un gran número de funciones para ayudarte a definir el movimiento:

place_free(x,y) Devuelve si la instancia colocada en la posición (x, y) está libre de colisión. Normalmente se emplea para revisar antes de mover la instancia a la nueva posición.

place_empty(x,y) Devuelve si la instancia colocada en la posición (x, y) no se encuentra con nadie. Esta función también toma en cuenta las instancias no sólidas.

place_meeting(x,y,obj) Devuelve si la instancia colocada en la posición (x,y) se encuentra con un el objeto obj. obj puede ser un objeto en cuyo caso la función devuelve verdadero si se encuentra con una instancia de ese objeto. También puede ser el id de una instancia, o la palabra especial other.

place_snapped(hsnap,vsnap) Devuelve si la instancia está alineada con los valores de snap hsnap y vsnap.

move_random(hsnap,vsnap) Mueve la instancia a una posición libre, y la alinea con los valores hsnap y vsnap,  al igual que la acción correspondiente.

move_snap(hsnap,vsnap) Alinea la instancia, como la acción correspondiente.

move_wrap(hor,vert,margin) Teleporta la instancia cuando sale del room al lado opuesto. hor indica si debe teleportarse horizontalmente y vert indica si debe teleprotarse verticalmente. margin indica cuánto debe salir el origen de la instancia del room para teleportarse (es decir, un margen alrededor del room). Esta función se usa normalmente el evento Outside.
move_towards_point(x,y,sp) Mueve la instancia con velocidad sp hacia el punto (x,y).

move_bounce_solid(adv) Rebotar contra objetos sólidos, como la acción correspondiente. adv indica si se emplea rebote avanzado, que toma en cuenta las paredes inclinadas.

move_bounce_all(adv) Rebotar contra todas las instancias, en lugar de sólo con las sólidas.

move_contact_solid(dir,maxdist) Mover la instancia en la dirección dir hasta que haya contacto con un objeto sólido. Si no hay collision en la posición actual, la instancia es colocada justo antes de donde ocurre una colisión. Si ya hay una colisión en la posición actual, la instancia no se mueve. Puedes especificar la distancia máxima a mover la instancia maxdist(emplea un número negativo para indicar distancia arbitraria).

move_contact_all(dir,maxdist) Igual que la función anterior pero esta vez se detiene hasta que haya contacto con cualquier objeto, no solo sólidos.

move_outside_solid(dir,maxdist) Mueve la instancia en la dirección dir hasta que no esté al alcance de un objeto sólido. Si no hay collision en la posición actual, no se mueve la instancia. Puedes especificar la distancia máxima a mover (usa un valor negativo para indicar una distancia arbitraria).

move_outside_all(dir,maxdist) Igual que la anterior pero se mueve hasta estar fuera de alcance de cualquier objeto, no solo objetos sólidos.

distance_to_point(x,y) Devuelve la distancia de la caja límite de la instancia actual hacia el punto (x,y).

distance_to_object(obj) Devuelve la distancia de la instancia actual a la instancia más cercana del objeto obj.

position_empty(x,y) Indica si no hay nada en la posición (x,y).

position_meeting(x,y,obj) Indica si en la posición (x,y) hay una instancia obj. obj puede ser un objeto, una id de una instancia, o las palabras clave self, other o all.

PATHS

En Game Maker puedes definir caminos o trayectorias (paths) y ordenar a las instancias que los sigan. Aunque puedes usar las acciones para esto, existen funciones que te dan más flexibilidad:

path_start(path,speed,endaction,absolute) Comienza un path para la instancia actual. path  es el nombre del path que deseas iniciar. speed es la velocidad  con la que la instancia debe moverse por el path (una velocidad negativa indica que la instancia se moverá al revés sobre el path). endaction indica que debería ocurrir cuando la instancia llegue al final del camino. Puedes usar los siguientes valores para esto:

0 : parase
1: continuar desde la posición inicial del path (s el path no está cerrado saltamos a la posición inicial)
2: continuar desde la posición inicial
3: recorrer el path al revés (cambia el signo de la velocidad)

El argumento absolute debe ser true o false. Cuando es true se usan las coordenadas absolutas del path. Cuando es false el path es relativo a la posición actual de la instancia. Para ser más precisos, si la velocidad es positiva el punto inicial del path se colocará en la posición actual de la instancia y se seguirá desde ahí. Cuando la velocidad es negativa, el punto final del path se colocará en la posición de la instancia y el path se seguirá al revés desde ahí. 
path_end() Termina el path para la instancia actual.
path_index* Índice del path que la instancia sigue. No se puede cambiar directamente, debes utilizar la función path_start(path,speed,endaction,absolute).
path_position Posición en el path actual. 0 es el principio del path y 1 es el final. Los valores deben estar entre 0 y 1. 
path_positionprevious Posición previa en el path. Esto se puede usar en eventos de colisión para colocar la instancia en la posición anterior antes de una colisión.
path_speed Velocidad (en píxels por paso) con la que la instancia sigue el path. Con una velocidad negativa el path se recorre en sentido inverso. 
path_orientation Orientación (antihoraria) en la que se realiza el path. 0 es la orientación normal del path.
path_scale Escala del path. Auméntala para hacer el path más grande. 1 es el valor normal del path. 
path_endaction La acción que se debe ejecutar al finalizar el path. Puedes indicar los valores explicados más arriba.

PLANIFICACION DE MOVIMIENTO

La planificación del movimiento te ayuda a mover una instancia de un punto a otro esquivando otras instancias que pudiera encontrarse por el camino (por ejempo, paredes). Resulta imposible dar funciones generales que funcionen en cualquier situación. Así mismo, las operaciones necesarias para calcular un camino libre de colisiones consumen bastantes recursos, así que debes usar estas funciones con criterio. Ten todo esto en cuenta cuando uses las siguientes funciones.

Game Maker dispone de diferentes formas de planificar el movimiento. La más simple consiste en hacer que una instancia de un paso hacia la posición final, intentando ir en línea recta pero tomando otra dirección si esto último resulta imposible. Estas funciones deben usarse en el evento step de la instancia y se corresponden a las acciones ya comentadas:

mp_linear_step(x,y,stepsize,checkall) Esta función hace que la instancia de un paso hacia la posición (x,y). La longitud del paso se indica con el parámetro stepsize. Si la instancia ya ha llegado a esa posición no se moverá. Si checkall es true la instancia se parará cuando choque con una instancia de cualquier objeto. Si es false, sólo se parará al chocar con un objeto sólido. Esta función no propone un camino alternativo, simplemente se parará si encuentra un obstáculo. La función devuelve si se ha alcanzado el destino. 
mp_linear_step_object(x,y,stepsize,obj) Igual que la anterior, pero esta vez sólo se tienen en cuenta las instancias del objeto obj. obj puede ser un objeto o una id de una instancia particular.
mp_potential_step(x,y,stepsize,checkall) Igual que las anteriores, pero en este caso la instancia intentará esquivar los obstáculos que encuentre. Cuando la instancia se choque con un obstáculo cambiará su dirección para tratar de esquivar el objeto, moviéndose alrededor de él. Puede que no siempre se consiga llegar a la meta, pero la función siempre intentará acercar lo más posible a la instancia. Devuelve true si se llega a la meta.
mp_potential_step_object(x,y,stepsize,obj) ) Igual que la anterior, pero esta vez sólo se tienen en cuenta las instancias del objeto obj. obj puede ser un objeto o una id de una instancia particular.
mp_potential_settings(maxrot,rotstep,ahead,onspot) La función anterior hace su trabajo usando un número de parámetros que pueden ser cambiados con esta función. El método funciona como sigue: primero la instancia intenta moverse en línea recta hacia la meta. Para ello, mira un número de pasos adelante para ver si hay algún obstáculo. Este número de pasos corresponde al valor ahead (por defecto 3). Reduciendo este valor la instancia comenzará a cambiar su dirección más tarde si encuentra un obstáculo. Aumentándolo cambiará antes de dirección. Si detectamos una colisión, la función mira a la derecha y a la izquierda para encontrar un camino libre. Esto se realiza en pasos de tamaño rotstep (por defecto 10). Reduciéndolo conseguimos que la instancia tenga más posibilidades para moverse pero la función será más lenta. El parámetro maxrot (por defecto 30) indica cuánto puede cambiar como máximo la dirección en un paso. Así que aunque pueda moverse en línea recta hacia la meta no lo hará si debe girar más de lo indicado por este parámetro. Aumentándolo conseguimos que la instancia pueda girar más en cada paso, haciendo que sea más fácil encontrar un camino aunque éste será menos uniforme. Disminuyendo su valor el camino será más suave pero la instancia realizará giros más largos, haciendo que a veces no pueda llegar exactamente a la meta. Cuando la instancia no se puede mover en ninguna dirección el comportamiento dependerá del valor de onspot. Si onspot es true la instancia rotará en su posición la cantidad indicada por maxrot. Si es false se parará (esto es útil para coches, por ejemplo, pero reduce las posibilidades de encontrar un camino hacia la meta).

Observa que el acercamiento potencial sólo usa información local. Así que sólo encontrará un camino si la información es suficiente para determinar la dirección correcta. Por ejemplo, normalmente no podrá encontrar el camino para escapar de un laberinto.

El segundo tipo de funciones calcula un camino libre colisiones. Una vez que el camino se ha calculado puedes asignárselo a la instancia para que se mueva hacia la meta como si fuera un path normal que tú hubieras creado. El cálculo del camino tarda un poco pero una vez hecho la ejecución del path es muy rápida. Por supuesto, esto es válido si la situación no cambia (por ejemplo, si los obstáculos se mueven). Entonces necesitarás volver a calcular el path. De nuevo, estas funciones pueden fallar en algunas circunstancias. Estas funciones sólo están disponibles en la versión registrada de Game Maker.

Las dos primeras funciones usan el acercamiento por movimiento lineal y potencial que se usan en las funciones anteriores.

mp_linear_path(path,xg,yg,stepsize,checkall) Calcula un path en línea recta para la instancia desde su posición hasta (xg,yg) usando el paso especificado en stepsize. Usa pasos como en la función mp_linear_step(). El path indicado debe existir con anterioridad a la llamada de la función y será sobreescrito por el nuevo path (consulta el capítulo sobre cómo crear y destruir paths). La función devuelve si se ha encontrado un path. Si no consigue encontrar un camino, la función devolverá un path hasta la posición donde la instancia quedó bloqueada.

mp_linear_path_object(path,xg,yg,stepsize,obj) Igual que la anterior, pero esta vez sólo se tienen en cuenta las instancias del objeto obj. obj puede ser un objeto o una id de una instancia particular.
mp_potential_path(path,xg,yg,stepsize,factor,checkall) Esta función calcula un camino para instancia desde su posición actual y orientación hasta (xg,yg) usando el paso especificado en stepsize e intentando evitar colisionar con los obstáculos. Utiliza pasos potenciales como la función mp_potential_step() y los parámetros se pueden configurar con mp_potential_settings(). El path indicado debe existir con anterioridad a la llamada de la función y será sobreescrito por el nuevo path (consulta el capítulo sobre cómo crear y destruir paths). La función devolverá si se ha encontrado un camino. Para evitar que la función continúe calculando para siempre debes especificar un factor mayor que 1. La función se detendrá y devolverá un mensaje de error si no puede  encontrar un camino que sea más corto que la distancia del origen a la meta multiplicada por factor. Un factor de 4 es normalmente suficiente pero si crees que la instancia tendrá un camino largo puedes aumentarlo. Si la función falla se crea el camino en dirección a la meta pero la instancia no llegará  la meta.
mp_potential_path_object(path,xg,yg,stepsize,factor,obj) Igual que la anterior, pero esta vez sólo se tienen en cuenta las instancias del objeto obj. obj puede ser un objeto o una id de una instancia particular.

 

Las demás funciones usan un mecanismo mucho más complejo basado en rejillas (un algoritmo A*). Tiene más sexito a la hora de encontrar caminos y hacerlos más cortos, pero requiere más trabajo por tu parte. Además, también puede fallar en algunas ocasiones. El funcionamiento es como sigue: primero situamos una rejilla sobre la parte del cuarto afectada. Puedes usar si quieres usar una rejilla fina (más lento) o más espaciada. Después, determinamos las celdas de la rejilla ocupadas por objetos relevantes (usando colisión precisa o la caja de contorno) y marcamos estas celdas como prohibidas. Así que una celda estará prohibida si parte de un obstáculo la está ocupando. Finalmente especificamos la posición inicial y final, que deben estar en celdas libres de la rejilla y la función calcula el camino más corto entre ellas. El camino irá de centro a centro de las celdas libres. Así que las celdas deben ser lo suficientemente grandes como para que la instancia entre totalmente dentro de ellas. Ahora puedes asignar el path a una instancia y hacer que lo siga.

Este sistema es muy potente (se usa en muchos juegos profesionales) pero requiere que lo planifiques con cuidado. Debes determinar la zona del cuarto sobre la que situar la rejilla y el tamaño de las celdas con la mayor precisión posible. También debes decidir qué objetos deben tomarse en cuenta y si es necesaria la colisión precisa o no. Todos estos parámetros afectan de manera muy notable a la eficiencia del método.

En particular, el tamaño de las celdas es crucial. Recuerda que las celdas deben lo suficientemente grandes como para que la instancia que se mueve entre totalmente dentro de ellas (ten cuidado con la posición del origen de la instancia y recuerda que puedes mover el path para hacer que el centro del objeto coincida con el centro de la celda). Por otro lado, cuanto menores sean las celdas más caminos diferentes podrás encontrar. Si haces las celdas demasiado grandes puede que unos pocos objetos ocupen todas las celdas cerrando todos los caminos posibles.

Las funciones para el método de rejilla son:

mp_grid_create(left,top,hcells,vcells,cellwidth,cellheight) Esta función crea la rejilla. Devuelve un índice que debe ser usado en las demás funciones. Puedes crear y mantener varias rejillas al mismo tiempo. left y top indican la posición de la esquina superior izquierda de la rejilla y hcells y vcells indican el número de celdas horizontales y verticales respectivamente. Finalmente, cellwidth y cellheight indican la anchura y altura de las celdas.

mp_grid_destroy(id) Destruye la rejilla indicada y libera la memoria usada. No olvides llamar a esta función cuando no necesites usar más la rejilla. 
mp_grid_clear_all(id) Marca todas las celdas como libres. 
mp_grid_clear_cell(id,h,v) Marca la celda indicada como libre (la primera celda es la 0,0).
mp_grid_clear_rectangle(id,left,top,right,bottom) Marca como libres todas las celdas que intersectan el rectángulo definido en coordenadas absolutas del cuarto.
mp_grid_add_cell(id,h,v) Marca ls celdas indicadas como prohibidas.
mp_grid_add_rectangle(id,left,top,right,bottom) Marca todas las celdas que intersectan el rectángulo como prohibidas.
mp_grid_add_instances(id,obj,prec) Marca todas las celdas que intersectan una instancia del objeto indicado como prohibidas. También puedes especificar una id de una instancia concreta, o la palabra clave all para indicar todas las instancias. prec indica si hay que usar colisión precisa (sólo funcionará si en el sprite de la instancia está activada la misma opción).
mp_grid_path(id,path,xstart,ystart,xgoal,ygoal,allowdiag) Calcula el path a través de la rejilla. El path indicado debe existir con anterioridad a la llamada de la función y será sobreescrito por el nuevo path (consulta el capítulo sobre cómo crear y destruir paths). xstart e ystart indican el comienzo del path y xgoal e ygoal las coordenadas de la meta. allowdiag indica si se permiten movimientos diagonales entre celdas o sólo horizontales y verticales. La función devuelve si consiguió calcular un path (observa que el path es independiente de la instancia actual). 
mp_grid_draw(id) Esta función dibuja la rejilla marcando las celdas libres y prohibidas (muy útil para buscar errores).

DETECCION DE COLISIONES

Al planificar movimientos o decidir ciertas acciones es importante comprobar si ocurren colisiones con otras instancias en otras posiciones. Las funciones siguientes se utilizan para esto. Todas ellas tienen 3 argumentos en común: el argumento obj puede ser un objeto, la palabra clave all, o la id de una instancia. El argumento prec indica si se debe usar colisión precisa o la caja de contorno de la instancia (la colisión precisa sólo funciona si el sprite de la instancia tiene activada la misma opción). El argumento notme indica si no se debe tener en cuenta a la instancia que llama a la función. Todas estas funciones devuelven la id de una de las instancias con las que se detecta colisión. Si no hay colisión devuelven un valor negativo.

collision_point(x,y,obj,prec,notme) Comprueba si hay una colisión en el punto (x,y) con instancias del objeto obj. 
collision_rectangle(x1,y1,x2,y2,obj,prec,notme) Comprueba si hay una colisión  entre el rectángulo (sólido) con las esquinas indicadas e  instancias del objeto obj. Por ejemplo, puedes usar esta función para ver si un área está libre de obstáculos.
collision_circle(xc,yc,radius,obj,prec,notme) Comprueba si hay una colisión  entre la circunferencia (sólido) con centro (xc,yc) y radio r e  instancias del objeto obj. Puedes usar esta función para ver si un objeto está cerca de una posición. 
collision_ellipse(x1,y1,x2,y2,obj,prec,notme) Comprueba si hay una colisión  entre la elipse (sólida) con las esquinas indicadas e  instancias del objeto obj. 
collision_line(x1,y1,x2,y2,obj,prec,notme) Comprueba si hay una colisión  entre la línea que va de (x1,y1) a (x2,y2) e instancias del objeto obj. Esta función es muy poderosa. Puedes usarla para comprobar si una instancia puede ver a otra chequeando si entre ellas hay una pared.

INSTANCIAS

Las unidades básicas del juego son las instancias. Durante el juego, puedes cambiar varios aspectos de estas instancias. También puedes crear o destruir instancias. Además de las variables de movimiento y las de dibujo cada instancia posee las siguientes variables:

object_index* Índice del objeto del cual ésta es una instancia. No se puede cambiar. 
id* La id única de la instancia (>= 100000) (Al definir cuartos la id de la instancia bajo el puntero del ratón es indicada). No se puede cambiar.
mask_index Índice de l sprite usado como máscara para las colisiones. Si indicas -1 la máscara será igual al sprite de la instancia. 
solid Indica si la instancia es sólida o no. 
persistent Indica si la instancia es persistente y reaparecerá al moverse a otro cuarto. A veces puedes querer volver a ponerlo a 0 (por ejemplo, al volver al primer cuarto).

Al trabajar con instancias hay un problema: no es fácil identificar una instancia concreta. No tienen un nombre. Cuando sólo hay una instancia de un objeto puedes acceder a ella usando el nombre del objeto pero normalmente necesitas conocer la id de la instancia. Este identificador único se puede usar en construcciones with y para identificar la instancia. Afortunadamente, las siguientes variables te ayudan a localizar la id de una instancia:

instance_count* Número de instancias que existen en el cuarto.
instance_id[0..n-1]* La id de la instancia número n.

Observa que la asignación de las instancias al instance_id[] cambia en cada step, así que debes actualizar este valor. Por ejemplo: imagina que cada unidad en tu juego tiene un poder y quieres encontrar la más poderosa de todas. Puedes hacerlo con el siguiente código:

{

  maxid = -1;

  maxpower = 0;

  for (i=0; i<instance_count; i+=1)

  {

    iii = instance_id[i];

    if (iii.object_index == unit)

    {

      if (iii.power > maxpower)

        {maxid = iii; maxpower = iii.power;}

    }

  }

}

Después del bucle maxid contendrá la id de la instancia más podersa (No destruyas instancias durante un bucle como éste porque se eliminarán inmediatamente y te saltarás instancias existentes).

instance_find(obj,n) Devuelve la id de la instancia n+1 de tipo obj. obj puede ser un objeto o la palabra clave all. Si no existe se devuelve el objeto especial noone. Recuerda que el orden de las instancias cambia en cada step así que no puedes usar valores de steps anteriores. 
instance_exists(obj) Devuelve si existe alguna instancia del objeto obj. obj puede ser un objeto, la id de una instancia  o la palabra clave all. 
instance_number(obj) Devuelve el número de instancias de tipo obj. obj puede ser un objeto o la palabra clave all. 
instance_position(x,y,obj) Devuelve la id de la instancia de tipo obj en la posición (x,y). Cuando hay varias instancias en esa posición se devuelve la id de la prtimera. obj puede ser un objeto o la palabra clave all. Si no existe se devuelve el objeto especial noone
instance_nearest(x,y,obj) Devuelve la id de la instancia de tipo obj que esté más cercana en ese momento a (x,y). obj puede ser un objeto o la palabra clave all.

instance_furthest(x,y,obj) Devuelve la id de la instancia de tipo obj que esté más lejana en ese momento a (x,y). obj puede ser un objeto o la palabra clave all.
instance_place(x,y,obj) Devuelve la id de la instancia de tipo obj encontrada cuando la instancia actual se coloca en la posición (x,y). obj puede ser un objeto o la palabra clave all. Si no existe se devuelve el objeto especial noone.

Las siguientes funciones se usan para crear y destruir instancias:

instance_create(x,y,obj) Crea una instancia de obj en la posición (x,y). La función devuelve la id de la nueva instancia creada.
instance_copy(performevent) Crea una copia de la instancia actual. El argumento indica si se debe ejecutar el evento create en la nueva instancia. La función devuelve la id de la nueva copia. 
instance_destroy() Destruye la instancia actual.
instance_change(obj,perf) Cambia la instancia a una del tipo obj. perf indica si se deben ejecutar los eventos de destrucción y creación.
position_destroy(x,y) Destruye toda las instancias cuyo sprite pasa por el punto (x,y).
position_change(x,y,obj,perf) Cambia todas las instancias en la posición indicada a otras del tipo obj. perf indica si se deben ejecutar los eventos de destrucción y creación.

DESACTIVANDO INSTANCIAS

Cuando creas un cuarto muy grande, por ejemplo en juegos de plataformas, con una vista (view) muy pequeña, muchas instancias se quedan fuera de la vista. Aunque no sean visibles, estas instancias siguen ejecutando sus eventos. También, al efectuar chequeos de colisión son tomadas en cuenta. Esto puede hacer que el juego se ralentice. Para remediar esto, Game Maker contiene unas funciones para desactivar o activar instancias. Pero antes de usarlas debes entender cómo funcionan.

Cuando desactivas instancias es como si las eliminaras del juego. No son visibles, no ejecutan sus eventos,…así que para todas las funciones y acciones estas instancias ya no existen y no son tomadas en cuenta. Así consigues que el juego sea más rápido. Pero ten cuidado, ya que esto puede generar errores en tu juego. Por ejemplo, al eliminar todas las instancias de un objeto, las instancias que estén desactivadas no serán eliminadas! Así, una llave que recoja el jugador no podrá abrir una puerta que esté desactivada, por ejemplo.

El error más crucial que puedes hacer es el de desactivar la instancia que se encarga de activar las demás instancias. Para evitar esto algunas funciones permiten especificar si la instancia que desactiva a las demás debe ser desactivada o no.

Las rutinas disponibles son las siguientes:

instance_deactivate_all(notme) Desactiva todas las instancias del cuarto. Si notme es true la instancia actual no es desactivada (normalmente es lo que se desea).
instance_deactivate_object(obj) Desactiva todas las instancias en el cuarto del objeto especificado. También puedes indicar all para desactivar todas las instancias o la id de una instancia concreta para desactivarla. 
instance_deactivate_region(left,top,width,height,inside,notme) Desactiva todas las instancias en la región indicada (es decir, todas aquellas cuya caja de contorno está parcial o completamente dentro de la región indicada). Si inside es igual a false las instancias completamente fuera de la región son desactivadas. Si notme es true la instancia actual no es desactivada (normalmente es lo que se desea).
instance_activate_all() Activa todas las instancias del cuarto.
instance_activate_object(obj) Activa todas las instancias en el cuarto del objeto especificado. También puedes indicar all para activar todas las instancias o la id de una instancia concreta para activarla.
instance_activate_region(left,top,width,height,inside) Activa las instancias dentro de la región especificada. Si inside es false las instancias fuera de la región son activadas.

Por ejemplo, para desactivar todas las instancias fuera de la vista y activar las que estén dentro podemos poner este código en el evento step del personaje del jugador:

{

  instance_activate_all();

  instance_deactivate_region(view_xview[0],view_yview[0],

                        view_wview[0],view_hview[0],false,true);

}

Normalmente es mejor usar una región ligeramente mayor que la vista.

TIMING

Los buenos juegos requirieron de cuidado especial de los tiempos en que las cosas se llevaban a cabo (timing). Afortunadamente el Game Maker se ocupa de la mayor parte del timing por ti. Se asegura de que las cosas ocurran con un ritmo constante. Este ritmo es definido al definir los cuartos. Pero puedes cambiarlo usando la variable global room_speed. Así por ejemplo, puedes incrementar lentamente la velocidad del juego, haciéndolo más difícil, agregando una muy pequeña cantidad (como 0.001) a room_speed en cada step. Si tu máquina es lenta la velocidad del juego pudiera no alcanzarse. Esto puede comprobarse usando la variable fps que monitorea constantemente el número actual de cuadros por segundo. Finalmente, para un timing avanzado puedes usar la variable current_time que te da el número de milisegundos desde que la computadora fue iniciada. Aquí está la colección completa de variables disponibles (sólo la primera puede ser cambiada):

room_speed Velocidad del juego en el cuarto actual (en steps por segundo).

fps* Número de cuadros que son dibujados por segundo.

current_time* Número de milisegundos que han pasado desde que el sistema fue iniciado.

current_year* El año actual.

current_month* El mes actual.

current_day* El día actual.

current_weekday* El día actual de la semana (1=domingo, …, 7=sábado).

current_hour* La hora actual.

current_minute* El minuto actual.

current_second* El segundo actual.

Algunas veces querrás detener el juego por un corto periodo. Para esto, usa la función sleep:

sleep(numb) Pausa el juego durante numb milisegundos.

Como debes saber, cada instancia tiene 12 diferentes alarmas que puedes configurar. Para cambiar los valores (u obtener los valores) de las diferentes alarmas usa la siguiente variable:

alarm[0..11] Valor de la alarma indicada. (Nota: ¡las alarmas solo se actualizan cuando el evento de alarma para el objeto contiene acciones!)

Hemos visto que para los problemas de un timing complejo puedes usar el recurso de las líneas de tiempo (time lines). Cada instancia puede tener un recurso time line asociado con ella. Las siguientes variables están relacionadas con esto:

timeline_index Índice de la time line asociada con la instancia. Puedes

establecerlo a una time line en particular para usarla. Ponlo en –1 para dejar de usar la time line para la instancia.

timeline_position Posición actual dentro de la time line. Puedes cambiarla para saltar o repetir ciertas partes.

timeline_speed Normalmente, en cada step la posición en la time line se incrementa en 1. Puedes cambiar esta cantidad configurando esta variable a un valor diferente. Puedes usar números reales, por ejemplo 0.5. Si el valor es mayor que uno, varios momentos pueden ocurrir dentro del mismo tiempo del step. Se realizarán en el orden correcto, por lo que no se saltará ninguna acción.

ROOMS

Los juegos funcionan en cuartos. Cada cuarto tiene un índice que se indica por el nombre del cuarto. El cuarto actual es almacenado en la variable room. No puedes asumir que los cuartos están numerados en un orden consecutivo. Por lo que nunca sumes o restes un número de la variable room. En lugar de ello usa las funciones y variables indicadas abajo. Por lo que una típica pieza de código que usarás sería:

{

  if (room != room_last)

  {

    room_goto_next();

  }

  else

  {

    game_end();

  }

}

Las siguientes variables y funciones se relacionan con los cuartos (rooms).

room Índice del cuarto actual; puede cambiarse para ir a un cuarto diferente, pero mejor usa las rutinas listadas abajo.

room_first* Índice del primer cuarto en el juego.

room_last* Índice del ultimo cuarto en el juego.

room_goto(numb) Ir al cuarto con indice numb.

room_goto_previous()Ir al cuarto anterior.

room_goto_next()Ir al siguiente cuarto.

room_restart() Reiniciar el cuarto actual.

room_previous(numb)Devuelve el índice del cuarto anterior a numb (-1 = ninguno) pero no va a él.

room_next(numb) Devuelve el índice del cuarto posterior a numb (-1 =ninguno).

game_end() Finaliza el juego.

game_restart() Reinicia el juego.

Los cuartos tienen varias propiedades adicionales:

room_width* Ancho del cuarto en píxeles.

room_height* Alto del cuarto en píxeles.

room_caption Título de la ventana del cuarto.

room_persistent Indica si el cuarto es persistente.

Muchos juegos ofrecen al jugador la posibilidad de guardar el juego y cargar un juego guardado. En el Game Maker esto ocurre automáticamente cuando el jugador presiona <F5> para guardar y <F6> para cargar. También puedes guardar y cargar juegos desde una pieza de código (nota que la carga sólo se lleva a cabo al final del step actual).

game_save(string) Guarda el juego al archivo con nombre string.

game_load(string) Carga el juego del archivo con nombre string.

Ten en cuenta que sólo los datos básicos del juego son guardados. Por ejemplo, si guardas cuando una canción está sonando, al cargar el juego la canción no sonará desde ese momento. Los recursos editados tampoco son guardados, ni las partículas, los contenidos de las estructuras de datos ni la configuración multijugador.

SCORE

Otro aspecto importante de muchos juegos es el score (marcador), la energía, y el número de vidas. El Game Maker mantiene el score en la variable global score y el número de vidas en la variable global lives. Puedes cambiar el score simplemente cambiado el valor de esta variable. Lo mismo se aplica para la energía y las vidas. Si la variable lives es mayor que 0 y se vuelve menor o igual a 0 se ejecuta el evento no-more-lives para todas las instancias. Si no quieres mostrar el score y las vidas en el título, pon la variable show_score, etc., a falso. También puedes cambiar el títulodel marcador, de las vidas o de la energía. Para juegos más complicados mejor muestra el score tú mismo.

score El marcador actual.

lives El número de vidas.

health La energía actual (0-100).

show_score Indica si se muestra el marcador en el título de la ventana.

show_lives Indica si se muestra el número de vidas en el título de la ventana.

show_health Indica si se muestra la energía en el título de la ventana.

caption_score El título empleado para el marcador.

caption_lives El título empleado para el número de vidas.

caption_health El título para la energía.

GENERANDO EVENTOS

Como sabes, el Game Maker está completamente manejado por eventos. Todas las acciones ocurren como resultado de eventos. Hay una gran cantidad de eventos diferentes. Los eventos de creación y destrucción ocurren cuando una instancia es creada o destruida. En cada step, el sistema maneja primero los eventos de alarma. Después los eventos de teclado y ratón, y luego el siguiente evento step. Después de esto las instancias son colocadas en su nueva posición después de lo cual se maneja el evento de colisión. Finalmente el evento draw se usa para dibujar las instancias (nota que cuando empleas múltiples vistas el evento draw es llamado varias veces en cada step). También puedes aplicar un evento a la instancia actual desde una pieza de código. Se tienen las siguientes funciones:

event_perform(type,numb) Realiza el evento numb del tipo type para la instancia actual. Se pueden emplear los siguientes tipos de eventos:

ev_create
ev_destroy
ev_step
ev_alarm
ev_keyboard
ev_mouse
ev_collision
ev_other
ev_draw
ev_keypress
ev_keyrelease

Cuando hay varios eventos del tipo dado, numb puede usarse para especificar el evento preciso. Para el evento de alarma numb puede tener un valor de 0 a 11. Para el evento de teclado puedes usar el código de tecla para la tecla. Para los eventos de ratón puedes usar las siguientes constantes:

ev_left_button
ev_right_button
ev_middle_button
ev_no_button
ev_left_press
ev_right_press
ev_middle_press
ev_left_release
ev_right_release
ev_middle_release
ev_mouse_enter
ev_mouse_leave
ev_mouse_wheel_up
ev_mouse_wheel_down
ev_global_left_button
ev_global_right_button
ev_global_middle_button
ev_global_left_press
ev_global_right_press
ev_global_middle_press
ev_global_left_release
ev_global_right_release
ev_global_middle_release
ev_joystick1_left
ev_joystick1_right
ev_joystick1_up
ev_joystick1_down
ev_joystick1_button1
ev_joystick1_button2
ev_joystick1_button3
ev_joystick1_button4
ev_joystick1_button5
ev_joystick1_button6
ev_joystick1_button7
ev_joystick1_button8
ev_joystick2_left
ev_joystick2_right
ev_joystick2_up
ev_joystick2_down
ev_joystick2_button1
ev_joystick2_button2
ev_joystick2_button3
ev_joystick2_button4
ev_joystick2_button5
ev_joystick2_button6
ev_joystick2_button7
ev_joystick2_button8

Para el evento de collision proporcionas el índice del otro objeto. Finalmente, para el evento other puedes usar las siguientes constantes:

ev_outside
ev_boundary
ev_game_start
ev_game_end
ev_room_start
ev_room_end
ev_no_more_lives
ev_no_more_health
ev_animation_end
ev_end_of_path
ev_user0
ev_user1
ev_user2
ev_user3
ev_user4
ev_user5
ev_user6
ev_user7
ev_user8
ev_user9
ev_user10
ev_user11
ev_user12
ev_user13
ev_user14
ev_user15

 

Para el evento step puedes dar el índice usando las siguientes constantes:

ev_step_normal
ev_step_begin
ev_step_end

event_perform_object(obj,type,numb) Esta función funciona igual que la anterior pero esta vez puedes especificar eventos en otro objeto. Nota que las acciones en estos eventos se aplican a la instancia actual, no a las instancias del objeto dado.

event_user(numb) En los eventos other también puedes definir 16 eventos definidos por el usuario. Estos son ejecutados solo si llamas esta función. Numb debe tener valores de 0 a 11.

event_inherited() Ejecuta el evento heredado. Esto sólo funciona si la instancia tiene un objeto padre.

Puedes obtener información sobre el evento actualmente ejecutado usando las siguientes variables de sólo lectura:

event_type* El tipo del evento que se está ejecutando.

event_number* El número del evento que se está ejecutando.

event_object* El índice del objeto para el cual se está ejecutando el evento actual.

event_action* El índice de la acción que está siendo ejecutada (0 es la primera en el evento, etc.)

OTRAS VARIABLES Y FUNCIONES

Aquí puedes ver algunas variables y funciones que se refieren a los errores.

error_occurred Indica si ha ocurrido un error

error_last Cadena de texto que indica el último mensaje de error

show_debug_message(str) Muestra la cadena str en modo debug

Las siguientes funciones te permiten saber si ciertas variables existen, darles un valor o leerlo. En todas ellas el nombre de la variable se pasa como una cadena de texto:

variable_global_exists(name) Devuelve si la variable global con el nombre especificado existe. 
variable_local_exists(name) Devuelve si la variable local con el nombre especificado existe para la instancia actual. 
variable_global_get(name) Devuelve el valor de la variable global indicada. 
variable_global_array_get(name,ind) Devuelve el valor de índice ind del array global con el nombre indicado.
variable_global_array2_get(name,ind1,ind2) Devuelve el valor de índice ind1, ind2 del array bidimensional global con el nombre indicado.
variable_local_get(name) Devuelve el valor de la variable local indicada para la instancia actual.
variable_local_array_get(name,ind) Devuelve el valor de índice ind del array locall con el nombre indicado.
variable_local_array2_get(name,ind1,ind2) Devuelve el valor de índice ind1, ind2 del array bidimensional global con el nombre indicado.
variable_global_set(name,value) Otorga el valor indicado a la variable global especificada. 
variable_global_array_set(name,ind,value) Otorga el valor indicado al elemento ind del array global especificado.
variable_global_array2_set(name,ind1,ind2,value) Otorga el valor indicado al elemento ind 1, ind2 del array bidimensional global especificado.
variable_local_set(name,value) Otorga el valor indicado a la variable local especificada.
variable_local_array_set(name,ind,value) Otorga el valor indicado al elemento ind del array local especificado.
variable_local_array2_set(name,ind1,ind2,value) Otorga el valor indicado al elemento ind 1, ind2 del array bidimensional local especificado.

Por ejemplo, puedes escribir:

{

  if variable_global_exists('ammunition')

    global.ammunition += 1

  else

    global.ammunition = 0

}

También puees usar estas funciones para pasar variables a los scripts usando referencias, utilizando el nombre de las variables como cadenas de texto.

Puedes cambiar la prioridad del programa usando la función :

set_program_priority(priority) Cambia la prioridad del programa. Debes indicar un valor comprendido entre -3 y +3. Usando -3 el programa se ejecutará sólo si no hay otro proceso que requiera tiempo de computación. -2 y -1 son valores por debajo de lo normal, así que otros procesos tendrán prioridad sobre el juego. 0 es el valor normal. +1 y +2 son valores de alta prioridad, que pueden hacer que el juego se ejecute más suavemente y a mayor velocidad. Otros procesos tendrán menos tiempo de computación. +3 indica ejecución en tiempo real: todo el tiempo de computación se pone en disposición del juego. Esto puede crear problemas con otras aplicaciones que se estén ejecutando en el ordenador. Además, los eventos de teclado o pinchar en el botón para cerrar la ventana pueden dejar de ser atendidos por Windows. Así que sólo debes usar este valor si realmente necesitas todo el procesamiento posible. Se cuidadoso y no olvides guardar tu juego antes de ejecutarlo.