Para interacción con el teclado (keyboard) las siguientes funciones y variables existen:

keyboard_lastkey Código de la última tecla presionada. Mira más las constantes para los códigos de tecla. Puedes cambiarlo, p. ej, ponerlo a 0 si tu lo manipulaste. 
keyboard_key Código de tecla de la tecla presionada actualmente (mira mas abajo; 0 si no se presiona ninguna) 
keyboard_lastchar Último carácter presionado (como string)
keyboard_string Cadena de caracteres de los últimos 1024 caracteres tipeados. Esta cadena solo contendrá caracteres imprimibles en la pantalla. También responde a la tecla de retroceso borrando el último carácter.

En ocasiones es útil mapear una tecla a otra. Por ejemplo pudieras permitir al jugador emplear tanto las teclas del cursor como las del teclado numérico. En lugar de duplicar las acciones puedes mapear el teclado numérico a las teclas del cursor. También pudieras implementar un mecanismo en el que el jugador pueda seleccionar las teclas a usar. Para este fin, contamos con las siguientes funciones:

keyboard_set_map(key1,key2) Mapea la tecla con el código de tecla key 1 a key2. 
keyboard_get_map(key) Devuelve el mapeado actual para una tecla
keyboard_unset_map() Restablece todas sus teclas a su mapa original.

Para chequear si una tecla o botón del ratón en particular han sido presionados puedes emplear las siguientes funciones. Esto es útil particularmente cuando se presionan varias teclas simultáneamente.

keyboard_check(key) Indica si la tecla con el código de tecla particular está presionado. 
keyboard_check_pressed(key) Indica si la tecla con el código de tecla particular fue presionado desde el último step.
keyboard_check_released(key) Indica si la tecla con el código de tecla particular dejó de presionarse desde el último step. 
keyboard_check_direct(key) Indica si la tecla con el código de tecla es presionada chequeando el hardware directamente. El resultado es independiente de la aplicación enfocada. Esta función permite algunos chequeos más. En este caso puedes emplear los códigos vk_lshift, vk_lcontrol, vk_lalt, vk_rshift, vk_rcontrol y vk_ralt para checar si se presiona la tecla shift, control o alt, ya sea izquierda o derecha

Las siguientes rutinas puedes ser usadas para manipular el estado del teclado:

keyboard_get_numlock()Indica si BloqNum está activada.
keyboard_set_numlock(on) Activa (on=true) o desactiva (on=false)

BloqNum.
keyboard_key_press(key) Simula presionar la tecla con el código de tecla
keyboard_key_release(key) Simulates a release of the key with the indicated keycode.

Las siguientes constantes para los códigos de tecla son:

vk_nokey Código de tecla que representa que no hay teclas presionadas
vk_anykey Código de tecla que representa que cualquier tecla ha sido presionada. 
vk_left Código para tecla de la flecha izquierda
vk_right Código para tecla de la flecha derecha
vk_up Código para tecla de la flecha arriba
vk_down Código para tecla de la flecha abajo
vk_enter Tecla Enter o Intro
vk_escape Tecla Escape
vk_space Tecla Espacio
vk_shift Tecla Shift
vk_control Tecla Control
vk_alt Tecla Alt
vk_backspace Tecla Backspace o Retroceso
vk_tab Tecla Tab
vk_home Tecla Inicio
vk_end Tecla Fin
vk_delete Tecla Suprimir
vk_insert Tecla Insertar
vk_pageup Tecla Re Pag
vk_pagedown Tecla Av Pag
vk_pause Tecla Pausa/Inter
vk_printscreen Tecla Impr Pant/Pet Sis
vk_f1 ... vk_f12 Códigos de tecla para las las teclas funcionales F1 hasta F12 
vk_numpad0 ... vk_numpad9 Teclas numéricas en el teclado numérico 
vk_multiply Tecla de multiplicación en el teclado numérico 
vk_divide Tecla de división en el teclado numérico
vk_add Tecla de suma en el teclado numérico
vk_subtract Tecla de substracción en el teclado numérico
vk_decimal Tecla de punto decimal en el teclado numérico

Para las letras usa por ejemplo ord('A'). (Letras Mayúsculas). Para los dígitos usa por ejemplo ord('5') para obtener la tecla <5> (no en el teclado numérico). Las siguientes constantes solo sirven para keyboard_check_direct:

vk_lshift Tecla Shift de la Izquierda 
vk_lcontrol Tecla Control de la Izquierda
vk_lalt Tecla Alt de la Izquierda
vk_rshift Tecla Shift de la Derecha
vk_rcontrol Tecla Control de la Derecha
vk_ralt Tecla Alt de la Derecha

Por ejemplo, asumiendo que tienes un objeto que el usuario puede controlar con las teclas del cursor puedes colocar el siguiente código en el evento step del objeto:

{

  if (keyboard_check(vk_left))  x -= 4;

  if (keyboard_check(vk_right)) x += 4;

  if (keyboard_check(vk_up))    y -= 4;

  if (keyboard_check(vk_down))  y += 4;

}

Claro, esto es mucho más fácil si simplemente lo ponemos en los eventos del teclado.

Hay algunas funciones adicionales relacionadas con la interacción con el teclado

keyboard_clear(key) ‘Limpia’ el estado de la tecla mencionada en “key”. Esto significa que no generará eventos de teclado hasta que se vuelva a presionar.
io_clear() ‘Limpia’ todos los estados del teclado y del ratón.

io_handle() Maneja la entrada y salida por parte del usuario, actualizando los estados del teclado y del ratón.

keyboard_wait() Espera hasta que el usuario presione una tecla del teclado.

EL RATON

Para más interacción, las siguientes variables y funciones existes:

mouse_x* Coordenada X del ratón. No puede cambiarse.
mouse_y* Coordenada Y del ratón. No puede cambiarse.
mouse_button Botón del ratón presionado actualmente. Como valores puedes emplear mb_none (ningún botón), mb_any (cualquier botón), mb_left (botón izquierdo), mb_middle (botón central) o mb_right (botón derecho).
mouse_lastbutton último botón presionado del ratón.

Para chequear si un botón particular del ratón se presionó puedes usar estas funciones. Esto es muy útil cuando muchas teclas se presionan simultáneamente.

mouse_check_button(numb) Indica si se presiona el botón del ratón numb (como valores de numb emplea mb_none, mb_left, mb_middle, o mb_right).
mouse_check_button_pressed(numb) Indica si el botón del ratón fue presionado desde el ultimo step. 
mouse_check_button_released(numb) Indica si el botón del ratón se soltó desde el último step.

Hay funciones adicionales relacionadas con la interacción con el ratón:

mouse_clear(button) “limpia” el estado del botón del Mouse. Esto significa que no se generarán mas eventos del ratón hasta que se vuelva a presionar otra vez. 
io_clear() ‘Limpia’ todos los estados del teclado y del ratón.

io_handle() Maneja la entrada y salida por parte del usuario, actualizando los estados del teclado y del ratón.
mouse_wait()Espera hasta que el usuario presione un botón en el ratón.

EL JOISTICK

Tenemos algunos eventos asociados con los joysticks (mandos de control, controles, palancas de mando, palancas de juego, etc.) Pero para tener control total sobre los joysticks hay un grupo de funciones para tratarlos. El Game Maker soporta hasta dos joystick. Por lo que todas estas funciones reciben el id del joystick como argumento.

joystick_exists(id) Indica si el joystick id (1 o 2) existe.

joystick_name(id) Devuelve el nombre del joystick.

joystick_axes(id) Devuelve el número de ejes del joystick.

joystick_buttons(id) Devuelve el número de botones del joystick.

joystick_has_pov(id) Indica si el joystick tiene capacidades point-of-view.

joystick_direction(id) Devuelve el código (vk_numpad1 a vk_numpad9) correspondiente a la dirección del joystick id (1 o 2).

joystick_check_button(id,numb) Indica si el botón del joystick id es presionado (numb está en el intervalo 1-32).

joystick_xpos(id) Devuelve la posición (-1 a 1) del eje-x del joystick id.

joystick_ypos(id) Devuelve la posición y del joystick id.

joystick_zpos(id) Devuelve la posición z del joystick id (si es que cuenta con eje z).

joystick_rpos(id) Devuelve la posición del timón del joystick id (del cuarto eje).

joystick_upos(id) Devuelve la posición u del joystick id (del quinto eje).

joystick_vpos(id) Devuelve la posición v del joystick id (del sexto eje).

joystick_pov(id) Devuelve la posición del point-of-view del joystick id. Este es un ángulo entre 0 y 360 grados. 0 es adelante, 90 a la derecha, 180 atrás y 270 a la izquierda. Cuando no se especifica la dirección del point-of-view devuelve –1.

GRAFICOS DEL JUEGO

IMAGENES Y SPRITES

Cada objeto tiene un sprite asociado. Puede ser una imagen simple o compuesta por varias subimágenes. Para cada instancia del objeto, el programa dibuja la imagen correspondiente en la pantalla, con su origen (definido en las propiedades de sprite) en la posición (x,y) de la instancia. Cuando hay varias subimágenes, ésta se reproduce a través de las subimágenes para crear un efecto de animación. Hay varias variables que afectan en el modo en que se dibuja la imagen. Estas pueden sert utilizadas para cambiar los efectos. Cada instancia posee las siguientes variables:

