Lägga till specialeffekter till Pygame-spel: partikelsystem och visuella förbättringar

Pygame är ett populärt bibliotek för att utveckla spel med Python. När du bygger spel kan specialeffekter avsevärt förbättra den visuella dragningen och den totala upplevelsen för spelare.

Partikelsystem är en kraftfull teknik för att skapa dynamiska och visuellt intressanta effekter som dammmoln, explosioner, dimma med mera.

Skapa ett enkelt spel

Innan du dyker in i partikelsystem och visuella förbättringar, börja med att skapa ett enkelt spel med Pygame. Skapa en ny fil med namnet simple-game.py och börja med att importera de nödvändiga biblioteken och initiera Pygame. Ställ in spelfönstret med en specificerad bredd och höjd.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Inuti huvudspelslingan, hantera användarhändelser och uppdatera spelarens position baserat på knapptryckningar. Rita en rektangel för spelarobjektet som använder pygame.draw.rect().

Uppdatera slutligen spelfönstret med hjälp av pygame.display.flip() och avsluta spelet när spelaren lämnar loopen. Detta enkla spel kommer att fungera som grunden för att lägga till specialeffekter med hjälp av partikelsystem.

Du bör se en vit fyrkant som representerar spelaren som du kan flytta åt vänster och höger:

Skapa olika partikeltyper

Nu när du har ställt in ditt enkla spel kan du lägga till olika partikelsystem. Skapa partikelklasser för varje effekt och en partikelsystemklass för att hantera och uppdatera partiklarna.

Partikeleffekt när spelaren rör sig

Den första partikeleffekten kommer att vara ett spår av dammpartiklar som avges från spelarens rygg när spelaren börjar flytta med mus- eller tangentbordsinmatning. Dessutom kommer dammpartiklarnas riktning att ändras när spelaren ändrar riktning.

Definiera a Partikel klass som representerar en enskild partikel. Varje partikel har en initial position (x och y), en slumpmässig hastighet (dx och dy), och en livstid som avgör hur länge partikeln kommer att existera.

Definiera också a PartikelSystem klass som hanterar en samling partiklar. Du kan lägga till en ny partikel till systemet med hjälp av add_particle() metod. De uppdatering() metod uppdaterar alla partiklar i systemet och tar bort partiklar som har nått slutet av sin livstid.

# Partikelklass
klassPartikel:
def__i det__(själv, x, y):
 själv.x = x
 själv.y = y
 self.dx = random.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 själv.livstid = 60
defuppdatering(själv):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defdra(själv, fönster):
 färg = (200, 200, 200)
 position = (int (self.x), int (self.y))
 pygame.draw.circle (fönster, färg, position, 2)
# Partikelsystemklass
klassPartikelSystem:
def__i det__(själv):
 self.particles = []
defadd_particle(själv, x, y):
 self.particles.append (Partikel (x, y))
defuppdatering(själv):
för partikel i self.particles:
 particle.update()
om partikel.livstid <= 0:
 self.particles.remove (partikel)
defdra(själv, fönster):
för partikel i self.particles:
 particle.draw (fönster)

För att integrera partikelsystemet i ditt spel måste du göra några ändringar i huvudspelslingan. Skapa en ny fil med namnet rörelse-partiklar.py och lägg till koden med följande uppdateringar:

# Skapa partikelsystem
particle_system = ParticleSystem()
# Huvudspelslinga
springer = Sann
klocka = pygame.time. Klocka()
medan löpning:
 dt = clock.tick(60) / 1000.0
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 springer = Falsk
 particle_y = player_y + player_height // 2
 particle_x = player_x + player_width
 keys = pygame.key.get_pressed()
 gräns = player_x < window_width - player_width
om nycklar[pygame. K_LEFT] och player_x > 0:
 player_x -= 5
 particle_system.add_particle (partikel_x, partikel_y)
om nycklar[pygame. K_RIGHT] och gräns:
 player_x += 5
 particle_system.add_particle (spelare_x, partikel_y)
 particle_system.update()
 window.fill (SVART)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (fönster, WHITE, player_pos)
 particle_system.draw (fönster)
 pygame.display.flip()
