Jak zaimplementować poziomy gry w Python’s Arcade

Biblioteka Arcade w Pythonie oferuje prosty i skuteczny sposób implementacji poziomów gier w twoich projektach.

Tworzenie gier to ekscytujący i kreatywny proces, który pozwala wcielić w życie swoje pomysłowe pomysły. Podczas projektowania gry jednym z kluczowych elementów, który może znacznie poprawić wrażenia gracza, jest implementacja poziomów gry.

Poziomy zapewniają strukturę, postępy i wyzwania, dając graczom poczucie osiągnięć i zaangażowania podczas przechodzenia przez różne etapy gry.

Stwórz prostą grę

Zanim zaczniesz, upewnij się, że masz pip zainstalowany na twoim urządzeniu. Użyj tego polecenia, aby zainstalować arkada biblioteka:

zręcznościowa instalacja pip

Stwórz podstawową grę, w której gracz może poruszać się w lewo i prawo.

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

Wykorzystaj możliwości biblioteki Arcade, aby obsłużyć dane wprowadzane przez użytkownika i odpowiednio zaktualizować stan gry. Utwórz nowy plik o nazwie prosta gra.py i dodaj poniższy kod:

instagram viewer

import arkadaSZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
klasaMoja gra(arkada. Okno):
pok__w tym__(samego siebie):
 super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, "Moja gra")
 arcade.set_background_color (arcade.color. BIAŁY)
 self.player_x = SZEROKOŚĆ_EKRANU // 2
pokon_draw(samego siebie):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkadowy.kolor. NIEBIESKI)
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 sam.gracz_x -= 10
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += 10
pokon_key_release(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY Lub klucz == klucz.zręcznościowy. PRAWIDŁOWY:
przechodzić
pokgłówny():
 gra = moja gra()
 arcade.run()Jeśli __nazwa__ == "__główny__":
 główny()

Poniżej znajduje się wyjście:

Twórz wiele poziomów

Teraz rozszerz grę, dodając wiele poziomów. Każdy poziom będzie miał swoją własną, unikalną charakterystykę, zapewniając graczowi różne wyzwania. Możesz zmodyfikować poprzedni kod, aby uwzględnić dodatkowe poziomy. Oto przykład:

klasaPierwszy poziom:
pok__w tym__(samego siebie):
 self.player_x = SZEROKOŚĆ_EKRANU // 2pokaktualizacja(samego siebie):
przechodzić
pokrysować(samego siebie):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkadowy.kolor. NIEBIESKI)
klasaPoziom drugi:
pok__w tym__(samego siebie):
 self.player_x = SZEROKOŚĆ_EKRANU // 2
pokaktualizacja(samego siebie):
przechodzić
pokrysować(samego siebie):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkadowy.kolor. CZERWONY)
klasaMoja gra(arkada. Okno):
pok__w tym__(samego siebie):
 super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, "Moja gra")
 arcade.set_background_color (arcade.color. BIAŁY)
 self.levels = [PoziomPierwszy(), PoziomDwa()]
 własny.obecny_poziom = 0
pokon_draw(samego siebie):
 arcade.start_render()
 self.levels[self.current_level].draw()
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 self.levels[self.current_level].player_x -= 10
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 self.levels[self.current_level].player_x += 10
pokon_key_release(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY Lub klucz == klucz.zręcznościowy. PRAWIDŁOWY:
przechodzić
pokaktualizacja(ja, delta_czas):
 self.levels[self.current_level].update()
pokgłówny():
 gra = moja gra()
 arcade.run()Jeśli __nazwa__ == "__główny__":
 główny()

Przejście między poziomami

Aby stworzyć płynne przejście między poziomami, wykrywaj, kiedy gracz przekracza określoną granicę. Możesz śledzić ruch gracza, a gdy gracz przekroczy granicę, możesz przejść do następnego poziomu. Utwórz nowy plik o nazwie przejście-pomiędzy-poziomami.py i dodaj kod z poniższymi aktualizacjami:

klasaMoja gra(arkada. Okno):
# ...pokaktualizacja(ja, delta_czas):
 self.levels[self.current_level].update()
# Sprawdź, czy gracz przekroczył granicę
Jeśli self.levels[self.current_level].player_x < 0:
 własny.poziom_obecny += 1
 self.current_level %= len (self.levels)
 self.levels[self.current_level].player_x = SCREEN_WIDTH
Elif self.levels[self.current_level].player_x > SCREEN_WIDTH:
 własny.poziom_obecny += 1
 self.current_level %= len (self.levels)
 self.levels[self.current_level].player_x = 0# ...

Poniżej znajduje się wyjście:

W tym dodatkowe funkcje

Aby Twoje poziomy gry były bardziej wciągające, możesz włączyć dodatkowe funkcje, takie jak ulepszenia i cele.

Cele

Cele zapewniają określone cele lub cele, które gracz może osiągnąć na poziomie. Dodają poczucia celu i postępu. Oto przykład implementacji funkcji celu:

klasaCel:
pok__w tym__(ja, x, y):
 ja.x = x
 ja.y = y
 promień własny = 20pokrysować(samego siebie):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ZIELONY)
klasaPierwszy poziom:
pok__w tym__(samego siebie):
 cel własny = Cel(600, 400)
# ...
pokaktualizacja(samego siebie):
# Sprawdź, czy gracz osiąga cel
Jeśli arcade.check_for_collision (samo.gracz, samo.cel):
 self.complete_objective()
pokrysować(samego siebie):
 własny.cel.draw()
# ...pokkompletny_cel(samego siebie):
# Kod do obsługi realizacji celu
przechodzić

