Share
In questo articolo, inizieremo con le basi del sistema di particelle di GameMaker Studio e termineremo con tecniche e implementazioni avanzate. Pensa a questo come a un corso accelerato per familiarizzare con una delle funzionalità incorporate più potenti di GameMaker Studio. La demo e il file di progetto scaricabile ti permetteranno di seguire l'articolo per vedere esattamente di cosa tratta il sistema di particelle.
Il sistema particellare di GameMaker Studio è un modo economico e semplice per creare effetti appariscenti per il tuo progetto di gioco. Attraverso una combinazione di particelle ed emettitori, è possibile creare rapidamente esplosioni impressionanti, fumo, sangue, schegge e innumerevoli altri effetti. Effetti simili possono essere raggiunti usando singoli oggetti, ma il costo di calcolo del sistema di effetti particella integrato è molto più economico.
Per utilizzare il sistema di particelle nel tuo progetto, devi comprendere GML (GameMaker Language), ma una volta acquisita familiarità con il sistema di particelle, si tratta semplicemente di riempire gli spazi vuoti e la sperimentazione.
Guarda la demo qui sotto per vedere cosa possiamo ottenere:
I sistemi di particelle in GameMaker Studio sono composti da tre parti: il sistema stesso, la particella e l'emettitore. È possibile creare più sistemi e ogni sistema può contenere più particelle ed emettitori. Pensa al sistema come a un contenitore, con le particelle e gli emettitori definiti all'interno.
L'implementazione di un effetto particellare in GameMaker Studio è un processo in quattro fasi.
Per insegnarti le basi del sistema particellare di GameMaker Studio, inizieremo creando questo semplice effetto particellare verde.
Creare il sistema di particelle è semplice come definire una variabile. Creiamo un oggetto chiamato obj_first_particle e inserisci il seguente codice nell'evento Crea dell'oggetto:
FirstParticleSystem = part_system_create ();
Il sistema di particelle adotterà il valore di profondità dell'oggetto in cui è definito il sistema, ma è anche possibile impostare separatamente la profondità con GML:
part_system_depth (FirstParticleSystem, 0);
Ricorda che gli oggetti e i sistemi di particelle con un valore di profondità elevato vengono prima disegnati sullo schermo. Con una profondità di 0, il nostro sistema di particelle verdi apparirà sopra gli oggetti con una profondità maggiore di 0, e apparirà sotto gli oggetti con una profondità inferiore a 0.
I sistemi di particelle vengono disegnati sullo schermo con una posizione di base relativa a (0,0). Se per qualche motivo vuoi creare un offset per tutte le posizioni future di questo sistema di particelle, puoi usare il seguente codice per creare una nuova posizione di base (dove ind è il sistema di particelle):
part_system_position (ind, x, y);
Con una nuova posizione di base impostata su (10,10), una particella creata a (25,25) sarà invece disegnato a (35,35). Cambiare la posizione di base di un sistema di particelle è raramente necessario, ma potresti trovarlo utile nel tuo progetto specifico.
Ora che il sistema è stato configurato, è il momento di definire la particella reale creata dall'emettitore. Le particelle possono contenere un gran numero di parametri che determinano l'aspetto e il comportamento della particella. Il primo passo è creare una variabile per la particella, e lo facciamo nel Creare evento del obj_first_particle oggetto:
first_particle = part_type_create ();
Successivamente, iniziamo a definire i singoli parametri della particella. Dal momento che non pensiamo di alterare questa particella durante il runtime, possiamo piazzare tutti di questo codice nel Creare evento del obj_first_particle oggetto.
part_type_shape determina la forma base della particella. Ci sono 14 forme di particelle predefinite disponibili in GameMaker Studio e puoi anche definire le tue forme. Tratteremo questo nella sezione avanzata di seguito, ma per ora iniziamo con un quadrato di base.
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 i valori di scala X e Y della forma delle particelle. Dal momento che vogliamo una forma quadrata perfetta, utilizziamo il seguente codice:
part_type_scale (first_particle, 1,1);
part_type_size ci consente di modificare la dimensione della particella al momento della creazione e nel tempo. Il formato per questo codice è part_type_size (ind, size_min, size_max, size_incr, size_wiggle).
Accentsconagua
ind è la variabile delle particelle. size_min e size_max determinare l'intervallo della dimensione delle particelle quando viene creato per la prima volta. Se vuoi una dimensione uniforme, inserisci semplicemente lo stesso valore per il minimo e il massimo. size_incr è un valore che consente alla particella di crescere o ridursi nel tempo. Questo valore determina la velocità di crescita, quindi se non vuoi che il tuo sprite cambi dimensione, puoi usare un valore di 0. size_wiggle è leggermente più complicato, quindi lo tratteremo nella sezione delle tecniche avanzate di seguito.Ecco il codice delle dimensioni delle particelle utilizzato nel nostro effetto particelle verdi:
part_type_size (first_particle, 0.10,0.15, - 001,0.);
La particella verrà creata con una dimensione da qualche parte tra 0.10 e 0.15 per creare varietà, e lo sprite si ridurrà lentamente ad una velocità di -0.001. Questo valore di velocità dipende molto dalla velocità della tua stanza, quindi dovrai probabilmente sperimentare valori per ottenere i risultati desiderati. Non useremo alcuna dimenzione dimensionale, quindi impostiamo il valore su 0.
Le particelle in GameMaker Studio possono effettivamente cambiare i colori nel tempo. Questo è realizzato con part_type_color2 e part_type_color3. Se non vuoi che il tuo sprite cambi i colori, puoi semplicemente usarlo part_type_color1. Per il nostro effetto particelle verdi, vogliamo che inizi con un colore giallo / verde brillante e poi cambi in un colore verde fisso, quindi utilizziamo part_type_color2:
part_type_color2 (first_particle, 8454143,65280);
I due colori che ho selezionato sono valori numerici specifici che uso regolarmente, ma se vuoi usare valori esadecimali più tradizionali, puoi usare il formato $ RRGGBB.
Le particelle possono anche diventare più o meno trasparenti nel tempo con part_type_alpha2 e part_type_alpha3. Se vuoi un valore alfa coerente, usa part_type_alpha1. Per il nostro effetto particelle verdi, vogliamo che la particella inizi completamente opaca e sbiadisce del 25% man mano che rimane sullo schermo, quindi abbiamo bisogno di due valori alfa:
part_type_alpha2 (first_particle, 1,0.75);
In GameMaker, alpha è un valore compreso tra 0 e 1. Un oggetto completamente invisibile avrà un valore alfa di 0, mentre un oggetto completamente opaco avrà un valore alfa di 1.
La velocità delle particelle è determinata proprio come la dimensione delle particelle. Le particelle vengono create in 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 delle particelle, Speed_Min e SPEED_MAX è la gamma di velocità, speed_incr è la velocità alla quale la velocità della particella cambia, e speed_wiggle è un parametro che tratteremo in seguito.
Il codice di velocità per la nostra particella verde è:
part_type_speed (first_particle, 0.1,0.5,0,0);
La nostra particella inizierà a muoversi con un valore di velocità da qualche parte 0.1 e 0.5. Questa velocità rimarrà costante, quindi usiamo un valore di 0, e di nuovo non implementeremo il controllo della velocità, quindi utilizziamo un valore di 0.
Mentre il parametro di velocità di una particella determina la velocità con cui si muove, il parametro di direzione determina dove si muove. Il codice di direzione è nel seguente formato: part_type_direction (ind, dir_min, dir_max, dir_incr, dir_wiggle) e di nuovo impostiamo la variabile, l'intervallo iniziale, un valore incrementale e un valore di oscillazione. Per l'effetto particelle verdi, vogliamo che la nostra particella inizi a muoversi in qualsiasi direzione e vogliamo che quella direzione rimanga costante:
part_type_direction (first_particle, 0,359,0,0);
L'intervallo da 0 a 359 garantisce che la particella abbia la possibilità di muoversi in qualsiasi direzione (un angolo compreso tra 0 e 359 gradi). Se vuoi che una particella si muova e solo su, quindi useresti un intervallo da 90 a 90).
La gravità del nostro effetto particellare è ciò che lo rende il più interessante. Mentre i nostri parametri di velocità e direzione sono impostati per creare una particella che inizia muovendosi in una direzione a una velocità costante, il parametro gravità entra in azione e modifica la particella nel tempo. Con un formato di part_type_gravity (ind, grav_amount, grav_direction), il parametro gravità è molto semplice:
part_type_gravity (first_particle, 0.02,90);
Applicando una leggera attrazione gravitazionale di 0,02 in una direzione verso l'alto (90 gradi), possiamo creare una particella che sembra fluttuare. In combinazione con le nostre dimensioni e parametri alfa, la particella si restringe e diventa più trasparente nel tempo, accompagnata dal sollevamento gravitazionale.
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) ruotare il quadrato nel tempo.
ind è la variabile delle particelle. ang_min e ang_max determinare il valore iniziale del valore di rotazione della forma.ang_incr è usato per incrementare o decrementare l'orientamento della forma nel tempo.ang_relative è un valore booleano per determinare se l'orientamento deve essere impostato rispetto al movimento della particella (vero) o meno (falso). Vogliamo che la nostra particella verde ruoti leggermente a sinistra, quindi utilizziamo il seguente codice:
part_type_orientation (first_particle, 0,359,10,0, true);
Uno dei parametri più importanti di una particella è il durata valore. Questo valore determina il tempo minimo e massimo che una particella verrà disegnata sullo schermo. Con due valori min e max identici, tutte le particelle di quel tipo esisteranno per lo stesso tempo. Vogliamo che le nostre particelle verdi abbiano varietà, quindi useremo un intervallo compreso tra 100 e 150 per il valore di durata della vita:
part_type_life (first_particle, 100,150);
Il parametro finale per le particelle è un semplice booleano per determinare se le particelle devono fondersi con un effetto di fusione additivo:
part_type_blend (first_particle, true);
Il primo passo per definire un emettitore è creare una variabile. Definiamo questo emettitore nell'evento Crea di obj_first_particle oggetto.
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 particellare a cui appartiene l'emettitore ind è la variabile emettitore.forma determina la forma della regione di emettitore (ps_shape_rectangle, ps_shape_ellipse, ps_shape_diamond, ps_shap_line). distribuzione è una curva di distribuzione (ps_dist_linear, ps_distr_gaussian, ps_distr_invgaussian).Tratteremo i parametri di forma e distribuzione in maggior dettaglio nella sezione delle tecniche avanzate. Per ora, utilizzeremo la forma ellittica di default e i valori di distribuzione gaussiana:
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 di emissione ellittica che è alta 40 pixel e larga 40 pixel e centrata sui valori xey del obj_first_particle oggetto. Le particelle create dall'emettitore appariranno all'interno di questa regione definita.
Il prossimo passo è determinare uno dei due tipi di emettitore: Burst o Stream. Un emettitore Burst crea una quantità specificata di una determinata particella ogni volta che viene attivata. Un emettitore di flusso crea una quantità specificata di una determinata particella ogni volta.
Daremo un'occhiata agli emettitori Burst più versatili nella sezione delle tecniche avanzate, quindi per ora utilizziamo l'emettitore Stream:
part_emitter_stream (FirstParticleSystem, first_emitter, first_particle, 1);
Inseriamo questo codice nel Creare evento del obj_first_particle oggetto, con conseguente emettitore che crea una particella ogni fase non appena viene creato l'oggetto. Con una velocità della stanza di 30, il nostro emettitore creerà 30 particelle al secondo; per creare 60 particelle al secondo, useresti semplicemente un valore di 2 invece di 1.
E con questo, il nostro semplice effetto di particelle verdi è completo! L'utilità di questo effetto è limitata, ma è importante iniziare in piccolo prima di immergersi negli aspetti più complicati del sistema di particelle di GameMaker Studio. Una volta comprese le basi del sistema di particelle, è possibile iniziare a implementare sistemi di particelle più avanzati.
Wiggle è un parametro semplice ma potente che può modificare drasticamente l'aspetto delle tue particelle. Il parametro wiggle fa oscillare la particella tra i valori minimo e massimo per la durata della particella. Il valore può essere tra 0 e 20 e determina la velocità del movimento.
L'esempio "Fire Bubble" nella demo incorporata utilizza un valore di wiggle di 0.40 nel part_type_size parametro:
part_type_size (fire_bubble_part, 0.25,0.75, -0.01,0.40);
Una delle implementazioni più comuni dei sistemi di particelle coinvolge particelle che emanano da dietro un oggetto in movimento, come una scia di fumo su un razzo. Raggiungere questo effetto in GameMaker Studio richiede che un emettitore Burst venga inserito in un oggetto Passo evento.
L'esempio incluso utilizza lo stesso sistema di particelle verdi di prima, ma con un emettitore leggermente modificato. Invece di attivare un emettitore di flusso nell'oggetto Creare evento, un emettitore Burst viene inserito nell'oggetto Passo evento. La posizione corrente del cursore del mouse viene controllata rispetto alla posizione precedente del cursore e, se si verifica un cambiamento nella posizione del cursore, l'emettitore Burst viene attivato per rilasciare cinque particelle:
x = mouse_x; y = mouse_y; part_emitter_region (MouseParticle, green_mouse_emitter, x, x, y, y, 0,0); se x! = old_x || old_y! = y part_emitter_burst (MouseParticle, green_mouse_emitter, green_mouse_particle, 5); old_x = x; old_y = y;
Utilizzando le diverse forme di emettitore e le curve di distribuzione, è possibile creare effetti molto diversi. La distribuzione della curva lineare combinata con un emettitore di particelle a forma di linea può creare un effetto pioggia convincente.
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 dell'origine della stanza ed è estesa alla larghezza della stanza. Una curva di distribuzione lineare viene utilizzata per distribuire uniformemente le particelle di pioggia attraverso la regione dell'emettitore. È anche utile da usare part_system_update per far avanzare la particella di pioggia diversi passaggi nel Creare evento. Questo codice dà l'impressione che la pioggia stava cadendo prima di caricare la stanza, anche se il sistema di particelle non esisteva ancora nella memoria.
repeat (room_speed * 3) part_system_update (RainParticle);
Le particelle individuali all'interno di un sistema possono anche generare altre particelle Passo e Morte eventi. L'esempio mostra una particella di scintilla viola che genera particelle di polvere più piccole mentre viaggia verso destra, e genera una particella di fumo alla fine della sua durata:
part_type_step (spark_particle, 1, dust_particle); part_type_death (spark_particle, 5, smoke_particle);
Usando part_type_sprite (ind, sprite, animate, stretch, random), puoi usare sprite personalizzate invece dei tipi di particelle GameMaker incorporati.
ind è la variabile delle particelle.folletto è la variabile sprite da utilizzare.animare è un booleano per determinare se le sotto-immagini devono essere animate.allungare è un booleano che corrisponde alla lunghezza dell'animazione alla durata della particella. casuale è un booleano per determinare se l'immagine secondaria iniziale debba essere selezionata casualmente.part_type_sprite (heart_particle, spr_heart, falso, falso, false);
La cosa più importante da ricordare sul sistema particellare di GameMaker Studio è che è necessario rimuovere manualmente gli oggetti dalla memoria quando non sono in uso. A differenza degli oggetti di gioco standard, i sistemi di particelle rimarranno in memoria anche se si cambiano le stanze. Il modo più semplice per gestirlo è inserire il codice di gestione della memoria nella stanza modificando gli eventi dei tuoi oggetti di gioco.
part_system_clear (ind): Cancella tutti gli emettitori e le particelle appartenenti a un sistema particellare specifico.part_system_clear (ind): Cancella tutte le istanze di un tipo di particella specifico.part_emitter_clear (ps, ind): Cancella tutte le particelle appartenenti ad un emettitore specifico.part_emitter_destroy (ps, ind): Distrugge uno specifico emettitore in un sistema di particelle specifico.part_emitter_destroy_all (ps): Distrugge tutti gli emettitori in un sistema particellare specifico.part_type_destroy (ind): Distrugge un tipo di particella specifico.part_system_destroy (ind): Distrugge un intero sistema di particelle, comprese tutte le particelle e gli emettitori contenuti all'interno.Anche con un tutorial così lungo, abbiamo ancora solo graffiato la superficie di quali tipi di effetti il sistema di particelle di GameMaker Studio è in grado di fare. La chiave per padroneggiare le particelle è familiarità e sperimentazione, quindi entra e inizia a creare i tuoi effetti usando la conoscenza che hai acquisito. Assicurati di controllare la documentazione ufficiale di GameMaker per visualizzare tutto il sistema di particelle GML disponibile!
