Una pila es una estructura LIFO (último en entrar, primero en salir). Puedes empujar (push) valores en la pila o quitarlos tirando de ellos (pop). El último valor que se empujó en la lista es el primero al que se accede al tirar de la lista. Es como si vas poniendo un libro encima de otro: cuando quieras coger un libro, el último que pusiste estará encima de todos los demás y será el que cojas. Las pilas se utilizan para gestionar interrupciones o cuando se usan funciones recursivas:

ds_stack_create() Crea una nueva pila. La función devuelve un número entero con la id de la pila para usarla en las diferentes funciones. Puedes crear varias pilas.
ds_stack_destroy(id) Destruye la pila, liberando la memoria usada. No olvides usar esta función cuando ya no necesites la pila.
ds_stack_clear(id) Limpia la pila, borrando todos los valores que contiene pero no la destruye.
ds_stack_size(id) Devuelve el número de valores en la pila.
ds_stack_empty(id) Devuelve true si la pila está vacía. Es lo mismo que chequear si el número de valores en la pila es cero.
ds_stack_push(id,val) Empuja el valor dentro de la pila.
ds_stack_pop(id) Devuelve el valor al final de la pila (esto es, el último valor introducido) y lo elimina de la pila.
ds_stack_top(id) Devuelve el valor al principio de la pila (el primero que se introdujo) pero no lo elimina.

COLAS

Una cola es parecido a una pila, pero funciona como una estructura FIFO (primero en entrar, primero en salir). El primer valor que se mete en la cola es el primero en salir, como una cola en una tienda. El primer cliente en llegar será el primero en ser atendido y los demás tendrán que esperar su turno en orden. Para trabajar  con colas existen las funciones siguientes (observa que las 5 primeras son equivalentes a las funciones de las pilas: todas las estructuras de datos poseen estas 5 funciones)

ds_queue_create()Crea una nueva cola. La función devuelve un número entero con la id de la cola para usarla en las diferentes funciones. Puedes crear varias colas.
ds_queue_destroy(id) Destruye la cola, liberando la memoria usada. No olvides usar esta función cuando ya no necesites la cola.
ds_queue_clear(id)Limpia la cola, borrando todos los valores que contiene pero no la destruye.
ds_queue_size(id) Devuelve el número de valores en la cola.
ds_queue_empty(id) Devuelve true si la cola está vacía. Es lo mismo que chequear si el número de valores en la cola es cero.
ds_queue_enqueue(id,val) Introduce el valor en la cola.
ds_queue_dequeue(id) Devuelve el último valor de la cola (el primero en introducirse) y lo elimina de la cola.

ds_queue_head(id) Devuelve el valor al principio de la cola, esto es, el primero que se introdujo, pero no lo elimina de la cola.
ds_queue_tail(id) Devuelve el último valor de la cola pero no lo elimina.

LISTAS

Una lista guarda una colección de valore en un orden determinado. Puedes añadir valores a la lista a la posición que desees. Por eso, puedes acceder acceder a los valores usando un índice de su posición en la lista. También puedes ordenar los elementos de forma ascendente o descendente. Las listas se pueden usar para muchas cosas, por ejemplo, para guardar valores que cambian. Las listas se han programado usando arrays, pero al estar definidas en código compilado son mucho más rápidas que los arrays.  

ds_list_create()Crea una nueva lista. La función devuelve un número entero con la id de la lista para usarla en las diferentes funciones. Puedes crear varias listas.
ds_list_destroy(id) Destruye la lista, liberando la memoria usada. No olvides usar esta función cuando ya no necesites la lista.
ds_list_clear(id) Limpia la lista, borrando todos los valores que contiene pero no la destruye.
ds_list_size(id) Devuelve el número de valores en la lista.
ds_list_empty(id) Devuelve true si la lista está vacía. Es lo mismo que chequear si el número de valores en la lista es cero.
ds_list_add(id,val) Inserta el valor al final de la lista.
ds_list_insert(id,pos,val) Inserta el valor en la posición pos. La primera posición es 0 y la última es igual al tamaño de la lista menos 1.

ds_list_replace(id,pos,val) Reemplaza el valor en la posición pos por val. ds_list_delete(id,pos) Elimina el valor en la posición pos.

ds_list_find_index(id,val) Devuelve la posición en la lista del valor val. Si no encuentra el valor en la lista devuelve -1. 
ds_list_find_value(id,pos) Devuelve el valor en al posición pos. 
ds_list_sort(id,ascend) Ordena los valores de la lista. Si ascend es true o 1 los ordena de forma ascendente, en caso contrario los ordena de manera descendente.

MAPAS

En algunas ocasiones necesitas guardar pares de valores consistentes de una llave (key) y un valor. Por ejemplo, un personaje puede llevar varios ítems diferentes y puede tener un número diferente de cada uno. En este caso, el ítem será la llave y la cantidad será el valor. Los mapas manejan estas parejas de valores, ordenándolos por la llave. Puedes añadir valores al mapa y buscar uno concreto usando las llaves. Como las llaves también están ordenadas, puedes encontrar los valores correspondientes a la llave siguiente o anterior. A veces es útil usar un mapa para guardar llaves sin ningún valor asignado. En este caso puedes asignarles a todas las llaves el valor 0.

