Speciale effecten toevoegen aan Pygame-spellen: deeltjessystemen en visuele verbeteringen

Pygame is een populaire bibliotheek voor het ontwikkelen van games met behulp van Python. Tijdens het bouwen van games kan het toevoegen van speciale effecten de visuele aantrekkingskracht en algehele ervaring voor spelers aanzienlijk verbeteren.

Deeltjessystemen zijn een krachtige techniek voor het creëren van dynamische en visueel interessante effecten zoals stofwolken, explosies, mist en meer.

Maak een eenvoudig spel

Voordat je in deeltjessystemen en visuele verbeteringen duikt, begin je met het maken van een eenvoudig spel met Pygame. Maak een nieuw bestand met de naam simpel-spel.py en begin met het importeren van de benodigde bibliotheken en het initialiseren van Pygame. Stel het spelvenster in met een opgegeven breedte en hoogte.

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats en is gratis voor u om te gebruiken onder de MIT-licentie.

Binnen de hoofdspellus handel je gebruikersgebeurtenissen af ​​en werk je de positie van de speler bij op basis van toetsaanslagen. Teken een rechthoek voor het spelerobject dat wordt gebruikt pygame.draw.rect().

Werk ten slotte het spelvenster bij met behulp van pygame.display.flip() en stop het spel wanneer de speler de lus verlaat. Dit eenvoudige spel zal dienen als basis voor het toevoegen van speciale effecten met behulp van partikelsystemen.

Je zou een wit vierkant moeten zien dat de speler voorstelt die je naar links en rechts kunt bewegen:

Verschillende soorten deeltjes maken

Nu je je eenvoudige spel hebt opgezet, kun je verschillende deeltjessystemen toevoegen. Maak partikelklassen voor elk effect en een partikelsysteemklasse om de partikels te beheren en bij te werken.

Deeltjeseffect wanneer de speler beweegt

Het eerste deeltjeseffect is een spoor van stofdeeltjes dat uit de rug van de speler wordt uitgestoten wanneer de speler begint verplaatsen met muis- of toetsenbordinvoer. Bovendien verandert de richting van de stofdeeltjes wanneer de speler van richting verandert.

Definieer een Deeltje klasse die een individueel deeltje vertegenwoordigt. Elk deeltje heeft een beginpositie (X En j), een willekeurige snelheid (dx En dood), en een levensduur die bepaalt hoe lang het deeltje zal bestaan.

Definieer ook een Deeltjessysteem klasse die een verzameling deeltjes beheert. U kunt een nieuw deeltje aan het systeem toevoegen met behulp van de add_particle() methode. De update() methode werkt alle deeltjes in het systeem bij en verwijdert deeltjes die het einde van hun levensduur hebben bereikt.

# Deeltjesklasse
klasDeeltje:
def__in het__(zelf, x, y):
 zelf.x = x
 zelf.y = y
 zelf.dx = willekeurig.uniform(-1, 1)
 zelf.dy = willekeurig.uniform(-1, 1)
 zelf.leven = 60
defupdate(zelf):
 zelf.x += zelf.dx
 zelf.y += zelf.dy
 zelf.levensduur -= 1
deftekenen(zelf, venster):
 kleur = (200, 200, 200)
 positie = (int (zelf.x), int (zelf.y))
 pygame.draw.circle (venster, kleur, positie, 2)
# Deeltjessysteemklasse
klasDeeltjessysteem:
def__in het__(zelf):
 self.particles = []
defvoeg_deeltje toe(zelf, x, y):
 self.particles.append (deeltje (x, y))
defupdate(zelf):
voor deeltje in zelf.deeltjes:
 deeltje.update()
als deeltje.levensduur <= 0:
 self.particles.remove (deeltje)
deftekenen(zelf, venster):
voor deeltje in zelf.deeltjes:
 partikel.draw (venster)

Om het partikelsysteem in je game te integreren, moet je een paar wijzigingen aanbrengen in de hoofdspellus. Maak een nieuw bestand met de naam bewegingsdeeltjes.py en voeg de code toe met de onderstaande updates:

# Maak een deeltjessysteem
partikel_systeem = Deeltjessysteem()
# Hoofdspellus
hardlopen = WAAR
klok = pygame.tijd. Klok()
terwijl rennen:
 dt = klok.vinkje(60) / 1000.0
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
 hardlopen = Vals
 partikel_y = speler_y + speler_hoogte // 2
 deeltje_x = speler_x + speler_breedte
 toetsen = pygame.key.get_pressed()
 grens = player_x < window_width - player_width
als toetsen[pygame. K_LEFT] En speler_x > 0:
 speler_x -= 5
 partikel_systeem.add_particle (particle_x, partikel_y)
