Come implementare un sistema di dialogo in Pygame

L'implementazione di un sistema di dialogo in Pygame può migliorare notevolmente l'esperienza interattiva di un gioco. Un sistema di dialogo consente al gioco di presentare conversazioni, messaggi e scelte al giocatore, creando un gameplay più coinvolgente e coinvolgente.

La libreria Pygame fornisce gli strumenti necessari per creare un'interfaccia utente grafica (GUI) e gestire l'input dell'utente, rendendola la scelta ideale per implementare un sistema di dialogo.

Crea un gioco semplice

Prima di iniziare, assicurati di averlo pip installato sul tuo sistema. Utilizzare questo comando per installare il file pygame biblioteca:

pip installa pygame

Successivamente, inizia creando un semplice gioco in cui il giocatore può muoversi a destra ea sinistra evitando un nemico.

Il codice utilizzato in questo articolo è disponibile in this Deposito GitHub ed è gratuito per l'uso con la licenza MIT.

Il frammento di codice riportato di seguito imposta la finestra di gioco, inizializza le proprietà del giocatore e del nemico ed esegue il ciclo di gioco.

# Importa le librerie necessarie
importare pygame
da pygame.locals importare *
pygame.init()
# Imposta la finestra di gioco
screen_width, screen_height = 800, 600
schermo = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Il mio gioco")
# Definisci i colori
NERO = (0, 0, 0)
BIANCO = (255, 255, 255)
GRIGIO = (128, 128, 128)
# Proprietà del giocatore
giocatore_x = 400
giocatore_y = 500
player_speed = 5
# Proprietà nemiche
nemico_x = 400
nemico_y = 100
nemico_velocità = 3
correre = VERO
orologio = pygame.time. Orologio()
Mentre corsa:
per evento In pygame.event.get():
Se event.type == ESCI:
 correre = Falso
 chiavi = pygame.key.get_pressed()
# Movimento del giocatore
Se chiavi[K_LEFT] E giocatore_x > 0:
 player_x -= player_speed
Se chiavi[K_RIGHT] E player_x < larghezza_schermo - velocità_player:
 player_x += player_speed
# Aggiorna la posizione del nemico
 nemico_y += velocità_nemico
Se nemico_y > altezza_schermo:
 nemico_y = -50
