Implementazione della fisica di base e del rilevamento delle collisioni in Pygame

Pygame fornisce diverse funzioni integrate per rilevare collisioni tra oggetti di gioco. Questi sono inestimabili perché capire esattamente quando e come gli oggetti in movimento si sovrappongono può essere un compito complicato.

Scopri come aggiungere la fisica di base e le collisioni nel tuo gioco usando il modulo pygame.

Funzioni integrate di rilevamento delle collisioni di Pygame

La funzione di rilevamento delle collisioni incorporata più basilare è spritecollide. Comprende uno sprite, un gruppo di sprite e un valore booleano che indica se gli sprite devono o meno "morire" (essere rimossi) quando entrano in collisione. Questa funzione restituisce un elenco di sprite che si sono scontrati. Ecco un esempio di come usarlo:

collided_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, VERO)

Un'altra utile funzione di rilevamento delle collisioni è groupcollide, che accetta anche due gruppi di sprite e un valore booleano. Questa funzione restituisce un dizionario con gli sprite in collisione come chiavi e gli sprite con cui si sono scontrati come valori. Ecco un esempio di come usarlo:

collision_dict = pygame.sprite.groupcollide (gruppo1, gruppo2, VERO, VERO)

Creazione di un gioco platform di base utilizzando la funzione spritecolline

Per creare un gioco platform di base utilizzando Pygame, dovrai creare uno sprite del giocatore che l'utente possa controllare e uno sprite della piattaforma su cui il giocatore possa stare in piedi. Puoi utilizzare la funzione spritecollide per rilevare quando lo sprite del giocatore si scontra con lo sprite della piattaforma e impedire al giocatore di cadere attraverso la piattaforma.

Iniziare, installa il modulo pygame usando pip:

pip installa pygame

Dopo di che, creare classi semplici per Player e Platform, entrambi ereditati dalla classe Sprite di Pygame. La classe Player dovrebbe avere un metodo di aggiornamento per gestire la posizione del giocatore in base alla velocità. Inoltre, dovrebbe avere una variabile y_velocity per applicare l'effetto gravità. La classe Platform dovrebbe avere un metodo __init__ che prende le coordinate della piattaforma e crea una superficie con quella dimensione.

Classe giocatore

Puoi creare una classe Player usando pygame.sprite. Modulo Sprite. Questa classe inizializzerà il giocatore con una data coordinata x e y. Quindi, il metodo di aggiornamento aggiornerà la posizione del giocatore incrementando il valore y_velocity.

importare pygame
classeGiocatore(pygame.sprite. Folletto):
def__dentro__(sé, x, y):
 super().__init__()
 self.image = pygame. Superficie((32, 32))
 self.rect = self.image.get_rect (in alto a sinistra=(x, y))
 self.y_velocity = 0
defaggiornamento(se stesso):
 self.rect.y += self.y_velocity

Classe piattaforma

Anche la classe Platform utilizza pygame.sprite. Modulo Sprite. Questa classe inizializzerà la piattaforma con le coordinate x e y fornite, nonché una larghezza e un'altezza.

classepiattaforma(pygame.sprite. Folletto):
def__dentro__(self, x, y, larghezza, altezza):
 super().__init__()
 self.image = pygame. Superficie((larghezza, altezza))
 self.rect = self.image.get_rect (in alto a sinistra=(x, y))

Il ciclo di gioco

Il ciclo di gioco ti consentirà di creare una finestra con una dimensione di 640x480. Quindi, eseguirà un ciclo che verificherà eventuali eventi, come un comando quit. Verificherà anche eventuali collisioni tra il giocatore e la piattaforma. Infine, riempirà lo schermo con un colore bianco, disegnerà il giocatore e la piattaforma, quindi capovolgerà il display.

giocatore = Giocatore(100, 300)
player_group = pygame.sprite. Gruppo()
player_group.add (giocatore)
piattaforma = Piattaforma(50, 400, 100, 20)
platform_group = pygame.sprite. Gruppo()
platform_group.add (piattaforma)
# Inizializza pygame e crea una finestra
pygame.init()
schermo = pygame.display.set_mode((640, 480))
# Ciclo di gioco principale
correre = VERO
Mentre corsa:
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 correre = Falso

 giocatore_gruppo.aggiornamento()
 collided = pygame.sprite.spritecollide (player, platform_group, Falso)
Se scontrato:
 player.y_velocity = 0
 schermo.riempimento((255, 255, 255))
 player_group.draw (schermo)
 platform_group.draw (schermo)
 pygame.display.flip()
