Aggiunta di effetti speciali ai giochi Pygame: sistemi di particelle e miglioramenti visivi

Pygame è una popolare libreria per lo sviluppo di giochi utilizzando Python. Durante la creazione di giochi, l'aggiunta di effetti speciali può migliorare notevolmente l'aspetto visivo e l'esperienza complessiva per i giocatori.

I sistemi di particelle sono una tecnica potente per creare effetti dinamici e visivamente interessanti come nuvole di polvere, esplosioni, nebbia e altro.

Crea un gioco semplice

Prima di immergerti nei sistemi di particelle e nei miglioramenti visivi, inizia creando un semplice gioco usando Pygame. Crea un nuovo file denominato gioco-semplice.py e inizia importando le librerie necessarie e inizializzando Pygame. Imposta la finestra di gioco con una larghezza e un'altezza specificate.

Il codice utilizzato in questo articolo è disponibile in this Deposito GitHub ed è gratuito per l'uso con la licenza MIT.

All'interno del ciclo di gioco principale, gestisci gli eventi dell'utente e aggiorna la posizione del giocatore in base alla pressione dei tasti.

Disegna un rettangolo per l'oggetto giocatore utilizzando pygame.draw.rect().

Infine, aggiorna la finestra del gioco usando pygame.display.flip() e lascia il gioco quando il giocatore esce dal loop. Questo semplice gioco servirà come base per l'aggiunta di effetti speciali utilizzando i sistemi di particelle.

Dovresti vedere un quadrato bianco che rappresenta il giocatore che puoi spostare a sinistra e a destra:

Creazione di vari tipi di particelle

Ora che hai impostato il tuo semplice gioco, puoi aggiungere diversi sistemi di particelle. Crea classi di particelle per ogni effetto e una classe di sistema di particelle per gestire e aggiornare le particelle.

Effetto particellare quando il giocatore si muove

Il primo effetto particellare sarà una scia di particelle di polvere emesse dalla schiena del giocatore quando il giocatore inizia a farlo spostare utilizzando il mouse o l'input da tastiera. Inoltre, la direzione delle particelle di polvere cambierà quando il giocatore cambia direzione.

Definisci un Particella classe che rappresenta una singola particella. Ogni particella ha una posizione iniziale (X E si), una velocità casuale (dx E morire) e una durata che determina per quanto tempo esisterà la particella.

Inoltre, definisci a Sistema di particelle classe che gestisce una raccolta di particelle. È possibile aggiungere una nuova particella al sistema utilizzando il file aggiungi_particella() metodo. IL aggiornamento() Il metodo aggiorna tutte le particelle nel sistema e rimuove le particelle che hanno raggiunto la fine del loro ciclo di vita.

# Classe di particelle
classeParticella:
def__dentro__(sé, x, y):
 self.x = x
 self.y = y
 self.dx = random.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 self.lifetime = 60
defaggiornamento(se stesso):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defdisegno(sé, finestra):
 colore = (200, 200, 200)
 posizione = (int (self.x), int (self.y))
 pygame.draw.circle (finestra, colore, posizione, 2)
# Classe del sistema particellare
classeSistema di particelle:
def__dentro__(se stesso):
 self.particelle = []
defadd_particle(sé, x, y):
 self.particelle.append (Particella (x, y))
defaggiornamento(se stesso):
per particella In self.particelle:
 particella.aggiornamento()
Se particella.vita <= 0:
 self.particles.remove (particella)
defdisegno(sé, finestra):
per particella In self.particelle:
 particella.draw (finestra)

Per integrare il sistema di particelle nel tuo gioco, devi apportare alcune modifiche al ciclo di gioco principale. Crea un nuovo file denominato movimento-particelle.py e aggiungi il codice con i seguenti aggiornamenti:

# Crea un sistema di particelle
sistema_particelle = Sistema_particelle()
# Ciclo di gioco principale
correre = VERO
orologio = pygame.time. Orologio()
Mentre corsa:
 dt = orologio.tick(60) / 1000.0
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 correre = Falso
 particella_y = giocatore_y + giocatore_altezza // 2
 particella_x = player_x + player_width
 chiavi = pygame.key.get_pressed()
 confine = player_x < window_width - player_width
Se chiavi[pygame. K_SINISTRA] E giocatore_x > 0:
 giocatore_x -= 5
 sistema_particella.add_particella (particella_x, particella_y)