ds_map_create()Crea un nuevo mapa. La función devuelve un número entero con la id del mapa para usarla en las diferentes funciones. Puedes crear varios mapas.
ds_map_destroy(id) Destruye el mapa, liberando la memoria usada. No olvides usar esta función cuando ya no necesites el mapa.
ds_map_clear(id)Limpia el mapa, borrando todos las parejas llave-valor que contiene pero no lo destruye.
ds_map_size(id) Devuelve el número de parejas llave-valor en el mapa.
ds_map_empty(id) Devuelve true si el mapa está vacía. Es lo mismo que chequear si el número de valores en el mapa es cero.
ds_map_add(id,key,val) Añade la pareja llave (key)-valor (val) al mapa.
ds_map_replace(id,key,val) Reemplaza el valor correspondiente a la llave con un nuevo valor. 
ds_map_delete(id,key) Elimina la pareja llave-valor especificada del mapa. Si hay varias parejas con la misma llave sólo 1 es eliminada. 
ds_map_exists(id,key) Devuelve true si la llave existe en el mapa.
ds_map_find_value(id,key) Devuelve el valor correspondiente a la llave.
ds_map_find_previous(id,key) Devuelve la mayor llave que sea menor que la indicada.
ds_map_find_next(id,key) Devuelve la menor llave que sea mayor que la indicada.
ds_map_find_first(id) Devuelve la menor llave del mapa.
ds_map_find_last(id) Devuelve la mayor llave del mapa.

COLAS DE PROPIEDADES

En una cola de prioridad a cada valor se le asigna una prioridad.  Así puedes buscar los valores con mayor o menor prioridad y controlar ciertas cosas según su prioridad.

ds_ priority _create()Crea una nueva cola. La función devuelve un número entero con la id de la cola para usarla en las diferentes funciones. Puedes crear varias colas.
ds_ priority _destroy(id) Destruye la cola, liberando la memoria usada. No olvides usar esta función cuando ya no necesites la cola.
ds_ priority _clear(id)Limpia la cola, borrando todos los valores que contiene pero no la destruye.
ds_ priority _size(id) Devuelve el número de valores en la cola.
ds_ priority _empty(id) Devuelve true si la cola está vacía. Es lo mismo que chequear si el número de valores en la cola es cero.
ds_priority_add(id,val,prio) Añade el valor con la prioridad especificada a la cola.
ds_priority_change_priority(id,val,prio) Cambia la prioridad del valor especificado al nuevo valor.
ds_priority_find_priority(id,val) Devuelve la prioridad del valor especificado.
ds_priority_delete_value(id,val) Elimina el valor (con su prioridad) de la cola de prioridad.
ds_priority_delete_min(id)Devuelve el valor con la menor prioridad y lo elimina de la cola.
ds_priority_find_min(id) Devuelve el valor con la menor prioridad pero no lo elimina de la cola.
ds_priority_delete_max(id) Devuelve el valor con la mayor prioridad y lo elimina de la cola.
ds_priority_find_max(id) Devuelve el valor con la mayor prioridad pero no lo elimina de la cola.

REJILLAS

Una rejilla es simplemente un vector (o arreglo) bidimensional. Una rejilla tiene un entero con su altura y anchura. Esta estructura te permite acceder a los valores indicando el valor de la celda deseada (el primer valor en las direcciones x e y es 0). Pero también puedes dar valores por regiones, añadirlos y encontrar los valores máximo, mínimo o medio de una región. Esta estructura es útil para representar por ejemplo un campo de juego. Aunque todo lo que hace esta estructura se puede conseguir usando vectores, las operaciones por regiones son mucho más rápidas.

