Spraw, aby Twoja rozgrywka była bardziej wciągająca, wdrażając system dialogów.

Implementacja systemu dialogowego w Pygame może znacznie poprawić interaktywne wrażenia z gry. System dialogów pozwala grze przedstawiać graczowi rozmowy, wiadomości i wybory, tworząc bardziej wciągającą i wciągającą rozgrywkę.

Biblioteka Pygame zapewnia niezbędne narzędzia do tworzenia graficznego interfejsu użytkownika (GUI) i obsługi danych wprowadzanych przez użytkownika, co czyni ją idealnym wyborem do implementacji systemu dialogowego.

Stwórz prostą grę

Zanim zaczniesz, upewnij się, że masz pip zainstalowany w twoim systemie. Użyj tego polecenia, aby zainstalować pygame biblioteka:

pip zainstaluj pygame

Następnie zacznij od stworzenia prostej gry, w której gracz może poruszać się w lewo i prawo, unikając wroga.

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

Poniższy fragment kodu konfiguruje okno gry, inicjuje właściwości gracza i wroga oraz uruchamia pętlę gry.

instagram viewer 
# Importuj niezbędne biblioteki
import pygame
z pygame.locals import *
pygame.init()


# Skonfiguruj okno gry
szerokość_ekranu, wysokość_ekranu = 800, 600
ekran = pygame.display.set_mode((szerokość_ekranu, wysokość_ekranu))
pygame.display.set_caption("Moja gra")


# Zdefiniuj kolory
CZARNY = (0, 0, 0)
BIAŁY = (255, 255, 255)
SZARY = (128, 128, 128)


# Właściwości odtwarzacza
gracz_x = 400
gracz_y = 500
prędkość_gracza = 5


# Właściwości wroga
wróg_x = 400
wróg_y = 100
prędkość_wroga = 3


bieganie = PRAWDA
zegar = pygame.czas. Zegar()


chwila działanie:
Do wydarzenie W pygame.event.get():
Jeśli event.type == WYJDŹ:
 bieganie = FAŁSZ


 klucze = pygame.key.get_pressed()


# Ruch gracza
Jeśli klucze[K_LEFT] I gracz_x > 0:
 gracz_x -= prędkość_gracza
Jeśli klucze[K_RIGHT] I gracz_x < szerokość_ekranu - prędkość_gracza:
 gracz_x += prędkość_gracza


# Zaktualizuj pozycję wroga
 wróg_y += prędkość_wroga
Jeśli wróg_y > wysokość_ekranu:
 wróg_y = -50


# Sprawdź kolizję
Jeśli pygame. Prostokąt (gracz_x, gracz_y, 50, 50).colliderect (pygame. Prostokąt (wróg_x, wróg_y, 50, 50)):
# Zaimplementuj tutaj okno dialogowe
przechodzić


 ekran.wypełnienie (CZARNY)
 pygame.draw.rect (ekran, BIAŁY, (gracz_x, gracz_y, 50, 50))
 pygame.draw.rect (ekran, BIAŁY, (wróg_x, wróg_y, 50, 50))
 pygame.display.flip()
 zegar.tik(60)
pygame.quit()

Poniżej znajduje się wyjście:

Utwórz okno dialogowe

Aby zaimplementować okno dialogowe, musisz je wyświetlać za każdym razem, gdy gracz dotknie wroga. Dodaj dialog_box zmienna, która kontroluje, czy okno dialogowe powinno być wyświetlane, czy nie.

Wewnątrz pętli gry, sprawdź kolizję między graczem a wrogiem, a jeśli jest kolizja, ustaw dialog_box Do PRAWDA. W warunkach gdzie dialog_box Jest PRAWDA, narysuj szary prostokąt na ekranie za pomocą pygame.draw.rect() do reprezentowania okna dialogowego.

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

# Właściwości okna dialogowego
szerokość_okna dialogowego = 400
wysokość_okna dialogowego = 200
dialog_box_x = (szerokość_ekranu - szerokość_pola_dialogu) // 2
dialog_box_y = (ekran_wysokość - dialog_box_height) // 2
dialog_box = FAŁSZ
# ...
chwila działanie:
Do wydarzenie W pygame.event.get():
Jeśli event.type == WYJDŹ:
 bieganie = FAŁSZ
 klucze = pygame.key.get_pressed()
# Ruch gracza
Jeśli klucze[K_LEFT] I gracz_x > 0:
 gracz_x -= prędkość_gracza
Jeśli klucze[K_RIGHT] I gracz_x < szerokość_ekranu - prędkość_gracza:
 gracz_x += prędkość_gracza
