Lesere som deg er med på å støtte MUO. Når du foretar et kjøp ved å bruke lenker på nettstedet vårt, kan vi tjene en tilknyttet provisjon. Les mer.

Hvis du er en spillutvikler som bruker Pygame-biblioteket, har du sannsynligvis kommet over Sprite-klassen. Sprite-klassen er et kraftig verktøy for å lage spillkarakterer som du enkelt kan flytte, rotere og skalere på skjermen.

Med et enkelt Python-program kan du lære om prosessen med å lage sprite-baserte spillkarakterer i Pygame. Finn ut hvordan du oppretter en grunnleggende Sprite-klasse, og legg deretter til attributter og metoder for å kontrollere atferd.

Introduksjon til Pygames Sprite-klasse

Sprite-klassen i Pygame er en containerklasse som inneholder alle egenskapene og oppførselen til en spillkarakter. Den stammer fra Pygames Surface-klasse, som representerer et bilde med en fast bredde og høyde.

For å jobbe med det, må du opprette en ny klasse som arver fra Sprite-klassen, og definere eventuelle attributter og metoder som du vil at spillkarakteren din skal ha.

instagram viewer

Opprette en grunnleggende Sprite-klasse for en spillkarakter

Først, installer pygame-modulen ved å bruke pip. Gjør det med denne kommandoen:

pip installere pygame

For å lage en grunnleggende sprite, må du importere Sprite-klassen fra Pygame og lage en ny klasse som arver fra den. Deretter kan du definere hvilke attributter og metoder du vil at spillkarakteren din skal ha.

Det kan for eksempel være lurt å lage en Sprite-klasse for en spillerkarakter som kan bevege seg til venstre og høyre over skjermen. For å gjøre dette kan du definere følgende attributter:

  • posisjon: En tuppel som holder x- og y-koordinatene til spriten på skjermen.
  • hastighet: En tuppel som holder hastigheten som spriten beveger seg horisontalt og vertikalt med.

Og følgende metoder:

  • Oppdater(): En metode som oppdaterer spritens posisjon basert på dens hastighet.
  • tegne(): En metode som trekker spriten til skjermen.

Her er et eksempel på en grunnleggende Sprite-klasse som implementerer disse attributtene og metodene:

import pygame
klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y, hastighet_x, hastighet_y):
super().__i det__()
selv-.posisjon = (x, y)
selv-.velocity = (velocity_x, velocity_y)

defOppdater(selv):
selv-.posisjon = (selv-.posisjon[0] + selv-.hastighet[0], selv-.posisjon[1] + selv-.hastighet[1])

deftegne(selv, overflate):
pygame.tegne.sirkel(flate, (255, 0, 0), selv-.posisjon, 10)

__init__ metoden er en spesiell metode i Python-klasser som kjører når du oppretter en forekomst av klassen. Du kan bruke den til å initialisere attributtene til forekomsten.

I denne koden tar __init__-metoden til Player-klassen fire argumenter: x, y, velocity_x og velocity_y. Disse argumentene setter startposisjonen og hastigheten til spillerens sprite.

__init__-metoden kaller også super().__init__()-metoden, som er __init__-metoden til den overordnede Sprite-klassen. Dette er nødvendig fordi Player-klassen er en underklasse av Sprite-klassen, og __init__-metoden til Sprite-klassen setter opp noen attributter som alle sprites trenger.

Legge til attributter og metoder for å kontrollere atferd

Nå som du har en grunnleggende Sprite-klasse, kan du legge til attributter og metoder for å kontrollere oppførselen til spillkarakteren din. Dette kan inkludere ting som bevegelse, angrep, hopp og mer.

For å legge til disse egenskapene og metodene, må du tenke på hvilke handlinger du vil ha spillet ditt karakter for å kunne utføre, og definere de tilsvarende attributtene og metodene i din Sprite klasse.

For eksempel vil du kanskje legge til en metode for å kontrollere spritens bevegelse, for eksempel en move_left()-metode som reduserer spritens hastighet på x-aksen.

Her er et eksempel på en modifisert Sprite-klasse som inkluderer disse tilleggsattributtene og metodene:

klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y, hastighet_x, hastighet_y):
super().__i det__()
selv-.posisjon = (x, y)
selv-.velocity = (velocity_x, velocity_y)

defOppdater(selv):
selv-.posisjon = (selv-.posisjon[0] + selv-.hastighet[0], selv-.posisjon[1] + selv-.hastighet[1])

deftegne(selv, overflate):
pygame.tegne.sirkel(flate, (255, 0, 0), selv-.posisjon, 10)

defgå til venstre(selv):
selv-.velocity = (-1, selv-.hastighet[1])

defFlytt til høyre(selv):
selv-.velocity = (1, selv-.hastighet[1])

For å bruke Player-klassen i Pygame-spillet ditt, må du opprette en forekomst av klassen og kalle metodene etter behov.

Start med å lage et vindu og en forekomst av Player sprite:

# Initialiser Pygame
pygame.init()
# Still inn vindusstørrelsen
vindu_størrelse = (640, 480)


# Lag et vindu
window = pygame.display.set_mode (window_size)
# Lag en spillersprite
spiller = spiller(320, 240, 0, 0)

Definer deretter en hovedspillløkke som håndterer tastaturhendelser og oppdateringer og tegner spriten. Når du trykker på venstre eller høyre piltast, vil spriten bevege seg i tilsvarende retning.

# Hovedspillsløyfe
samtidig somekte:
# Håndter hendelser
til begivenhet i pygame.event.get():
hvis event.type == pygame. SLUTTE:
 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()

# Oppdater spillerens sprite
 player.update()

# Tøm vinduet
 window.fill((255, 255, 255))

# Tegn spillerens sprite
 player.draw (vindu)

# Oppdater skjermen
 pygame.display.update()

Med det resulterende programmet vil du kunne kontrollere spillerens sprite og se den trekke til skjermen på forskjellige posisjoner:

Laste inn og vise Sprite-grafikk ved hjelp av bildemodulen

Nå som du har en grunnleggende Sprite-klasse med attributter og metoder for å kontrollere atferd, vil du sannsynligvis legge til litt grafikk til din sprite. Pygames bildemodul gjør det enkelt å laste og vise bilder på skjermen.

For å laste et bilde, må du bruke funksjonen pygame.image.load() som tar en filbane som et argument og returnerer et Surface-objekt. Du kan deretter tilordne dette Surface-objektet til en sprite-attributt, for eksempel self.image, som du kan bruke til å tegne spriten til skjermen.

For eksempel, her er hvordan du kan laste et bilde og tilordne det til en sprite:

import pygame
klasseSpiller(pygame.sprite. Sprite):
def__i det__(selv, x, y, hastighet_x, hastighet_y, bildebane):
super().__i det__()
selv-.posisjon = (x, y)
selv-.velocity = (velocity_x, velocity_y)
selv-.image = pygame.image.load (bildebane)

defOppdater(selv):
selv-.posisjon = (selv-.posisjon[0] + selv-.hastighet[0], selv-.posisjon[1] + selv-.hastighet[1])

deftegne(selv, overflate):
flate.blit(selv-.bilde, selv-.posisjon)
defgå til venstre(selv):
selv-.velocity = (-1, selv-.hastighet[1])

defFlytt til høyre(selv):
selv-.velocity = (1, selv-.hastighet[1])

Denne koden definerer en spillerklasse som utvider Pygames Sprite-klasse og inkluderer attributter for posisjon, hastighet og bilde, samt metoder for å oppdatere spritens posisjon, tegne spriten til skjermen og kontrollere bevegelse.

Du kan sjekke ut dette GitHub repo for den komplette koden!

Forbedre Sprite Management med Sprite Class

Sprite-klassen gir en praktisk beholder for alle egenskapene og oppførselen til en spillkarakter, noe som gjør det enkelt å oppdatere, tegne og kontrollere spriten på skjermen.

Ved å implementere en Sprite-klasse i Pygame-spillet ditt kan du forbedre den generelle opplevelsen for spillerne dine og strømlinjeforme utviklingsprosessen for deg selv.