ds_grid_create(w,h) Crea una rejilla con la anchura especificada en w y la altura especificada en h. La función devuelve la id de la rejilla que debe usarse en las demás funciones. 
ds_grid_destroy(id) Destruye la rejilla, liberando la memoria usada. No olvides usar esta función cuando ya no necesites la rejilla.
ds_grid_resize(id,w,h) Aumenta el tamaño de la rejilla a la nueva anchura y altura especificadas. Las celdas ya existentes mantienen su valor.
ds_grid_width(id) Devuelve la anchura de la rejilla.
ds_grid_height(id) Devuelve la altura de la rejilla.
ds_grid_clear(id,val) Hace que todos las celdas de la rejilla tomen el valor val (puede ser un número o una cadena de texto).
ds_grid_set(id,x,y,val)Asigna a la celda x,y el valor val.
ds_grid_add(id,x,y,val) Suma el valor a la celda especificada. Para cadenas de texto, la cadena se concatena a la que ya existe en la celda.
ds_grid_multiply(id,x,y,val) Multiplica la celda por el valor. Sólo se puede usar con números. 
ds_grid_set_region(id,x1,y1,x2,y2,val) Todas las celdas de la región especificada toman el valor especificado. 
ds_grid_add_region(id,x1,y1,x2,y2,val)Suma el valor a la región especificada. Para cadenas de texto, concatena la cadena de texto a la existente en cada celda.
ds_grid_multiply_region(id,x1,y1,x2,y2,val) Multiplica el valor por todas las celdas de la región (sólo para valores numéricos).
ds_grid_set_disk(id,xm,ym,r,val) Da el valor especificado a toda las celdas dentro del círculo de centro xm,ym y radio r.
ds_grid_add_disk(id,xm,ym,r,val) Suma el valor a la región especificada por el círculo. Para cadenas de texto, concatena la cadena de texto a la existente en cada celda.
ds_grid_multiply_disk(id,xm,ym,r,val) Multiplica el valor por todas las celdas de la región (sólo para valores numéricos).
ds_grid_get(id,x,y) Devuelve el valor de la celda indicada.
ds_grid_get_sum(id,x1,y1,x2,y2) Devuelve la suma de los valores de las celdas de la región especificada. Sólo funciona con valores numéricos.
ds_grid_get_max(id,x1,y1,x2,y2) Devuelve el máximo valor de las celdas de la región especificada. Sólo funciona con valores numéricos.
ds_grid_get_min(id,x1,y1,x2,y2) Devuelve el mínimo valor de las celdas de la región especificada. Sólo funciona con valores numéricos.
ds_grid_get_mean(id,x1,y1,x2,y2) Devuelve el valor medio de las celdas de la región especificada. Sólo funciona con valores numéricos.
ds_grid_get_disk_sum(id,xm,ym,r) Devuelve la suma de los valores de las celdas de la región circular especificada. Sólo funciona con valores numéricos..
ds_grid_get_disk_min(id,xm,ym,r) Devuelve el mínimo valor de las celdas de la región circular especificada. Sólo funciona con valores numéricos.
ds_grid_get_disk_max(id,xm,ym,r) Devuelve el máximo valor de las celdas de la región circular especificada. Sólo funciona con valores numéricos.
ds_grid_get_disk_mean(id,xm,ym,r) Devuelve el valor medio de las celdas de la región circular especificada. Sólo funciona con valores numéricos.
ds_grid_value_exists(id,x1,y1,x2,y2,val) Devuelve true si el valor especificado existe en la región. 
ds_grid_value_x(id,x1,y1,x2,y2,val) Devuelve la coordenada x de la celda de la región en la que aparece el valor especificado.
ds_grid_value_y(id,x1,y1,x2,y2,val) Devuelve la coordenada y de la celda de la región en la que aparece el valor especificado.
ds_grid_value_disk_exists(id,xm,ym,r,val) Devuelve true si el valor especificado existe en la región circular.
ds_grid_value_disk_x(id,xm,ym,r,val) Devuelve la coordenada x de la celda de la región circular en la que aparece el valor especificado.
ds_grid_value_disk_y(id,xm,ym,r,val) Devuelve la coordenada y de la celda de la región circular en la que aparece el valor especificado.

CREANDO PARTICULAS

EFECTOS SIMPLES

La forma más sencilla de crear partículas es usando el mecanismo de efectos. Los efectos se crean usando partículas, pero tú no tienes que preocuparte de eso. Simplemente eliges el tipo de efecto, la posición donde debe crearse, su color y su tamaño y del resto se encarga Game Maker.

Los efectos disponibles son:

• ef_explosion
• ef_ring
• ef_ellipse
• ef_firework
• ef_smoke
• ef_smokeup
• ef_star
• ef_spark
• ef_flare
• ef_cloud
• ef_rain
• ef_snow

Algunos sólo necesitarás crearlos una vez (como la explosión) mientras que otros deberás crearlos en cada step (como el humo o la lluvia). Observa que los efectos de nieve y lluvia siempre se crean en la parte superior de la pantalla así que la posición que especifiques para ellos será irrelevante.

Aunque esto pueda sonar limitado, se pueden conseguir efectos muy espectaculares. Por ejemplo, creando una pequeña nube de humo rojo debajo de una nave espacial en cada step se consigue una cola de fuego. Las dos funciones siguientes sirven para crear efectos:

effect_create_below(kind,x,y,size,color) Crea un efecto del tipo indicado en kind en la posición especificada. size es el tamaño del efecto según la convención siguiente: 0 = pequeño, 1 = mediano, 2 = grande. color indica el color del efecto. El efecto se crea por debajo de la instancia con una profundidad (depth) igual a 100000.
effect_create_above(kind,x,y,size,color) Igual que la función anterior, pero esta vez el efecto se crea encima de la instancia, con una profundidad igual a-100000.

Para eliminar todos los efectos usa la función:

effect_clear() Detiene y elimina todos los efectos.

