Création d'un Tic-Tac-Toe avec Pygame

Introduction

Ce projet vous guidera tout au long des étapes pour créer un jeu de Morpion à l'aide de Pygame. Le Morpion est un jeu à deux joueurs dont le but est d'obtenir trois de vos symboles alignés, horizontalement, verticalement ou en diagonale. Dans ce projet, vous allez apprendre à configurer la fenêtre de jeu, à dessiner le plateau de jeu, à gérer les coups des joueurs et de l'IA, et à déterminer le gagnant. À la fin de ce projet, vous aurez un jeu de Morpion entièrement fonctionnel contre un adversaire IA.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment créer les fichiers du projet et importer les bibliothèques nécessaires
• Comment initialiser PyGame et configurer la fenêtre de jeu
• Comment définir les symboles, les couleurs et l'état du jeu
• Comment définir les propriétés des boutons et créer des fonctions d'aide
• Comment créer la boucle principale du jeu et implémenter les fonctions d'aide
• Comment compléter le code restant à l'intérieur de la boucle principale du jeu

🏆 Réalisations

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

• Utiliser Pygame pour créer un jeu graphique
• Dessiner des graphiques sur une fenêtre à l'aide de Pygame
• Gérer l'entrée utilisateur et mettre à jour l'état du jeu
• Implémenter la logique du jeu, telle que la vérification d'une condition de victoire
• Créer une boucle de jeu pour maintenir le jeu en cours

Créer les fichiers du projet

Pour commencer, créez un nouveau fichier nommé tic_tac_toe.py. Ouvrez le fichier dans votre éditeur de texte préféré.

cd ~/projet
touch tic_tac_toe.py

Importer les bibliothèques nécessaires

Dans tic_tac_toe.py, importez les bibliothèques nécessaires : pygame et random. Ces bibliothèques seront utilisées respectivement pour gérer les graphiques du jeu et générer des coups aléatoires de l'IA.

import pygame
import random

Installez la bibliothèque pygame en utilisant la commande suivante :

sudo pip install pygame

Initialiser PyGame et configurer la fenêtre de jeu

Dans tic_tac_toe.py, initialisez PyGame à l'aide de pygame.init(). Ensuite, configurez la fenêtre de jeu en définissant la largeur et la hauteur de la fenêtre, la couleur d'arrière-plan, la couleur des lignes et la taille des cellules. Créez également une fenêtre PyGame avec la largeur et la hauteur spécifiées et définissez le titre de la fenêtre.

pygame.init()

LARGEUR = 600
HAUTEUR = 600
COULEUR_ARRIERE_PLAN = (40, 40, 40)
COULEUR_LIGNE = (70, 70, 70)
TAILLE_CELLULE = LARGEUR // 3

win = pygame.display.set_mode((LARGEUR, HAUTEUR))
pygame.display.set_caption("Morpion")

Définir les symboles et les couleurs

Dans tic_tac_toe.py, définissez les symboles et les couleurs pour le joueur et l'IA. Ces symboles et couleurs seront utilisés pour dessiner les coups du joueur et de l'IA sur le plateau de jeu.

SYMBOLE_JOUEUR = "X"
SYMBOLE_IA = "O"
COULEUR_JOUEUR = (0, 255, 0)
COULEUR_IA = (255, 0, 0)
COULEUR_VIDE = (0, 0, 0)

Définir l'état du jeu

Dans tic_tac_toe.py, définissez l'état initial du jeu. Cela inclut le plateau de jeu, le tour actuel (soit "joueur" soit "ia"), un drapeau indiquant si la partie est terminée et le vainqueur de la partie.

plateau = [["" for _ in range(3)] for _ in range(3)]
tour = "joueur"
partie_terminee = False
vainqueur = None

Définir les propriétés du bouton

Dans tic_tac_toe.py, définissez les propriétés du bouton de réinitialisation, y compris la largeur, la hauteur, la couleur, la couleur du texte et la taille de police du bouton. Créez également un objet reset_button_rect à l'aide de la classe pygame.Rect pour représenter la position et la taille du bouton.

LARGEUR_BOUTON = 200
HAUTEUR_BOUTON = 50
COULEUR_BOUTON = (50, 50, 50)
COULEUR_TEXTE_BOUTON = (255, 255, 255)
POLICE_BOUTON = pygame.font.Font(None, 30)

reset_button_rect = pygame.Rect(
    (LARGEUR - LARGEUR_BOUTON) // 2,
    (HAUTEUR - HAUTEUR_BOUTON) // 2,
    LARGEUR_BOUTON,
    HAUTEUR_BOUTON,
)

Créer des fonctions d'aide

Dans tic_tac_toe.py, définissez plusieurs fonctions d'aide qui seront utilisées tout au long du jeu.

• dessiner_plateau() : Cette fonction dessinera le plateau de jeu sur la fenêtre.

• dessiner_symboles() : Cette fonction dessinera les symboles du joueur et de l'IA sur le plateau de jeu.

• est_plateau_rempli() : Cette fonction vérifiera si le plateau de jeu est rempli.

