Comment créer un jeu de morpion en Python ?

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

Le jeu est l'un des divertissements que les humains ont. Nous pouvons trouver différents types de jeux sur le Web, les mobiles, les ordinateurs de bureau, etc. Nous ne sommes pas ici pour créer un de ces jeux lourds maintenant. Nous allons créer un jeu CLI tic-tac-toe en utilisant Python.

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

tic tac orteil

Le didacticiel est divisé en trois sections différentes. Dans la première section, vous apprendrez à jouer au jeu de morpion. Après cela, nous verrons un algorithme qui nous aide à trouver 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à jouer à Tic Tac Toe.

Alors, sans plus tarder, plongeons-nous dans notre première section.

Jouer au tic tac toe

Il y aura deux joueurs dans un match. Deux signes représentent chaque joueur. Les signes généraux utilisés dans le jeu sont X et O . Enfin, il y aura un plateau avec 9 cases.

Voir le tableau de tic-tac-toe visuellement.

Le gameplay sera le suivant.

• Tout d'abord, un utilisateur placera 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 ou en colonne, ou en diagonale.
• Le jeu continue jusqu'à ce qu'un joueur gagne le jeu ou qu'il se termine par un match nul en remplissant toutes les cases sans match gagnant.

Voyons quelques gameplays visuellement.

Le joueur X gagne la partie dans le gameplay ci-dessus. Toutes les cases se remplissent en diagonale avec des signes X. Ainsi, le joueur respectif gagne la partie.

Il y a un total de 8 façons d'organiser le même signe et de gagner la partie. Voyons tous les 8 arrangements qui peuvent gagner la partie.

Et enfin, un tirage au sort remplit le tableau sans aucun arrangement gagnant. J'espère que vous comprenez comment Tic Tac Toe maintenant.

Maintenant, c'est l'heure du jeu pour vous. Vous pouvez aller ici et y jouer pour comprendre complètement le gameplay. Laissez-le si vous l'avez déjà.

Maintenant, il est temps de déplacer la section algorithme.

Algorithme

Nous allons maintenant discuter de l'algorithme pour écrire le code. Cet algorithme vous aidera à écrire du code dans n'importe quel langage de programmation de votre choix. Voyons comment c'est fait.

• Créez un tableau à l'aide d'un tableau à 2 dimensions et initialisez chaque élément comme vide.
  • Vous pouvez représenter le vide en utilisant n'importe quel symbole que vous aimez. Ici, nous allons utiliser un tiret. '-' .
• Écrivez une fonction pour vérifier si le tableau est rempli ou non.
  • Itérer sur le tableau et renvoyer false si le tableau contient un signe vide ou sinon renvoyer true .
• Écrivez 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 montrerons le tableau plusieurs fois aux utilisateurs pendant qu'ils jouent.
• Écrivez une fonction pour démarrer le jeu.
  • Sélectionnez le premier tour du joueur au hasard.
  • Écrivez une boucle infinie qui s'interrompt lorsque le jeu est terminé (gagnant ou nul).
    • Montrez le tableau à l'utilisateur pour sélectionner l'endroit pour le prochain coup.
    • Demandez à l'utilisateur d'entrer le numéro de ligne et de colonne.
    • Mettez à jour l'endroit 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 gagnant et brisez la boucle infinie.
    • Ensuite, vérifiez si le tableau est rempli ou non.
    • Si le tableau est rempli, imprimez le message de dessin et brisez la boucle infinie.
  • Enfin, montrez à l'utilisateur la vue finale du tableau.

Vous pourrez peut-être visualiser ce qui se passe. Ne vous inquiétez pas, même si vous ne l'avez pas complètement compris. Vous obtiendrez plus de clarté une fois que vous verrez le code.

Alors, passons à la section code. Je suppose que Python est installé sur votre PC pour essayer le code.

Code

Passez par le code ci-dessous.

 import random class 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] = player def is_player_win(self, player): win = None n = len(self.board) # checking rows for i in range(n): win = True for j in range(n): if self.board[i][j] != player: win = False break if win: return win # checking columns for i in range(n): win = True for j in range(n): if self.board[j][i] != player: win = False break if win: return win # checking diagonals win = True for i in range(n): if self.board[i][i] != player: win = False break if win: return win win = True for i in range(n): if self.board[i][n - 1 - i] != player: win = False break if win: return win return False for row in self.board: for item in row: if item == '-': 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"Player {player} turn") self.show_board() # taking user input row, col = list( map(int, input("Enter row and column numbers to fix spot: ").split())) print() # fixing the spot self.fix_spot(row - 1, col - 1, player) # checking whether current player is won or not if self.is_player_win(player): print(f"Player {player} wins the game!") break # checking whether the game is draw or not if self.is_board_filled(): print("Match Draw!") break # swapping the turn player = self.swap_player_turn(player) # showing the final view of board print() self.show_board() # starting the game tic_tac_toe = TicTacToe() tic_tac_toe.start()

Découvrez l'exemple de sortie du code.

 $ python tic_tac_toe.py Player X turn - - - - - - - - - Enter row and column numbers to fix spot: 1 1 Player O turn X - - - - - - - - Enter row and column numbers to fix spot: 2 1 Player X turn X - - O - - - - - Enter row and column numbers to fix spot: 1 2 Player O turn XX - O - - - - - Enter row and column numbers to fix spot: 1 3 Player X turn XXO O - - - - - Enter row and column numbers to fix spot: 2 2 Player O turn XXO OX - - - - Enter row and column numbers to fix spot: 3 3 Player X turn XXOOX - - - O Enter row and column numbers to fix spot: 3 2 Player X wins the game! XXO OX - - XO

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

• Nous avons utilisé une classe pour avoir toutes les méthodes en un seul endroit. Il peut également s'agir d'un ensemble réutilisable dans un autre code.
• Ensuite, nous avons défini différentes fonctions pour chaque responsabilité, même si c'est une petite tâche. Cela aide à maintenir le code avec facilité.
• 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.

Derniers mots

Hourra! 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 cela vous aide à écrire une logique et à maintenir une structure propre dans le code. Suivez des directives similaires pour créer des jeux intéressants comme celui-ci. Vous pouvez trouver des jeux similaires si vous retournez quelques années dans votre enfance.

Bon codage !

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