Jeśli Twoja gra nie jest bardzo krótka, warto zapisywać postępy. Nawet krótkie gry mogą zyskać na zapisaniu najlepszych wyników.
Dodanie systemu zapisywania i wczytywania do gry może znacznie poprawić wrażenia gracza. Pozwala graczom kontynuować postępy, wznawiać sesje gry i eksperymentować z różnymi strategiami bez utraty ciężko zdobytych osiągnięć.
Będziesz mile zaskoczony, jak łatwo można dodać tę funkcję do swojej gry za pomocą biblioteki Python Arcade.
Stwórz prostą grę
Zacznij od stworzenia prosta gra, w której gracz może się poruszać 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.
Utwórz nowy plik o nazwie prosta gra.py i dodaj poniższy kod:
import arkadaSZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
PRĘDKOŚĆ_GRACZA = 5
niebieski = arkadowy.kolor. NIEBIESKIklasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
super().__init__(szerokość, wysokość)
self.player_x = szerokość // 2pokon_draw(samego siebie):
arcade.start_render()
arcade.draw_rectangle_filled (self.game_state.player_x,
50, 50, 50, niebieski)pokaktualizacja(ja, delta_czas):
przechodzićpokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
self.player_x -= PRĘDKOŚĆ_GRACZA
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
self.player_x += PRĘDKOŚĆ_GRACZApokgłówny():
okno = okno gry (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Jeśli __nazwa__ == '__główny__':
główny()
Kod tworzy okno z niebieskim prostokątem reprezentującym gracza. Gracz może poruszać się w lewo iw prawo za pomocą klawiszy strzałek w lewo iw prawo.
Zarządzanie stanami gry
Aby wdrożyć system zapisywania i wczytywania, musisz zarządzać różnymi stanami gry. Stan gry reprezentuje bieżący stan gry, w tym pozycje obiektów, wyniki i inne istotne dane. W tym przykładzie skup się tylko na współrzędnej x gracza.
Aby zarządzać stanami gry, wprowadź a Stan gry class, która hermetyzuje dane gry i zapewnia metody ich zapisywania i ładowania. Oto kod:
klasaStan gry:
pok__w tym__(samego siebie):
sam.gracz_x = 0Zapisywanie danych gry
Aby zapisać dane gry, rozszerz plik Okno gry class i dodaj metodę zapisywania stanu gry w razie potrzeby. Dla uproszczenia użyj formatu JSON. Oto kod:
w Zapisz grę metoda, stworzyć słownik Pythona zawierające odpowiednie dane gry. Następnie serializuj go do pliku JSON o nazwie zapisz.json.
import jsonklasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
super().__init__(szerokość, wysokość)
self.game_state = GameState()pokZapisz grę(samego siebie):
dane = {
„gracz_x”: self.game_state.player_x
}
z otwarty(„zapisz.json”, „w”) Jak plik:
json.dump (dane, plik)
drukować (dane)pokon_draw(samego siebie):
arcade.start_render()
arcade.draw_rectangle_filled (self.game_state.player_x,
50, 50, 50, niebieski)pokaktualizacja(ja, delta_czas):
przechodzić
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
self.game_state.player_x -= PRĘDKOŚĆ_GRACZA
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
self.game_state.player_x += PLAYER_SPEED
Elif klucz == klucz.zręcznościowy. S:
self.save_game()
Ładowanie danych gry
Aby załadować dane gry, rozszerz plik Okno gry class dalej i dodaj metodę ładowania stanu gry. Utwórz nowy plik o nazwie ładuj-game.py i dodaj kod z poniższymi aktualizacjami:
klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
super().__init__(szerokość, wysokość)
self.game_state = GameState()
self.load_game()pokWczytaj grę(samego siebie):
próbować:
z otwarty(„zapisz.json”, 'R') Jak plik:
data = json.load (plik)
self.game_state.player_x = dane[„gracz_x”]
z wyjątkiem Błąd pliku, którego nie znaleziono:
przechodzić
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. L:
self.load_game()
The Wczytaj grę metoda próbuje otworzyć plik zapisz.json plik i pobierz dane gry. Następnie aktualizuje stan gry za pomocą załadowanych danych. Jeśli plik nie istnieje, możesz po prostu zignorować wyjątek, pozostawiając domyślny stan gry.
W tym dodatkowe funkcje
Możesz dodać więcej funkcji, aby ulepszyć system zapisywania i ładowania gry.
Zapisywanie najlepszych wyników
Zapisywanie najlepszych wyników wraz ze stanem gry jest powszechną cechą wielu gier. Możesz zarządzać punktacją i zapisz najlepszy wynik za pomocą tego systemu. Utwórz nowy plik o nazwie high-score.py i dodaj kod z poniższymi aktualizacjami:
klasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
super().__init__(szerokość, wysokość)
własny.wysoki_wynik = 0pokWczytaj grę(samego siebie):
próbować:
z otwarty(„zapisz.json”, 'R') Jak plik:
data = json.load (plik)
drukować (dane)
sam.gracz_x = dane.pobierz(„gracz_x”, sam.gracz_x)
self.high_score = data.get('wysoki wynik', własny.wysoki_wynik)
z wyjątkiem Błąd pliku, którego nie znaleziono:
przechodzićpokZapisz grę(samego siebie):
dane = {
„gracz_x”: sam.gracz_x,
'wysoki wynik': własny.wysoki_wynik
}
z otwarty(„zapisz.json”, „w”) Jak plik:
json.dump (dane, plik)
drukować (dane)
pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
self.player_x -= PRĘDKOŚĆ_GRACZA
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
self.player_x += PRĘDKOŚĆ_GRACZA
własny.wysoki_wynik += 1
Funkcja automatycznego zapisywania
Aby zapewnić graczom spokój ducha i zapobiec utracie postępów, możesz automatycznie zapisywać stan gry w regularnych odstępach czasu. Utwórz nowy plik o nazwie autozapis.py i dodaj kod z poniższymi aktualizacjami:
import czasklasaOkno gry(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
super().__init__(szerokość, wysokość)
self.game_state = GameState()# Zapisz co 6 sekund
self.autosave_interval = 6
self.last_save_time = czas.czas()pokaktualizacja(ja, delta_czas):
aktualny_czas = czas.czas()
różnica_czasu = bieżący_czas - własny.ostatni_zaoszczędzony_czas
Jeśli różnica_czasu >= self.autosave_interval:
self.save_game()
wydrukować(„Zapisane”)
self.last_save_time = aktualny_czas
W tym fragmencie kodu plik aktualizacja Metoda sprawdza, czy od ostatniego zapisu minął określony przedział czasu. Jeśli tak, uruchamia Zapisz grę metoda tzw Okno gry class, aby automatycznie zapisać stan gry. Poprawić odstęp_autozapisu wartość zgodnie z wymaganiami twojej gry.
Weryfikacja danych gry
Walidacja załadowanych danych gry jest niezbędna do zapewnienia ich integralności i spójności. Możesz łatwo włączyć sprawdzanie poprawności danych do naszego systemu zapisywania i ładowania:
klasaStan gry:
pok__w tym__(samego siebie):
sam.gracz_x = 0pokzapisz_stan(samego siebie):
Jeśli self.is_valid_state():
dane = {
„gracz_x”: sam.gracz_x
}z otwarty(„zapisz.json”, „w”) Jak plik:
json.dump (dane, plik)pokStan obciążenia(samego siebie):
z otwarty(„zapisz.json”, 'R') Jak plik:
data = json.load (plik)Jeśli self.validate_loaded_data (dane):
self.player_x = dane[„gracz_x”]
w przeciwnym razie:
wydrukować("Błąd!")pokjest_poprawny_stan(samego siebie):
# Wykonaj tutaj logikę sprawdzania poprawności
# Zwraca True, jeśli stan jest prawidłowy, w przeciwnym razie False
przechodzić
pokvalidate_loaded_data(ja, dane):
# Wykonaj walidację załadowanych danych
# Zwraca True, jeśli dane są prawidłowe, w przeciwnym razie False
przechodzić
Włączając te dodatkowe funkcje do systemu zapisywania i wczytywania, możesz stworzyć bardziej wszechstronną i solidną rozgrywkę doświadczenie, oferując graczom możliwość zapisywania wielu stanów gry, śledzenia najlepszych wyników, włączania automatycznego zapisywania i zapewniania danych uczciwość.
Najlepsze praktyki dotyczące systemu zapisywania i wczytywania
Implementacja systemu zapisywania i wczytywania jest ważnym aspektem tworzenia gier. Aby zapewnić solidny i niezawodny system, konieczne jest przestrzeganie najlepszych praktyk. Oto kilka kluczowych praktyk, które należy wziąć pod uwagę:
Szyfruj wrażliwe dane
Jeśli gra zawiera poufne informacje, takie jak hasła, dane osobowe lub zakupy w aplikacji, bardzo ważne jest zaszyfrowanie zapisanego stanu gry. Szyfrowanie dodaje dodatkową warstwę bezpieczeństwa, chroniąc prywatność gracza i zapobiegając nieautoryzowanemu dostępowi do jego danych. Korzystaj z algorytmów szyfrowania i bibliotek, aby chronić poufne informacje.
Sprawdź poprawność załadowanych danych
Przed załadowaniem danych gry należy je zweryfikować, aby zapewnić ich integralność i spójność. Sprawdź, czy załadowane dane są zgodne z oczekiwanym formatem, strukturą i ograniczeniami Twojej gry.
Przeprowadzaj kontrole poprawności krytycznych pól danych, aby uniknąć awarii lub oszukiwania. Implementuj solidne mechanizmy sprawdzania poprawności danych, aby obsłużyć potencjalne błędy lub nieoczekiwane dane.
Postępuj z błędami z wdziękiem
Podczas operacji wejścia/wyjścia na plikach mogą wystąpić błędy. Bardzo ważne jest, aby odpowiednio radzić sobie z tymi błędami i przekazywać graczowi komunikaty o błędach zawierające informacje. Łap i obsługuj wyjątki, takie jak Błąd pliku nie znaleziono Lub Błąd uprawnień, podczas operacji zapisywania i ładowania.
Wyświetlaj przyjazne dla użytkownika komunikaty o błędach, aby prowadzić graczy i zapobiegać frustracji. Ponadto rozważ wdrożenie rejestrowania błędów, aby pomóc w diagnozowaniu i rozwiązywaniu problemów.
Przetestuj funkcjonalność zapisywania i ładowania
Dokładnie przetestuj funkcje zapisywania i wczytywania swojej gry, aby zapewnić jej niezawodność i poprawność. Twórz przypadki testowe obejmujące różne scenariusze, takie jak zapisywanie w różnych stanach gry, ładowanie z prawidłowych i nieprawidłowych plików składowania oraz testowanie przypadków brzegowych.
Sprawdź, czy stan gry został prawidłowo zapisany i załadowany oraz czy występuje oczekiwane zachowanie. Ramy testów automatycznych mogą pomóc w tworzeniu kompleksowych zestawów testów.
Spraw, by gry były przyjemniejsze dzięki systemowi zapisywania i wczytywania
Dodanie systemu zapisywania i wczytywania może sprawić, że gry będą bardziej wciągające, dając graczom poczucie ciągłości i postępu. Gracze mogą swobodnie eksperymentować, próbować różnych podejść i wracać do gry później bez utraty swoich osiągnięć.
Ta funkcja pozwala również graczom rywalizować ze znajomymi lub rzucić sobie wyzwanie, aby pobić swoje poprzednie najlepsze wyniki, zwiększając powtarzalność i długoterminowe zaangażowanie w grę.
