Implementarea fizicii de bază și detectarea coliziunilor în Pygame

Pygame oferă mai multe funcții încorporate pentru detectarea coliziunilor între obiectele jocului. Acestea sunt de neprețuit, deoarece a determina exact când și cum se suprapun obiectele în mișcare poate fi o sarcină complicată.

Aflați cum să adăugați fizica de bază și coliziuni în joc folosind modulul pygame.

Funcțiile Pygame de detectare a coliziunilor încorporate

Cea mai simplă funcție încorporată de detectare a coliziunilor este spritecollide. Acesta preia un sprite, un grup de sprite și o valoare booleană care indică dacă sprite-urile ar trebui sau nu să „moară” (să fie eliminate) atunci când se ciocnesc. Această funcție returnează o listă de sprite-uri care s-au ciocnit. Iată un exemplu de utilizare:

collided_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, Adevărat)

O altă funcție utilă de detectare a coliziunilor este groupcollide, care preia două grupuri de sprites și o valoare booleană. Această funcție returnează un dicționar cu sprite-urile ciocnite ca taste și sprite-urile cu care s-au ciocnit ca valori. Iată un exemplu de utilizare:

collision_dict = pygame.sprite.groupcollide (grup1, grup2, Adevărat, Adevărat)

Crearea unui joc platformer de bază folosind funcția spritecollide

Pentru a crea un joc platformer de bază folosind Pygame, va trebui să creați un sprite de jucător pe care utilizatorul îl poate controla și un sprite de platformă pe care să stea jucătorul. Puteți folosi funcția spritecollide pentru a detecta când sprite-ul jucătorului se ciocnește de sprite-ul platformei și pentru a împiedica jucătorul să cadă prin platformă.

A începe, instalați modulul pygame folosind pip:

pip install pygame

După care, creați clase simple pentru Player și Platformă, ambele ar trebui să moștenească din clasa Sprite a lui Pygame. Clasa Player ar trebui să aibă o metodă de actualizare pentru a gestiona poziția jucătorului pe baza vitezei. De asemenea, ar trebui să aibă o variabilă y_velocity pentru a aplica efectul gravitației. Clasa Platform ar trebui să aibă o metodă __init__ care preia coordonatele platformei și creează o suprafață cu acea dimensiune.

Clasa de jucători

Puteți crea o clasă Player folosind pygame.sprite. Modulul Sprite. Această clasă va inițializa jucătorul cu coordonatele x și y date. Apoi, metoda de actualizare va actualiza poziția jucătorului prin creșterea valorii y_velocity.

import pygame
clasăJucător(pygame.sprite. Sprite):
def__init__(sine, x, y):
 super().__init__()
 self.image = pygame. Suprafaţă((32, 32))
 self.rect = self.image.get_rect (sus în stânga=(x, y))
 self.y_viteza = 0
defActualizați(de sine):
 self.rect.y += self.y_viteza

Clasa platformei

Clasa Platform folosește și pygame.sprite. Modulul Sprite. Această clasă va inițializa platforma cu coordonatele x și y date, precum și cu o lățime și o înălțime.

clasăPlatformă(pygame.sprite. Sprite):
def__init__(sine, x, y, lățime, înălțime):
 super().__init__()
 self.image = pygame. Suprafață ((lățime, înălțime))
 self.rect = self.image.get_rect (sus în stânga=(x, y))

Bucla jocului

Bucla jocului vă va permite să creați o fereastră cu o dimensiune de 640x480. Apoi, va rula o buclă care va verifica orice evenimente, cum ar fi o comandă de ieșire. De asemenea, va verifica eventualele coliziuni între jucător și platformă. În cele din urmă, va umple ecranul cu o culoare albă, va desena playerul și platforma, apoi va întoarce afișajul.

player = Player(100, 300)
player_group = pygame.sprite. Grup()
player_group.add (player)
platforma = Platforma(50, 400, 100, 20)
platform_group = pygame.sprite. Grup()
platform_group.add (platformă)
# Inițializați pygame și creați o fereastră
pygame.init()
ecran = pygame.display.set_mode((640, 480))
# Bucla principală a jocului
alergare = Adevărat
in timp ce alergare:
pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 alergare = Fals

 player_group.update()
 ciocnit = pygame.sprite.spritecollide (player, platform_group, Fals)
dacă s-a ciocnit:
 player.y_viteza = 0
 screen.fill((255, 255, 255))
 player_group.draw (ecran)
 platform_group.draw (ecran)
 pygame.display.flip()
pygame.quit()

Mai jos este rezultatul:

Implementarea gravitației și a comportamentului de săritură

Pentru a implementa comportamentul gravitației și sărituri în jocul dvs. de platformă, va trebui să adăugați o viteză y la sprite-ul jucătorului și să-i actualizați poziția y în fiecare cadru. Pentru a face acest lucru, puteți utiliza metoda de actualizare în cadrul clasei Player și puteți adăuga următorul fragment de cod:

clasăJucător(pygame.sprite. Sprite):
def__init__(sine, x, y):
 super().__init__()
 self.image = pygame. Suprafaţă((32, 32))
 self.rect = self.image.get_rect (sus în stânga=(x, y))
 self.y_viteza = 0
defActualizați(de sine):
 self.rect.y += self.y_viteza
 self.y_viteza += GRAVITATE # Aplicați gravitația vitezei y

Acum, de fiecare dată când apelați metoda de actualizare, aceasta va actualiza poziția jucătorului în funcție de viteza și gravitatea acestuia.

Pentru a face sprite-ul jucătorului să sară, puteți lega acțiunea de săritură la o anumită tastă sau buton și puteți actualiza viteza y a jucătorului cu o valoare negativă. Următorul fragment de cod este un exemplu despre cum să sari atunci când un jucător apasă pe bara de spațiu.

JUMP_VELOCITY = -10
# în bucla de joc
dacă event.type == pygame. TASTA ÎN JOS și event.key == pygame. K_SPACE:
 player.y_velocity = JUMP_VELOCITY

Rețineți că va trebui să verificați event.type pentru a vă asigura că evenimentul este un eveniment KEYDOWN înainte de a verifica valoarea cheii.

Adăugarea fizicii de bază, cum ar fi frecarea și accelerația

Pentru a adăuga fizica de bază, cum ar fi frecarea și accelerația jocului de platformă, va trebui să actualizați viteza x a sprite-ului jucătorului în fiecare cadru. Puteți adăuga viteza x la clasa jucătorului și o puteți actualiza în același mod ca viteza y. Pentru a implementa frecarea, puteți reduce viteza x a sprite-ului jucătorului cu o cantitate mică în fiecare cadru. De exemplu, puteți adăuga următorul fragment de cod în cadrul metodei de actualizare a clasei Player:

FRICAȚIA = 0.9
clasăJucător(pygame.sprite. Sprite):
def__init__(sine, x, y):
 super().__init__()
 self.image = pygame. Suprafaţă((32, 32))
 self.rect = self.image.get_rect (sus în stânga=(x, y))
 self.y_viteza = 0
 self.x_viteza = 0
defActualizați(de sine):
 self.rect.y += self.y_viteza
 self.rect.x += self.x_viteza
 self.y_viteza += GRAVITATE # Aplicați gravitația vitezei y
 self.x_viteza *= FRICȚIE # Aplicați frecare la viteza x

Pentru a implementa accelerația, puteți seta o variabilă, player_movement, pentru mișcarea orizontală și puteți actualiza viteza x a sprite-ului jucătorului în funcție de valoarea player_movement. Puteți face acest lucru legând mișcarea la anumite taste sau butoane și actualizând viteza x a jucătorului în bucla de eveniment, de exemplu:

ACCELERARE = 0.5
player_movement = 0
dacă event.type == pygame. TASTA ÎN JOS:
dacă event.key == pygame. K_LEFT:
 player_movement = -1
elif event.key == pygame. K_DREPTA:
 player_movement = 1
elif event.type == pygame. TASATĂ:
dacă eveniment.cheie în (pygame. K_LEFT, pygame. K_dreapta):
 player_movement = 0

player.x_velocity += player_movement * ACCELERARE

Folosind aceste tehnici, puteți crea un joc platformer simplu, dar distractiv, folosind funcțiile de detectare a coliziunilor încorporate și fizica de bază ale Pygame. Cu puțină creativitate și experimentare, puteți folosi aceste tehnici pentru a crea o varietate de jocuri și mecanisme de joc diferite.

Puteți găsi codul complet în Depozitul GitHub.

Mai jos este rezultatul:

Îmbunătățiți implicarea utilizatorilor cu coliziunile

Multe jocuri necesită o anumită formă de detectare a coliziunilor. Puteți folosi coliziunile pentru a crea o gamă largă de mecanici de joc, de la simple platforme la simulări complexe bazate pe fizică.

Implementarea fizicii de bază, cum ar fi gravitația, frecarea și accelerația poate, de asemenea, îmbunătăți considerabil implicarea utilizatorului, adăugând realism și un sentiment de greutate obiectelor de joc.