Se chiavi[pygame. K_DESTRA] E confine:
 giocatore_x += 5
 partition_system.add_particle (player_x, particella_y)
 sistema_particelle.aggiornamento()
 finestra.fill (NERO)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (finestra, BIANCO, player_pos)
 partition_system.draw (finestra)
 pygame.display.flip()
# Esci dal gioco
pygame.quit()

Quando sposti ora l'oggetto giocatore, dovresti vedere delle particelle che enfatizzano il movimento:

Effetto esplosivo

Il prossimo effetto particellare sarà un effetto esplosivo che si verifica quando il giocatore spara un proiettile. L'effetto dell'esplosione consisterà in particelle di colore rosso emesse dalla posizione del proiettile.

Definisci un Particella classe simile alla precedente, ma questa volta include a colore parametro per rappresentare il colore della particella.

Inoltre, aggiorna il file Sistema di particelle class per gestire il nuovo tipo di particella. IL aggiungi_particella() Il metodo ora richiede un ulteriore colore parametro e crea particelle con il colore specificato.

# Classe di particelle
classeParticella:
def__dentro__(self, x, y, colore):
 self.x = x
 self.y = y
 self.dx = random.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 self.lifetime = 30
 self.color = colore
defaggiornamento(se stesso):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defdisegno(sé, finestra):
 posizione = (int (self.x), int (self.y))
 pygame.draw.circle (window, self.color, position, 3)
# Classe del sistema particellare
classeSistema di particelle:
def__dentro__(se stesso):
 self.particelle = []
