Padroneggiare il Sistema Particellare di GameMaker Studio

Italian (Italiano) translation by Chip (you can also view the original English article)

In questo articolo, inizieremo dalle basi del sistema di particelle di GameMaker Studio e finiremo con le tecniche avanzate e le loro implementazioni. Pensate a questo come un corso accelerato per avere familiarità e comodità nell'uso di una delle più potenti funzionalità incorporate in GameMaker Studio. Il file di progetto scaricabile e il demo e vi permetteranno di seguire l'articolo per vedere esattamente tutto ciò che riguarda il sistema di particelle.

Come apprendere

Come apprendere GameMaker: Studio

Jacob Ford

Una Panoramica del Sistema Particellare

Il sistema particellare di GameMaker Studio è un modo economico e semplice per creare effetti appariscenti per il progetto del vostro gioco. Attraverso una combinazione di particelle ed emettitori, è possibile creare rapidamente esplosioni impressionanti, fumo, sangue, schegge, e innumerevoli altri effetti. Effetti simili possono essere ottenuti utilizzando singoli oggetti, ma il costo di calcolo del sistema di effetti particellari incorporato è molto più economico.

Per utilizzare il sistema di particelle nel progetto, è necessario comprendere GML (GameMaker Language), ma una volta che si sarà diventati familiari con il sistema di particelle, sarà semplicemente una questione di riempire gli spazi vuoti e sperimentazione.

Osservate la demo qui sotto per vedere cosa possiamo ottenere:

Basi del Sistema Particellare

Il Sistema di particelle in GameMaker Studio è costituito da tre parti: il sistema stesso, la particella e l'emettitore. È possibile creare più sistemi e ogni sistema può contenere più particelle ed emettitori. Pensiamo al sistema come un contenitore, con le particelle e gli emettitori definiti all'interno.

L'implementazione di un effetto particellare in GameMaker Studio è un processo diviso in quattro fasi.

In primo luogo, è necessario definire il sistema di particelle in sé.
Poi, si definiscono le particelle reali che verranno utilizzate all'interno di quel sistema.
Successivamente, è necessario definire l'emettitore che creerà le vostre particelle già definite.
Infine, è necessario determinare quando e dove l'emettitore di particelle apparirà nel vostro gioco.

Per spiegare le basi del sistema di particelle di GameMaker Studio, inizieremo con la creazione di questo semplicissimo effetto particellare verde.

Creazione del Sistema di Particelle

La creazione del sistema di particelle è semplice come la definizione di una variabile. Creiamo un oggetto chiamato obj_first_particle ed inseriamo il codice seguente nell'evento Create dell'oggetto:

1	FirstParticleSystem = part_system_create();

Il sistema di particelle adotterà il valore profondità definito dell'oggetto nel sistema, ma è anche possibile impostare la profondità separatamente con GML:

1	part_system_depth(FirstParticleSystem,0);

Ricordate che gli oggetti e i sistemi di particelle con un alto valore di profondità saranno disegnati prima sullo schermo. Con una profondità di 0, il nostro sistema di particelle verde apparirà sopra gli oggetti con una profondità maggiore di 0 e apparirà sotto gli oggetti con una profondità minore di 0.

I sistemi di particelle sono disegnati sullo schermo con una posizione di base rispetto a (0,0). Se per qualche motivo si desidera creare un offset per tutte le posizioni future di questo sistema di particelle, è possibile utilizzare il seguente codice per creare una nuova posizione di base (dove ind è il sistema di particelle):

1	part_system_position(ind, x, y);

Con una nuova posizione di base impostata su (10,10), un particellare creato in (25,25) sarà disegnato in (35,35). E' raro cambiare la posizione di base di un sistema di particelle ma si può essere utile nel vostro specifico progetto.

Creazione del Tipo di Particella

Ora che il sistema è stato configurato, è il momento di definire l'effettiva particella che l'emettitore creerà. Le particelle possono contenere un gran numero di parametri che indicano come la particella apparirà e si comporterà. Il primo passo è quello di creare una variabile per la particella e lo facciamo nell'evento Create dell'oggetto obj_first_particle:

1	first_particle = part_type_create();

Quindi, cominciamo definendo i singoli parametri della particella. Dal momento che non abbiamo intenzione di modificare questa particella durante il runtime, possiamo collocare tutto questo codice nell'evento Create dell'oggetto obj_first_particle.

part_type_shape determina la forma di base della particella. Ci sono 14 forme di particelle di default disponibili in GameMaker Studio, ed è anche possibile definire le proprie forme. Parleremo di questo nella sezione avanzata più sotto, ma per ora iniziamo con un semplice quadrato di base.

1	part_type_shape(first_particle,pt_shape_square);

Per un elenco completo delle forme predefinite disponibili, consultare la documentazione ufficiale di GameMaker.

Con part_type_scale, possiamo impostare la scalatura di base X e Y della forma delle particelle. Dal momento che vogliamo una forma quadrata perfetta, si usa il seguente codice:

1	part_type_scale(first_particle,1,1);

part_type_size ci permette di modificare la dimensione della particella durante la creazione, così anche nel tempo. Il formato per questo codice è part_type_size (ind, size_min, size_max, size_incr, size_wiggle).

ind è la variabile per la particella.
size_min e size_max determinano l'intervallo della dimensione delle particelle quando vengono create. Se si desidera una dimensione uniforme, è sufficiente inserire lo stesso valore sia per il minimo che per il massimo.
size_incr è un valore che consente alla particella di accrescere o ridursi nel tempo. Questo valore determina la velocità di crescita, quindi se non volete che il vostro sprite cambi dimensione è possibile utilizzare un valore pari a 0.
size_wiggle è leggermente più complicato, quindi lo vedremo nella sezione di tecniche avanzate successiva.

Ecco il codice per la dimensione delle particelle utilizzato nel nostro effetto di particelle verdi:

1	part_type_size(first_particle,0.10,0.15,-.001,0);

La particella viene creata con una dimensione compresa tra 0,10 e 0,15 per dare un pò di varietà e lo sprite lentamente esaurisce ad una velocità di -0.001. Questo valore di velocità dipende in gran parte dalla velocità della vostra stanza, quindi ci sarà probabilmente bisogno di sperimentare con altri valori per ottenere i risultati desiderati. Noi non useremo qualsiasi size wiggle, quindi impostiamo il valore a 0.

Le particelle in GameMaker Studio possono effettivamente cambiare i colori nel corso del tempo. Questo risultato è ottenuto con part_type_color2 e part_type_color3. Se non volete che il vostro sprite cambi colori, allora si può semplicemente utilizzare part_type_color1. Per il nostro effetto particellare verde, vogliamo iniziare con un colore giallo/verde brillante e poi passare ad un colore verde fisso, quindi usiamo part_type_color2:

1	part_type_color2(first_particle,8454143,65280);

I due colori che ho selezionato sono valori numerici specifici che uso regolarmente, ma se si desidera utilizzare valori esadecimali più tradizionali, è possibile utilizzare il formato $RRGGBB.

Le particelle possono anche diventare più o meno trasparenti nel tempo con part_type_alpha2 e part_type_alpha3. Se si desidera un valore costante di alfa (trasparenza), utilizzare part_type_alpha1. Per il nostro effetto particellare verde, vogliamo che la particella inizi da completamente opaca fino ad una dissolvenza del 25% finché rimane sullo schermo, quindi abbiamo bisogno di due valori di alfa:

1	part_type_alpha2(first_particle,1,0.75);

In GameMaker, l'alfa è un valore che va da 0 a 1. Un oggetto completamente invisibile avrà un valore alfa pari a 0, mentre un oggetto completamente opaco avrà un valore di alfa uguale a 1.

La velocità delle particelle è determinata proprio come la dimensione delle particelle. Le particelle vengono create con un intervallo di valori di velocità, e tale valore può aumentare o diminuire. Il formato per questo codice è part_type_speed(ind, Speed_Min, speed_max, speed_incr, speed_wiggle), dove ind è la variabile particella, speed_Min e speed_max è l'intervallo di velocità, speed_incr è il tasso di variazione della velocità delle particelle, e speed_wiggle è un parametro che vedremo in seguito.

