Créer un jeu 2048 avec Python et Tkinter

Introduction

Dans ce projet, vous apprendrez à créer un simple jeu 2048 en utilisant Python et la bibliothèque Tkinter pour l'interface graphique utilisateur. 2048 est un jeu de puzzle glissant populaire où vous combinez des tuiles pour atteindre la tuile ayant une valeur de 2048. Bien que ce projet ne créera pas l'interface utilisateur la plus moderne et la plus belle, il fournira une base solide sur laquelle vous pourrez vous appuyer pour améliorer l'esthétique.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous apprendrez :

• Comment importer les bibliothèques nécessaires pour le jeu
• Comment créer la classe Game2048 pour gérer la logique du jeu et l'interface utilisateur
• Comment dessiner la grille de jeu à l'aide de Tkinter
• Comment générer les tuiles initiales sur la grille
• Comment mettre à jour l'interface utilisateur pour refléter l'état actuel de la grille de jeu
• Comment définir les couleurs des tuiles en fonction de leurs valeurs
• Comment gérer les pressions de touches pour déplacer les tuiles
• Comment définir des méthodes pour déplacer les tuiles dans différentes directions
• Comment vérifier si le jeu est terminé

🏆 Réalisations

Après avoir terminé ce projet, vous serez en mesure de :

• Utiliser la bibliothèque Tkinter pour créer une interface graphique utilisateur
• Gérer les pressions de touches et déclencher les actions correspondantes
• Mettre à jour l'interface utilisateur en fonction de l'état du jeu
• Implémenter la logique du jeu pour les mouvements et la fusion des tuiles
• Vérifier si un jeu est terminé

Créer les fichiers du projet

Tout d'abord, créez un nouveau fichier nommé 2048_game.py et ouvrez-le dans votre éditeur de code préféré.

cd ~/project
touch 2048_game.py

Importer les bibliothèques nécessaires

Pour que votre jeu fonctionne, vous devez importer les bibliothèques essentielles. Dans le fichier 2048_game.py, incluez la bibliothèque random de Python et Tkinter pour construire l'interface graphique utilisateur.

import random
import tkinter as tk

Ces bibliothèques seront utilisées pour créer la fonctionnalité du jeu et l'interface utilisateur.

Créer la classe Game2048

Définissez la classe Game2048 dans votre fichier 2048_game.py. Cette classe gérera la logique du jeu et l'interface utilisateur.

class Game2048:
    def __init__(self, root):
        self.root = root
        self.root.title("2048 Game")
        self.root.geometry("400x400")

        ## Initialize the game grid and score
        self.grid = [[0 for _ in range(4)] for _ in range(4)]
        self.score = 0

        ## Create an empty list to store tile labels
        self.tiles = []

Ici, vous créez un constructeur de classe qui initialise la fenêtre racine du jeu, définit son titre et sa taille, initialise la grille du jeu et crée une liste pour stocker les tuiles du jeu.

Dessiner la grille de jeu

Dans la classe Game2048, ajoutez une méthode pour dessiner la grille de jeu à l'aide de Tkinter. Cette méthode crée la grille de l'interface utilisateur initiale.

    def draw_grid(self):
        for i in range(4):
            row = []
            for j in range(4):
                cell = tk.Label(self.root, text="", font=("Helvetica", 24), width=5, height=2, borderwidth=4, relief="ridge")
                cell.grid(row=i, column=j, padx=5, pady=5)
                row.append(cell)
            self.tiles.append(row)

Cette méthode crée une grille de labels de 4x4 qui affichera les tuiles du jeu.

Faire apparaître les tuiles initiales

Maintenant, vous devez implémenter une méthode qui fait apparaître les tuiles initiales lorsque le jeu commence. Cette méthode placera une ou deux tuiles de valeur 2 ou 4 sur la grille.

    def spawn_tile(self):
        empty_cells = [(i, j) for i in range(4) for j in range(4) if self.grid[i][j] == 0]
        if empty_cells:
            i, j = random.choice(empty_cells)
            self.grid[i][j] = 2 if random.random() < 0.9 else 4
            self.update_tiles()

Cette méthode localise les cellules vides sur la grille et place aléatoirement une nouvelle tuile dans l'une d'elles.

Mettre à jour l'interface utilisateur

Créez une méthode pour mettre à jour l'interface utilisateur afin de refléter l'état actuel de la grille de jeu.

    def update_tiles(self):
        for i in range(4):
            for j in range(4):
                tile_value = self.grid[i][j]
                self.tiles[i][j]["text"] = str(tile_value) if tile_value > 0 else ""
                self.tiles[i][j]["background"] = self.get_tile_color(tile_value)

Cette méthode parcourt la grille, mettant à jour les étiquettes (labels) dans l'interface graphique utilisateur pour qu'elles correspondent à l'état de la grille.

