Home-theater-designers
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:
iphone 12 pro sau pro max
collided_sprites = pygame.sprite.spritecollide(sprite1, sprite_group, True)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(group1, group2, True, True)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 pygameDupa aceea, 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 modulul pygame.sprite.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
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
def update(self):
self.rect.y += self.y_velocityClasa platformei
Clasa Platform folosește și modulul pygame.sprite.Sprite. Această clasă va inițializa platforma cu coordonatele x și y date, precum și cu o lățime și o înălțime.
class Platform(pygame.sprite.Sprite):
def __init__(self, x, y, width, height):
super().__init__()
self.image = pygame.Surface((width, height))
self.rect = self.image.get_rect(topleft=(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 eventualele 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.Group()
player_group.add(player)
platform = Platform(50, 400, 100, 20)
platform_group = pygame.sprite.Group()
platform_group.add(platform)
# Initialize pygame and create window
pygame.init()
screen = pygame.display.set_mode((640, 480))
# Main game loop
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
player_group.update()
collided = pygame.sprite.spritecollide(player, platform_group, False)
if collided:
player.y_velocity = 0
screen.fill((255, 255, 255))
player_group.draw(screen)
platform_group.draw(screen)
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 din clasa Player și adăugați următorul fragment de cod:
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
def update(self):
self.rect.y += self.y_velocity
self.y_velocity += GRAVITY # Apply gravity to y velocityAcum, 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
# inside the game loop
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
player.y_velocity = JUMP_VELOCITYReț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:
FRICTION = 0.9
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
self.x_velocity = 0
def update(self):
self.rect.y += self.y_velocity
self.rect.x += self.x_velocity
self.y_velocity += GRAVITY # Apply gravity to y velocity
self.x_velocity *= FRICTION # Apply friction to x velocityPentru 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:
ACCELERATION = 0.5
player_movement = 0
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player_movement = -1
elif event.key == pygame.K_RIGHT:
player_movement = 1
elif event.type == pygame.KEYUP:
if event.key in (pygame.K_LEFT, pygame.K_RIGHT):
player_movement = 0
player.x_velocity += player_movement * ACCELERATIONFolosind 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.