Czytelnicy tacy jak ty pomagają wspierać MUO. Kiedy dokonujesz zakupu za pomocą linków na naszej stronie, możemy otrzymać prowizję partnerską. Czytaj więcej.

PyGame to popularna biblioteka do tworzenia projektów w Pythonie, która zapewnia potężny zestaw narzędzi do tworzenia gier. W tym artykule dowiesz się, jak stworzyć menu startowe i ekran zakończenia gry dla prostej gry przy użyciu PyGame.

Tworzenie prostej gry

Zanim utworzysz menu startowe i ekran końca gry, stwórzmy najpierw prostą grę. W tej grze będziesz sterować postacią za pomocą klawiszy strzałek i próbować omijać przeszkody. Aby uprościć sprawę, staraj się nie używać żadnych obrazów.

Aby rozpocząć, musisz zaimportować niezbędne moduły. Będziesz korzystać z pygame moduł dostępu do funkcji PyGame. Aby zainstalować moduł, możesz użyj menedżera pakietów pip:

pypeć zainstalować pygame

Teraz, gdy nasz moduł jest gotowy do użycia, stwórzmy prostą grę z graczem, który może poruszać się w lewo lub w prawo za pomocą klawiszy strzałek i przeszkody. Jeśli zderzysz się z przeszkodą, gra się skończy. Oto kod dla tego samego:

import pygame
pygame.w tym()
szerokość_ekranu = 750
wysokość_ekranu = 450
ekran = pygame.display.set_mode((szerokość_ekranu, wysokość_ekranu))


przeszkoda_x = 400
przeszkoda_y = 400
szerokość_przeszkody = 40
wysokość_przeszkody = 40
gracz_x = 200
gracz_y = 400
szerokość_gracza = 20
wysokość_gracza = 20


chwilaPRAWDA:

DowydarzenieWpygame.wydarzenie.Dostawać():

 if event.type == pygame. ZREZYGNOWAĆ:
pygame.zrezygnować()
 zrezygnować()



 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_LEFT]:
 gracz_x -= 5
JeśliKlucze[gra. K_PRAWO]:
 gracz_x += 5



 jeśli gracz_x + szerokość_gracza > przeszkoda_x i gracz_x < przeszkoda_x + szerokość_przeszkodyIgracz_y + wysokość_gracza > przeszkoda_y i gracz_y < przeszkoda_y + wysokość_przeszkody:
 koniec_gry = PRAWDA

ekran.wypełnić((0, 0, 0))
pygame.rysowaćprosto(ekran, (255, 0, 0), (przeszkoda_x, przeszkoda_y, szerokość_przeszkody, wysokość_przeszkody))
pygame.rysowaćprosto(ekran, (0, 255, 0), (gracz_x, gracz_y, szerokość_gracza, wysokość_gracza))
pygame.wyświetlacz.aktualizacja()

W powyższym kodzie skonfigurowałeś okno gry i zadeklarowałeś zmienne gry. Obsługiwałeś również wprowadzanie danych przez użytkownika i rysowałeś elementy na ekranie.

Tworzenie menu Start

Teraz, gdy masz podstawową grę, utwórzmy menu startowe. Aby to zrobić, musisz zadeklarować zmienną globalną dla stanu gry. Ta zmienna będzie śledzić bieżący stan gry, na przykład, czy menu startowe jest aktywne, czy gra jest uruchomiona. Musisz dodać tę zmienną na początku kodu gry:

stan_gry = "menu_początkowe"

Następnie dodasz funkcję rysowania menu startowego na ekranie. Możesz użyć funkcji PyGame do rysowania tekstu, przycisków i innych elementów na ekranie.

pokrysuj_menu_startowe():
ekran.wypełnić((0, 0, 0))
 czcionka = pygame.font. SysFont(„arialny”, 40)
 tytuł = czcionka. renderowanie ('Moja gra', PRAWDA, (255, 255, 255))
 przycisk_startu = czcionka.renderowanie('Początek', PRAWDA, (255, 255, 255))
 screen.blit (tytuł, (screen_width/2 - tytuł.get_width()/2, screen_height/2 - tytuł.get_height()/2))
 ekran.blit (przycisk_startu, (szerokość_ekranu/2 - przycisk_startu.get_width()/2, wysokość_ekranu/2 + przycisk_startu.get_wysokość()/2))
pygame.wyświetlacz.aktualizacja()

Następnie możesz dodać draw_start_menu() funkcji do głównej pętli gry.

chwilaPRAWDA: 
DowydarzenieWpygame.wydarzenie.Dostawać(): 
 if event.type == pygame. ZREZYGNOWAĆ:
pygame.zrezygnować()
 zrezygnować()
Jeśli stan_gry == "menu_początkowe":
 draw_start_menu()

Jeśli stan_gry == "gra":
 klucze = pygame.key.get_pressed()
#reszta kodu