• est_gagnant() : Cette fonction vérifiera si un joueur a gagné la partie.

• faire_coup() : Cette fonction effectuera un coup sur le plateau de jeu.

• coup_joueur() : Cette fonction gérera le coup du joueur.

• coup_ia() : Cette fonction gérera le coup de l'IA.

• vérifier_fin_partie() : Cette fonction vérifiera si la partie est terminée.

• dessiner_gagnant() : Cette fonction dessinera le message du gagnant sur la fenêtre.

• dessiner_bouton_reset() : Cette fonction dessinera le bouton de réinitialisation sur la fenêtre.

• réinitialiser_partie() : Cette fonction réinitialisera l'état de la partie.

## Fonctions d'aide
def dessiner_plateau():
    ## Dessiner le plateau de jeu
    pass

def dessiner_symboles():
    ## Dessiner les symboles du joueur et de l'IA sur le plateau de jeu
    pass

def est_plateau_rempli():
    ## Vérifier si le plateau de jeu est rempli
    pass

def est_gagnant(symbole):
    ## Vérifier si un joueur a gagné la partie
    pass

def faire_coup(x, y, symbole):
    ## Effectuer un coup sur le plateau de jeu
    pass

def coup_joueur():
    ## Gérer le coup du joueur
    pass

def coup_ia():
    ## Gérer le coup de l'IA
    pass

def vérifier_fin_partie():
    ## Vérifier si la partie est terminée
    pass

def dessiner_gagnant():
    ## Dessiner le message du gagnant sur la fenêtre
    pass

def dessiner_bouton_reset():
    ## Dessiner le bouton de réinitialisation sur la fenêtre
    pass

def réinitialiser_partie():
    ## Réinitialiser l'état de la partie
    pass

Créer la boucle principale du jeu

Dans tic_tac_toe.py, créez la boucle principale du jeu à l'aide d'une boucle while. Cette boucle s'exécutera jusqu'à ce que l'utilisateur ferme la fenêtre de jeu. À l'intérieur de la boucle de jeu, gérez les événements d'entrée de l'utilisateur et mettez à jour l'état du jeu en conséquence.

## Boucle principale du jeu
en_cours = True
while en_cours:
    for événement in pygame.event.get():
        if événement.type == pygame.QUIT:
            en_cours = False
        elif événement.type == pygame.MOUSEBUTTONDOWN:
            if reset_button_rect.collidepoint(événement.pos):
                réinitialiser_partie()
            elif not partie_terminee and tour == "joueur":
                coup_joueur()

    if not partie_terminee and tour == "ia":
        coup_ia()
        vérifier_fin_partie()

    dessiner_plateau()
    dessiner_symboles()

    if partie_terminee:
        dessiner_gagnant()
        dessiner_bouton_reset()

    pygame.display.flip()

## Quitter le jeu
pygame.quit()

Implémenter les fonctions d'aide

Maintenant, implémentons les fonctions d'aide que nous avons définies précédemment. Commençons par compléter la fonction dessiner_plateau(). Cette fonction dessinera le plateau de jeu sur la fenêtre en dessinant des lignes verticales et horizontales à l'aide de la fonction pygame.draw.line().

## Fonctions d'aide
def dessiner_plateau():
    win.fill(COULEUR_FOND)

    ## Dessiner les lignes verticales
    for x in range(1, 3):
        pygame.draw.line(
            win, COULEUR_LIGNE, (TAILLE_CELLULE * x, 0), (TAILLE_CELLULE * x, HAUTEUR), 2
        )

    ## Dessiner les lignes horizontales
    for y in range(1, 3):
        pygame.draw.line(win, COULEUR_LIGNE, (0, TAILLE_CELLULE * y), (LARGEUR, TAILLE_CELLULE * y), 2)

Implémenter les fonctions d'aide restantes

Ensuite, implémentez les fonctions d'aide restantes : dessiner_symboles(), est_plateau_rempli(), est_gagnant(), faire_coup(), coup_joueur(), coup_ia(), vérifier_fin_partie(), dessiner_gagnant(), dessiner_bouton_reset() et réinitialiser_partie().