als toetsen[pygame. K_RIGHT] En grens:
 speler_x += 5
 partikel_systeem.add_particle (speler_x, partikel_y)
 partikel_systeem.update()
 venster.vulling (ZWART)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (venster, WIT, player_pos)
 particle_system.draw (venster)
 pygame.display.flip()
# Sluit het spel af
pygame.quit()

Als je het spelerobject nu verplaatst, zou je deeltjes moeten zien die de beweging benadrukken:

Ontploffingseffect

Het volgende deeltjeseffect is een explosie-effect dat optreedt wanneer de speler een kogel afschiet. Het ontploffingseffect bestaat uit roodgekleurde deeltjes die worden uitgestoten vanuit de positie van de kogel.

Definieer een Deeltje klasse vergelijkbaar met de vorige, maar deze keer bevat een kleur parameter om de kleur van het deeltje weer te geven.

Update ook de Deeltjessysteem class om met het nieuwe partikeltype om te gaan. De add_particle() methode kost nu een extra kleur parameter en maakt deeltjes met de opgegeven kleur.

# Deeltjesklasse
klasDeeltje:
def__in het__(zelf, x, y, kleur):
 zelf.x = x
 zelf.y = y
 zelf.dx = willekeurig.uniform(-2, 2)
 zelf.dy = willekeurig.uniform(-2, 2)
 zelf.leven = 30
 zelf.kleur = kleur
defupdate(zelf):
 zelf.x += zelf.dx
 zelf.y += zelf.dy
 zelf.levensduur -= 1
deftekenen(zelf, venster):
 positie = (int (zelf.x), int (zelf.y))
 pygame.draw.circle (venster, zelfkleur, positie, 3)
# Deeltjessysteemklasse
klasDeeltjessysteem:
def__in het__(zelf):
 self.particles = []