Un tipo de particular define la forma, color y movimiento de una clase de partículas. Sólo necesitas definir un tipo de partícula una vez durante el juego, una vez hecho esto puede ser usado por cualquier sistema de partículas. Los tipos de partículas tienen un gran número de características que pueden ser cambiadas para alterar su apariencia o comportamiento. Con la elección adecuada puedes crear cualquier tipo de efecto.

Las funciones para crear y destruir tipos de partículas son:

 part_type_create() Crea un Nuevo tipo de particular. Devuelve el índice del tipo. Este índice debe usarse en todas las llamadas a las funciones siguientes para configurar las propiedades del tipo de partícula, por lo que es aconsejable que lo guardes en una variable global.
part_type_destroy(ind) Destruye el tipo de particular ind. Llama a esta función cuando ya no se necesite el tipo de partícula para ahorrar espacio. 
part_type_exists(ind) Devuelve si el tipo indicado de particular existe. 
part_type_clear(ind) Devuelve el tipo de particular ind a sus valores por defecto.

LA FORMA DE UNA PARTICULA

Las partículas tienen una forma. Esta forma se indica mediante un sprite. Puedes usar cualquier sprite que quieras para tus partículas pero debes saber que además hay 15 tipos de sprites ya definidos. Estos sprites son todos de tamaño 64x64 y poseen valores de transparencia que los hacen fundirse de manera excelente con el fondo. Estos sprites se indican con las constantes:

• pt_shape_pixel (pixel)

• pt_shape_disk (disco)

• pt_shape_square (cuadrado)

• pt_shape_line (línea)

• pt_shape_star (estrella)

• pt_shape_circle (círculo)

• pt_shape_ring (anillo)

• pt_shape_sphere (esfera)

• pt_shape_flare (brillo)

• pt_shape_spark (chispa)

• pt_shape_explosion (explosión)

• pt_shape_cloud (nube)

• pt_shape_smoke (humo)

• pt_shape_snow (nieve)

Para indicar la forma debes usar la función:

part_type_shape(ind,shape) Aplica la forma tipo shape a la partícula ind.

También puedes usar tu propio sprite con la función:

part_type_sprite(ind,sprite,animate,stretch,random) Asigna el sprite para el tipo de particular ind. Con la opción animate puedes indicar si el sprite debe ser animado. Con stretch indicas si la animación debe repetirse durante el tiempo de vida de la partícula. Y con random indicas si se escoge una subimagen aleatoria como la imagen inicial.

Una vez que hayas seeccionado el sprite para el tipo de partícula puedes elegir el tamaño de éste. Un tamaño de 1 significa el tamaño normal del sprite. Un tipo de partícula se puede definir para que todas las partículas tengan el mismo tamaño o para que tengan tamaños distintos. También puedes especificar un rango de tamaños, si el tamaño debe variar durante la vida de la partícula y si puede alternarse al crecer o disminuir, creando un efecto de tintineo.

 

part_type_size(ind,size_min,size_max,size_incr,size_wiggle) Establece los parámetros de tamaño para el tipo de partícula. Debes indicar el tamaño inicial, el tamaño final, la cantidad que debe crecer en cada step (usa un valor negativo para que disminuya) y el tintineo (El valor por defecto es 1 y el tamaño no cambia).

Las partículas también tienen una orientación que se indica en grados en sentido antihorario. Al igual que el tamaño, la orientación puede crecer, disminuir y puede ser la misma para todas las partículas o diferente para cada una.

part_type_orientation(ind,ang_min,ang_max,ang_incr,ang_wiggle,ang_relative) Aplica la orientación al tipo de partícula. Debes indicar la orientación inicial, final, el incremento o decremento en cada step, si la orientación tintinea y si los valores son relativos al movimiento actual (1) o absolutos (0). Por ejemplo, si ponemos todos los valores a 0 menos ang_relative, que lo ponemos a 1, la orientación de la partícula seguirá el camino que ésta describa.

COLOR Y BLENDING

Las partículas tendrán un color. Hay diferentes maneras de especificar un color para una partícula. La más simple es especificar solamente un color. Pero también puedes especificar dos ó tres colores que se interpolarán a lo largo de la vida de la partícula. Por ejemplo, una partícula puede crearse siendo blanca y poco a poco irse convirtiendo en negra. Otra posibilidad es indicar que el color de cada partícula debe ser diferente y elegido de un rango de colores especificado.

El color por defecto es blanco. Cuando usas un sprite con sus propios colores esto es lo que normalmente quieres y no necesitas especificar ninguna propiedad de color.

part_type_color1(ind,color1) Indica un sólo color para la partícula. part_type_color2(ind,color1,color2) Especifica dos colores entre los que se interpolará. 
part_type_color3(ind,color1,color2,color3) Ahora los colores representan el color incial, medio y final.
part_type_color_mix(ind,color1,color2) El color será seleccionado de una mezcla aleatoria de estos dos colores y permanecerá inalterado durante la vida de la partícula.
part_type_color_rgb(ind,rmin,rmax,gmin,gmax,bmin,bmax) Se puede usar para especificar que cada partícula tendrá un color fijo pero escogido de un rango de colores que especificas en modo rgb. 
part_type_color_hsv(ind,hmin,hmax,smin,smax,vmin,vmax) Igual que la anterior, pero esta vez el rango se especifica en modo hsv.

