Machen Sie Ihr Spielerlebnis noch intensiver, indem Sie ein Dialogsystem implementieren.

Die Implementierung eines Dialogsystems in Pygame kann das interaktive Erlebnis eines Spiels erheblich verbessern. Ein Dialogsystem ermöglicht es dem Spiel, dem Spieler Gespräche, Nachrichten und Auswahlmöglichkeiten zu präsentieren und so ein immersiveres und fesselnderes Gameplay zu schaffen.

Die Pygame-Bibliothek bietet die notwendigen Tools zum Erstellen einer grafischen Benutzeroberfläche (GUI) und zur Verarbeitung von Benutzereingaben, was sie zu einer idealen Wahl für die Implementierung eines Dialogsystems macht.

Erstellen Sie ein einfaches Spiel

Bevor Sie beginnen, stellen Sie sicher, dass Sie dies getan haben pip auf Ihrem System installiert. Verwenden Sie diesen Befehl, um die zu installieren Pygame Bibliothek:

Pip Pygame installieren

Beginnen Sie anschließend mit der Erstellung eines einfachen Spiels, bei dem sich der Spieler nach links und rechts bewegen und dabei einem Feind ausweichen kann.

instagram viewer

Der in diesem Artikel verwendete Code ist hier verfügbar GitHub-Repository Die Nutzung steht Ihnen unter der MIT-Lizenz kostenlos zur Verfügung.

Der folgende Codeausschnitt richtet das Spielfenster ein, initialisiert die Spieler- und Feindeigenschaften und führt die Spielschleife aus.

# Importieren Sie die erforderlichen Bibliotheken
importieren Pygame
aus pygame.locals importieren *
pygame.init()


# Richten Sie das Spielfenster ein
screen_width, screen_height = 800, 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Mein Spiel")


# Farben definieren
SCHWARZ = (0, 0, 0)
WEISS = (255, 255, 255)
GRAU = (128, 128, 128)


# Spielereigenschaften
Spieler_x = 400
player_y = 500
player_speed = 5


# Feindeigenschaften
feind_x = 400
feind_y = 100
feind_geschwindigkeit = 3


laufen = WAHR
Uhr = pygame.time. Uhr()


während Betrieb:
für Fall In pygame.event.get():
Wenn event.type == QUIT:
 laufen = FALSCH


 Schlüssel = pygame.key.get_pressed()


# Spielerbewegung
Wenn Tasten[K_LEFT] Und Spieler_x > 0:
 Spieler_x -= Spielergeschwindigkeit
Wenn Tasten[K_RIGHT] Und player_x < screen_width - player_speed:
 Spieler_x += Spielergeschwindigkeit


# Feindposition aktualisieren
 feind_y += feind_geschwindigkeit
Wenn feind_y > screen_height:
 feind_y = -50


