Share
In diesem Artikel beginnen wir mit den Grundlagen des Partikelsystems GameMaker Studio und enden mit fortgeschrittenen Techniken und Implementierungen. Betrachten Sie dies als einen Crash-Kurs, um sich mit einer der leistungsfähigsten integrierten Funktionen von GameMaker Studio vertraut zu machen. Mit der Demo-Datei und der herunterladbaren Projektdatei können Sie dem Artikel folgen, um genau zu erfahren, worum es beim Partikelsystem geht.
Das Partikelsystem des GameMaker Studio ist eine kostengünstige und einfache Möglichkeit, auffällige Effekte für Ihr Spielprojekt zu erstellen. Durch die Kombination von Partikeln und Emittern können Sie schnell beeindruckende Explosionen, Rauch, Blut, Granatsplitter und zahlreiche andere Effekte erzeugen. Ähnliche Effekte können durch die Verwendung einzelner Objekte erzielt werden, aber die Berechnungskosten des eingebauten Partikeleffektsystems sind weitaus günstiger.
Um das Partikelsystem in Ihrem Projekt verwenden zu können, müssen Sie GML (GameMaker Language) verstehen. Sobald Sie sich mit dem Partikelsystem vertraut gemacht haben, müssen Sie lediglich die Lücken füllen und experimentieren.
Schauen Sie sich die Demo unten an, um zu sehen, was wir erreichen können:
Partikelsysteme in GameMaker Studio bestehen aus drei Teilen: dem System selbst, dem Partikel und dem Emitter. Sie können mehrere Systeme erstellen und jedes System kann mehrere Partikel und Emitter enthalten. Stellen Sie sich das System als Container vor, in dem die Partikel und die Emitter definiert sind.
Die Implementierung eines Partikeleffekts in GameMaker Studio umfasst vier Schritte.
Um Ihnen die Grundlagen des GameMaker Studio-Partikelsystems zu vermitteln, erstellen wir zunächst diesen sehr einfachen grünen Partikeleffekt.
Das Partikelsystem erstellen ist so einfach wie das Definieren einer Variablen. Wir erstellen ein Objekt namens obj_first_particle und fügen Sie den folgenden Code in das Create-Ereignis des Objekts ein:
FirstParticleSystem = part_system_create ();
Das Partikelsystem übernimmt den Tiefenwert des Objekts, in dem das System definiert ist. Sie können die Tiefe jedoch auch separat mit GML einstellen:
part_system_depth (FirstParticleSystem, 0);
Denken Sie daran, dass Objekte und Partikelsysteme mit einem hohen Tiefenwert zuerst auf den Bildschirm gezeichnet werden. Mit einer Tiefe von 0, Unser grünes Partikelsystem erscheint über Objekten mit einer Tiefe von mehr als 0, und erscheint unter Objekten mit einer Tiefe von weniger als 0.
Partikelsysteme werden mit einer Basisposition relativ zu dem Bildschirm gezeichnet (0,0). Wenn Sie aus irgendeinem Grund einen Versatz für alle zukünftigen Positionen dieses Partikelsystems erstellen möchten, können Sie den folgenden Code verwenden, um eine neue Basisposition (wo.) Zu erstellen ind ist das Partikelsystem):
part_system_position (ind, x, y);
Mit einer neuen Grundposition auf (10,10), ein Teilchen, erstellt am (25,25) wird stattdessen angezogen (35,35). Das Ändern der Basisposition eines Partikelsystems ist selten notwendig, kann jedoch für Ihr spezifisches Projekt nützlich sein.
Nun, da das System eingerichtet wurde, ist es an der Zeit, das tatsächliche Partikel zu definieren, das der Emitter erzeugen wird. Partikel können eine große Anzahl von Parametern enthalten, die bestimmen, wie das Partikel aussehen und sich verhalten soll. Der erste Schritt besteht darin, eine Variable für das Partikel zu erstellen, und wir tun dies im Erstellen Ereignis der obj_first_particle Objekt:
first_particle = part_type_create ();
Als Nächstes beginnen wir mit der Definition der einzelnen Parameter des Partikels. Da wir nicht vorhaben, dieses Teilchen zur Laufzeit zu ändern, können wir platzieren alles dieses Codes in der Erstellen Ereignis der obj_first_particle Objekt.
part_type_shape bestimmt die Grundform des Partikels. In GameMaker Studio stehen 14 voreingestellte Partikelformen zur Verfügung. Sie können auch Ihre eigenen Formen definieren. Wir werden das weiter unten im Abschnitt "Fortgeschrittene" behandeln. Beginnen wir aber jetzt mit einem einfachen Quadrat.
part_type_shape (first_particle, pt_shape_square);
Eine vollständige Liste der verfügbaren Standardformen finden Sie in der offiziellen GameMaker-Dokumentation.
Mit part_type_scale, Wir können die Basis-X- und Y-Skalenwerte der Partikelform einstellen. Da wir eine perfekte quadratische Form wünschen, verwenden wir den folgenden Code:
part_type_scale (first_particle, 1,1);
part_type_size erlaubt es uns, die Größe des Partikels bei der Erstellung und auch im Laufe der Zeit zu verändern. Das Format für diesen Code lautet part_type_size (ind, size_min, size_max, size_incr, size_wiggle).
Accentsconagua
ind ist die Partikelvariable. size_min und size_max Bestimmen Sie den Bereich der Partikelgröße bei der ersten Erstellung. Wenn Sie eine einheitliche Größe wünschen, geben Sie einfach den gleichen Wert für min und max ein. size_incr ist ein Wert, mit dem das Partikel im Laufe der Zeit wachsen oder schrumpfen kann. Dieser Wert bestimmt die Wachstumsgeschwindigkeit. Wenn Sie nicht möchten, dass Ihr Sprite die Größe ändert, können Sie einen Wert von verwenden 0. size_wiggle ist etwas komplizierter, wir werden das im Abschnitt Fortgeschrittene Techniken weiter unten behandeln.Hier ist der Partikelgrößencode, der in unserem grünen Partikeleffekt verwendet wird:
part_type_size (first_particle, 0.10,0.15, -. 001,0);
Das Partikel wird mit einer Größe irgendwo dazwischen erstellt 0,10 und 0,15 Um Abwechslung zu schaffen, schrumpft das Sprite langsam mit einer Geschwindigkeit von -0,001. Dieser Geschwindigkeitswert hängt stark von Ihrer Raumgeschwindigkeit ab. Daher müssen Sie wahrscheinlich mit Werten experimentieren, um die gewünschten Ergebnisse zu erhalten. Wir werden kein Größenwackeln verwenden, also setzen wir den Wert auf 0.
Partikel in GameMaker Studio können im Laufe der Zeit ihre Farben ändern. Dies wird mit erreicht part_type_color2 und part_type_color3. Wenn Sie nicht möchten, dass Ihr Sprite die Farben ändert, können Sie es einfach verwenden part_type_color1. Für unseren grünen Partikeleffekt möchten wir, dass er mit einer leuchtend gelben / grünen Farbe beginnt und dann zu einer durchgehenden grünen Farbe wechselt, so dass wir dies verwenden part_type_color2:
part_type_color2 (first_particle, 8454143,65280);
Die zwei Farben, die ich ausgewählt habe, sind bestimmte numerische Werte, die ich regelmäßig verwende. Wenn Sie jedoch mehr traditionelle Hex-Werte verwenden möchten, können Sie das Format verwenden $ RRGGBB.
Partikel können mit der Zeit auch mehr oder weniger transparent werden part_type_alpha2 und part_type_alpha3. Wenn Sie einen konsistenten Alpha-Wert wünschen, verwenden Sie part_type_alpha1. Für unseren grünen Partikeleffekt möchten wir, dass das Partikel vollständig undurchsichtig beginnt und um 25% verblaßt, wenn es auf dem Bildschirm bleibt. Daher benötigen wir zwei Alpha-Werte:
part_type_alpha2 (first_particle, 1,0.75);
In GameMaker ist Alpha ein Wert von 0 bis 1. Ein vollständig unsichtbares Objekt hat einen Alphawert von 0, während ein vollständig undurchsichtiges Objekt einen Alphawert von 1 hat.
Die Partikelgeschwindigkeit wird genau wie die Partikelgröße bestimmt. Partikel werden innerhalb eines Bereichs von Geschwindigkeitswerten erzeugt, und dieser Wert kann sich erhöhen oder verringern. Das Format für diesen Code lautet part_type_speed (ind, speed_min, speed_max, speed_incr, speed_wiggle), woher ind ist die Partikelvariable, speed_min und speed_max ist der Geschwindigkeitsbereich, speed_incr ist die Geschwindigkeit, mit der sich die Partikelgeschwindigkeit ändert, und speed_wiggle ist ein Parameter, den wir später behandeln werden.
Der Geschwindigkeitscode für unsere grünen Partikel lautet:
part_type_speed (erster_Partikel, 0,1,0,5,0,0);
Unser Partikel bewegt sich irgendwo mit einem Geschwindigkeitswert 0,1 und 0,5. Diese Geschwindigkeit bleibt konstant, daher verwenden wir einen Wert von 0, und wir werden wieder kein Geschwindigkeits-Wackeln implementieren, also verwenden wir den Wert von 0.
Während der Geschwindigkeitsparameter eines Partikels bestimmt, wie schnell es sich bewegt, bestimmt der Richtungsparameter, wo es sich bewegt. Der Richtungscode hat das folgende Format: part_type_direction (ind, dir_min, dir_max, dir_incr, dir_wiggle) und wieder setzen wir die Variable, den Startbereich, einen inkrementellen Wert und einen Wackelwert. Für den grünen Partikeleffekt möchten wir, dass sich unser Partikel in eine beliebige Richtung bewegt, und dass diese Richtung konstant bleibt:
part_type_direction (first_particle, 0,359,0,0);
Der Bereich von 0 bis 359 stellt sicher, dass sich das Partikel in jede Richtung bewegen kann (Winkel zwischen 0 und 359 Grad). Wenn Sie wollten, dass sich ein Teilchen nach oben bewegt nur up, dann würden Sie einen Bereich von 90 bis 90 verwenden).
Die Schwerkraft unseres Partikeleffekts macht ihn am interessantesten. Während unsere Geschwindigkeits- und Richtungsparameter so eingestellt sind, dass ein Partikel entsteht, das mit einer konstanten Geschwindigkeit in einer Richtung beginnt, setzt der Schwerkraftparameter das Partikel mit der Zeit ein und ändert es. Mit einem Format von part_type_gravity (ind, grav_amount, grav_direction), Der Schwerkraftparameter ist sehr einfach:
part_type_gravity (first_particle, 0.02,90);
Durch Anwenden einer leichten Anziehungskraft von 0,02 nach oben (90 Grad) können wir ein Teilchen erzeugen, das zu schweben scheint. In Kombination mit unseren Größen- und Alphaparametern schrumpft das Partikel und wird mit der Zeit transparenter, begleitet von der Schwerkraftanhebung.
Die Orientierung der Partikelform ist auch wichtig für das Auftreten des Effekts, also verwenden wir part_type_orientation (ind, ang_min, ang_max, ang_incr, ang_wiggle, ang_relative) das Quadrat mit der Zeit drehen.
ind ist die Partikelvariable. ang_min und ang_max Bestimmen Sie den Startwert des Rotationswerts der Form.ang_incr wird verwendet, um die Orientierung der Form im Laufe der Zeit zu erhöhen oder zu verringern.ang_relativ ist ein boolescher Wert, um zu bestimmen, ob die Orientierung relativ zur Bewegung des Partikels festgelegt werden soll (true) oder nicht (false).. Wir möchten, dass sich unser grüner Partikel leicht nach links dreht, daher verwenden wir den folgenden Code:
part_type_orientation (first_particle, 0,359,10,0, true);
Einer der wichtigsten Parameter eines Partikels ist der Lebensdauer Wert. Dieser Wert bestimmt die minimale und maximale Zeit, die ein Partikel auf den Bildschirm gezogen wird. Bei zwei identischen min- und max-Werten existieren alle Partikel dieses Typs für die gleiche Zeit. Wir möchten, dass unsere grünen Partikel eine große Vielfalt aufweisen. Daher werden wir für den Lebensdauerwert einen Bereich von 100 bis 150 verwenden:
part_type_life (first_particle, 100,150);
Der letzte Parameter für Partikel ist ein einfacher Boolescher Wert, um zu bestimmen, ob die Partikel mit einem additiven Mischungseffekt zusammengefügt werden sollen:
part_type_blend (first_particle, true);
Der erste Schritt bei der Definition eines Emitters ist das Erstellen einer Variablen. Wir definieren diesen Emitter im Create-Event des obj_first_particle Objekt.
first_emitter = part_emitter_create (FirstParticleSystem);
Als nächstes definieren wir die Emitterregion mit part_emitter_region (ps, ind, xmin, xmax, ymin, ymax, Form, Verteilung).
ps ist das Partikelsystem, zu dem der Emitter gehört ind ist die Emittervariable.gestalten bestimmt die Form der Emitterregion (ps_shape_rectangle, ps_shape_ellipse, ps_shape_diamond, ps_shap_line). Verteilung ist eine Verteilungskurve (ps_dist_linear, ps_distr_gaussian, ps_distr_invgaussian).Die Form- und Verteilungsparameter werden im Abschnitt Fortgeschrittene Techniken ausführlicher behandelt. Im Moment verwenden wir die Standardform der Ellipse und die Verteilung der Gaußschen Verteilung:
part_emitter_region (FirstParticleSystem, first_emitter, x-20, x + 20, y-20, y + 20, ps_shape_ellipse, ps_distr_gaussian);
Mit diesem Code wird ein elliptischer Emitterbereich erstellt, der 40 Pixel hoch und 40 Pixel breit ist und auf den x- und y-Werten des Wertes zentriert ist obj_first_particle Objekt. Vom Emitter erzeugte Partikel werden in diesem definierten Bereich angezeigt.
Der nächste Schritt besteht darin, einen von zwei Emittertypen zu bestimmen: Burst oder Stream. Ein Burst-Emitter erzeugt bei jedem Auslösen eine bestimmte Menge eines bestimmten Partikels. Ein Stream-Emitter erzeugt einmal pro Schritt eine bestimmte Menge eines bestimmten Partikels.
Wir werden einen Blick auf die vielseitigeren Burst-Emitter im Abschnitt für fortgeschrittene Techniken werfen. Im Moment verwenden wir einfach den Stream-Emitter:
part_emitter_stream (FirstParticleSystem, first_emitter, first_particle, 1);
Wir setzen diesen Code in die Erstellen Ereignis der obj_first_particle Objekt, so dass der Emitter in jedem Schritt ein Partikel erzeugt, sobald das Objekt erstellt wird. Bei einer Raumgeschwindigkeit von 30 erzeugt unser Emitter 30 Partikel pro Sekunde. Um 60 Partikel pro Sekunde zu erzeugen, verwenden Sie einfach den Wert 2 anstatt 1.
Und damit ist unser einfacher grüner Partikeleffekt komplett! Der Nutzen dieses Effekts ist begrenzt, aber es ist wichtig, klein zu beginnen, bevor Sie in die komplizierteren Aspekte des Partikelsystems von GameMaker Studio eintauchen. Wenn Sie die Grundlagen des Partikelsystems verstanden haben, können Sie fortschrittlichere Partikelsysteme implementieren.
Wiggle ist ein einfacher, aber leistungsstarker Parameter, der das Aussehen Ihrer Partikel drastisch verändern kann. Der Wiggle-Parameter bewirkt, dass das Partikel für die Lebensdauer des Partikels zwischen den minimalen und maximalen Werten schwingt. Der Wert kann zwischen sein 0 und 20 und bestimmt die Geschwindigkeit des Wackelns.
Das "Fire Bubble" -Beispiel in der eingebetteten Demo verwendet einen Wackelwert von 0,40 in dem part_type_size Parameter:
part_type_size (fire_bubble_part, 0,25,0,75, -0,01,0,40);
Eine der gebräuchlichsten Implementierungen von Partikelsystemen umfasst Partikel, die hinter einem sich bewegenden Objekt wie einer Rauchspur auf einer Rakete austreten. Um diesen Effekt in GameMaker Studio zu erreichen, muss ein Burst-Emitter in einem Objekt platziert werden Schritt Veranstaltung.
Das mitgelieferte Beispiel verwendet dasselbe grüne Partikelsystem wie zuvor, jedoch mit einem leicht modifizierten Emitter. Anstatt einen Stream-Emitter im Objekt auszulösen Erstellen Event wird ein Burst-Emitter in das Objekt eingefügt Schritt Veranstaltung. Die aktuelle Position des Mauscursors wird mit der vorherigen Position des Cursors verglichen. Wenn sich die Position des Cursors ändert, wird der Burst-Emitter ausgelöst, um fünf Partikel freizugeben:
x = mouse_x; y = mouse_y; part_emitter_region (MouseParticle, green_mouse_emitter, x, x, y, y, 0,0); wenn x! = old_x || old_y! = y part_emitter_burst (MouseParticle, green_mouse_emitter, green_mouse_particle, 5); old_x = x; old_y = y;
Durch die Verwendung der verschiedenen Emitterformen und Verteilungskurven können Sie sehr unterschiedliche Effekte erzeugen. Lineare Kurvenverteilung kombiniert mit einem linienförmigen Partikelemitter kann einen überzeugenden Regeneffekt erzeugen.
part_emitter_region (RainParticle, rain_emitter, -100, Raumbreite, y, y, ps_shape_line, ps_distr_linear);
Die Emitterform wird durch eine Linie definiert, die 100 Pixel links vom Raumursprung beginnt und sich auf die Breite des Raums erstreckt. Eine lineare Verteilungskurve wird verwendet, um die Regenpartikel gleichmäßig über den Emitterbereich zu verteilen. Es ist auch nützlich zu verwenden part_system_update um das Regenpartikel mehrere Schritte im Erstellen Veranstaltung. Dieser Code vermittelt den Eindruck, dass der Regen gefallen ist, bevor Sie den Raum geladen haben, obwohl das Partikelsystem noch nicht im Speicher vorhanden war.
repeat (room_speed * 3) part_system_update (RainParticle);
Einzelne Partikel innerhalb eines Systems können auch andere Partikel erzeugen Schritt und Tod Veranstaltungen. Das Beispiel zeigt ein violettes Funkenpartikel, das kleinere Staubpartikel erzeugt, wenn es sich nach rechts bewegt, und am Ende seiner Lebensdauer ein Rauchpartikel erzeugt:
part_type_step (spark_particle, 1, dust_particle); part_type_death (spark_particle, 5, smoke_particle);
Durch die Nutzung part_type_sprite (ind, sprite, animieren, dehnen, zufällig), Sie können anstelle der integrierten GameMaker-Partikeltypen benutzerdefinierte Sprites verwenden.
ind ist die Partikelvariable.Sprite ist die zu verwendende Sprite-Variable.animieren ist ein Boolean, um zu bestimmen, ob die Unterbilder animiert werden sollen.strecken ist ein boolescher Wert, der die Animationslänge an die Lebensdauer des Partikels anpasst. zufällig ist ein Boolean, um zu bestimmen, ob das Start-Unterbild zufällig ausgewählt werden soll.part_type_sprite (heart_particle, spr_heart, false, false, false);
Beim GameMaker Studio-Partikelsystem sollten Sie unbedingt darauf achten, dass Sie Elemente aus dem Speicher entfernen müssen, wenn Sie sie nicht verwenden. Im Gegensatz zu herkömmlichen Spielobjekten bleiben Partikelsysteme auch dann im Speicher, wenn Sie den Raum wechseln. Der einfachste Weg, um damit umzugehen, ist das Platzieren von Speicherverwaltungscode in den Raum ändernden Ereignissen Ihrer Spielobjekte.
part_system_clear (ind): Löscht alle Emitter und Partikel, die zu einem bestimmten Partikelsystem gehören.part_system_clear (ind): Löscht alle Instanzen eines bestimmten Partikeltyps.part_emitter_clear (ps, ind): Löscht alle Partikel, die zu einem bestimmten Emitter gehören.part_emitter_destroy (ps, ind): Zerstört einen bestimmten Emitter in einem bestimmten Partikelsystem.part_emitter_destroy_all (ps): Zerstört alle Emitter in einem bestimmten Partikelsystem.part_type_destroy (ind): Zerstört einen bestimmten Partikeltyp.part_system_destroy (ind): Zerstört ein gesamtes Partikelsystem, einschließlich aller darin enthaltenen Partikel und Emitter.Trotz dieses langwierigen Tutorials haben wir immer nur die Oberfläche der Effekte gekratzt, zu denen das GameMaker Studio-Partikelsystem fähig ist. Der Schlüssel zum Beherrschen von Partikeln ist Vertrautheit und Experimentieren. Springen Sie also ein und erstellen Sie Ihre eigenen Effekte mit dem erworbenen Wissen. Schauen Sie sich die offizielle GameMaker-Dokumentation an, um alle verfügbaren Partikel-GML-Systeme anzuzeigen!
