Comment créer le jeu de tuiles de mémoire à l'aide de Python

La tuile de mémoire ou le jeu d'association est un excellent moyen amusant de stimuler les capacités cognitives, d'améliorer la mémoire et d'améliorer la concentration. Le jeu comporte un ensemble de tuiles que vous devez retourner une par une, mémoriser et sélectionner celles qui correspondent. En faisant correspondre toutes les tuiles correctement, vous gagnez la partie.

Alors, comment pouvez-vous développer ce jeu incroyable en utilisant Python ?

Les modules Tkinter et Random

Vous pouvez créer le jeu de tuiles de mémoire à l'aide des 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 développer des applications comme des calendriers, des calculatrices et des listes de tâches. Pour installer Tkinter, ouvrez le terminal et exécutez :

pip installer tkinter

Le module Random est un module Python intégré utilisé pour générer des nombres pseudo-aléatoires. En utilisant ceci,

vous pouvez créer un générateur de mot de passe aléatoire, une application de simulation de lancer de dés ou un mélangeur de liste. De plus, vous pouvez également développer des jeux intéressants comme le hand cricket et jeux de devinettes.

Comment créer le jeu de tuiles de mémoire à l'aide de Python

Vous pouvez trouver le code source pour construire le jeu de tuiles de mémoire en utilisant Python dans ce Référentiel GitHub.

Commencez par importer le Tkinter et le module Random. Initialisez la fenêtre racine et définissez le titre et les dimensions en pixels.

depuis tkinter importer *
importer aléatoire
depuis tkinter importer messagerie
racine = Tk()
racine.titre("Jeu de tuiles de mémoire")
root.geometry("760x550")

Définissez deux variables globales et initialisez la variable gagnante à zéro. Déclarez une liste d'éléments qui apparaîtront sur les tuiles. Réorganisez la liste en utilisant les modules aléatoires mélanger() méthode. Définissez un cadre dans la fenêtre racine et ajoutez un remplissage de 10 dans le sens vertical.

Initialisez une variable de comptage à 0 et déclarez respectivement une liste de réponses et un dictionnaire.

mondial gagnant, matchs
gagnant = 0
correspondances = ["pomme","pomme","banane","banane", "orange","orange", "myrtille","myrtille","mûre","mûre", "raisins","raisins"]
random.shuffle (correspondances)
my_frame = Cadre (racine)
my_frame.pack (pady=10)
compter = 0
liste_réponses = []
answer_dict = {}

Définir une fonction, réinitialiser(). Définissez le texte de l'étiquette sur une chaîne vide à l'aide de la config() fonction. Définissez une liste de boutons, un pour chacune des vignettes. Parcourez la liste et définissez le texte sur la vignette du bouton sur une chaîne vide, la couleur d'arrière-plan par défaut (SystemButtonFace), et l'état à la normale.

définitivementréinitialiser():
 mon_étiquette.config (texte="")
 liste_boutons = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
pour bouton dans liste_boutons :
 bouton.config (texte=" ", bg="SystemButtonFace", état="normal")

Définir une fonction, gagner(). Définissez un message gagnant dans le paramètre texte de l'étiquette à l'aide de la 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 vignette sur vert clair.

définitivementgagner():
 mon_étiquette.config (texte="Toutes nos félicitations! Vous gagnez!")
 liste_boutons = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
pour bouton dans liste_boutons :
 bouton.config (bg="#90EE90")

Définir une fonction, bouton_clic() qui prend le bouton et son numéro comme paramètres d'entrée. Référencez les variables globales, la liste et le 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 de réponses et le nom au dictionnaire de réponses. Incrémentez la variable count de un.

définitivementbouton_clic(b, nombre):
mondial compter, answer_list, answer_dict, gagnant
si b["texte"] == ' 'et compter < 2:
 b["texte"] = correspondances[nombre]
 answer_list.append (numéro)
 answer_dict[b] = correspond[nombre]
 compter += 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 vignette correspond à l'autre, configurez l'étiquette pour afficher que les deux correspondent correctement. Mettez l'état du bouton sur désactivé. Définissez le décompte sur zéro et videz la liste et le dictionnaire. Incrémentez la variable winner de un et si elle devient six, appelez la fonction win déclarée précédemment.

si len (liste_réponses) == 2:
si correspond[answer_list[0]] == correspond[answer_list[1]]:
 mon_étiquette.config (texte="C'est un match!")
pour clé dans answer_dict :
 clé["État"] = "désactivé"
 compter = 0
 liste_réponses = []
 answer_dict = {}
 gagnant += 1
si gagnant == 6:
 gagner()

