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, Sann)
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 (grupp1, grupp2, Sann, Sann)
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:
pip installera pygame
Efter 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 hjälp av pygame.sprite. Sprite-modul. 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.
importera pygame
klassSpelare(pygame.sprite. Sprite):
def__i det__(själv, x, y):
super().__init__()
self.image = pygame. Yta((32, 32))
self.rect = self.image.get_rect (topleft=(x, y))
self.y_velocity = 0
defuppdatering(själv):
self.rect.y += self.y_velocity
Plattformsklass
Platformklassen använder också pygame.sprite. Sprite-modul. Denna klass kommer att initialisera plattformen med givna x- och y-koordinater, samt en bredd och höjd.
klassPlattform(pygame.sprite. Sprite):
def__i det__(själv, x, y, bredd, höjd):
super().__init__()
self.image = pygame. Yta ((bredd, höjd))
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.
spelare = Spelare(100, 300)
player_group = pygame.sprite. Grupp()
player_group.add (spelare)plattform = Plattform(50, 400, 100, 20)
platform_group = pygame.sprite. Grupp()
platform_group.add (plattform)# Initiera pygame och skapa ett fönster
pygame.init()
skärm = pygame.display.set_mode((640, 480))# Huvudspelslinga
springer = Sannmedan löpning:
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
springer = Falsk
player_group.update()
collided = pygame.sprite.spritecollide (spelare, plattformsgrupp, Falsk)om kolliderade:
player.y_velocity = 0
screen.fill((255, 255, 255))
player_group.draw (skärm)
platform_group.draw (skärm)
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:
klassSpelare(pygame.sprite. Sprite):
def__i det__(själv, x, y):
super().__init__()
self.image = pygame. Yta((32, 32))
self.rect = self.image.get_rect (topleft=(x, y))
self.y_velocity = 0
defuppdatering(själv):
self.rect.y += self.y_velocity
self.y_velocity += GRAVITY # Tillämpa gravitation på y hastighet
Nu 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
# inne i spelslingan
om event.type == pygame. NYCKEL NER och event.key == pygame. K_SPACE:
player.y_velocity = JUMP_VELOCITY
Observera 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.
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:
FRIKTION = 0.9
klassSpelare(pygame.sprite. Sprite):
def__i det__(själv, x, y):
super().__init__()
self.image = pygame. Yta((32, 32))
self.rect = self.image.get_rect (topleft=(x, y))
self.y_velocity = 0
self.x_velocity = 0
defuppdatering(själv):
self.rect.y += self.y_velocity
self.rect.x += self.x_velocity
self.y_velocity += GRAVITY # Tillämpa gravitation på y hastighet
self.x_velocity *= FRIKTION # Applicera friktion på x hastighet
Fö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
om event.type == pygame. NYCKEL NER:
om event.key == pygame. K_LEFT:
player_movement = -1
elif event.key == pygame. K_RIGHT:
player_movement = 1
elif event.type == pygame. KEYUP:
om händelse.nyckel i (pygame. K_LEFT, pygame. K_RIGHT):
player_movement = 0
player.x_velocity += player_movement * ACCELERATION
Genom 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ändarnas engagemang, lägga till realism och en känsla av vikt till spelobjekt.