Comment créer un jeu de morpion en Python ?

Créons un simple jeu de Tic Tac Toe en Python. Cela vous aidera à construire la logique du jeu et à comprendre comment structurer le code.

Le jeu est l’un des divertissements de l’être humain. Nous pouvons trouver différents types de jeux sur le web, les téléphones portables, les ordinateurs de bureau, etc. Nous ne sommes pas ici pour créer un de ces jeux lourds. Nous allons créer un jeu de morpion CLI en utilisant Python.

Si vous n’êtes pas familier avec le Tic Tac Toe, jouez-le visuellement ici pour comprendre. Ne vous inquiétez pas, même si vous ne comprenez pas, nous allons le voir.

Tic Tac Toe

Le didacticiel est divisé en trois sections différentes. Dans la première section, vous apprendrez à jouer au jeu du morpion. Ensuite, nous verrons un algorithme qui nous aide à élaborer la logique du jeu. Enfin, nous verrons le code structuré et son explication.

Vous pouvez sauter la première section si vous savez déjà comment jouer au morpion.

Alors, sans plus attendre, plongeons dans notre première section.

Jouer au morpion

Le jeu se joue à deux. Chaque joueur est représenté par deux signes. Les signes généraux utilisés dans le jeu sont X et O. Enfin, il y aura un tableau avec 9 cases .

Voyez le tableau de morpion visuellement.

Tic Tac Toe Board — Tableau de Tic Tac Toe

Le jeu se déroule comme suit.

Tout d’abord, un utilisateur place son signe dans l’une des cases vides disponibles.
Ensuite, le deuxième utilisateur placera son signe dans l’une des cases vides disponibles.
Le but des joueurs est de placer leurs signes respectifs complètement en ligne, en colonne ou en diagonale.
Le jeu se poursuit jusqu’à ce qu’un joueur gagne la partie ou qu’elle se termine par un match nul en remplissant toutes les cases sans qu’aucune ne soit gagnante.

Voyons quelques scénarios de jeu en images.

Le joueur X gagne la partie dans le jeu ci-dessus. Toutes les cases se remplissent en diagonale avec des signes X . Le joueur concerné gagne donc la partie.

Il y a au total 8 façons d’arranger le même signe et de gagner la partie. Voyons les 8 combinaisons possibles pour gagner la partie.

Et enfin, un tirage au sort remplit le tableau sans qu’il y ait d’arrangement gagnant. J’espère que vous comprenez maintenant comment jouer au Tic Tac Toe.

Maintenant, c’est à vous de jouer. Vous pouvez aller ici et jouer pour comprendre complètement le jeu. Laissez tomber si vous avez déjà compris.

Il est maintenant temps de passer à la section sur les algorithmes.

Algorithme

Nous allons maintenant discuter de l’algorithme pour écrire le code. Cet algorithme vous aidera à écrire du code dans le langage de programmation de votre choix. Voyons comment procéder.

Créez un tableau en utilisant un tableau à deux dimensions et initialisez chaque élément comme vide.
- Vous pouvez représenter empty par n’importe quel symbole. Ici, nous allons utiliser un trait d’union. '-'.
Écrivez une fonction pour vérifier si le tableau est rempli ou non.
- Interrogez le tableau et renvoyez false si le tableau contient un signe vide, sinon renvoyez true.
Ecrivez une fonction pour vérifier si un joueur a gagné ou non.
- Nous devons vérifier toutes les possibilités dont nous avons parlé dans la section précédente.
- Vérifiez toutes les lignes, colonnes et deux diagonales.
Écrivez une fonction pour afficher le tableau, car nous le montrerons plusieurs fois aux utilisateurs pendant qu’ils jouent.
Écrivez une fonction pour démarrer le jeu.
- Sélectionnez le premier tour du joueur de manière aléatoire.
- Écrivez une boucle infinie qui s’arrête lorsque le jeu est terminé (victoire ou match nul).
  - Montrez le tableau à l’utilisateur pour qu’il choisisse l’emplacement du prochain coup.
  - Demandez à l’utilisateur d’entrer le numéro de la ligne et de la colonne.
  - Mettez à jour l’emplacement avec le signe du joueur respectif.
  - Vérifiez si le joueur actuel a gagné la partie ou non.
  - Si le joueur actuel a gagné la partie, imprimez un message de victoire et sortez de la boucle infinie.
  - Ensuite, vérifiez si le plateau est rempli ou non.
  - Si le plateau est rempli, imprimez le message de tirage au sort et sortez de la boucle infinie.
- Enfin, montrez à l’utilisateur la vue finale du tableau.

Vous pouvez peut-être visualiser ce qui se passe. Ne vous inquiétez pas, même si vous n’avez pas tout compris. Vous y verrez plus clair une fois que vous aurez vu le code.

Passons maintenant à la section du code. Je suppose que vous avez installé Python sur votre PC pour essayer le code.

Code

Parcourez le code ci-dessous.

