Concevoir un jeu de Tic Tac Toe en Python
Plongeons ensemble dans la création d’un jeu de Tic Tac Toe (Morpion) en Python. Cet exercice vous permettra de saisir la logique d’un jeu et d’apprendre à structurer votre code de manière efficace.
Les jeux font partie intégrante du divertissement humain. Que ce soit sur le web, mobile ou ordinateur, les options sont multiples. Cependant, nous allons nous concentrer sur la création d’un jeu de morpion en ligne de commande (CLI) en utilisant Python. Notre but n’est pas de concevoir un jeu complexe, mais d’établir les bases solides.
Si vous n’êtes pas familier avec le concept du Tic Tac Toe, vous pouvez jeter un coup d’œil ici pour en comprendre le fonctionnement. Ne vous inquiétez pas, nous allons détailler toutes les règles.
Structure du Tutoriel
Ce tutoriel se divise en trois parties distinctes. La première est une présentation du jeu Tic Tac Toe. Ensuite, nous aborderons l’algorithme nécessaire pour la logique du jeu. Enfin, nous allons examiner le code structuré avec une explication détaillée.
Si vous êtes déjà un expert du Tic Tac Toe, vous pouvez passer directement à la section suivante.
Alors, sans plus attendre, commençons par la première partie.
Le Jeu du Morpion
Une partie de morpion oppose deux joueurs. Chacun est représenté par un symbole, généralement ‘X’ et ‘O’. Le jeu se déroule sur un plateau composé de 9 cases.
Vous pouvez visualiser un plateau de Tic Tac Toe ci-dessous:
Tableau de Tic Tac Toe
Le déroulement d’une partie est simple :
- Un joueur place son symbole dans une des cases vides disponibles.
- Le second joueur fait de même.
- L’objectif est d’aligner trois de ses symboles, horizontalement, verticalement ou en diagonale.
- Le jeu continue jusqu’à ce qu’un joueur gagne ou que toutes les cases soient remplies, menant à une égalité.
Illustrons cela avec quelques exemples de parties :
Exemple de Victoire au Tic Tac Toe
Dans l’exemple ci-dessus, le joueur X a remporté la partie en alignant ses symboles en diagonale.
Il existe un total de 8 combinaisons gagnantes possibles. Voici un aperçu de ces 8 configurations:
Combinaisons Gagnantes au Tic Tac Toe
Si aucune combinaison gagnante n’est réalisée et que toutes les cases sont remplies, alors il y a égalité. J’espère que vous avez compris les règles du Tic Tac Toe maintenant.
Si vous souhaitez vous entraîner, vous pouvez vous rendre ici. Sinon, passons à la partie suivante.
L’Algorithme
Nous allons maintenant détailler l’algorithme qui nous permettra de coder le jeu. Cet algorithme est adaptable à n’importe quel langage de programmation. Voici les étapes clés:
- Créer un tableau à 2 dimensions pour représenter le plateau de jeu, en initialisant chaque case à vide.
- Un tiret ‘-‘ sera notre symbole pour représenter une case vide.
- Écrire une fonction pour vérifier si le plateau est rempli.
- Cette fonction va parcourir le plateau et retourner « faux » s’il existe une case vide, et « vrai » sinon.
- Créer une fonction pour déterminer si un joueur a gagné.
- Cette fonction va vérifier toutes les combinaisons gagnantes possibles (lignes, colonnes et diagonales).
- Écrire une fonction pour afficher le plateau à l’écran.
- Écrire une fonction pour lancer le jeu.
- Déterminer au hasard quel joueur commence la partie.
- Mettre en place une boucle infinie qui se termine lorsqu’il y a une victoire ou une égalité.
- Afficher le plateau de jeu.
- Demander au joueur d’indiquer la ligne et la colonne où il souhaite placer son symbole.
- Mettre à jour le plateau avec le symbole du joueur.
- Vérifier si le joueur actuel a gagné la partie.
- Si oui, afficher un message de victoire et sortir de la boucle.
- Sinon, vérifier si le plateau est rempli.
- Si c’est le cas, afficher un message d’égalité et sortir de la boucle.
- Enfin, afficher le plateau final à l’écran.
Vous commencez peut-être à visualiser le déroulement du jeu. Ne vous inquiétez pas si tout n’est pas parfaitement clair. Le code apportera davantage de précision.
Passons maintenant à la section du code. Assurez-vous que Python est installé sur votre ordinateur pour pouvoir tester le code.
Le Code Source
Voici le code que nous allons utiliser:
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"Tour du joueur {player}")
self.show_board()
# taking user input
row, col = list(
map(int, input("Entrez le numéro de ligne et de colonne : ").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"Le joueur {player} a gagné la partie!")
break
# checking whether the game is draw or not
if self.is_board_filled():
print("Match nul!")
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()
Voici un exemple de sortie de ce code:
$ python tic_tac_toe.py Tour du joueur X - - - - - - - - - Entrez le numéro de ligne et de colonne : 1 1 Tour du joueur O X - - - - - - - - Entrez le numéro de ligne et de colonne : 2 1 Tour du joueur X X - - O - - - - - Entrez le numéro de ligne et de colonne : 1 2 Tour du joueur O X X - O - - - - - Entrez le numéro de ligne et de colonne : 1 3 Tour du joueur X X X O O - - - - - Entrez le numéro de ligne et de colonne : 2 2 Tour du joueur O X X O O X - - - - Entrez le numéro de ligne et de colonne : 3 3 Tour du joueur X X X O O X - - - O Entrez le numéro de ligne et de colonne : 3 2 Le joueur X a gagné la partie! X X O O X - - X O
Quelques points importants à retenir concernant la structure du code :
- Nous avons utilisé une classe afin de regrouper toutes les méthodes en un seul endroit, ce qui permet une réutilisation aisée.
- Chaque fonctionnalité du jeu est implémentée dans une fonction dédiée, même pour des actions simples. Cela facilite la maintenance du code.
- Ces deux approches permettent une mise à jour aisée du jeu si nous souhaitons ajouter ou modifier des fonctionnalités.
N’hésitez pas à modifier cette structure et à l’améliorer en fonction de vos besoins. La structuration du code n’est pas une science exacte.
Conclusion
Félicitations ! 😎 Vous avez créé un jeu de zéro. Bien que ce ne soit pas un jeu visuel comme ceux auxquels nous jouons quotidiennement, cela vous permet d’acquérir des compétences en logique de programmation et en structuration de code. Appliquez ces mêmes principes pour concevoir d’autres jeux intéressants. Vous pouvez vous inspirer de jeux simples que vous avez peut-être connus dans votre enfance.
Bon codage ! 👩💻
Pour la suite, vous pourriez explorer comment créer un jeu de devinettes et utiliser les tests unitaires avec le module Python unittest.
Avez-vous apprécié cet article ? Partagez-le avec vos amis !