Construire un jeu de couleurs à l'aide de Tkinter en Python

Battlefield2, World of Tanks, Les Sims4 et Freedom Force sont quelques-uns des milliers de jeux incroyables qui ont été développés avec Python.

Tkinter, l'interface Python standard de la boîte à outils Tk GUI, est un module puissant qui rend la création d'interfaces utilisateur graphiques simple et amusante. Utilisez ce module pour développer un jeu de couleurs hallucinant. Apprenez également à utiliser le module en cours de route.

Qu'est-ce que le jeu des couleurs?

Dans le jeu des couleurs, le programme affiche le nom d'une couleur à l'écran mais dans une couleur de police différente. Par exemple, il affiche le mot Jaune en utilisant une couleur de police rouge et le joueur doit taper la couleur du texte.

Cette inadéquation des informations avec la minuterie crée une multitude de confusion et crée une expérience de jeu divertissante.

Le module Tkinter et aléatoire

Pour construire le jeu de couleurs, vous utiliserez le tkinter modules et le aléatoire module. Tkinter est un module d'interface graphique multiplateforme, simple et convivial que vous pouvez utiliser pour créer rapidement des interfaces utilisateur graphiques.

Il dispose d'outils utiles tels que les widgets d'étiquette et d'entrée et les gestionnaires de mise en page tels que pack, grid et place. Les fonctions fournies sont assez simples, ce qui permet aux programmeurs débutants de concevoir facilement des applications sans trop d'effort. Pour installer tkinter sur votre système, exécutez la commande suivante dans le terminal :

pip installer tkinter

Le module random est une bibliothèque intégrée à l'aide de laquelle vous pouvez générer des choix aléatoires. Grâce à ce module, vous pouvez développer des jeux de cricket à la main, jeux de devinettes, jeux magiques à huit boules, générateurs de mots de passe aléatoires, et beaucoup plus.

Comment créer un jeu de couleurs avec Python

Le code source du jeu de couleurs est disponible dans un Référentiel GitHub et est libre d'utilisation sous la licence MIT.

Commencez par importer le tkinter et le module random. Enregistrez le nom des couleurs sous forme de liste de chaînes et initialisez le score variable à 0 et temps restant à 60.

depuis tkinter importer *
importer aléatoire
couleurs = ['Rouge', 'Vert', 'Bleu', 'Noir', 'Rose', 'Blanc', 'Violet', 'Jaune', 'Brun']
note = 0
temps_restant = 60

Définir une fonction nommée débutJeu() qui prend événement comme argument d'entrée. La fonction exécute deux tâches. Premièrement, il vérifie si le temps restant est égal à 60. Si oui, il appelle et exécute le compte à rebours() fonction. Deuxièmement, il appelle le couleursuivante() fonction qui mélange aléatoirement et affiche la couleur et le score lorsque le jeu est en cours.

définitivementcommencerJeu(événement):
si temps_restant == 60:
 compte à rebours()
 couleursuivante()

Définir une fonction nommée couleursuivante() et référencez les variables globalement. Si le temps restant est supérieur à 0, placez le focus sur le champ de saisie à l'aide des focus_set() méthode sur l'étiquette d'entrée (stockée dans la variable e) défini dans la seconde moitié du code.

Utilisez le obtenir() pour récupérer le texte actuel de l'entrée sous forme de chaîne et le transformer en minuscules pour éviter les incompatibilités de casse. Si cela est égal à la couleur affichée à l'écran, incrémentez le score de un. Utilisez le supprimer() fonction du 0 au dernier index sur le widget d'entrée pour effacer le contenu.

définitivementcouleur suivante():
mondial score
mondial temps restant
si temps_restant > 0:
 e.focus_set()
si e.get().lower() == couleurs[1].inférieur():
 note += 1
 e.delete(0, FIN)

