Puteți anima cele mai simple jocuri cu particule animate. Simulați mișcarea, exploziile și multe altele folosind aceste tehnici.

Pygame este o bibliotecă populară pentru dezvoltarea de jocuri folosind Python. În timp ce construiți jocuri, adăugarea de efecte speciale poate îmbunătăți considerabil atractivitatea vizuală și experiența generală pentru jucători.

Sistemele de particule sunt o tehnică puternică pentru a crea efecte dinamice și interesante vizual, cum ar fi nori de praf, explozii, ceață și multe altele.

Creați un joc simplu

Înainte de a vă scufunda în sistemele de particule și îmbunătățirile vizuale, începeți prin a crea un joc simplu folosind Pygame. Creați un fișier nou numit joc simplu.py și începeți prin a importa bibliotecile necesare și a inițializa Pygame. Configurați fereastra de joc cu o lățime și o înălțime specificate.

Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.

În bucla principală a jocului, gestionați evenimentele utilizatorului și actualizați poziția jucătorului pe baza apăsării tastelor.

instagram viewer
Desenați un dreptunghi pentru obiectul jucător care utilizează pygame.draw.rect().

În cele din urmă, actualizați fereastra jocului folosind pygame.display.flip() și părăsește jocul când jucătorul iese din buclă. Acest joc simplu va servi drept bază pentru adăugarea de efecte speciale folosind sisteme de particule.

Ar trebui să vedeți un pătrat alb reprezentând jucătorul pe care îl puteți muta la stânga și la dreapta:

Crearea diferitelor tipuri de particule

Acum că ați configurat jocul simplu, puteți adăuga diferite sisteme de particule. Creați clase de particule pentru fiecare efect și o clasă de sistem de particule pentru a gestiona și actualiza particulele.

Efect de particule atunci când jucătorul se mișcă

Primul efect de particule va fi o urmă de particule de praf emise din spatele jucătorului atunci când jucătorul începe să mutați folosind mouse-ul sau tastatura. În plus, direcția particulelor de praf se va schimba atunci când jucătorul își schimbă direcția.

Definiți a Particulă clasă care reprezintă o particulă individuală. Fiecare particulă are o poziție inițială (X și y), o viteză aleatorie (dx și dy), și o durată de viață care determină cât de mult va exista particula.

De asemenea, definiți a ParticleSystem clasă care gestionează o colecție de particule. Puteți adăuga o nouă particulă la sistem utilizând add_particle() metodă. The Actualizați() Metoda actualizează toate particulele din sistem și elimină particulele care au ajuns la sfârșitul duratei de viață.

# Clasa de particule
clasăParticulă:
def__init__(sine, x, y):
 sine.x = x
 self.y = y
 self.dx = random.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 self.lifetime = 60
defActualizați(de sine):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1


defa desena(sine, fereastra):
 culoare = (200, 200, 200)
 poziție = (int (self.x), int (self.y))
 pygame.draw.circle (fereastră, culoare, poziție, 2)


# Clasa de sistem de particule
clasăParticleSystem:
def__init__(de sine):
 sine.particule = []


defadaugă_particulă(sine, x, y):
 self.particles.append (Particulă (x, y))


defActualizați(de sine):
pentru particulă în particule de sine:
 particule.actualizare()


dacă particule.durata de viata <= 0:
 auto.particule.elimină (particulă)
defa desena(sine, fereastra):
pentru particulă în particule de sine:
 particulă.desenează (fereastră)

Pentru a integra sistemul de particule în jocul dvs., trebuie să faceți câteva modificări buclei principale ale jocului. Creați un fișier nou numit particule-de-mișcare.py și adăugați codul cu actualizările de mai jos:

# Creați un sistem de particule
particule_sistem = ParticleSystem()
# Bucla principală a jocului
alergare = Adevărat
ceas = pygame.time. Ceas()


in timp ce alergare:
 dt = clock.tick(60) / 1000.0


pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 alergare = Fals


 particule_y = player_y + player_height // 2
 particule_x = player_x + player_width


 taste = pygame.key.get_pressed()
 limită = player_x < window_width - player_width


dacă chei[pygame. K_LEFT] și player_x > 0:
 player_x -= 5
 particle_system.add_particle (particule_x, particule_y)


