Lesere som deg er med på å støtte MUO. Når du foretar et kjøp ved å bruke lenker på nettstedet vårt, kan vi tjene en tilknyttet provisjon. Les mer.

Pygame har flere innebygde funksjoner for å oppdage kollisjoner mellom spillobjekter. Disse er uvurderlige fordi det kan være en komplisert oppgave å finne ut nøyaktig når og hvordan bevegelige objekter overlapper hverandre.

Lær hvordan du legger til grunnleggende fysikk og kollisjoner i spillet ditt ved å bruke pygame-modulen.

Pygames innebygde kollisjonsdeteksjonsfunksjoner

Den mest grunnleggende innebygde kollisjonsdeteksjonsfunksjonen er spritecollide. Den tar inn en sprite, en gruppe sprites og en boolsk verdi som indikerer om sprites skal "dø" (fjernes) når de kolliderer. Denne funksjonen returnerer en liste over sprites som har kollidert. Her er et eksempel på hvordan du bruker det:

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

En annen nyttig kollisjonsdeteksjonsfunksjon er groupcollide, som tar inn to grupper av sprites og en boolsk verdi også. Denne funksjonen returnerer en ordbok med de kolliderte sprites som tastene og sprites de kolliderte med som verdier. Her er et eksempel på hvordan du bruker det:

instagram viewer 

collision_dict = pygame.sprite.groupcollide (gruppe1, gruppe2, ekte, ekte)

Opprette et grunnleggende plattformspill ved å bruke spritecollide-funksjonen

For å lage et grunnleggende plattformspill med Pygame, må du lage en spillersprite som brukeren kan kontrollere og en plattformsprite som spilleren kan stå på. Du kan bruke spritecollide-funksjonen til å oppdage når spillerens sprite kolliderer med plattformspriten og forhindre at spilleren faller gjennom plattformen.

Å starte, installer pygame-modulen ved å bruke pip:

pip installer pygame

Etter det, lage enkle klasser for spilleren og plattformen, som begge skal arve fra Pygames Sprite-klasse. Spillerklassen bør ha en oppdateringsmetode for å håndtere posisjonen til spilleren basert på hastigheten. Den bør også ha en y_velocity-variabel for å bruke gravitasjonseffekten. Plattformklassen skal ha en __init__-metode som tar koordinatene til plattformen og lager en overflate med den størrelsen.

Spillerklasse

Du kan opprette en spillerklasse ved å bruke pygame.sprite. Sprite-modul. Denne klassen vil initialisere spilleren med en gitt x- og y-koordinater. Deretter vil oppdateringsmetoden oppdatere posisjonen til spilleren ved å øke y_velocity-verdien.

