Läsare som du hjälper till att stödja MUO. När du gör ett köp med hjälp av länkar på vår webbplats kan vi tjäna en affiliate-provision. Läs mer.

Om du är en spelutvecklare som använder Pygame-biblioteket har du förmodligen stött på Sprite-klassen. Sprite-klassen är ett kraftfullt verktyg för att skapa spelkaraktärer som du enkelt kan flytta, rotera och skala på skärmen.

Med ett enkelt Python-program kan du lära dig om processen att skapa sprite-baserade spelkaraktärer i Pygame. Ta reda på hur du skapar en grundläggande Sprite-klass och lägg sedan till attribut och metoder för att kontrollera beteendet.

Introduktion till Pygames Sprite Class

Sprite-klassen i Pygame är en containerklass som innehåller alla attribut och beteenden hos en spelkaraktär. Den härrör från Pygames Surface-klass, som representerar en bild med en fast bredd och höjd.

För att arbeta med det måste du skapa en ny klass som ärver från Sprite-klassen och definiera alla attribut och metoder som du vill att din spelkaraktär ska ha.

instagram viewer

Skapa en Basic Sprite-klass för en spelkaraktär

Först, installera pygame-modulen med pip. Gör det med detta kommando:

pip Installera pygame

För att skapa en grundläggande sprite, måste du importera Sprite-klassen från Pygame och skapa en ny klass som ärver från den. Sedan kan du definiera alla attribut och metoder som du vill att din spelkaraktär ska ha.

Till exempel kanske du vill skapa en Sprite-klass för en spelarkaraktär som kan röra sig åt vänster och höger över skärmen. För att göra detta kan du definiera följande attribut:

  • placera: En tuppel som håller x- och y-koordinaterna för spriten på skärmen.
  • hastighet: En tuppel som håller hastigheten med vilken spriten rör sig horisontellt och vertikalt.

Och följande metoder:

  • uppdatering(): En metod som uppdaterar spritens position baserat på dess hastighet.
  • dra(): En metod som drar spriten till skärmen.

Här är ett exempel på en grundläggande Sprite-klass som implementerar dessa attribut och metoder:

importera pygame
klassSpelare(pygame.sprite. Sprite):
def__i det__(själv, x, y, hastighet_x, hastighet_y):
super().__i det__()
själv.position = (x, y)
själv.velocity = (hastighet_x, hastighet_y)

defuppdatering(själv):
själv.position = (själv.placera[0] + själv.hastighet[0], själv.placera[1] + själv.hastighet[1])

defdra(själv, yta):
pygame.dra.cirkel(yta, (255, 0, 0), själv.placera, 10)

Metoden __init__ är en speciell metod i Python-klasser som körs när du skapar en instans av klassen. Du kan använda den för att initiera attributen för instansen.

I den här koden tar metoden __init__ för klassen Player fyra argument: x, y, hastighet_x och hastighet_y. Dessa argument anger den ursprungliga positionen och hastigheten för spelarens sprite.

Metoden __init__ anropar också metoden super().__init__(), som är metoden __init__ för den överordnade Sprite-klassen. Detta är nödvändigt eftersom Player-klassen är en underklass till Sprite-klassen, och __init__-metoden för Sprite-klassen ställer in några attribut som alla sprites behöver.

Lägga till attribut och metoder för att kontrollera beteende

Nu när du har en grundläggande Sprite-klass kan du lägga till attribut och metoder för att kontrollera din spelkaraktärs beteende. Detta kan inkludera saker som rörelse, attack, hopp och mer.

För att lägga till dessa attribut och metoder måste du tänka på vilka åtgärder du vill ha ditt spel karaktär för att kunna utföra, och definiera motsvarande attribut och metoder i din Sprite klass.

Du kanske till exempel vill lägga till en metod för att styra spritens rörelse, till exempel en move_left()-metod som minskar spritens hastighet på x-axeln.

Här är ett exempel på en modifierad Sprite-klass som inkluderar dessa ytterligare attribut och metoder:

klassSpelare(pygame.sprite. Sprite):
def__i det__(själv, x, y, hastighet_x, hastighet_y):
super().__i det__()
själv.position = (x, y)
själv.velocity = (hastighet_x, hastighet_y)

defuppdatering(själv):
själv.position = (själv.placera[0] + själv.hastighet[0], själv.placera[1] + själv.hastighet[1])

defdra(själv, yta):
pygame.dra.cirkel(yta, (255, 0, 0), själv.placera, 10)

defflytta vänster(själv):
själv.velocity = (-1, själv.hastighet[1])

defflytta höger(själv):
själv.velocity = (1, själv.hastighet[1])

För att använda klassen Player i ditt Pygame-spel måste du skapa en instans av klassen och anropa dess metoder efter behov.

Börja med att skapa ett fönster och en instans av Player sprite:

# Initiera Pygame
pygame.init()
# Ställ in fönsterstorleken
fönsterstorlek = (640, 480)


# Skapa ett fönster
window = pygame.display.set_mode (window_size)
# Skapa en spelarsprite
spelare = Spelare(320, 240, 0, 0)

Definiera sedan en huvudspelslinga som hanterar tangentbordshändelser och uppdateringar och ritar spriten. När du trycker på vänster eller höger piltangenter kommer spriten att röra sig i motsvarande riktning.

# Huvudspelslinga
medanSann:
# Hantera händelser
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 pygame.quit()
 sys.exit()
om event.type == pygame. NYCKEL NER:
om event.key == pygame. K_LEFT:
 player.move_left()
elif event.key == pygame. K_RIGHT:
 player.move_right()

# Uppdatera spelarens sprite
 player.update()

# Rensa fönstret
 window.fill((255, 255, 255))

# Rita spelarens sprite
 player.draw (fönster)

# Uppdatera displayen
 pygame.display.update()

Med det resulterande programmet kommer du att kunna styra spelarens sprite och se den dras till skärmen på olika positioner:

Ladda och visa Sprite-grafik med hjälp av bildmodulen

Nu när du har en grundläggande Sprite-klass med attribut och metoder för att kontrollera beteenden, vill du förmodligen lägga till lite grafik till din sprite. Pygames bildmodul gör det enkelt att ladda och visa bilder på skärmen.

För att ladda en bild måste du använda funktionen pygame.image.load() som tar en filsökväg som ett argument och returnerar ett Surface-objekt. Du kan sedan tilldela detta Surface-objekt till ett sprite-attribut, till exempel self.image, som du kan använda för att rita spriten till skärmen.

Så här kan du till exempel ladda en bild och tilldela den till en sprite:

importera pygame
klassSpelare(pygame.sprite. Sprite):
def__i det__(själv, x, y, hastighet_x, hastighet_y, bildbana):
super().__i det__()
själv.position = (x, y)
själv.velocity = (hastighet_x, hastighet_y)
själv.image = pygame.image.load (bildsökväg)

defuppdatering(själv):
själv.position = (själv.placera[0] + själv.hastighet[0], själv.placera[1] + själv.hastighet[1])

defdra(själv, yta):
yta.blit(själv.bild, själv.placera)
defflytta vänster(själv):
själv.velocity = (-1, själv.hastighet[1])

defflytta höger(själv):
själv.velocity = (1, själv.hastighet[1])

Den här koden definierar en spelarklass som utökar Pygames Sprite-klass och inkluderar attribut för position, hastighet och bild, samt metoder för att uppdatera spritens position, rita spriten till skärmen och kontrollera rörelse.

Du kan kolla in detta GitHub repo för hela koden!

Förbättra Sprite-hanteringen med Sprite-klassen

Sprite-klassen tillhandahåller en bekväm behållare för alla attribut och beteenden hos en spelkaraktär, vilket gör det enkelt att uppdatera, rita och kontrollera spriten på skärmen.

Genom att implementera en Sprite-klass i ditt Pygame-spel kan du förbättra den övergripande upplevelsen för dina spelare och effektivisera utvecklingsprocessen för dig själv.