Il codice per la velocità della nostra particella verde è:

1	part_type_speed(first_particle,0.1,0.5,0,0);

La nostra particella inizia a muoversi con un valore di velocità compreso tra 0.1 e 0.5. Questa velocità rimarrà costante, quindi usiamo un valore pari a 0, e ancora una volta non faremo alcuna oscillazione della velocità (seed wiggle), quindi usiamo un valore pari a 0.

Mentre il parametro della velocità di una particella determina la velocità di movimento, il parametro di direzione determina dove si muove. Il codice della direzione è nel seguente formato: part_type_direction (ind, dir_min, dir_max, dir_incr, dir_wiggle) e ancora una volta abbiamo impostato la variabile con un intervallo di partenza, un valore incrementale e un valore di wiggle (n.d.a. piccoli movimenti casuali). Per l'effetto particellare verde, vogliamo cje la nostra particella inizi a muoversi in qualsiasi direzione e vogliamo che quella direzione rimanga costante.

1	part_type_direction(first_particle,0,359,0,0);

L'intervallo tra 0 a 359 assicura che la particella abbia la possibilità di muoversi in qualsiasi direzione (un angolo compreso tra 0 e 359 gradi). Se volevamo una particella che si spostava solo e soltanto in alto, allora potevamo utilizzare un'intervallo da 90 a 90).

La gravità del nostro effetto particellare è ciò che lo rende più interessante. Mentre i nostri parametri di velocità e direzione sono impostati per creare una particella che parte e si muove in una direzione a velocità costante, il parametro gravità colpisce e altera la particella nel tempo. Con un formato di part_type_gravity (ind, grav_amount, grav_direction), il parametro gravità è molto semplice:

1	part_type_gravity(first_particle,0.02,90);

Applicando una leggera forza gravitazionale di 0,02 verso l'alto (90 gradi), possiamo creare una particella che sembra fluttuare. In combinazione con i parametri di dimensione e alfa, la particella, accompagnata dal ascensore gravitazionale, si restringe e diventa più trasparente nel tempo.

L'orientamento della forma delle particelle è importante anche per l'aspetto dell'effetto, quindi usiamo part_type_orientation(ind, ang_min, ang_max, ang_incr, ang_wiggle, ang_relative) per ruotare il quadrato nel corso del tempo.

ind è la variabile particella.
ang_min e ang_max determinano il valore di partenza della rotazione della forma.
ang_incr è utilizzato per incrementare o decrementare l'orientamento della forma nel tempo.
ang_relative è un valore booleano per determinare se l'orientamento deve essere impostato in base al movimento della particella (true) o no (false).

Vogliamo che la nostra particella verde ruoti leggermente a sinistra, quindi usiamo il seguente codice:

1	part_type_orientation(first_particle,0,359,10,0,true);

Uno dei parametri più importanti delle particelle è il valore durata della vita. Questo valore determina il tempo minimo e massimo in cui una particella resterà disegnata sullo schermo. Con due valori minimo e massimo identici, tutte le particelle di questo tipo vivranno per la stessa quantità di tempo. Vogliamo dare alle nostre particelle verdi un pò di varietà, quindi dovremo utilizzare un'intervallo da 100 a 150 per il valore della durata della vita:

1	part_type_life(first_particle,100,150);

Il parametro finale per le particelle è un semplice Booleano per determinare se le particelle debbano fondersi tra loro con un effetto additivo di miscela:

1	part_type_blend(first_particle,true);

Creazione del Emettitore di Particelle

Il primo passo nella definizione di un emettitore è quello di creare una variabile. Definiamo questo emettitore nell'evento Create dell'oggetto obj_first_particle.

1	first_emitter = part_emitter_create(FirstParticleSystem);

