Home-theater-designers
Pygame har flera inbyggda funktioner för att upptäcka kollisioner mellan spelobjekt. Dessa är ovärderliga eftersom det kan vara en komplicerad uppgift att ta reda på exakt när och hur rörliga objekt överlappar varandra.
Lär dig hur du lägger till grundläggande fysik och kollisioner i ditt spel med hjälp av pygame-modulen.
Pygames inbyggda kollisionsdetektionsfunktioner
Den mest grundläggande inbyggda kollisionsdetekteringsfunktionen är spritecollide. Den tar in en sprite, en grupp sprites och ett booleskt värde som indikerar om sprites ska 'dö' (tas bort) när de kolliderar. Denna funktion returnerar en lista över sprites som har kolliderat. Här är ett exempel på hur man använder det:
collided_sprites = pygame.sprite.spritecollide(sprite1, sprite_group, True)En annan användbar kollisionsdetekteringsfunktion är groupcollide, som tar in två grupper av sprites och ett booleskt värde också. Den här funktionen returnerar en ordlista med de kolliderade sprites som nycklar och sprites de kolliderade med som värden. Här är ett exempel på hur du använder det:
collision_dict = pygame.sprite.groupcollide(group1, group2, True, True)Skapa ett grundläggande plattformsspel med spritecollide-funktionen
För att skapa ett grundläggande plattformsspel med Pygame måste du skapa en spelarsprite som användaren kan kontrollera och en plattformssprite som spelaren kan stå på. Du kan använda spritecollide-funktionen för att upptäcka när spelarens sprite kolliderar med plattformsspriten och förhindra att spelaren faller genom plattformen.
Att börja, installera pygame-modulen med pip :
hur hittar jag mitt hus historia
pip install pygameEfter det, skapa enkla klasser för spelaren och plattformen, som båda borde ärva från Pygames Sprite-klass. Spelarklassen bör ha en uppdateringsmetod för att hantera spelarens position baserat på hastigheten. Den bör också ha en variabel y_velocity för att tillämpa gravitationseffekten. Platformklassen ska ha en __init__-metod som tar plattformens koordinater och skapar en yta med den storleken.
Spelarklass
Du kan skapa en spelarklass med modulen pygame.sprite.Sprite. Denna klass kommer att initialisera spelaren med en given x- och y-koordinater. Sedan kommer uppdateringsmetoden att uppdatera spelarens position genom att öka värdet y_velocity.
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_velocityPlattformsklass
Platformklassen använder också modulen pygame.sprite.Sprite. Denna klass kommer att initialisera plattformen med givna x- och y-koordinater, samt en bredd och höjd.
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))Spelslingan
Spelslingan låter dig skapa ett fönster med storleken 640x480. Sedan kommer den att köra en slinga som kontrollerar eventuella händelser, till exempel ett quit-kommando. Den kommer också att kontrollera om det finns kollisioner mellan spelaren och plattformen. Slutligen kommer den att fylla skärmen med en vit färg, rita spelaren och plattformen och sedan vända 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()Nedan är utgången:
Implementering av gravitation och hoppbeteende
För att implementera gravitation och hoppbeteende i ditt plattformsspel måste du lägga till en y-hastighet till din spelarsprite och uppdatera dess y-position i varje bildruta. För att göra detta kan du använda uppdateringsmetoden i klassen Player och lägga till följande kodavsnitt:
vad ska man göra på en dator när man har tråkigt
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 velocityNu varje gång du anropar uppdateringsmetoden kommer den att uppdatera spelarens position enligt dess hastighet och gravitation.
För att få spelarens sprite att hoppa kan du binda hoppåtgärden till en specifik tangent eller knapp och uppdatera spelarens y-hastighet med ett negativt värde. Följande kodsnutt är ett exempel på hur man hoppar när en spelare trycker på mellanslagstangenten.
JUMP_VELOCITY = -10
# inside the game loop
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
player.y_velocity = JUMP_VELOCITYObservera att du måste kontrollera event.type för att säkerställa att händelsen är en KEYDOWN-händelse innan du kontrollerar nyckelvärdet.
disney plus hjälpcenter fel 83
Lägga till grundläggande fysik som friktion och acceleration
För att lägga till grundläggande fysik som friktion och acceleration till ditt plattformsspel måste du uppdatera x-hastigheten för din spelarsprite i varje bildruta. Du kan lägga till x hastighet till spelarklassen och uppdatera den på samma sätt som y hastighet. För att implementera friktion kan du minska x-hastigheten för spelarens sprite med en liten mängd i varje bildruta. Du kan till exempel lägga till följande kodavsnitt i uppdateringsmetoden för klassen Player:
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 velocityFör att implementera acceleration kan du ställa in en variabel, player_movement, för den horisontella rörelsen, och uppdatera x-hastigheten för spelarens sprite enligt player_movement-värdet. Du kan göra detta genom att binda rörelsen till specifika tangenter eller knappar och uppdatera spelarens x-hastighet i händelseloopen, till exempel:
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 * ACCELERATIONGenom att använda dessa tekniker kan du skapa ett enkelt men roligt plattformsspel med Pygames inbyggda kollisionsdetekteringsfunktioner och grundläggande fysik. Med lite kreativitet och experimenterande kan du använda dessa tekniker för att skapa en mängd olika spel och spelmekaniker.
Du hittar hela koden i GitHub-förråd .
Nedan är utgången:
Förbättra användarengagemang med kollisioner
Många spel kräver någon form av kollisionsdetektering. Du kan använda kollisioner för att skapa ett brett utbud av spelmekanik, från enkla plattformsspel till komplexa fysikbaserade simuleringar.
Att implementera grundläggande fysik som gravitation, friktion och acceleration kan också avsevärt förbättra användarens engagemang, lägga till realism och en känsla av vikt till spelobjekt.