Initiation à la programmation avec Python : Développez un simulateur de lancer de dés
Alors, c'est la nuit des jeux de rôle sur table, et tout le monde a son sac de dés, et toi, tu sors... ton ordinateur portable ? Eh bien, c'est le moment parfait pour montrer ce simulateur de lancer de dés que tu as construit en Python. Ce projet pour débutants devrait t'apprendre les bases des lancers de dés et de la randomisation.
Mise en place de notre projet
Ceci va être une configuration assez simple. J'ai déjà décrit comment nous avons configuré Visual Studio pour coder en Python, donc nous allons l'utiliser pour notre configuration de base. Nous allons garder cela aussi simple que possible, donc nous allons commencer par nos imports :
import tkinter as tk
from tkinter import ttk
import randomNous avons utilisé Tkinter auparavant lorsque nous avons construit notre simple suiveur de dépenses ; dans ce cas, c'est la solution la plus légère. La bibliothèque nous permet de créer une interface GUI simple, moderne et élégante à la fois. La bibliothèque random nous donne la fonctionnalité de randomiser des nombres entre deux valeurs, ce qui est l'essence d'un lancer de dé. Rendons les choses un peu plus jolies.
Considérations de conception avec nos faces de dés
Nous allons simuler un ensemble de dés de jeu de rôle. Pour un effet stylistique, j'ai rendu les dés à quatre faces (d4) et les dés à six faces (d6) un peu élégants pour démontrer la gestion de l'art ASCII avec Tkinter.
def __init__(self, root):
self.root = root
self.root.title("Dice Simulator")
self.root.geometry("400x500")
Dice face configurations using ASCII art
self.d4_faces = {
1: " ╱▲╲\n ╱ 1 ╲\n╱ ╲\n‾‾‾‾‾‾‾",
2: " ╱▲╲\n ╱ 2 ╲\n╱ ╲\n‾‾‾‾‾‾‾",
3: " ╱▲╲\n ╱ 3 ╲\n╱ ╲\n‾‾‾‾‾‾‾",
4: " ╱▲╲\n ╱ 4 ╲\n╱ ╲\n‾‾‾‾‾‾‾"
}
self.d6_faces = {
1: "┌─────────┐\n│ │\n│ ● │\n│ │\n└─────────┘",
2: "┌─────────┐\n│ ● │\n│ │\n│ ● │\n└─────────┘",
3: "┌─────────┐\n│ ● │\n│ ● │\n│ ● │\n└─────────┘",
4: "┌─────────┐\n│ ● ● │\n│ │\n│ ● ● │\n└─────────┘",
5: "┌─────────┐\n│ ● ● │\n│ ● │\n│ ● ● │\n└─────────┘",
6: "┌─────────┐\n│ ● ● │\n│ ● ● │\n│ ● ● │\n└─────────┘"
}
J'ai opté pour cela parce que je pensais qu'une interface graphique serait beaucoup plus attirante. Quand nous avons fait notre application de quiz, nous avons persévéré avec le terminal, mais j'aimerais un peu de style dans cette application. Ne vous inquiétez pas trop pour ce morceau de code. Tout ce qu'il fait, c'est afficher notre d6 avec une face comme un véritable d6, et c'est la même chose pour un d4. C'est aussi le début de notre interface graphique, avec le titre de l'application "Simulateur de Dés" affiché en haut de la fenêtre. Voyons comment nous allons faire notre saisie.
Nous voulons un espace pour que l'utilisateur puisse entrer le nombre et le type de dés qu'il souhaite lancer. Pour garder les choses simples, nous limiterons le nombre de dés à cinq, donc tout ce qui est supérieur à cela ne sera pas pris en charge. Notre interface utilisateur aura donc un sélecteur de dés (pour le type de dés) et un nombre d'entrées de dés si nous lançons plus d'un.
Je veux également mettre en place un système d'historique pour nos lancers, donc je vais le mettre en bas et le mettre à jour chaque fois que nous lançons un nouveau set de dés. Notre extrait de code devrait ressembler à quelque chose comme ça :
Create and configure the main frame
self.main_frame = ttk.Frame(self.root, padding="10")
self.main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
Number of dice selector
ttk.Label(self.main_frame, text="Number of Dice:").grid(row=0, column=0, pady=5)
self.num_dice = ttk.Spinbox(self.main_frame, from_=1, to=5, width=5)
self.num_dice.set(1)
self.num_dice.grid(row=0, column=1, pady=5)
Dice type selector
ttk.Label(self.main_frame, text="Dice Type:").grid(row=1, column=0, pady=5)
self.dice_type = ttk.Combobox(self.main_frame, values=["d4", "d6", "d8", "d12", "d20"], width=5)
self.dice_type.set("d6")
self.dice_type.grid(row=1, column=1, pady=5)
Roll button
self.roll_button = ttk.Button(self.main_frame, text="Roll Dice!", command=self.roll_dice)
self.roll_button.grid(row=2, column=0, columnspan=2, pady=10)
Results display
self.result_text = tk.Text(self.main_frame, height=15, width=40, font=('Courier', 10))
self.result_text.grid(row=3, column=0, columnspan=2, pady=10)
History display
ttk.Label(self.main_frame, text="Roll History:").grid(row=4, column=0, columnspan=2, pady=5)
self.history_text = tk.Text(self.main_frame, height=5, width=40)
self.history_text.grid(row=5, column=0, columnspan=2, pady=5)
self.roll_history = []
Create and configure the main frame
self.main_frame = ttk.Frame(self.root, padding="10")
self.main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
Number of dice selector
ttk.Label(self.main_frame, text="Number of Dice:").grid(row=0, column=0, pady=5)
self.num_dice = ttk.Spinbox(self.main_frame, from_=1, to=5, width=5)
self.num_dice.set(1)
self.num_dice.grid(row=0, column=1, pady=5)
Dice type selector
ttk.Label(self.main_frame, text="Dice Type:").grid(row=1, column=0, pady=5)
self.dice_type = ttk.Combobox(self.main_frame, values=["d4", "d6", "d8", "d12", "d20"], width=5)
self.dice_type.set("d6")
self.dice_type.grid(row=1, column=1, pady=5)
Roll button
self.roll_button = ttk.Button(self.main_frame, text="Roll Dice!", command=self.roll_dice)
self.roll_button.grid(row=2, column=0, columnspan=2, pady=10)
Results display
self.result_text = tk.Text(self.main_frame, height=15, width=40, font=('Courier', 10))
self.result_text.grid(row=3, column=0, columnspan=2, pady=10)
History display
ttk.Label(self.main_frame, text="Roll History:").grid(row=4, column=0, columnspan=2, pady=5)
self.history_text = tk.Text(self.main_frame, height=5, width=40)
self.history_text.grid(row=5, column=0, columnspan=2, pady=5)
self.roll_history = []Cela nous donne une configuration de base de l'interface utilisateur pour notre application de lancer de dés. Passons à la simulation des lancers.
Rouler des dés à travers un ordinateur
Si vous avez déjà joué à un jeu vidéo de rôle, vous avez expérimenté des lancers de dés simulés. Les dés influencent le déroulement des jeux de rôle sur table, leurs flux et reflux et ce qui arrive aux personnages. Un lancer de dé est un nombre aléatoire produit entre deux valeurs, un minimum et un maximum. En Python, nous pouvons utiliser la bibliothèque random pour simuler ces lancers. Voici notre code :
def roll_single_die(self, sides):
"""Simulate rolling a single die with given number of sides."""
return random.randint(1, sides)
def get_dice_face(self, value, dice_type):
"""Get ASCII art representation of a die face."""
if dice_type == 4:
return self.d4_faces.get(value, str(value))
elif dice_type == 6:
return self.d6_faces.get(value, str(value))
return str(value)
def roll_dice(self):
"""Handle the dice rolling action and update the display."""
try:
num_dice = int(self.num_dice.get())
dice_type = int(self.dice_type.get()[1:]) Extract number from 'd6', 'd20' etc.
Clear previous results
self.result_text.delete(1.0, tk.END)
Roll the dice and calculate total
rolls = [self.roll_single_die(dice_type) for _ in range(num_dice)]
total = sum(rolls)
Display results
if dice_type in [4, 6]: Show ASCII art for d4 and d6
for roll in rolls:
self.result_text.insert(tk.END, self.get_dice_face(roll, dice_type) + "\n")
else:
roll_str = ", ".join(str(roll) for roll in rolls)
self.result_text.insert(tk.END, f"Rolls: {roll_str}\n")
self.result_text.insert(tk.END, f"\nTotal: {total}")
Update history
roll_record = f"{num_dice}d{dice_type}: {rolls} = {total}"
self.roll_history.append(roll_record)
if len(self.roll_history) > 5: Keep only last 5 rolls
self.roll_history.pop(0)
Update history display
self.history_text.delete(1.0, tk.END)
for record in self.roll_history:
self.history_text.insert(tk.END, record + "\n")
except ValueError:
self.result_text.delete(1.0, tk.END)
self.result_text.insert(tk.END, "Please enter valid numbers")Cela nous fournit le code de base pour simuler nos lancers de dés. Pour faire fonctionner le programme, nous devons simplement appeler notre fonction principale :
if __name__ == "__main__":
root = tk.Tk()
app = DiceSimulator(root)
root.mainloop()Et cela devrait suffire. Nous avons maintenant un simulateur de lancer de dés !
Suggestions pour les mises à jour et les améliorations
Lorsque vous lancez l'application, vous devriez voir quelque chose comme ceci :
L'application a quelques limitations que j'ai intentionnellement omises pour vous offrir quelque chose pour étendre l'application. Il n'y a pas de support pour les d10 ou d100 (qui peuvent être simulés en lançant soit 2d10 soit 1d100). Vous pouvez les ajouter vous-même si vous souhaitez étendre l'application. De plus, vous pourriez transformer cela en un lanceur de dés en réseau et rendre l'interface utilisateur un peu plus joli avec quelques personnalisations. Comme d'habitude, tout le code de cette application est disponible sur mon GitHub. Tous les commentaires sur le code ou mon approche sont toujours les bienvenus.