Además del color, también puedes especificar un valor de transparencia. Así puedes conseguir que las partículas desaparezcan poco a poco.

part_type_alpha1(ind,alpha1) Aplica un único valor de transparencia (entre 0 y 1) al tipo de partícula.
part_type_alpha2(ind,alpha1,alpha2) Igual que la anterior, pero esta vez la transparencia en cada momento se interpola entre las dos especificadas.
part_type_alpha3(ind,alpha1,alpha2,alpha3) Igual que a anterior, pero esta vez la transparencia en cada momento se interpola entre las tres especificadas.

Normalmente las partículas se mezclan con el fondo igual que los sprites. Pero también es posible usar additive blending, controlando así la forma en que se mezclan. Esto resulta un efecto muy bueno para explosiones.

part_type_blend(ind,additive) Indica si se debe utilizar additive blending (1) or normal blending (0) para el tipo de partícula.

VIDA Y MUERTE

Las partículas viven durante un tiempo limitado, después, desaparecen. La vida de las partículas se mide en steps. Puedes indicar su vida, o un rango para cada tipo de partículas. Además, las partículas pueden crear otras partículas en cada step o cuando mueren. Vigila que el número de partículas total no sea demasiado elevado. 
part_type_life(ind,life_min,life_max) Establece los límites del tiempo de vida para el tipo de partícula (Ambos son 100 por defecto).

part_type_step(ind,step_number,step_type) Establece el número y tipo de partículas que deben ser generadas en cada step para el tipo indicado de particula. Si usas un número negativo para step_number, por ejemplo -5, se generará una partícula cada 5 steps.

part_type_death(ind,death_number,death_type) Establece el número y tipo de partículas que deben ser generadas cuando una particular del tipo indicado llega al final de su ciclo de vida. Puedes usar valores negativos al igual que en la función anterior. La partícula sólo creará otras partículas al llegar al final de su vida y no cuando sea destruida por un destructor (lee más adelante).

MOVIMIENTOS DE PARTICULAS

Las partículas se pueden mover durante su vida. Pueden tener velocidad inicial y dirección y cambiar durante su vida. También pueden verse afectadas por la gravedad.
part_type_speed(ind,speed_min,speed_max,speed_incr,speed_wiggle) Establece las propiedades de velocidad para el tipo de partícula. (Todos los valores son 0 por defecto). Especificas un valor mínimo y máximo para la partícula y cuando ésta sea creada se escogerá un valor aleatorio entre ellos. Puedes especificar un valor negativo en speed_incr para hacer que la partícula se frene (aunque nunca llegará a tener velocidad negativa). 
part_type_direction(ind,dir_min,dir_max,dir_incr,dir_wiggle) Establece las propiedades de dirección para el tipo de partícula, en grados antihorarios (0-360).(Todos los valores son 0 por defecto). 
part_type_gravity(ind,grav_amount,grav_dir) Establece las propiedades de gravedad para el tipo de partícula. (Por defecto no hay valor de gravedad). 

SISTEMA DE PARTICULAS

Las partículas tienen vida en sistemas de partículas. Por lo que para tener partículas en tu juego necesitas crear uno o más sistemas de partículas. Puede haber muchos tipos diferentes de sistemas de partículas. Por ejemplo, si tu juego tiene varias pelotas y cada pelota debiera tener una cola de partículas, lo más probable es que cada pelota tenga su sistema de partículas. La manera más fácil para manejar los sistemas de partículas es crear uno y luego crear partículas en él, usando los tipos partículas que especificaste antes. Pero, como veremos a continuación, los sistemas de partículas pueden contener emisores que automáticamente producen partículas, atractores que las atraen y destructores que las eliminan.

Una vez que las partículas se añaden a un sistema son dibujadas y actualizadas en cada step automáticamente. Para definir si las partículas se deben dibujar delante o detrás de las demás instancias, los sistemas de partículas poseen una profundidad.

Los sistemas de partículas no se eliminarán aunque reinicies el juego, para eliminarlos debes usar la función adecuada. Así que asegúrate de hacerlo cuando ya no los necesites.

Las siguientes funciones permiten manejar los sistemas de partículas:

part_system_create() Crea un nuevo sistema de partículas. Devuelve el índice del sistema creado. Este índice debe emplearse en las llamadas a las funciones siguientes para configurar las propiedades del sistema de partículas. 
part_system_destroy(ind) Destruye el sistema de partículas ind. Llama a esta función si ya no harás uso del sistema para ahorrar espacio. 
part_system_exists(ind) Devuelve si el sistema de partículas ind existe. 
part_system_clear(ind) Devuelve el sistema ind a sus valores por defecto, removiendo todas las partículas, emisores y atractores en él. 
part_system_draw_order(ind,oldtonew) Establece el orden en el que el sistema dibuja las partículas. Cuando oldtonew es true las partículas más viejas son dibujadas primero y las nuevas se dibujan sobre ellas (valor por defecto). De otra forma las partículas más recientes son dibujadas primero. Esto puede resultar en varios efectos diferentes. 
part_system_depth(ind,depth) Especifica la profundidad del sistema de partículas.
part_system_position(ind,x,y) Especifica la posición en la que se dibuja el sistema de partículas. Si quieres dibujar el sistema relativo a un objeto puedes usar sus coordenadas.

Como ya hemos visto, los sistemas de partículas se dibujan y actualizan automáticamente. Pero a veces puedes no querer que esto sea así. Las siguientes funciones te permiten controlar estos aspectos:

part_system_automatic_update(ind,automatic) Indica si el sistema debe actualizare automáticamente (1) o no (0).
part_system_automatic_draw(ind,automatic) Indica si el sistema debe dibujarse automáticamente (1) o no (0).
part_system_update(ind) Esta función actualiza el sistema y permite a los emisores crear partículas. Puedes llamar a esta función cuando no uses actualización automática, o para acelerar un poco el sistema al inicio. 
part_system_drawit(ind) Esta función dibuja el sistema de partículas si has desactivado la opción automática. Debes llamar a esta función desde el evento draw de algún objeto.

Las siguientes funciones se encargan de las partículas de un sistema de partículas:

part_particles_create(ind,x,y,parttype,number) Esta función crea number partículas del tipo ind en la posición (x,y) dentro del sistema.

part_particles_create_color(ind,x,y,parttype,color,number) Esta función crea number partículas del tipo ind en la posición (x,y) dentro del sistema con el color indicado. Esto es útil cuando el tipo de partícula sólo usa un color o no define ninguno.

 part_particles_clear(ind) Esta función elimina todas las partículas del sistema. 
part_particles_count(ind) Esta función devuelve el número de partículas en el sistema.

EMISORES

Los emisores crean partículas. Pueden crear un flujo continuo de partículas o pueden lanzar un cierto número de partículas usando la función adecuada. Un sistema de partículas puede tener un número arbitrario de emisores. Un emisor tiene las siguientes propiedades:

• xmin, xmax, ymin, ymax indican la extensión de la región en la cual se generan las partículas.
• shape indica la forma de la región. Puede tener uno de los siguientes valores:
  • ps_shape_rectangle
  • ps_shape_ellipse
  • ps_shape_diamond
  • ps_shape_line
• distribution indica la distribución usada para general las partículas. Puede tener uno de los siguientes valores:
  • ps_distr_linear indica una distribución lineal, esto es que en toda la región se tiene la misma oportunidad de que aparezca una partícula
  • ps_distr_gaussian indica una distribución Gaussiana en la cual se generan más partículas en el centro que en las orillas de la región
• particle type indica el tipo de partículas que serán generadas
• number indica el número de partículas generadas en cada step. Si es menor que 0, en cada step se generará una particular con una probabilidad de –1/number. Por ejemplo con un valor de –5 se generará una particular en promedio una vez cada 5 steps.

Las siguientes funciones permiten establecer los emisores y permitirles crear partículas. Nota que cada una de ellas necesita el id del  sistema de partículas al que pertenecen como primer argumento.

part_emitter_create(ps) Crea un nuevo emisor en el sistema de partículas ps. Devuelve el índice del emisor. Este índice debe usarse en todas las llamadas a las funciones siguientes para configurar las propiedades del emisor. 
part_emitter_destroy(ps,ind) Destruye el emisor ind en el sistema de partículas ps. Llama a esta función si no necesitas más del emisor para ahorrar espacio.

part_emitter_destroy_all(ps) Destruye todos los emisores del sistema de partículas ps.  
part_emitter_exists(ps,ind) Devuelve true si el emisor ind existe en el sistema ps. 
part_emitter_clear(ps,ind) Devuelve el emisor ind a sus valores por defecto. 
part_emitter_region(ps,ind,xmin,xmax,ymin,ymax,shape,distribution) Establece la región y distribución del emisor. 
part_emitter_burst(ps,ind,parttype,number) Emite number  partículas del tipo partype en forma de estallido (una sola vez) desde el emisor ind. 
part_emitter_stream(ps,ind,parttype,number) Desde este momento se crearán number partículas de tipo partype desde el emisor ind en cada step. Si indicas un número menor a 0 en cada step una particular sera generada con una probabilidad de –1/number. Por ejemplo con un valor de –5 se creará en promedio una particular cada 5 steps.

ATRACTORES

Además de los emisores, un sistema de partículas también puede contener atractores. Un atractor atrae a las partículas (o las aleja). Un sistema de partículas puede tener múltiples atractores. Aunque se te recomienda solo usar unos pocos porque alentarán el procesamiento de las partículas. Un atractor tiene las siguientes propiedades:

