Chcesz udoskonalić radzenie sobie z niebezpieczeństwami w grze? Zamień życie w zdrowie i dodaj dodatkowy wymiar do swojej rozgrywki.

Dodanie systemu zdrowia do gry zręcznościowej może poprawić wrażenia gracza i dodać dodatkową warstwę wyzwania i zaangażowania. Możesz stworzyć bardziej wciągającą rozgrywkę dzięki wyświetlaniu stanu zdrowia gracza oraz mechaniki obrażeń i leczenia.

Na szczęście wdrożenie systemu opieki zdrowotnej w Pythonie przy użyciu biblioteki Arcade jest proste i wymaga tylko kilku kroków.

Stwórz prostą grę

Pierwszy, zainstaluj pip na swoim urządzeniu i użyj poniższego polecenia, aby zainstalować bibliotekę arcade:

zręcznościowa instalacja pip

Następnie zacznij od stworzenia prostej gry przy użyciu biblioteki Arcade. Ta gra będzie zawierała postać gracza, która może poruszać się w lewo, w prawo, w górę iw dół oraz obiekt wroga, który stanowi zagrożenie dla gracza.

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

Utwórz nowy plik o nazwie prosta gra.py i dodaj poniższy kod:

instagram viewer 
import arkada
# Ustaw wymiary okna
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600


# Ustaw prędkość ruchu gracza
PLAYER_MOVEMENT_SPEED = 5
biały = arkadowy.kolor. BIAŁY
niebieski = arkadowy.kolor. NIEBIESKI
czerwony = arkadowy.kolor. CZERWONY


klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 arcade.set_background_color (biały)


# Twórz obiekty gracza i wroga
 sam.gracz = arkada. SpriteOkrąg(30, niebieski)
 wróg własny = arkada. SpriteOkrąg(30, czerwony)
 sam.gracz.centrum_x = 100
 self.player.center_y = 100
 self.enemy.center_x = 400
 self.enemy.center_y = 300


pokon_draw(samego siebie):
 arcade.start_render()
 sam.gracz.draw()
 własny.wróg.draw()


pokaktualizacja(ja, delta_czas):
przechodzić


pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 self.player.center_x -= PLAYER_MOVEMENT_SPEED
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 self.player.center_x += PLAYER_MOVEMENT_SPEED
Elif klucz == klucz.zręcznościowy. W GÓRĘ:
 self.player.center_y += PLAYER_MOVEMENT_SPEED
Elif klucz == klucz.zręcznościowy. W DÓŁ:
 self.player.center_y -= PLAYER_MOVEMENT_SPEED


