Share
In dit artikel beginnen we met de basis van het GameMaker Studio-deeltjessysteem en eindigen met geavanceerde technieken en implementaties. Beschouw dit als een spoedcursus om u bekend en comfortabel te maken met een van de krachtigste ingebouwde functies van GameMaker Studio. Met het demo- en downloadbare projectbestand kun je het artikel volgen om precies te zien waar het particle systeem over gaat.
Het particle-systeem van GameMaker Studio is een goedkope en gemakkelijke manier om flitsende effecten te creëren voor je gameproject. Door een combinatie van deeltjes en stralers, kunt u snel indrukwekkende explosies, rook, bloed, granaatscherven en talloze andere effecten creëren. Vergelijkbare effecten kunnen worden bereikt door individuele objecten te gebruiken, maar de computerkosten van het ingebouwde deeltjeseffectsysteem zijn veel goedkoper.
Om het particle systeem in je project te gebruiken, moet je GML (GameMaker Language) begrijpen, maar als je eenmaal bekend bent met het particle systeem, is het gewoon een kwestie van de lege plekken invullen en experimenteren.
Bekijk de onderstaande demo om te zien wat we kunnen bereiken:
Particle Systems in GameMaker Studio bestaat uit drie delen: het systeem zelf, het deeltje en de emitter. U kunt meerdere systemen maken en elk systeem kan meerdere deeltjes en emitters bevatten. Beschouw het systeem als een container, met de deeltjes en de emitters hierin gedefinieerd.
Het implementeren van een partikeleffect in GameMaker Studio is een proces in vier stappen.
Om je de basis van het deeltjesstelsel van GameMaker Studio te leren, beginnen we met het maken van dit zeer eenvoudige groendeeltjeseffect.
Het maken van het deeltjessysteem is net zo eenvoudig als het definiëren van een variabele. We maken een object met de naam obj_first_particle en plaats de volgende code in de Create-gebeurtenis van het object:
FirstParticleSystem = part_system_create ();
Het particle systeem neemt de dieptewaarde over van het object waarin het systeem is gedefinieerd, maar u kunt de diepte ook afzonderlijk instellen met GML:
part_system_depth (FirstParticleSystem, 0);
Vergeet niet dat objecten en deeltjessystemen met een hoge dieptewaarde eerst naar het scherm worden getrokken. Met een diepte van 0, ons groenedeeltjessysteem verschijnt boven objecten met een diepte groter dan 0, en verschijnt onder objecten met een diepte van minder dan 0.
Deeltjesstelsels worden naar het scherm getrokken met een basispositie ten opzichte van (0,0). Als u om welke reden dan ook een offset wilt maken voor alle toekomstige posities van dit particle systeem, kunt u de volgende code gebruiken om een nieuwe basispositie te creëren (waarbij ind is het particle systeem):
part_system_position (ind, x, y);
Met een nieuwe basispositie ingesteld op (10,10), een deeltje gemaakt op (25,25) zal in plaats daarvan worden aangetrokken door (35,35). Het wijzigen van de basispositie van een deeltjessysteem is zelden nodig, maar mogelijk vindt u het nuttig in uw specifieke project.
Nu het systeem is ingesteld, is het tijd om het eigenlijke deeltje te definiëren dat de emitter zal maken. Deeltjes kunnen een groot aantal parameters bevatten die bepalen hoe het deeltje eruit zal zien en zich zal gedragen. De eerste stap is om een variabele voor het deeltje te maken, en we doen dit in de creëren evenement van de obj_first_particle voorwerp:
first_particle = part_type_create ();
Vervolgens beginnen we met het definiëren van de individuele parameters van het deeltje. Omdat we niet van plan zijn om dit deeltje tijdens runtime te veranderen, kunnen we plaatsen allemaal van deze code in de creëren evenement van de obj_first_particle voorwerp.
part_type_shape bepaalt de basisvorm van het deeltje. Er zijn 14 standaarddeeltjesvormen beschikbaar in GameMaker Studio en je kunt ook je eigen vormen definiëren. We behandelen dit in het geavanceerde gedeelte hieronder, maar laten we nu beginnen met een eenvoudig vierkant.
part_type_shape (first_particle, pt_shape_square);
Raadpleeg de officiële GameMaker-documentatie voor een volledige lijst met beschikbare standaardvormen.
Met part_type_scale, we kunnen de basis X- en Y-schaalwaarden van de deeltjesvorm instellen. Omdat we een perfecte vierkante vorm willen, gebruiken we de volgende code:
part_type_scale (first_particle, 1,1);
part_type_size stelt ons in staat om de grootte van het deeltje bij de schepping en zo ook in de loop van de tijd te veranderen. Het formaat voor deze code is part_type_size (ind, size_min, size_max, size_incr, size_wiggle).
Accentsconagua
ind is de deeltjesvariabele. size_min en size_max bepaal het bereik van de deeltjesgrootte wanneer het voor het eerst wordt gemaakt. Als u een uniform formaat wilt, voert u eenvoudig dezelfde waarde in voor zowel de min als de max. size_incr is een waarde waarmee het deeltje in de loop van de tijd kan groeien of krimpen. Deze waarde bepaalt de groeisnelheid, dus als u niet wilt dat uw sprite van grootte verandert, kunt u een waarde van gebruiken 0. size_wiggle is iets gecompliceerder, dus we behandelen dat in de sectie geavanceerde technieken hieronder.Hier is de code voor de deeltjesgrootte die wordt gebruikt in ons groendeeltjeseffect:
part_type_size (first_particle, 0.10,0.15, - 001,0.);
Het deeltje wordt gemaakt met een grootte ergens tussenin 0.10 en 0.15 om variatie te creëren, en de sprite zal langzaam kleiner worden met een snelheid van -0.001. Deze snelheidswaarde is sterk afhankelijk van de snelheid van je kamer, dus je zult waarschijnlijk moeten experimenteren met waarden om de gewenste resultaten te krijgen. We zullen geen enkele wiggle gebruiken, dus we hebben de waarde ingesteld op 0.
Deeltjes in GameMaker Studio kunnen kleuren in de loop van de tijd veranderen. Dit wordt bereikt met part_type_color2 en part_type_color3. Als u niet wilt dat uw sprite van kleur verandert, kunt u deze gewoon gebruiken part_type_color1. Voor ons effect op groene partikels willen we dat het begint met een felle gele / groene kleur en vervolgens overgaat in een effen groene kleur, dus we gebruiken part_type_color2:
part_type_color2 (first_particle, 8454143,65280);
De twee kleuren die ik heb geselecteerd, zijn specifieke numerieke waarden die ik regelmatig gebruik, maar als u meer traditionele hexwaarden wilt gebruiken, kunt u het formaat gebruiken $ RRGGBB.
Deeltjes kunnen ook met de tijd min of meer transparant worden part_type_alpha2 en part_type_alpha3. Gebruik als u een consistente alpha-waarde wilt part_type_alpha1. Voor ons groendeeltjeseffect willen we dat het deeltje helemaal ondoorzichtig wordt en met 25% vervagen als het op het scherm blijft staan. We hebben dus twee alfawaarden nodig:
part_type_alpha2 (first_particle, 1,0.75);
In GameMaker is alpha een waarde van 0 tot 1. Een volledig onzichtbaar object krijgt een alpha-waarde van 0, terwijl een volledig ondoorzichtig object een alpha-waarde van 1 heeft.
De deeltjessnelheid wordt bepaald net als de deeltjesgrootte. Deeltjes worden gemaakt binnen een bereik van snelheidswaarden en die waarde kan toenemen of afnemen. Het formaat voor deze code is part_type_speed (ind, speed_min, speed_max, speed_incr, speed_wiggle), waar ind is de deeltjesvariabele, speed_min en speed_max is het snelheidsbereik, speed_incr is de snelheid waarmee de deeltjessnelheid verandert, en speed_wiggle is een parameter die we later zullen bespreken.
De snelcode voor ons groene deeltje is:
part_type_speed (first_particle, 0.1,0.5,0,0);
Ons deeltje zal gaan bewegen met een snelheidswaarde ergens tussenin 0.1 en 0.5. Deze snelheid blijft constant, dus gebruiken we een waarde van 0, en we zullen opnieuw geen snelheidswiggle implementeren, dus gebruiken we een waarde van 0.
Terwijl de parameter snelheid van een deeltje bepaalt hoe snel deze beweegt, bepaalt de richtingparameter waar deze zich beweegt. De richtingscode heeft de volgende notatie: part_type_direction (ind, dir_min, dir_max, dir_incr, dir_wiggle) en opnieuw stellen we de variabele, het startbereik, een incrementele waarde en een wiggle-waarde in. Voor het groene-deeltjeseffect willen we dat ons deeltje in elke richting begint te bewegen en we willen dat die richting constant blijft:
part_type_direction (first_particle, 0,359,0,0);
Het bereik van 0 tot 359 zorgt ervoor dat het deeltje de kans heeft om in elke richting te bewegen (een hoek tussen 0 en 359 graden). Als je een deeltje wilde laten bewegen en enkel en alleen hoger, dan zou je een bereik van 90 tot 90 gebruiken).
De zwaartekracht van ons partikeleffect maakt het het meest interessant. Terwijl onze snelheids- en richtingsparameters zijn ingesteld om een deeltje te creëren dat begint met het bewegen in één richting met een constante snelheid, start de zwaartekrachtparameter en verandert het deeltje in de loop van de tijd. Met een indeling van part_type_gravity (ind, grav_amount, grav_direction), de zwaartekrachtparameter is heel eenvoudig:
part_type_gravity (first_particle, 0.02,90);
Door een lichte zwaartekracht van 0,02 in een opwaartse richting (90 graden) toe te passen, kunnen we een deeltje creëren dat lijkt te zweven. Gecombineerd met onze grootte en alfaparameters, krimpt het deeltje en wordt transparanter in de tijd, vergezeld door de zwaartekrachtslift.
De oriëntatie van de deeltjesvorm is ook belangrijk voor het uiterlijk van het effect, dus gebruiken we part_type_orientation (ind, ang_min, ang_max, ang_incr, ang_wiggle, ang_relative) om het vierkant in de loop van de tijd te roteren.
ind is de deeltjesvariabele. ang_min en ang_max bepaal de startwaarde van de rotatiewaarde van de vorm.ang_incr wordt gebruikt om de oriëntatie van de vorm in de loop van de tijd te verhogen of te verlagen.ang_relative is een Booleaanse waarde om te bepalen of de richting moet worden ingesteld ten opzichte van de beweging van het deeltje (true) of niet (false). We willen dat ons groene deeltje iets naar links draait, dus gebruiken we de volgende code:
part_type_orientation (first_particle, 0,359,10,0, true);
Een van de belangrijkste parameters van een deeltje is de levensduur waarde. Deze waarde bepaalt de minimale en maximale tijd dat een deeltje naar het scherm wordt getrokken. Met twee identieke min en max waarden, zullen alle deeltjes van dat type gedurende dezelfde tijd bestaan. We willen dat onze groene deeltjes een variëteit hebben, dus we zullen een bereik van 100 tot 150 gebruiken voor de levensduurwaarde:
part_type_life (first_particle, 100150);
De laatste parameter voor deeltjes is een eenvoudige Booleaanse waarde om te bepalen of de deeltjes samen met een additief mengseleffect moeten worden gemengd:
part_type_blend (first_particle, true);
De eerste stap bij het definiëren van een emitter is het maken van een variabele. We definiëren deze emitter in de Create-gebeurtenis van de obj_first_particle voorwerp.
first_emitter = part_emitter_create (FirstParticleSystem);
Vervolgens definiëren we het emittergebied met part_emitter_region (ps, ind, xmin, xmax, ymin, ymax, vorm, distributie).
ps is het particle systeem waar de emitter toe behoort en ind is de emitter variabel.vorm bepaalt de vorm van het emittergebied (ps_shape_rectangle, ps_shape_ellipse, ps_shape_diamond, ps_shap_line). distributie is een distributiecurve (ps_dist_linear, ps_distr_gaussian, ps_distr_invgaussian).We zullen de vorm- en distributieparameters in detail bespreken in de sectie geavanceerde technieken. Voor nu gebruiken we de standaardvorm voor ellipsvorm en de Gauss-verdeling:
part_emitter_region (FirstParticleSystem, first_emitter, x-20, x + 20, y-20, y + 20, ps_shape_ellipse, ps_distr_gaussian);
Deze code maakt een elliptisch emittergebied van 40 pixels hoog en 40 pixels breed en gecentreerd op de x- en y-waarden van de obj_first_particle voorwerp. Deeltjes gemaakt door de emitter verschijnen binnen deze gedefinieerde regio.
De volgende stap is om een van de twee emittertypen te bepalen: Burst of Stream. Een burst-emitter maakt een bepaalde hoeveelheid van een bepaald deeltje wanneer deze wordt geactiveerd. Een stream-zender maakt eenmaal per stap een bepaalde hoeveelheid van een bepaald deeltje.
We zullen een kijkje nemen naar de meer veelzijdige Burst-emitters in de sectie geavanceerde technieken, dus laten we nu de stream-emitter gebruiken:
part_emitter_stream (FirstParticleSystem, first_emitter, first_particle, 1);
We plaatsen deze code in de creëren evenement van de obj_first_particle object, met als resultaat dat de emittent elke keer een deeltje maakt zodra het object is gemaakt. Met een kamersnelheid van 30, maakt onze emitter 30 deeltjes per seconde; om 60 deeltjes per seconde te maken, zou je gewoon een waarde van gebruiken 2 in plaats van 1.
En daarmee is ons eenvoudige groene-deeltjeseffect voltooid! Het nut van dit effect is beperkt, maar het is belangrijk om klein te beginnen voordat je duikt in de meer gecompliceerde aspecten van het GameMaker Studio-deeltjessysteem. Zodra u de basis van het deeltjessysteem begrijpt, kunt u beginnen met de implementatie van geavanceerdere deeltjessystemen.
Wiggle is een eenvoudige, maar krachtige parameter die het uiterlijk van uw deeltjes drastisch kan veranderen. De wiggle-parameter zorgt ervoor dat het deeltje oscilleert tussen de min- en max-waarden voor de levensduur van het deeltje. De waarde kan tussen zijn 0 en 20 en bepaalt de snelheid van de wiebel.
Het voorbeeld "Fire Bubble" in de ingesloten demo gebruikt een wiggle waarde van 0,40 in de part_type_size parameter:
part_type_size (fire_bubble_part, 0.25,0.75, -0.01,0.40);
Een van de meest voorkomende implementaties van particle systems betreft deeltjes die van achter een bewegend object uitgaan, zoals een rookpad op een raket. Om dit effect in GameMaker Studio te bereiken, moet een burst-emitter in een object worden geplaatst Stap evenement.
Het opgenomen voorbeeld maakt gebruik van hetzelfde systeem met groene partikels als hiervoor, maar met een licht gewijzigde emitter. In plaats van een Stream-zender in de objecten te triggeren creëren gebeurtenis, wordt een burst-emitter in de objecten geplaatst Stap evenement. De huidige positie van de muiscursor wordt vergeleken met de vorige positie van de cursor en als er een verandering is in de positie van de cursor, wordt de burst-emitter geactiveerd om vijf deeltjes vrij te geven:
x = mouse_x; y = mouse_y; part_emitter_region (MouseParticle, green_mouse_emitter, x, x, y, y, 0,0); als x! = old_x || old_y! = y part_emitter_burst (MouseParticle, green_mouse_emitter, green_mouse_particle, 5); old_x = x; old_y = y;
Door de verschillende emittervormen en distributiecurven te gebruiken, kunt u enorm verschillende effecten creëren. Lineaire curveverdeling in combinatie met een lijnvormige deeltjesemitter kan een overtuigend regeneffect creëren.
part_emitter_region (RainParticle, rain_emitter, -100, room_width, y, y, ps_shape_line, ps_distr_linear);
De vorm van de zender wordt bepaald door een lijn die 100 pixels links van de oorsprong van de kamer begint en wordt uitgebreid tot de breedte van de kamer. Een lineaire verdelingscurve wordt gebruikt om de regendruppels gelijkmatig over het emittergebied te verdelen. Het is ook handig om te gebruiken part_system_update om het regendeeltje een aantal stappen in de creëren evenement. Deze code wekt de indruk dat de regen viel voordat je de kamer laadde, ook al bestond het deeltjesstelsel nog niet in het geheugen.
repeat (room_speed * 3) part_system_update (RainParticle);
Individuele deeltjes in een systeem kunnen ook andere deeltjes spawnen Stap en Dood evenementen. Het voorbeeld toont een paars vonkdeeltje dat kleinere stofdeeltjes afzet terwijl het naar rechts beweegt en een rookdeeltje aan het einde van zijn levensduur sproeit:
part_type_step (spark_particle, 1, dust_particle); part_type_death (spark_particle, 5, smoke_particle);
Door het gebruiken van part_type_sprite (ind, sprite, animeren, uitrekken, willekeurig), u kunt aangepaste sprites gebruiken in plaats van de ingebouwde speltypen van GameMaker.
ind is de deeltjesvariabele.sprite is de sprite-variabele die moet worden gebruikt.bezielen is een Boolean om te bepalen of de subafbeeldingen moeten worden geanimeerd.uitrekken is een Boolean die overeenkomt met de lengte van de animatie met de levensduur van het deeltje. willekeurig is een Boolean om te bepalen of de startende subafbeelding willekeurig moet worden geselecteerd.part_type_sprite (heart_particle, spr_heart, false, false, false);
Het belangrijkste om te onthouden over het deeltjesstelsel van GameMaker Studio is dat je items handmatig uit het geheugen moet verwijderen wanneer ze niet in gebruik zijn. In tegenstelling tot standaard game-objecten blijven deeltjessystemen in het geheugen bewaard, zelfs als u van kamer wisselt. De eenvoudigste manier om hiermee om te gaan, is door geheugenbeheercode in de kamerveranderende evenementen van uw game-objecten te plaatsen.
part_system_clear (ind): Wist alle emitters en deeltjes die tot een specifiek particle systeem behoren.part_system_clear (ind): Wist alle exemplaren van een specifiek deeltjestype.part_emitter_clear (ps, ind): Wist alle deeltjes die bij een specifieke zender horen.part_emitter_destroy (ps, ind): Vernietigt een specifieke emitter in een specifiek particle systeem.part_emitter_destroy_all (ps): Vernietigt alle zenders in een specifiek particle systeem.part_type_destroy (ind): Vernietigt een specifiek deeltjestype.part_system_destroy (ind): Vernietigt een volledig particle systeem, inclusief alle deeltjes en emitters die zich binnenin bevinden.Zelfs met zo'n lange tutorial hebben we alleen nog maar het oppervlak gekraakt van wat voor soort effecten het GameMaker Studio-deeltjessysteem kan. De sleutel tot het beheersen van deeltjes is bekendheid en experiment, dus spring erin en begin met het creëren van je eigen effecten met behulp van de kennis die je hebt opgedaan. Zorg ervoor dat je de officiële GameMaker-documentatie bekijkt om alle beschikbare GML-particle-systemen te bekijken!
