Comment implémenter un système de dialogue dans Pygame

L'implémentation d'un système de dialogue dans Pygame peut grandement améliorer l'expérience interactive d'un jeu. Un système de dialogue permet au jeu de présenter des conversations, des messages et des choix au joueur, créant ainsi un gameplay plus immersif et engageant.

La bibliothèque Pygame fournit les outils nécessaires pour créer une interface utilisateur graphique (GUI) et gérer les entrées de l'utilisateur, ce qui en fait un choix idéal pour implémenter un système de dialogue.

Créer un jeu simple

Avant de commencer, assurez-vous d'avoir pip installé sur votre système. Utilisez cette commande pour installer le pygame bibliothèque:

pip installer pygame

Après cela, commencez par créer un jeu simple où le joueur peut se déplacer à gauche et à droite tout en évitant un ennemi.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.

L'extrait de code ci-dessous configure la fenêtre de jeu, initialise les propriétés du joueur et de l'ennemi et exécute la boucle de jeu.

# Importer les bibliothèques nécessaires
importer pygame
depuis pygame.locals importer *
pygame.init()
# Configurer la fenêtre de jeu
screen_width, screen_height = 800, 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Mon jeu")
# Définir les couleurs
NOIR = (0, 0, 0)
BLANC = (255, 255, 255)
GRIS = (128, 128, 128)
# Propriétés du joueur
joueur_x = 400
joueur_y = 500
player_speed = 5
# Propriétés ennemies
ennemi_x = 400
ennemi_y = 100
vitesse_ennemie = 3
courir = Vrai
horloge = pygame.heure. Horloge()
alors que en cours d'exécution:
pour événement dans pygame.event.get() :
si event.type == QUITTER :
 courir = FAUX
 clés = pygame.key.get_pressed()
# Mouvement du joueur
si touches[K_LEFT] et joueur_x > 0:
 joueur_x -= vitesse_joueur
si touches[K_RIGHT] et player_x < screen_width - player_speed :
 player_x += player_speed
# Mettre à jour la position de l'ennemi
 ennemi_y += vitesse_ennemie
si ennemi_y > screen_height :
 ennemi_y = -50
# Vérifier les collisions
si pygame. Rect (joueur_x, joueur_y, 50, 50).colliderect (pygame. Rect (ennemi_x, ennemi_y, 50, 50)):
# Mettre en œuvre la boîte de dialogue ici
passer
 screen.fill (NOIR)
 pygame.draw.rect (écran, BLANC, (player_x, player_y, 50, 50))
 pygame.draw.rect (écran, BLANC, (ennemi_x, ennemi_y, 50, 50))
 pygame.display.flip()
 horloge.tick(60)
pygame.quit()

Ci-dessous la sortie :

Créer une boîte de dialogue

Pour implémenter une boîte de dialogue, vous devez l'afficher chaque fois que le joueur touche l'ennemi. Ajouter le dialogue_box variable, qui contrôle si la boîte de dialogue doit être affichée ou non.

Dans la boucle du jeu, vérifier la collision entre le joueur et l'ennemi, et s'il y a une collision, définissez dialogue_box pour Vrai. Dans la condition où dialogue_box est Vrai, dessinez un rectangle gris sur l'écran en utilisant pygame.draw.rect() pour représenter la boîte de dialogue.

Créer un nouveau fichier nommé dialogue.py et ajoutez le code avec les mises à jour ci-dessous :

# Propriétés de la boîte de dialogue
dialogue_box_width = 400
dialogue_box_height = 200
dialogue_box_x = (screen_width - dialogue_box_width) // 2
dialogue_box_y = (hauteur_écran - dialogue_box_height) // 2
dialogue_box = FAUX
# ...
alors que en cours d'exécution:
pour événement dans pygame.event.get() :
si event.type == QUITTER :
 courir = FAUX
 clés = pygame.key.get_pressed()
# Mouvement du joueur
si touches[K_LEFT] et joueur_x > 0:
 joueur_x -= vitesse_joueur
si touches[K_RIGHT] et player_x < screen_width - player_speed :
 player_x += player_speed
# Mettre à jour la position de l'ennemi
 ennemi_y += vitesse_ennemie
si ennemi_y > screen_height :
 ennemi_y = -50
