Dowiedz się, jak włączyć funkcję zapisywania i wczytywania postępu gry, aby zapewnić płynną rozgrywkę.

W nowoczesnym tworzeniu gier możliwość zapisywania i wczytywania postępów w grze jest kluczową funkcją, która zwiększa doświadczenie i zaangażowanie użytkownika. PyGame, popularna biblioteka do tworzenia gier 2D w Pythonie, zapewnia narzędzia niezbędne do bezproblemowego zaimplementowania funkcji zapisywania i ładowania.

Tworzenie prostej gry

Zanim zaczniesz, upewnij się, że masz pip zainstalowany na twoim urządzeniu. Po zainstalowaniu pip uruchom poniższe polecenie, aby zainstalować pygame moduł:

pip zainstaluj pygame

Aby zilustrować implementację systemu zapisu i ładowania w PyGame, zacznij od stworzenia prostej gry.

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

W tej grze gracz będzie miał możliwość poruszania się w lewo iw prawo. Oto przykładowy fragment kodu, który demonstruje podstawową strukturę gry:

import pygame
# Zainicjuj grę Pygame
pygame.init()







instagram viewer



# Skonfiguruj okno gry
szerokość_okna = 800
wysokość_okna = 600
okno = pygame.display.set_mode((szerokość_okna, wysokość_okna))
pygame.display.set_caption(„Samouczek dotyczący zapisywania i ładowania systemu”)


# Zmienne gry
gracz_x = 400
gracz_y = 500
prędkość_gracza = 5


# Pętla gry
bieganie = PRAWDA
chwila działanie:
Do wydarzenie W pygame.event.get():
Jeśli event.type == pygame. ZREZYGNOWAĆ:
 bieganie = FAŁSZ


 klucze = pygame.key.get_pressed()
Jeśli klucze [gra. K_LEWO]:
 gracz_x -= prędkość_gracza
Jeśli klucze [gra. K_PRAWO]:
 gracz_x += prędkość_gracza


# Wyczyść ekran
 okno.wypełnij((0, 0, 0))


# Narysuj gracza
 pygame.draw.rect (okno, (255, 255, 255), (gracz_x, gracz_y, 50, 50))


# Zaktualizuj wyświetlacz
 pygame.display.flip()
# Wyjdź z gry
pygame.quit()

Zarządzanie stanem gry i trwałością danych

Przed wdrożeniem funkcji zapisywania i wczytywania należy ustalić sposób zarządzania stanem gry i utrwalania danych. Jednym z powszechnych podejść jest użyj słownika Pythona do przechowywania odpowiednich danych gry. Oto przykład, jak możesz zmodyfikować poprzedni kod, aby uwzględnić zarządzanie stanem gry:

# Zmienne gry
stan_gry = {
„gracz_x”: 400,
„gracz_y”: 500
}
# Pętla gry
bieganie = PRAWDA
chwila działanie:
# ...


 klucze = pygame.key.get_pressed()
Jeśli klucze [gra. K_LEWO]:
 stan_gry[„gracz_x”] -= prędkość_gracza
Jeśli klucze [gra. K_PRAWO]:
 stan_gry[„gracz_x”] += prędkość_gracza


# ...
 pygame.display.flip()

Wdrażanie funkcji zapisywania i ładowania

Aby umożliwić zapisywanie i ładowanie postępów w grze, możesz wykorzystać wbudowane funkcje Pythona marynata moduł, który pozwala nam serializować i deserializować obiekty Pythona. Utwórz nowy plik o nazwie save-game.py i dodaj kod z poniższymi aktualizacjami:

stan_gry = {
„gracz_x”: gracz_x,
„gracz_y”: gracz_y
}
# Zapisz stan gry
pokzapisz_stan_gry(stan_gry, nazwa_pliku):
próbować:
z otwórz (nazwa_pliku, 'wb') Jak plik:
 pickle.dump (stan_gry, plik)
 wydrukować(„Stan gry został pomyślnie zapisany!”)
z wyjątkiem Błąd we/wy:
 wydrukować(„Błąd: nie można zapisać stanu gry”.)


# Załaduj stan gry
pokładowanie_stan_gry(Nazwa pliku):
próbować:
z otwórz (nazwa_pliku, „rb”) Jak plik:
 stan_gry = pickle.load (plik)
 wydrukować(„Stan gry został załadowany pomyślnie!”)