• x,y indican la posición del atractor.
• force indican la fuerza de atracción del atractor. El cómo actúe la fuerza sobre las partículas depende de los siguientes parámetros.
• dist indica la máxima distancia a la cual el atractor tiene efecto. Solo las partículas con una distancia al atractor menor que dist serán atraídas.
• kind indica el tipo de atractor. Se tienen los siguientes valores
  • ps_force_constant indica que la fuerza es constante independientemente de la distancia.
  • ps_force_linear indica una fuerza que aumenta linealmente. A la distancia máxima la fuerza es 0 mientras que en la posición del atractor la fuerza tiene el valor force indicado.
  • ps_force_quadratic indica que la fuerza aumenta de manera cuadrática.
• additive indica si la fuerza se suma a la velocidad y dirección en cada step (true) o si solo se aplica a la posición de la particular (false). Cuando es true la particular acelerará hacia el atractor mientras que cuando sea false se moverá hacia él con velocidad constante.

Las siguientes funciones definen atractores. Nota que todas necesitan como primer argumento el índice del sistema de partículas al cual pertenecen.

part_attractor_create(ps) Crea un nuevo atractor en el sistema de partículas ps. Devuelve el índice del atractor. Este índice debe emplearse en la llamada a las funciones siguientes para configurar las propiedades del atractor. 
part_attractor_destroy(ps,ind) Destruye el atractor ind dentro del sistema de partículas ps. Llama a esta función si ya no necesitas el atractor para ahorrar espacio. 
part_attractor_destroy_all(ps) Destruye todos los atractores que hayan sido creados en el sistema de partículas ps.
part_attractor_exists(ps,ind) Devuelve true si el atractor ind existe dentro del sistema de partículas ps. 
part_attractor_clear(ps,ind) Devuelve los valores del atractor a sus valores por defecto. 
part_attractor_position(ps,ind,x,y) Establece a (x,y) la posición del atractor ind. 
part_attractor_force(ps,ind,force,dist,kind,aditive) Establece las propiedades de fuerza del atractor ind.

DESTRUCTURAS

Los destructores destruyen las partículas cuando aparecen dentro de su región. Un sistema de partículas puede tener un número arbitrario de destructores. Un destructor cuenta con las siguientes propiedades:

• xmin, xmax, ymin, ymax indican la extensión de la región en la cual se destruyen las partículas.
• shape indica la forma de la región. Puede tener uno de los valores siguientes:
  • ps_shape_rectangle
  • ps_shape_ellipse
  • ps_shape_diamond

Las funciones siguientes configuran las propiedades de los destructores. Nota que cada una de ellas necesita como primer argumento el índice del sistema de partículas al que pertenece el destructor.

part_destroyer_create(ps) Crea un nuevo destructor en el sistema de partículas ps. Devuelve el índice del destructor. Este índice debe usarse en las llamadas a las funciones siguientes para configurar las propiedades del destructor. 
part_destroyer_destroy(ps,ind) Destruye el destructor ind dentro del sistema de partículas ps. Llama a esta función cuando ya no hagas uso del destructor para ahorrar espacio. 
part_destroyer_destroy_all(ps) Destruye todos los destructores que hayan sido creados en el sistema de partículas ps. 
part_destroyer_exists(ps,ind) Devuelve true si el destructor ind existe dentro del sistema de partículas ps. 
part_destroyer_clear(ps,ind) Devuelve el destructor a sus valores por defecto. 
part_destroyer_region(ps,ind,xmin,xmax,ymin,ymax,shape) Establece la región del destructor.

DEFLECTORES

Los deflectores desvían a las partículas cuando aparecen dentro de su región. Un sistema de partículas puede tener un número arbitrario de deflectores. Un deflector tiene las siguientes propiedades:

• xmin, xmax, ymin, ymax indican la extensión de la región en la cual las partículas son desviadas.
• kind indica el tipo de deflector. Puede tener uno de los siguientes valores:
  • ps_deflect_horizontal refleja las partículas horizontalmente; normalmente usado para paredes verticales
  • ps_deflect_vertical refleja las partículas verticalmente; normalmente usado para paredes horizontales
• friction la cantidad de fricción como resultado de un impacto con el deflector. Entre mayor sea este valor más se alentará la particular al impactarse con el deflector.

Se tienen las siguientes funciones para configurar las propiedades del deflector. Nota que todas necesitan como primer argumento el índice del sistema de partículas al cual pertenece el deflector.

