Le jeu des tuiles de mémoire ou jeu d’association est un excellent moyen amusant de stimuler les capacités cognitives, d’améliorer la mémoire et la concentration. Le jeu comporte un ensemble de tuiles que vous devez retourner une à une, mémoriser et sélectionner celles qui correspondent. Si toutes les tuiles correspondent correctement, vous gagnez la partie.
Comment pouvez-vous développer ce jeu étonnant en utilisant Python ?
Les modules Tkinter et Random
Vous pouvez créer le jeu des tuiles de mémoire en utilisant les modules Tkinter et Random. Tkinter vous permet de créer des applications de bureau. Il offre une variété de widgets tels que des boutons, des étiquettes et des zones de texte qui facilitent le développement d’applications telles que des calendriers, des calculatrices et des listes de tâches. Pour installer Tkinter, ouvrez le terminal et exécutez :
pip install tkinter Le module Random est un module Python intégré utilisé pour générer des nombres pseudo-aléatoires. Grâce à lui, vous pouvez créer un générateur de mots de passe aléatoires, une application de simulation de lancer de dés ou un mélangeur de listes. En outre, vous pouvez également développer des jeux intéressants tels que le jeu de cricket et les jeux de devinettes.
Comment construire un jeu de tuiles de mémoire en utilisant Python
Vous pouvez trouver le code source pour construire le jeu des tuiles de mémoire en utilisant Python dans ce dépôt GitHub.
Commencez par importer le module Tkinter et le module Random. Initialisez la fenêtre racine et définissez le titre et les dimensions en pixels.
from tkinter import *
import random
from tkinter import messagebox
root = Tk()
root.title('Memory Tile Game')
root.geometry("760x550") Définir deux variables globales et initialiser la variable winner à zéro. Déclarez une liste d’éléments qui apparaîtront sur les tuiles. Réorganiser la liste à l’aide de la fonction shuffle() méthode. Définissez un cadre dans la fenêtre racine et ajoutez une marge de 10 dans la direction verticale.
Initialiser une variable count à 0 et déclarer respectivement une liste de réponses et un dictionnaire.
global winner, matches
winner = 0
matches = ["apple","apple","banana","banana", "orange","orange", "blueberry","blueberry","mulberry","mulberry", "grapes","grapes"]
random.shuffle(matches)
my_frame = Frame(root)
my_frame.pack(pady=10)
count = 0
answer_list = []
answer_dict = {} Définir une fonction, reset(). Définir le texte de l’étiquette à une chaîne vide à l’aide de la fonction config() fonction. Définir une liste de boutons, un pour chaque tuile. Interrogez la liste et définissez le texte du bouton à une chaîne vide, la couleur d’arrière-plan à la valeur par défaut (SystemButtonFace), et l’état redevient normal.
def reset():
my_label.config(text="")
button_list = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
for button in button_list:
button.config(text=" ", bg="SystemButtonFace", state="normal") Définir une fonction, win(). Définissez un message de victoire dans le paramètre texte de l’étiquette à l’aide de la fonction config() fonction. Définissez la liste des boutons comme précédemment et parcourez-la pour définir la couleur d’arrière-plan de la tuile en vert clair.
def win():
my_label.config(text="Congratulations! You Win!")
button_list = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
for button in button_list:
button.config(bg="#90EE90") Définir une fonction, button_click() qui prend le bouton et son numéro comme paramètres d’entrée. Faites référence aux variables globales, à la liste et au dictionnaire. Si le texte du bouton est égal à un espace et que le nombre est inférieur à deux, insérez et affichez le texte du bouton. Ajoutez le numéro du bouton à la liste des réponses et son nom au dictionnaire des réponses. Incrémenter la variable count de un.
def button_click(b, number):
global count, answer_list, answer_dict, winner
if b["text"] == ' ' and count < 2:
b["text"] = matches[number]
answer_list.append(number)
answer_dict[b] = matches[number]
count += 1 Si la longueur de la liste de réponses est de deux, cela signifie que l’utilisateur a sélectionné deux tuiles. Si le texte de la première tuile correspond à celui de l’autre, configurez l’étiquette pour qu’elle indique que les deux tuiles correspondent correctement. Désactivez le bouton. Mettez le compte à zéro et videz la liste et le dictionnaire. Incrémentez la variable winner de un et si elle vaut six, appelez la fonction win déclarée plus tôt.
if len(answer_list) == 2:
if matches[answer_list[0]] == matches[answer_list[1]]:
my_label.config(text="It's a Match!")
for key in answer_dict:
key["state"] = "disabled"
count = 0
answer_list = []
answer_dict = {}
winner += 1
if winner == 6:
win() Dans le cas contraire, réinitialisez la variable count et la liste. Afficher une boîte de message avec le titre et le contenu indiquant qu’il s’agit d’une correspondance incorrecte. Itérer sur la liste des réponses et mettre le texte de la tuile à un espace. Réinitialisez l’étiquette et videz le dictionnaire. Cela permet de s’assurer qu’il n’y a pas de texte visible sur le bouton et l’étiquette après que l’utilisateur a sélectionné des tuiles incorrectes.
else:
count = 0
answer_list = []
messagebox.showinfo("Incorrect!", "Incorrect")
for key in answer_dict:
key["text"] = " "
my_label.config(text=" ")
answer_dict = {} Définissez 12 boutons. Définissez la fenêtre parente dans laquelle vous souhaitez les placer, le texte qu’ils doivent afficher, le style de police qu’ils doivent avoir, leur hauteur et leur largeur, ainsi que la commande à exécuter lorsqu’ils sont cliqués. N’oubliez pas d’utiliser la fonction lambda pour transmettre les données à la fonction button_click() fonction. Définir la fonction secours paramètre à rainure pour créer un effet de profondeur en 3D autour du bouton.
b0 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b0, 0), relief="groove")
b1 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b1, 1), relief="groove")
b2 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b2, 2), relief="groove")
b3 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b3, 3), relief="groove")
b4 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b4, 4), relief="groove")
b5 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b5, 5), relief="groove")
b6 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b6, 6), relief="groove")
b7 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b7, 7), relief="groove")
b8 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b8, 8), relief="groove")
b9 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b9, 9), relief="groove")
b10 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b10, 10), relief="groove")
b11 = Button(my_frame, text=' ', font=("Helvetica", 20), height=4, width=8, command=lambda: button_click(b11, 11), relief="groove") Organisez les boutons dans un format tabulaire composé de trois lignes et de quatre colonnes à l’aide du gestionnaire de grille de Tkinter. Pour ce faire, appelez la fonction grid() et transmettez la ligne ainsi que le numéro de la colonne dans laquelle vous souhaitez la placer.
b0.grid(row=0, column=0)
b1.grid(row=0, column=1)
b2.grid(row=0, column=2)
b3.grid(row=0, column=3)
b4.grid(row=1, column=0)
b5.grid(row=1, column=1)
b6.grid(row=1, column=2)
b7.grid(row=1, column=3)
b8.grid(row=2, column=0)
b9.grid(row=2, column=1)
b10.grid(row=2, column=2)
b11.grid(row=2, column=3) Définissez une étiquette qui affiche une chaîne vide et ajoutez une marge de 20 dans le sens vertical. Définir un menu de premier niveau sur la fenêtre racine et l’attacher en tournant le bouton déchirure paramètre à Faux. Ajouter un élément de sous-menu, Options utilisation de l’option add_cascade paramètre.
Ajouter deux éléments de menu ainsi que les commandes qu’ils doivent exécuter lorsqu’ils sont cliqués dans le sous-menu nommé Réinitialiser le jeu et Exit Game. Ajoutez un séparateur entre les deux pour les délimiter.
my_label = Label(root, text="")
my_label.pack(pady=20)
my_menu = Menu(root)
root.config(menu=my_menu)
option_menu = Menu(my_menu, tearoff=False)
my_menu.add_cascade(label="Options", menu=option_menu)
option_menu.add_command(label="Reset Game", command=reset)
option_menu.add_separator()
option_menu.add_command(label="Exit Game", command=root.quit) Le mainloop() indique à Python de lancer la boucle d’événements Tkinter et d’écouter les événements jusqu’à ce que vous fermiez la fenêtre.
root.mainloop() Rassemblez tout le code. Le jeu de tuiles de mémoire est maintenant prêt à être joué.
Sortie du jeu des tuiles de mémoire
Lors de l’exécution du programme, 12 boutons apparaissent avec un texte vide ainsi que la mention Options menu. En cliquant sur Réinitialiser le jeu, la fenêtre apparaît de la même manière.
Lors de la sélection de deux tuiles correspondantes, les boutons apparaissent désactivés et l’étiquette indique que le choix est correct.
Lors de la sélection de deux tuiles qui ne correspondent pas, une boîte de message apparaît pour indiquer que la sélection était incorrecte. Les boutons et l’étiquette reviennent à leur état vide d’origine.
Lorsque tous les choix ont été faits, le programme transforme toutes les tuiles en vert et affiche le message de victoire.
Les jeux que vous pouvez construire en utilisant Python
Python offre une variété de modules pour construire des jeux. Pour créer des jeux simples basés sur des mots ou des choix, tels que le pendu, le morpion ou la pierre-papier-ciseaux, vous pouvez utiliser les modules Tkinter et Random. Pour développer des jeux plus graphiques, vous pouvez utiliser Pygame.
Pygame est un ensemble de modules Python qui fonctionne sur toutes les plateformes. Il comprend des bibliothèques d’images de synthèse et de sons qui rendent les jeux plus interactifs. Parmi les jeux que vous pouvez créer à l’aide de Pygame, citons le jeu du serpent, le jeu de mémoire et le Sudoku.