powrót stan_gry
z wyjątkiem (Błąd IO, marynata. Błąd wytrawiania):
 wydrukować(„Błąd: nie można załadować stanu gry”.)


# Pętla gry
bieganie = PRAWDA
chwila działanie:


# ...


 klucze = pygame.key.get_pressed()
Jeśli klucze [gra. K_LEWO]:
 gracz_x -= prędkość_gracza
 stan_gry[„gracz_x”] = gracz_x
Jeśli klucze [gra. K_PRAWO]:
 gracz_x += prędkość_gracza
 stan_gry[„gracz_x”] = gracz_x


Jeśli klucze [gra. K_s]:
 save_game_state (game_state, „save_game.pickle”)
Jeśli klucze [gra. K_l]:
 stan_gry = wczytaj stan_gry(„save_game.pickle”)
 gracz_x = stan_gry[„gracz_x”]

# ...
# ...

Poniżej znajduje się wyjście:

Projektowanie interfejsu użytkownika dla slotów zapisu

Aby udostępnić interfejs zapisywania i wczytywania, możesz wyświetlić miejsca zapisu, które pozwalają graczowi wybrać miejsce do zapisania lub wczytania. W tym przykładzie opcje są wyświetlane w konsoli, ale możesz ich użyć Frameworki GUI Pythona, aby stworzyć bardziej przyjazny dla użytkownika interfejs.

Stwórz zapisz_miejsca lista reprezentująca dostępne miejsca zapisu. Dodaj też A wybrane_slot zmienna do śledzenia slotu wybranego przez gracza.

Pokaż dostępne miejsca zapisu, gdy gracz naciśnie przycisk zapisu (K_s). Gracz może wybrać slot, naciskając odpowiedni klawisz numeryczny (K_1, K_2, Lub K_3). Jeśli wybrano gniazdo, stan gry jest zapisywany w pliku o nazwie odpowiadającej wybranemu slotowi.

Podobnie, gdy gracz naciśnie przycisk ładowania (K_l), wyświetl miejsca zapisu. Gracz może wybrać miejsce, naciskając klawisze K_a, K_b, Lub K_c aby załadować stan gry. Alternatywnie możesz korzystać z wejść dotykowych zamiast wprowadzania klawiatury do wyboru gniazda. Jeśli wybrano miejsce, stan gry jest ładowany z odpowiedniego pliku.

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

# Zmienne gry
miejsca_zapisz = [„Gniazdo 1”, „Gniazdo 2”, „Gniazdo 3”]
wybrane_slot = Nic
# Pętla gry
bieganie = PRAWDA
chwila działanie:
Do wydarzenie W pygame.event.get():
Jeśli event.type == pygame. ZREZYGNOWAĆ:
 bieganie = FAŁSZ


Jeśli event.type == pygame. KLAWIATURA:
Jeśli event.key == pygame. K_s:
# Pokaż miejsca na zapis
 wybrane_slot = Nic