part_deflector_create(ps) Crea un nuevo deflector en el sistema de partículas ps. Devuelve el índice del deflector. Este índice debe emplearse en las llamadas a las funciones siguientes para configurar las propiedades del deflector.
part_deflector_destroy(ps,ind) Destruye el deflector ind del sistema de partículas ps. Llama a esta función cuando ya no necesites el deflector para ahorrar espacio. 
part_deflector_destroy_all(ps) Destruye todos los deflectores que hayan sido creados en el sistema de partículas ps.
part_deflector_exists(ps,ind) Devuelve true si el deflector ind existe dentro del sistema de partículas ps. 
part_deflector_clear(ps,ind) Devuelve el deflector a sus valores por defecto. 
part_deflector_region(ps,ind,xmin,xmax,ymin,ymax) Establece la región para el deflector. 
part_deflector_kind(ps,ind,kind) Establece el tipo de deflector. 
part_deflector_friction(ps,ind,friction) Establece la fricción del deflector.

CAMBIADORES

Los cambiadores cambian ciertas partículas cuando aparecen dentro de su región. Un sistema de partículas puede tener un número arbitrario de cambiadores. Un cambiador tiene las siguientes propiedades:

• xmin, xmax, ymin, ymax indican la extensión de la región en la cual las partículas son cambiadas.
• shape indica la forma de la región. Puede tener uno de los valores siguientes:
  • ps_shape_rectangle
  • ps_shape_ellipse
  • ps_shape_diamond
• parttype1 indica el tipo de partícula a ser cambiado.
• parttype2 indica el tipo de partícula al que se cambiará.
• kind indica el tipo del cambiador. Puede tener uno de los siguientes valores:
  • ps_change_motion sólo cambia los parámetros de movimiento de la partícula, no el color o forma ni las propiedades de tiempo de vida
  • ps_change_shape sólo cambia los parámetros de forma de la partícula como el tamaño, el color y forma
  • ps_change_all cambia todos los parámetros, básicamente significa que la partícula es destruida y se crea una nueva del nuevo tipo.

Las siguientes funciones permiten establecer las propiedades del cambiador. Nota que cada una de ellas necesita como primer argumento el índice del sistema de partículas al que pertenece el cambiador.

part_changer_create(ps) Crea un nuevo cambiador en el sistema de partículas ps. Devuelve el índice del cambiador. Este índice debe usarse en las llamadas a las funciones siguientes para configurar las propiedades del cambiador. 
part_changer_destroy(ps,ind) Destruye el cambiador ind en el sistema de partículas ps. Llama a esta función si ya no necesitas el cambiador para ahorrar espacio. 
part_changer_destroy_all(ps) Destruye todos los cambiadores que hayan sido creados en el sistema de partículas ps. 
part_changer_exists(ps,ind) Devuelve true si el cambiador ind existe en el sistema de partículas ps. 
part_changer_clear(ps,ind) Devuelve las propiedades del cambiador a sus valores por defecto. 
part_changer_region(ps,ind,xmin,xmax,ymin,ymax,shape) Establece la región para el cambiador.
part_changer_types(ps,ind,parttype1,parttype2) Establece el tipo de partícula que debe ser cambiado y el tipo al que debe ser cambiado. 
part_changer_kind(ps,ind,kind) Establece el tipo de cambiador.

EJEMPLO DE FUEGOS ARTIFICIALES

Aquí tienes un ejemplo de un sistema de partículas que crea unos fuegos artificiales. Hace uso de dos tipos de partículas: uno que forma el cohete y otro que forma los fuegos artificiales en si. El cohete genera las partículas de los fuegos artificiales cuando se destruye. También tenemos un emisor en el sistema de partículas que emite regularmente partículas del cohete desde la parte baja de la pantalla. Para hacer que esto funcione necesitas un objeto. En su evento de creación colocamos el siguiente código que crea los tipos de partículas, un sistema de partículas y el emisor:

{

  // Crear el sistema de partículas

  ps = part_system_create();

  // the firework particles

  pt1 = part_type_create();

  part_type_shape(pt1,pt_shape_flare);

  part_type_size(pt1,0.1,0.2,0,0);

  part_type_speed(pt1,0.5,4,0,0);

  part_type_direction(pt1,0,360,0,0);

  part_type_color1(pt1,c_red);

  part_type_alpha2(pt1,1,0.4);

  part_type_life(pt1,20,30);

  part_type_gravity(pt1,0.2,270);

  // El cohete

  pt2 = part_type_create();

  part_type_shape(pt2,pt_shape_sphere);

  part_type_size(pt2,0.2,0.2,0,0);

  part_type_speed(pt2,10,14,0,0);

  part_type_direction(pt2,80,100,0,0);

  part_type_color2(pt2,c_white,c_gray);

  part_type_life(pt2,30,60);

  part_type_gravity(pt2,0.2,270);

  part_type_death(pt2,150,pt1);    /* Crear el fuego artificial al morir*/

  // Crear el emisor

  em = part_emitter_create(ps);

  part_emitter_region(ps,em,100,540,480,490,ps_shape_rectangle,ps_distr_linear);

  part_emitter_stream(ps,em,pt2,-4);   // Crear 1 cada 4 steps

}

Listo! Asegúrate de que el sistema de partículas (y tal vez los tipos de partículas) se destruyen al cambiar de room o el efecto durará para siempre.