dacă chei[pygame. K_DREPTA] și limite:
 player_x += 5
 particle_system.add_particle (player_x, particle_y)


 particule_sistem.update()


 window.fill (NEGRU)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (fereastră, ALB, player_pos)
 particle_system.draw (fereastra)


 pygame.display.flip()
# Închide jocul
pygame.quit()

Când mutați obiectul jucătorului acum, ar trebui să vedeți particule care accentuează mișcarea:

Efect de explozie

Următorul efect de particule va fi un efect de explozie care apare atunci când jucătorul trage un glonț. Efectul de explozie va consta din particule de culoare roșie emise din poziția glonțului.

Definiți a Particulă clasă similară cu cea anterioară, dar de data aceasta include a culoare parametru pentru a reprezenta culoarea particulei.

De asemenea, actualizați ParticleSystem clasa pentru a gestiona noul tip de particule. The add_particle() Metoda necesită acum un plus culoare parametru și creează particule cu culoarea specificată.

# Clasa de particule
clasăParticulă:
def__init__(sine, x, y, culoare):
 sine.x = x
 self.y = y
 self.dx = random.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 self.lifetime = 30
 self.color = culoare
defActualizați(de sine):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1


defa desena(sine, fereastra):
 poziție = (int (self.x), int (self.y))
 pygame.draw.cercle (fereastră, self.color, poziție, 3)


# Clasa de sistem de particule
clasăParticleSystem:
def__init__(de sine):
 sine.particule = []


