Læsere som dig hjælper med at støtte MUO. Når du foretager et køb ved hjælp af links på vores websted, kan vi optjene en affiliate-kommission. Læs mere.

Hvis du er en spiludvikler, der bruger Pygame-biblioteket, er du sikkert stødt på Sprite-klassen. Sprite-klassen er et kraftfuldt værktøj til at skabe spilfigurer, som du nemt kan flytte, rotere og skalere på skærmen.

Med et simpelt Python-program kan du lære om processen med at skabe sprite-baserede spilfigurer i Pygame. Find ud af, hvordan du opretter en grundlæggende Sprite-klasse, og tilføj derefter attributter og metoder til at kontrollere adfærd.

Introduktion til Pygames Sprite-klasse

Sprite-klassen i Pygame er en containerklasse, der indeholder alle egenskaber og adfærd for en spilkarakter. Det stammer fra Pygames Surface-klasse, som repræsenterer et billede med en fast bredde og højde.

For at arbejde med det, skal du oprette en ny klasse, der arver fra Sprite-klassen, og definere de attributter og metoder, som du ønsker, at din spilfigur skal have.

instagram viewer

Oprettelse af en Basic Sprite-klasse for en spilkarakter

Først, installer pygame-modulet ved hjælp af pip. Gør det med denne kommando:

pip installere pygame

For at oprette en grundlæggende sprite, skal du importere Sprite-klassen fra Pygame og oprette en ny klasse, der arver fra den. Derefter kan du definere alle egenskaber og metoder, som du ønsker, at din spilfigur skal have.

For eksempel vil du måske oprette en Sprite-klasse for en spillerkarakter, der kan bevæge sig til venstre og højre over skærmen. For at gøre dette kan du definere følgende attributter:

  • position: En tupel, der holder x- og y-koordinaterne for spriten på skærmen.
  • hastighed: En tupel, der holder den hastighed, hvormed spriten bevæger sig vandret og lodret.

Og følgende metoder:

  • opdatering(): En metode, der opdaterer spritens position baseret på dens hastighed.
  • tegne(): En metode, der trækker spriten til skærmen.

Her er et eksempel på en grundlæggende Sprite-klasse, der implementerer disse attributter og metoder:

importere pygame
klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y, hastighed_x, hastighed_y):
super().__i det__()
selv.position = (x, y)
selv.velocity = (hastighed_x, hastighed_y)

defopdatering(selv):
selv.position = (selv.position[0] + selv.hastighed[0], selv.position[1] + selv.hastighed[1])

deftegne(selv, overflade):
pygame.tegne.cirkel(overflade, (255, 0, 0), selv.position, 10)

__init__ metoden er en speciel metode i Python-klasser der kører, når du opretter en forekomst af klassen. Du kan bruge den til at initialisere forekomstens attributter.

I denne kode tager __init__-metoden i Player-klassen fire argumenter: x, y, velocity_x og velocity_y. Disse argumenter sætter startpositionen og hastigheden af ​​spillerens sprite.

__init__ metoden kalder også super().__init__() metoden, som er __init__ metoden for den overordnede Sprite klasse. Dette er nødvendigt, fordi Player-klassen er en underklasse af Sprite-klassen, og __init__-metoden i Sprite-klassen opsætter nogle attributter, som alle sprites har brug for.

Tilføjelse af attributter og metoder til kontrol af adfærd

Nu hvor du har en grundlæggende Sprite-klasse, kan du tilføje attributter og metoder til at kontrollere din spilfigurs adfærd. Dette kan omfatte ting som bevægelse, angreb, hop og mere.

For at tilføje disse attributter og metoder skal du tænke over, hvilke handlinger du vil have dit spil karakter for at kunne udføre, og definere de tilsvarende attributter og metoder i din Sprite klasse.

For eksempel vil du måske tilføje en metode til at styre spritens bevægelse, såsom en move_left()-metode, der reducerer spritens hastighed på x-aksen.