defadd_particle(self, x, y, colore):
 self.particelle.append (Particella (x, y, colore)
defaggiornamento(se stesso):
per particella In self.particelle:
 particella.aggiornamento()
Se particella.vita <= 0:
 self.particles.remove (particella)
defdisegno(sé, finestra):
per particella In self.particelle:
 particella.draw (finestra)

Per integrare l'effetto esplosione nel tuo gioco, devi apportare alcune modifiche al ciclo di gioco principale. Crea un nuovo nome file sparare-particella.py e aggiungi il codice con i seguenti aggiornamenti:

# Crea un sistema di particelle
sistema_particelle = Sistema_particelle()
# Ciclo di gioco principale
correre = VERO
orologio = pygame.time. Orologio()
Mentre corsa:
 dt = orologio.tick(60) / 1000.0
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 correre = Falso
 chiavi = pygame.key.get_pressed()
 confine = player_x < window_width - player_width
Se chiavi[pygame. K_SINISTRA] E giocatore_x > 0:
 giocatore_x -= 5
Se chiavi[pygame. K_DESTRA] E confine:
 giocatore_x += 5
Se chiavi[pygame. K_SPACE]:
 bullet_x = player_x + player_width // 2
 proiettile_y = giocatore_y
 partition_system.add_particle (proiettile_x, proiettile_y, ROSSO)
 sistema_particelle.aggiornamento()
 finestra.fill (NERO)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (finestra, BIANCO, player_pos)
 partition_system.draw (finestra)
 pygame.display.flip()
# Esci dal gioco
pygame.quit()

Ecco l'output:

Quando la barra spaziatrice ( pygame. K_SPACE) viene premuto, aggiungi una particella al sistema di particelle nella posizione del punto elenco. Questo crea l'effetto esplosione con particelle rosse.

Effetto polvere

Il miglioramento visivo finale che puoi implementare è un effetto di sfondo polveroso. L'effetto polvere consisterà in piccole particelle grigie che si muovono in uno schema circolare, creando uno sfondo dinamico e polveroso.

Aggiorna il Particella classe per includere un angolo E velocità per ogni particella. L'angolo determina la direzione del movimento e la velocità controlla la velocità con cui le particelle si muovono nel loro schema circolare. Modifica il aggiornamento() metodo per aggiornare la posizione di ogni particella in base al suo angolo e alla sua velocità.

Inoltre, aggiorna il file Sistema di particelle class per gestire il nuovo comportamento delle particelle. Le particelle ora si muovono secondo uno schema circolare all'interno della finestra di gioco.

# Classe di particelle
classeParticella:
def__dentro__(sé, x, y, raggio):
 self.x = x
 self.y = y
 self.raggio = raggio
 self.angolo = random.uniform(0, 2 * math.pi)
 self.speed = random.uniform(0.5, 1.5)
defaggiornamento(se stesso):
 self.angolo += 0.02
 self.x += math.cos (self.angolo) * self.speed
 self.y += math.sin (self.angle) * self.speed
Se self.x < 0:
 self.x = window_width
elif self.x > window_width:
 self.x = 0
Se self.y < 0:
 self.y = altezza_finestra
elif self.y > altezza_finestra:
 self.y = 0
defdisegno(sé, finestra):
 colore = (128, 128, 128)
 pos = (int (self.x), int (self.y))
 raggio = int (self.raggio)
 pygame.draw.circle (finestra, colore, pos, raggio)
# Classe del sistema particellare
classeSistema di particelle:
def__dentro__(se stesso):
 self.particelle = []
defadd_particle(sé, x, y, raggio):
 self.particelle.append (Particella (x, y, raggio))
defaggiornamento(se stesso):
per particella In self.particelle:
 particella.aggiornamento()
defdisegno(sé, finestra):
per particella In self.particelle:
 particella.draw (finestra)

Per integrare l'effetto polvere nel tuo gioco, devi apportare alcune modifiche al ciclo di gioco principale. Crea un nuovo file denominato polvere-particella.py e aggiungi il codice con i seguenti aggiornamenti:

# Crea un sistema di particelle per l'effetto polvere
sistema_particelle = Sistema_particelle()
# Ciclo di gioco principale
correre = VERO
orologio = pygame.time. Orologio()
Mentre corsa:
 dt = orologio.tick(60) / 1000.0
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 correre = Falso
 particella_x = random.randint(0, larghezza_finestra)
 particella_y = random.randint(0, altezza_finestra)
 sistema_particella.aggiungi_particella (particella_x, particella_y, 1)
 sistema_particelle.aggiornamento()
 finestra.riempimento((0, 0, 0))
 partition_system.draw (finestra)
 pygame.display.flip()
# Esci dal gioco
pygame.quit()

Aggiungi particelle in modo casuale attraverso la finestra di gioco usando il casuale.randint() funzione. Ogni particella ha un raggio iniziale di 1. Aggiorna e disegna il sistema di particelle sulla finestra di gioco, creando un effetto di sfondo dinamico e polveroso.

Dovresti vedere molte particelle sullo schermo, che si muovono in modo casuale ma fluido:

Le migliori pratiche per gli effetti speciali

Quando aggiungi effetti speciali al tuo gioco Pygame, considera le seguenti best practice:

Ottimizzazione delle prestazioni

I sistemi di particelle possono coinvolgere un gran numero di particelle, che possono influire sulle prestazioni del gioco. Implementa tecniche come il partizionamento spaziale (ad es. Quadtree) per ottimizzare gli aggiornamenti e il disegno delle particelle.

Riciclo delle particelle

Invece di creare e distruggere particelle in ogni fotogramma, prendi in considerazione il riutilizzo delle particelle reimpostando le loro proprietà quando raggiungono la fine della loro vita. Ciò consente di ridurre al minimo l'allocazione e la deallocazione della memoria.

Raggruppamento di particelle

Mantieni un pool di particelle preallocate per evitare il sovraccarico dovuto alla creazione di nuove istanze durante il runtime. Ciò può migliorare le prestazioni e ridurre la frammentazione della memoria.

Limita il conteggio delle particelle

Per impedire ai sistemi di particelle di sovraccaricare la schermata di gioco, imposta dei limiti sul numero massimo di particelle e rimuovi le particelle quando raggiungono questo limite. Ciò garantisce che gli effetti rimangano visivamente accattivanti senza ostacolare il gameplay.

Coerenza visiva

Mantieni uno stile visivo coerente durante il gioco, inclusi gli effetti particellari. Assicurati che i colori, le dimensioni e i modelli di movimento delle particelle siano coerenti con il tema generale e lo stile artistico.

Effetti sonori

Aggiungi effetti sonori per completare i tuoi effetti particellari. Ad esempio, riproduci suoni di esplosione quando si verifica un effetto di esplosione o suoni ambientali quando sono attivi effetti di nebbia o polvere.

Rendi i giochi più divertenti con effetti speciali

L'aggiunta di effetti speciali, come i sistemi di particelle, ai tuoi giochi Pygame può migliorare notevolmente l'esperienza del giocatore e rendere i tuoi giochi più coinvolgenti e divertenti per i giocatori. Implementando effetti particellari come scie, esplosioni, nebbia e polvere, puoi creare ambienti visivamente sbalorditivi e dinamici.

Ricorda di considerare l'ottimizzazione delle prestazioni, il riciclaggio delle particelle e la coerenza visiva mentre incorpori effetti speciali nei tuoi giochi. Con la creatività e la sperimentazione, puoi portare i tuoi giochi Pygame a un livello superiore e affascinare i giocatori con esperienze coinvolgenti ed entusiasmanti.