# Vérifier les collisions
si pygame. Rect (joueur_x, joueur_y, 50, 50).colliderect (pygame. Rect (ennemi_x, ennemi_y, 50, 50)):
 dialogue_box = Vrai
 screen.fill (NOIR)
si dialogue_box :
 pygame.draw.rect (écran, GRIS, (dialogue_box_x,
 dialogue_box_y,
 dialogue_box_width,
 dialogue_box_height))

# Ajoutez du texte de dialogue et des boutons ici
autre:
 pygame.draw.rect (écran, BLANC, (player_x, player_y, 50, 50))
 pygame.draw.rect (écran, BLANC, (ennemi_x, ennemi_y, 50, 50))
 pygame.display.flip()
 horloge.tick(60)
pygame.quit()

Ci-dessous la sortie :

Maintenant, pour rendre la boîte de dialogue plus fonctionnelle et interactive, vous pouvez continuer à ajouter des boutons et du texte.

Ajouter des boutons à l'aide de l'interface graphique Python

Pour ajouter des boutons à la boîte de dialogue, vous pouvez utiliser une bibliothèque Python GUI telle que Pygame GUI ou PySimpleGUI.

Installez et importez le pygame_gui module, puis créez un gestionnaire d'interface graphique Pygame à l'aide de pygame_gui. UIManager. Après cela, créez un bouton en utilisant le Bouton UI classe fournie par la bibliothèque Python GUI.

Dans la boucle de jeu, ajoutez manager.update (pygame.time.get_ticks() / 1000.0) pour mettre à jour le gestionnaire d'interface graphique, et manager.draw_ui (écran) pour dessiner les éléments de l'interface graphique à l'écran.

Créer un nouveau fichier nommé boutons.py et ajoutez le code avec les mises à jour ci-dessous :

importer pygame_gui 
# Gestionnaire d'interface graphique Pygame
gestionnaire = pygame_gui. UIManager((screen_width, screen_height))
# Créer un bouton
largeur_bouton = 100
hauteur_bouton = 30
button_x = dialogue_box_x + (dialogue_box_width - button_width) // 2
button_y = dialogue_box_y + (dialogue_box_height - button_height) // 2
bouton = pygame_gui.elements. UIButton (relative_rect=pygame. Rect (bouton_x, bouton_y, largeur_bouton, hauteur_bouton),
 texte='Cliquez-moi',
 gérant=gérant)
courir = Vrai
horloge = pygame.heure. Horloge()
alors que en cours d'exécution:
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX
 manager.process_events (événement)
 clés = pygame.key.get_pressed()
# Vérifier les collisions
si pygame. Rect (joueur_x, joueur_y, 50, 50).colliderect (pygame. Rect (ennemi_x, ennemi_y, 50, 50)):
 dialogue_box = Vrai
 screen.fill (NOIR)
si dialogue_box :
 pygame.draw.rect (écran, GRIS, (dialogue_box_x, 
 dialogue_box_y, 
 dialogue_box_width, 
 dialogue_box_height))
 manager.update (pygame.time.get_ticks() / 1000.0)
 manager.draw_ui (écran)
autre:
 pygame.draw.rect (écran, BLANC, (player_x, player_y, 50, 50))
 pygame.draw.rect (écran, BLANC, (ennemi_x, ennemi_y, 50, 50))
 pygame.display.flip()
 horloge.tick(60)
pygame.quit()

Ci-dessous la sortie :

Avec ces modifications, le bouton devrait maintenant être visible dans la boîte de dialogue lorsqu'il apparaît.

Ajouter du texte à l'aide de l'interface graphique Python

Pour afficher du texte personnalisé dans la boîte de dialogue, vous pouvez utiliser la fonctionnalité de texte fournie par la bibliothèque Python GUI.

Définissez les propriétés de la police à l'aide de pygame.font. Police de caractère(). Créer un texte variable avec le contenu souhaité, puis affichez-la en utilisant la police et la couleur spécifiées.

Créer un nouveau fichier nommé texte.py et ajoutez le code avec les mises à jour ci-dessous :