Teraz menu startowe zostanie narysowane na ekranie. Ostatnim krokiem jest obsługa danych wprowadzonych przez użytkownika. Możesz dodaj instrukcję if do głównej pętli gry, aby sprawdzić, czy użytkownik nacisnął przycisk start.

Jeśli stan_gry == "menu_początkowe":
 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_SPACE]:
 gracz_x = 200
 gracz_y = 400
 stan_gry = "gra"
 koniec_gry = FAŁSZ

Dzięki temu kodowi gra rozpocznie się, gdy użytkownik naciśnie przycisk start.

Implementacja ekranu końca gry

Teraz, gdy masz już menu startowe, utwórzmy ekran końca gry. Ta funkcja powinna wyświetlać końcowy wynik i komunikat o zakończeniu gry.

pokremis_ekran_gry_nad_ekranem():
ekran.wypełnić((0, 0, 0))
 czcionka = pygame.font. SysFont(„arialny”, 40)
 tytuł = czcionka. renderowanie ('Koniec gry', PRAWDA, (255, 255, 255))
 przycisk_restartu = czcionka.renderowanie(„R — Uruchom ponownie”, PRAWDA, (255, 255, 255))
 przycisk_wyjdź = czcionka.renderuj(„Q - Zamknij”, PRAWDA, (255, 255, 255))
 screen.blit (tytuł, (screen_width/2 - tytuł.get_width()/2, screen_height/2 - tytuł.get_height()/3))
 screen.blit (restart_button, (screen_width/2 - restart_button.get_width()/2, screen_height/1.9 + restart_button.get_height()))
 screen.blit (quit_button, (screen_width/2 - quit_button.get_width()/2, screen_height/2 + quit_button.get_height()/2))
pygame.wyświetlacz.aktualizacja()

Następnie możesz dodać tę funkcję do głównej pętli gry.

Jeśli stan_gry == "menu_początkowe":
 draw_start_menu()
Jeśli stan_gry == "koniec gry":
 draw_game_over_screen()

Jeśli stan_gry == "gra":
 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_LEFT]:
 gracz_x -= 5
JeśliKlucze[gra. K_PRAWO]:
 gracz_x += 5

jeśli gracz_x + szerokość_gracza > przeszkoda_x i gracz_x < przeszkoda_x + szerokość_przeszkodyIgracz_y + wysokość_gracza > przeszkoda_y i gracz_y < przeszkoda_y + wysokość_przeszkody:
 koniec_gry = PRAWDA
 stan_gry = "koniec gry"

Wreszcie, musisz obsłużyć dane wejściowe użytkownika, aby obsłużyć wybór użytkownika. Możesz dodać instrukcję if do głównej pętli gry, aby sprawdzić, czy użytkownik nacisnął przycisk restartu lub wyjścia.

Jeśli stan_gry == "menu_początkowe":
 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_SPACE]:
 stan_gry = "gra"
 gracz_x = 200
 gracz_y = 400
 stan_gry = "gra"
 koniec_gry = FAŁSZ
Jeśli stan_gry == "koniec gry":
 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_r]:
 stan_gry = "menu_początkowe"
JeśliKlucze[gra. K_q]:
pygame.zrezygnować()
 zrezygnować()

Dzięki temu kodowi gra uruchomi się ponownie, gdy użytkownik naciśnie przycisk „R”, i wyjdzie, gdy użytkownik naciśnie przycisk „Q” na klawiaturze.

Poniżej pełny kod:

import pygame
pygame.w tym()
szerokość_ekranu = 750
wysokość_ekranu = 450
ekran = pygame.display.set_mode((szerokość_ekranu, wysokość_ekranu))
przeszkoda_x = 400
przeszkoda_y = 400
szerokość_przeszkody = 40
wysokość_przeszkody = 40
gracz_x = 200
gracz_y = 400
szerokość_gracza = 20
wysokość_gracza = 20
stan_gry = "menu_początkowe"


pokrysuj_menu_startowe():
ekran.wypełnić((0, 0, 0))
 czcionka = pygame.font. SysFont(„arialny”, 40)
 tytuł = czcionka. renderowanie ('Moja gra', PRAWDA, (255, 255, 255))
 przycisk_startu = czcionka.renderowanie('Początek', PRAWDA, (255, 255, 255))
 screen.blit (tytuł, (screen_width/2 - tytuł.get_width()/2, screen_height/2 - tytuł.get_height()/2))
 ekran.blit (przycisk_startu, (szerokość_ekranu/2 - przycisk_startu.get_width()/2, wysokość_ekranu/2 + przycisk_startu.get_wysokość()/2))
pygame.wyświetlacz.aktualizacja()