pokgłówny():
 gra = okno gry (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
Jeśli __nazwa__ == "__główny__":
 główny()

Powinieneś zobaczyć okno zawierające dwa znaki, reprezentowane przez niebieskie i czerwone kółka:

Aby wdrożyć system opieki zdrowotnej, zdefiniuj zmienne i stałe związane ze zdrowiem. Posłużysz się nimi do śledzenia aktualnego stanu zdrowia gracza oraz ustalania zasad dotyczących obrażeń i leczenia. Dodaj następujący kod wewnątrz pliku Okno gry klasa:

klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
# ...
# Zmienne i stałe związane ze zdrowiem
 self.player_health = 100
# Punkty zdrowia leczone na sekundę
 własny.współczynnik_leczenia = 1


# Timer do leczenia
 self.heal_timer = 0


pokaktualizacja(ja, delta_czas):
# ...
# Zaktualizuj zegar leczenia
 self.heal_timer += delta_time


# Ulecz zdrowie gracza co 2 sekundy
Jeśli self.heal_timer >= 2:
 self.player_health += self.heal_rate
 self.heal_timer = 0
# Upewnij się, że zdrowie nie przekracza wartości maksymalnej
Jeśli self.player_health > 100:
 self.player_health = 100

Wdrażanie mechaniki obrażeń i leczenia

Aby zaimplementować mechanikę obrażeń i leczenia, wykrywanie kolizji między graczem a wrogiem. Zmniejsza zdrowie gracza, gdy zderza się z wrogiem i leczy zdrowie gracza co 2 sekundy, gdy nie zderzają się. Zmodyfikuj aktualizacja() metodę i dodaj następujący kod:

klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
# ...
pokaktualizacja(ja, delta_czas):
# Wykryj kolizje między graczem a wrogiem
Jeśli arcade.check_for_collision (samodzielny gracz, własny wróg):
 self.player_health -= 5
# ...

Zarządzanie scenariuszami śmierci gracza i zakończenia gry

Aby zarządzać scenariuszami śmierci gracza i końca gry, sprawdź, czy poziom zdrowia gracza wynosi zero lub mniej. Jeśli zdrowie spadnie do zera, uznaj gracza za martwego i zakończ grę. Zmodyfikuj aktualizacja() metoda z następującym kodem:

klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
# ...
pokaktualizacja(ja, delta_czas):
# ...


# Sprawdź, czy zdrowie gracza wynosi zero lub mniej
Jeśli self.player_health <= 0:
# Zakończ grę
 arcade.close_window()
# ...

Wizualizacja paska zdrowia

Wizualne przedstawienie stanu zdrowia gracza może znacznie poprawić wrażenia z gry. Utwórz pasek zdrowia za pomocą prostokątów, aby pokazać aktualny poziom zdrowia. Utwórz nowy plik o nazwie pasek zdrowia.py i dodaj kod z poniższymi aktualizacjami:

klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
# ...
pokon_draw(samego siebie):
 arcade.start_render()
 sam.gracz.draw()
 własny.wróg.draw()
 szary = arkadowy.kolor. JASNY SZARY
 zielony = arcade.kolor. ZIELONY


# Narysuj pasek zdrowia
 arcade.draw_rectangle_filled (SCREEN_WIDTH // 2, 20, 
 SZEROKOŚĆ_EKRANU, 20, szary)


 zdrowie_width = self.player_health / 100 * SZEROKOŚĆ_EKRANU
 arcade.draw_rectangle_filled (health_width // 2, 20, 
 szerokość_zdrowie, 20, zielony)

Poniżej znajduje się wyjście:

W tym dodatkowe funkcje

Możesz jeszcze bardziej udoskonalić system opieki zdrowotnej, dodając więcej funkcji, takich jak te poniżej.

Numeryczny wyświetlacz stanu zdrowia

Oprócz paska zdrowia możesz wyświetlić pozostałe zdrowie jako wartość liczbową na ekranie. Zapewnia to precyzyjne wskazanie stanu zdrowia gracza. Dodaj następujący kod wewnątrz pliku on_draw() metoda:

# Wewnątrz metody on_draw().
czarny = arkadowy.kolor. CZARNY
tekst = f"Zdrowie: {self.player_health}"
arcade.draw_text (tekst, 10, 10, czarny, 14)

Wzmacniacze zdrowia

Aby wprowadzić ulepszenia zdrowia, możesz tworzyć specjalne obiekty, które zwiększają zdrowie gracza, gdy się z nimi zderzają. Oto przykład implementacji tej funkcji:

# Wewnątrz metody update().
Jeśli arcade.check_for_collision (self.player, self.power_up):
 self.player_health += 20
# Usuń ulepszenie z gry
 self.power_up.kill()

Różne typy wrogów

Aby dodać głębi swojej grze, możesz wprowadzić różne typy wrogów, które zadają graczowi różne poziomy obrażeń. Dodaje to element strategiczny i pozwala na bardziej zróżnicowaną rozgrywkę. Oto implementacja tej funkcji:

# Wewnątrz metody update().
Jeśli arcade.check_for_collision (samodzielny gracz, własny wróg):
Jeśli typ.wroga.własnego == "słaby":
 self.player_health -= 5
Elif typ.wroga.własnego == "mocny":
 self.player_health -= 20

Włączając te dodatkowe funkcje do swojego systemu opieki zdrowotnej, możesz stworzyć bardziej dynamiczną i wymagającą rozgrywkę dla swoich graczy.

Najlepsze praktyki dla systemu opieki zdrowotnej

Podczas wdrażania systemu zdrowia w grze zręcznościowej ważne jest, aby postępować zgodnie z najlepszymi praktykami, aby system był solidny i wydajny. Oto kilka najlepszych praktyk, o których warto pamiętać:

Zrób to modułowo

Zachowaj funkcjonalność systemu opieki zdrowotnej w oddzielnej klasie lub module, aby zachować modułowość i łatwe ponowne użycie w różnych projektach gier. Sprzyja to organizacji kodu i separacji problemów.

Walidacja danych wejściowych i zabezpieczenia

Zaimplementuj sprawdzanie poprawności danych wejściowych, aby uniemożliwić kodowi przypisywanie nieprawidłowych wartości kondycji. Te same zabezpieczenia powinny chronić przed nieprawidłowymi wartościami zdrowia w przypadku uszkodzenia lub uzdrowienia.

Zapisz i załaduj mechanizm

Zaimplementuj mechanizm zapisywania i wczytywania, który obejmuje stan zdrowia gracza. Dzięki temu gracze mogą wznowić grę z nienaruszonym postępem, w tym zdrowiem, nawet po wyjściu z gry.

Testowanie i obsługa błędów

Dokładnie przetestuj wdrożenie Health System, aby zweryfikować jego poprawność i niezawodność. Używaj odpowiednich technik obsługi błędów, aby skutecznie obsługiwać wyjątki i przypadki brzegowe.

Spójne informacje zwrotne dotyczące zdrowia

Zapewnij graczowi spójną i jasną informację zwrotną na temat jego stanu zdrowia. Możesz dodać efekty dźwiękowe, wskazówki wizualne, a nawet dotykowe informacje zwrotne, dzięki którym gracze znają swój stan zdrowia w grze i mogą podejmować świadome decyzje podczas rozgrywki.

Postępując zgodnie z tymi najlepszymi praktykami, możesz stworzyć solidny i skuteczny system opieki zdrowotnej, który poprawi wrażenia z gry zręcznościowej, zachowując jednocześnie jakość i czytelność kodu.

Spraw, by gry były przyjemniejsze dzięki systemowi opieki zdrowotnej

Dodanie systemu zdrowia do gry może znacznie poprawić ogólne wrażenia gracza. Wprowadza element ryzyka i wyzwania, czyniąc rozgrywkę bardziej wciągającą i satysfakcjonującą.

Wizualna reprezentacja zdrowia pozwala graczom łatwo ocenić ich aktualny stan, zwiększając immersję i podejmowanie strategicznych decyzji.