Dodawanie efektów specjalnych do gier Pygame: systemy cząstek i ulepszenia wizualne

Pygame to popularna biblioteka do tworzenia gier przy użyciu Pythona. Podczas tworzenia gier dodawanie efektów specjalnych może znacznie poprawić atrakcyjność wizualną i ogólne wrażenia graczy.

Systemy cząstek to potężna technika tworzenia dynamicznych i interesujących wizualnie efektów, takich jak chmury pyłu, eksplozje, mgła i inne.

Stwórz prostą grę

Zanim zagłębisz się w systemy cząsteczkowe i ulepszenia wizualne, zacznij od stworzenia prostej gry przy użyciu Pygame. Utwórz nowy plik o nazwie prosta gra.py i zacznij od zaimportowania niezbędnych bibliotek i zainicjowania Pygame. Ustaw okno gry o określonej szerokości i wysokości.

Kod użyty w tym artykule jest dostępny w this Repozytorium GitHub i jest darmowy do użytku na licencji MIT.

Wewnątrz głównej pętli gry obsługuj zdarzenia użytkownika i aktualizuj pozycję gracza na podstawie naciśnięć klawiszy. Narysuj prostokąt dla obiektu gracza za pomocą pygame.draw.rect().

Na koniec zaktualizuj okno gry za pomocą pygame.display.flip() i wyjdź z gry, gdy gracz wyjdzie z pętli. Ta prosta gra posłuży jako podstawa do dodawania efektów specjalnych za pomocą systemów cząstek.

Powinieneś zobaczyć biały kwadrat reprezentujący gracza, którego możesz przesuwać w lewo i prawo:

Tworzenie różnych typów cząstek

Teraz, gdy masz już skonfigurowaną prostą grę, możesz dodać różne systemy cząsteczek. Twórz klasy cząstek dla każdego efektu i klasę systemu cząstek, aby zarządzać cząsteczkami i aktualizować je.

Efekt cząsteczkowy, gdy gracz się porusza

Pierwszym efektem cząsteczkowym będzie ślad cząsteczek kurzu emitowanych z pleców gracza, gdy gracz zacznie to robić poruszać się za pomocą myszy lub klawiatury. Dodatkowo kierunek cząstek pyłu zmieni się, gdy gracz zmieni kierunek.

zdefiniuj Cząstka klasa reprezentująca pojedynczą cząstkę. Każda cząstka ma swoją pozycję początkową (X I y), losowa prędkość (dx I dy) i czas życia, który określa, jak długo cząstka będzie istnieć.

Zdefiniuj też A System cząstek klasa zarządzająca zbiorem cząstek. Możesz dodać nową cząsteczkę do systemu za pomocą add_cząstka() metoda. The aktualizacja() metoda aktualizuje wszystkie cząstki w systemie i usuwa cząstki, które osiągnęły koniec swojego życia.

# Klasa cząstek
klasaCząstka:
pok__w tym__(ja, x, y):
 ja.x = x
 ja.y = y
 self.dx = random.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 własny.czas życia = 60
pokaktualizacja(samego siebie):
 sam.x += sam.dx
 ja.y += ja.dy
 własny.czas życia -= 1
pokrysować(ja, okno):
 kolor = (200, 200, 200)
 pozycja = (int (self.x), int (self.y))
 pygame.draw.circle (okno, kolor, pozycja, 2)
# Klasa układu cząstek
klasaSystem cząstek:
pok__w tym__(samego siebie):
 własne.cząstki = []
pokdodaj_cząsteczkę(ja, x, y):
 self.particles.append (Cząsteczka (x, y))
pokaktualizacja(samego siebie):
Do cząstka W cząstki własne:
 cząsteczka.aktualizacja()
Jeśli czas życia cząstki <= 0:
 self.cząstki.usuń (cząsteczka)
pokrysować(ja, okno):
Do cząstka W cząstki własne:
 cząsteczka.draw (okno)