# Avsluta spelet
pygame.quit()

När du flyttar spelarobjektet nu bör du se partiklar som framhäver rörelsen:

Blast effekt

Nästa partikeleffekt blir en sprängeffekt som uppstår när spelaren skjuter en kula. Sprängeffekten kommer att bestå av rödfärgade partiklar som emitteras från kulans position.

Definiera a Partikel klass som liknar den föregående, men den här gången inkluderar en Färg parameter för att representera partikelns färg.

Uppdatera också PartikelSystem klass för att hantera den nya partikeltypen. De add_particle() metod tar nu en extra Färg parameter och skapar partiklar med den angivna färgen.

# Partikelklass
klassPartikel:
def__i det__(själv, x, y, färg):
 själv.x = x
 själv.y = y
 self.dx = random.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 själv.livstid = 30
 self.color = färg
defuppdatering(själv):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defdra(själv, fönster):
 position = (int (self.x), int (self.y))
 pygame.draw.circle (fönster, själv.färg, position, 3)
# Partikelsystemklass
klassPartikelSystem:
def__i det__(själv):
 self.particles = []
defadd_particle(själv, x, y, färg):
 self.particles.append (Partikel (x, y, färg)
defuppdatering(själv):
för partikel i self.particles:
 particle.update()
om partikel.livstid <= 0:
 self.particles.remove (partikel)
defdra(själv, fönster):
för partikel i self.particles:
 particle.draw (fönster)

För att integrera blast-effekten i ditt spel måste du göra några ändringar i huvudspelslingan. Skapa ett nytt filnamn shoot-particle.py och lägg till koden med följande uppdateringar:

# Skapa partikelsystem
particle_system = ParticleSystem()
# Huvudspelslinga
springer = Sann
klocka = pygame.time. Klocka()
medan löpning:
 dt = clock.tick(60) / 1000.0
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 springer = Falsk
 keys = pygame.key.get_pressed()
 gräns = player_x < window_width - player_width
om nycklar[pygame. K_LEFT] och player_x > 0:
 player_x -= 5
om nycklar[pygame. K_RIGHT] och gräns:
 player_x += 5
om nycklar[pygame. K_SPACE]:
 bullet_x = player_x + player_width // 2
 bullet_y = player_y
 particle_system.add_particle (bullet_x, bullet_y, RED)
 particle_system.update()
 window.fill (SVART)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (fönster, WHITE, player_pos)
 particle_system.draw (fönster)
 pygame.display.flip()
# Avsluta spelet
pygame.quit()

Här är utgången:

När mellanslagstangenten ( pygame. K_SPACE) trycks, lägg till en partikel till partikelsystemet vid kulans position. Detta skapar sprängeffekten med röda partiklar.

Dammeffekt

Den sista visuella förbättringen du kan implementera är en dammig bakgrundseffekt. Dammeffekten kommer att bestå av små grå partiklar som rör sig i ett cirkulärt mönster, vilket skapar en dynamisk och dammig bakgrund.

Uppdatera Partikel klass att inkludera en vinkel och fart för varje partikel. Vinkeln bestämmer rörelseriktningen och hastigheten styr hur snabbt partiklarna rör sig i sitt cirkulära mönster. Ändra uppdatering() metod för att uppdatera positionen för varje partikel baserat på dess vinkel och hastighet.

Uppdatera också PartikelSystem klass för att hantera det nya partikelbeteendet. Partiklarna rör sig nu i ett cirkulärt mönster inom spelfönstret.

# Partikelklass
klassPartikel:
def__i det__(själv, x, y, radie):
 själv.x = x
 själv.y = y
 self.radius = radie
 self.angle = random.uniform(0, 2 * math.pi)
 self.speed = random.uniform(0.5, 1.5)
defuppdatering(själv):
 själv.vinkel += 0.02
 self.x += math.cos (self.angle) * self.speed
 self.y += math.sin (self.angle) * self.speed
om self.x < 0:
 self.x = window_width
elif self.x > window_width:
 själv.x = 0
om self.y < 0:
 self.y = fönsterhöjd
elif self.y > window_height:
 self.y = 0
defdra(själv, fönster):
 färg = (128, 128, 128)
 pos = (int (self.x), int (self.y))
 radius = int (self.radius)
 pygame.draw.circle (fönster, färg, pos, radie)
# Partikelsystemklass
klassPartikelSystem:
def__i det__(själv):
 self.particles = []
defadd_particle(själv, x, y, radie):
 self.particles.append (Partikel (x, y, radie))
defuppdatering(själv):
för partikel i self.particles:
 particle.update()
defdra(själv, fönster):
för partikel i self.particles:
 particle.draw (fönster)

För att integrera dammeffekten i ditt spel måste du göra några ändringar i huvudspelslingan. Skapa en ny fil med namnet dust-particle.py och lägg till koden med följande uppdateringar:

# Skapa partikelsystem för dammeffekt
particle_system = ParticleSystem()
# Huvudspelslinga
springer = Sann
klocka = pygame.time. Klocka()
medan löpning:
 dt = clock.tick(60) / 1000.0
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 springer = Falsk
 partikel_x = random.randint(0, window_width)
 partikel_y = random.randint(0, window_height)
 particle_system.add_particle (partikel_x, partikel_y, 1)
 particle_system.update()
 window.fill((0, 0, 0))
 particle_system.draw (fönster)
 pygame.display.flip()
# Avsluta spelet
pygame.quit()

Lägg till partiklar slumpmässigt över spelfönstret med hjälp av random.randint() fungera. Varje partikel har en initial radie på 1. Uppdatera och rita partikelsystemet i spelfönstret, vilket skapar en dynamisk och dammig bakgrundseffekt.

Du bör se många partiklar på skärmen som rör sig slumpmässigt men smidigt:

Bästa metoder för specialeffekter

När du lägger till specialeffekter till ditt Pygame-spel, överväg följande bästa praxis:

Prestandaoptimering

Partikelsystem kan involvera ett stort antal partiklar, vilket kan påverka spelets prestanda. Implementera tekniker som rumslig partitionering (t.ex. Quadtree) för att optimera partikeluppdateringar och ritning.

Partikelåtervinning

Istället för att skapa och förstöra partiklar i varje bildruta, överväg att återanvända partiklar genom att återställa deras egenskaper när de når slutet av sin livstid. Detta hjälper till att minimera minnesallokering och avallokering.

Partikelpoolning

Upprätthåll en pool av förallokerade partiklar för att undvika omkostnader för att skapa nya instanser under körning. Detta kan förbättra prestandan och minska minnesfragmenteringen.

Begränsa antalet partiklar

För att förhindra att partikelsystem överväldigar spelskärmen, sätt gränser för det maximala antalet partiklar och ta bort partiklar när de når denna gräns. Detta säkerställer att effekterna förblir visuellt tilltalande utan att hindra spelet.

Visuell konsistens

Behåll en konsekvent visuell stil genom hela ditt spel, inklusive partikeleffekter. Se till att färger, storlekar och rörelsemönster för partiklar stämmer överens med det övergripande temat och konststilen.

Ljudeffekter

Lägg till ljudeffekter för att komplettera dina partikeleffekter. Spela till exempel explosionsljud när en sprängeffekt uppstår eller omgivande ljud när dimma eller dammeffekter är aktiva.

Gör spel roligare med specialeffekter

Att lägga till specialeffekter, som partikelsystem, till dina Pygame-spel kan avsevärt förbättra spelarupplevelsen och göra dina spel mer engagerande och roligare för spelarna. Genom att implementera partikeleffekter som stigar, explosioner, dimma och damm kan du skapa visuellt fantastiska och dynamiska miljöer.

Kom ihåg att överväga prestandaoptimering, partikelåtervinning och visuell konsekvens samtidigt som du införlivar specialeffekter i dina spel. Med kreativitet och experimenterande kan du ta dina Pygame-spel till nästa nivå och fängsla spelare med uppslukande och spännande upplevelser.