Większość gier platformowych wykorzystuje jakiś rodzaj skoku, z odmianami obejmującymi podwójny skok i skok o zmiennej wysokości. Odkryj techniki stojące za tymi ruchami.
Mechanika skoków odgrywa kluczową rolę w zwiększaniu wrażeń z gry platformowej. Implementując różne mechaniki skoków w Python's Arcade Library, możesz dodać głębi i emocji swoim grom.
Biblioteka Arcade zapewnia intuicyjne i łatwe w obsłudze środowisko do tworzenia gier, dzięki czemu jest idealnym wyborem do tworzenia platformówek.
Stwórz prostą grę
Przed rozpoczęciem, zainstaluj pip na swoim urządzeniu i użyj tego polecenia, aby zainstalować arkada moduł:
zręcznościowa instalacja pipAby dowiedzieć się, jak działa mechanika skakania, zacznij od stworzenia prostej gry, w której gracz może poruszać się w lewo i w prawo dzięki grawitacji i statycznej platformie.
Kod użyty w tym artykule jest dostępny w this Repozytorium GitHub i jest darmowy do użytku na licencji MIT.
W grze gracz zderzy się z platformą i stanie na jej szczycie. Utwórz nowy plik o nazwie prosta gra.py i dodaj poniższy kod:
import arkadaSZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
PROMIEŃ_GRACZA = 20
PLATFORMA_SZEROKOŚĆ = 200
WYSOKOŚĆ_PLATFORMY = 20
GRAWITACJA = 0.5
niebieski = arkadowy.kolor. NIEBIESKI
zielony = arcade.kolor. ZIELONYklasaOkno gry(arkada. Okno):
pok__w tym__(samego siebie):
super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, „Mechanika skoków”)
self.player_x = SZEROKOŚĆ_EKRANU // 2
self.player_y = WYSOKOŚĆ_EKRANU // 2
sam.gracz_dy = 0
self.platform_x = SZEROKOŚĆ_EKRANU // 2
self.platform_y = WYSOKOŚĆ_EKRANU // 4pokon_draw(samego siebie):
arcade.start_render()arcade.draw_circle_filled (self.player_x, self.player_y,
PLAYER_RADIUS, niebieski)arcade.draw_rectangle_filled (self.platform_x, self.platform_y,
PLATFORM_WIDTH, PLATFORM_HEIGHT, zielony)pokw dniu_aktualizacji(ja, delta_czas):
self.player_dy -= GRAWITACJA
self.player_y += self.player_dy
dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2Jeśli sam.gracz_y < odległość:
sam.gracz_y = odl
sam.gracz_dy = 0
gra = Okno Gry()
arcade.run()
Po uruchomieniu programu zobaczysz, jak obiekt gracza szybko spada na platformę, a następnie spoczywa na nim.
Dodanie funkcji prostego skoku
Teraz dodaj do gry prostą funkcję skoku. Sprawdź kolizję pomiędzy graczem a platformą i uruchom akcję skoku, gdy gracz naciśnie klawisz strzałki w górę. Aby to osiągnąć, utwórz nowy plik o nazwie skok.py oraz kod z poniższymi aktualizacjami:
klasaOkno gry(arkada. Okno):
pok__w tym__(samego siebie):
# ...pokon_key_press(ja, klucz, modyfikatory):
on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2Jeśli klucz == klucz.zręcznościowy. W GÓRĘ I self.player_y == na ziemi:
sam.gracz_dy = 10
pokw dniu_aktualizacji(ja, delta_czas):
self.player_dy -= GRAWITACJA
self.player_y += self.player_dy
dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
Jeśli sam.gracz_y < odległość:
sam.gracz_y = odl
sam.gracz_dy = 0
self.liczba_skoków = 0
Dodanie funkcji podwójnego skoku
Aby dodać funkcję podwójnego skoku, rozszerz istniejącą logikę skoku. Gdy gracz znajdzie się na platformie i po raz pierwszy wciśnie strzałkę w górę, wykona zwykły skok. Jeśli jednak ponownie wcisną strzałkę w górę w powietrzu, gracz wykona podwójny skok.
Utwórz nowy plik o nazwie podwójny skok.py oraz kod z poniższymi aktualizacjami:
klasaOkno gry(arkada. Okno):
pok__w tym__(samego siebie):
self.liczba_skoków = 0# Śledź liczbę skokówpokon_key_press(ja, klucz, modyfikatory):
on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
Jeśli klucz == klucz.zręcznościowy. W GÓRĘ:
Jeśli self.player_y == on_ground Lub własny.liczba_skoków < 2:
sam.gracz_dy = 10
self.liczba_skoków += 1
W tym dodatkowe funkcje
Oprócz prostych i podwójnych skoków istnieje wiele funkcji, które możesz dodać, aby ulepszyć mechanikę skoków w swojej grze.
Implementacja zmiennej wysokości skoku
Umożliwienie graczowi kontrolowania wysokości skoków w zależności od tego, jak długo trzyma przycisk skoku, może zwiększyć kontrolę i strategię w rozgrywce. Oto przykład, jak można zaimplementować zmienną wysokość skoku. Utwórz nowy plik o nazwie zmienna-jump.py oraz kod z poniższymi aktualizacjami:
GRAWITACJA = 0.5
JUMP_POWER_INCREMENT = 0.2
MAX_JUMP_POWER = 100klasaOkno gry(arkada. Okno):
pok__w tym__(samego siebie):
super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, „Mechanika skoków”)
self.jump_pressed = FAŁSZ
self.jump_power = 0pokon_key_press(ja, klucz, modyfikatory):
on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2Jeśli klucz == klucz.zręcznościowy. W GÓRĘ I self.player_y == na ziemi:
self.jump_pressed = PRAWDApokon_key_release(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. W GÓRĘ:
self.jump_pressed = FAŁSZpokaktualizacja_skoku_mocy(samego siebie):
# Zwiększ siłę skoku, gdy przycisk skoku jest wciśnięty
Jeśli self.jump_pressed:
self.jump_power += JUMP_POWER_INCREMENTJeśli self.jump_power > MAX_JUMP_POWER:
self.jump_power = MAX_JUMP_POWER
w przeciwnym razie:
Jeśli self.jump_power > 0:
self.jump_power -= 1pokw dniu_aktualizacji(ja, delta_czas):
self.player_dy -= GRAWITACJA
dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2Jeśli self.player_y == odległość I self.jump_power > 0:
self.player_dy = self.jump_power
self.player_y += self.player_dy
self.update_jump_power()
Implementacja funkcji Air Dash
Dodanie mechaniki doskoku w powietrzu może dać graczowi dodatkowe możliwości poruszania się w powietrzu. Utwórz nowy plik o nazwie air-dash.py oraz kod z poniższymi aktualizacjami:
AIR_DASH_DISTANCE = 100
MAX_AIR_DASHES = 2klasaOkno gry(arkada. Okno):
pok__w tym__(samego siebie):
super().__init__(SZEROKOŚĆ_EKRANU, WYSOKOŚĆ_EKRANU, „Mechanika skoków”)
siebie.na_ziemiu = FAŁSZ
self.air_kreski = 0
self.can_air_dash = PRAWDApokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. W GÓRĘ I sam.na_ziemiu:
sam.gracz_dy = 10
Elif klucz == klucz.zręcznościowy. W GÓRĘ I \
self.air_kreski < MAX_AIR_DASHES I \
self.can_air_dash:
self.player_dx = AIR_DASH_DISTANCE
self.air_kreski += 1
self.can_air_dash = FAŁSZpokw dniu_aktualizacji(ja, delta_czas):
self.player_dy -= GRAWITACJA
self.player_y += self.player_dydist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
Jeśli self.player_y <= odległość:
sam.gracz_y = odl
sam.gracz_dy = 0
siebie.na_ziemiu = PRAWDA
w przeciwnym razie:
siebie.na_ziemiu = FAŁSZsam.gracz_x += sam.gracz_dx
Jeśli self.player_x < PROMIEŃ_GRACZA:
self.player_x = PROMIEŃ_GRACZA
sam.gracz_dx = 0
Elif self.player_x > SCREEN_WIDTH – PLAYER_RADIUS:
self.player_x = SZEROKOŚĆ_EKRANU - PROMIEŃ_GRACZA
sam.gracz_dx = 0
Jeśli sam.na_ziemiu:
self.air_kreski = 0
self.can_air_dash = PRAWDA
Kiedy wykonasz doskok w powietrzu, twoja postać gracza odsunie się daleko od platformy:
Najlepsze praktyki dotyczące mechaniki skoków
Implementacja mechaniki skoków w grze wymaga starannego rozważenia, aby zapewnić płynną i przyjemną rozgrywkę. Oto kilka najlepszych praktyk, o których warto pamiętać:
Zrównoważ wysokość i czas trwania skoku
Aby zachować poczucie realizmu i trudności gry, ważne jest zrównoważenie wysokości i czasu trwania skoku. Zbyt wysoki lub zbyt krótki skok może negatywnie wpłynąć na rozgrywkę. Eksperymentuj z różnymi wysokościami i czasem trwania skoku, aby znaleźć odpowiednią równowagę dla swojej gry.
Podczas określania odpowiedniej mechaniki skoku weź pod uwagę fizykę gry, zdolności postaci i ogólny projekt poziomów.
Przekaż opinię wizualną i dźwiękową
Wizualne i dźwiękowe informacje zwrotne są kluczowe, aby skoki były responsywne i satysfakcjonujące. Użyj animacji lub efektów cząsteczkowych, aby zobrazować skoki i lądowania gracza.
Dodatkowo rozważ dodanie efektów dźwiękowych lub podkładu muzycznego co zwiększa wrażenia podczas skoków. Te wskazówki wizualne i dźwiękowe przyczyniają się do immersji i zaangażowania graczy.
Precyzyjne wykrywanie kolizji
Dokładne wykrywanie kolizji między graczem a platformami jest niezbędne dla precyzyjnej i niezawodnej mechaniki skoków. Upewnij się, że algorytm wykrywania kolizji jest solidny i prawidłowo radzi sobie z różnymi scenariuszami, takimi jak lądowanie na platformie, zderzenie z przeszkodami lub ślizganie się po ścianach.
Przetestuj i popraw swój kod wykrywania kolizji, aby wyeliminować wszelkie usterki lub niespójności, które mogą wpływać na mechanikę skoków.
Spraw, by gry były przyjemniejsze dzięki mechanice skoków
Dodanie mechaniki skoków może znacznie zwiększyć zaangażowanie i radość z gry. Otwiera nowe możliwości projektowania poziomów, łamigłówek i trudnych przeszkód. Implementując różne mechanizmy skoków w bibliotece gier Arcade w Pythonie, możesz tworzyć wciągające gry platformowe, które zapewnią graczom rozrywkę na wiele godzin.
Pamiętaj, że eksperymentowanie z różnymi mechanikami skoków i wprowadzanie unikalnych funkcji może wyróżnić Twoją grę i sprawić, że będzie ona wciągającym i niezapomnianym przeżyciem dla graczy.