Sinon, réinitialisez la variable count et la liste. Afficher une boîte de message avec le titre et le contenu le décrivant comme une correspondance incorrecte. Parcourez la liste de réponses et définissez le texte de la vignette sur un espace. Réinitialisez l'étiquette et videz le dictionnaire. Cela garantit 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.

autre:
 compter = 0
 liste_réponses = []
 messagebox.showinfo("Incorrect!", "Incorrect")
pour clé dans answer_dict :
 clé["texte"] = " "
 mon_étiquette.config (texte=" ")
 answer_dict = {}

Définir 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 lorsque vous cliquez dessus. N'oubliez pas d'utiliser la fonction lambda pour transmettre les données au bouton_clic() fonction. Met le relief paramètre à rainure pour créer un effet de profondeur 3D autour du bouton.

b0 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b0, 0), relief="rainure")
b1 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b1, 1), relief="rainure")
b2 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b2, 2), relief="rainure")
b3 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b3, 3), relief="rainure")
b4 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b4, 4), relief="rainure")
b5 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b5, 5), relief="rainure")
b6 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b6, 6), relief="rainure")
b7 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b7, 7), relief="rainure")
b8 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b8, 8), relief="rainure")
b9 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b9, 9), relief="rainure")
b10 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b10, 10), relief="rainure")
b11 = Bouton (my_frame, text=' ', police=("Helvética", 20), hauteur=4, largeur=8, commande=lambda: bouton_clic (b11, 11), relief="rainure")

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 le grille() méthode et transmettez la ligne avec le numéro de colonne dans laquelle vous souhaitez la placer.

b0.grid (ligne=0, colonne=0)
b1.grid (ligne=0, colonne=1)
b2.grid (ligne=0, colonne=2)
b3.grid (ligne=0, colonne=3)
b4.grid (ligne=1, colonne=0)
b5.grid (ligne=1, colonne=1)
b6.grid (ligne=1, colonne=2)
b7.grid (ligne=1, colonne=3)
b8.grid (ligne=2, colonne=0)
b9.grid (ligne=2, colonne=1)
b10.grid (ligne=2, colonne=2)
b11.grid (ligne=2, colonne=3)

Définissez une étiquette qui affiche une chaîne vide et ajoutez un remplissage de 20 dans le sens vertical. Définissez un menu de niveau supérieur sur la fenêtre racine et attachez-le en tournant le bouton arracher paramètre à FAUX. Ajouter un élément de sous-menu, Choix en utilisant le add_cascade paramètre.

Ajoutez deux éléments de menu avec les commandes qu'ils doivent exécuter lorsqu'ils sont cliqués dans le sous-menu nommé Réinitialiser le jeu et Quitter le jeu. Ajoutez un séparateur entre eux pour la démarcation.

mon_étiquette = Étiquette (racine, texte="")
mon_étiquette.pack (pady=20)
mon_menu = Menu (racine)
root.config (menu=mon_menu)
option_menu = Menu (my_menu, tearoff=FAUX)
mon_menu.add_cascade (étiquette="Options", menu=option_menu)
option_menu.add_command (étiquette="Réinitialiser le jeu", commande=réinitialiser)
option_menu.add_separator()
option_menu.add_command (étiquette="Quitter le jeu", commande=root.quit)

Le boucle principale() La fonction indique à Python d'exécuter la boucle d'événements Tkinter et d'écouter les événements jusqu'à ce que vous fermiez la fenêtre.

root.mainloop()

Mettez tout le code ensemble. Maintenant, le jeu de tuiles de mémoire est prêt à jouer.

Résultat du jeu de tuiles de mémoire

Lors de l'exécution du programme, 12 boutons apparaissent avec du texte vide avec le Choix menu. En cliquant Réinitialiser le jeu, la fenêtre apparaît de la même manière.

Lors de la sélection de deux tuiles identiques, 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 indiquant que la sélection était incorrecte. Les boutons et l'étiquette reviennent à leur état vide d'origine.

En cas de correspondance réussie avec tous les choix, le programme transforme toutes les tuiles en vert et affiche le message gagnant.

Jeux que vous pouvez créer avec Python

Python propose une variété de modules pour créer des jeux. Pour créer des jeux simples basés sur des mots ou des choix tels que Hangman, Tic-Tac-Toe ou Rock Paper Scissors, vous pouvez utiliser les modules Tkinter et Random. Pour développer des jeux nécessitant plus de graphismes, vous pouvez utiliser Pygame.

Pygame est un ensemble de modules Python qui fonctionne sur toutes les plateformes. Il comprend des infographies et des bibliothèques de sons qui rendent les jeux plus interactifs. Quelques-uns des jeux que vous pouvez créer à l'aide de Pygame incluent le jeu Snake, le jeu de puzzle de mémoire et le Sudoku.