## Fonctions d'aide
def dessiner_symboles():
    for x in range(3):
        for y in range(3):
            symbole = plateau[x][y]
            if symbole == SYMBOLE_JOUEUR:
                couleur = COULEUR_JOUEUR
            elif symbole == SYMBOLE_IA:
                couleur = COULEUR_IA
            else:
                couleur = COULEUR_VIDE
            if symbole!= "":
                pygame.draw.circle(
                    win,
                    couleur,
                    (x * TAILLE_CELLULE + TAILLE_CELLULE // 2, y * TAILLE_CELLULE + TAILLE_CELLULE // 2),
                    TAILLE_CELLULE // 2 - 10,
                    2,
                )

def est_plateau_rempli():
    for ligne in plateau:
        if "" in ligne:
            return False
    return True

def est_gagnant(symbole):
    for ligne in plateau:
        if all(cellule == symbole for cellule in ligne):
            return True
    for colonne in range(3):
        if all(plateau[row][colonne] == symbole for row in range(3)):
            return True
    if all(plateau[i][i] == symbole for i in range(3)):
        return True
    if all(plateau[i][2 - i] == symbole for i in range(3)):
        return True
    return False

def faire_coup(x, y, symbole):
    if plateau[x][y] == "":
        plateau[x][y] = symbole
        return True
    return False

def coup_joueur():
    global tour
    pos_souris = pygame.mouse.get_pos()
    cellule_x = pos_souris[0] // TAILLE_CELLULE
    cellule_y = pos_souris[1] // TAILLE_CELLULE

    if faire_coup(cellule_x, cellule_y, SYMBOLE_JOUEUR):
        tour = "ia"

def coup_ia():
    global tour
    cellules_vides = []
    for x in range(3):
        for y in range(3):
            if plateau[x][y] == "":
                cellules_vides.append((x, y))

    if cellules_vides:
        x, y = random.choice(cellules_vides)
        faire_coup(x, y, SYMBOLE_IA)

    tour = "joueur"

def vérifier_fin_partie():
    global partie_terminee, gagnant
    if est_gagnant(SYMBOLE_JOUEUR):
        partie_terminee = True
        return "joueur"
    elif est_gagnant(SYMBOLE_IA):
        partie_terminee = True
        return "ia"
    elif est_plateau_rempli():
        partie_terminee = True
        return "égalité"
    return None

def dessiner_gagnant():
    police = pygame.font.Font(None, 50)
    if gagnant == "joueur":
        texte = police.render("Le joueur gagne!", True, COULEUR_JOUEUR)
    elif gagnant == "ia":
        texte = police.render("L'IA gagne!", True, COULEUR_IA)
    else:
        texte = police.render("Match nul!", True, (255, 255, 255))
    rect_texte = texte.get_rect(center=(LARGEUR // 2, HAUTEUR // 3))
    win.blit(texte, rect_texte)

def dessiner_bouton_reset():
    pygame.draw.rect(win, COULEUR_BOUTON, reset_button_rect)
    texte_bouton = BUTTON_FONT.render("Réinitialiser", True, COULEUR_TEXTE_BOUTON)
    rect_texte_bouton = texte_bouton.get_rect(center=reset_button_rect.center)
    win.blit(texte_bouton, rect_texte_bouton)

def réinitialiser_partie():
    global plateau, tour, partie_terminee, gagnant
    plateau = [["" for _ in range(3)] for _ in range(3)]
    tour = "joueur"
    partie_terminee = False
    gagnant = None

Dans le code ci-dessus, la fonction dessiner_symboles() dessinera les symboles sur le plateau. La fonction est_plateau_rempli() vérifiera si le plateau est rempli. La fonction est_gagnant() vérifiera si le symbole donné a gagné la partie. La fonction faire_coup() effectuera un coup sur le plateau. La fonction coup_joueur() gérera le coup du joueur. La fonction coup_ia() gérera le coup de l'IA. La fonction vérifier_fin_partie() vérifiera si la partie est terminée. La fonction dessiner_gagnant() dessinera le message du gagnant. La fonction dessiner_bouton_reset() dessinera le bouton de réinitialisation. La fonction réinitialiser_partie() réinitialisera le jeu.

Compléter le code restant

Enfin, complétez le code restant à l'intérieur de la boucle principale du jeu pour appeler les fonctions d'aide aux endroits appropriés. Cela inclut appeler les fonctions dessiner_plateau() et dessiner_symboles() pour dessiner le plateau de jeu et les symboles, appeler la fonction vérifier_fin_partie() pour vérifier si la partie est terminée, et appeler les fonctions dessiner_gagnant() et dessiner_bouton_reset() pour dessiner le message du gagnant et le bouton de réinitialisation respectivement.

## Boucle principale du jeu
en_cours = True
while en_cours:
    for événement in pygame.event.get():
        if événement.type == pygame.QUIT:
            en_cours = False
        elif événement.type == pygame.MOUSEBUTTONDOWN:
            if reset_button_rect.collidepoint(événement.pos):
                réinitialiser_partie()
            elif not partie_terminee and tour == "joueur":
                coup_joueur()

    if not partie_terminee and tour == "ia":
        coup_ia()
        gagnant = vérifier_fin_partie()

    dessiner_plateau()
    dessiner_symboles()

    if partie_terminee:
        dessiner_gagnant()
        dessiner_bouton_reset()

    pygame.display.flip()

## Quitter le jeu
pygame.quit()

Exécutez le jeu en utilisant la commande suivante :

python tic_tac_toe.py

Sommaire

Félicitations! Vous avez réussi à créer un jeu de Tic-Tac-Toe à l'aide de Pygame. Dans ce projet, vous avez appris à configurer la fenêtre de jeu, à dessiner le plateau de jeu, à gérer les coups des joueurs et de l'IA, et à déterminer le gagnant. Vous avez également appris à implémenter des fonctions d'aide pour simplifier le code et le rendre plus modulaire.