Artykuły kolekcjonerskie

Przedmioty kolekcjonerskie to przedmioty lub bonusy, które gracz może zbierać na różnych poziomach. Oto przykład implementacji funkcji kolekcjonerskiej:

klasaKolekcjonerska:
pok__w tym__(ja, x, y):
 ja.x = x
 ja.y = y
 promień własny = 10
 self.is_collected = FAŁSZpokrysować(samego siebie):
Jeślinie self.is_collected:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. POMARAŃCZOWY)
pokzbierać(samego siebie):
 self.is_collected = PRAWDA
# Kod do obsługi wpływu przedmiotu kolekcjonerskiego na gracza
klasaPierwszy poziom:
pok__w tym__(samego siebie):
 self.collectible = Collectible(300, 300)
# ...
pokaktualizacja(samego siebie):
# Sprawdź, czy gracz zbiera przedmiot
Jeśli arcade.check_for_collision (samodzielny gracz, samodzielny przedmiot kolekcjonerski):
 samo.zbieranie.zbieranie()pokrysować(samego siebie):
 samo.kolekcja.draw()
# ...

Przeszkody

Przeszkody mogą być obiektami statycznymi lub poruszającymi się obiektami, które blokują ścieżkę gracza. Wymagają od gracza opracowania strategii i znalezienia sposobów na ich pokonanie. Oto przykład implementacji funkcji przeszkód:

klasaPrzeszkoda:
pok__w tym__(ja, x, y, szerokość, wysokość):
 ja.x = x
 ja.y = y
 własna szerokość = szerokość
 własny.wysokość = wzrostpokrysować(samego siebie):
 arcade.draw_rectangle_filled (self.x, self.y, self.width, self.height, arcade.color. SZARY)klasaPierwszy poziom:
pok__w tym__(samego siebie):
 self.obstacles = [Przeszkoda(400, 200, 100, 50), Przeszkoda(600, 500, 80, 120)]
# ...

Dopalacze

Power-upy mogą zwiększać umiejętności gracza lub zapewniać tymczasowe korzyści. Oto przykład implementacji funkcji włączania:

klasaWzmocnienie:
pok__w tym__(ja, x, y):
 ja.x = x
 ja.y = y
 promień własny = 10
 self.is_active = PRAWDApokrysować(samego siebie):
Jeśli self.is_active:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ŻÓŁTY)
pokaktywuj_zasilanie(samego siebie):
 self.is_active = PRAWDA
pokdezaktywuj_zasilanie(samego siebie):
 self.is_active = FAŁSZ
klasaPierwszy poziom:
pok__w tym__(samego siebie):
 self.power_up = PowerUp(200, 200)
# ...
pokaktualizacja(samego siebie):
# Sprawdź, czy odtwarzacz nie koliduje z zasilaniem
Jeśli arcade.check_for_collision (self.player, self.power_up):
 self.player.activate_power_up()
 self.power_up.deactivate_power_up()pokrysować(samego siebie):
 self.power_up.draw()
# ...

Najlepsze praktyki projektowania poziomów

Projektowanie poziomów odgrywa kluczową rolę w tworzeniu wciągającej i przyjemnej rozgrywki. Oto kilka najlepszych praktyk, które należy wziąć pod uwagę podczas projektowania poziomów do gry:

Wyczyść cele

Każdy poziom powinien mieć jasny cel lub cel, który gracz ma osiągnąć. Niezależnie od tego, czy chodzi o dotarcie do określonego miejsca, pokonanie wrogów czy rozwiązanie zagadki, cel powinien być dobrze zdefiniowany i zakomunikowany graczowi.

Stopniowa krzywa trudności

Projektuj poziomy ze stopniowym wzrostem trudności, aby zapewnić płynną krzywą uczenia się dla graczy. Zacznij od prostszych wyzwań i stopniowo wprowadzaj nowe mechaniki lub przeszkody w miarę postępów gracza. Nagłe skoki poziomu trudności mogą frustrować graczy, dlatego ważne jest, aby zachować zrównoważony postęp.

Przejrzystość wizualna

Upewnij się, że projekt poziomu i elementy wizualne jasno przekazują graczowi ważne informacje. Zawiera muzykę i efekty dźwiękowe może również przekazywać kluczowe wskazówki i dostarczać graczowi niezbędnych informacji.

Testowanie gry i iteracja

Regularne testowanie gry jest niezbędne do udoskonalania i ulepszania projektu poziomów. Zbieraj opinie od graczy i obserwuj ich doświadczenia, aby zidentyfikować obszary, które mogą wymagać poprawek. Przeprowadź iterację swojego projektu poziomów w oparciu o te opinie, aby stworzyć bardziej przyjemną i zrównoważoną rozgrywkę.

Zrównoważ nagrodę i wyzwanie

Nagradzaj graczy za pokonywanie wyzwań na swoich poziomach. Można to osiągnąć poprzez ulepszenia, przedmioty kolekcjonerskie, odblokowywanie nowych obszarów lub postęp narracyjny. Równoważenie trudności wyzwań z sensownymi nagrodami pomaga motywować graczy i zapewnia poczucie spełnienia.

Spraw, by gry były bardziej wciągające dzięki poziomom

Wdrażając poziomy gry, możesz poprawić ogólne wrażenia gracza i stworzyć bardziej wciągające środowisko rozgrywki. Poziomy zapewniają postęp, wyzwanie i różnorodność, dzięki czemu gracze są zaangażowani i zmotywowani. Pozwalają wprowadzić nowe mechaniki, przeszkody, wrogów i nagrody, zapewniając, że każdy poziom będzie inny i ekscytujący.

About Technology - denizatm.com