Jak zaimplementować przewijane tła w Pygame

Przewijane tła mogą znacznie poprawić atrakcyjność wizualną i głębię gry. Mogą stworzyć iluzję ruchu, nadając grze dynamiczny i wciągający charakter. Możesz zaimplementować przewijane tła w kilku prostych krokach za pomocą Pygame.

Pygame to popularna biblioteka Pythona, której możesz używać do tworzenia gier. Dodanie przewijanego tła do projektów Pygame ożywi je i zapewni graczom bardziej wciągające wrażenia.

Stwórz prostą grę

Aby zrozumieć koncepcję przewijania tła w Pygame, zacznij od stworzenia prostej gry, w której gracz może poruszać się w lewo i w prawo. Możesz także dołączyć dwie platformy, reprezentowane przez prostokąty, które będą służyć jako środowisko gry. Utwórz nowy plik o nazwie prosta gra.py.

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

Najpierw zaimportuj moduł pygame i zainicjuj go. Następnie określ pozycję startową gracza i prędkość ruchu. Twórz platformy za pomocą

pygame. Prost obiektów i zdefiniuj ich położenie oraz wymiary.

Wewnątrz pętli gry obsługuj zdarzenia, takie jak wyjście z gry. Możesz też poradzić ruch gracza oparty na wejściach dotykowych lub klawiaturowych.

Oto wynik prostej gry:

Twórz różne warstwy

Aby uzyskać efekt przewijania, możesz utworzyć wiele warstw tła o różnych kolorach. Każda warstwa będzie się poruszać z inną prędkością, tworząc efekt paralaksy. Efekt ten daje iluzję głębi i wzmacnia poczucie ruchu w grze.

Zdefiniuj dwie warstwy tła, z których każda pokrywa całe okno gry, używając pygame. Wyprostuj obiekty. Zdefiniuj również kolory każdej warstwy w pliku kolory_tła lista. The prędkość_tła lista określa prędkość, z jaką każda warstwa będzie się poruszać.

# Dodaj ten kod poniżej poprzedniej sekcji
warstwy_tła = [
 pygame. prostokąt(0, 0, szerokość_ekranu, wysokość_ekranu), 
 pygame. prostokąt(0, 0, szerokość_ekranu, wysokość_ekranu) 
]
kolory_tła = [(30, 30, 30), (60, 60, 60)]
prędkości_w tle = [0.1, 1.0]

Aby utworzyć efekt przewijania tła, musisz zaktualizować pozycje warstw tła w pętli gry. Będziesz przesuwać każdą warstwę w poziomie w oparciu o przypisaną jej prędkość.

Utwórz nowy plik o nazwie scrolling-bg.py i dodaj kod z poniższymi aktualizacjami:

Do I W zakres (dł. (warstwy_tła)):
 warstwy_w tle[i].x -=prędkości_w tle[i]
Jeśli warstwy_tła[i].x <= -szerokość_ekranu:
 warstwy_tła[i].x = 0
 pygame.draw.rect (ekran, kolory_tła [i], warstwy_tła [i])

Przejrzyj każdą warstwę tła. Odejmij odpowiednią prędkość od współrzędnej x warstwy, powodując jej ruch w lewo. Jeśli warstwa dotrze do lewej krawędzi ekranu, zresetuj jej położenie w prawo, tworząc efekt ciągłego przewijania.

Wreszcie, narysuj każdą prostokątną warstwę tła na ekranie za pomocą pygame.draw.rect() i przekazując odpowiedni kolor i pygame. Prostokątny obiekt.

Dodawanie efektu paralaksy podczas ruchu

Aby wzmocnić efekt paralaksy, możesz zmodyfikować ruch platformy tak, aby występował, gdy gracz się porusza. Stworzy to silne wrażenie głębi i dynamicznego ruchu. Utwórz nowy plik o nazwie paralaksa.py i dodaj kod z poniższymi aktualizacjami:

# Zdefiniuj pozycje i prędkości platformy
rect1 = pygame. prostokąt(50, wysokość_ekranu - 100, 200, 10)
rect2 = pygame. Prostokąt (szerokość_ekranu - 250, wysokość_ekranu - 200, 200, 10)
platformy = [
 {„prosto”: prostokąt1, "prędkość": 3},
 {„prosto”: prostokąt2, "prędkość": 1}
]
# Dodaj ten kod w pętli gry
# Ruch gracza
klucze = pygame.key.get_pressed()
Jeśli klucze [gra. K_LEFT] I gracz_x > 0:
 gracz_x -= prędkość_gracza
Do platforma W platformy:
 platforma[„prosto”].x -= platforma["prędkość"]
Jeśli klucze [gra. K_PRAWO] I gracz_x < szerokość_ekranu:
 gracz_x += prędkość_gracza
Do platforma W platformy:
 platforma[„prosto”].x += platforma["prędkość"]
Do platforma W platformy:
 pygame.draw.rect (ekran, (0, 255, 0), platforma[„prosto”])

Przedstaw platformy jako słowniki zawierające zarówno obiekt prostokątny (prostokąt), jak i prędkość, z jaką platforma powinna się poruszać (prędkość). Platformy aktualizują się w pętli gry na podstawie ruchu gracza.