Her er et eksempel på en modificeret Sprite-klasse, der inkluderer disse yderligere attributter og metoder:

klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y, hastighed_x, hastighed_y):
super().__i det__()
selv.position = (x, y)
selv.velocity = (hastighed_x, hastighed_y)

defopdatering(selv):
selv.position = (selv.position[0] + selv.hastighed[0], selv.position[1] + selv.hastighed[1])

deftegne(selv, overflade):
pygame.tegne.cirkel(overflade, (255, 0, 0), selv.position, 10)

defbevæg dig til venstre(selv):
selv.velocity = (-1, selv.hastighed[1])

defmove_right(selv):
selv.velocity = (1, selv.hastighed[1])

For at bruge Player-klassen i dit Pygame-spil, skal du oprette en forekomst af klassen og kalde dens metoder efter behov.

Start med at oprette et vindue og en forekomst af Player sprite:

# Initialiser Pygame
pygame.init()
# Indstil vinduesstørrelsen
vinduesstørrelse = (640, 480)


# Opret et vindue
vindue = pygame.display.set_mode (window_size)
# Opret en spillersprite
spiller = spiller(320, 240, 0, 0)

Definer derefter en hovedspilsløjfe, der håndterer tastaturbegivenheder og opdateringer og tegner spriten. Når du trykker på venstre eller højre piletast, vil spriten bevæge sig i den tilsvarende retning.

# Hovedspilsløjfe
mensRigtigt:
# Håndter begivenheder
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 pygame.quit()
 sys.exit()
hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_LEFT:
 player.move_left()
elif event.key == pygame. K_RIGHT:
 player.move_right()

# Opdater afspillerens sprite
 player.update()

# Ryd vinduet
 window.fill((255, 255, 255))

# Tegn spillerens sprite
 player.draw (vindue)

# Opdater displayet
 pygame.display.update()

Med det resulterende program vil du være i stand til at styre spillerens sprite og se den trække til skærmen på forskellige positioner:

Indlæsning og visning af Sprite-grafik ved hjælp af billedmodulet

Nu hvor du har en grundlæggende Sprite-klasse med attributter og metoder til at kontrollere adfærd, vil du sikkert gerne tilføje noget grafik til din sprite. Pygames billedmodul gør det nemt at indlæse og vise billeder på skærmen.

For at indlæse et billede skal du bruge funktionen pygame.image.load(), som tager en filsti som et argument og returnerer et Surface-objekt. Du kan derefter tildele dette Surface-objekt til en sprite-attribut, såsom self.image, som du kan bruge til at tegne spriten til skærmen.

Sådan kan du f.eks. indlæse et billede og tildele det til en sprite:

importere pygame
klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y, hastighed_x, hastighed_y, billedsti):
super().__i det__()
selv.position = (x, y)
selv.velocity = (hastighed_x, hastighed_y)
selv.image = pygame.image.load (image_path)

defopdatering(selv):
selv.position = (selv.position[0] + selv.hastighed[0], selv.position[1] + selv.hastighed[1])

deftegne(selv, overflade):
overflade.blit(selv.billede, selv.position)
defbevæg dig til venstre(selv):
selv.velocity = (-1, selv.hastighed[1])

defmove_right(selv):
selv.velocity = (1, selv.hastighed[1])

Denne kode definerer en spillerklasse, der udvider Pygames Sprite-klasse og inkluderer attributter for position, hastighed og billede, samt metoder til at opdatere spritens position, tegne spriten til skærmen og kontrollere bevægelse.

Du kan tjekke dette ud GitHub repo for den komplette kode!

Forbedre Sprite-styringen med Sprite-klassen

Sprite-klassen giver en praktisk beholder til alle egenskaber og adfærd for en spilkarakter, hvilket gør det nemt at opdatere, tegne og styre spriten på skærmen.

Ved at implementere en Sprite-klasse i dit Pygame-spil kan du forbedre den samlede oplevelse for dine spillere og strømline udviklingsprocessen for dig selv.