Basisfysica en botsingsdetectie implementeren in Pygame

Pygame biedt verschillende ingebouwde functies voor het detecteren van botsingen tussen spelobjecten. Deze zijn van onschatbare waarde omdat het een gecompliceerde taak kan zijn om precies uit te zoeken wanneer en hoe bewegende objecten elkaar overlappen.

Leer hoe je basisfysica en botsingen in je game kunt toevoegen met behulp van de pygame-module.

Pygame's ingebouwde botsdetectiefuncties

De meest elementaire ingebouwde botsingsdetectiefunctie is spritecollide. Het bevat een sprite, een groep sprites en een booleaanse waarde die aangeeft of de sprites al dan niet moeten "sterven" (verwijderd worden) wanneer ze botsen. Deze functie retourneert een lijst met sprites die zijn gebotst. Hier is een voorbeeld van hoe het te gebruiken:

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

Een andere handige functie voor het detecteren van botsingen is groupcollide, die ook twee groepen sprites en een booleaanse waarde opneemt. Deze functie retourneert een woordenboek met de gebotste sprites als de sleutels en de sprites waarmee ze botsten als de waarden. Hier is een voorbeeld van hoe het te gebruiken:

collision_dict = pygame.sprite.groupcollide (groep1, groep2, WAAR, WAAR)

Een basisplatformgame maken met behulp van de spritecollide-functie

Om een ​​basisplatformgame te maken met Pygame, moet je een speler-sprite maken die de gebruiker kan besturen en een platform-sprite waar de speler op kan staan. Je kunt de spritecollide-functie gebruiken om te detecteren wanneer de speler-sprite botst met de platform-sprite en te voorkomen dat de speler door het platform valt.

Beginnen, installeer de pygame-module met behulp van pip:

pip installeer pygame

Daarna, eenvoudige klassen maken voor de speler en het platform, die beide zouden moeten erven van de Sprite-klasse van Pygame. De Player-klasse moet een updatemethode hebben om de positie van de speler te verwerken op basis van de snelheid. Het moet ook een variabele y_velocity hebben om het zwaartekrachteffect toe te passen. De klasse Platform moet een methode __init__ hebben die de coördinaten van het platform neemt en een oppervlak met die grootte maakt.

Speler klasse

U kunt een Player-klasse maken met behulp van pygame.sprite. Sprite-module. Deze klasse initialiseert de speler met een gegeven x- en y-coördinaat. Vervolgens zal de updatemethode de positie van de speler bijwerken door de waarde y_velocity te verhogen.

importeren pyspel
klasSpeler(pygame.sprite. Sprite):
def__in het__(zelf, x, y):
 super().__init__()
 self.image = pygame. Oppervlak((32, 32))
 self.rect = self.image.get_rect (linksboven=(x, y))
 self.y_velocity = 0
defupdate(zelf):
 self.rect.y += self.y_velocity

Platform klasse

De klasse Platform gebruikt ook de pygame.sprite. Sprite-module. Deze klasse initialiseert het platform met gegeven x- en y-coördinaten, evenals een breedte en hoogte.

klasPlatform(pygame.sprite. Sprite):
def__in het__(zelf, x, y, breedte, hoogte):
 super().__init__()
 self.image = pygame. Oppervlakte((breedte, hoogte))
 self.rect = self.image.get_rect (linksboven=(x, y))

De spellus

Met de spellus kun je een venster maken met een grootte van 640x480. Vervolgens voert het een lus uit die controleert op gebeurtenissen, zoals een stopcommando. Het controleert ook op botsingen tussen de speler en het platform. Ten slotte zal het het scherm vullen met een witte kleur, de speler en het platform tekenen en vervolgens het scherm omdraaien.

speler = speler(100, 300)
player_group = pygame.sprite. Groep()
player_group.add (speler)
perron = perron(50, 400, 100, 20)
platformgroep = pygame.sprite. Groep()
platform_group.add (platform)
# Initialiseer pygame en maak een venster
pygame.init()
scherm = pygame.display.set_mode((640, 480))
# Hoofdspellus
hardlopen = WAAR
terwijl rennen:
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
 hardlopen = Vals

 speler_groep.update()
 botste = pygame.sprite.spritecollide (speler, platformgroep, Vals)
als botste:
 speler.y_velocity = 0
 scherm.vullen((255, 255, 255))
 player_group.draw (scherm)
 platform_group.draw (scherm)
 pygame.display.flip()