# Kollision prüfen
Wenn Pygame. Rect (player_x, player_y, 50, 50).colliderect (pygame. Rect (Feind_x, Feind_y, 50, 50)):
# Dialogbox hier implementieren
passieren


 screen.fill (SCHWARZ)
 pygame.draw.rect (screen, WHITE, (player_x, player_y, 50, 50))
 pygame.draw.rect (Bildschirm, WEISS, (Feind_x, Feind_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Unten ist die Ausgabe:

Dialogfeld erstellen

Um ein Dialogfeld zu implementieren, müssen Sie es immer dann anzeigen, wenn der Spieler den Feind berührt. Ergänzen Sie die Dialog Box Variable, die steuert, ob das Dialogfeld angezeigt werden soll oder nicht.

Innerhalb der Spielschleife, Überprüfen Sie, ob es zu einer Kollision zwischen Spieler und Feind kommt, und wenn es zu einer Kollision kommt, setzen Dialog Box Zu WAHR. Innerhalb der Bedingung, wo Dialog Box Ist WAHR, zeichnen Sie mit ein graues Rechteck auf dem Bildschirm pygame.draw.rect() um das Dialogfeld darzustellen.

Erstellen Sie eine neue Datei mit dem Namen dialog.py und fügen Sie den Code mit den folgenden Updates hinzu:

# Eigenschaften des Dialogfelds
dialog_box_width = 400
dialog_box_height = 200
dialog_box_x = (screen_width - dialog_box_width) // 2
dialog_box_y = (screen_height - dialog_box_height) // 2
dialog_box = FALSCH
# ...
während Betrieb:
für Fall In pygame.event.get():
Wenn event.type == QUIT:
 laufen = FALSCH
 Schlüssel = pygame.key.get_pressed()
# Spielerbewegung
Wenn Tasten[K_LEFT] Und Spieler_x > 0:
 Spieler_x -= Spielergeschwindigkeit
Wenn Tasten[K_RIGHT] Und player_x < screen_width - player_speed:
 Spieler_x += Spielergeschwindigkeit
# Feindposition aktualisieren
 feind_y += feind_geschwindigkeit
Wenn feind_y > screen_height:
 feind_y = -50
# Kollision prüfen
Wenn Pygame. Rect (player_x, player_y, 50, 50).colliderect (pygame. Rect (Feind_x, Feind_y, 50, 50)):
 dialog_box = WAHR
 screen.fill (SCHWARZ)
Wenn Dialog Box:
 pygame.draw.rect (screen, GRAU, (dialogue_box_x,
 dialog_box_y,
 dialog_box_width,
 dialog_box_height))

# Fügen Sie hier Dialogtext und Schaltflächen hinzu
anders:
 pygame.draw.rect (screen, WHITE, (player_x, player_y, 50, 50))
 pygame.draw.rect (Bildschirm, WEISS, (Feind_x, Feind_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Unten ist die Ausgabe:

Um das Dialogfeld funktionaler und interaktiver zu gestalten, können Sie nun Schaltflächen und Text hinzufügen.

Fügen Sie Schaltflächen mithilfe der Python-GUI hinzu

Um dem Dialogfeld Schaltflächen hinzuzufügen, können Sie eine Python-GUI-Bibliothek wie Pygame GUI oder PySimpleGUI verwenden.

Installieren und importieren Sie die pygame_gui Modul und erstellen Sie dann einen Pygame-GUI-Manager mit pygame_gui. UIManager. Erstellen Sie anschließend eine Schaltfläche mit UIButton Klasse, die von der Python-GUI-Bibliothek bereitgestellt wird.

Fügen Sie innerhalb der Spielschleife hinzu manager.update (pygame.time.get_ticks() / 1000,0) um den GUI-Manager zu aktualisieren, und manager.draw_ui (Bildschirm) um die GUI-Elemente auf dem Bildschirm zu zeichnen.

Erstellen Sie eine neue Datei mit dem Namen Buttons.py und fügen Sie den Code mit den folgenden Updates hinzu:


importieren pygame_gui 
# Pygame GUI-Manager
manager = pygame_gui. UIManager((screen_width, screen_height))


# Erstellen Sie eine Schaltfläche
button_width = 100
button_height = 30
button_x = dialog_box_x + (dialogue_box_width - button_width) // 2
button_y = dialog_box_y + (dialogue_box_height - button_height) // 2
button = pygame_gui.elements. UIButton (relative_rect=pygame. Rect (button_x, button_y, button_width, button_height),
 text='Klick mich',
 Manager=Manager)


laufen = WAHR
Uhr = pygame.time. Uhr()


während Betrieb:
für Fall In pygame.event.get():
Wenn event.type == pygame. AUFHÖREN:
 laufen = FALSCH


 manager.process_events (Ereignis)


 Schlüssel = pygame.key.get_pressed()


# Kollision prüfen
Wenn Pygame. Rect (player_x, player_y, 50, 50).colliderect (pygame. Rect (Feind_x, Feind_y, 50, 50)):
 dialog_box = WAHR


 screen.fill (SCHWARZ)


Wenn Dialog Box:
 pygame.draw.rect (screen, GRAU, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialog_box_height))
 manager.update (pygame.time.get_ticks() / 1000.0)
 manager.draw_ui (Bildschirm)
anders:
 pygame.draw.rect (screen, WHITE, (player_x, player_y, 50, 50))
 pygame.draw.rect (Bildschirm, WEISS, (Feind_x, Feind_y, 50, 50))


 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Unten ist die Ausgabe:

Mit diesen Änderungen sollte die Schaltfläche jetzt im Dialogfeld sichtbar sein, wenn sie angezeigt wird.

Fügen Sie Text mithilfe der Python-GUI hinzu

Um benutzerdefinierten Text im Dialogfeld anzuzeigen, können Sie die Textfunktionalität der Python-GUI-Bibliothek verwenden.

Definieren Sie die Schriftarteigenschaften mit pygame.font. Schriftart(). Ein... kreieren Text Variable mit dem gewünschten Inhalt und rendern Sie sie dann mit der angegebenen Schriftart und Farbe.

Erstellen Sie eine neue Datei mit dem Namen text.py und fügen Sie den Code mit den folgenden Updates hinzu:


# Pygame GUI-Manager initialisieren
manager = pygame_gui. UIManager((screen_width, screen_height))
# Schriftarteigenschaften definieren
Schriftart = pygame.font. Schriftart(Keiner, 24)
text_color = SCHWARZ


# ...


während Betrieb:
# ...


Wenn Dialog Box:
 pygame.draw.rect (screen, GRAU, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialog_box_height))


# Fügen Sie dem Dialogfeld Text hinzu
 Text = „Hallo, willkommen im Spiel!“
 rendered_text = font.render (Text, WAHR, Textfarbe)
 text_rect = rendered_text.get_rect (center=(dialogue_box_x + dialog_box_width // 2,
 dialog_box_y + dialog_box_height // 2))
 screen.blit (rendered_text, text_rect)

Unten ist die Ausgabe:

Inklusive zusätzlicher Funktionen

Zusätzlich zu Schaltflächen und Text gibt es mehrere weitere Funktionen, die Sie Ihrem Dialogsystem in Pygame hinzufügen können. Hier noch ein paar Beispiele:

Charaktergefühle

Zeigen Sie den Charakteren während des Dialogs Emotionen oder Gesichtsausdrücke an, um deren Stimmung oder Reaktionen zu vermitteln. Dies kann durch die Verwendung animierter Sprites oder Bildüberlagerungen erreicht werden, die sich je nach Kontext der Konversation ändern.

Bedingte Dialoge

Verwenden Sie bedingte Anweisungen, um bestimmte Dialoge basierend auf bestimmten Kriterien auszulösen, z. B. dem Fortschritt des Spielers, früheren Entscheidungen oder Ereignissen im Spiel. Dies sorgt für mehr Tiefe und personalisierte Interaktionen basierend auf den Aktionen des Spielers.

Synchronaufnahme

Verbessern Sie das Eintauchen in das Dialogsystem, indem Sie Sprachausgabe für Charakterdialoge integrieren. Spielen Sie Audioclips in Pygame ab die mit dem im Dialogfeld angezeigten Text übereinstimmen, um den Charakteren eine eindeutige Stimme zu verleihen.

Durch die Integration dieser zusätzlichen Funktionen können Sie ein dynamischeres und ansprechenderes Dialogsystem erstellen, das die Immersion des Spielers verbessert und ein einzigartiges Spielerlebnis bietet.

Best Practices für das Hinzufügen eines Dialogsystems

Bei der Implementierung eines Dialogsystems in Pygame ist es wichtig, bestimmte Best Practices zu befolgen, um Effizienz, Wartbarkeit und ein reibungsloses Spielerlebnis sicherzustellen. Hier sind einige zusätzliche Best Practices, die Sie berücksichtigen sollten:

Nutzen Sie datengesteuertes Design

Speichern Sie Dialoginhalte, einschließlich Text, Sprecherinformationen und Dialogoptionen, in externen Datendateien (z. B. JSON, XML). Dies ermöglicht eine einfache Änderung, Lokalisierung und Verwaltung des Dialoginhalts, ohne dass Codeänderungen erforderlich sind.

Implementieren Sie einen Dialogmanager

Erstellen Sie eine spezielle Dialogmanagerklasse oder ein Modul, das die Logik für die Verwaltung von Dialoginteraktionen verwaltet. Dies trägt dazu bei, den Code organisiert zu halten und ermöglicht eine einfachere Wartung und Erweiterbarkeit.

Spieltests und Balancing

Testen und balancieren Sie das Dialogsystem regelmäßig, um sicherzustellen, dass die Dialoge natürlich ablaufen, Entscheidungen sinnvolle Konsequenzen haben und das Tempo mit dem gesamten Spielerlebnis übereinstimmt. Sammeln Sie Feedback von Spielern und wiederholen Sie den Inhalt und die Struktur des Dialogs, um das Engagement der Spieler zu verbessern.

Lokalisierungsunterstützung

Entwerfen Sie das Dialogsystem von Anfang an unter Berücksichtigung der Lokalisierung. Trennen Sie Textzeichenfolgen vom Code und verwenden Sie Sprachdateien oder Lokalisierungsbibliotheken, um mehrere Sprachen zu unterstützen. Dies ermöglicht eine einfachere Übersetzung und Lokalisierung des Dialoginhalts.

Indem Sie diese Best Practices befolgen, können Sie sicherstellen, dass Ihr Dialogsystem gut gestaltet, effizient und flexibel ist und eine einfachere Wartung und Aktualisierungen ermöglicht, während sich Ihr Spiel weiterentwickelt.

Machen Sie Spiele mit dem Dialogsystem ansprechender

Das Hinzufügen eines Dialogsystems zu Ihrem Spiel kann es spannender machen, indem es den Spielern ermöglicht, mit Nicht-Spieler-Charakteren (NPCs) zu interagieren, Handlungsstränge aufzudecken, Entscheidungen zu treffen und wertvolle Informationen zu erhalten.

Denken Sie daran, die Dialogstruktur sorgfältig zu gestalten, einen modularen Ansatz zu verwenden und die Integration von Sammlerstücken und Levels in Betracht zu ziehen, um das Spielerlebnis noch weiter zu bereichern.