import pygame
klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y):
 super().__init__()
 self.image = pygame. Flate((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
defOppdater(selv):
 self.rect.y += self.y_velocity

Plattformklasse

Plattformklassen bruker også pygame.sprite. Sprite-modul. Denne klassen vil initialisere plattformen med gitte x- og y-koordinater, samt en bredde og høyde.

klassePlattform(pygame.sprite. Sprite):
def__i det__(selv, x, y, bredde, høyde):
 super().__init__()
 self.image = pygame. Overflate ((bredde, høyde))
 self.rect = self.image.get_rect (topleft=(x, y))

Spillsløyfen

Spillløkken lar deg lage et vindu med en størrelse på 640x480. Deretter vil den kjøre en sløyfe som vil se etter eventuelle hendelser, for eksempel en quit-kommando. Den vil også se etter eventuelle kollisjoner mellom spilleren og plattformen. Til slutt vil den fylle skjermen med en hvit farge, tegne spilleren og plattformen, og deretter snu skjermen.

spiller = spiller(100, 300)
player_group = pygame.sprite. Gruppe()
player_group.add (spiller)
plattform = Plattform(50, 400, 100, 20)
platform_group = pygame.sprite. Gruppe()
platform_group.add (plattform)


# Initialiser pygame og lag vindu
pygame.init()
skjerm = pygame.display.set_mode((640, 480))


# Hovedspillsløyfe
kjører = ekte


samtidig som løping:
til begivenhet i pygame.event.get():
hvis event.type == pygame. SLUTTE:
 kjører = Falsk

 player_group.update()
 collided = pygame.sprite.spritecollide (spiller, plattformgruppe, Falsk)


hvis kolliderte:
 player.y_velocity = 0
 screen.fill((255, 255, 255))
 player_group.draw (skjerm)
 platform_group.draw (skjerm)
 pygame.display.flip()
pygame.quit()

Nedenfor er utgangen:

Implementering av tyngdekraft og hoppeatferd

For å implementere gravitasjon og hoppadferd i plattformspillet ditt, må du legge til en y-hastighet til spillerens sprite og oppdatere dens y-posisjon i hver ramme. For å gjøre dette kan du bruke oppdateringsmetoden i Player-klassen og legge til følgende kodebit:

klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y):
 super().__init__()
 self.image = pygame. Flate((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
defOppdater(selv):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVITY # Påfør tyngdekraften på y-hastigheten

Nå hver gang du kaller opp oppdateringsmetoden, vil den oppdatere spillerposisjonen i henhold til hastigheten og tyngdekraften.

For å få spilleren til å hoppe, kan du binde hopphandlingen til en spesifikk tast eller knapp og oppdatere spillerens y-hastighet med en negativ verdi. Følgende kodebit er et eksempel på hvordan man hopper når en spiller trykker på mellomromstasten.

JUMP_VELOCITY = -10
# inne i spillløkken
hvis event.type == pygame. NASTATUR og event.key == pygame. K_SPACE:
 player.y_velocity = JUMP_VELOCITY

Merk at du må sjekke event.type for å sikre at hendelsen er en KEYDOWN-hendelse før du sjekker nøkkelverdien.

Legge til grunnleggende fysikk som friksjon og akselerasjon

For å legge til grunnleggende fysikk som friksjon og akselerasjon til plattformspillet ditt, må du oppdatere x-hastigheten til spillerens sprite i hver ramme. Du kan legge til x hastighet til spillerklassen og oppdatere den på samme måte som y hastighet. For å implementere friksjon kan du redusere x-hastigheten til spillerens sprite med en liten mengde i hver ramme. Du kan for eksempel legge til følgende kodebit i oppdateringsmetoden til Player-klassen:

FRIKSJON = 0.9
klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y):
 super().__init__()
 self.image = pygame. Flate((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
 self.x_velocity = 0
defOppdater(selv):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += GRAVITY # Påfør tyngdekraften på y-hastigheten
 self.x_velocity *= FRIKSJON # Påfør friksjon på x hastighet

For å implementere akselerasjon kan du angi en variabel, player_movement, for den horisontale bevegelsen, og oppdatere x-hastigheten til spillerens sprite i henhold til player_movement-verdien. Du kan gjøre dette ved å binde bevegelsen til bestemte taster eller knapper og oppdatere spillerens x-hastighet i hendelsessløyfen, for eksempel:

AKSELERASJON = 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 event.key i (pygame. K_LEFT, pygame. K_RIGHT):
 player_movement = 0

player.x_velocity += player_movement * AKSELERASJON

Ved å bruke disse teknikkene kan du lage et enkelt, men morsomt plattformspill med Pygames innebygde kollisjonsdeteksjonsfunksjoner og grunnleggende fysikk. Med litt kreativitet og eksperimentering kan du bruke disse teknikkene til å lage en rekke forskjellige spill og spillmekanikk.

Du finner hele koden i GitHub-depot.

Nedenfor er utgangen:

Forbedre brukerengasjementet med kollisjoner

Mange spill krever en form for kollisjonsdeteksjon. Du kan bruke kollisjoner til å lage et bredt spekter av spillmekanikk, fra enkle plattformspillere til komplekse fysikkbaserte simuleringer.

Implementering av grunnleggende fysikk som tyngdekraft, friksjon og akselerasjon kan også i stor grad forbedre brukerengasjementet, legge til realisme og en følelse av vekt til spillobjekter.