Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen. Lees verder.

Als je een game-ontwikkelaar bent die de Pygame-bibliotheek gebruikt, ben je waarschijnlijk de Sprite-klasse tegengekomen. De klasse Sprite is een krachtige tool voor het maken van gamekarakters die je gemakkelijk op het scherm kunt verplaatsen, roteren en schalen.

Met een eenvoudig Python-programma kun je leren over het proces van het maken van sprite-gebaseerde gamekarakters in Pygame. Ontdek hoe u een basisklasse Sprite maakt en vervolgens attributen en methoden toevoegt om gedrag te controleren.

Inleiding tot de Sprite-klasse van Pygame

De Sprite-klasse in Pygame is een containerklasse die alle attributen en gedragingen van een gamekarakter bevat. Het is afgeleid van de Surface-klasse van Pygame, die een afbeelding vertegenwoordigt met een vaste breedte en hoogte.

Om ermee te werken, moet je een nieuwe klasse maken die overerft van de Sprite-klasse, en alle attributen en methoden definiëren die je gamekarakter moet hebben.

instagram viewer

Een basis Sprite-klasse maken voor een gamekarakter

Eerst, installeer de pygame-module met behulp van pip. Doe dit met dit commando:

Pip installeren pyspel

Om een ​​basis-sprite te maken, moet je de Sprite-klasse uit Pygame importeren en een nieuwe klasse maken die ervan overerft. Vervolgens kunt u alle attributen en methoden definiëren die u wilt dat uw spelkarakter heeft.

U wilt bijvoorbeeld een klasse Sprite maken voor een personage van een speler die naar links en rechts over het scherm kan bewegen. Om dit te doen, kunt u de volgende attributen definiëren:

  • positie: Een tuple die de x- en y-coördinaten van de sprite op het scherm bevat.
  • snelheid: Een tuple die de snelheid vasthoudt waarmee de sprite horizontaal en verticaal beweegt.

En de volgende methodes:

  • update(): Een methode die de positie van de sprite bijwerkt op basis van zijn snelheid.
  • tekenen(): Een methode die de sprite naar het scherm trekt.

Hier is een voorbeeld van een standaard Sprite-klasse die deze attributen en methoden implementeert:

importeren pyspel
klasSpeler(pygame.sprite. Sprite):
def__in het__(zelf, x, y, snelheid_x, snelheid_y):
super().__in het__()
zelf.positie = (x, y)
zelf.velocity = (velocity_x, velocity_y)

defupdate(zelf):
zelf.positie = (zelf.positie[0] + zelf.snelheid[0], zelf.positie[1] + zelf.snelheid[1])

deftekenen(zelf, oppervlak):
pyspel.tekenen.cirkel(oppervlak, (255, 0, 0), zelf.positie, 10)

De __init__ methode is een bijzondere methode in Python-klassen die wordt uitgevoerd wanneer u een instantie van de klasse maakt. U kunt het gebruiken om de attributen van de instantie te initialiseren.

In deze code heeft de methode __init__ van de klasse Player vier argumenten nodig: x, y, velocity_x en velocity_y. Deze argumenten bepalen de beginpositie en snelheid van de sprite van de speler.

De methode __init__ roept ook de methode super().__init__() aan, de methode __init__ van de bovenliggende Sprite-klasse. Dit is nodig omdat de klasse Player een subklasse is van de klasse Sprite en de methode __init__ van de klasse Sprite een aantal attributen instelt die alle sprites nodig hebben.

Attributen en methoden toevoegen om gedrag te beheersen

Nu je een basis Sprite-klasse hebt, kun je attributen en methoden toevoegen om het gedrag van je gamekarakter te regelen. Dit kunnen zaken zijn als beweging, aanvallen, springen en meer.

Om deze attributen en methoden toe te voegen, moet je nadenken over welke acties je wilt in je game karakter om te kunnen uitvoeren, en definieer de overeenkomstige attributen en methoden in uw Sprite klas.

U kunt bijvoorbeeld een methode toevoegen om de beweging van de sprite te regelen, zoals een methode move_left() die de snelheid van de sprite op de x-as verlaagt.

Hier is een voorbeeld van een gewijzigde Sprite-klasse die deze extra attributen en methoden bevat:

klasSpeler(pygame.sprite. Sprite):
def__in het__(zelf, x, y, snelheid_x, snelheid_y):
super().__in het__()
zelf.positie = (x, y)
zelf.velocity = (velocity_x, velocity_y)