Aby zintegrować system cząsteczkowy ze swoją grą, musisz wprowadzić kilka modyfikacji w głównej pętli gry. Utwórz nowy plik o nazwie cząstki-ruchu.py i dodaj kod z poniższymi aktualizacjami:

# Utwórz system cząstek
system_cząsteczek = system_cząstek()
# Główna pętla gry
bieganie = PRAWDA
zegar = pygame.czas. Zegar()
chwila działanie:
 dt = zegar.tick(60) / 1000.0
Do wydarzenie W pygame.event.get():
Jeśli event.type == pygame. ZREZYGNOWAĆ:
 bieganie = FAŁSZ
 cząstka_y = gracz_y + wysokość_gracza // 2
 cząsteczka_x = gracz_x + szerokość_gracza
 klucze = pygame.key.get_pressed()
 granica = gracz_x < szerokość_okna - gracz_szerokość
Jeśli klucze [gra. K_LEFT] I gracz_x > 0:
 gracz_x -= 5
 system_cząsteczek.add_cząsteczka (cząstka_x, cząsteczka_y)
Jeśli klucze [gra. K_PRAWO] I granica:
 gracz_x += 5
 system_cząsteczek.add_cząsteczka (gracz_x, cząsteczka_y)
 system_cząsteczek. aktualizacja()
 okno.wypełnienie (CZARNY)
 pozycja_gracza = (gracz_x, gracz_y, szerokość_gracza, wysokość_gracza)
 pygame.draw.rect (okno, BIAŁY, pozycja_gracza)
 system_cząsteczek.draw (okno)
 pygame.display.flip()
# Wyjdź z gry
pygame.quit()

Kiedy teraz przesuniesz obiekt gracza, powinieneś zobaczyć cząstki podkreślające ruch:

Efekt wybuchu

Następnym efektem cząsteczkowym będzie efekt wybuchu, który pojawia się, gdy gracz strzela pociskiem. Efekt wybuchu będzie się składał z czerwonych cząstek emitowanych z pozycji pocisku.

zdefiniuj Cząstka klasa podobna do poprzedniej, ale tym razem zawiera a kolor parametr reprezentujący kolor cząstki.

Zaktualizuj także System cząstek class do obsługi nowego typu cząstek. The add_cząstka() metoda pobiera teraz dodatkowe kolor parametru i tworzy cząstki o określonym kolorze.

# Klasa cząstek
klasaCząstka:
pok__w tym__(ja, x, y, kolor):
 ja.x = x
 ja.y = y
 self.dx = random.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 własny.czas życia = 30
 własny.kolor = kolor
pokaktualizacja(samego siebie):
 sam.x += sam.dx
 ja.y += ja.dy
 własny.czas życia -= 1
pokrysować(ja, okno):
 pozycja = (int (self.x), int (self.y))
 pygame.draw.circle (okno, własny.kolor, pozycja, 3)
# Klasa układu cząstek
klasaSystem cząstek:
pok__w tym__(samego siebie):
 własne.cząstki = []
