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 utilisateur, ce qui en fait un choix idéal pour la mise en œuvre d’un système de dialogue.
Créer un jeu simple
Avant de commencer, assurez-vous que pip est installé sur votre système. Utilisez cette commande pour installer le programme pygame bibliothèque :
pip install pygame
Ensuite, commencez par créer un jeu simple où le joueur peut se déplacer de gauche à droite tout en évitant un ennemi.
Le code utilisé dans cet article est disponible dans ce dépôt 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 du jeu.
# Import necessary libraries
import pygame
from pygame.locals import *
pygame.init()
# Set up the game window
screen_width, screen_height = 800, 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("My Game")
# Define colors
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (128, 128, 128)
# Player properties
player_x = 400
player_y = 500
player_speed = 5
# Enemy properties
enemy_x = 400
enemy_y = 100
enemy_speed = 3
running = True
clock = pygame.time.Clock()
while running:
for event in pygame.event.get():
if event.type == QUIT:
running = False
keys = pygame.key.get_pressed()
# Player movement
if keys[K_LEFT] and player_x > 0:
player_x -= player_speed
if keys[K_RIGHT] and player_x < screen_width - player_speed:
player_x += player_speed
# Update enemy position
enemy_y += enemy_speed
if enemy_y > screen_height:
enemy_y = -50
# Check collision
if pygame.Rect(player_x, player_y, 50, 50).colliderect(pygame.Rect(enemy_x, enemy_y, 50, 50)):
# Implement dialogue box here
pass
screen.fill(BLACK)
pygame.draw.rect(screen, WHITE, (player_x, player_y, 50, 50))
pygame.draw.rect(screen, WHITE, (enemy_x, enemy_y, 50, 50))
pygame.display.flip()
clock.tick(60)
pygame.quit()
Voici le résultat :
Créer une boîte de dialogue
Pour mettre en place une boîte de dialogue, il faut l’afficher dès que le joueur touche l’ennemi. Ajoutez l’élément boîte_de_dialogue qui détermine si la boîte de dialogue doit être affichée ou non.
A l’intérieur de la boucle de jeu, vérifier la collision entre le joueur et l’ennemi, et s’il y a une collision, définir la variable boîte_de_dialogue à Vrai. Dans la condition où dialogue_box est Vrai, dessinez un rectangle gris sur l’écran à l’aide de pygame.draw.rect() pour représenter la boîte de dialogue.
Créez un nouveau fichier nommé dialogue.py et ajoutez le code avec les mises à jour ci-dessous :
# Dialogue box properties
dialogue_box_width = 400
dialogue_box_height = 200
dialogue_box_x = (screen_width - dialogue_box_width) // 2
dialogue_box_y = (screen_height - dialogue_box_height) // 2
dialogue_box = False
# ...
while running:
for event in pygame.event.get():
if event.type == QUIT:
running = False
keys = pygame.key.get_pressed()
# Player movement
if keys[K_LEFT] and player_x > 0:
player_x -= player_speed
if keys[K_RIGHT] and player_x < screen_width - player_speed:
player_x += player_speed
# Update enemy position
enemy_y += enemy_speed
if enemy_y > screen_height:
enemy_y = -50
# Check collision
if pygame.Rect(player_x, player_y, 50, 50).colliderect(pygame.Rect(enemy_x, enemy_y, 50, 50)):
dialogue_box = True
screen.fill(BLACK)
if dialogue_box:
pygame.draw.rect(screen, GRAY, (dialogue_box_x,
dialogue_box_y,
dialogue_box_width,
dialogue_box_height))
# Add dialogue text and buttons here
else:
pygame.draw.rect(screen, WHITE, (player_x, player_y, 50, 50))
pygame.draw.rect(screen, WHITE, (enemy_x, enemy_y, 50, 50))
pygame.display.flip()
clock.tick(60)
pygame.quit()
Voici le résultat :
Maintenant, pour rendre la boîte de dialogue plus fonctionnelle et interactive, vous pouvez 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 comme Pygame GUI ou PySimpleGUI.
Installez et importez la bibliothèque pygame_gui puis créez un gestionnaire d’interface graphique Pygame en utilisant le module pygame_gui.UIManager. Ensuite, créez un bouton à l’aide de la commande UIButton fournie par la bibliothèque Python GUI.
A l’intérieur de la boucle du jeu, ajoutez manager.update(pygame.time.get_ticks() / 1000.0) pour mettre à jour le gestionnaire de l’interface graphique, et manager.draw_ui(screen) pour dessiner les éléments de l’interface graphique sur l’écran.
Créer un nouveau fichier nommé buttons.py et ajoutez le code avec les mises à jour ci-dessous :
import pygame_gui
# Pygame GUI manager
manager = pygame_gui.UIManager((screen_width, screen_height))
# Create a button
button_width = 100
button_height = 30
button_x = dialogue_box_x + (dialogue_box_width - button_width) // 2
button_y = dialogue_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='Click Me',
manager=manager)
running = True
clock = pygame.time.Clock()
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
manager.process_events(event)
keys = pygame.key.get_pressed()
# Check collision
if pygame.Rect(player_x, player_y, 50, 50).colliderect(pygame.Rect(enemy_x, enemy_y, 50, 50)):
dialogue_box = True
screen.fill(BLACK)
if dialogue_box:
pygame.draw.rect(screen, GRAY, (dialogue_box_x,
dialogue_box_y,
dialogue_box_width,
dialogue_box_height))
manager.update(pygame.time.get_ticks() / 1000.0)
manager.draw_ui(screen)
else:
pygame.draw.rect(screen, WHITE, (player_x, player_y, 50, 50))
pygame.draw.rect(screen, WHITE, (enemy_x, enemy_y, 50, 50))
pygame.display.flip()
clock.tick(60)
pygame.quit()
Voici le résultat :
Avec ces changements, le bouton devrait maintenant être visible à l’intérieur de la boîte de dialogue lorsqu’elle apparaît.
Ajouter du texte à l’aide de l’interface graphique de Python
Pour afficher un texte personnalisé dans la boîte de dialogue, vous pouvez utiliser la fonctionnalité de texte fournie par la bibliothèque Python GUI.
Définir les propriétés de la police en utilisant pygame.font.Font(). Créer une police texte avec le contenu souhaité, puis le rendre en utilisant la police et la couleur spécifiées.
Créer un nouveau fichier nommé text.py et ajoutez le code avec les mises à jour ci-dessous :
# Initialize Pygame GUI manager
manager = pygame_gui.UIManager((screen_width, screen_height))
# Define font properties
font = pygame.font.Font(None, 24)
text_color = BLACK
# ...
while running:
# ...
if dialogue_box:
pygame.draw.rect(screen, GRAY, (dialogue_box_x,
dialogue_box_y,
dialogue_box_width,
dialogue_box_height))
# Add text to the dialog box
text = "Hello, welcome to the game!"
rendered_text = font.render(text, True, text_color)
text_rect = rendered_text.get_rect(center=(dialogue_box_x + dialogue_box_width // 2,
dialogue_box_y + dialogue_box_height // 2))
screen.blit(rendered_text, text_rect)
Voici le résultat :
Inclure des fonctionnalités supplémentaires
En plus des boutons et du texte, il y a plusieurs autres fonctionnalités que vous pouvez envisager d’ajouter à votre système de dialogue dans Pygame. Voici quelques exemples supplémentaires :
Émotions des personnages
Affichez les émotions ou les expressions faciales des personnages au cours du dialogue afin de transmettre leur humeur ou leurs réactions. Pour ce faire, on peut utiliser 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, les choix précédents ou les événements du jeu. Cela permet d’ajouter 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 des voix off pour les dialogues des personnages. Jouez 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 plus engageant qui améliore l’immersion du joueur et offre une expérience de jeu unique.
Meilleures pratiques pour l’ajout d’un système de dialogue
Lors de l’implémentation d’un système de dialogue dans Pygame, il est important de suivre certaines bonnes pratiques pour assurer l’efficacité, la maintenabilité et une expérience fluide pour le joueur. Voici quelques bonnes pratiques supplémentaires à prendre en compte :
Utiliser une conception basée sur les données
Stocker 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 de modifier, de localiser et de gérer facilement le contenu du dialogue sans avoir à modifier le code.
Implémenter un gestionnaire de dialogue
Créez une classe ou un module dédié au gestionnaire de dialogue qui gère la logique de gestion des interactions de dialogue. Cela permet d’organiser le code et de faciliter la maintenance et l’extensibilité.
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 des dialogues afin d’améliorer l’engagement des joueurs.
Soutien à la localisation
Concevez le système de dialogue en tenant compte de la localisation dès le départ. 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 facilite la traduction et la localisation du contenu du dialogue.
En suivant ces bonnes pratiques, vous pouvez vous assurer que votre système de dialogue est bien conçu, efficace et flexible, ce qui facilitera la maintenance et les mises à jour au fur et à mesure de l’évolution de votre jeu.
Rendre les jeux plus attrayants grâce au 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 les personnages non joueurs (PNJ), de découvrir l’histoire, de faire des choix et d’obtenir des informations précieuses.
N’oubliez pas de concevoir la structure du dialogue de manière réfléchie, d’utiliser une approche modulaire et d’envisager d’intégrer des objets à collectionner et des niveaux pour enrichir l’expérience du joueur.