import random


classe TicTacToe :

    def __init__(self) :
        self.board = []

    def create_board(self) :
        for i in range(3) :
            row = []
            for j in range(3) :
                row.append('-')
            self.board.append(row)

    def get_random_first_player(self) :
        return random.randint(0, 1)

    def fix_spot(self, row, col, player) :
        self.board[row][col] = joueur

    def is_player_win(self, player) :
        win = None

        n = len(self.board)

        # vérification des lignes
        for i in range(n) :
            win = True
            for j in range(n) :
                si self.board[i][j]!= joueur :
                    victoire = Faux
                    break
            si victoire :
                return win

        # vérification des colonnes
        for i in range(n) :
            win = True
            for j in range(n) :
                si self.board[j][i]!= joueur :
                    victoire = Faux
                    break
            si victoire :
                return win

        # vérification des diagonales
        win = True
        pour i dans range(n) :
            si self.board[i][i]!= player :
                win = False
                break
        si victoire :
            return win

        win = True
        for i in range(n) :
            si self.board[i][n - 1 - i] != player :
                victoire = Faux
                break
        si victoire :
            return win
        retour Faux

        for row in self.board :
            for item in row :
                si élément == '-' :
                    return False
        return True

    def is_board_filled(self) :
        for row in self.board :
            for item in row :
                if item == '-' :
                    return False
        return True

    def swap_player_turn(self, player) :
        return 'X' if player == 'O' else 'O'

    def show_board(self) :
        for row in self.board :
            for item in row :
                print(item, end=" ")
            print()

    def start(self) :
        self.create_board()

        player = 'X' if self.get_random_first_player() == 1 else 'O'
        while True :
            print(f "Tour du joueur {joueur}")

            self.show_board()

            # prise en compte des données de l'utilisateur
            row, col = list(
                map(int, input("Enter row and column numbers to fix spot : ").split()))
            print()

            # fixation de la tache
            self.fix_spot(row - 1, col - 1, player)

            # vérifier si le joueur actuel a gagné ou non
            if self.is_player_win(player) :
                print(f "Le joueur {joueur} gagne la partie !")
                break

            # vérifier si la partie est nulle ou non
            if self.is_board_filled() :
                print("Match nul !")
                break

            # échanger le tour
            joueur = self.swap_player_turn(joueur)

        # afficher la vue finale du plateau
        print()
        self.show_board()


# démarrer le jeu
tic_tac_toe = TicTacToe()
tic_tac_toe.start()

Regardez l’exemple de sortie du code.

python tic_tac_toe.py 
Tour du joueur X
- - -
- - -
- - -
Entrez les numéros de ligne et de colonne pour fixer le point : 1 1

Tour du joueur O
X - -
- - -
- - -
Entrez les numéros de ligne et de colonne pour fixer l'emplacement : 2 1

Tour du joueur X
X - -
O - -
- - -
Entrez les numéros de ligne et de colonne pour fixer l'emplacement : 1 2

Joueur O tour
X X -
O - -
- - -
Entrez les numéros de ligne et de colonne pour fixer le point : 1 3

Tour du joueur X
X X O
O - -
- - -
Entrez les numéros de ligne et de colonne pour fixer le point : 2 2

Tour du joueur O
X X O
O X - -
- - -
Entrez les numéros de ligne et de colonne pour fixer l'emplacement : 3 3

Tour du joueur X
X X O 
O X - 
- - O
Entrez les numéros de ligne et de colonne pour fixer le point : 3 2

Le joueur X gagne la partie !

X X O
O X -
- X O

Quelques points importants qui vous aideront à comprendre la structure du code.

Nous avons utilisé une classe pour regrouper toutes les méthodes en un seul endroit. Elle peut facilement être réutilisée dans d’autres codes.
Ensuite, nous avons défini différentes fonctions pour chaque responsabilité, même s’il s’agit d’une petite tâche. Cela facilite la maintenance du code.
Les deux approches ci-dessus nous aident à mettre à jour l’application sans effort si nous voulons mettre à jour le jeu.

N’hésitez pas à adapter la structure et à l’améliorer en fonction de votre projet. La structuration du code n’est pas limitée.

Mot de la fin

Bravo ! 😎 Vous avez créé un jeu entièrement à partir de zéro. Ce n’est pas l’un des jeux visuels auxquels nous jouons quotidiennement. Mais il vous aide à écrire la logique et à maintenir une structure propre dans le code. Suivez des lignes directrices similaires pour créer des jeux intéressants comme celui-ci. Vous pouvez trouver des jeux similaires si vous revenez quelques années en arrière, dans votre enfance.

Bon codage ! 👩‍💻

Ensuite, découvrez comment créer un jeu de devinettes et des tests unitaires avec le module Python unittest.

Hafeezul Kareem Shaik
Contributeur
- LinkedIn
Hafeez est développeur et aime partager ses connaissances de Python et des langages de développement émergents.