Créer un jeu Tic Tac Toe en Python :didacticiel de code étape par étape

Tic Tac Toe Game en Python est un projet intéressant que vous pouvez essayer. C'est un projet sympa et amusant pour résoudre un défi et peut vous aider à maîtriser les concepts de base en Python. Créer un jeu de morpion amusant vous aide à développer vos compétences.

Vous pouvez utiliser un bon éditeur Python tel que Pycharm ou l'interface de ligne de commande.

Comment jouer au jeu Tic Toc ?

Le jeu Tic Tac Toe est un jeu simple à deux joueurs auquel tout le monde peut jouer sans avoir besoin d'un plateau de jeu. Cela implique deux joueurs marquant des cellules différentes jusqu'à la fin du jeu, en cas de victoire ou d'égalité.

Voici comment jouer au jeu du tic tac toe.

Étape 1) Le jeu de tic tac toe commence avec des cellules vides dans une grille carrée. C'est le tableau de tic tac toe.

Étape 2) Les deux joueurs choisissent parmi deux symboles, généralement X ou Os. Vous pouvez utiliser n'importe quel autre symbole unique dans le jeu.

Étape 3) Le joueur actuel marque à tour de rôle en remplissant les cellules du tableau tic tac toe jusqu'à ce qu'un joueur remplisse une combinaison gagnante. Il s'agit d'une ligne, d'une colonne ou d'une diagonale entière avec le même signe.

Étape 4) Une égalité est également possible si toutes les cellules sont pleines sans gagnant apparent.

Exigences

Construire le projet Python tic tac toe nécessite une compréhension de niveau débutant du langage de programmation Python. Cela inclut la compréhension des boucles et des itérations « for » et ce qu'une instruction if est utilisée en Python.

Vous devez également avoir Python et un éditeur de texte Python installés sur votre ordinateur pour terminer le projet Python tic-tac-toe. Comme il s'agit d'un jeu de morpion de niveau débutant en Python, vous n'aurez besoin d'aucune bibliothèque Python.

Vous aurez peut-être besoin de compétences en débogage afin de trouver des solutions aux bugs dans votre code et vous devez également avoir une compréhension adéquate des composants du jeu.

Algorithme Python Tic Tac Toe

Suivez ces étapes pour créer un jeu de morpion en langage de programmation Python :

Étape 1) Créez le plateau pour commencer le jeu de tic tac toe.

Étape 2) Demandez à l'utilisateur de décider des dimensions du plateau de jeu.

Étape 3) Choisissez au hasard le premier joueur.

Étape 4) Le jeu Tic Tac Toe commence.

Étape 5) Les joueurs jouent en sélectionnant un emplacement vide sur le plateau.

Étape 6) Remplissez l'emplacement vide sélectionné avec le signe du joueur.

Étape 7) Déterminez si un joueur gagne ou obtient une égalité dans le jeu en utilisant la logique du jeu.

Étape 8) Affichez le plateau de jeu après chaque partie si aucun joueur ne gagne ou n'obtient une égalité avec le deuxième joueur.

Étape 9) Affichez respectivement un message d'égalité ou de victoire.

Étape 10) Terminez le jeu de tic tac toe avec des options pour démarrer une nouvelle partie.

Code Python complet pour tic tac toe

# Guru99
# Code developed by Guru99.com
# Guru99 tic-tac-toe game
#Get input
def getInput(prompt, cast=None, condition=None, errorMessage=None):
 while True:
 try:
 val = cast(input(prompt))
 assert condition is None or condition(val)
 return val
 except:
 print(errorMessage or "Invalid input.")
# Print the game board
def printBoard(board):
 print()
 for row in board:
 print(*row)
 print()
