Créer un jeu Tic-Tac-Toe en C++
L'exemple suivant fournit les bases de la création de ce jeu de tic-tac-toe interactif à deux joueurs. Il présente une approche simple et facile pour le programmer en C++ et fournit un code source bien documenté pour revivre ces défis d'enfance avec des amis dans un nouveau format numérique. Voyons le code suivant.
Exemple : Tic-Tac-Toe de base basé sur la console sans utiliser le tableau 2D
Dans cet exemple, nous utiliserons un tableau 2D, des fonctions et des conditions if-else pour créer le jeu tic-tac-toe en C++. Dans ce jeu, deux joueurs sont autorisés à saisir à tour de rôle leurs mouvements, et cela détermine l'état du jeu en vérifiant s'il y a un gagnant ou une égalité. Voir le code donné suivant :
#include
en utilisant l'espace de noms std ;
vide Tableau à dessin ( carboniser conseil [ 3 ] [ 3 ] ) ;
bool isMoveValid ( carboniser conseil [ 3 ] [ 3 ] , int rangée , int col ) ;
bool isBoardFull ( carboniser conseil [ 3 ] [ 3 ] ) ;
carboniser checkWinner ( carboniser conseil [ 3 ] [ 3 ] ) ;
int principal ( ) {
carboniser conseil [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
int rangée , col ;
carboniser Joueur actuel = 'X' ;
alors que ( vrai ) {
Tableau à dessin ( conseil ) ;
cout << 'Joueur' << Joueur actuel << ' C'est au tour de '. Entrez la ligne (1-3) et la colonne (1-3) : ' ;
manger >> rangée >> col ;
rangée --;
col --;
si ( estMoveValid ( conseil , rangée , col ) ) {
conseil [ rangée ] [ col ] = Joueur actuel ;
carboniser gagnant = checkWinner ( conseil ) ;
si ( gagnant != ' ' ) {
Tableau à dessin ( conseil ) ;
cout << 'Joueur' << gagnant << ' est un gagnant ! \n ' ;
casser ;
}
si ( isBoardFull ( conseil ) ) {
Tableau à dessin ( conseil ) ;
cout << 'C'est une cravate! \n ' ;
casser ;
}
Joueur actuel = ( Joueur actuel == 'X' ) ? 'Ô' : 'X' ;
} autre {
cout << 'Déplacement invalide. Choisissez une autre cellule. \n ' ;
} }
retour 0 ;
}
vide Tableau à dessin ( carboniser conseil [ 3 ] [ 3 ] ) {
cout << 'b| \t 1 \t | \t 2 \t | \t 3 \t | \n ' ;
cout << ' ______________________ \n ' ;
pour ( int m = 0 ; m < 3 ; m ++ ) {
cout << m + 1 << '|' ;
pour ( int t = 0 ; t < 3 ; t ++ ) {
cout << '' << conseil [ m ] [ t ] ;
si ( t < 2 ) cout << ' \t | \t ' ;
}
cout << ' \t | \n ' ;
si ( m < 2 ) cout << ' ______________________ \n ' ;
}
cout << ' \n ' ; }
bool isMoveValid ( carboniser conseil [ 3 ] [ 3 ] , int rangée , int col ) {
retour ( rangée >= 0 && rangée < 3 && col >= 0 && col < 3 && conseil [ rangée ] [ col ] == ' ' ) ;
}
bool isBoardFull ( carboniser conseil [ 3 ] [ 3 ] ) {
pour ( int m = 0 ; m < 3 ; m ++ ) {
pour ( int t = 0 ; t < 3 ; t ++ ) {
si ( conseil [ m ] [ t ] == ' ' ) {
retour FAUX ;
} } }
retour vrai ; }
carboniser checkWinner ( carboniser conseil [ 3 ] [ 3 ] ) {
pour ( int m = 0 ; m < 3 ; m ++ ) {
si ( conseil [ m ] [ 0 ] == conseil [ m ] [ 1 ] && conseil [ m ] [ 1 ] == conseil [ m ] [ 2 ] && conseil [ m ] [ 0 ] != ' ' ) {
retour conseil [ m ] [ 0 ] ;
}
si ( conseil [ 0 ] [ m ] == conseil [ 1 ] [ m ] && conseil [ 1 ] [ m ] == conseil [ 2 ] [ m ] && conseil [ 0 ] [ m ] != ' ' ) {
retour conseil [ 0 ] [ m ] ;
} }
si ( conseil [ 0 ] [ 0 ] == conseil [ 1 ] [ 1 ] && conseil [ 1 ] [ 1 ] == conseil [ 2 ] [ 2 ] && conseil [ 0 ] [ 0 ] != ' ' ) {
retour conseil [ 0 ] [ 0 ] ;
}
si ( conseil [ 0 ] [ 2 ] == conseil [ 1 ] [ 1 ] && conseil [ 1 ] [ 1 ] == conseil [ 2 ] [ 0 ] && conseil [ 0 ] [ 2 ] != ' ' ) {
retour conseil [ 0 ] [ 2 ] ;
}
retour ' ' ;
}
Voici un aperçu de ses fonctionnalités :
Le « #include
Il existe quatre prototypes de fonctions dans ce programme : drawBoard(), isMoveValid(), isBoardFull() et checkWinner(). La déclaration de fonction est connue sous le nom de prototype de fonction. Bien qu'elle vienne après la fonction principale du programme, elle sera utilisée. La fonction principale contient la boucle de jeu et la logique pour gérer les tours et les mouvements des joueurs. Au sein de la fonction principale, le plateau de jeu est initialisé avec des espaces.
carboniser conseil [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
Après cela, deux variables de ligne et de col sont définies pour stocker l'entrée de mouvement du joueur. Le 'char currentPlayer = 'X';' définit que le joueur « X » commence.
Maintenant, la boucle de jeu while (vrai) commence et se poursuit jusqu'à ce qu'il y ait un gagnant ou une égalité. Cette boucle « while » appelle « drawBoard(); » pour afficher le tableau. Après avoir affiché le tableau sur la console, l'utilisateur est invité à choisir une cellule à marquer dans l'instruction de code suivante :
cout << 'Joueur' << Joueur actuel << ' C'est au tour de '. Entrez la ligne et la colonne (1-3) : ' ;
Le joueur saisit son mouvement dans « cin >> row >> col; ».
Lors de la sélection d'une cellule à marquer, le programme vérifiera d'abord la validité de l'entrée, en s'assurant que la cellule n'est pas déjà remplie en appelant la fonction isMoveValid().
conseil [ rangée ] [ col ] = Joueur actuel ;Cette déclaration place la marque du joueur sur le plateau.
carboniser gagnant = checkWinner ( conseil ) ;si ( gagnant != ' ' ) {
Tableau à dessin ( conseil ) ;
cout << 'Joueur' << gagnant << 'gagne ! \n ' ;
Ces déclarations vérifient un gagnant chaque fois qu'un joueur marque une entrée sur le tableau. Le nom du gagnant sera annoncé s’il y a un gagnant et le programme quittera la boucle du jeu.
si ( isBoardFull ( conseil ) ) {Cette déclaration vérifie l'égalité. La condition d'égalité se produit dans le cas où le tableau est plein et qu'il n'y a pas de gagnant. Dans ce cas, « c’est égalité ! » est imprimé sur l'écran.
Joueur actuel = ( Joueur actuel == 'X' ) ? 'Ô' : 'X' ;Cette instruction change les joueurs pour donner à chaque joueur une chance de jouer son tour.
cout << 'Déplacement invalide. Choisissez une autre cellule. \n ' ;Si le déplacement n'est pas valide, l'utilisateur est invité à saisir à nouveau et à choisir une autre cellule.
Après la fonction « principale », les définitions de fonctions pour les prototypes de fonctions précédemment déclarés commenceront. La première fonction définie ici est drawBoard() qui est utilisée pour dessiner le tableau tic-tac-toe sur la console. La fonction drawBoard() imprime l'état actuel du tableau, y compris les lignes de la grille.
La fonction suivante définie ici est isMoveValid(). Cette fonction permet de déterminer si un déplacement est autorisé à la fois à l'intérieur du plateau et sur une cellule vide. La fonction isBoardFull() permet de vérifier si le tableau est encore plein. C'est une condition pour une situation d'égalité lorsqu'il n'y a pas de gagnant. isBoardFull() vérifie si toutes les positions du tableau sont occupées, ce qui indique une égalité s'il n'y a pas de gagnant. S'il y a un gagnant, il peut être déterminé à l'aide de la fonction checkWinner(). Le checkWinner() vérifie toutes les lignes gagnantes potentielles pour la marque du même joueur (« X » ou « O ») et renvoie la marque du joueur gagnant s'il est trouvé ou un espace « » s'il n'y a pas encore de gagnant. Ce qui suit est le résultat du programme. Il montre chaque tour de chaque joueur.
Premièrement, le tableau est clair ; le joueur « X » est invité à choisir la cellule à marquer. Ici, le joueur « X » entre 2 et 2. Les cellules de la ligne 2 et de la colonne 2 sont marquées. Reportez-vous au tableau marqué dans ce qui suit :
C’est maintenant au tour du joueur O. Le joueur est invité à choisir une cellule à marquer. Le joueur « O » choisit 1 pour la ligne et 1 pour la colonne. La cellule choisie est marquée pour le joueur « O », comme indiqué dans l'extrait de sortie suivant :
Tous les tours de chaque joueur suivront le même schéma. C'est au tour du joueur X, et le joueur choisit 1 pour la ligne et 2 pour la colonne. Reportez-vous aux instantanés de sortie suivants :
Maintenant, c'est au joueur « O » de jouer. Le joueur choisit 1 pour la ligne et 3 pour la colonne.
Le tour suivant revient à nouveau au joueur « X ». Le joueur en choisit 3 pour la ligne et 1 pour la colonne.
Le joueur « O » en choisit 3 pour la ligne et 2 pour la colonne.
Le joueur « X » sélectionne la deuxième ligne et la troisième colonne.
Le joueur « O » sélectionne désormais la deuxième ligne et la première colonne.
Le joueur « X » choisit cette fois la troisième ligne et la troisième colonne.
Aucun joueur ne peut tracer une ligne horizontalement, verticalement ou en diagonale, c'est donc une égalité. Il n’y a pas de gagnant pour la gamme d’entrées choisie.
Dans l'ensemble, le code comprend une boucle de jeu principale chargée de gérer l'état du jeu et les entrées de l'utilisateur, ainsi que plusieurs fonctions utilitaires utilisées pour dessiner le plateau, valider les mouvements, vérifier si le plateau est plein et déterminer s'il y a un gagnant. .
Conclusion
Développer un jeu de morpion en C++ est un excellent exercice pratique pour renforcer vos compétences en programmation. L'article explique avec précision comment créer un tic-tac-toe en C++. Les conseils étape par étape fournis dans cet article englobaient un tableau 2D, des fonctions et des conditions if-else permettant aux lecteurs de comprendre les mécanismes de jeu, les interactions des utilisateurs et la structuration efficace du code. La présentation détaillée du code et l'explication des fonctions essentielles au gameplay de base offrent aux lecteurs des informations inestimables sur les pratiques de programmation C++ et les subtilités d'un développement de jeu simple.