Home-theater-designers
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, True)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(group1, group2, True, True)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 install pygameDaarna, 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 de 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.
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_velocityPlatform klasse
De klasse Platform gebruikt ook de module pygame.sprite.Sprite. Deze klasse initialiseert het platform met gegeven x- en y-coördinaten, evenals een breedte en hoogte.
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))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.
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()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:
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 velocityElke keer dat u de updatemethode aanroept, wordt de positie van de speler bijgewerkt op basis van zijn snelheid en zwaartekracht.
hoe lang duurt een macbook-uitzending?
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
# inside the game loop
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
player.y_velocity = JUMP_VELOCITYMerk 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 platformspel 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:
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 velocityOm 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:
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 * ACCELERATIONDoor 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, door realisme en een gevoel van gewicht toe te voegen aan game-objecten.