Share
En este artículo, comenzaremos con los conceptos básicos del sistema de partículas GameMaker Studio y terminaremos con técnicas avanzadas e implementaciones. Piense en esto como un curso intensivo para familiarizarse y sentirse cómodo con una de las funciones integradas más poderosas de GameMaker Studio. La demostración y el archivo de proyecto descargable le permitirán seguir el artículo para ver exactamente de qué se trata el sistema de partículas..
El sistema de partículas GameMaker Studio es una forma barata y fácil de crear efectos llamativos para tu proyecto de juego. Mediante una combinación de partículas y emisores, puede crear rápidamente explosiones impresionantes, humo, sangre, metralla y muchos otros efectos. Se pueden lograr efectos similares utilizando objetos individuales, pero el costo de computación del sistema de efectos de partículas incorporado es mucho más barato.
Para utilizar el sistema de partículas en su proyecto, deberá comprender GML (lenguaje de GameMaker), pero una vez que se familiarice con el sistema de partículas, es simplemente una cuestión de completar los espacios en blanco y la experimentación..
Echa un vistazo a la demostración a continuación para ver lo que podemos lograr:
Los sistemas de partículas en GameMaker Studio constan de tres partes: el sistema en sí, la partícula y el emisor. Puede crear múltiples sistemas, y cada sistema puede contener múltiples partículas y emisores. Piense en el sistema como un contenedor, con las partículas y los emisores definidos dentro de.
Implementar un efecto de partículas en GameMaker Studio es un proceso de cuatro pasos.
Para enseñarle los conceptos básicos del sistema de partículas GameMaker Studio, comenzaremos creando este simple efecto de partícula verde..
Crear el sistema de partículas es tan simple como definir una variable. Creamos un objeto llamado obj_first_particle y coloque el siguiente código en el evento Crear del objeto:
FirstParticleSystem = part_system_create ();
El sistema de partículas adoptará el valor de profundidad del objeto en el que se define el sistema, pero también puede establecer la profundidad por separado con GML:
part_system_depth (FirstParticleSystem, 0);
Recuerde que los objetos y los sistemas de partículas con un alto valor de profundidad se dibujan primero en la pantalla. Con una profundidad de 0, Nuestro sistema de partículas verdes aparecerá sobre los objetos con una profundidad mayor que 0, y aparecerá debajo de los objetos con una profundidad inferior a 0.
Los sistemas de partículas se dibujan en la pantalla con una posición base relativa a (0,0). Si por alguna razón desea crear un desplazamiento para todas las posiciones futuras de este sistema de partículas, puede usar el siguiente código para crear una nueva posición base (donde Indiana es el sistema de partículas):
part_system_position (ind, x, y);
Con una nueva posición de base establecida en (10,10), una partícula creada en (25,25) en su lugar será atraído a (35,35). Cambiar la posición base de un sistema de partículas rara vez es necesario, pero puede que le resulte útil en su proyecto específico.
Ahora que el sistema se ha configurado, es hora de definir la partícula real que creará el emisor. Las partículas pueden contener una gran cantidad de parámetros que determinan cómo se verá y se comportará la partícula. El primer paso es crear una variable para la partícula, y lo hacemos en el Crear evento de la obj_first_particle objeto:
first_particle = part_type_create ();
A continuación, comenzamos a definir los parámetros individuales de la partícula. Como no planeamos alterar esta partícula durante el tiempo de ejecución, podemos colocar todos de este código en el Crear evento de la obj_first_particle objeto.
part_type_shape Determina la forma de la base de la partícula. Hay 14 formas predeterminadas de partículas disponibles en GameMaker Studio, y también puedes definir tus propias formas. Cubriremos esto en la sección avanzada a continuación, pero por ahora comencemos con un cuadrado básico.
part_type_shape (first_particle, pt_shape_square);
Para obtener una lista completa de las formas predeterminadas disponibles, consulte la documentación oficial de GameMaker.
Con part_type_scale, Podemos establecer los valores de escala base X e Y de la forma de la partícula. Como queremos una forma cuadrada perfecta, usamos el siguiente código:
part_type_scale (first_particle, 1,1);
part_type_size nos permite alterar el tamaño de la partícula en la creación y también a lo largo del tiempo. El formato para este código es part_type_size (ind, size_min, size_max, size_incr, size_wiggle).
Accentsconagua
Indiana es la variable de partícula. size_min y size_max determinar el rango del tamaño de partícula cuando se crea por primera vez. Si desea un tamaño uniforme, simplemente ingrese el mismo valor tanto para el mínimo como para el máximo. size_incr es un valor que permite que la partícula crezca o se contraiga con el tiempo. Este valor determina la velocidad de crecimiento, por lo que si no desea que su sprite cambie de tamaño, puede usar un valor de 0. size_wiggle es un poco más complicado, así que lo cubriremos en la sección de técnicas avanzadas a continuación.Aquí está el código de tamaño de partícula usado en nuestro efecto de partícula verde:
part_type_size (first_particle, 0.10,0.15, -. 001,0);
La partícula se creará con un tamaño en algún lugar entre 0.10 y 0.15 para crear variedad, y el sprite se reducirá lentamente a una velocidad de -0.001. Este valor de velocidad depende en gran medida de la velocidad de su habitación, por lo que es probable que tenga que experimentar con valores para obtener los resultados deseados. No vamos a utilizar un cambio de tamaño, por lo que establecemos el valor en 0.
Las partículas en GameMaker Studio pueden cambiar los colores con el tiempo. Esto se logra con part_type_color2 y part_type_color3. Si no quieres que tu sprite cambie de color, entonces puedes usar part_type_color1. Para nuestro efecto de partícula verde, queremos que comience con un color amarillo / verde brillante y luego cambie a un color verde sólido, así que usamos part_type_color2:
part_type_color2 (first_particle, 8454143,65280);
Los dos colores que seleccioné son valores numéricos específicos que uso regularmente, pero si quieres usar valores hexadecimales más tradicionales, puedes usar el formato $ RRGGBB.
Las partículas también pueden volverse más o menos transparentes con el tiempo con part_type_alpha2 y part_type_alpha3. Si quieres un valor alfa consistente, usa part_type_alpha1. Para nuestro efecto de partícula verde, queremos que la partícula comience a ser completamente opaca y se desvanezca en un 25% mientras permanece en la pantalla, por lo que necesitamos dos valores alfa:
part_type_alpha2 (first_particle, 1,0.75);
En GameMaker, alfa es un valor de 0 a 1. Un objeto completamente invisible tendrá un valor alfa de 0, mientras que un objeto completamente opaco tendrá un valor alfa de 1.
La velocidad de la partícula se determina al igual que el tamaño de partícula. Las partículas se crean dentro de un rango de valores de velocidad, y ese valor puede aumentar o disminuir. El formato para este código es part_type_speed (ind, speed_min, speed_max, speed_incr, speed_wiggle), dónde Indiana es la variable de partícula, speed_min y speed_max es el rango de velocidad, speed_incr es la velocidad a la que cambia la velocidad de las partículas, y speed_wiggle Es un parámetro que cubriremos más adelante..
El código de velocidad para nuestra partícula verde es:
part_type_speed (first_particle, 0.1,0.5,0,0);
Nuestra partícula comenzará a moverse con un valor de velocidad en algún lugar entre 0.1 y 0.5. Esta velocidad se mantendrá constante, por lo que utilizamos un valor de 0, y no volveremos a implementar el cambio de velocidad, por lo que usamos un valor de 0.
Mientras que el parámetro de velocidad de una partícula determina qué tan rápido se mueve, el parámetro de dirección determina dónde se mueve. El código de dirección está en el siguiente formato: part_type_direction (ind, dir_min, dir_max, dir_incr, dir_wiggle) y nuevamente establecemos la variable, el rango de inicio, un valor incremental y un valor de balanceo. Para el efecto de partícula verde, queremos que nuestra partícula comience a moverse en cualquier dirección, y queremos que esa dirección permanezca constante:
part_type_direction (first_particle, 0,359,0,0);
El rango de 0 a 359 garantiza que la partícula tenga la posibilidad de moverse en cualquier dirección (un ángulo entre 0 y 359 grados). Si quisieras que una partícula se moviera hacia arriba y solamente arriba, entonces usarías un rango de 90 a 90).
La gravedad de nuestro efecto de partículas es lo que lo hace más interesante. Mientras que nuestros parámetros de velocidad y dirección están configurados para crear una partícula que comienza moviéndose en una dirección a una velocidad constante, el parámetro de gravedad se activa y altera la partícula con el tiempo. Con un formato de part_type_gravity (ind, grav_amount, grav_direction), El parámetro de gravedad es muy simple:
part_type_gravity (first_particle, 0.02,90);
Al aplicar un ligero tirón gravitacional de 0.02 en una dirección hacia arriba (90 grados), podemos crear una partícula que parece flotar. Combinado con nuestro tamaño y parámetros alfa, la partícula se encoge y se vuelve más transparente con el tiempo, acompañada por la elevación gravitacional.
La orientación de la forma de la partícula también es importante para la apariencia del efecto, por lo que usamos part_type_orientation (ind, ang_min, ang_max, ang_incr, ang_wiggle, ang_relative) para girar el cuadrado con el tiempo.
Indiana es la variable de partícula. ang_min y ang_max Determinar el valor inicial del valor de rotación de la forma..ang_incr se utiliza para aumentar o disminuir la orientación de la forma con el tiempo.ang_relativo es un valor booleano para determinar si la orientación debe establecerse con relación al movimiento de la partícula (verdadero) o no (falso). Queremos que nuestra partícula verde gire ligeramente hacia la izquierda, así que usamos el siguiente código:
part_type_orientation (first_particle, 0,359,10,0, true);
Uno de los parámetros más importantes de una partícula es el esperanza de vida valor. Este valor determina el tiempo mínimo y máximo que una partícula se dibujará en la pantalla. Con dos valores mínimos y máximos idénticos, todas las partículas de ese tipo existirán durante la misma cantidad de tiempo. Queremos que nuestras partículas verdes tengan variedad, por lo que usaremos un rango de 100 a 150 para el valor de la vida útil:
part_type_life (first_particle, 100,150);
El parámetro final para las partículas es un booleano simple para determinar si las partículas deben mezclarse con un efecto de mezcla aditiva:
part_type_blend (first_particle, true);
El primer paso para definir un emisor es crear una variable. Definimos este emisor en el evento Crear del obj_first_particle objeto.
First_emitter = part_emitter_create (FirstParticleSystem);
A continuación, definimos la región del emisor con part_emitter_region (ps, ind, xmin, xmax, ymin, ymax, forma, distribución).
PD es el sistema de partículas al que pertenece el emisor y Indiana es la variable emitter.forma determina la forma de la región del emisor (ps_shape_rectangle, ps_shape_ellipse, ps_shape_diamond, ps_shap_line). distribución es una curva de distribución (ps_dist_linear, ps_distr_gaussian, ps_distr_invgaussian).Cubriremos los parámetros de forma y distribución con más detalle en la sección de técnicas avanzadas. Por ahora, usaremos la forma de elipse predeterminada y los valores de distribución gaussianos:
part_emitter_region (FirstParticleSystem, first_emitter, x-20, x + 20, y-20, y + 20, ps_shape_ellipse, ps_distr_gaussian);
Este código crea una región de emisor elíptica que tiene 40 píxeles de alto y 40 píxeles de ancho, y se centra en los valores de x e y de obj_first_particle objeto. Las partículas creadas por el emisor aparecerán dentro de esta región definida.
El siguiente paso es determinar uno de los dos tipos de emisores: Ráfaga o Corriente. Un emisor de ráfaga crea una cantidad específica de una determinada partícula cada vez que se activa. Un emisor de flujo crea una cantidad específica de una determinada partícula una vez en cada paso.
Echaremos un vistazo a los emisores de ráfaga más versátiles en la sección de técnicas avanzadas, así que por ahora solo usemos el emisor Stream:
part_emitter_stream (FirstParticleSystem, first_emitter, first_particle, 1);
Ponemos este código en el Crear evento de la obj_first_particle objeto, lo que hace que el emisor cree una partícula en cada paso tan pronto como se crea el objeto. Con una velocidad de sala de 30, nuestro emisor creará 30 partículas por segundo; para crear 60 partículas por segundo, simplemente usarías un valor de 2 en lugar de 1.
Y con eso, nuestro simple efecto de partícula verde está completo! La utilidad de este efecto es limitada, pero es importante comenzar poco a poco antes de sumergirse en los aspectos más complicados del sistema de partículas GameMaker Studio. Una vez que entienda los conceptos básicos del sistema de partículas, puede comenzar a implementar sistemas de partículas más avanzados.
Wiggle es un parámetro simple pero poderoso que puede cambiar drásticamente la apariencia de tus partículas. El parámetro wiggle hace que la partícula oscile entre los valores mínimo y máximo durante la vida útil de la partícula. El valor puede estar entre 0 y 20 y determina la velocidad del meneo.
El ejemplo de "Fire Bubble" en la demostración incorporada utiliza un valor de meneo de 0.40 en el part_type_size parámetro:
part_type_size (fire_bubble_part, 0.25,0.75, -0.01,0.40);
Una de las implementaciones más comunes de sistemas de partículas involucra partículas que emanan de detrás de un objeto en movimiento, como un rastro de humo en un cohete. Para lograr este efecto en GameMaker Studio, es necesario colocar un emisor Burst en el objeto de un objeto. Paso evento.
El ejemplo incluido utiliza el mismo sistema de partículas verdes que antes, pero con un emisor ligeramente modificado. En lugar de activar un emisor de corriente en el objeto Crear evento, un emisor de ráfaga se coloca en el objeto Paso evento. La posición actual del cursor del mouse se compara con la posición anterior del cursor, y si hay un cambio en la posición del cursor, el emisor Burst se activa para liberar cinco partículas:
x = mouse_x; y = mouse_y; part_emitter_region (MouseParticle, green_mouse_emitter, x, x, y, y, 0,0); si x! = old_x || old_y! = y part_emitter_burst (MouseParticle, green_mouse_emitter, green_mouse_particle, 5); old_x = x; old_y = y;
Al utilizar las diferentes formas de emisores y las curvas de distribución, puede crear efectos muy diferentes. La distribución de la curva lineal combinada con un emisor de partículas en forma de línea puede crear un efecto de lluvia convincente.
part_emitter_region (RainParticle, rain_emitter, -100, room_width, y, y, ps_shape_line, ps_distr_linear);
La forma del emisor se define por una línea que comienza 100 píxeles a la izquierda del origen de la sala y se extiende hasta el ancho de la sala. Se utiliza una curva de distribución lineal para distribuir las partículas de lluvia uniformemente en la región del emisor. También es útil utilizar part_system_update Para avanzar la partícula de lluvia varios pasos en el Crear evento. Este código da la impresión de que la lluvia caía antes de cargar la habitación, aunque el sistema de partículas todavía no existía en la memoria.
repetir (room_speed * 3) part_system_update (RainParticle);
Las partículas individuales dentro de un sistema también pueden generar otras partículas en Paso y Muerte eventos. El ejemplo muestra una partícula de chispa púrpura que genera partículas de polvo más pequeñas a medida que viaja hacia la derecha y genera una partícula de humo al final de su vida útil:
part_type_step (spark_particle, 1, dust_particle); part_type_death (spark_particle, 5, smoke_particle);
Mediante el uso part_type_sprite (ind, sprite, animate, stretch, random), Puede utilizar sprites personalizados en lugar de los tipos de partículas incorporados de GameMaker..
Indiana es la variable de partícula.duende es la variable sprite que se utilizará.animar es un booleano para determinar si las subimágenes deben ser animadas.tramo es un booleano que hace coincidir la longitud de la animación con la vida útil de la partícula. aleatorio es un booleano para determinar si la subimagen inicial debe seleccionarse al azar.part_type_sprite (heart_particle, spr_heart, false, false, false);
Lo más importante que debe recordar sobre el sistema de partículas de GameMaker Studio es que debe eliminar manualmente los elementos de la memoria cuando no esté en uso. A diferencia de los objetos de juegos estándar, los sistemas de partículas permanecerán en la memoria incluso si cambias de habitación. La forma más fácil de manejar esto es colocar el código de administración de memoria en los eventos de cambio de sala de los objetos del juego..
part_system_clear (ind): Elimina todos los emisores y partículas que pertenecen a un sistema de partículas específico.part_system_clear (ind): Borra todas las instancias de un tipo de partícula específico.part_emitter_clear (ps, ind): Borra todas las partículas pertenecientes a un emisor específico.part_emitter_destroy (ps, ind): Destruye un emisor específico en un sistema de partículas específico.part_emitter_destroy_all (ps): Destruye todos los emisores en un sistema de partículas específico.part_type_destroy (ind): Destruye un tipo de partícula específica.part_system_destroy (ind): Destruye todo un sistema de partículas, incluidas todas las partículas y emisores contenidos dentro de.Incluso con un tutorial tan extenso, solo hemos arañado la superficie de los tipos de efectos que puede realizar el sistema de partículas GameMaker Studio. La clave para dominar las partículas es la familiaridad y la experimentación, así que salte y comience a crear sus propios efectos utilizando el conocimiento que ha adquirido. Asegúrese de consultar la documentación oficial de GameMaker para ver todo el sistema de partículas disponible GML!
