Share
I den här artikeln börjar vi med grunderna i GameMaker Studio-partikelsystemet och slutar med avancerade tekniker och implementeringar. Tänk på detta som en kraschbana för att få dig bekant och bekväm med en av GameMaker Studios mest kraftfulla inbyggda funktioner. Den demo och nedladdningsbara projektfilen låter dig följa med artikeln för att se exakt vad partikelsystemet handlar om.
GameMaker Studio-partikelsystemet är ett billigt och enkelt sätt att skapa flashiga effekter för ditt spelprojekt. Genom en kombination av partiklar och emittrar kan du snabbt skapa imponerande explosioner, rök, blod, shrapnel och otaliga andra effekter. Liknande effekter kan uppnås genom att använda enskilda objekt, men datorkostnaden för det inbyggda partikeleffekter systemet är mycket billigare.
För att använda partikelsystemet i ditt projekt måste du förstå GML (GameMaker Language), men när du väl är bekant med partikelsystemet är det helt enkelt en fråga om att fylla i ämnena och experimenten.
Kolla in demo nedan för att se vad vi kan uppnå:
Partikelsystem i GameMaker Studio består av tre delar: själva systemet, partikeln och emitern. Du kan skapa flera system, och varje system kan innehålla flera partiklar och emittrar. Tänk på systemet som en behållare, med partiklarna och emitterna definierade inom.
Genomförandet av en partikeleffekt i GameMaker Studio är en fyra stegs process.
För att lära dig grunderna i GameMaker Studio-partikelsystemet börjar vi med att skapa denna mycket enkla gröna partikeleffekt.
Att skapa partikelsystemet är lika enkelt som att definiera en variabel. Vi skapar ett objekt som heter obj_first_particle och placera följande kod i objektets Skapa-händelse:
FirstParticleSystem = part_system_create ();
Partikelsystemet kommer att anta djupvärdet för det objekt som systemet definieras i, men du kan också ställa in djupet separat med GML:
part_system_depth (FirstParticleSystem, 0);
Kom ihåg att objekt och partikelsystem med hög djupvärde dras till skärmen först. Med ett djup av 0, vårt gröna partikelsystem kommer att dyka upp över objekt med ett djup större än 0, och kommer att visas under objekt med ett djup mindre än 0.
Partikelsystem dras till skärmen med en basposition i förhållande till (0,0). Om du av någon anledning vill skapa en kompensation för alla framtida positioner för detta partikelsystem, kan du använda följande kod för att skapa en ny basposition (var ind är partikelsystemet):
part_system_position (ind, x, y);
Med en ny basposition inställd på (10,10), en partikel skapad på (25,25) kommer istället att dras till (35,35). Det är sällan nödvändigt att byta basposition för ett partikelsystem, men det kan du tycka är användbart i ditt specifika projekt.
Nu när systemet har upprättats är det dags att definiera den faktiska partikel som emitteren kommer att skapa. Partiklar kan innehålla ett stort antal parametrar som dikterar hur partikeln kommer att se ut och uppträda. Det första steget är att skapa en variabel för partikeln, och vi gör det här i Skapa händelse av obj_first_particle objekt:
first_particle = part_type_create ();
Därefter börjar vi definiera de enskilda parametrarna för partikeln. Eftersom vi inte planerar att ändra denna partikel under körtiden, kan vi placera Allt av den här koden i Skapa händelse av obj_first_particle objekt.
part_type_shape bestämmer partikelns basform. Det finns 14 standardpartikelformer tillgängliga i GameMaker Studio, och du kan också definiera dina egna former. Vi täcker det här i det avancerade avsnittet nedan, men för nu börjar vi bara med en grundläggande torg.
part_type_shape (first_particle, pt_shape_square);
För en fullständig lista över tillgängliga standardformer, kontrollera den officiella GameMaker-dokumentationen.
Med part_type_scale, vi kan ställa in basen X och Y skalvärdena för partikelformen. Eftersom vi vill ha en perfekt kvadratisk form använder vi följande kod:
part_type_scale (first_particle, 1,1);
part_type_size tillåter oss att ändra partiklarnas storlek vid skapandet såväl som över tiden. Formatet för den här koden är part_type_size (ind, size_min, size_max, size_incr, size_wiggle).
Accentsconagua
ind är partikelvariabeln. size_min och size_max bestämma intervallets storlek när den först skapas. Om du vill ha en likformig storlek, skriv helt enkelt samma värde för både min och max. size_incr är ett värde som tillåter partikeln att växa eller krympa över tiden. Detta värde bestämmer tillväxtens hastighet, så om du inte vill att din sprite ska ändra storlek kan du använda ett värde av 0. size_wiggle är lite mer komplicerat, så vi täcker det i avsnittet avancerade tekniker nedan.Här är partikelstorlekskoden som används i vår gröna partikeleffekt:
part_type_size (first_particle, 0.10,0.15, - 001,0.);
Partikeln kommer att skapas med en storlek någonstans mellan 0,10 och 0,15 för att skapa variation, och sprite kommer långsamt att krympa med en hastighet av -0,001. Det här hastighetsvärdet beror mycket på din rumhastighet, så du kommer sannolikt att behöva experimentera med värden för att få de önskade resultaten. Vi använder inte någon storlek wiggle, så vi sätter värdet på 0.
Partiklar i GameMaker Studio kan faktiskt ändra färger över tiden. Detta uppnås med part_type_color2 och part_type_color3. Om du inte vill att din sprite ska ändra färger, så kan du bara använda part_type_color1. För vår gröna partikeleffekt vill vi att den ska börja med en ljusgul / grön färg och sedan byta till en solid grön färg, så vi använder part_type_color2:
part_type_color2 (first_particle, 8454143,65280);
De två färgerna jag har valt är specifika numeriska värden som jag använder regelbundet, men om du vill använda mer traditionella hex-värden kan du använda formatet $ RRGGBB.
Partiklar kan också bli mer eller mindre transparenta över tiden med part_type_alpha2 och part_type_alpha3. Om du vill ha ett konsekvent alfavärde, använd part_type_alpha1. För vår gröna partikeleffekt vill vi att partikeln börjar bli helt ogenomskinlig och blekna med 25% eftersom den stannar på skärmen, så vi behöver två alfa värden:
part_type_alpha2 (first_particle, 1,0.75);
I GameMaker är alfa ett värde från 0 till 1. Ett helt osynligt objekt kommer att ha ett alfavärde på 0, medan ett helt ogenomskinligt objekt har ett alfavärde på 1.
Partikelhastigheten bestäms precis som partikelstorlek. Partiklar skapas inom ett antal hastighetsvärden, och det värdet kan öka eller minska. Formatet för den här koden är part_type_speed (ind, speed_min, speed_max, speed_incr, speed_wiggle), var ind är partikelvariabeln, speed_min och speed_max är hastighetsintervallet, speed_incr är den hastighet vid vilken partikelhastigheten ändras, och speed_wiggle är en parameter som vi kommer att täcka senare.
Snabbkoden för vår gröna partikel är:
part_type_speed (first_particle, 0.1,0.5,0,0);
Vår partikel börjar börja flytta med ett hastighetsvärde någonstans mellan 0,1 och 0,5. Denna hastighet kommer att förbli konstant, så vi använder ett värde av 0, och vi kommer återigen inte att implementera hastighetsvippning, så vi använder ett värde av 0.
Medan en partikelhastighetsparameter bestämmer hur snabbt den rör sig bestämmer riktningsparametern var den rör sig. Riktningskoden finns i följande format: part_type_direction (ind, dir_min, dir_max, dir_incr, dir_wiggle) och igen ställer vi in variabeln, startintervallet, ett inkrementellt värde och ett wiggle-värde. För den gröna partikeleffekten vill vi att vår partikel börjar röra sig i vilken riktning som helst, och vi vill att den riktningen ska förbli konstant:
part_type_direction (first_particle, 0,359,0,0);
Intervallet 0 till 359 säkerställer att partikeln har en chans att röra sig i vilken riktning som helst (en vinkel mellan 0 och 359 grader). Om du ville ha en partikel att flytta upp och endast upp, då skulle du använda ett intervall på 90 till 90).
Graden av vår partikel effekt är det som gör det mest intressant. Medan våra hastighets- och riktningsparametrar är inställda på att skapa en partikel som börjar med att flytta i en riktning med konstant hastighet, slår gravitationsparametern in och ändrar partikeln över tiden. Med ett format av part_type_gravity (ind, grav_amount, grav_direction), tyngdkraftsparametern är väldigt enkel:
part_type_gravity (first_particle, 0.02,90);
Genom att applicera ett litet gravitationstryck på 0,02 i en uppåtriktad riktning (90 grader) kan vi skapa en partikel som verkar flyta. Kombinerade med vår storlek och alfaparametrar krymper partikeln och blir tydligare över tiden, åtföljd av gravitationslyften.
Orienteringen av partikelformen är också viktig för effektens utseende, så vi använder part_type_orientation (ind, ang_min, ang_max, ang_incr, ang_wiggle, ang_relative) att rotera torget över tiden.
ind är partikelvariabeln. ang_min och ang_max bestämmer utgångsvärdet för formens rotationsvärde.ang_incr används för att öka eller minska formens orientering över tiden.ang_relative är ett booleskt värde för att bestämma om orienteringen ska ställas i förhållande till partikelns rörelse (true) eller inte (false). Vi vill att vår gröna partikel roterar något till vänster, så vi använder följande kod:
part_type_orientation (first_particle, 0,359,10,0, true);
En av de viktigaste parametrarna för en partikel är livslängd värde. Detta värde bestämmer den minsta och maximala tiden som en partikel kommer att dras till skärmen. Med två identiska min- och maxvärden kommer alla partiklar av den typen att existera i samma tid. Vi vill att våra gröna partiklar ska ha olika, så vi kommer att använda ett intervall på 100 till 150 för livslängdsvärdet:
part_type_life (first_particle, 100.150);
Den slutliga parametern för partiklar är en enkel booleska för att bestämma huruvida partiklarna ska blandas ihop med en additiv blandningseffekt:
part_type_blend (first_particle, true);
Det första steget i att definiera en emitter är att skapa en variabel. Vi definierar denna emitter i Create Event of the obj_first_particle objekt.
first_emitter = part_emitter_create (FirstParticleSystem);
Därefter definierar vi emitterregionen med part_emitter_region (ps, ind, xmin, xmax, ymin, ymax, form, distribution).
ps är det partikelsystem som emitteren tillhör och ind är emittervariabeln.form bestämmer formen av emitterområdet (ps_shape_rectangle, ps_shape_ellipse, ps_shape_diamond, ps_shap_line). distribution är en fördelningskurva (ps_dist_linear, ps_distr_gaussian, ps_distr_invgaussian).Vi kommer att täcka formen och fördelningsparametrarna närmare i avsnittet avancerade tekniker. För närvarande använder vi standard ellipsform och gaussiska distributionsvärden:
part_emitter_region (FirstParticleSystem, first_emitter, x-20, x + 20, y-20, y + 20, ps_shape_ellipse, ps_distr_gaussian);
Denna kod skapar en elliptisk emitterregion som är 40 pixlar lång och 40 pixlar bred och centrerad på x- och y-värdena för obj_first_particle objekt. Partiklar som skapas av emitteren kommer att visas inom den här definierade regionen.
Nästa steg är att bestämma en av två emittentyper: Burst eller Stream. En Burst-emitter skapar en viss mängd av en viss partikel när den utlöses. En strömavgivare skapar en viss mängd av en viss partikel en gång varje steg.
Vi tar en titt på de mer mångsidiga Burst-emittrarna i sektionen avancerade tekniker, så nu kan vi bara använda Stream-emitern:
part_emitter_stream (FirstParticleSystem, first_emitter, first_particle, 1);
Vi placerar den här koden i Skapa händelse av obj_first_particle objekt, vilket resulterar i att emitteren skapar en partikel varje steg så snart objektet skapas. Med en rumhastighet på 30, kommer vår emitter att skapa 30 partiklar per sekund; att skapa 60 partiklar per sekund, skulle du helt enkelt använda ett värde av 2 istället för 1.
Och med det är vår enkla gröna partikeleffekt komplett! Användbarheten av denna effekt är begränsad, men det är viktigt att börja små innan du dyker in i de mer komplicerade aspekterna av GameMaker Studio-partikelsystemet. När du förstår grunderna i partikelsystemet kan du börja implementera mer avancerade partikelsystem.
Wiggle är en enkel, men ändå kraftfull parameter som kan drastiskt förändra utseendet på dina partiklar. Wiggle-parametern får partikeln att svänga mellan min- och maxvärdena för partikelns livslängd. Värdet kan vara mellan 0 och 20 och bestämmer hastigheten på wiggle.
"Fire Bubble" -exemplet i den inbäddade demo använder ett wiggle-värde på 0,40 i part_type_size parameter:
part_type_size (fire_bubble_part, 0.25,0.75, -0.01,0.40);
En av de vanligaste implementeringarna av partikelsystem involverar partiklar som strömmar utifrån ett rörligt föremål, såsom en rökspår på en raket. Att uppnå denna effekt i GameMaker Studio kräver att en Burst-emitter placeras i ett objekt Steg händelse.
Det medföljande exemplet använder samma gröna partikelsystem som tidigare, men med en lätt modifierad emitter. Istället för att utlösa en strömavgivare i objektets Skapa händelse placeras en Burst-emitter i objektets Steg händelse. Markörens nuvarande position markeras mot markörens föregående position, och om det finns en förändring i markörens position utlöses Burst emitteren för att släppa fem partiklar:
x = mouse_x; y = mouse_y; part_emitter_region (MouseParticle, green_mouse_emitter, x, x, y, y, 0,0); om x! = old_x || old_y! = y part_emitter_burst (MouseParticle, green_mouse_emitter, green_mouse_particle, 5); old_x = x; old_y = y;
Genom att använda olika emitterformer och fördelningskurvor kan du skapa väldigt olika effekter. Linjär kurvfördelning kombinerad med en linjär partikelemitterare kan skapa en övertygande regn effekt.
part_emitter_region (RainParticle, rain_emitter, -100, room_width, y, y, ps_shape_line, ps_distr_linear);
Emitterformen definieras av en linje som börjar 100 pixlar till vänster om rumets ursprung och sträcker sig till rummets bredd. En linjär fördelningskurva används för att fördela regnen partiklar jämnt över emitterområdet. Det är också användbart att använda part_system_update för att föra regnen partikel flera steg i Skapa händelse. Denna kod ger intrycket att regnet faller innan du laddat rummet, trots att partikelsystemet inte fanns kvar i minnet ännu.
repetera (room_speed * 3) part_system_update (RainParticle);
Individuella partiklar i ett system kan även kasta andra partiklar på Steg och Död evenemang. I exemplet visas en lila gnistpartikel som gynnar mindre dammpartiklar när den reser till höger och ger en rökpartikel vid slutet av dess livslängd:
part_type_step (spark_particle, 1, dust_particle); part_type_death (spark_particle, 5, smoke_particle);
Genom att använda part_type_sprite (ind, sprite, animera, sträcka, slumpmässigt), du kan använda egna sprites istället för de inbyggda GameMaker partikeltyperna.
ind är partikelvariabeln.sprite är sprite-variabeln som ska användas.animera är en booleska för att avgöra om delbilderna ska animeras.sträcka är en booleska som matchar animationslängden till partikelns livslängd. slumpmässig är en booleska för att avgöra om startbilden ska väljas slumpmässigt.part_type_sprite (heart_particle, spr_heart, falskt, falskt, falskt);
Det viktigaste att komma ihåg om GameMaker Studio-partikelsystemet är att du manuellt måste ta bort objekt från minnet när det inte används. Till skillnad från vanliga spelobjekt kvarstår partikelsystemen i minnet även om du byter rum. Det enklaste sättet att hantera detta är att placera minneshanteringskoden i rumsändringshändelserna i dina spelobjekt.
part_system_clear (ind): Rensar alla emittrar och partiklar som tillhör ett specifikt partikelsystem.part_system_clear (ind): Rensar alla instanser av en viss partikel typ.part_emitter_clear (ps, ind): Rensar alla partiklar som tillhör en viss emitter.part_emitter_destroy (ps, ind): Förstörar en specifik emitter i ett specifikt partikelsystem.part_emitter_destroy_all (ps): Förstörar alla emittrar i ett specifikt partikelsystem.part_type_destroy (ind): Förstörar en specifik partikel typ.part_system_destroy (ind): Förstörar ett helt partikelsystem, inklusive alla partiklar och emittrar som ingår i.Även med en sådan långvarig handledning har vi fortfarande bara repat ytan på vilka slags effekter GameMaker Studio-partikelsystemet kan. Nyckeln till att mastera partiklar är förtrogenhet och experiment, så hoppa in och börja skapa egna effekter med hjälp av den kunskap du har fått. Var noga med att kolla in den officiella GameMaker-dokumentationen för att se alla tillgängliga GTS-partiklar!