defvoeg_deeltje toe(zelf, x, y, kleur):
 self.particles.append (Deeltje (x, y, kleur)
defupdate(zelf):
voor deeltje in zelf.deeltjes:
 deeltje.update()
als deeltje.levensduur <= 0:
 self.particles.remove (deeltje)
deftekenen(zelf, venster):
voor deeltje in zelf.deeltjes:
 partikel.draw (venster)

Om het ontploffingseffect in je spel te integreren, moet je een paar wijzigingen aanbrengen in de hoofdspelloop. Maak een nieuwe bestandsnaam aan shoot-particle.py en voeg de code toe met de onderstaande updates:

# Maak een deeltjessysteem
partikel_systeem = Deeltjessysteem()
# Hoofdspellus
hardlopen = WAAR
klok = pygame.tijd. Klok()
terwijl rennen:
 dt = klok.vinkje(60) / 1000.0
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
 hardlopen = Vals
 toetsen = pygame.key.get_pressed()
 grens = player_x < window_width - player_width
als toetsen[pygame. K_LEFT] En speler_x > 0:
 speler_x -= 5
als toetsen[pygame. K_RIGHT] En grens:
 speler_x += 5
als toetsen[pygame. K_SPACE]:
 bullet_x = player_x + player_width // 2
 bullet_y = speler_y
 partikel_systeem.add_particle (bullet_x, bullet_y, ROOD)
 partikel_systeem.update()
 venster.vulling (ZWART)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (venster, WIT, player_pos)
 particle_system.draw (venster)
 pygame.display.flip()
# Sluit het spel af
pygame.quit()

Hier is de uitvoer:

Wanneer de spatiebalk ( pyspel. K_SPACE) wordt ingedrukt, voegt u een deeltje toe aan het partikelsysteem op de positie van de kogel. Dit creëert het explosie-effect met rode deeltjes.

Stofeffect

De laatste visuele verbetering die u kunt implementeren, is een stoffig achtergrondeffect. Het stofeffect bestaat uit kleine grijze deeltjes die in een cirkelvormig patroon bewegen, waardoor een dynamische en stoffige achtergrond ontstaat.

Update de Deeltje klasse om een ​​op te nemen hoek En snelheid voor elk deeltje. De hoek bepaalt de bewegingsrichting en de snelheid bepaalt hoe snel de deeltjes in hun cirkelvormige patroon bewegen. Wijzig de update() methode om de positie van elk deeltje bij te werken op basis van zijn hoek en snelheid.

Update ook de Deeltjessysteem class om met het nieuwe deeltjesgedrag om te gaan. De deeltjes bewegen nu in een cirkelvormig patroon binnen het spelvenster.

# Deeltjesklasse
klasDeeltje:
def__in het__(zelf, x, y, straal):
 zelf.x = x
 zelf.y = y
 self.radius = straal
 zelf.hoek = willekeurig.uniform(0, 2 * wiskunde.pi)
 zelf.snelheid = willekeurig.uniform(0.5, 1.5)
defupdate(zelf):
 zelf.hoek += 0.02
 self.x += math.cos (self.angle) * self.speed
 zelf.y += math.sin (zelf.hoek) * zelf.snelheid
als zelf.x < 0:
 self.x = venster_breedte
elif self.x > venster_breedte:
 zelf.x = 0
als zelf.y < 0:
 zelf.y = venster_hoogte
elif zelf.y > vensterhoogte:
 zelf.y = 0
deftekenen(zelf, venster):
 kleur = (128, 128, 128)
 pos = (int (zelf.x), int (zelf.y))
 radius = int (zelfradius)
 pygame.draw.circle (venster, kleur, pos, radius)
# Deeltjessysteemklasse
klasDeeltjessysteem:
def__in het__(zelf):
 self.particles = []
defvoeg_deeltje toe(zelf, x, y, straal):
 self.particles.append (deeltje (x, y, straal))
defupdate(zelf):
voor deeltje in zelf.deeltjes:
 deeltje.update()
deftekenen(zelf, venster):
voor deeltje in zelf.deeltjes:
 partikel.draw (venster)

Om het dust-effect in je game te integreren, moet je een paar wijzigingen aanbrengen in de hoofdgame-lus. Maak een nieuw bestand met de naam stofdeeltjes.py en voeg de code toe met de onderstaande updates:

# Creëer deeltjessysteem voor stofeffect
partikel_systeem = Deeltjessysteem()
# Hoofdspellus
hardlopen = WAAR
klok = pygame.tijd. Klok()
terwijl rennen:
 dt = klok.vinkje(60) / 1000.0
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
 hardlopen = Vals
 deeltje_x = willekeurig.randint(0, vensterbreedte)
 partikel_y = willekeurig.randint(0, vensterhoogte)
 partikel_systeem.add_particle (particle_x, partikel_y, 1)
 partikel_systeem.update()
 venster.vullen((0, 0, 0))
 particle_system.draw (venster)
 pygame.display.flip()
# Sluit het spel af
pygame.quit()

Voeg willekeurig deeltjes toe aan het spelvenster met behulp van de willekeurig.randint() functie. Elk deeltje heeft een initiële straal van 1. Werk het deeltjessysteem bij en teken het in het spelvenster, waardoor een dynamisch en stoffig achtergrondeffect ontstaat.

Je zou veel deeltjes op het scherm moeten zien, willekeurig maar soepel bewegend:

Beste praktijken voor speciale effecten

Houd bij het toevoegen van speciale effecten aan je Pygame-spel rekening met de volgende best practices:

Prestatie optimalisatie

Bij deeltjessystemen kan een groot aantal deeltjes betrokken zijn, wat de spelprestaties kan beïnvloeden. Implementeer technieken zoals ruimtelijke partitionering (bijvoorbeeld Quadtree) om partikelupdates en tekenen te optimaliseren.

Recycling van deeltjes

In plaats van deeltjes in elk frame te creëren en te vernietigen, kun je overwegen deeltjes te hergebruiken door hun eigenschappen te resetten wanneer ze het einde van hun levensduur bereiken. Dit helpt geheugentoewijzing en deallocatie te minimaliseren.

Deeltjespooling

Onderhoud een pool van vooraf toegewezen deeltjes om de overhead van het maken van nieuwe exemplaren tijdens runtime te voorkomen. Dit kan de prestaties verbeteren en geheugenfragmentatie verminderen.

Beperk het aantal deeltjes

Om te voorkomen dat deeltjessystemen het spelscherm overweldigen, stelt u limieten in voor het maximale aantal deeltjes en verwijdert u deeltjes wanneer ze deze limiet bereiken. Dit zorgt ervoor dat de effecten visueel aantrekkelijk blijven zonder de gameplay te belemmeren.

Visuele consistentie

Zorg voor een consistente visuele stijl tijdens je game, inclusief partikeleffecten. Zorg ervoor dat kleuren, afmetingen en bewegingspatronen van deeltjes coherent zijn met het algemene thema en de kunststijl.

Geluidseffecten

Voeg geluidseffecten toe als aanvulling op uw partikeleffecten. Speel bijvoorbeeld explosiegeluiden wanneer er een ontploffingseffect optreedt of omgevingsgeluiden wanneer mist- of stofeffecten actief zijn.

Maak games leuker met speciale effecten

Het toevoegen van speciale effecten, zoals partikelsystemen, aan uw Pygame-spellen kan de spelerservaring aanzienlijk verbeteren en uw spellen boeiender en leuker maken voor spelers. Door deeltjeseffecten zoals paden, explosies, mist en stof te implementeren, kunt u visueel verbluffende en dynamische omgevingen creëren.

Vergeet niet om prestatie-optimalisatie, deeltjesrecycling en visuele consistentie te overwegen terwijl je speciale effecten in je games opneemt. Met creativiteit en experimenteren kun je je Pygame-spellen naar een hoger niveau tillen en spelers boeien met meeslepende en opwindende ervaringen.