# Initialiser le gestionnaire d'interface graphique Pygame
gestionnaire = pygame_gui. UIManager((screen_width, screen_height))
# Définir les propriétés de la police
police = pygame.font. Police de caractère(Aucun, 24)
text_color = NOIR
# ...
alors que en cours d'exécution:
# ...
si dialogue_box :
 pygame.draw.rect (écran, GRIS, (dialogue_box_x, 
 dialogue_box_y, 
 dialogue_box_width, 
 dialogue_box_height))
# Ajouter du texte à la boîte de dialogue
 texte = "Bonjour, bienvenue dans le jeu !"
 render_text = font.render (texte, Vrai, text_color)
 text_rect = render_text.get_rect (center=(dialogue_box_x + dialogue_box_width // 2,
 dialogue_box_y + dialogue_box_height // 2))
 screen.blit (rendered_text, text_rect)

Ci-dessous la sortie :

Inclure des fonctionnalités supplémentaires

En plus des boutons et du texte, il existe plusieurs autres fonctionnalités que vous pouvez envisager d'ajouter à votre système de dialogue dans Pygame. Voici quelques exemples supplémentaires :

Émotions du personnage

Affichez les émotions ou les expressions faciales des personnages pendant le dialogue pour exprimer leur humeur ou leurs réactions. Ceci peut être réalisé en utilisant des sprites animés ou des superpositions d'images qui changent en fonction du contexte de la conversation.

Dialogues conditionnels

Utilisez des instructions conditionnelles pour déclencher des dialogues spécifiques en fonction de certains critères, tels que la progression du joueur, ses choix précédents ou des événements dans le jeu. Cela ajoute de la profondeur et des interactions personnalisées en fonction des actions du joueur.

Voix off

Améliorez l'immersion du système de dialogue en incorporant le doublage pour les dialogues des personnages. Lire des clips audio dans Pygame qui correspondent au texte affiché dans la boîte de dialogue pour donner aux personnages une voix distincte.

En incorporant ces fonctionnalités supplémentaires, vous pouvez créer un système de dialogue plus dynamique et engageant qui améliore l'immersion du joueur et offre une expérience de jeu unique.

Meilleures pratiques pour ajouter un système de dialogue

Lors de la mise en œuvre d'un système de dialogue dans Pygame, il est important de suivre certaines bonnes pratiques pour garantir l'efficacité, la maintenabilité et une expérience de jeu fluide. Voici quelques bonnes pratiques supplémentaires à prendre en compte :

Utiliser la conception basée sur les données

Stockez le contenu du dialogue, y compris le texte, les informations sur le locuteur et les options de dialogue, dans des fichiers de données externes (par exemple, JSON, XML). Cela permet une modification, une localisation et une gestion faciles du contenu du dialogue sans nécessiter de changements de code.

Implémenter un gestionnaire de dialogue

Créez une classe ou un module de gestionnaire de dialogue dédié qui gère la logique de gestion des interactions de dialogue. Cela aide à garder le code organisé et permet une maintenance et une extensibilité plus faciles.

Test de jeu et équilibrage

Testez et équilibrez régulièrement le système de dialogue pour vous assurer que les dialogues se déroulent naturellement, que les choix ont des conséquences significatives et que le rythme s'aligne sur l'expérience de jeu globale. Recueillez les commentaires des joueurs et modifiez le contenu et la structure du dialogue pour améliorer l'engagement des joueurs.

Prise en charge de la localisation

Concevez le système de dialogue en tenant compte de la localisation dès le début. Séparez les chaînes de texte du code et utilisez des fichiers de langue ou des bibliothèques de localisation pour prendre en charge plusieurs langues. Cela permet une traduction et une localisation plus faciles du contenu du dialogue.

En suivant ces meilleures pratiques, vous pouvez vous assurer que votre système de dialogue est bien conçu, efficace et flexible, permettant une maintenance et des mises à jour plus faciles à mesure que votre jeu évolue.

Rendre les jeux plus engageants avec le système de dialogue

L'ajout d'un système de dialogue à votre jeu peut le rendre plus attrayant en permettant aux joueurs d'interagir avec des personnages non-joueurs (PNJ), de découvrir des scénarios, de faire des choix et d'obtenir des informations précieuses.

N'oubliez pas de concevoir la structure de dialogue de manière réfléchie, d'utiliser une approche modulaire et d'envisager d'intégrer des objets de collection et des niveaux pour enrichir davantage l'expérience du joueur.