# Zaktualizuj pozycję wroga
 wróg_y += prędkość_wroga
Jeśli wróg_y > wysokość_ekranu:
 wróg_y = -50
# Sprawdź kolizję
Jeśli pygame. Prostokąt (gracz_x, gracz_y, 50, 50).colliderect (pygame. Prostokąt (wróg_x, wróg_y, 50, 50)):
 dialog_box = PRAWDA
 ekran.wypełnienie (CZARNY)
Jeśli okno dialogowe:
 pygame.draw.rect (ekran, SZARY, (dialogue_box_x,
 dialog_box_y,
 szerokość_okna dialogowego,
 dialog_box_height))

# Dodaj tekst dialogu i przyciski tutaj
w przeciwnym razie:
 pygame.draw.rect (ekran, BIAŁY, (gracz_x, gracz_y, 50, 50))
 pygame.draw.rect (ekran, BIAŁY, (wróg_x, wróg_y, 50, 50))
 pygame.display.flip()
 zegar.tik(60)
pygame.quit()

Poniżej znajduje się wyjście:

Teraz, aby okno dialogowe było bardziej funkcjonalne i interaktywne, możesz przystąpić do dodawania przycisków i tekstu.

Dodaj przyciski za pomocą GUI Pythona

Aby dodać przyciski do okna dialogowego, możesz użyć biblioteki Python GUI, takiej jak Pygame GUI lub PySimpleGUI.

Zainstaluj i zaimportuj plik pygame_gui module, a następnie utwórz menedżera GUI Pygame za pomocą pygame_gui. Menedżer UIM. Następnie utwórz przycisk za pomocą Przycisk UI klasa udostępniana przez bibliotekę GUI Pythona.

Wewnątrz pętli gry dodaj manager.update (pygame.time.get_ticks() / 1000.0) zaktualizować menedżera GUI i manager.draw_ui (ekran) aby narysować elementy GUI na ekranie.

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


import pygame_gui 
# Menedżer GUI Pygame
menedżer = pygame_gui. UIManager((szerokość_ekranu, wysokość_ekranu))


# Utwórz przycisk
szerokość_przycisku = 100
wysokość_przycisku = 30
button_x = dialog_box_x + (szerokość_pola_dialogu - szerokość_przycisku) // 2
button_y = dialog_box_y + (dialog_box_height - button_height) // 2
button = pygame_gui.elements. UIButton (relative_rect=pygame. Prostokąt (przycisk_x, przycisk_y, szerokość_przycisku, wysokość_przycisku),
 tekst='Kliknij',
 kierownik = kierownik)


bieganie = PRAWDA
zegar = pygame.czas. Zegar()


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


 manager.process_events (zdarzenie)


 klucze = pygame.key.get_pressed()


# Sprawdź kolizję
Jeśli pygame. Prostokąt (gracz_x, gracz_y, 50, 50).colliderect (pygame. Prostokąt (wróg_x, wróg_y, 50, 50)):
 dialog_box = PRAWDA


 ekran.wypełnienie (CZARNY)


Jeśli okno dialogowe:
 pygame.draw.rect (ekran, SZARY, (dialogue_box_x, 
 dialog_box_y, 
 szerokość_okna dialogowego, 
 dialog_box_height))
 manager.update (pygame.time.get_ticks() / 1000.0)
 manager.draw_ui (ekran)
w przeciwnym razie:
 pygame.draw.rect (ekran, BIAŁY, (gracz_x, gracz_y, 50, 50))
 pygame.draw.rect (ekran, BIAŁY, (wróg_x, wróg_y, 50, 50))


 pygame.display.flip()
 zegar.tik(60)
pygame.quit()

Poniżej znajduje się wyjście:

Po tych zmianach przycisk powinien być teraz widoczny w oknie dialogowym, gdy się pojawi.

Dodaj tekst za pomocą GUI Pythona

Aby wyświetlić niestandardowy tekst w oknie dialogowym, możesz użyć funkcji tekstowej udostępnianej przez bibliotekę Python GUI.

Zdefiniuj właściwości czcionki za pomocą pygame.font. Czcionka(). Stwórz tekst zmienną o żądanej zawartości, a następnie wyrenderuj ją przy użyciu określonej czcionki i koloru.

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


# Zainicjuj menedżera GUI Pygame
menedżer = pygame_gui. UIManager((szerokość_ekranu, wysokość_ekranu))
# Zdefiniuj właściwości czcionki
czcionka = pygame.font. Czcionka(Nic, 24)
kolor_tekstu = CZARNY