pokremis_ekran_gry_nad_ekranem():
ekran.wypełnić((0, 0, 0))
 czcionka = pygame.font. SysFont(„arialny”, 40)
 tytuł = czcionka. renderowanie ('Koniec gry', PRAWDA, (255, 255, 255))
 przycisk_restartu = czcionka.renderowanie(„R — Uruchom ponownie”, PRAWDA, (255, 255, 255))
 przycisk_wyjdź = czcionka.renderuj(„Q - Zamknij”, PRAWDA, (255, 255, 255))
 screen.blit (tytuł, (screen_width/2 - tytuł.get_width()/2, screen_height/2 - tytuł.get_height()/3))
 screen.blit (restart_button, (screen_width/2 - restart_button.get_width()/2, screen_height/1.9 + restart_button.get_height()))
 screen.blit (quit_button, (screen_width/2 - quit_button.get_width()/2, screen_height/2 + quit_button.get_height()/2))
pygame.wyświetlacz.aktualizacja()
chwilaPRAWDA:
DowydarzenieWpygame.wydarzenie.Dostawać():
 if event.type == pygame. ZREZYGNOWAĆ:
pygame.zrezygnować()
 zrezygnować()
Jeśli stan_gry == "menu_początkowe":
 draw_start_menu()
 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_SPACE]:
 gracz_x = 200
 gracz_y = 400
 stan_gry = "gra"
 koniec_gry = FAŁSZ
Elif stan_gry == "koniec gry":
 draw_game_over_screen()
 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_r]:
 stan_gry = "menu_początkowe"
JeśliKlucze[gra. K_q]:
pygame.zrezygnować()
 zrezygnować()

Elif stan_gry == "gra":
 klucze = pygame.key.get_pressed()
JeśliKlucze[gra. K_LEFT]:
 gracz_x -= 5
JeśliKlucze[gra. K_PRAWO]:
 gracz_x += 5

 jeśli gracz_x + szerokość_gracza > przeszkoda_x i gracz_x < przeszkoda_x + szerokość_przeszkodyIgracz_y + wysokość_gracza > przeszkoda_y i gracz_y < przeszkoda_y + wysokość_przeszkody:
 koniec_gry = PRAWDA
 stan_gry = "koniec gry"

ekran.wypełnić((0, 0, 0))
pygame.rysowaćprosto(ekran, (255, 0, 0), (przeszkoda_x, przeszkoda_y, szerokość_przeszkody, wysokość_przeszkody))
pygame.rysowaćprosto(ekran, (0, 255, 0), (gracz_x, gracz_y, szerokość_gracza, wysokość_gracza))
pygame.wyświetlacz.aktualizacja()

Elif koniec gry:
 stan_gry = "koniec gry"
 koniec_gry = FAŁSZ

Kod rozpoczyna się od zaimportowania pliku pygame moduł i inicjalizacja go. Następnie tworzy okno gry i deklaruje niezbędne zmienne gry, w tym pozycję gracza i przeszkody, wymiar i stan gry.

Kod definiuje dwie funkcje, draw_start_menu() I draw_game_over_screen(), aby narysować menu startowe i ekran zakończenia gry. Te funkcje wykorzystują funkcje PyGame do rysowania tekstu i przycisków na ekranie.

Główna pętla gry rozpoczyna się od obsługi zdarzeń i sprawdzenia stanu gry. Jeśli stan gry jest menu_początkowe, menu startowe jest rysowane na ekranie. Jeśli stan gry jest koniec gry, ekran końca gry zostanie przyciągnięty do ekranu. Jeśli stan gry jest inny, gra aktualizuje się i rysuje gracza oraz przeszkodę na ekranie.

Gra aktualizuje się, obsługując naciśnięcia klawiszy i sprawdzając kolizję między graczem a przeszkodą. Jeśli dojdzie do kolizji, gra ustawia koniec gry flaga do PRAWDA i ustawia stan gry na koniec gry.

Po zaktualizowaniu gry gracz i przeszkoda są rysowani na ekranie. Na koniec kod sprawdza, czy plik koniec gry flaga jest ustawiona, a jeśli tak, resetuje flagę i ustawia stan gry na koniec gry.

Ten proces jest powtarzany w sposób ciągły, aż do zamknięcia okna gry.

Zwiększ zaangażowanie użytkowników dzięki atrakcyjnemu wizualnie interfejsowi użytkownika

Korzystanie z dobrze zaprojektowanego interfejsu użytkownika (UI) może znacznie zwiększyć zaangażowanie użytkownika w grę PyGame. Przejrzysta i łatwa do odczytania czcionka, atrakcyjna wizualnie grafika, łatwa nawigacja i opinie użytkowników to ważne elementy, które należy wziąć pod uwagę podczas projektowania interfejsu użytkownika. Implementując te elementy, możesz stworzyć interfejs użytkownika, który pomoże utrzymać zainteresowanie gracza i zanurzyć się w grze.

Pamiętaj, aby przetestować swój interfejs i zebrać opinie od graczy, aby upewnić się, że skutecznie zwiększa zaangażowanie. Ogólnie rzecz biorąc, poświęcenie czasu na stworzenie silnego interfejsu użytkownika może znacznie poprawić wrażenia gracza i radość z gry.