Cititorii ca tine ajută la sprijinirea MUO. Când efectuați o achiziție folosind link-uri de pe site-ul nostru, este posibil să câștigăm un comision de afiliat. Citeşte mai mult.

Dacă sunteți un dezvoltator de jocuri care utilizează biblioteca Pygame, probabil că ați întâlnit clasa Sprite. Clasa Sprite este un instrument puternic pentru a crea personaje de joc pe care le puteți muta, roti și scala cu ușurință pe ecran.

Cu un program simplu Python, puteți afla despre procesul de creare a personajelor de joc bazate pe sprite în Pygame. Aflați cum să creați o clasă de bază Sprite, apoi adăugați atribute și metode pentru a controla comportamentul.

Introducere în clasa Sprite de la Pygame

Clasa Sprite din Pygame este o clasă container care deține toate atributele și comportamentele unui personaj de joc. Derivă din clasa Surface a lui Pygame, care reprezintă o imagine cu o lățime și o înălțime fixe.

Pentru a lucra cu el, va trebui să creați o nouă clasă care moștenește din clasa Sprite și să definiți orice atribute și metode pe care doriți să le aibă personajul dvs. de joc.

instagram viewer

Crearea unei clase de sprite de bază pentru un personaj de joc

Primul, instalați modulul pygame folosind pip. Faceți acest lucru cu această comandă:

pip instalare pygame

Pentru a crea un sprite de bază, va trebui să importați clasa Sprite din Pygame și să creați o nouă clasă care moștenește din aceasta. Apoi, puteți defini orice atribute și metode pe care doriți să le aibă personajul dvs. de joc.

De exemplu, ați putea dori să creați o clasă Sprite pentru un personaj jucător care se poate deplasa la stânga și la dreapta pe ecran. Pentru a face acest lucru, puteți defini următoarele atribute:

  • poziţie: Un tuplu care deține coordonatele x și y ale sprite-ului de pe ecran.
  • viteză: Un tuplu care menține viteza cu care sprite-ul se mișcă orizontal și vertical.

Și următoarele metode:

  • Actualizați(): O metodă care actualizează poziția sprite-ului în funcție de viteza acestuia.
  • a desena(): O metodă care atrage sprite-ul pe ecran.

Iată un exemplu de clasă de bază Sprite care implementează aceste atribute și metode:

import pygame
clasăJucător(pygame.sprite. Sprite):
def__init__(self, x, y, speed_x, speed_y):
super().__init__()
de sine.poziție = (x, y)
de sine.viteza = (viteza_x, viteza_y)

defActualizați(de sine):
de sine.poziție = (de sine.poziţie[0] + de sine.viteză[0], de sine.poziţie[1] + de sine.viteză[1])

defa desena(sine, suprafață):
pygame.a desena.cerc(suprafaţă, (255, 0, 0), de sine.poziţie, 10)

Metoda __init__ este una specială metoda în clasele Python care rulează atunci când creați o instanță a clasei. Îl puteți folosi pentru a inițializa atributele instanței.

În acest cod, metoda __init__ a clasei Player ia patru argumente: x, y, velocity_x și velocity_y. Aceste argumente stabilesc poziția inițială și viteza sprite-ului jucătorului.

Metoda __init__ apelează și metoda super().__init__(), care este metoda __init__ a clasei părinte Sprite. Acest lucru este necesar deoarece clasa Player este o subclasă a clasei Sprite, iar metoda __init__ a clasei Sprite stabilește unele atribute de care au nevoie toți sprite-urile.

Adăugarea de atribute și metode pentru a controla comportamentul

Acum că aveți o clasă de bază Sprite, puteți adăuga atribute și metode pentru a controla comportamentul personajului din joc. Aceasta poate include lucruri precum mișcarea, atacul, săriturile și multe altele.

Pentru a adăuga aceste atribute și metode, va trebui să vă gândiți la ce acțiuni doriți în jocul dvs caracterul pentru a putea efectua și defini atributele și metodele corespunzătoare în Sprite-ul tău clasă.

De exemplu, poate doriți să adăugați o metodă pentru a controla mișcarea sprite-ului, cum ar fi o metodă move_left() care scade viteza sprite-ului pe axa x.

Iată un exemplu de clasă Sprite modificată care include aceste atribute și metode suplimentare:

clasăJucător(pygame.sprite. Sprite):
def__init__(self, x, y, speed_x, speed_y):
super().__init__()
de sine.poziție = (x, y)
de sine.viteza = (viteza_x, viteza_y)