# Check if player won using the winning combinations
def checkWin(board):
 # Check rows
 for row in range(len(board)):
 for col in range(len(board)-1):
 if board[row][col] == "_" or board[row][col+1] == "_" or board[row][col] != board[row][col+1]:
 break
 else:
 return True
 # Check column numbers
 for col in range(len(board)):
 for row in range(len(board)-1):
 if board[row][col] == "_" or board[row+1][col] == "_" or board[row][col] != board[row+1][col]:
 break
 else:
 return True
 # Check left diagonal
 for cell in range(len(board)-1):
 if board[cell][cell] == "_" or board[cell+1][cell+1] == "_" or board[cell][cell] != board[cell+1][cell+1]:
 break
 else:
 return True
 # Check right diagonal
 for cell in range(len(board)-1):
 emptyCell = board[cell][len(board)-cell-1] == "_" or board[cell+1][len(board)-cell-2] == "_"
 different = board[cell][len(board)-cell-1] != board[cell+1][len(board)-cell-2]
 if emptyCell or different:
 break
 else:
 return True
 # No win
 return False
# Play tic tac toe game
def play():
 # Introduction
 print("------------\nN-DIMENSIONAL TIC TAC TOE game by guru 99.com \n------------")
 # Set up variables
 N = getInput(prompt="Guru99 says>>> Enter N, the dimensions of the board: ",
 cast=int,
 condition=lambda x: x >= 3,
 errorMessage="Invalid input. Please enter an integer greater than or equal to 3 as explained on guru99.com")
 board = [['_'] * N for _ in range(N)]
 used = 0
 turn = 0
 # Play guru99 tic tac toe game in Python using while infinite loop
 while True:
 # Print guru99 tic tac toe game board
 printBoard(board)
 # Get user pick
 pick = getInput(prompt=f"Player {turn+1} - Pick location (row, col): ",
 cast=lambda line: tuple(map(int, line.split(" "))),
 condition=lambda pair: min(pair) >= 0 and max(pair) < N and board[pair[0]][pair[1]] == "_",
 errorMessage="Invalid input. Please enter a valid, unoccupied location as an integer pair.")
 # Populate location
 board[pick[0]][pick[1]] = "X" if turn == 0 else "O"
 used += 1
 # Check for win
 #Guru99 tutorial
 if checkWin(board):
 printBoard(board)
 print(f"Game over, Player {turn+1} wins.")
 break
 # Check for tie
 elif used == N*N:
 printBoard(board)
 print("Game over. Players have tied the match.")
 print("Guru99.com tic tac toe game ")
 break
 # If no win yet, update next user
 turn = (turn+1)%2
 # Check for rematch
 playAgain = getInput(prompt="Play Guru99 tic tac toe_Game again? (y/n): ",
 cast=str,
 condition=lambda ans: ans.strip("\n").lower() in {"y", "n"},
 errorMessage="Invalid input. Please enter 'y' or 'n'.")
 if playAgain == 'n':
 # End the game
 print("\nGuru99 TicTacToe game ended.")
 return
 else:
 # Rematch
 play()
# Main
if __name__ == '__main__':
 play()

Une fois que vous avez exécuté le code source ci-dessus, vous trouverez ci-dessous le résultat attendu pour un tableau tic tac toe 3 x 3 :

------------
N-DIMENSIONAL TIC TAC TOE game by guru 99.com
------------
Guru99 says>>> Enter N, the dimensions of the board: 3
_ _ _
_ _ _
_ _ _
Player 1 - Pick location (row, col): 1 1
_ _ _
_ X _
_ _ _
Player 2 - Pick location (row, col): 0 1
_ O _
_ X _
_ _ _
Player 1 - Pick location (row, col): 1 2
_ O _
_ X X
_ _ _
Player 2 - Pick location (row, col): 0 2
_ O O
_ X X
_ _ _
Player 1 - Pick location (row, col): 1 0
_ O O
X X X
_ _ _
Game over, Player 1 wins.
Play Guru99 tic tac toe_Game again? (y/n):

Répartition complète du code

Créer le tic tac toe en Python est simple. Décortiquons les différentes fonctions en bits pour comprendre ce qui se passe pour chaque ligne :

Impression du tableau

Le plateau Tic tac toe est l’affichage principal du jeu. Dans, la fenêtre d'affichage Python est utilisée pour afficher le plateau de jeu.

Voici les étapes qui vous aident à créer un tableau pour tic tac toe en Python :