defadaugă_particulă(sine, x, y, culoare):
 self.particles.append (Particulă (x, y, culoare)


defActualizați(de sine):
pentru particulă în particule de sine:
 particule.actualizare()


dacă particule.durata de viata <= 0:
 auto.particule.elimină (particulă)
defa desena(sine, fereastra):
pentru particulă în particule de sine:
 particulă.desenează (fereastră)

Pentru a integra efectul de explozie în jocul tău, trebuie să faci câteva modificări buclei principale ale jocului. Creați un nume de fișier nou shoot-particle.py și adăugați codul cu actualizările de mai jos:

# Creați un sistem de particule
particule_sistem = ParticleSystem()
# Bucla principală a jocului
alergare = Adevărat
ceas = pygame.time. Ceas()


in timp ce alergare:
 dt = clock.tick(60) / 1000.0


pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 alergare = Fals


 taste = pygame.key.get_pressed()
 limită = player_x < window_width - player_width


dacă chei[pygame. K_LEFT] și player_x > 0:
 player_x -= 5


dacă chei[pygame. K_DREPTA] și limite:
 player_x += 5


dacă chei[pygame. K_SPACE]:
 bullet_x = player_x + player_width // 2
 bullet_y = player_y
 particle_system.add_particle (bullet_x, bullet_y, RED)


 particule_sistem.update()


 window.fill (NEGRU)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (fereastră, ALB, player_pos)
 particle_system.draw (fereastra)


 pygame.display.flip()
# Închide jocul
pygame.quit()

Iată rezultatul:

Când bara de spațiu ( pygame. K_SPACE) este apăsat, adăugați o particulă în sistemul de particule în poziția glonțului. Acest lucru creează efectul de explozie cu particule roșii.

Efect de praf

Îmbunătățirea vizuală finală pe care o puteți implementa este un efect de fundal prăfuit. Efectul de praf va consta în particule gri mici care se mișcă într-un model circular, creând un fundal dinamic și prăfuit.

Actualizați Particulă clasa pentru a include o unghi și viteză pentru fiecare particulă. Unghiul determină direcția de mișcare, iar viteza controlează cât de repede se mișcă particulele în modelul lor circular. Modificați Actualizați() metodă de a actualiza poziția fiecărei particule în funcție de unghiul și viteza acesteia.

De asemenea, actualizați ParticleSystem clasa pentru a gestiona noul comportament al particulelor. Particulele se mișcă acum într-un model circular în fereastra jocului.

# Clasa de particule
clasăParticulă:
def__init__(sine, x, y, rază):
 sine.x = x
 self.y = y
 self.radius = raza
 self.angle = random.uniform(0, 2 * math.pi)
 self.speed = random.uniform(0.5, 1.5)
defActualizați(de sine):
 auto.unghi += 0.02
 self.x += math.cos (self.unghi) * self.speed
 self.y += math.sin (self.unghi) * self.speed


dacă sine.x < 0:
 self.x = lățimea_ferestrei
elif self.x > window_width:
 sine.x = 0


dacă self.y < 0:
 self.y = window_height
elif self.y > window_height:
 self.y = 0


defa desena(sine, fereastra):
 culoare = (128, 128, 128)
 pos = (int (self.x), int (self.y))
 raza = int (self.radius)
 pygame.draw.circle (fereastră, culoare, poziție, rază)


# Clasa de sistem de particule
clasăParticleSystem:
def__init__(de sine):
 sine.particule = []


defadaugă_particulă(sine, x, y, rază):
 self.particles.append (Particulă (x, y, rază))


defActualizați(de sine):
pentru particulă în particule de sine:
 particule.actualizare()
defa desena(sine, fereastra):
pentru particulă în particule de sine:
 particulă.desenează (fereastră)

Pentru a integra efectul de praf în jocul tău, trebuie să faci câteva modificări buclei principale ale jocului. Creați un fișier nou numit particule-praf.py și adăugați codul cu actualizările de mai jos:

# Creați un sistem de particule pentru efectul de praf
particule_sistem = ParticleSystem()
# Bucla principală a jocului
alergare = Adevărat
ceas = pygame.time. Ceas()


in timp ce alergare:
 dt = clock.tick(60) / 1000.0


pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 alergare = Fals


 particule_x = aleatoriu.randint(0, window_width)
 particule_y = random.randint(0, window_height)


 particle_system.add_particle (particule_x, particule_y, 1)


 particule_sistem.update()


 window.fill((0, 0, 0))
 particle_system.draw (fereastra)


 pygame.display.flip()
# Închide jocul
pygame.quit()

Adăugați particule aleatoriu în fereastra jocului folosind random.randint() funcţie. Fiecare particulă are o rază inițială de 1. Actualizați și desenați sistemul de particule în fereastra jocului, creând un efect de fundal dinamic și prăfuit.

Ar trebui să vedeți multe particule pe ecran, mișcându-se aleator, dar lin:

Cele mai bune practici pentru efecte speciale

Când adăugați efecte speciale în jocul dvs. Pygame, luați în considerare următoarele bune practici:

Optimizarea performanței

Sistemele de particule pot implica un număr mare de particule, ceea ce poate afecta performanța jocului. Implementați tehnici precum partiționarea spațială (de exemplu, Quadtree) pentru a optimiza actualizările și desenul particulelor.

Reciclarea particulelor

În loc să creați și să distrugeți particule în fiecare cadru, luați în considerare reutilizarea particulelor prin resetarea proprietăților lor când ajung la sfârșitul duratei de viață. Acest lucru ajută la minimizarea alocării și dezalocării memoriei.

Pooling de particule

Mențineți un grup de particule prealocate pentru a evita suprasolicitarea creării de noi instanțe în timpul rulării. Acest lucru poate îmbunătăți performanța și poate reduce fragmentarea memoriei.

Limitarea numărului de particule

Pentru a preveni ca sistemele de particule să copleșească ecranul jocului, setați limite pentru numărul maxim de particule și eliminați particulele când ating această limită. Acest lucru asigură că efectele rămân atrăgătoare din punct de vedere vizual, fără a împiedica jocul.

Consistență vizuală

Mențineți un stil vizual consistent pe tot parcursul jocului, inclusiv efectele de particule. Asigurați-vă că culorile, dimensiunile și modelele de mișcare ale particulelor sunt coerente cu tema generală și stilul artistic.

Efecte sonore

Adăugați efecte sonore pentru a vă completa efectele particulelor. De exemplu, redați sunete de explozie când are loc un efect de explozie sau sunete ambientale când sunt active efecte de ceață sau praf.

Faceți jocurile mai distractive cu efecte speciale

Adăugarea de efecte speciale, cum ar fi sisteme de particule, la jocurile dvs. Pygame poate îmbunătăți considerabil experiența jucătorului și poate face jocurile dvs. mai captivante și mai distractive pentru jucători. Prin implementarea efectelor de particule cum ar fi urme, explozii, ceață și praf, puteți crea medii vizuale uimitoare și dinamice.

Nu uitați să luați în considerare optimizarea performanței, reciclarea particulelor și consistența vizuală în timp ce încorporați efecte speciale în jocuri. Cu creativitate și experimentare, puteți duce jocurile dvs. Pygame la următorul nivel și puteți captiva jucătorii cu experiențe captivante și incitante.