Do ja, gniazdo W wyliczyć (save_slots):
 wydrukować(f „Zapisz miejsce {i+1}: {otwór}")
 wydrukować(„Wybierz miejsce, aby zapisać grę”.)


Jeśli event.key == pygame. K_l:
 wydrukować(„Wybierz gniazdo:- a — gniazdo 1, b — gniazdo 3, c — gniazdo 3”)
# Pokaż miejsca na zapis
 wybrane_slot = Nic
Do ja, gniazdo W wyliczyć (save_slots):
 wydrukować(f „Zapisz miejsce {i+1}: {otwór}")
 wydrukować(„Wybierz automat, aby załadować grę”.)


Jeśli zdarzenie.klucz W [gra. K_1, pygame. K_2, pygame. K_3]:
# Zapisz lub załaduj grę na podstawie wybranego gniazda
 slot_index = event.key - pygame. K_1
 wybrane_slot = zapisz_sloty[slot_index]

 save_game_state (game_state, F"{selected_slot}.marynata")
 wydrukować(f"Gra zapisana w {selected_slot}!")


Jeśli zdarzenie.klucz W [gra. K_a, pygame. K_b, pygame. K_c]:

 slot_index = event.key - pygame. K_a
 wybrane_slot = zapisz_sloty[slot_index]
 stan_gry = wczytaj stan_gry(F"{selected_slot}.marynata")
 gracz_x = stan_gry[„gracz_x”]
 wydrukować(f"Gra ładowana z {selected_slot}!")
# ...


 pygame.display.flip()
# ...

Poniżej znajduje się wyjście:

Uznanie autorstwa nie jest wymagane: zrzut ekranu: Imran

Obsługa opcji nadpisywania

Aby udostępnić opcje nadpisywania istniejących zapisów, możesz zaimplementować komunikat ostrzegawczy, który prosi gracza o potwierdzenie przed nadpisaniem pliku zapisu. Utwórz nowy plik o nazwie nadpisywanie-save.py i zmodyfikuj kod za pomocą poniższych aktualizacji:

# Zapisz stan gry
pokzapisz_stan_gry(stan_gry, nazwa_pliku):
Jeśli os.path.exists (nazwa_pliku):
# Prośba o potwierdzenie nadpisania istniejącego pliku składowania
 nadpisz = wejście („Plik zapisu już istnieje. Chcesz nadpisać? (t/n): ")
Jeśli nadpisz.lower() != „y”:
 wydrukować(„Zapisywanie zostało anulowane”.)
powrót
próbować:
z otwórz (nazwa_pliku, 'wb') Jak plik:
 pickle.dump (stan_gry, plik)
 wydrukować(„Stan gry został pomyślnie zapisany!”)
z wyjątkiem Błąd we/wy:
 wydrukować(„Błąd: nie można zapisać stanu gry”.)


# ...


# Załaduj stan gry
pokładowanie_stan_gry(Nazwa pliku):
Jeślinie os.path.exists (nazwa_pliku):
 wydrukować(„Błąd: plik zapisu nie istnieje”.)
powrótNic


próbować:
z otwórz (nazwa_pliku, „rb”) Jak plik:
 stan_gry = pickle.load (plik)
 wydrukować(„Stan gry został załadowany pomyślnie!”)
powrót stan_gry
z wyjątkiem (Błąd IO, marynata. Błąd wytrawiania):
 wydrukować(„Błąd: nie można załadować stanu gry”.)
powrótNic
# ...

W powyższym kodzie przed zapisaniem stanu gry sprawdzasz, czy plik zapisu już istnieje za pomocą os.ścieżka.istnieje(). Jeśli tak, poprosisz odtwarzacz o potwierdzenie nadpisania istniejącego pliku zapisu. Jeśli odtwarzacz zdecyduje się nie nadpisywać, operacja zapisywania zostanie anulowana.

Podobnie, przed załadowaniem stanu gry sprawdzasz, czy plik zapisu istnieje za pomocą os.ścieżka.istnieje(). Jeśli tak się nie stanie, poinformujesz o tym gracza komunikatem o błędzie.

Najlepsze praktyki dotyczące systemu zapisywania i ładowania

Wdrażając system zapisywania i ładowania w PyGame lub dowolnym projekcie tworzenia gier, weź pod uwagę następujące najlepsze praktyki:

  • Użyj dobrze zdefiniowanej struktury danych do reprezentowania stanu gry i zserializuj ją za pomocą biblioteki serializacji, takiej jak marynata. Pozwala to łatwo zapisać i załadować cały stan gry.
  • Utwórz dedykowany katalog lub folder do przechowywania zapisanych plików. Pomaga to uporządkować zapisane pliki i zapobiega zaśmiecaniu głównego katalogu gry.
  • Zaimplementuj obsługę błędów i dostarczaj informacyjne komunikaty o błędach, aby pomóc w debugowaniu i rozwiązywaniu problemów. Pomaga to graczom zrozumieć wszelkie problemy, które mogą wystąpić podczas operacji zapisywania i wczytywania.
  • Rozważ wprowadzenie wielu miejsc na zapisy, aby umożliwić graczom posiadanie wielu zapisów gry. Daje to graczom elastyczność w odkrywaniu różnych ścieżek lub odtwarzaniu określonych sekcji gry bez nadpisywania ich postępów.

Spraw, aby gry były bardziej wciągające dzięki systemowi zapisywania i wczytywania

Dodanie funkcji zapisywania i wczytywania może znacznie zwiększyć zaangażowanie i radość z gry. Pozwala graczom zapisywać swoje postępy i powracać do gry w dogodnym dla nich momencie. Ponadto otwiera możliwości tworzenia złożonych światów gry, w których wybory i działania graczy mają trwałe konsekwencje.

Wdrażając system zapisywania i wczytywania, możesz zapewnić swoim graczom bardziej wciągające i satysfakcjonujące wrażenia z gry.