Pygame har flere indbyggede funktioner til at detektere kollisioner mellem spilobjekter. Disse er uvurderlige, fordi det kan være en kompliceret opgave at finde ud af præcis, hvornår og hvordan bevægelige objekter overlapper hinanden.
Lær, hvordan du tilføjer grundlæggende fysik og kollisioner i dit spil ved hjælp af pygame-modulet.
Pygames indbyggede kollisionsdetektionsfunktioner
Den mest grundlæggende indbyggede kollisionsdetektionsfunktion er spritecollide. Det tager en sprite, en gruppe af sprites og en boolesk værdi, der angiver, om sprites skal "dø" (fjernes), når de kolliderer. Denne funktion returnerer en liste over sprites, der er stødt sammen. Her er et eksempel på, hvordan du bruger det:
collided_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, Rigtigt)En anden nyttig kollisionsdetektionsfunktion er groupcollide, som også optager to grupper af sprites og en boolsk værdi. Denne funktion returnerer en ordbog med de kolliderede sprites som taster og sprites de kolliderede med som værdier. Her er et eksempel på, hvordan du bruger det:
collision_dict = pygame.sprite.groupcollide (gruppe1, gruppe2, Rigtigt, Rigtigt)Oprettelse af et grundlæggende platformspil ved hjælp af spritecollide-funktionen
For at oprette et grundlæggende platformspil ved hjælp af Pygame, skal du oprette en spillersprite, som brugeren kan kontrollere, og en platformsprite, som spilleren kan stå på. Du kan bruge spritecollide-funktionen til at registrere, hvornår spillerens sprite kolliderer med platformspriten og forhindre spilleren i at falde gennem platformen.
At begynde, installer pygame-modulet ved hjælp af pip:
pip installer pygameEfter det, lave simple klasser for spilleren og platformen, som begge skulle arve fra Pygames Sprite-klasse. Spillerklassen skal have en opdateringsmetode til at håndtere spillerens position baseret på hastigheden. Den skal også have en y_velocity-variabel for at anvende tyngdekraftseffekten. Platform-klassen skal have en __init__-metode, der tager platformens koordinater og skaber en overflade med den størrelse.
Spillerklasse
Du kan oprette en spillerklasse ved hjælp af pygame.sprite. Sprite modul. Denne klasse vil initialisere spilleren med en given x- og y-koordinater. Derefter vil opdateringsmetoden opdatere spillerens position ved at øge y_velocity-værdien.
importere pygameklasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y):
super().__init__()
self.image = pygame. Overflade((32, 32))
self.rect = self.image.get_rect (topleft=(x, y))
self.y_velocity = 0
defopdatering(selv):
self.rect.y += self.y_velocity
Platform klasse
Platform-klassen bruger også pygame.sprite. Sprite modul. Denne klasse vil initialisere platformen med givne x- og y-koordinater, samt en bredde og højde.
klassePlatform(pygame.sprite. Sprite):
def__i det__(selv, x, y, bredde, højde):
super().__init__()
self.image = pygame. Overflade ((bredde, højde))
self.rect = self.image.get_rect (topleft=(x, y))The Game Loop
Spilløkken giver dig mulighed for at oprette et vindue med en størrelse på 640x480. Derefter vil den køre en løkke, der kontrollerer for eventuelle hændelser, såsom en quit-kommando. Den vil også tjekke for eventuelle kollisioner mellem spilleren og platformen. Til sidst vil den fylde skærmen med en hvid farve, tegne afspilleren og platformen og derefter vende skærmen.
spiller = spiller(100, 300)
player_group = pygame.sprite. Gruppe()
player_group.add (spiller)platform = platform(50, 400, 100, 20)
platform_group = pygame.sprite. Gruppe()
platform_group.add (platform)# Initialiser pygame og opret vindue
pygame.init()
skærm = pygame.display.set_mode((640, 480))# Hovedspilsløjfe
kører = Rigtigtmens kører:
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
kører = Falsk
player_group.update()
collided = pygame.sprite.spritecollide (player, platform_group, Falsk)hvis kolliderede:
player.y_velocity = 0
screen.fill((255, 255, 255))
player_group.draw (skærm)
platform_group.draw (skærm)
pygame.display.flip()
pygame.quit()
Nedenfor er output:
Implementering af tyngdekraft og springadfærd
For at implementere tyngdekraft og springadfærd i dit platformspil, skal du tilføje en y-hastighed til din spillersprite og opdatere dens y-position i hver frame. For at gøre dette kan du bruge opdateringsmetoden inde i Player-klassen og tilføje følgende kodestykke:
klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y):
super().__init__()
self.image = pygame. Overflade((32, 32))
self.rect = self.image.get_rect (topleft=(x, y))
self.y_velocity = 0
defopdatering(selv):
self.rect.y += self.y_velocity
self.y_velocity += GRAVITY # Anvend tyngdekraften til y-hastigheden
Hver gang du kalder opdateringsmetoden, opdaterer den spillerens position i henhold til dens hastighed og tyngdekraft.
For at få spillerens sprite til at hoppe, kan du binde springhandlingen til en bestemt tast eller knap og opdatere spillerens y-hastighed med en negativ værdi. Følgende kodestykke er et eksempel på, hvordan man hopper, når en spiller trykker på mellemrumstasten.
JUMP_VELOCITY = -10
# inde i spilløkken
hvis event.type == pygame. NASTATUR og event.key == pygame. K_SPACE:
player.y_velocity = JUMP_VELOCITY
Bemærk, at du skal kontrollere event.type for at sikre, at begivenheden er en KEYDOWN-begivenhed, før du tjekker nøgleværdien.
Tilføjelse af grundlæggende fysik såsom friktion og acceleration
For at tilføje grundlæggende fysik såsom friktion og acceleration til dit platformspil, skal du opdatere x-hastigheden af din spillersprite i hver frame. Du kan tilføje x hastighed til spillerklassen og opdatere den på samme måde som y hastighed. For at implementere friktion kan du mindske x-hastigheden af afspillerens sprite med en lille mængde i hver frame. For eksempel kan du tilføje følgende kodestykke inde i opdateringsmetoden for Player-klassen:
FRIKTION = 0.9klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y):
super().__init__()
self.image = pygame. Overflade((32, 32))
self.rect = self.image.get_rect (topleft=(x, y))
self.y_velocity = 0
self.x_velocity = 0
defopdatering(selv):
self.rect.y += self.y_velocity
self.rect.x += self.x_velocity
self.y_velocity += GRAVITY # Anvend tyngdekraften til y-hastigheden
self.x_velocity *= FRIKTION # Påfør friktion til x hastighed
For at implementere acceleration kan du indstille en variabel, player_movement, for den horisontale bevægelse og opdatere x-hastigheden af player-sprite i henhold til player_movement-værdien. Du kan gøre dette ved at binde bevægelsen til bestemte taster eller knapper og opdatere afspillerens x-hastighed i begivenhedsløkken, for eksempel:
ACCELERATION = 0.5
player_movement = 0
hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_LEFT:
player_movement = -1
elif event.key == pygame. K_RIGHT:
player_movement = 1
elif event.type == pygame. KEYUP:
hvis begivenhed.nøgle i (pygame. K_LEFT, pygame. K_RIGHT):
player_movement = 0
player.x_velocity += player_movement * ACCELERATION
Ved at bruge disse teknikker kan du skabe et simpelt, men sjovt platformspil ved hjælp af Pygames indbyggede kollisionsdetektionsfunktioner og grundlæggende fysik. Med en lille smule kreativitet og eksperimentering kan du bruge disse teknikker til at skabe en række forskellige spil og spilmekanikker.
Du kan finde den komplette kode i GitHub-depot.
Nedenfor er output:
Forbedre brugerengagementet med kollisioner
Mange spil kræver en form for kollisionsdetektion. Du kan bruge kollisioner til at skabe en bred vifte af spilmekanik, fra simple platformspil til komplekse fysikbaserede simuleringer.
Implementering af grundlæggende fysik såsom tyngdekraft, friktion og acceleration kan også i høj grad forbedre brugerengagementet, tilføje realisme og en følelse af vægt til spilobjekter.