# ...


chwila działanie:
# ...


Jeśli okno dialogowe:
 pygame.draw.rect (ekran, SZARY, (dialogue_box_x, 
 dialog_box_y, 
 szerokość_okna dialogowego, 
 dialog_box_height))


# Dodaj tekst do okna dialogowego
 tekst = "Cześć, witaj w grze!"
 renderowany_tekst = font.render (tekst, PRAWDA, kolor tekstu)
 text_rect = rendered_text.get_rect (center=(dialog_box_x + dialog_box_width // 2,
 dialog_box_y + dialog_box_height // 2))
 screen.blit (wyrenderowany_tekst, tekst_rekt)

Poniżej znajduje się wyjście:

W tym dodatkowe funkcje

Oprócz przycisków i tekstu istnieje kilka innych funkcji, które możesz rozważyć dodanie do swojego systemu dialogowego w Pygame. Oto kilka innych przykładów:

Emocje postaci

Wyświetlaj emocje lub mimikę postaci podczas dialogu, aby przekazać ich nastrój lub reakcje. Można to osiągnąć za pomocą animowanych duszków lub nakładek graficznych, które zmieniają się w zależności od kontekstu rozmowy.

Dialogi warunkowe

Używaj instrukcji warunkowych, aby uruchamiać określone dialogi w oparciu o określone kryteria, takie jak postępy gracza, poprzednie wybory lub wydarzenia w grze. To dodaje głębi i spersonalizowanych interakcji opartych na działaniach gracza.

Podkłady głosowe

Zwiększ immersję systemu dialogowego, włączając aktorstwo głosowe do dialogów postaci. Odtwarzaj klipy audio w Pygame pasujące do tekstu wyświetlanego w oknie dialogowym, aby nadać postaciom wyraźny głos.

Włączając te dodatkowe funkcje, możesz stworzyć bardziej dynamiczny i wciągający system dialogowy, który zwiększa zanurzenie gracza i zapewnia wyjątkowe wrażenia z gry.

Najlepsze praktyki dodawania systemu dialogu

Podczas wdrażania systemu dialogowego w Pygame ważne jest przestrzeganie pewnych najlepszych praktyk w celu zapewnienia wydajności, łatwości konserwacji i płynnego doświadczenia gracza. Oto kilka dodatkowych najlepszych praktyk do rozważenia:

Korzystaj z projektowania opartego na danych

Przechowuj treść dialogów, w tym tekst, informacje o mówcy i opcje dialogowe, w zewnętrznych plikach danych (np. JSON, XML). Pozwala to na łatwą modyfikację, lokalizację i zarządzanie treścią dialogów bez konieczności zmiany kodu.

Zaimplementuj menedżera dialogu

Utwórz dedykowaną klasę lub moduł menedżera dialogów, który obsługuje logikę zarządzania interakcjami dialogowymi. Pomaga to utrzymać porządek w kodzie i pozwala na łatwiejszą konserwację i rozszerzalność.

Testowanie i balansowanie

Regularnie testuj i balansuj system dialogów, aby upewnić się, że dialogi toczą się naturalnie, wybory mają znaczące konsekwencje, a tempo jest zgodne z ogólnymi wrażeniami z gry. Zbieraj opinie od graczy i modyfikuj treść i strukturę dialogów, aby zwiększyć zaangażowanie graczy.

Wsparcie lokalizacji

Od początku projektuj system dialogowy z myślą o lokalizacji. Oddziel ciągi tekstowe od kodu i użyj plików językowych lub bibliotek lokalizacyjnych do obsługi wielu języków. Pozwala to na łatwiejsze tłumaczenie i lokalizację treści dialogów.

Stosując się do tych najlepszych praktyk, możesz mieć pewność, że twój system dialogowy jest dobrze zaprojektowany, wydajny i elastyczny, co pozwala na łatwiejsze utrzymanie i aktualizacje w miarę rozwoju gry.

Spraw, aby gry były bardziej wciągające dzięki systemowi dialogów

Dodanie systemu dialogowego do gry może uczynić ją bardziej wciągającą, umożliwiając graczom interakcję z postaciami niezależnymi (NPC), odkrywanie wątków fabularnych, dokonywanie wyborów i zdobywanie cennych informacji.

Pamiętaj o przemyślanym zaprojektowaniu struktury dialogów, zastosowaniu podejścia modułowego i rozważeniu integracji elementów kolekcjonerskich i poziomów, aby jeszcze bardziej wzbogacić wrażenia gracza.