pokdodaj_cząsteczkę(ja, x, y, kolor):
 self.particles.append (Cząstka (x, y, kolor)
pokaktualizacja(samego siebie):
Do cząstka W cząstki własne:
 cząsteczka.aktualizacja()
Jeśli czas życia cząstki <= 0:
 self.cząstki.usuń (cząsteczka)
pokrysować(ja, okno):
Do cząstka W cząstki własne:
 cząsteczka.draw (okno)

Aby włączyć efekt wybuchu do swojej gry, musisz wprowadzić kilka modyfikacji w głównej pętli gry. Utwórz nową nazwę pliku shoot-cząsteczka.py i dodaj kod z poniższymi aktualizacjami:

# Utwórz system cząstek
system_cząsteczek = system_cząstek()
# Główna pętla gry
bieganie = PRAWDA
zegar = pygame.czas. Zegar()
chwila działanie:
 dt = zegar.tick(60) / 1000.0
Do wydarzenie W pygame.event.get():
Jeśli event.type == pygame. ZREZYGNOWAĆ:
 bieganie = FAŁSZ
 klucze = pygame.key.get_pressed()
 granica = gracz_x < szerokość_okna - gracz_szerokość
Jeśli klucze [gra. K_LEFT] I gracz_x > 0:
 gracz_x -= 5
Jeśli klucze [gra. K_PRAWO] I granica:
 gracz_x += 5
Jeśli klucze [gra. K_SPACE]:
 punktor_x = gracz_x + szerokość_gracza // 2
 punktor_y = gracz_y
 system_cząstek.add_cząsteczka (bullet_x, kula_y, CZERWONY)
 system_cząsteczek. aktualizacja()
 okno.wypełnienie (CZARNY)
 pozycja_gracza = (gracz_x, gracz_y, szerokość_gracza, wysokość_gracza)
 pygame.draw.rect (okno, BIAŁY, pozycja_gracza)
 system_cząsteczek.draw (okno)
 pygame.display.flip()
# Wyjdź z gry
pygame.quit()

Oto dane wyjściowe:

Kiedy spacja ( pygame. K_SPACE) jest wciśnięty, dodaj cząsteczkę do systemu cząsteczek w miejscu pocisku. Tworzy to efekt podmuchu z czerwonymi cząsteczkami.

Efekt pyłu

Ostatnim wizualnym ulepszeniem, które możesz zastosować, jest efekt zakurzonego tła. Efekt kurzu będzie się składał z małych szarych cząstek poruszających się po okręgu, tworząc dynamiczne i zakurzone tło.

Zaktualizuj Cząstka klasa obejmująca kąt I prędkość dla każdej cząstki. Kąt określa kierunek ruchu, a prędkość kontroluje, jak szybko cząstki poruszają się po okręgu. Zmodyfikuj aktualizacja() metoda aktualizacji pozycji każdej cząstki na podstawie jej kąta i prędkości.

Zaktualizuj także System cząstek class do obsługi nowego zachowania cząstek. Cząsteczki poruszają się teraz po okręgu w oknie gry.

# Klasa cząstek
klasaCząstka:
pok__w tym__(ja, x, y, promień):
 ja.x = x
 ja.y = y
 promień własny = promień
 własny.kąt = losowy.uniform(0, 2 * matematyka.pi)
 własna.prędkość = losowy.jednolity(0.5, 1.5)
pokaktualizacja(samego siebie):
 własny.kąt += 0.02
 self.x += math.cos (self.angle) * self.speed
 self.y += math.sin (kąt.self) * self.speed
Jeśli ja.x < 0:
 self.x = szerokość_okna
Elif self.x > szerokość_okna:
 ja.x = 0
Jeśli ja.y < 0:
 self.y = wysokość_okna
Elif self.y > wysokość_okna:
 ja.y = 0
pokrysować(ja, okno):
 kolor = (128, 128, 128)
 poz = (int (self.x), int (self.y))
 promień = int (promień własny)
 pygame.draw.circle (okno, kolor, pozycja, promień)
# Klasa układu cząstek
klasaSystem cząstek:
pok__w tym__(samego siebie):
 własne.cząstki = []
pokdodaj_cząsteczkę(ja, x, y, promień):
 self.particles.append (Cząsteczka (x, y, promień))
pokaktualizacja(samego siebie):
Do cząstka W cząstki własne:
 cząsteczka.aktualizacja()
pokrysować(ja, okno):
Do cząstka W cząstki własne:
 cząsteczka.draw (okno)

Aby włączyć efekt kurzu do swojej gry, musisz wprowadzić kilka modyfikacji w głównej pętli gry. Utwórz nowy plik o nazwie cząsteczki pyłu.py i dodaj kod z poniższymi aktualizacjami:

# Utwórz system cząstek dla efektu pyłu
system_cząsteczek = system_cząstek()
# Główna pętla gry
bieganie = PRAWDA
zegar = pygame.czas. Zegar()
chwila działanie:
 dt = zegar.tick(60) / 1000.0
Do wydarzenie W pygame.event.get():
Jeśli event.type == pygame. ZREZYGNOWAĆ:
 bieganie = FAŁSZ
 cząsteczka_x = losowo.randint(0, szerokość_okna)
 cząsteczka_y = losowo.randint(0, wysokość_okna)
 system_cząsteczek.add_cząsteczka (cząstka_x, cząsteczka_y, 1)
 system_cząsteczek. aktualizacja()
 okno.wypełnij((0, 0, 0))
 system_cząsteczek.draw (okno)
 pygame.display.flip()
# Wyjdź z gry
pygame.quit()

Dodaj cząsteczki losowo w oknie gry za pomocą random.randint() funkcjonować. Każda cząstka ma początkowy promień 1. Zaktualizuj i narysuj system cząsteczek w oknie gry, tworząc dynamiczny i zakurzony efekt tła.

Na ekranie powinieneś zobaczyć wiele cząstek poruszających się losowo, ale płynnie:

Najlepsze praktyki dotyczące efektów specjalnych

Dodając efekty specjalne do swojej gry Pygame, weź pod uwagę następujące najlepsze praktyki:

Optymalizacja wydajności

Systemy cząstek mogą obejmować dużą liczbę cząstek, co może wpływać na wydajność gry. Implementuj techniki, takie jak partycjonowanie przestrzenne (np. Quadtree), aby zoptymalizować aktualizacje cząstek i rysowanie.

Recykling cząstek

Zamiast tworzyć i niszczyć cząstki w każdej klatce, rozważ ich ponowne użycie poprzez zresetowanie ich właściwości, gdy osiągną koniec swojego życia. Pomaga to zminimalizować alokację i zwalnianie pamięci.

Łączenie cząstek

Utrzymuj pulę wstępnie przydzielonych cząstek, aby uniknąć narzutu związanego z tworzeniem nowych instancji w czasie wykonywania. Może to poprawić wydajność i zmniejszyć fragmentację pamięci.

Ogranicz liczbę cząstek

Aby zapobiec przytłoczeniu ekranu gry przez systemy cząsteczkowe, ustaw limity maksymalnej liczby cząstek i usuwaj cząsteczki, gdy osiągną ten limit. Gwarantuje to, że efekty pozostaną atrakcyjne wizualnie bez utrudniania rozgrywki.

Spójność wizualna

Zachowaj spójny styl wizualny w całej grze, w tym efekty cząsteczkowe. Upewnij się, że kolory, rozmiary i wzory ruchu cząstek są spójne z ogólnym motywem i stylem graficznym.

Efekty dźwiękowe

Dodaj efekty dźwiękowe aby uzupełnić efekty cząsteczkowe. Na przykład odtwarzaj dźwięki eksplozji, gdy wystąpi efekt wybuchu lub dźwięki otoczenia, gdy efekty mgły lub pyłu są aktywne.

Spraw, by gry były przyjemniejsze dzięki efektom specjalnym

Dodanie efektów specjalnych, takich jak systemy cząstek, do gier Pygame może znacznie poprawić wrażenia gracza i sprawić, że gry będą bardziej wciągające i zabawne dla graczy. Implementując efekty cząsteczkowe, takie jak ślady, eksplozje, mgła i kurz, możesz tworzyć oszałamiające wizualnie i dynamiczne środowiska.

Pamiętaj, aby wziąć pod uwagę optymalizację wydajności, recykling cząstek i spójność wizualną podczas włączania efektów specjalnych do swoich gier. Dzięki kreatywności i eksperymentom możesz przenieść swoje gry Pygame na wyższy poziom i urzekać graczy wciągającymi i ekscytującymi doświadczeniami.