defActualizați(de sine):
de sine.poziție = (de sine.poziţie[0] + de sine.viteză[0], de sine.poziţie[1] + de sine.viteză[1])

defa desena(sine, suprafață):
pygame.a desena.cerc(suprafaţă, (255, 0, 0), de sine.poziţie, 10)

defmută la stânga(de sine):
de sine.viteza = (-1, de sine.viteză[1])

defmisca-te la dreapta(de sine):
de sine.viteza = (1, de sine.viteză[1])

Pentru a utiliza clasa Player în jocul dvs. Pygame, va trebui să creați o instanță a clasei și să apelați metodele acesteia după cum este necesar.

Începeți prin a crea o fereastră și o instanță a sprite-ului Player:

# Inițializați Pygame
pygame.init()
# Setați dimensiunea ferestrei
dimensiunea_ferestrei = (640, 480)


# Creați o fereastră
window = pygame.display.set_mode (window_size)
# Creați un sprite pentru jucător
player = Player(320, 240, 0, 0)

Apoi definiți o buclă principală de joc care se ocupă de evenimentele de la tastatură și actualizările și desenează sprite-ul. Când apăsați tastele săgeți stânga sau dreapta, sprite-ul se va mișca în direcția corespunzătoare.

# Bucla principală a jocului
in timp ceAdevărat:
# Gestionați evenimentele
pentru eveniment în pygame.event.get():
dacă event.type == pygame. PĂRĂSI:
 pygame.quit()
 sys.exit()
dacă event.type == pygame. TASTA ÎN JOS:
dacă event.key == pygame. K_LEFT:
 player.move_left()
elif event.key == pygame. K_DREPTA:
 player.move_right()

# Actualizați sprite-ul jucătorului
 player.update()

# Goliți fereastra
 window.fill((255, 255, 255))

# Desenați sprite-ul jucătorului
 player.draw (fereastra)

# Actualizați afișajul
 pygame.display.update()

Cu programul rezultat, veți putea controla sprite-ul jucătorului și îl veți observa desenând pe ecran în diferite poziții:

Încărcarea și afișarea graficelor Sprite folosind modulul de imagine

Acum că aveți o clasă de bază Sprite cu atribute și metode pentru a controla comportamentul, probabil că veți dori să adăugați niște elemente grafice sprite-ului dvs. Modulul de imagine al Pygame facilitează încărcarea și afișarea imaginilor pe ecran.

Pentru a încărca o imagine, va trebui să utilizați funcția pygame.image.load(), care ia o cale de fișier ca argument și returnează un obiect Surface. Apoi, puteți atribui acest obiect de suprafață unui atribut de sprite, cum ar fi self.image, pe care îl puteți utiliza pentru a desena sprite-ul pe ecran.

De exemplu, iată cum ați putea încărca o imagine și să o alocați unui sprite:

import pygame
clasăJucător(pygame.sprite. Sprite):
def__init__(self, x, y, velocity_x, speed_y, image_path):
super().__init__()
de sine.poziție = (x, y)
de sine.viteza = (viteza_x, viteza_y)
de sine.image = pygame.image.load (cale_imagine)

defActualizați(de sine):
de sine.poziție = (de sine.poziţie[0] + de sine.viteză[0], de sine.poziţie[1] + de sine.viteză[1])

defa desena(sine, suprafață):
suprafaţă.blit(de sine.imagine, de sine.poziţie)
defmută la stânga(de sine):
de sine.viteza = (-1, de sine.viteză[1])

defmisca-te la dreapta(de sine):
de sine.viteza = (1, de sine.viteză[1])

Acest cod definește o clasă Player care extinde clasa Sprite a lui Pygame și include atribute pentru poziție, viteză și imagine, precum și metode de actualizare a poziției sprite-ului, de a atrage sprite-ul pe ecran și de control circulaţie.

Puteți verifica asta Repo GitHub pentru codul complet!

Îmbunătățiți managementul Sprite cu clasa Sprite

Clasa Sprite oferă un container convenabil pentru toate atributele și comportamentele unui personaj de joc, facilitând actualizarea, desenarea și controlul sprite-ului de pe ecran.

Prin implementarea unei clase Sprite în jocul tău Pygame, poți îmbunătăți experiența generală pentru jucătorii tăi și poți simplifica procesul de dezvoltare pentru tine.