Successivamente, definiamo la regione dell'emettitore con part_emitter_region(ps, ind, xmin, xmax, ymin, ymax, shape, distribution).

ps è il sistema di particelle a cui l'emettitore appartiene e ind è la variabile emettitore.
X e Y valori minimi e massimi che determinano le dimensioni della regione dell'emettitore.
shape determina la forma dell'area dell'emettitore (ps_shape_rectangle, ps_shape_ellipse, ps_shape_diamond, ps_shap_line).
distribution è una curva di distribuzione (ps_dist_linear, ps_distr_gaussian, ps_distr_invgaussian).

Parleremo approfonditamente dei parametri della shape e distribution in modo più dettagliato nella sezione tecniche avanzate. Per il momento, useremo la forma di default dell'ellisse e i valori della distribuzione gaussiana:

1	part_emitter_region(FirstParticleSystem, first_emitter, x-20, x+20, y-20, y+20, ps_shape_ellipse, ps_distr_gaussian);

Questo codice crea una regione dell'emettitore ellittica che è di 40 pixel di altezza e di larghezza 40 pixel e centrata sui valori x e y dell'oggetto obj_first_particle. Le particelle create dall'emettitore appariranno dentro questa regione definita.

Attivazione del Emettitore di Particelle

Il passo successivo è quello di determinare uno dei due tipi di emettitore: Burst o Stream. Un emettitore di tipo Burst (scoppio) crea una quantità specificata di una certa particella ogni volta che viene attivato. Un emettitore Stream (flusso) crea una quantità specificata di una certa particella, ogni volta ad ogni passo.

Daremo uno sguardo agli emettitori Burst più versatili nella sezione tecniche avanzate, quindi per ora facciamo uso del solo emettitore Stream:

1	part_emitter_stream(FirstParticleSystem,first_emitter,first_particle,1);

Abbiamo piazzato questo codice nell'evento Create dell'oggetto obj_first_particle, con la conseguente creazione di emettere una particella ad ogni passo, non appena viene creato l'oggetto. Con una velocità di 30 per la stanza, il nostro emettitore creerà 30 particelle al secondo; per creare 60 particelle al secondo, dovreste semplicemente utilizzare un valore di 2 invece di 1.

E con questo, il nostro semplice effetto particellare verde è completo! L'utilità di questo effetto è limitata, ma è importante iniziare in semplicità prima di immergersi negli aspetti più complessi del sistema particellare di GameMaker Studio. Una volta apprese le basi del sistema particellare, è possibile avviare l'implementazione di sistemi particellari più avanzati.

Tecniche avanzate del Sistema Particellare

Particella Wiggle (agitata)

Wiggle è un semplice ma anche potente parametro che può cambiare drasticamente l'aspetto delle particelle. Il parametro wiggle determina per la particella una oscillazione (agitamento, dimenarsi) tra i valori minimi e massimi per la durata della particella. Il valore può essere compreso tra 0 e 20 e determina la velocità dell'agitazione.

L'esempio "Fire Bubble" nella demo incorporata utilizza un valore di wiggle 0.40 nel parametro part_type_size:

1	part_type_size(fire_bubble_part,0.25,0.75,-0.01,0.40);

Emettitori Burst e oggetti in movimento

Una delle implementazioni più comuni di sistema particellare comporta particelle emesse da dietro un oggetto in movimento, come ad esempio una scia di fumo su un razzo. Il raggiungimento di questo effetto in GameMaker Studio richiede un emettitore Burst pa piazzare nell'evento Step dell'oggetto.

L'esempio incluso utilizza lo stesso sistema di particelle verdi precedente ma con un emettitore leggermente modificato. Invece di innescare un emettitore Stream nell'evento Create dell'oggetto, poniamo un emettitore Burst nell'evento Step dell'oggetto. La posizione corrente del cursore del mouse viene controllata rispetto alla precedente posizione del cursore e se vi è un cambiamento nella posizione del cursore, l'emettitore Burst viene attivato per liberare cinque particelle:

x = mouse_x;
y = mouse_y;

part_emitter_region(MouseParticle,green_mouse_emitter,x,x,y,y,0,0);

