Créer un jeu Tic Tac Toe en Python : Tutoriel complet avec code

Le Tic Tac Toe (Morpion) est un projet Python idéal pour débutants : ludique, il consolide les bases (boucles, conditions, listes, fonctions). Aucun bibliothèque externe n'est requise.

Règles du jeu

1. Grille carrée vide (3×3 par défaut).
2. Deux joueurs, symboles X et O.
3. À tour de rôle, chaque joueur place son symbole dans une case libre.
4. Victoire : aligner 3 symboles identiques (ligne, colonne, diagonale).
5. Match nul : grille pleine sans vainqueur.

Prérequis

• Python installé.
• Éditeur de code (PyCharm, VS Code, ou simple Bloc-notes + terminal).
• Compréhension de base : variables, boucles for/while, conditions if/else, listes, fonctions.

Algorithme

1. Créer le plateau (liste de listes).
2. Demander la dimension N (≥ 3).
3. Choisir le premier joueur aléatoirement.
4. Boucle principale : afficher le plateau, demander les coordonnées, placer le symbole, vérifier victoire/nul, alterner joueur.
5. Proposer une nouvelle partie.

Code complet (version N×N)

# Tic Tac Toe N-dimensionnel par Guru99

def obtenir_entree(prompt, cast=None, condition=None, message_erreur=None):
    while True:
        try:
            val = cast(input(prompt))
            if condition is None or condition(val):
                return val
        except:
            print(message_erreur or "Entrée invalide.")

def afficher_plateau(plateau):
    print()
    for ligne in plateau:
        print(*ligne)
    print()

def verifier_victoire(plateau):
    n = len(plateau)
    # Lignes
    for i in range(n):
        if all(plateau[i][j] == plateau[i][0] != "_" for j in range(n)):
            return True
    # Colonnes
    for j in range(n):
        if all(plateau[i][j] == plateau[0][j] != "_" for i in range(n)):
            return True
    # Diagonale principale
    if all(plateau[i][i] == plateau[0][0] != "_" for i in range(n)):
        return True
    # Diagonale secondaire
    if all(plateau[i][n-1-i] == plateau[0][n-1] != "_" for i in range(n)):
        return True
    return False

def jouer():
    print("------------\nMORPION N-DIMENSIONNEL par Guru99\n------------")
    N = obtenir_entree(
        prompt="Entrez N, la dimension du plateau (≥ 3) : ",
        cast=int,
        condition=lambda x: x >= 3,
        message_erreur="Entier ≥ 3 requis."
    )
    plateau = [['_'] * N for _ in range(N)]
    tours_joues = 0
    joueur = 0  # 0 = X, 1 = O

    while True:
        afficher_plateau(plateau)
        coords = obtenir_entree(
            prompt=f"Joueur {joueur+1} ({"X" if joueur == 0 else "O"}) - Entrez ligne colonne (ex: 1 2) : ",
            cast=lambda s: tuple(map(int, s.split())),
            condition=lambda p: 0 <= p[0] < N and 0 <= p[1] < N and plateau[p[0]][p[1]] == "_",
            message_erreur="Coordonnées invalides ou case occupée."
        )
        plateau[coords[0]][coords[1]] = "X" if joueur == 0 else "O"
        tours_joues += 1

        if verifier_victoire(plateau):
            afficher_plateau(plateau)
            print(f"Partie terminée ! Joueur {joueur+1} gagne.")
            break
        elif tours_joues == N * N:
            afficher_plateau(plateau)
            print("Match nul !")
            break

        joueur = (joueur + 1) % 2

    rejouer = obtenir_entree(
        prompt="Nouvelle partie ? (o/n) : ",
        cast=str,
        condition=lambda r: r.lower() in {"o", "n"},
        message_erreur="Répondez 'o' ou 'n'."
    )
    if rejouer.lower() == "o":
        jouer()
    else:
        print("Au revoir !")

if __name__ == "__main__":
    jouer()

Exemple de partie (3×3)

------------
MORPION N-DIMENSIONNEL par Guru99
------------
Entrez N, la dimension du plateau (≥ 3) : 3
_ _ _
_ _ _
_ _ _
Joueur 1 (X) - Entrez ligne colonne : 1 1
_ _ _
_ X _
_ _ _
Joueur 2 (O) - Entrez ligne colonne : 0 1
_ O _
_ X _
_ _ _
Joueur 1 (X) - Entrez ligne colonne : 1 2
_ O _
_ X X
_ _ _
Joueur 2 (O) - Entrez ligne colonne : 0 2
_ O O
_ X X
_ _ _
Joueur 1 (X) - Entrez ligne colonne : 1 0
_ O O
X X X
_ _ _
Partie terminée ! Joueur 1 gagne.
Nouvelle partie ? (o/n) :

Analyse du code

Fonction obtenir_entree

Gère la saisie utilisateur avec validation (cast, condition, message d'erreur). Évite les plantages sur entrée invalide.

Fonction afficher_plateau

Affiche la grille lisiblement avec print(*ligne) qui dépaquette la liste.

Fonction verifier_victoire

Vérifie les 4 directions de victoire (lignes, colonnes, 2 diagonales) avec all() pour concision. Retourne True dès qu'une ligne complète est trouvée.

Boucle principale jouer()

• Initialisation du plateau N×N avec des _ (cases vides).
• Alternance joueurs via joueur = (joueur + 1) % 2.
• Vérification victoire → match nul → continuation.
• Récursivité pour rejouer (simple pour un petit jeu).

Conclusion

• Projet parfait pour pratiquer : listes 2D, boucles, conditions, fonctions, entrée/sortie.
• Extensible : IA (minimax), interface graphique (Tkinter), scores, timer.
• Testez, modifiez, amusez-vous !