Home-theater-designers
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.
kan jeg spille mine ps3 -spil på min ps4
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, True)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(group1, group2, True, True)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 install 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 modulet pygame.sprite.Sprite. 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.
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
Platformklassen bruger også modulet pygame.sprite.Sprite. Denne klasse vil initialisere platformen med givne x- og y-koordinater, samt en bredde og højde.
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))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.
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()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:
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 velocityHver 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
# inside the game loop
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
player.y_velocity = JUMP_VELOCITYBemæ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:
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 velocityFor 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
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 * ACCELERATIONVed 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.
hvordan man får adgang til sim -kort på Android -telefon
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.