visible : Si visible es cierto (1) la imagen se dibuja,  en caso contrario no se dibuja. Las instancias invisibles aun son activas y crean eventos de colisión; Simplemente no puedes verlas. Definir la visibilidad como falso es útil para por ejemplo objetos controladores (hazlos también no sólidos para evitar eventos de  colisión con ellos) o palancas ocultas.

sprite_index Este es el índice del sprite actual para la instancia. Puedes cambiarlo para asignar un sprite diferente a la instancia.  Como valor puedes usar los nombres de los diferentes sprites que definas . Cambiando el sprite no cambias el índice de la subimagen actual.
sprite_width* Indica el ancho del sprite. Este valor no puede ser cambiado, pero puedes utilizarlo.

sprite_height* Indica el alto del sprite. Este valor no puede ser cambiado, pero puedes utilizarlo.

sprite_xoffset* Indica el offset horizontal del sprite, como esta definido en las propiedades del sprite. Este valor no puede ser cambiado, pero puedes utilizarlo.

sprite_yoffset* Indica el offset horizontal del sprite, como esta definido en las propiedades del sprite. Este valor no puede ser cambiado, pero puedes utilizarlo.

image_number* El numero de subimágenes del sprite actual de la instancia (no puede ser cambiado).

image_index Cuando la imagen tiene varias subimágenes, el programa las recorre cíclicamente. Esta variable indica la subimagen dibujada actualmente (están numeradas desde 0). Puedes cambiar la imagen actual cambiando esta variable. EL programa continuará reproduciendo el ciclo de subimágenes, pero comenzando desde el nuevo índice. (El valor puede ser fraccional. En este caso, se redondea siempre hacia abajo para obtener el índice de la  subimagen dibujada.

image_speed La velocidad con que se reproduce el ciclo de subimágenes. Un valor de 1 indica que en cada paso se muestra la siguiente subimagen . Valores menores, reducirán la velocidad de visualización de la animación, dibujando la misma subimagen varias veces. Valores mayores harán que se salten subimágenes para aumentar la velocidad de la animación. A veces quieres que una subimagen en particular sea visible y no quieres que el programa muestre todas las demás subimágenes. Puedes conseguir esto definiendo la velocidad igual a 0 y eligiendo la subimagen correcta. Por ejemplo, asumamos que tenemos un objeto que puede rotar y has creado un sprite que tiene varias subimágenes para  las diferentes orientaciones (en sentido contrario a las agujas del reloj) Puedes introducir el siguiente código en el evento step:

{

  image_index = direction * image_number/360;

  image_speed = 0;

}

depth Normalmente las imágenes son dibujadas en el orden en que se crean las instancias. Puedes cambiar este orden cambiando la profundidad de la imagen. El valor por defecto es 0, hasta que le introduzcas un valor diferente en las propiedades del objeto.  Cuanto mayor es el valor más al fondo se dibujará la instancia. (También puedes utilizar valores negativos.) Las instancias con mayor profundidad permanecerán debajo de las instancias con menor profundidad. Definiendo la profundidad garantizamos que las instancias son dibujadas en el orden que queremos. (Ej. El avión sobre la nube). Las instancias de fondo tendrán una alta profundidad (valor positivo) y las imágenes frontales tendrán una profundidad baja (valores negativos).
image_xscale Un valor de escala para hacer  mayores o menores las imágenes. Un valor de 1 indica el tamaño normal. Debes separar la escala horizontal xscale y la vertical yscale. Cambiando la escala también cambian el ancho y el alto de la imagen e influye en los eventos de collisión, como podrías esperar. Cambiar la escala  puede ser utilizado para dar un efecto 3-D. Puedes utilizar un valor de -1 para invertir horizontalmente la imagen.
image_yscale Escala vertical yscale. 1 no modifica el tamaño. Puedes utilizar un valor de -1 para invertir verticalmente la imagen.
image_angle El ángulo con que se rota la imagen. Se especifica en grados en sentido contrario a las agujas del reloj.  Un valor de 0 indica que no hay rotación. Esta variable solo puede modificarse en la versión registrada!

image_alpha El valor de transparencia (alpha) que se aplica al dibujar la imagen. Un valor de 1 es la opacidad normal; un valor de 0 es totalmente transparente.
image_blend Teñido de color que se aplica al dibujar la imagen. Un valor de color  blanco (c_white) es el que se utiliza por defecto. Cuando especificas un color diferente, la imagen se tiñe de dicho color. Esto puede ser utilizado para colorear el personaje en tiempo de ejecución. Esta variable solo puede modificarse en la versión registrada!
bbox_left* Lado izquierdo de la caja de contorno utilizada por la imagen de la instancia (Se toma en cuenta el escalado).
bbox_right* Lado derecho de la caja de contorno utilizada por la imagen de la instancia
bbox_top* parte superior de la caja de contorno utilizada por la imagen de la instancia.
bbox_bottom* parte inferior de la caja de contorno utilizada por la imagen de la instancia.

FONDOS

Cada room (cuarto) puede tener hasta 8 fondos. Así mismo, también puede tener un color de fondo. Todos los aspecto de estos fondos se pueden cambiar con código usando las siguientes variables (observa que algunas son vectores con un rango de 0 a 7; este número indica el fondo al que se aplicarán los cambios):

background_color Color de fondo para el cuarto.
background_showcolor Indica si se debe limpiar la pantalla con el color de fondo.
background_visible[0..7] Indica si el fondo indicado es visible o no. Por ejemplo, para indicar que el fondo número 3 no debe mostrarse, deberíamos hacerlo así:background_visible[3]=false;
background_foreground[0..7] Indica si el fondo está en primer plano (se dibujará encima de todo lo demás, tapando todo lo que quede por debajo).
background_index[0..7] Imagen de fondo asignada al fondo indicado.
background_x[0..7] Posición x del fondo.
background_y[0...7] Posición y del fondo.
background_width[0...7]* Anchura de la imagen del fondo.
background_height[0...7]* Altura de la imagen del fondo.
background_htiled[0..7] Indica si el fondo debe repetirse horizontalmente para llenar toda la pantalla.
background_vtiled[0..7] Indica si el fondo debe repetirse verticalmente para llenar toda la pantalla.
background_xscale[0..7] Factor de escalado horizontal del fondo: un número entre 0 y 1 hará la imagen más pequeña y un número mayor que 1 la hará más grande. (Debe ser un valor positivo)
background_yscale[0..7] Factor de escalado vertical del fondo: un número entre 0 y 1 hará la imagen más pequeña y un número mayor que 1 la hará más grande. (Debe ser un valor positivo)
background_hspeed[0..7] Velocidad horizontal de scrolling del fondo, en píxeles por step. El scrolling es el movimiento del fondo, por lo tanto esto se refiere al movimiento horizontal del fondo.
background_vspeed[0..7] Velocidad vertical de scrolling del fondo, en píxeles por step. El scrolling es el movimiento del fondo, por lo tanto esto se refiere al movimiento vertical del fondo.
background_blend[0..7] Color de teñido usado al dibujar el fondo. El valor por defecto es c_white. Esta variable sólo se puede usar en la versión registrada! 
background_alpha[0..7] Factor de transparencia usado al dibujar el fondo. 1 es el valor normal (imagen totalmente opaca) y 0 es totalmente transparente (utiliza valores intermedios para dibujar fondos parcialmente transparentes).

DIBUJANDO SPRITES Y FONDOS

Normalmente los objetos tienen un sprite asociado que se dibuja en la pantalla. Pero también puedes usar el evento draw. para dibujar otras cosas. Esta sección y las dos siguientes te darán información sobre este aspecto. Primero de todo, hay un grupo de funciones que sirven para dibujar sprites y fondos de distintas maneras. Estas funciones te dan un gran control sobre la apariencia gráfica del juego y te permiten hacer cosas como dibujar sólo un trozo de un fondo, rotar un sprite...

draw_sprite(sprite,subimg,x,y) Dibuja la subimagen subimg (-1 = subimagen actual) del sprite con índice sprite con su origen en la posición (x,y) sin teñirlo de ningún color y sin usar transparencia. 
draw_sprite_stretched(sprite,subimg,x,y,w,h) Dibuja la subimagen subimg del sprite con índice sprite de forma que llene la región con esquina superior-izquierda en(x,y), anchura w y altura h.
draw_sprite_tiled(sprite,subimg,x,y) Dibuja el sprite repitiéndolo horizontal y verticalmente de forma que llene toda la pantalla. (x,y) es la posición donde se dibuja una de las copias del sprite. 
draw_sprite_part(sprite,subimg,left,top,width,height,x,y) Dibuja la parte del sprite indicada con su esquina superior izquierda en (x,y). La parte del sprite que queremos dibujar se indica con left y top (coordenadas de la esquina superior-izquierda) y width y height (anchura y altura del trozo que queremos dibujar). 

draw_background(back,x,y) Dibuja el fondo en la posición (x,y), sin teñirlo de ningún color y sin transparencia.
draw_background_stretched(back,x,y,w,h) Dibuja el fondo escalado de forma que ocupe la región indicada.
draw_background_tiled(back,x,y) Dibuja el fondo repitiéndolo en horizontal y vertical de forma que llene toda la pantalla. 
draw_background_part(back,left,top,width,height,x,y) Dibuja el trozo indicado del fondo con su esquina superior-izquierda en la posición (x,y).

 

Las funciones siguientes son versiones extendidas de las funciones anteriores. Estas funciones sólo están disponibles en la versión registrada de Game Maker.

draw_sprite_ext(sprite,subimg,x,y,xscale,yscale,rot,color,alpha) Dibuja el sprite escalado con factores xscale (horizontal) e yscale (vertical) y rotadorot grados en sentido antihorario. color indica el color con el que queremos teñir el sprite (usa el color blanco c_white si no quieres teñir el sprite de ningún color) y alpha indica el factor de transparencia. Un valor igual a 0 hace la imagen totalmente transparente y un valor igual a 1 la hace totalmente opaca. Con valores intermedios conseguirás que la imagen sea parcialmente transparente. Con esta función se pueden crear efectos muy espectaculares como explosiones semi-transparentes.
draw_sprite_stretched_ext(sprite,subimg,x,y,w,h,color,alpha) Dibuja el sprite escalado de forma que ocupe la región indicada: esquina superior izquierda en (x,y), anchura w y altura h. color indica el color de teñido y alpha el factor de transparencia.
draw_sprite_tiled_ext(sprite,subimg,x,y,xscale,yscale,color,alpha) Dibuja el sprite repetido de forma que cubra toda la pantalla con factores de escala, color de teñido y factor de transparencia. 
draw_sprite_part_ext(sprite,subimg,left,top,width,height,x,y,xscale,yscale,color,alpha) Dibuja la parte indicada del sprite con factores de escala, color de teñido y factor de transparencia. 
draw_sprite_general(sprite,subimg,left,top,width,height,x,y,xscale,yscale,rot,c1,c2,c3,c4,alpha) La función más general para dibujar sprites. Dibuja la parte indicada de la subimagen subimg (-1 = subimagen actual) del sprite con índice sprite situando su esquina superior-izquierda en la posición (x,y) y con factores de escala, ángulo de rotación, un color de teñido para cada una de las 4 esquinas del sprite (en el orden arriba-izquierda, arriba-derecha, abajo-derecha y abajo-izquierda) y un factor de transparencia. Observa que el sprite se rotará sobre su esquina superior-izquierda y no sobre su origen. 

draw_background_ext(back,x,y,xscale,yscale,rot,color,alpha) Dibuja el fondo escalado, rotado, teñido del color especificado (usa c_white si no quieres teñirlo) y con factor de transparencia alpha (0-1).
draw_background_stretched_ext(back,x,y,w,h,color,alpha) Dibuja el fondo escalado de forma que ocupe la región indicada con color de teñido y factor de transparencia. 
draw_background_tiled_ext(back,x,y,xscale,yscale,color,alpha) Dibuja el fondo repetido de forma que ocupe todo el cuarto con factores de escala, color de teñido y factor de transparencia.
draw_background_part_ext(back,left,top,width,height,x,y,xscale,yscale,color,alpha) Dibuja la parte indicada del fondo situando su esquina superior-izquierda en la posición (x,y) con factores de escala, color de teñido y factor de transparencia. 
draw_background_general(back,left,top,width,height,x,y,xscale,yscale,rot,c1,c2,c3,c4,alpha) La función más general para dibujar fondos. Dibuja la parte indicada del fondo situando su esquina superior-izquierda en la posición (x,y) con factores de escala, ángulo de rotación, un color de teñido para cada una de las cuatro esquinas (en el orden arriba-izquierda, arriba-derecha, abajo-derecha y abajo-izquierda) y un factor de transparencia. Observa que el sprite se rotará sobre su esquina superior-izquierda del trozo indicado del fondo.

DIBUJANDO FORMAS

Game Maker dispone de una amplia colección de funciones para dibujar diferentes formas. También hay otras funciones para dibujar texto (consulta el capítulo siguiente). Estas funciones de dibujo sólo se pueden usar en el evento draw ya que no tienen sentido si se colocan en otro evento. Debes tener en cuenta que las colisiones entre las instancias se determinan según sus sprites y sus máscaras de colisión y no según lo que cada instancia dibuja en la pantalla. Las funciones siguientes sirven para dibujar las formas básicas:

draw_clear(col) Pinta todo el cuarto del color especificado.
draw_clear_alpha(col,alpha) Pinta todo el cuarto del color especificado y con el factor de transparencia indicado (muy útil para superficies).
draw_point(x,y) Dibuja un punto en (x,y) en el color de dibujo actual.
draw_line(x1,y1,x2,y2) Dibuja una línea desde (x1,y1) hasta (x2,y2).
draw_rectangle(x1,y1,x2,y2,outline) Dibuja un rectángulo. outline indica si sólo debe dibujarse el borde (true) o si el rectángulo debe estar relleno (false).
draw_roundrect(x1,y1,x2,y2,outline) Dibuja un rectángulo redondeado. outline indica si sólo debe dibujarse el borde (true) o si el rectángulo debe estar relleno (false).
draw_triangle(x1,y1,x2,y2,x3,y3,outline) Dibuja un triángulo. outline indica si sólo debe dibujarse el borde (true) o si debe estar relleno (false).
draw_circle(x,y,r,outline) Dibuja un círculo con su centro en (x,y) y radio r. outline indica si sólo debe dibujarse el borde (true) o si debe estar relleno (false). 
draw_ellipse(x1,y1,x2,y2,outline) Dibuja una elipse. outline indica si sólo debe dibujarse el borde (true) o si debe estar rellena (false).
draw_arrow(x1,y1,x2,y2,size) Dibuja una flecha desde (x1,y1) hasta (x2,y2). size indica el tamaño de la flecha en píxeles. 
draw_button(x1,y1,x2,y2,up) Dibuja un botón. up indica si está pulsado (0) o no (1).
draw_path(path,x,y,absolute) Con esta función puedes dibujar el path indicado en el cuarto con su comienzo en la posición (x,y). Si absolute es true el path se dibuja en la posición en la que fue definido y los valores de x e y son ignorados. 
draw_healthbar(x1,y1,x2,y2,amount,backcol,mincol,maxcol,direction,showback,showborder) Con esta función puedes dibujar una barra de vida (o una barra que indique cualquier otra cosa como poder, magia,…). Los parámetros x1, y1, x2 e y2 indican el área total de la barra. amount indica el porcentaje de la barra que debe estar relleno (debe estar entre 0 y 100). backcol es el color de fondo de la barra. mincol y maxcol indican el color cuando el porcentaje de llenado (parámetro amount) es 0 y 100 respectivamente. Para un porcentaje intermedio el color se interpola entre estos dos. Así puedes crear fácilmente una barra que vaya de verde a rojo, por ejemplo. direction es la dirección en la que la barra se dibuja: 0 significa que la barra está fijada a la izquierda, 1 a la derecha, 2 arriba y 3 abajo. Finalmente, showback indica si debe mostrarse una caja de fondo y showborder si la caja de fondo y la barra deben tener un borde negro.

Muchas de las funciones anteriores utilizan los colores y transparencia generales de dibujo que pueden ser cambiados con estas funciones:

draw_set_color(col) Indica el color que debe usarse para dibujar primitivas. 
draw_set_alpha(alpha) Indica el factor de transparencia que debe usarse para dibujar primitivas. Debe estar comprendido  en el rango 0-1. 0 significa totalmente transparente y 1 totalmente opaco. 
draw_get_color() Devuelve el color general de dibujo utilizado para dibujar primitivas. 
draw_get_alpha()Devuelve el factor de transparencia general de dibujo utilizado para dibujar primitivas.

Hay un gran rango de colores predefinidos:

c_aqua
c_black
c_blue
c_dkgray
c_fuchsia
c_gray
c_green
c_lime
c_ltgray
c_maroon
c_navy
c_olive
c_purple
c_red
c_silver
c_teal
c_white
c_yellow

Sin embargo, también puedes usar las funciones siguientes para crear tus propios colores:

make_color_rgb(red,green,blue) Devuelve un color con los componentes indicados de rojo, verde y azul. Los valores indicados deben estar entre 0 y 255 (ambos inclusive). 
make_color_hsv(hue,saturation,value) Devuelve un color con los componentes indicados de brillo, saturación y valor. Los valores indicados deben estar entre 0 y 255 (ambos inclusive).
color_get_red(col) Devuelve el componente de rojo del color.
color_get_green(col) Devuelve el componente de verde del color.
color_get_blue(col) Devuelve el componente de azul del color.
color_get_hue(col) Devuelve el componente de brillo del color.
color_get_saturation(col) Devuelve el componente de saturación del color.
color_get_value(col) Devuelve el componente de valor del color.
merge_color(col1,col2,amount) Devuelve un color resultante de mezclar los dos colores indicados. La mezcla se determina por el parámetro amount: un valor igual a 0 corresponde a col1, un valor de 1 corresponde a col2 y un valor intermedio hace que se mezclen los dos colores.

También puedes utilizar las siguientes funciones misceláneas:

draw_getpixel(x,y) Devuelve el color del píxel en la posición (x,y) del cuarto. Esta función no es muy rápida, así que úsala con cuidado. 
screen_save(fname) Salva una imagen bmp de la pantalla en el archive especificado. Útil para crear screenshots. 
screen_save_part(fname,x,y,w,h) Salva la parte de la pantalla indicada a un archive bmp.

FUENTES Y TEXTOS

A veces necesitas dibujar texto. Para ello, primero debes indicar la fuente que quieres usar. Las fuentes se pueden definir creando un recurso de fuente (directamente en Game Maker o usando las funciones de modificación de recursos). Para dibujar texto disponemos de varias funciones distintas. En todas ellas debes indicar el texto a ser dibujado y la posición del mismo. Además, existen dos funciones para definir la alineación del texto en horizontal y vertical respecto a esa posición.

Para dibujar texto disponemos de las funciones siguientes:

draw_set_font(font) Indica la fuente que debe usarse para dibujar texto. Puedes indicar el valor -1 para usar la fuente por defecto (Arial 12).
draw_set_halign(halign) Indica la alineación horizontal del texto. Debes indicar uno de los siguientes valores:

fa_left izquierda
fa_center centrada
fa_right derecha

draw_set_valign(valign) Indica la alineación vertical del texto. Debes indicar uno de los siguientes valores:

fa_top arriba
fa_middle centrada
fa_bottom abajo

draw_text(x,y,string) Dibuja el texto indicado en la posición (x,y) usando el color y el factor de transparencia de dibujo generales. Los símbolo #, chr(13) o chr(10) (tecla ENTER o de salto de línea) son interpretados como caracteres de salto de línea. De esta forma puedes dibujar textos de varias líneas (Usa # para dibujar el símbolo #).
draw_text_ext(x,y,string,sep,w) Similar a la función anterior pero ahora puedes especificar 2 cosas más. Primero de todo, sep indica la distancia de separación entre las líneas del texto si es que tiene varias líneas. Usa -1 para obtener la distancia por defecto. Por último, w indica la anchura del texto en píxeles. Las líneas más largas que esta distancia se dividen en nuevas líneas cuando encuentren un espacio en el texto o el símbolo -. Utiliza el valor -1 si no quieres que el texto se divida automáticamente en varias líneas. 
string_width(string) Anchura que el texto indicado ocuparía si se dibujara con la fuente actual usando la función draw_text(). Puedes usar esta función para posicionar los gráficos con precisión. 
string_height(string) Altura que el texto indicado ocuparía si se dibujara con la fuente actual usando la función draw_text(). Puedes usar esta función para posicionar los gráficos con precisión.
string_width_ext(string,sep,w) Anchura que el texto indicado ocuparía si se dibujara con la fuente actual usando la función draw_text_ext(). Puedes usar esta función para posicionar los gráficos con precisión.
string_height_ext(string,sep,w) Altura que el texto indicado ocuparía si se dibujara con la fuente actual usando la función draw_text_ext(). Puedes usar esta función para posicionar los gráficos con precisión.

Las siguientes funciones te permiten dibujar texto escalado o rotado e incluso aplicarle gradientes de color. Estas funciones sólo están disponibles en la versión registrada de Game Maker!

draw_text_transformed(x,y,string,xscale,yscale,angle) Dibuja el texto indicado en la posición (x,y) con factores de escala y rotado angle grados en sentido antihorario.
draw_text_ext_transformed(x,y,string,sep,w,xscale,yscale,angle) Combina las funciones draw_text_ext() y draw_text_transformed(). De esta forma es posible dibujar textos multilíneas rotados o escalados.
draw_text_color(x,y,string,c1,c2,c3,c4,alpha) Dibuja el texto indicado aplicando a cada esquina el color indicado en el orden arriba-izquierda, arriba-derecha, abajo-derecha, abajo-izquierda y con factor de transparencia alpha (0-1).
draw_text_ext_color(x,y,string,sep,w,c1,c2,c3,c4,alpha) Similar a draw_text_ext() pero con vértices coloreados.
draw_text_transformed_color(x,y,string,xscale,yscale,angle,c1,c2,c3,c4,alpha) Similar a draw_text_transformed()pero con vértices coloreados.
draw_text_ext_transformed_color(x,y,string,sep,w,xscale,yscale,angle,c1,c2,c3,c4,alpha) Similar a draw_text_ext_transformed()pero con vértices coloreados.

FUNCIONES AVANZADAS DE DIBUJO

Esta funcionalidad sólo está disponible en la versión registrada de Game Maker

En los capítulos anteriores hemos descrito las funciones básicas de dibujo. En este capítulo veremos funciones más avanzadas que te otorgan muchas más posibilidades para crear los gráficos de tus juegos. Primero, hay unas funciones que sirven para dibujar formas coloreadas con gradientes o efectos de difuminado. Después veremos las funciones que sirven para dibujar polígonos básicos y por último veremos la forma de dibujar polígonos texturizados.

Las siguientes funciones son versiones extendidas de las funciones de dibujo básicas. Todas ellas admiten parámetros para el color, por lo que ninguna de estas funciones usará el color general de dibujo.

draw_point_color(x,y,col1) Dibuja un punto en la posición (x,y) con el color indicado.
draw_line_color(x1,y1,x2,y2,col1,col2) Dibuja una línea desde (x1,y1) hasta (x2,y2), interpolando el color entre col1 y col2.
draw_rectangle_color(x1,y1,x2,y2,col1,col2,col3,col4,outline) Dibuja un rectángulo. Los cuatro colores indican los colores de los vértices superior-izquierdo, superior-derecho, inferior-derecho e inferior-izquierdo respectivamente. outline indica si sólo debe dibujarse el contorno del rectángulo (true) o si éste debe estar relleno (false).
draw_roundrect_color(x1,y1,x2,y2,col1,col2,outline) Dibuja un rectángulo redondeado. col1 es el color en el centro del rectángulo y col2 en el borde. outlineindica si sólo debe dibujarse el contorno del rectángulo (true) o si éste debe estar relleno (false). 
draw_triangle_color(x1,y1,x2,y2,x3,y3,col1,col2,col3,outline) Dibuja un triángulo. Los tres colores son los colores en los vértices del triángulo (el color se interpola en las demás zonas entre estos tres colores). outline indica si sólo debe dibujarse el contorno del triángulo (true) o si éste debe estar relleno (false).
draw_circle_color(x,y,r,col1,col2,outline) Dibuja un círculo en (x,y) con radio r. col1 es el color en el centro y col2 en el borde. outline indica si sólo debe dibujarse el contorno del círculo (true) o si éste debe estar relleno (false).
draw_ellipse_color(x1,y1,x2,y2,col1,col2,outline) Dibuja una elipse. col1 es el color en el centro y col2 en el borde. outline indica si sólo debe dibujarse el contorno de la elipse (true) o si éste debe estar rellena (false).

También puedes dibujar primitivas más complicadas, pero esto se hace de forma diferente. Primero debes especificar el tipo de primitiva que quieres dibujar. Después especificas los vértices y finalmente la terminas. En este momento se dibuja la primitiva. Existen seis tipos de primitivas:

pr_pointlist Los vértices son un grupo de puntos. 
pr_linelist Los vértices son un grupo de líneas. Cada pareja de puntos forma una línea, por lo que debe haber un número par de puntos. 
pr_linestrip Los vértices forman una poli-línea de forma que el primer punto se conecta al segundo, el segundo al tercero, etc...El último punto no se conecta al primero. Para conseguir esto, debes especificar otra vez el primer punto al final de la primitiva. 
pr_trianglelist Los vértices son un grupo de triángulos. Cada trena de puntos forma un triángulo, luego el número de puntos debe ser un múltiplo de 3. 
pr_trianglestrip Los vértices son un grupo de triángulos, pero esta vez  de forma distinta. Los tres primeros puntos forman el primer triángulo. Los dos últimos puntos de este triángulo junto con el siguiente punto forman el segundo triángulo y así sucesivamente. Es decir, cada nuevo punto especifica un nuevo triángulo conectado por un lado al triángulo anterior.
pr_trianglefan Similar a la función anterior, pero esta vez el primer punto forma parte de todos los triángulos. Cada nuevo punto especifica un nuevo triángulo formado también por el punto anterior y por el primer punto, que ya hemos dicho que está presente en todos los triángulos.

Para dibujar primitivas disponemos de las siguientes funciones:

draw_primitive_begin(kind) Comenzar a definir una primitiva del tipo indicado. 
draw_vertex(x,y) Añade el vértice (x,y) a la primitiva, usando los valores generales de dibujo de color y transparencia. 
draw_vertex_color(x,y,col,alpha) Añade el vértice (x,y) a la primitiva, con los valores de color y transparencia especificados. De esta forma puedes crear primitivas que cambian gradualmente de color u opacidad. 
draw_primitive_end() Terminar la definición de la primitiva. En este momento es cuando se dibuja la primitiva.

Finalmente, es posible dibujar primitivas usando sprites o fondos como texturas. Cuando usas una textura la imagen se sitúa sobre la primitiva y se escala para que su tamaño encaje con el de la primitiva. Las texturas se usan para dar detalle a las primitivas, como por ejemplo, una pared de ladrillos. Para usar una textura, primero debes obtener su id. Esto se realiza con las funciones siguientes:

sprite_get_texture(spr,subimg) Devuelve la id de la textura correspondiente a la subimagen subimg del sprite indicado. 
background_get_texture(back) Devuelve la id de la textura correspondiente al fondo indicado.

Una textura seleccionada puede que no esté cargada en la memoria de video. Normalmente el sistema se encarga de hacerlo automáticamente pero puede ser que a veces decidas encargarte tú mismo de esto. Puedes hacerlo con las funciones siguientes:

texture_preload(texid) Carga la textura en la memoria de video inmediatamente.
texture_set_priority(texid,prio) Cuando no hay memoria gráfica suficiente algunas texturas se eliminarán temporalmente para hacer sitio a otras que se necesiten. Las texturas con menor prioridad se eliminarán primero. Por defecto todas las texturas tienen prioridad 0 pero con esta función puedes especificar una prioridad distinta para cada una (usa sólo valores positivos).

Para añadir una textura a una primitiva debes especificar dónde se situará cada parte de la textura sobre la primitiva. Las posiciones en la textura se indican con valores entre 0 y 1, pero esto nos presenta un problema. Los tamaños de las texturas siempre deben ser potencias de 2 (por ejemplo, 32x32 o 64x64). Si quieres usar sprites o fondos como texturas debes asegurarte de que cumplan esta restricción. Si no, la textura será completamente blanca. Para hallar qué parte de la textura se está utilizando puedes utilizar las dos siguientes funciones. Ambas devuelven un valor entre 0 y 1 que indica la anchura o altura de la parte de la textura que se está usando. Usando este valor como coordenada de textura indicará el lado derecho o inferior de la textura.

texture_get_width(texid) Devuelve la anchura de la textura con la id especificada. Esta anchura será un valor comprendido entre 0 y 1. 
texture_get_height(texid) Devuelve la altura de la textura con la id especificada. Esta altura será un valor comprendido entre 0 y 1.

Para dibujar texturas puedes usar las siguientes funciones:

draw_primitive_begin_texture(kind,texid) Comienza la definición de una primitiva del tipo indicado con la textura indicada. 
draw_vertex_texture(x,y,xtex,ytex) Añade el vértice (x,y) a la primitiva con la posición (xtex,ytex) en la textura, usando los valores generales de dibujo de color y transparencia.xtex e ytex deben estar comprendidos entre 0 y 1 pero también pueden usarse valores mayores para hacer que la textura se repita (ver más abajo).
draw_vertex_texture_color(x,y,xtex,ytex,col,alpha) Añade el vértice (x,y) a la primitiva con la posición (xtex,ytex) en la textura, usando le color de teñido y transparencia indicados. 
draw_primitive_end() Termina la descripción de la primitiva, dibujándola.

Existen tres funciones que influencian la forma en que se dibujan las texturas:

texture_set_interpolation(linear) Indica si debe usarse interpolación lineal (true) o utilizar el píxel más cercano (false). La interpolación lineal suele conseguir texturas más suaves pero a veces pueden parecer un poco borrosas o hacer que le juego se ralentice. Esta propiedad también afecta a la forma en que se dibujan los sprites y fondos. Por defecto es false (esta propiedad también puede cambiarse desde las opciones globales del juego).
texture_set_blending(blend) Indica si debe usarse blending para el color y la transparencia. Blending es la capacidad para que se mezclen. Así por ejemplo, un sprite puede teñirse de un color. Por defecto es true. Activándola se puede conseguir que el juego vaya más rápido en máquina más viejas. Esta propiedad también afecta a la forma en que se dibujan los sprites y fondos.
texture_set_repeat(repeat) Indica si se permite que la textura se repita. Como hemos dicho las coordenadas de textura deben indicarse en el rango 0-1. Si se especifica un valor mayor que 1, el resto no se dibuja. Sin embargo, si ponemos esta propiedad a true la textura se repetirá hasta llenar la primitiva por completo. Observa que los sprites y fondos siempre se dibujan sin repetición, luego cuando se dibuje un sprite o un fondo este valor volverá a ponerse a false (valor por defecto).

Hay dos funciones más que son muy útiles para dibujar texturas. Normalmente, las primitivas se mezclan con el fondo usando el factor de transparencia. Pero puedes controlar la forma en que sucede esto. Por ejemplo, puedes indicar si los colores de la primitiva deben sumarse a los del fondo o restarse. De esta forma puedes crear puntos de luz o sombras. También es posible elegir el máximo entre el nuevo color y el color original para evitar efectos de saturación que ocurren al sumar varios colores. Observa que ni al restar, ni al calcular el máximo se toma en cuenta el valor de transparencia totalmente (DirectX no lo permite), así que debes asegurarte de que el área alrededor es negra. Como ya hemos dicho, hay dos funciones para esto. La primera te da las cuatro opciones ya descritas. La segunda te da muchas más opciones. Es muy recomendable que experimentes con estas funciones ya que se pueden crear efectos muy espectaculares como explosiones, sombras, efectos de luz, halos...

draw_set_blend_mode(mode) Indica el modo de mezcla a usar de entre los siguientes: bm_normal, bm_add (suma), bm_subtract (resta), y bm_max (máximo). No olvides volver a poner el modo normal cuando termines lo que estás haciendo por que esto afectará a la forma en que se dibujan los sprites y fondos. 
draw_set_blend_mode_ext(src,dest) Indica el modo de mezcla que se debe usar para la fuente y el destino. El color resultante se calcula aplicando a cada color (fuente y destino) un factor diferente. Estos factores de mezcla se especifican con esta función. Los colores de fuente y el destino están formados por las componentes de rojo, verde, azul y transparencia. Así, llamamos a los componentes de la fuente (Rf,Gf,Bf,Af) y a los del destino (Rd, Gd, Bd, Ad). Todos estos factores se encuentran entre 0 y 1. Los factores de mezcla que puede usar en esta función son:

• bm_zero: El factor de mezcla es (0, 0, 0, 0).
• bm_one: El factor de mezcla es (1, 1, 1, 1).
• bm_src_color: El factor de mezcla es (Rf, Gf, Bf, Af).
• bm_inv_src_color: El factor de mezcla es (1–Rf, 1–Gf, 1–Bf, 1–Af).
• bm_src_alpha: El factor de mezcla es (Af, Af, Af, Af).
• bm_inv_src_alpha: El factor de mezcla es (1–Af, 1–Af, 1–Af, 1–Af).
• bm_dest_alpha: El factor de mezcla es (Ad, Ad, Ad, Ad).
• bm_inv_dest_alpha: El factor de mezcla es (1–Ad, 1–Ad, 1–Ad, 1–Ad).
• bm_dest_color: El factor de mezcla es (Rd, Gd, Bd, Ad).
• bm_inv_dest_color: El factor de mezcla es (1–Rd, 1–Gd, 1–Bd, 1–Ad).
• bm_src_alpha_sat: El factor de mezcla es (f, f, f, 1); f = min(Af, 1–Ad).

Por ejemplo, el modo de mezcla normal pone la fuente a bm_src_alpha y el destino a bm_inv_src_alpha. No olvides volver a poner el modo normal cuando termines porque si no los sprites y fondos se dibujarán con el nuevo modo.

Dibujar primitivas texturizadas es un poco complicado pero se consiguen resultados geniales. Puedes incluso crear juegos en falso 3D.

DIBUJANDO SUPERFICIES

Esta funcionalidad sólo está disponible en la versión registrada de Game Maker

En algunas situaciones puede que no quieras dibujar directamente en la pantalla sino en un lienzo que más tarde puedas usar para dibujar otras cosas. Por ejemplo, puedes querer que el usuario dibuje en la pantalla. En vez de dejar que el usuario dibuje directamente en la pantalla (lo que no funcionaría, ya que la pantalla se refresca en cada step) puedes hacer que dibuje en un lienzo a parte y copiar este lienzo a la pantalla en cada paso. También podrías querer usar una textura que cambie con el tiempo, crear un efecto de transiciones entre cuartos, efectos de iluminación…

Las superficies hacen posibles cosas como éstas. Las superficies son muy sencillas de usar: primero creas una superficie indicando su tamaño. Luego indicas que vas a dibujar sobre la superficie. Desde este momento, todas las funciones de dibujo se aplicarán a la superficie. Cuando termines de dibujar, indicas que ya no vas a dibujar más en la superficie. Ya tienes lista la superficie, ahora puedes dibujarla directamente en la pantalla, usarla como textura…Consulta el final del capítulo para conocer algunos detalles con los que debes tener cuidado al trabajar con superficies.

Las siguientes funciones sirven para tratar superficies:

surface_create(w,h) Crea una superficie con la anchura y altura indicadas. La función devuelve la id de la superficie que debe ser usada en las demás funciones. Observa que la superficie no se “limpia” (es decir, que no se pinta toda ella de un mismo color). Para esto, debes indicar que vas a dibujar en la superficie y llamar a la función apropiada, por ejemplo draw_clear(color). 
surface_free(id) Libera la memoria utilizada por la superficie. 
surface_exists(id) Devuelve si la superficie con la id especificada existe. 

 

Estas funciones nos dan información sobre la superficie:

surface_get_width(id) Devuelve la anchura de la superficie.
surface_get_height(id) Devuelve la altura de la superficie.
surface_get_texture(id) Devuelve la textura correspondiente a la superficie. Esto se puede usar para dibujar objetos texturizados con la imagen de la superficie. 

 

Estas dos funciones manejan el mecanismo de dibujo:

surface_set_target(id) Indica que la superficie con la id correspondiente es el objetivo de dibujo. Esto significa que todas las funciones de dibujo que se llamen actuarán sobre la superficie. Simplemente resetea la proyección para que cubra sólo a la superficie. 
surface_reset_target() Vuelve a fijar la pantalla como objetivo de dibujo. Es decir, las funciones de dibujo que se llamen a partir de ahora funcionarán normalmente ¡No olvides llamar a esta función cuando termines de dibujar sobre la superficie! 

 

Las funciones siguientes nos permiten manejar las superficies:

surface_getpixel(id,x,y) Devuelve el color del píxel en la posición (x,y) de la superficie. Esta función no es muy rápida así que úsala con moderación. 
surface_save(id,fname) Guarda una imagen bmp de la superficie, creando para ello el archivo con el nombre indicado. Se puede usar para crear screenshots, por ejemplo. 
surface_save_part(id,fname,x,y,w,h) Igual que la función anterior, pero esta vez sólo se copiará la parte de la superficie que indiques.

Para dibujar superficies hay muchas posibilidades:

 
draw_surface(id,x,y) Dibuja la superficie en la posición (x,y). 
draw_surface_stretched(id,x,y,w,h) Dibuja la superficie en la posición (x,y) y escalada de forma que tenga la anchura y altura indicadas.
draw_surface_tiled(id,x,y) Dibuja la superficie en la posición (x,y) y la repite una y otra vez para que ocupe todo el cuarto.
draw_surface_part(id,left,top,width,height,x,y) Dibuja la parte indicada de la superficie en la posición (x,y). 
draw_surface_ext(id,x,y,xscale,yscale,rot,color,alpha) Dibuja la superficie en la posición (x,y), con factores de escala, rotación, transparencia y tiñiéndola con el color indicado (utiliza c_white si no quieres teñir la superficie). 
draw_surface_stretched_ext(id,x,y,w,h,color,alpha) Dibuja la superficie en la posición (x,y) escalada para que ocupe la región indicada con factor de transparencia y tiñiéndola del color especificado.
draw_surface_tiled_ext(id,x,y,xscale,yscale,color,alpha) Dibuja la superficie repitiéndola para que ocupe todo el cuarto pero con factores de escala, transparencia y tiñiéndola del color indicado.
draw_surface_part_ext(id,left,top,width,height,x,y,xscale,yscale,color,alpha) Dibuja la parte indicada de la superficie en la posición (x,y) pero con factores de escala, transparencia y color. 
draw_surface_general(id,left,top,width,height,x,y,xscale,yscale,rot,c1,c2,c3,c4,alpha) La función más general de dibujo. Dibuja la parte indicada de la superficie con su origen en la posición (x,y), con factores de escala, transparencia y rotada rot grados en sentido antihorario. Además debes indicar 4 colores para cada una de las esquinas de la superficie en este orden: esquina superior izquierda, esquina superior derecha, esquina inferior derecha y esquina inferior izquierda. 

 

Por último, existen dos funciones para copiar superficies:

surface_copy(destination,x,y,source) Copia la superfcie en la posición (x,y) en la superficie indicada por destination. 
surface_copy_part(destination,x,y,source,xs,ys,ws,hs) Copia la parte indicada de la superfcie en la posición (x,y) en la superficie indicada por destination.

Observa que no hay funciones para copiar parte de la pantalla a una superficie. Esto es imposible debido a la diferencia de formato entre la pantalla y las superficies. Si necesitaras usar esto puedes indicar la superficie como objetivo de dibujo y dibujar todo el room. Luego usando las funciones para copiar superficies puedes copiar partes de ella a la pantalla.

También puedes crear sprites y fondos de superficies. Esto se explica con más detalle en la sección de modificación de recursos.

Al usar superficies debes tener algunas cosas en cuenta:

• Nunca debes cambiar el objetivo de dibujo mientras dibujas estás dibujando sobre la pantalla. Es decir, nunca uses las funciones surface_set_target() ni surface_reset_target() en el evento draw. Esto causará graves problemas en la proyección.
• Las superficies no funcionan correctamente en modo 3D. Puedes usarlas mientras no estés en modo 3D (llamando a la función d3d_end() antes de usarlas) pero una vez que empieces a usar el modo 3D de nuevo las superficies se destruirán automáticamente.
• Por motivos de velocidad, las superficies se mantienen en la memoria de video constantemente. Como resultado de esto, podrías perder las superficies al cambiar la resolución de la pantalla o cuando salte el salvapantallas.
•  

Como ya debes saber, puedes añadir tiles a los cuartos. Una tile es una parte de un fondo. En realidad, una tile es simplemente una imagen visible: no reaccionan ante eventos y no generan colisiones. Como resultado de esto, las tiles funcionan mucho más rápido que los objetos. Así pues, todo lo que no sufra colisiones o no reaccione ante eventos funcionará mucho mejor si lo haces con tiles. Incluso a veces es mejor utilizar un tile para mostrar los gráficos y poner por debajo un objeto invisible que se encargue de las colisiones. Para definir un tile necesitas un fondo. Sobre este fondo indicas la esquina superior (top) izquierda (left), la anchura (width) y la altura (height) de un rectángulo. La parte del fondo que queda dentro de este rectángulo pasa a ser una tile.

Puedes añadir tiles al diseñar el room, pero también puedes hacerlo mientras el juego se ejecuta. Puedes cambiar su posición, escalarlas o hacerlas transparentes. Una tile tiene las propiedades siguientes:

• background. El fondo del que se crea la tile.
• left, top, width, height. La parte del fondo usada en la tile (izquierda, arriba, anchura y altura).
• x,y. Posición de la esquina superior izquierda del tile en el room.
• depth. Profundidad del tile. Puedes escoger la profundidad que quieras, haciendo que las tiles aparezcan entre varias instancias distintas.
• visible. Indica si es visible.
• xscale, yscale. Factores de escalado horixontal y vertical (el tamaño normal es 1).
• blend. Color de teñido usado al dibujar el tile.
• alpha. Factor de transparencia utilizado al dibujar el tile.

Para cambiar las propiedades de una tile debes conocer su id. Cuando creas tiles desde el editor de rooms la id se muestra en la barra inferior de información. Pero también existen funciones para conocer la id de una tile en una posición particular.

Las funciones siguientes sirven para manejar tiles:

tile_add(background,left,top,width,height,x,y,depth) Añade una nueva tile al cuarto con las propiedades indicadas. Esta función devuelve la id de la nueva tile que se puede usar más tarde en el resto de funciones.
tile_delete(id) Elimina el tile con la id especificada.
tile_exists(id) Devuelve si existe una tile con la id especificada.

 

Las funciones siguientes nos dan información sobre las tiles:

tile_get_x(id) Devuelve la posición x de la tile con la id especificada.
tile_get_y(id) Devuelve la posición y de la tile con la id especificada.
tile_get_left(id) Devuelve el valor de la propiedad left  (izquierda) de la tile con la id especificada.
tile_get_top(id) Devuelve el valor de la propiedad top (arriba) de la tile con la id especificada.
tile_get_width(id) Devuelve la anchura de la tile con la id especificada.
tile_get_height(id) Devuelve la altura de la tile con la id especificada.
tile_get_depth(id) Devuelve la profundidad de la tile con la id especificada.
tile_get_visible(id) Devuelve si la tile con la id especificada es visible o no.
tile_get_xscale(id) Devuelve el factor horizontal de escalado de la tile con la id especificada.
tile_get_yscale(id) Devuelve el factor vertical de escalado de la tile con la id especificada.
tile_get_background(id) Devuelve el fondo de la tile con la id especificada.
tile_get_blend(id) Devuelve el color de teñido de la tile con la id especificada.
tile_get_alpha(id) Devuelve el factor de transparencia de la tile con la id especificada.

Las funciones siguientes sirven para manipular las propiedades de las tiles:

tile_set_position(id,x,y) Coloca la tile con la id especificada en la posición x,y.
tile_set_region(id,left,top,width,height) Cambia la región del tile con la id especificada sobre su fondo.
tile_set_background(id,background) Cambia el fondo de la tile con la id especificada.
tile_set_visible(id,visible) Cambia la visibilidad de la tile con la id especificada.
tile_set_depth(id,depth) Cambia la profundidad de la tile con la id especificada.
tile_set_scale(id,xscale,yscale) Cambia los factores de escala de la tile con la id especificada.
tile_set_blend(id,color) Cambia el color de teñido de la tile con la id especificada. Sólo disponible en la versión registrada! 
tile_set_alpha(id,alpha) Cambia la transparencia de la tile con la id especificada.

Las funciones siguientes manejan capas de tiles, es decir, grupos de tiles que tienen la misma profundidad:

tile_layer_hide(depth) Oculta todas las tiles con la profundidad indicada.
tile_layer_show(depth) Muestra todas las tiles con la profundidad indicada.
tile_layer_delete(depth) Elimina todas las tiles con la profundidad indicada..
tile_layer_shift(depth,x,y) Mueve todas las tiles con la profundidad indicada siguiendo el vector (x,y). Esta función se puede usar para capas de tiles móviles.
tile_layer_find(depth,x,y) Devuelve la id de la tile con la profundidad indicada que se encuentra en la posición (x,y). Si no se encuentra ninguna tile la función devuelve -1. Cuando se encuentran varias tiles en esa posición con la misma profundidad se devuelve la primera. 
tile_layer_delete_at(depth,x,y) Elimina la tile con la profundidad indicada que se encuentra en la posición (x,y). Si se encentran varias tiles en esa posición y con la profundidad indicada se eliminan todas.
tile_layer_depth(depth,newdepth) Cambia la profundidad de todas las tiles con la profundidad indicada a la nueva profundidad. Es decir, con esta función puedes mover capas enteras de tiles a otra profundidad.

EL DISPLAY

El display es todo el área del monitor. Tiene varias características como el tamaño (típicamente 1024x768 ó 1280x1024), la profundidad de color (que es el número de bits que se utilizan para representar 1 píxel) y suele ser de 16 bits (color de alta densidad) ó 32 bits (color verdadero) y la frecuencia de refresco, que es el número de veces por segundo que se refresca el display, es decir, cuántas veces por segundo se vuelven a dibujar los píxeles en la pantalla (típicamente entre 60 y 120). Estos parámetros se pueden cambiar desde las propiedades de la pantalla en Windows. Pero para algunos juegos, sobre todo los que se ejecuten en pantalla completa, es importante poder controlar estos aspectos. Todos ellos se pueden inicializar desde la pestaña Game Settings. Para cambiar estos parámetros durante el juego Game Maker dispone de un grupo de funciones que veremos a continuación. Debes tener en cuenta que al cambiar estos parámetros el sistema necesitará un poco de tiempo para volver a ajustarlo todo. Las funciones para cambiar el modo sólo están disponibles en la versión registrada de Game Maker.

display_get_width() Devuelve la anchura del display en píxeles. 
display_get_height()Devuelve la altura del display en píxeles.
display_get_colordepth()Devuelve la profundidad de color en bits.
display_get_frequency()Devuelve la frecuencia de refresco del monitor.
display_set_size(w,h) Cambia la altura y anchura del display a los nuevos valores indicados. La función devuelve true si los cambios se aplicaron con éxito y false en caso contrario (Debes tener en cuenta que sólo algunas combinaciones están permitidas, por ejemplo 800x600, 1024x768 ó 1280x1024).
display_set_colordepth(coldepth) Cambia la profundidad de color a la especificada. En general sólo se permite usar profundidad de color de 16 ó 32 bits. La función devuelve true si los cambios se aplicaron con éxito y false en caso contrario.
display_set_frequency(frequency) Cambia la frecuencia de refresco del monitor a la especificada. Sólo unas pocas frecuencias están permitidas. Por ejemplo, puedes ajustar este valor a 60 y usar un room_speed del mismo valor para lograr animaciones fluidas de 60 frames por segundo. La función devuelve true si los cambios se aplicaron con éxito y false en caso contrario.
display_set_all(w,h,frequency,coldepth) Cambia todos los valores a la vez. Para valores que no quieras cambiar utiliza -1. La función devuelve true si los cambios se aplicaron con éxito y false en caso contrario.
display_test_all(w,h,frequency,coldepth) Comprueba si los valores especificados están permitidos. La función no aplica los valores al display, sólo chequea si son válidos. Para los valores que no quieras cambiar usa el valor -1. La función devuelve true si los cambios se pueden aplicar y false en caso contrario.
display_reset() Resetea las características del display a los originales, es decir, a los que estaban presentes cuando se inició el programa.

A veces es útil poder conocer la posición del puntero en el display o poder cambiarla. Para ello se usan las funciones siguientes:

display_mouse_get_x() Devuelve la coordenada x del puntero en el display. 
display_mouse_get_y()Devuelve la coordenada x del puntero en el display.
display_mouse_set(x,y) Cambia la posición del puntero a los valores indicados.

LA VENTANA

El juego se ejecuta en una ventana. Esta ventana tiene varias propiedades como si tiene borde, si ocupa toda la pantalla...Normalmente estos valores se fijan desde la opción Game Settings. Pero también puedes cambiarlos durante el juego. Para ello puedes usar las funciones siguientes:

window_set_visible(visible) Hace que la ventana se vuelva visible o invisible. Normalmente la ventana es visible durante todo el juego. Cuando la ventana sea invisible el programa no ejecutará ni recibirá los eventos del teclado. 
window_get_visible() Devuelve si la ventana es visible.
window_set_fullscreen(full) Hace que la ventana ocupe toda la pantalla (modo pantalla completa) o no.
window_get_fullscreen() Devuelve si la ventana ocupa toda la pantalla.
window_set_showborder(show) Indica si el borde alrededor de la ventana debe mostrarse (si la ventana está a pantalla completa el borde no se muestra).
window_get_showborder() Devuelve si el borde de la ventana es visible cuando ésta no está a pantalla completa.
window_set_showicons(show) Indica si deben mostrarse los iconos de la ventana (minimizar, maximizar y cerrar). Si la ventana está a pantalla completa no se muestran. 
window_get_showicons() Devuelve si los iconos de la ventana son visibles.
window_set_stayontop(stay) Indica si la ventana de be mostrarse siempre por encima de otras ventanas que puedan existir. 
window_get_stayontop() Devuelve si la ventana se mantiene siempre por encima de las demás.
window_set_sizeable(sizeable) Indica si el jugador puede cambiar el tamaño de la ventana. El jugador sólo podrá hacer esto si el borde de la ventana es visible y la ventana no está a pantalla completa. 
window_get_sizeable() Devuelve si el jugador puede cambiar el tamaño de la ventana.
window_set_caption(caption) Indica el título de la ventana. Normalmente esto se especifica al definir el room y se cambia usando la variable room_caption. Por ello, esta función no es útil a no ser que dibujes tú mismo el room en lugar de dejar que Game Maker lo haga automáticamente. El título de la ventana sólo es visible cuando ésta tiene borde visible y no está a pantalla completa.
window_get_caption() Devuelve el título de la ventana.
window_set_cursor(curs) Indica el puntero que se usará en la ventana. Puedes indicar una de las siguientes constantes:

cr_default 
cr_none 
cr_arrow 
cr_cross 
cr_beam 
cr_size_nesw 
cr_size_ns
cr_size_nwse
cr_size_we
cr_uparrow
cr_hourglass
cr_drag
cr_nodrop
cr_hsplit
cr_vsplit
cr_multidrag
cr_sqlwait
cr_no
cr_appstart
cr_help
cr_handpoint
cr_size_all

Por ejemplo, para hacer que no se vea el cursor o puntero usa window_set_cursor(cr_none).
window_get_cursor() Devuelve el cursor utilizado en la ventana.
window_set_color(color) Indica el color de la parte de la ventana que no se usa para mostrar el room.
window_get_color() Devuelve el color de la ventana.
window_set_region_scale(scale,adaptwindow) Si la ventana es mayor que el cuarto actual el cuarto se muestra centrado en la ventana. Con esta función es posible indicar si queremos que el cuarto sea escalado para que ocupe toda la ventana o una parte concreta. Si usamos el valor 1 el cuarto no será escalado. Si usamos el valor 0 el cuarto se escalará para ocupar toda la ventana. Si usas un valor negativo el cuarto será escalado al máximo valor dentro de la ventana que le permita seguir conservando su relación de aspecto entre altura y anchura. El segundo parámetro, adaptwindow, indica si el tamaño de la ventana debe adaptarse al cuarto si éste, una vez escalado, no entra por completo dentro de la misma. Esto sólo suele ser útil cuando el primer parámetro (el que indica el escalado del cuarto) es positivo. 
window_get_region_scale() Devuelve el factor de escala de la región de dibujo.

La ventana tiene una posición en la pantalla y un tamaño. Cuando hablamos de posición y tamaño siempre nos referimos a la ventana sin los bordes. Puedes cambiar estos valores aunque raramente querrás utilizarlo desde el  juego. Normalmente, se determinan automáticamente o el jugador escoge los que le interesan. Las funciones siguientes te permiten cambiar estos aspectos de las ventanas. Observa que estas funciones sólo funcionarán si la ventana no está a pantalla completa. Si la ventana está a pantalla completa los cambios no se aplicarán hasta que la ventana vuelva al modo normal.

window_set_position(x,y) Indica la posición de la ventana. 
window_set_size(w,h) Indica el nuevo tamaño de la ventana. Observa que si el tamaño indicado es menor que la región de dibujo se mantendrá lo suficientemente grande como para que la región entre por completo dentro de él. 
window_set_rectangle(x,y,w,h) Indica la nueva posición y medidas de la ventana (es como usar las dos funciones anteriores a la vez).
window_center() Centra la ventana en la pantalla.
window_default() Da a la ventana los valores por defecto de tamaño y posición (centrada).
window_get_x() Devuelve la coordenada x de la ventana.
window_get_y()Devuelve la coordenada y de la ventana.
window_get_width()Devuelve la anchura de la ventana.
window_get_height()Devuelve la altura de la ventana.

Puede que nunca necesites utilizar las funciones de posicionamiento de l ventana ya que Game Maker lo realizará automáticamente.

En algunas ocasiones puede que quieras conocer la posición del ratón respecto a la ventana (normalmente se usa la posición del ratón respecto a un cuarto o a una vista). Las siguientes funciones sirven para esto:

window_mouse_get_x() Devuelve la coordenada x del puntero en la ventana.
window_mouse_get_y()Devuelve la coordenada y del puntero en la ventana.
window_mouse_set(x,y) Indica la nueva posición del puntero en la ventana.

VISTAS

Como ya deberías saber puedes definir hasta 8 vistas diferentes al diseñar un cuarto. Una vista se define por su área en el cuarto y por su puerto o viewport en la pantalla (la región de dibujo dentro de la ventana). Usando vistas puedes mostrar diferentes partes del cuarto en diferentes lugares de la pantalla. Además, puedes asegurar que un objeto concreto siempre permanezca visible en una vista.

Puedes controlar las vistas con código. Puedes hacerlas visibles o invisibles, cambiar su posición o tamaño dentro de la región de dibujo o en el cuarto (lo cual es muy útil cuando no indicas ningún objeto que deba ser seguido por la vista). Puedes cambiar el tamaño de los bordes horizontal y vertical alrededor del objeto a ser seguido. Si el objeto que quieres que sea seguido cambia a otro tipo de objeto durante el juego (por ejemplo, si acumula mucha experiencia y evoluciona en un personaje más poderoso) puede que las vistas siguientes no lo sigan correctamente. Para solucionar esto, puedes indicar este código en el evento de creación de todos los objetos del personaje (en este ejemplo se supone que la vista principal es la vista 0):

{

  view_object[0] = object_index;

}

Las siguientes variables actúan sobre las propiedades de las vistas. Todas, excepto las dos primeras, son vectores con 8 elementos: el primer elemento (0) indica la primera vista y el último elemento (7) la última.

view_enabled Indica si las vistas están activadas en el cuarto actual.
view_current* La vista que actualmente se está dibujando (0...7). Usa esta variable sólo en el evento draw. Por ejemplo, puedes chequear el valor de esta variable para dibujar algo sólo en unas vistas y no en otras. El valor de esta variable no se puede cambiar. 
view_visible[0..7] Devuelve si la vista indicada es visible en la pantalla

view_xview[0..7] Posición X de la vista en el cuarto. 
view_yview[0..7] Posición Y de la vista en el cuarto.
view_wview[0..7] Anchura de la vista en el cuarto.
view_hview[0..7] Altura de la vista en el cuarto.
view_xport[0..7] Posición X del puerto en la región de dibujo.
view_yport[0..7] Posición Y del puerto en la región de dibujo.
view_wport[0..7] Anchura del puerto en la región de dibujo.
view_hport[0..7] Altura del puerto en la región de dibujo.
view_angle[0..7] Ángulo de rotación usado para la vista en el cuarto (grados en sentido antihorario).
view_hborder[0..7] Tamaño en píxeles del borde horizontal alrededor del objeto a seguir por la vista. 
view_vborder[0..7] Tamaño en píxeles del borde vertical alrededor del objeto a seguir por la vista.
view_hspeed[0..7] Velocidad horizontal máxima de la vista.
view_vspeed[0..7] Velocidad vertical máxima de la vista.
view_object[0..7] Objeto cuya instancia debe permanecer visible en la vista. Si hay varias instancias de este objeto se usará la primera. Puedes asignar una id de una instancia a esta variable para indicar una instancia concreta que quieras seguir.

Observa que el tamaño de la imagen en la pantalla se calcula a partir de las vistas visible al comienzo del cuarto. Si cambias las vistas durante el juego puede que ya no entren correctamente en la pantalla. Para solucionar esto, puedes adaptar tú mismo el tamaño de la pantalla con las siguientes funciones:

window_set_region_size(w,h,adaptwindow) Indica la anchura y altura de la región de dibujo en la ventana. adaptwindow indica si el tamaño de la ventana debe adaptarse si la región de dibujo no cabe dentro de ella. La ventana siempre se adaptará si usas escalado fijo (Consulta la función window_set_region_scale() en el capítulo La ventana).
window_get_region_width() Devuelve la anchura actual de la región de dibujo. 
window_get_region_height()Devuelve la altura actual de la región de dibujo.

A veces necesitarás conocer la posición del ratón. Normalmente puedes hacer esto con las variables mouse_x y mouse_y. Cuando hay muchas vistas, estas variables dan la posición del ratón respecto a la vista en la que el ratón se encuentra. Pero puede ser que en alguna ocasión necesites conocer la posición del ratón respecto a una vista concreta, incluso cuando el ratón se encuentre fuera de esa vista. Para hacer esto, puedes usar las siguientes funciones:

window_view_mouse_get_x(id) Devuelve la coordenada x del ratón respecto a la vista indicada. 
window_view_mouse_get_y(id) Devuelve la coordenada y del ratón respecto a la vista indicada.
window_view_mouse_set(id,x,y) Indica la posición del ratón respecto a la vista indicada. 
window_views_mouse_get_x()Devuelve la coordenada x del ratón respecto a la vista en la que se encuentra (es lo mismo que mouse_x).
window_views_mouse_get_y()Devuelve la coordenada y del ratón respecto a la vista en la que se encuentra (es lo mismo que mouse_y).
window_views_mouse_set(x,y) Indica la posición del ratón respecto a la primera vista que es visible.

TRANSICIONES

Al moverse de una room a otra puedes seleccionar una transición. También puedes seleccionar la transición que se utilizará en el frame siguiente sin tener que cambiar de cuarto. Para esto usamos la variable transition_kind. Asignándole un valor entre 1 y 13 se usará la transición correspondiente. Si usamos un  valor igual a 0 significa que no se aplicará ninguna transición. La transición sólo se aplicará la próxima vez que se dibuje un frame.

transition_kind Indica la transición al próximo frame:

0 = sin transición
1 = Crear desde la izquierda
2 = Crear desde la derecha
3 = Crear desde arriba
4 = Crear desde abajo
5 = Crear desde el centro
6 = Cambiar desde la izquierda
7 = Cambiar desde la derecha
8 = Cambiar desde arriba
9 = Cambiar desde abajo
10 = Mezclar desde la izquierda
11 = Mezclar desde la derecha
12 = Mezclar desde arriba
13 = Mezclar desde abajo

Observa que es muy sencillo crear tus propias transiciones. Por ejemplo, para crear un efecto de oscurecimiento puedes dibujar un rectángulo negro que tape toda la pantalla y hacer que su factor de transparencia vaya aumentando poco a poco. O puedes cambiar la posición y el tamaño de una vista para mover el cuarto fuera de la zona visible. Utilizando superficies y partículas puedes crear transiciones realmente asombrosas!

REDIBUJANEDO LA PANTALLA

Normalmente al final de cada paso del juego (step) el cuarto se dibuja en la pantalla. Pero en algunas ocasiones puede que quieras dibujar el cuarto en otro momento. Esto ocurre cuando tu programa toma el control, por ejemplo: antes de que el programa se congele durante un largo período es recomendable dibujar el cuarto. O cuando el juego muestra un mensaje y espera a que el jugador presione un tecla para continuar es necesario dibujar el cuarto en medio de esta operación. Existen dos funciones para hacer esto:

screen_redraw() Redibuja la pantalla ejecutando todos los eventos de dibujo.
screen_refresh() Refresca la pantalla usando la imagen del cuarto actual sin ejecutar los eventos de dibujo.

Para entender la segunda función es necesario ver cómo trabaja internamente el mecanismo de dibujo. Internamente existe una imagen donde se dibuja todo. Esta imagen no es visible en la pantalla. Sólo al final de un paso del juego, cuando se ha dibujado todo, la imagen de la pantalla se reemplaza por esta imagen interna (esta técnica se conoce como “double buffering”). La primera funciónscrren_redraw() dibuja la imagen interna y luego refresca la imagen de la pantalla. La segunda función screen_refresh() sólo refresca la imagen de la pantalla, pero no actualiza la imagen interna.

Ahora deberías entender por qué no puedes usar las acciones o funciones de dibujo en otros eventos a parte de los eventos de dibujo. Si lo haces así, dibujarías elementos en la imagen interna pero no en la pantalla. Cuando se ejecuta el evento draw, primero se dibuja el fondo del cuarto, tapando y borrando todo lo que habías dibujado en la imagen interna. Pero cuando usas screen_refresh()después de dibujar algo, la imagen se volverá visible en la pantalla. Por ejemplo, podemos crear un trozo de código que dibuje un texto en la pantalla, llame a la función de refresco y espere a que el jugador pulse una tecla:

{

  draw_text(screen_width/2,100,'Pulsa cualquier tecla para continuar');

  screen_refresh();

  keyboard_wait();

}

Observa que al dibujar en un evento distinto del evento draw sólo puedes dibujar en la imagen interna, ¡nunca en una vista! Así que las coordenadas que usas serán las mismas que si no hubiera vistas. Ten cuidado al usar esta técnica: asegúrate de que has entendido bien como funciona y ten en cuenta que el refresco de la pantalla tarda un poco de tiempo.

Cuando estás dibujando el propio cuarto puede ser útil no dejar que se dibuje automáticamente. Por ejemplo, puedes querer que el cuarto sólo se dibuje cada 5 pasos. Para ello puedes usar la función siguiente:

set_automatic_draw(value) Indica si el cuarto se debe dibujar automáticamente (true por defecto) o no (false).

Finalmente, hay una función que te permite sincronizar el dibujo con la frecuencia de refresco del monitor:

set_synchronization(value) Indica si se debe sincronizar el dibujo con la frecuencia de refresco del monitor.

También puedes obligar a que el programa espere hasta la próxima sincronización vertical:

screen_wait_vsync() Espera hasta la siguiente sincronización vertical del monitor.