# Controlla la collisione
Se pygame. Rect (giocatore_x, giocatore_y, 50, 50).colliderect (pygame. Rect (nemico_x, nemico_y, 50, 50)):
# Implementa qui la finestra di dialogo
passaggio
 screen.fill (NERO)
 pygame.draw.rect (schermo, BIANCO, (giocatore_x, giocatore_y, 50, 50))
 pygame.draw.rect (schermo, BIANCO, (nemico_x, nemico_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Di seguito è riportato l'output:

Crea finestra di dialogo

Per implementare una finestra di dialogo, devi visualizzarla ogni volta che il giocatore tocca il nemico. Aggiungi il dialog_box variabile, che controlla se la finestra di dialogo deve essere visualizzata o meno.

All'interno del ciclo di gioco, controlla la collisione tra il giocatore e il nemico, e se c'è una collisione, impostare dialog_box A VERO. All'interno della condizione in cui dialog_box È VERO, disegna un rettangolo grigio sullo schermo usando pygame.draw.rect() per rappresentare la finestra di dialogo.

Crea un nuovo file denominato dialogo.py e aggiungi il codice con i seguenti aggiornamenti:

# Proprietà della finestra di dialogo
dialog_box_width = 400
dialog_box_height = 200
dialog_box_x = (larghezza_schermo - dialog_box_width) // 2
dialog_box_y = (altezza_schermo - altezza_dialogo_box) // 2
dialog_box = Falso
# ...
Mentre corsa:
per evento In pygame.event.get():
Se event.type == ESCI:
 correre = Falso
 chiavi = pygame.key.get_pressed()
# Movimento del giocatore
Se chiavi[K_LEFT] E giocatore_x > 0:
 player_x -= player_speed
Se chiavi[K_RIGHT] E player_x < larghezza_schermo - velocità_player:
 player_x += player_speed
# Aggiorna la posizione del nemico
 nemico_y += velocità_nemico
Se nemico_y > altezza_schermo:
 nemico_y = -50
# Controlla la collisione
Se pygame. Rect (giocatore_x, giocatore_y, 50, 50).colliderect (pygame. Rect (nemico_x, nemico_y, 50, 50)):
 dialog_box = VERO
 screen.fill (NERO)
Se dialog_box:
 pygame.draw.rect (schermo, GRIGIO, (dialogue_box_x,
 dialog_box_y,
 dialog_box_width,
 dialog_box_altezza))

# Aggiungi qui testo di dialogo e pulsanti
altro:
 pygame.draw.rect (schermo, BIANCO, (giocatore_x, giocatore_y, 50, 50))
 pygame.draw.rect (schermo, BIANCO, (nemico_x, nemico_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Di seguito è riportato l'output:

Ora, per rendere la finestra di dialogo più funzionale e interattiva, puoi procedere ad aggiungere pulsanti e testo.

Aggiungi pulsanti usando la GUI di Python

Per aggiungere pulsanti alla finestra di dialogo, puoi utilizzare una libreria GUI Python come Pygame GUI o PySimpleGUI.

Installa e importa il file pygame_gui modulo, quindi creare un gestore GUI Pygame utilizzando pygame_gui. UIManager. Successivamente, crea un pulsante utilizzando il file UIButton classe fornita dalla libreria della GUI di Python.

All'interno del ciclo di gioco, aggiungi manager.update (pygame.time.get_ticks() / 1000.0) per aggiornare il gestore della GUI e manager.draw_ui (schermo) per disegnare gli elementi della GUI sullo schermo.

Crea un nuovo file denominato pulsanti.py e aggiungi il codice con i seguenti aggiornamenti:

importare pygame_gui 
# Gestore della GUI di Pygame
gestore = pygame_gui. Gestione interfaccia utente((larghezza_schermo, altezza_schermo))
# Crea un pulsante
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
pulsante = pygame_gui.elements. UIButton (relative_rect=pygame. Rett (pulsante_x, pulsante_y, larghezza_pulsante, altezza_pulsante),
 testo='Cliccami',
 amministratore=amministratore)
correre = VERO
orologio = pygame.time. Orologio()
Mentre corsa:
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 correre = Falso
 manager.process_events (evento)
 chiavi = pygame.key.get_pressed()
# Controlla la collisione
Se pygame. Rect (giocatore_x, giocatore_y, 50, 50).colliderect (pygame. Rect (nemico_x, nemico_y, 50, 50)):
 dialog_box = VERO
 screen.fill (NERO)
Se dialog_box:
 pygame.draw.rect (schermo, GRIGIO, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialog_box_altezza))
 manager.update (pygame.time.get_ticks() / 1000.0)
 manager.draw_ui (schermo)
altro:
 pygame.draw.rect (schermo, BIANCO, (giocatore_x, giocatore_y, 50, 50))
 pygame.draw.rect (schermo, BIANCO, (nemico_x, nemico_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Di seguito è riportato l'output:

Con queste modifiche, il pulsante ora dovrebbe essere visibile all'interno della finestra di dialogo quando appare.

Aggiungi testo usando la GUI di Python

Per visualizzare un testo personalizzato nella finestra di dialogo, puoi utilizzare la funzionalità di testo fornita dalla libreria GUI di Python.

Definire le proprietà del carattere utilizzando pygame.font. Font(). Creare un testo variabile con il contenuto desiderato, quindi eseguirne il rendering utilizzando il carattere e il colore specificati.

Crea un nuovo file denominato testo.py e aggiungi il codice con i seguenti aggiornamenti:

# Inizializza il gestore della GUI di Pygame
gestore = pygame_gui. Gestione interfaccia utente((larghezza_schermo, altezza_schermo))
# Definisci le proprietà dei caratteri
carattere = pygame.font. Font(Nessuno, 24)
text_color = NERO
# ...
Mentre corsa:
# ...
Se dialog_box:
 pygame.draw.rect (schermo, GRIGIO, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialog_box_altezza))
# Aggiungi testo alla finestra di dialogo
 testo = "Ciao, benvenuto nel gioco!"
 testo_reso = font.render (testo, VERO, colore del testo)
 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)

Di seguito è riportato l'output:

Comprese funzionalità aggiuntive

Oltre ai pulsanti e al testo, ci sono molte altre funzionalità che puoi considerare di aggiungere al tuo sistema di dialogo in Pygame. Ecco alcuni altri esempi:

Emozioni di carattere

Mostra emozioni o espressioni facciali per i personaggi durante il dialogo per trasmettere il loro stato d'animo o le loro reazioni. Ciò può essere ottenuto utilizzando sprite animati o sovrapposizioni di immagini che cambiano in base al contesto della conversazione.

Dialoghi condizionali

Usa istruzioni condizionali per attivare dialoghi specifici basati su determinati criteri, come i progressi del giocatore, le scelte precedenti o gli eventi di gioco. Ciò aggiunge profondità e interazioni personalizzate basate sulle azioni del giocatore.

Voci fuori campo

Migliora l'immersione del sistema di dialogo incorporando la recitazione vocale per i dialoghi dei personaggi. Riproduci clip audio in Pygame che corrispondono al testo visualizzato nella finestra di dialogo per dare ai personaggi una voce distinta.

Incorporando queste funzionalità aggiuntive, puoi creare un sistema di dialogo più dinamico e coinvolgente che migliora l'immersione del giocatore e offre un'esperienza di gioco unica.

Best practice per l'aggiunta di un sistema di dialogo

Quando si implementa un sistema di dialogo in Pygame, è importante seguire alcune best practice per garantire efficienza, manutenibilità e un'esperienza di gioco fluida. Di seguito sono riportate alcune best practice aggiuntive da considerare:

Usa la progettazione basata sui dati

Memorizza il contenuto del dialogo, inclusi testo, informazioni sul relatore e opzioni di dialogo, in file di dati esterni (ad es. JSON, XML). Ciò consente una facile modifica, localizzazione e gestione del contenuto del dialogo senza richiedere modifiche al codice.

Implementare un Dialog Manager

Crea una classe o un modulo dedicato al gestore di dialoghi che gestisca la logica per la gestione delle interazioni di dialogo. Ciò aiuta a mantenere il codice organizzato e consente una manutenzione e un'estensibilità più semplici.

Test di gioco e bilanciamento

Testare e bilanciare regolarmente il sistema di dialogo per garantire che i dialoghi scorrano in modo naturale, che le scelte abbiano conseguenze significative e che il ritmo sia in linea con l'esperienza di gioco complessiva. Raccogli feedback dai giocatori e ripeti il ​​contenuto e la struttura del dialogo per migliorare il coinvolgimento dei giocatori.

Supporto alla localizzazione

Progetta il sistema di dialogo tenendo presente la localizzazione fin dall'inizio. Separare le stringhe di testo dal codice e utilizzare file di lingua o librerie di localizzazione per supportare più lingue. Ciò consente una più facile traduzione e localizzazione del contenuto del dialogo.

Seguendo queste best practice, puoi assicurarti che il tuo sistema di dialogo sia ben progettato, efficiente e flessibile, consentendo una manutenzione e aggiornamenti più semplici man mano che il tuo gioco si evolve.

Rendi i giochi più coinvolgenti con il sistema di dialogo

L'aggiunta di un sistema di dialogo al tuo gioco può renderlo più coinvolgente consentendo ai giocatori di interagire con personaggi non giocanti (NPC), scoprire trame, fare scelte e ottenere informazioni preziose.

Ricorda di progettare attentamente la struttura dei dialoghi, utilizzare un approccio modulare e considerare l'integrazione di collezionabili e livelli per arricchire ulteriormente l'esperienza del giocatore.