if x != old_x || old_y != y
{
    part_emitter_burst(MouseParticle,green_mouse_emitter,green_mouse_particle,5);
}

old_x = x;
old_y = y;

Forme delle aree dell'Emettitore

Utilizzando le diverse forme di emettitore e le curve di distribuzione è possibile creare effetti molto diversi. Una distribuzione a curva lineare combinata con una particella emettitore a forma di una linea è in grado di creare un effetto pioggia convincente.

1	part_emitter_region(RainParticle, rain_emitter, -100, room_width, y, y, ps_shape_line, ps_distr_linear);

La forma dell'emettitore è definita da una linea che inizia a 100 pixel a sinistra dall'origine della camera e si estende alla larghezza della stanza. Una curva di distribuzione lineare viene utilizzata per distribuire le particelle della pioggia uniformemente sulla regione dell'emettitore. E' anche utile usare part_system_update per far avanzare le pioggia di particelle neli diversi step nell'evento Create. Questo codice dà l'impressione che la pioggia stesse cadendo anche prima del caricamento della stanza, anche se il sistema di particelle non esisteva ancora in memoria.

1	repeat (room_speed * 3)
2	{
3	part_system_update(RainParticle);
4	}

Fasi del Sistema di particelle ed effetto morte

Singole particelle all'interno di un sistema sono in grado anche di generare altre particelle negli eventi Step e Death. L'esempio mostra una particella scintilla viola che genera particelle di polvere più piccole mentre viaggia verso destra e genera una particella fumo alla fine della sua durata:

1	part_type_step(spark_particle,1,dust_particle);
2	part_type_death(spark_particle,5,smoke_particle);

Forme di particelle personalizzate

Utilizzando part_type_sprite(ind, sprite, animate, stretch, random), è possibile utilizzare sprite personalizzati al posto dei tipi interni al sistema particellare di GameMaker.

ind è la variabile particella.
sprite è la variabile sprite da utilizzare.
animate è un valore Booleano per determinare se le sotto-immagini devono essere animate.
stretch è un Booleano che fa corrispondere la lunghezza dell'animazione alla durata della particella.
random è un Booleano per determinare se la sub-immagine di partenza deve essere selezionata in modo casuale.

1	part_type_sprite(heart_particle,spr_heart,false,false,false);

Gestione della memoria

La cosa più importante da ricordare per il sistema particellare di GameMaker Studio è che è necessario rimuovere manualmente gli elementi dalla memoria quando non sono più in uso. A differenza di oggetti standard del gioco, i sistemi particellari rimangono in memoria anche se si cambiano le stanze. Il modo più semplice per gestire questa situazione è di inserire il codice di gestione della memoria negli eventi di cambiamento dei vostri oggetti di gioco

part_system_clear (ind): cancella tutti gli emettitori e le particelle appartenenti ad un sistema particellare specifico.
part_system_clear (ind): cancella tutte le istanze di un determinato tipo di particella.
part_emitter_clear (ps, ind): cancella tutte le particelle appartenenti ad uno specifico emettitore.
part_emitter_destroy (ps, ind): Distrugge uno specifico emettitore in uno specifico sistema particellare.
part_emitter_destroy_all (ps): Distrugge tutti gli emettitori in uno specifico sistema di particellare.
part_type_destroy (ind): Distrugge uno specifico tipo di particella.
part_system_destroy (ind): Distrugge un intero sistema particellare, comprese tutte le particelle e gli emettitori contenuti al suo interno.

Conclusioni

Anche con una lezione così lunga, abbiamo solo scalfito la superficie del genere di effetti che è in grado di generare il sistema particellare di GameMaker Studio. La chiave per padroneggiare il sistema particellare è raggiungere una certa familiarità e sperimentare, così buttatevici dentro ed iniziate a creare i vostri effetti utilizzando le conoscenze che avete acquisito. Assicuratevi di controllare sempre la documentazione ufficiale GameMaker per visualizzare tutto il sistema particellare disponibile in GML!