defupdate(zelf):
zelf.positie = (zelf.positie[0] + zelf.snelheid[0], zelf.positie[1] + zelf.snelheid[1])

deftekenen(zelf, oppervlak):
pyspel.tekenen.cirkel(oppervlak, (255, 0, 0), zelf.positie, 10)

defga naar links(zelf):
zelf.snelheid = (-1, zelf.snelheid[1])

defga naar rechts(zelf):
zelf.snelheid = (1, zelf.snelheid[1])

Om de Player-klasse in uw Pygame-game te gebruiken, moet u een instantie van de klasse maken en de methoden indien nodig aanroepen.

Begin met het maken van een venster en een instantie van de Player-sprite:

# Initialiseer Pygame
pygame.init()
# Stel de venstergrootte in
venstergrootte = (640, 480)


# Maak een venster
venster = pygame.display.set_mode (venstergrootte)
# Maak een sprite voor een speler
speler = speler(320, 240, 0, 0)

Definieer vervolgens een hoofdspellus die toetsenbordgebeurtenissen en -updates afhandelt en de sprite tekent. Wanneer u op de linker of rechter pijltjestoetsen drukt, zal de sprite in de overeenkomstige richting bewegen.

# Hoofdspellus
terwijlWAAR:
# Gebeurtenissen afhandelen
voor evenement in pygame.event.get():
als event.type == pygame. ONTSLAG NEMEN:
 pygame.quit()
 sys.exit()
als event.type == pygame. TOETS NEER:
als event.key == pygame. K_LEFT:
 speler.move_left()
elif event.key == pygame. K_RIGHT:
 speler.move_right()

# Werk de sprite van de speler bij
 speler.update()

# Maak het raam leeg
 venster.vullen((255, 255, 255))

# Teken de sprite van de speler
 player.draw (venster)

# Werk de weergave bij
 pygame.display.update()

Met het resulterende programma kun je de sprite van de speler besturen en observeren hoe hij op verschillende posities naar het scherm trekt:

Sprite-afbeeldingen laden en weergeven met behulp van de afbeeldingsmodule

Nu je een basis Sprite-klasse hebt met attributen en methoden om gedrag te controleren, wil je waarschijnlijk wat afbeeldingen aan je sprite toevoegen. De afbeeldingsmodule van Pygame maakt het gemakkelijk om afbeeldingen op het scherm te laden en weer te geven.

Om een ​​afbeelding te laden, moet u de functie pygame.image.load() gebruiken, die een bestandspad als argument gebruikt en een Surface-object retourneert. U kunt dit Surface-object vervolgens toewijzen aan een sprite-attribuut, zoals self.image, dat u kunt gebruiken om de sprite naar het scherm te tekenen.

Zo kun je bijvoorbeeld een afbeelding laden en toewijzen aan een sprite:

importeren pyspel
klasSpeler(pygame.sprite. Sprite):
def__in het__(zelf, x, y, snelheid_x, snelheid_y, afbeelding_pad):
super().__in het__()
zelf.positie = (x, y)
zelf.velocity = (velocity_x, velocity_y)
zelf.image = pygame.image.load (image_path)

defupdate(zelf):
zelf.positie = (zelf.positie[0] + zelf.snelheid[0], zelf.positie[1] + zelf.snelheid[1])

deftekenen(zelf, oppervlak):
oppervlak.blit(zelf.afbeelding, zelf.positie)
defga naar links(zelf):
zelf.snelheid = (-1, zelf.snelheid[1])

defga naar rechts(zelf):
zelf.snelheid = (1, zelf.snelheid[1])

Deze code definieert een Player-klasse die de Sprite-klasse van Pygame uitbreidt en attributen bevat voor positie, snelheid en afbeelding, evenals methoden om de positie van de sprite bij te werken, de sprite naar het scherm te tekenen en te besturen beweging.

Je kunt dit bekijken GitHub-opslagplaats voor de volledige code!

Verbeter Sprite-beheer met de Sprite-klasse

De klasse Sprite biedt een handige container voor alle attributen en gedragingen van een gamekarakter, waardoor het gemakkelijk is om de sprite op het scherm bij te werken, te tekenen en te besturen.

Door een Sprite-klasse in je Pygame-game te implementeren, kun je de algehele ervaring voor je spelers verbeteren en het ontwikkelingsproces voor jezelf stroomlijnen.