Utilisez le mélanger() pour réorganiser les éléments de la liste et afficher l'étiquette de couleur avec le texte comme première couleur de la liste et la couleur de la police comme deuxième couleur de la liste. Utilisez le config() fonction sur scoreLabel (qui demande d'appuyer sur Entrée) pour afficher le score pendant que le jeu est en cours.

 random.shuffle (couleurs)
 label.config (fg=str (couleurs[1]), text=str (couleurs[0]))
 scoreLabel.config (texte="Score: " + for (score))

Définir une fonction nommée compte à rebours() qui fait référence à la variable de temps restant et la décrémente de un. Utilisez le config() fonction sur le timeLabel pour afficher le temps restant à l'écran et le après() fonction de rappel compte à rebours fonction après un délai de 1000 millisecondes ou une seconde.

définitivementcompte à rebours():
mondial temps restant
si temps_restant > 0:
 temps_restant -= 1
 timeLabel.config (texte="Temps restant: " + chaîne (time_remaining))
 timeLabel.after(1000, compte à rebours)

Initialisez l'instance de tkinter et affichez la fenêtre racine. Définissez le titre, les dimensions en pixels et la couleur d'arrière-plan de la fenêtre.

racine = Tk()
racine.titre("Jeu de couleurs avec une torsion")
root.geometry("750x450")
root.configure (arrière-plan='Orange')

Utilisez le Étiqueter widget pour instruire le joueur sur les instructions du jeu. Il accepte la fenêtre parente dans laquelle vous le placeriez. Le texte doit afficher le type et la taille de la police ainsi que la couleur d'arrière-plan de l'étiquette. Utilisez le paquet() pour organiser le widget label en blocs avant de les placer dans le widget parent.

De même, définissez l'étiquette de score pour demander à l'utilisateur d'appuyer sur Entrer pour commencer le jeu ainsi qu'une étiquette de temps pour afficher le temps restant. Assurez-vous que toutes les étiquettes ont une couleur d'arrière-plan orange, afin qu'elles se fondent dans l'arrière-plan. Définissez une étiquette vide qui contiendra les noms de couleur dans le couleursuivante() fonction.

instructions = Libellé (racine, texte="Tapez la couleur du mot pas le texte ;)", police=('Arial', 24), bg="orange")
instructions.pack()
scoreLabel = Libellé (racine, texte="Appuyez sur Entrée pour commencer", police=('Arial', 24), bg="orange")
scoreLabel.pack()
timeLabel = Libellé (racine, text="Temps restant: " + str (time_remaining), font=('Arial', 24), bg="orange")
timeLabel.pack()
étiquette = étiquette (racine, police=('Arial', 90), bg="orange")

Comme mentionné précédemment, utilisez le widget d'entrée pour capturer la réponse du joueur. Une étape importante consiste à lier la touche Entrée à un événement dans la fenêtre tkinter afin que lorsque le joueur appuie dessus, une fonction particulière s'exécute.

Pour y parvenir, vous passez le clé et la débutJeu() fonctionnent comme paramètres de la lier() fonction. De plus, utilisez le paquet() et focus_set() méthodes pour organiser et définir le focus sur l'étiquette d'entrée une fois que vous avez appuyé sur la touche Entrée.

e = Entrée (font=20)
root.bind('', débutJeu)
e.pack()
e.focus_set()

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

root.mainloop()

Rassemblez tout le code et vous avez le jeu de couleurs avec une torsion prêt à jouer au bout de vos doigts.

Sortie du jeu de couleurs à l'aide de Python

Lors de l'exécution du programme Color Game, une fenêtre apparaît à l'écran. En appuyant sur Entrée, le compte à rebours commence et le joueur doit commencer à taper la couleur du mot. Pour chaque bonne réponse, le score s'incrémente de un, et à la fin, il affiche le score final.

Développer des jeux avec Python

Python est un langage fantastique pour le développement de jeux. Le langage est non seulement simple à comprendre et à utiliser, mais il permet également aux développeurs de jeux de tous niveaux d'expérience de créer des mondes de jeu époustouflants, intéressants et divertissants.

De plus, les créateurs disposent d'un vaste éventail d'options pour donner vie à leurs idées, grâce aux différentes plateformes de développement de jeux disponibles sur le marché, telles que PyGame ou Kivy.