pygame.quit()

Di seguito è riportato l'output:

Implementazione della gravità e del comportamento di salto

Per implementare la gravità e il comportamento di salto nel tuo gioco platform, dovrai aggiungere una velocità y allo sprite del tuo giocatore e aggiornare la sua posizione y in ogni fotogramma. Per fare ciò puoi utilizzare il metodo update all'interno della classe Player e aggiungere il seguente snippet di codice:

classeGiocatore(pygame.sprite. Folletto):
def__dentro__(sé, x, y):
 super().__init__()
 self.image = pygame. Superficie((32, 32))
 self.rect = self.image.get_rect (in alto a sinistra=(x, y))
 self.y_velocity = 0
defaggiornamento(se stesso):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVITA' # Applica la gravità alla velocità y

Ora ogni volta che chiami il metodo di aggiornamento, aggiornerà la posizione del giocatore in base alla sua velocità e gravità.

Per far saltare lo sprite del giocatore, puoi associare l'azione di salto a un tasto o pulsante specifico e aggiornare la velocità y del giocatore con un valore negativo. Il seguente frammento di codice è un esempio di come saltare quando un giocatore preme la barra spaziatrice.

JUMP_VELOCITÀ = -10
# all'interno del ciclo di gioco
Se event.type == pygame. KEYDOWN E event.key == pygame. K_SPACE:
 player.y_velocity = JUMP_VELOCITY

Nota che dovrai controllare event.type per assicurarti che l'evento sia un evento KEYDOWN prima di controllare il valore della chiave.

Aggiunta di fisica di base come attrito e accelerazione

Per aggiungere fisica di base come l'attrito e l'accelerazione al tuo gioco platform, dovrai aggiornare la velocità x dello sprite del tuo giocatore in ogni fotogramma. Puoi aggiungere la velocità x alla classe del giocatore e aggiornarla allo stesso modo della velocità y. Per implementare l'attrito, puoi diminuire la velocità x dello sprite del giocatore di una piccola quantità in ogni fotogramma. Ad esempio, puoi aggiungere il seguente frammento di codice all'interno del metodo update della classe Player:

ATTRITO = 0.9
classeGiocatore(pygame.sprite. Folletto):
def__dentro__(sé, x, y):
 super().__init__()
 self.image = pygame. Superficie((32, 32))
 self.rect = self.image.get_rect (in alto a sinistra=(x, y))
 self.y_velocity = 0
 self.x_velocità = 0
defaggiornamento(se stesso):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += GRAVITA' # Applica la gravità alla velocità y
 self.x_velocity *= ATTRITO # Applicare l'attrito alla velocità x

Per implementare l'accelerazione, puoi impostare una variabile, player_movement, per il movimento orizzontale, e aggiornare la velocità x dello sprite del giocatore in base al valore player_movement. Puoi farlo associando il movimento a tasti o pulsanti specifici e aggiornando la velocità x del giocatore nel ciclo degli eventi, ad esempio:

ACCELERAZIONE = 0.5
giocatore_movimento = 0
Se event.type == pygame. TASTO GIÙ:
Se event.key == pygame. K_SINISTRA:
 giocatore_movimento = -1
elif event.key == pygame. K_DESTRA:
 giocatore_movimento = 1
elif event.type == pygame. TASTO:
Se evento.chiave In (pygame. K_LEFT, pygame. K_DESTRA):
 giocatore_movimento = 0

player.x_velocity += player_movement * ACCELERAZIONE

Utilizzando queste tecniche, puoi creare un gioco platform semplice ma divertente utilizzando le funzioni di rilevamento delle collisioni integrate di Pygame e la fisica di base. Con un po' di creatività e sperimentazione, puoi utilizzare queste tecniche per creare una varietà di giochi e meccaniche di gioco differenti.

Puoi trovare il codice completo nel file Deposito GitHub.

Di seguito è riportato l'output:

Migliora il coinvolgimento degli utenti con le collisioni

Molti giochi richiedono una qualche forma di rilevamento delle collisioni. Puoi utilizzare le collisioni per creare un'ampia gamma di meccaniche di gioco, da semplici platform a complesse simulazioni basate sulla fisica.

L'implementazione della fisica di base come la gravità, l'attrito e l'accelerazione può anche migliorare notevolmente il coinvolgimento dell'utente, aggiungendo realismo e un senso di peso agli oggetti di gioco.