×

Coder un jeu de dames avec python (Tkinter)

Coder un jeu de dames avec python (Tkinter)

Dans ce tutoriel, on vas créer un jeu de dames avec Tkinter. Cette version étendue du jeu de dames simplifié comprendra la création d’un tableau de jeu, la logique de déplacement, la prise des pièces adverses et la détection de la fin de partie. Vous pouvez continuer à développer ces fonctionnalités pour en faire un jeu complet.

1. Créez une classe pour le jeu de dames :

import tkinter as tk

class Checkerboard(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Jeu de Dames")
        self.geometry("400x400")

        self.board = [[None for _ in range(8)] for _ in range(8)]  # Crée un damier vide
        self.current_player = "white"  # Le joueur blanc commence

        self.create_board()

        self.selected_piece = None
        self.valid_moves = []

        self.bind("<Button-1>", self.on_click)

    # ... (le reste du code reste le même)

2. Ajoutez des méthodes pour créer les pions :

def create_pieces(self):
    for row in range(3):
        for col in range(8):
            if (row + col) % 2 == 1:
                self.draw_piece(row, col, "white")

    for row in range(5, 8):
        for col in range(8):
            if (row + col) % 2 == 1:
                self.draw_piece(row, col, "black")

3. Définissez la logique de déplacement :

def get_valid_moves(self, row, col):
    moves = []
    if self.current_player == "white":
        directions = [(1, 1), (1, -1)]
    else:
        directions = [(-1, 1), (-1, -1)]

    for dr, dc in directions:
        new_row, new_col = row + dr, col + dc
        jump_row, jump_col = row + 2 * dr, col + 2 * dc
        if 0 <= jump_row < 8 and 0 <= jump_col < 8 and self.board[new_row][new_col] is not None and self.board[jump_row][jump_col] is None:
            moves.append((jump_row, jump_col))
    return moves

def on_click(self, event):
    col = event.x // 50
    row = event.y // 50

    if self.selected_piece:
        selected_row, selected_col = self.selected_piece
        if (row, col) in self.valid_moves:
            self.move_piece(selected_row, selected_col, row, col)
            self.end_turn()
        else:
            self.selected_piece = None
            self.valid_moves = []
            self.draw_board()
    else:
        if self.board[row][col] and self.board[row][col].color == self.current_player:
            self.selected_piece = (row, col)
            self.valid_moves = self.get_valid_moves(row, col)
            self.draw_board(highlight_moves=True)

4. Ajoutez des méthodes pour déplacer et supprimer les pièces :

def move_piece(self, from_row, from_col, to_row, to_col):
    self.board[to_row][to_col] = self.board[from_row][from_col]
    self.board[from_row][from_col] = None
    self.draw_board()

def remove_piece(self, row, col):
    self.board[row][col] = None
    self.draw_board()

def king_piece(self, row, col):
    self.board[row][col].king = True
    self.draw_board()

5. Ajoutez la détection de la fin de partie :

def check_for_winner(self):
    white_pieces = 0
    black_pieces = 0
    for row in range(8):
        for col in range(8):
            if self.board[row][col]:
                if self.board[row][col].color == "white":
                    white_pieces += 1
                else:
                    black_pieces += 1

    if white_pieces == 0:
        return "black"
    elif black_pieces == 0:
        return "white"
    else:
        return None

6. Ajoutez une méthode pour terminer le tour :

def end_turn(self):
    if self.current_player == "white":
        self.current_player = "black"
    else:
        self.current_player = "white"
    self.selected_piece = None
    self.valid_moves = []

    winner = self.check_for_winner()
    if winner:
        print(f"Joueur {winner} gagne !")
        self.quit()

    self.draw_board()

7. Ajoutez une méthode pour dessiner le tableau :

def draw_board(self, highlight_moves=False):
    for row in range(8):
        for col in range(8):
            color = "white" if (row + col) % 2 == 0 else "black"
            self.board[row][col] = self.board[row][col] or None

            if (row, col) == self.selected_piece:
                color = "red"

            self.board[row][col].draw(row, col, color, highlight_moves)

8. Créez une classe pour les pions :

class Piece:
    def __init__(self, color):
        self.color = color
        self.king = False

    def draw(self, row, col, color, highlight=False):
        x0, y0, x1, y1 = col * 50, row * 50, (col + 1) * 50, (row + 1) * 50
        canvas = self.canvas if hasattr(self, "canvas") else None
        if canvas:
            canvas.delete("piece")

        if not self.king:
            radius = 20
            if self.color == "white":
                y0 += 15
                y1 += 15
            else:
                y0 += 5
                y1 += 5
        else:
            radius = 25
            if self.color == "white":
                y0 += 10
                y1 += 10
            else:
                y0 += 0
                y1 += 0

        if highlight:
            color = "green"

        if canvas:
            canvas.create_oval(x0, y0, x1, y1, fill=color, tags="piece")

9. Créez une instance du jeu :

if __name__ == "__main__":
    app = Checkerboard()
    app.create_pieces()
    app.mainloop()

La vidéo complète du tuto est déjà sur ma chaine YouTube. je vous invite a allez le visualiser pour mieux comprendre le code et le réutiliser. Merci.

Ceci est une version simplifiée d’un jeu de dames en utilisant Tkinter. Vous pouvez continuer à améliorer ce jeu en ajoutant des fonctionnalités telles que la prise multiple, les règles pour couronner un pion, le déplacement en arrière, etc. Ce code vous donne une base solide pour développer votre propre jeu de dames

288 commentaires