Wprowadzając tę ​​modyfikację, efekt przewijania będzie aktywny tylko wtedy, gdy gracz aktywnie się porusza, jeszcze bardziej wzmacniając iluzję głębi i ruchu.

W tym dodatkowe funkcje

Możesz zaimplementować kilka dodatkowych funkcji, aby ulepszyć przewijane tła w swojej grze. Oto kilka przykładów.

Losuj kolory tła

Aby dodać wariacji do warstw tła, możesz wybrać losowo ich kolory. Możesz to zrobić, modyfikując plik kolory_tła lista:

import losowy
# Dodaj ten kod przed pętlą gry
kolory_tła = [
 (losowy.randint(0, 255), losowo.randint(0, 255), losowo.randint(0, 255)),
 (losowy.randint(0, 255), losowo.randint(0, 255), losowo.randint(0, 255)),
 (losowy.randint(0, 255), losowo.randint(0, 255), losowo.randint(0, 255))
]

Dodaj więcej warstw tła

Możesz poeksperymentować z dodaniem większej liczby warstw tła, aby uzyskać bogatszy efekt paralaksy. Po prostu zdefiniuj dodatkowe pygame. Prost obiekty, kolory i prędkości:

# Dodaj ten kod przed pętlą gry
warstwy_tła = [
 pygame. prostokąt(0, 0, szerokość_ekranu, wysokość_ekranu), 
 pygame. prostokąt(0, 0, szerokość_ekranu, wysokość_ekranu), 
 pygame. prostokąt(0, 0, szerokość_ekranu, wysokość_ekranu), 
 pygame. prostokąt(0, 0, szerokość_ekranu, wysokość_ekranu) 
]
kolory_tła = [
 (30, 30, 30),
 (60, 60, 60),
 (90, 90, 90),
 (120, 120, 120)
]
prędkości_w tle = [1, 2, 3, 4]

Użyj obrazów jako tła

Zamiast jednolitych kolorów możesz użyć plików graficznych jako tła. Pygame zapewnia funkcje do ładowania i renderowania obrazów.

Załaduj pliki obrazów tło_0.png, tło_1.png, I tło_2.png za pomocą pygame.image.load(). Użyj metody convert(), aby poprawić wydajność i skalować obrazy, aby dopasować je do wymiarów ekranu pygame.transform.scale().

# Dodaj ten kod przed pętlą gry
obrazy_tła = [
 pygame.image.load("tło_0.png").konwertować(),
 pygame.image.load("tło_1.png").konwertować(),
 pygame.image.load("tło_2.png").konwertować()
]
prędkości_w tle = [1, 2, 3]
Do I W zakres (dł. (obrazy_tła)):
 rozmiar = (szerokość_ekranu, wysokość_ekranu)
 obrazy_tła[i] = pygame.transform.scale (obrazy_tła[i], rozmiar)

Na koniec zaktualizuj pętlę, w której rysujesz warstwy tła, aby użyć obrazów:

# Zaktualizuj ten kod w pętli gry
Do I W zakres (dł. (warstwy_tła)):
 warstwy_w tle[i].x -=prędkości_w tle[i]
Jeśli warstwy_tła[i].x <= -szerokość_ekranu:
 warstwy_tła[i].x = 0
 screen.blit (obrazy_tła[i], warstwy_tła[i])

Oto kilka najlepszych praktyk, które należy wziąć pod uwagę przy wdrażaniu przewijanego tła w projektach Pygame.

Zoptymalizuj wydajność

Przewijanie tła wiąże się z ciągłym renderowaniem i aktualizacją. Aby zapewnić płynną rozgrywkę, rozważ optymalizację kodu i zminimalizowanie zbędnych obliczeń.

Eksperymentuj z prędkościami warstw

Dostosowanie prędkości warstw tła może tworzyć różne efekty. Baw się różnymi wartościami, aby znaleźć właściwą równowagę i osiągnąć pożądany efekt wizualny.

Testuj na różnych rozmiarach ekranu

Upewnij się, że przewijane tła działają dobrze na różnych rozdzielczościach ekranu. Rozważ wdrożenie skalowania dynamicznego lub użycie różnych obrazów tła dla różnych współczynników proporcji.

Użyj odpowiednich formatów obrazu

Jeśli zdecydujesz się użyć obrazów jako tła, wybierz odpowiedni format obrazu (np. PNG, JPEG), aby zrównoważyć rozmiar pliku i jakość obrazu. Możesz także skrócić czas ładowania, kompresując i optymalizując obrazy.

Rozważ wykorzystanie pamięci

Jeśli planujesz użyć wielu obrazów o wysokiej rozdzielczości jako tła, pamiętaj o wymaganiach dotyczących pamięci. Duże obrazy mogą zajmować znaczną ilość pamięci, potencjalnie wpływając na wydajność i szybkość reakcji gry.

Włączając przewijane tła, możesz tworzyć różne środowiska, takie jak ruchome krajobrazy, futurystyczne pejzaże miejskie lub podwodne światy. Efekt paralaksy dodaje dynamiki, sprawiając, że świat gry wydaje się żywy i interaktywny.

Pamiętaj, aby eksperymentować, iterować i odkrywać kreatywne możliwości przewijania tła, aby Twoje gry były ciekawsze i bardziej wciągające dla graczy.