Définir les couleurs des tuiles

Créez une méthode pour attribuer des couleurs de fond aux tuiles en fonction de leurs valeurs.

    def get_tile_color(self, value):
        colors = {
            0: "#CDC1B4",
            2: "#EEE4DA",
            4: "#EDE0C8",
            8: "#F2B179",
            16: "#F59563",
            32: "#F67C5F",
            64: "#F65E3B",
            128: "#EDCF72",
            256: "#EDCC61",
            512: "#EDC850",
            1024: "#EDC53F",
            2048: "#EDC22E"
        }
        return colors.get(value, "#FF0000")

Cette méthode renvoie un code couleur en fonction de la valeur de la tuile.

Gérer les appuis sur les touches

Implémentez une méthode pour gérer les touches pressées. À cette étape, vous allez capturer les pressions sur les touches fléchées et y répondre en conséquence.

    def key_pressed(self, event):
        if self.is_game_over():
            return

        if event.keysym == "Up":
            self.move("up")
        elif event.keysym == "Down":
            self.move("down")
        elif event.keysym == "Left":
            self.move("left")
        elif event.keysym == "Right":
            self.move("right")

        self.spawn_tile()
        self.update_tiles()

Cette méthode écoute les pressions sur les touches fléchées et déclenche la fonction de mouvement correspondante.

Déplacer les tuiles

Implémentez des méthodes pour déplacer les tuiles dans la direction souhaitée : haut, bas, gauche ou droite.

    def move(self, direction):
        if direction == "up":
            self.grid = list(map(list, zip(*self.grid)))
            self.move_left()
            self.grid = list(map(list, zip(*self.grid)))
        elif direction == "down":
            self.grid = list(map(list, zip(*self.grid)))
            self.move_right()
            self.grid = list(map(list, zip(*self.grid)))
        elif direction == "left":
            self.move_left()
        elif direction == "right":
            self.move_right()

Cette méthode prépare la grille pour le déplacement, appelle la fonction de déplacement appropriée, puis réinitialise la grille.

Déplacer les tuiles vers la gauche

Définissez une méthode pour déplacer les tuiles vers la gauche dans une ligne.

    def move_left(self):
        for i in range(4):
            row = self.grid[i]
            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.append(0)

            for j in range(3):
                if row[j] == row[j + 1] and row[j]!= 0:
                    row[j] *= 2
                    row[j + 1] = 0
                    self.score += row[j]

            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.append(0)
            self.grid[i] = row

Cette méthode gère les déplacements des tuiles vers la gauche, fusionne les tuiles adjacentes lorsque cela est possible et remplit les cellules vides.

Déplacer les tuiles vers la droite

Définissez une méthode pour déplacer les tuiles vers la droite dans une ligne.

    def move_right(self):
        for i in range(4):
            row = self.grid[i]
            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.insert(0, 0)

            for j in range(3, 0, -1):
                if row[j] == row[j - 1] and row[j]!= 0:
                    row[j] *= 2
                    row[j - 1] = 0
                    self.score += row[j]

            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.insert(0, 0)
            self.grid[i] = row

Cette méthode est chargée de déplacer les tuiles vers la droite, de les fusionner lorsque cela est approprié et de remplir les espaces vides.

Vérifier si le jeu est terminé

Créez une méthode pour vérifier si le jeu est terminé. Le jeu est terminé lorsqu'aucun mouvement supplémentaire n'est possible.

    def is_game_over(self):
        for i in range(4):
            for j in range(4):
                if self.grid[i][j] == 0:
                    return False

        for i in range(4):
            for j in range(3):
                if self.grid[i][j] == self.grid[i][j + 1]:
                    return False

        for j in range(4):
            for i in range(3):
                if self.grid[i][j] == self.grid[i + 1][j]:
                    return False

        return True

Cette méthode vérifie si des mouvements supplémentaires sont possibles en examinant si la grille contient des cellules vides ou des cellules adjacentes ayant la même valeur. Si aucun mouvement supplémentaire n'est possible, le jeu est terminé.

Exécuter le projet

Enfin, accédez au bureau et exécutez le projet en utilisant la commande suivante :

python 2048_game.py

Résumé

Dans ce projet, vous avez appris à créer un jeu 2048 simple en Python en utilisant la bibliothèque Tkinter. Vous avez commencé par configurer le projet, créer le fichier Python principal et définir la classe Game2048. Vous avez ensuite implémenté les presses de touches, les déplacements des tuiles et vérifié les conditions de fin de jeu. L'interface du jeu n'est peut-être pas la plus moderne et la plus belle, mais vous disposez maintenant d'une base que vous pouvez améliorer et personnaliser pour créer un jeu 2048 plus abouti. Pour exécuter le projet, vous pouvez suivre les étapes ci-dessous.