Code Python pour Tic Tac Toe

def getInput(prompt, cast=None, condition=None, errorMessage=None):
 while True:
 try:
 val = cast(input(prompt))
 assert condition is None or condition(val)
 return val
 except:
 print(errorMessage or "Invalid input.")
# Print the board
def printBoard(board):
 print()
 for row in board:
 print(*row)
 print()
N = getInput(prompt="Guru99 says>>> Enter N, the dimensions of the board: ",
 cast=int,
 condition=lambda x: x >= 3,
 errorMessage="Invalid input. Please enter an integer greater than or equal to 3 as explained on guru99.com")
board = [['_'] * N for _ in range(N)]
used = 0
turn = 0
printBoard(board)

Sortie du code :

------------
N-DIMENSIONAL TIC TAC TOE game by guru 99.com
------------
Guru99 says>>> Enter N, the dimensions of the board: 3
_ _ _
_ _ _
_ _ _

Jeu Tic Tac Toe – arrangement gagnant

Pour vérifier si un joueur a gagné, nous devons vérifier les combinaisons gagnantes dans les lignes, les colonnes et les diagonales. S'il y a un gagnant, nous devons afficher un message gagnant.

Lignes

• Pour la ligne, la fonction prend chaque paire de colonnes consécutives et recherche une combinaison gagnante.
• Le premier joueur à remplir les rangées gagne. Le deuxième joueur perd donc.
• Si deux colonnes consécutives sont identiques, alors il est évident que tous les éléments de cette ligne sont identiques.
• Si deux d'entre eux sont différents ou si la ligne contient une cellule vide, il n'y a toujours pas de gagnant.
• Nous implémentons ensuite des conditions perdantes et ajoutons une pause. Si l'une de ces conditions perdantes est vraie, nous n'avons pas de gagnant dans la ligne cochée.
• L'instruction else donne un vrai retour pour montrer qu'il y a un gagnant.
• La pause sort de cette boucle pour passer à la ligne suivante.

Colonnes

Pour les colonnes, on répète la même fonction que pour les lignes. Nous vérifions si un joueur a gagné après que chaque joueur ait choisi sa place.

La ligne diagonale gagne

Pour la diagonale gauche, la tâche devient plus simple. Nous allons toujours comparer les cellules dans les diagonales. Cependant, s'il n'y a pas de gagnant, nous pouvons passer à l'instruction suivante.

Jouer à la logique du jeu

C'est la fonction principale du jeu. Pour cela, nous pouvons utiliser des variables qui stockent des informations.

• La première variable est la taille de la carte stockée dans « N ». Le jeu obtiendra la taille du plateau après avoir demandé à l'utilisateur de saisir un nombre.
• Ainsi, lorsque vous saisissez la valeur, elle est traitée.
• Nous créons également un message d'erreur pour indiquer aux joueurs lorsqu'un numéro non valide est saisi.
• On peut alors créer deux variables qui remplissent un « X » ou un « O » lorsqu'une cellule est remplie.
• Montrez ensuite le plateau de jeu aux joueurs. Après cela, obtenez l'avis du joueur.
• La logique marquera ensuite la cellule sélectionnée comme remplie et recherchera une victoire ou un match nul.
• S'il n'y a pas de gagnant, le jeu demande au joueur suivant de jouer. En cas de victoire ou de match nul, le jeu peut demander aux utilisateurs s'ils souhaitent un nouveau jeu.

Conclusion

• Tic Tac Toe est un jeu amusant à deux joueurs auquel vous pouvez jouer en plaçant un symbole unique dans une cellule vide du tableau.
• La création d'un jeu de morpion en Python nécessite une compréhension de niveau débutant de Python, un éditeur de texte et l'installation de Python.
• L'algorithme vous aide à écrire systématiquement le code dans n'importe quelle langue.
• Pour créer le jeu, commencez par dessiner le tableau et écrivez le code pour déterminer les arrangements gagnants et perdants et
• Vous pouvez tester le code tic-tac-toe en Python en y jouant d'abord.