pygame.quit()

Hieronder is de uitvoer:

Zwaartekracht en springgedrag implementeren

Om zwaartekracht en springgedrag in je platformgame te implementeren, moet je een y-snelheid toevoegen aan je sprite en de y-positie in elk frame bijwerken. Om dit te doen, kunt u de update-methode in de Player-klasse gebruiken en het volgende codefragment toevoegen:

klasSpeler(pygame.sprite. Sprite):
def__in het__(zelf, x, y):
 super().__init__()
 self.image = pygame. Oppervlak((32, 32))
 self.rect = self.image.get_rect (linksboven=(x, y))
 self.y_velocity = 0
defupdate(zelf):
 self.rect.y += self.y_velocity
 self.y_velocity += ZWAARTEKRACHT # Pas zwaartekracht toe op y snelheid

Elke keer dat u de updatemethode aanroept, wordt de positie van de speler bijgewerkt op basis van zijn snelheid en zwaartekracht.

Om de sprite van de speler te laten springen, kun je de springactie koppelen aan een specifieke toets of knop en de y-snelheid van de speler bijwerken met een negatieve waarde. Het volgende codefragment is een voorbeeld van hoe te springen wanneer een speler op de spatiebalk drukt.

JUMP_VELOCITY = -10
# in de spellus
als event.type == pygame. TOETS NEER En event.key == pygame. K_SPACE:
 speler.y_velocity = JUMP_VELOCITY

Merk op dat u event.type moet controleren om er zeker van te zijn dat de gebeurtenis een KEYDOWN-gebeurtenis is voordat u de sleutelwaarde controleert.

Basisfysica toevoegen, zoals wrijving en versnelling

Om basisfysica zoals wrijving en versnelling aan je platformgame toe te voegen, moet je de x-snelheid van je sprite in elk frame bijwerken. Je kunt x-snelheid toevoegen aan de spelerklasse en deze op dezelfde manier bijwerken als y-snelheid. Om frictie te implementeren, kun je de x-snelheid van de speler-sprite in elk frame met een kleine hoeveelheid verlagen. U kunt bijvoorbeeld het volgende codefragment toevoegen aan de updatemethode van de Player-klasse:

WRIJVING = 0.9
klasSpeler(pygame.sprite. Sprite):
def__in het__(zelf, x, y):
 super().__init__()
 self.image = pygame. Oppervlak((32, 32))
 self.rect = self.image.get_rect (linksboven=(x, y))
 self.y_velocity = 0
 zelf.x_velocity = 0
defupdate(zelf):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += ZWAARTEKRACHT # Pas zwaartekracht toe op y snelheid
 self.x_velocity *= WRIJVING # Pas wrijving toe op x snelheid

Om versnelling te implementeren, kun je een variabele, player_movement, instellen voor de horizontale beweging, en de x-snelheid van de player-sprite bijwerken volgens de player_movement-waarde. U kunt dit doen door de beweging aan specifieke toetsen of knoppen te binden en de x-snelheid van de speler in de gebeurtenislus bij te werken, bijvoorbeeld:

VERSNELLING = 0.5
speler_beweging = 0
als event.type == pygame. TOETS NEER:
als event.key == pygame. K_LEFT:
 speler_beweging = -1
elif event.key == pygame. K_RIGHT:
 speler_beweging = 1
elif event.type == pygame. TOETSEN:
als evenement.sleutel in (pyspel. K_LEFT, pygame. K_RIGHT):
 speler_beweging = 0

player.x_velocity += player_movement * VERSNELLING

Door deze technieken te gebruiken, kun je een eenvoudig maar leuk platformspel maken met behulp van Pygame's ingebouwde botsingsdetectiefuncties en basisfysica. Met een beetje creativiteit en experimenteren kun je deze technieken gebruiken om verschillende spellen en spelmechanismen te creëren.

U vindt de volledige code in de GitHub-opslagplaats.

Hieronder is de uitvoer:

Verbeter gebruikersbetrokkenheid met botsingen

Veel games vereisen een vorm van botsingsdetectie. Je kunt botsingen gebruiken om een ​​breed scala aan spelmechanismen te creëren, van eenvoudige platformgames tot complexe op fysica gebaseerde simulaties.

Het implementeren van basisfysica, zoals zwaartekracht, wrijving en versnelling, kan ook de betrokkenheid van gebruikers aanzienlijk verbeteren, realisme en een gevoel van gewicht toevoegen aan spelobjecten.