Comment créer un jeu textuel de base en C++
Les jeux textuels en C++ permettent au joueur de saisir des commandes via une fenêtre de console et le programme traite les mouvements du joueur. Ici, j'ai créé un jeu de tic-tac-toe basé sur du texte qui permet à l'utilisateur de jouer avec deux options. L'utilisateur peut jouer avec le compilateur C++ ou avec un autre humain. Ce jeu a une fonctionnalité qui continue d'additionner le score du joueur gagnant. Une fois le résultat du premier match annoncé, une option de revanche est disponible.
Règles pour gagner le jeu
Deux joueurs jouent à un jeu de tic-tac-toe, en plaçant alternativement X et 0 dans l'un des neuf espaces disponibles sur une grille de trois par trois. La partie est gagnée par le premier joueur à obtenir trois de ses marques consécutives dans le sens vertical, horizontal ou diagonal. Chaque joueur doit réfléchir intelligemment et anticiper le prochain mouvement de l'autre joueur.
Le code permettant de concevoir un jeu de tic-tac-toe basé sur du texte comporte différentes sections, divisées en fonction des fonctionnalités. Dans la première section, l'utilisateur décide s'il souhaite jouer avec un ordinateur ou avec un autre humain. Après avoir décidé du mode de gain, le programme demande une entrée à l'utilisateur. Les deux joueurs entrent l’un après l’autre.
// Prendre les commentaires des joueurs
vide joueurEntrée ( Joueur & joueur ) {
int position ;
cout << fin ;
cout << ' \t ' << joueur. obtenirNom ( ) << ' Tourner: ' ;
cout << ' \t Entrez le poste ' <> position ;
position - = 1 ;
si ( indexvide [ position ] == 1 ) {
cout << '-----Position non vide-------' << fin ;
joueurEntrée ( joueur ) ;
} autre {
indexvide [ position ] = 1 ;
compte vide - = 1 ;
joueur. obtenirNom ( ) . comparer ( 'Joueur I' ) == 0 ? conseil [ position ] = 'X' : conseil [ position ] = 'Ô' ;
}
}
Après avoir pris les entrées de l'utilisateur, il vérifie la règle de victoire. La fonction checkWin() possède deux paramètres p1 et p2 pour vérifier si le joueur a gagné ou non. Différentes variables sont déclarées dans la fonction i, j et k sont des variables entières déclarées pour la boucle et le drapeau est une fonction booléenne pour vérifier la condition de victoire. La boucle commence à partir de la toute première position et continue de parcourir les neuf positions. Le first_symbol est un caractère qui peut être 0 ou X s'il est vrai, alors toutes les combinaisons possibles sont vérifiées pour la règle gagnante. Sinon, l'itérateur passe à la position suivante, et cela continue jusqu'à ce que toutes les positions possibles soient vérifiées. Si le drapeau est défini sur vrai, alors un gagnant est déclaré et le programme demande de refaire son choix.
vide vérifierGagner ( Joueur & p1,Joueur & p2 ) {
int je,j,k ;
bouffon drapeau = FAUX ;
carboniser premier_symbole ;
pour ( je = 0 ; je < 8 ; je ++ ) {
premier_symbole = conseil [ liste gagnante [ je ] . rangée [ 0 ] ] ;
si ( ( premier_symbole ! = 'X' ) && ( premier_symbole ! = 'Ô' ) ) {
drapeau = FAUX ;
continuer ;
}
drapeau = vrai ;
pour ( j = 0 ; j < 3 ; j ++ ) {
si ( premier_symbole ! = conseil [ liste gagnante [ je ] . rangée [ j ] ] ) {
drapeau = FAUX ;
casser ;
}
}
si ( drapeau ) {
jeu activé = 0 ;
si ( premier_symbole == 'X' ) {
cout << '------------------------' << fin ;
cout << ' \t Joueur que j'ai gagné' << fin ;
cout << '------------------------' << fin ;
p1. gagné ( ) ;
} autre {
p2. gagné ( ) ;
si ( contreOrdinateur ) {
cout << '------------------------' << fin ;
cout << ' \t Ordinateur GAGNÉ' << fin ;
cout << '------------------------' << fin ;
} autre {
cout << '------------------------' << fin ;
cout << ' \t Joueur II GAGNÉ' << fin ;
cout << '------------------------' << fin ;
}
}
displayScore ( p1,p2 ) ;
casser ;
}
Cette partie du code montre le score du jeu. Si le jeu se déroule contre un ordinateur, alors le score du joueur 1 et de l'ordinateur est affiché, sinon, le score du joueur 1 et du joueur 2 est affiché.
vide displayScore ( Joueur & p1, joueur & p2 ) {
cout << fin ;
cout << ' \t SCORE: \t ' ;
si ( contreOrdinateur )
cout << ' Joueur I : ' << p1. obtenirScore ( ) << ' \t Ordinateur: ' << p2. obtenirScore ( ) << fin ;
autre
cout << ' Joueur I : ' << p1. obtenirScore ( ) << ' \t Joueur II : ' << p2. obtenirScore ( ) << fin ;
}
Il s'agit du code principal pour l'exécution d'un jeu de tic-tac-toe pour deux joueurs. L'utilisateur peut choisir parmi une variété de procédures à effectuer à l'aide de l'instruction switch case. Ce code fournit une interface conviviale pour jouer à un jeu sur un compilateur C++, et le code continue de s'exécuter jusqu'à ce que l'utilisateur sélectionne l'option de sortie.
int principal ( ){
int ch ;
alors que ( 1 ) {
cout << ' ----------MENU----------' << fin ;
cout << ' \t 1. Jeu à 1 joueur' << fin ;
cout << ' \t 2. Jeu à 2 joueurs' << fin ;
cout << ' \t 3. Pour quitter ' << fin ;
cout << ' ----------' << fin ;
cout << fin ;
cout << ' \t Choisir une option' <> ch ;
changer ( ch ) {
cas 1 : {
Jeu * jeu = nouveau Jeu ;
jeu - > chaleur ( ) ;
jeu - > unJoueurJeu ( ) ;
}
casser ;
cas 2 : {
Jeu * jeu = nouveau Jeu ;
jeu - > chaleur ( ) ;
jeu - > jeu à deux joueurs ( ) ;
}
casser ;
cas 3 :
retour 0 ;
défaut :
cout << 'Option non valide pour les POO ! ESSAYEZ À NOUVEAU' ;
}
}
retour 0 ;
}
Code complet pour un jeu Tic-Tac-Toc basé sur du texte
Il s'agit d'un code complet pour la conception et l'exécution d'un jeu de tic-tac-toe basé sur du texte.
#include
#include
#include
#include
#inclure
en utilisant espace de noms norme ;
typedef structurer {
int * rangée ;
} Liste gagnante ;
classe Joueur {
privé :
nom de chaîne ;
int score ;
publique :
Joueur ( ) : Joueur { '' } { }
Joueur ( chaîne m ) : score { 0 } , nom { n } { }
vide gagné ( ) {
//incrémente le score
score ++ ;
}
int obtenirScore ( ) { retour ce - > score ; }
chaîne getName ( ) { retour ce - > nom ; }
} ;
classe Jeu {
privé :
carboniser conseil [ 9 ] ;
int indexvide [ 9 ] ;
int jeuSur, contreOrdinateur ;
int compte vide ;
Liste des victoires WinList [ 8 ] ;
vide panneau d'affichage ( ) {
cout << fin ;
cout << ' | | ' << fin ;
cout << ' ' << conseil [ 0 ] << ' | ' << conseil [ 1 ] << ' | ' << conseil [ 2 ] << fin ;
cout << ' | | ' << fin ;
cout << '---------------' << fin ;
cout << ' | | ' << fin ;
cout << ' ' << conseil [ 3 ] << ' | ' << conseil [ 4 ] << ' | ' << conseil [ 5 ] << fin ;
cout << ' | | ' << fin ;
cout << '---------------' << fin ;
cout << ' | | ' << fin ;
cout << ' ' << conseil [ 6 ] << ' | ' << conseil [ 7 ] << ' | ' << conseil [ 8 ] << fin ;
cout << ' | | ' << fin ;
cout << fin ;
}
vide ordinateurEntrée ( ) {
int position ;
position = rand ( ) % dix ;
si ( indexvide [ position ] == 1 ) {
si ( compte vide < 0 )
retour ;
ordinateurEntrée ( ) ;
} autre {
cout << 'Ordinateur choisir : ' << position + 1 << fin ;
indexvide [ position ] = 1 ;
compte vide - = 1 ;
conseil [ position ] = 'Ô' ;
}
}
vide joueurEntrée ( Joueur & joueur ) {
int position ;
cout << fin ;
cout << ' \t ' << joueur. obtenirNom ( ) << ' Tourner: ' ;
cout << ' \t Entrez le poste ' <> position ;
position - = 1 ;
si ( indexvide [ position ] == 1 ) {
cout << '-----Position non vide-------' << fin ;
joueurEntrée ( joueur ) ;
} autre {
indexvide [ position ] = 1 ;
compte vide - = 1 ;
joueur. obtenirNom ( ) . comparer ( 'Joueur I' ) == 0 ? conseil [ position ] = 'X' : conseil [ position ] = 'Ô' ;
}
}
vide vérifierGagner ( Joueur & p1,Joueur & p2 ) {
int je,j,k ;
bouffon drapeau = FAUX ;
carboniser premier_symbole ;
pour ( je = 0 ; je < 8 ; je ++ ) {
premier_symbole = conseil [ liste gagnante [ je ] . rangée [ 0 ] ] ;
si ( ( premier_symbole ! = 'X' ) && ( premier_symbole ! = 'Ô' ) ) {
drapeau = FAUX ;
continuer ;
}
drapeau = vrai ;
pour ( j = 0 ; j < 3 ; j ++ ) {
si ( premier_symbole ! = conseil [ liste gagnante [ je ] . rangée [ j ] ] ) {
drapeau = FAUX ;
casser ;
}
}
si ( drapeau ) {
jeu activé = 0 ;
si ( premier_symbole == 'X' ) {
cout << '------------------------' << fin ;
cout << ' \t Joueur que j'ai gagné' << fin ;
cout << '------------------------' << fin ;
p1. gagné ( ) ;
} autre {
p2. gagné ( ) ;
si ( contreOrdinateur ) {
cout << '------------------------' << fin ;
cout << ' \t Ordinateur GAGNÉ' << fin ;
cout << '------------------------' << fin ;
} autre {
cout << '------------------------' << fin ;
cout << ' \t Joueur II GAGNÉ' << fin ;
cout << '------------------------' < 0 ) && ( jeu activé ! = 0 ) ) {
si ( contreOrdinateur )
main == 1 ? ordinateurEntrée ( ) : joueurEntrée ( p2 ) ;
autre
main == 1 ? joueurEntrée ( p1 ) : joueurEntrée ( p2 ) ;
main = ! main ;
panneau d'affichage ( ) ;
vérifierGagner ( p1,p2 ) ;
}
si ( compte vide <= 0 ) {
cout << ' -----------------------' << fin ;
cout << ' \t Pas de GAGNANT' << fin ;
cout << ' -----------------------' << fin ;
}
cout << fin ;
cout <> revanche ;
si ( ( revanche == 'ET' ) || ( revanche == 'et' ) ) {
chaleur ( ) ;
jouer ( p1,p2 ) ;
}
}
vide displayScore ( Joueur & p1, joueur & p2 ) {
cout << fin ;
cout << ' \t SCORE: \t ' ;
si ( contreOrdinateur )
cout << ' Joueur I : ' << p1. obtenirScore ( ) << ' \t Ordinateur: ' << p2. obtenirScore ( ) << fin ;
autre
cout << ' Joueur I : ' << p1. obtenirScore ( ) << ' \t Joueur II : ' << p2. obtenirScore ( ) << fin ;
}
publique :
Jeu ( ) : compte vide { 0 } , jeu activé { 1 } , contreOrdinateur { 0 } {
chaleur ( ) ;
liste gagnante [ 0 ] . rangée = nouveau int [ 3 ] { 0 , 1 , 2 } ;
liste gagnante [ 1 ] . rangée = nouveau int [ 3 ] { 3 , 4 , 5 } ;
liste gagnante [ 2 ] . rangée = nouveau int [ 3 ] { 6 , 7 , 8 } ;
liste gagnante [ 3 ] . rangée = nouveau int [ 3 ] { 0 , 3 , 6 } ;
liste gagnante [ 4 ] . rangée = nouveau int [ 3 ] { 1 , 4 , 7 } ;
liste gagnante [ 5 ] . rangée = nouveau int [ 3 ] { 2 , 5 , 8 } ;
liste gagnante [ 6 ] . rangée = nouveau int [ 3 ] { 0 , 4 , 8 } ;
liste gagnante [ 7 ] . rangée = nouveau int [ 3 ] { 2 , 4 , 6 } ;
}
vide chaleur ( ) {
jeu activé = 1 ;
compte vide = 0 ;
sable ( temps ( 0 ) ) ;
pour ( taille_t je = 0 ; je < dix ; je ++ ) {
indexvide [ je ] = 0 ;
conseil [ je ] = ( je + 1 ) + '0' ;
compte vide ++ ;
}
compte vide -- ;
}
vide unJoueurJeu ( ) {
//Création du joueur
Joueur p ( 'Joueur I' ) ;
Joueur c ( 'Ordinateur' ) ;
cout << ' -------------' << fin ;
cout << ' \t Joueur I : X \t Ordinateur : O' << fin ;
cout << ' -------------' << fin ;
cout << fin ;
contreOrdinateur = 1 ;
jouer ( c,p ) ;
}
vide jeu à deux joueurs ( ) {
//Création du joueur
Joueur p ( 'Joueur I' ) ;
Joueur c ( 'Joueur II' ) ;
cout << ' -------------' << fin ;
cout << ' \t Joueur I : X \t Joueur II : O » << fin ;
cout << ' -------------' << fin ;
cout << fin ;
contreOrdinateur = 0 ;
jouer ( c,p ) ;
}
} ;
int principal ( )
{
int ch ;
alors que ( 1 ) {
cout << ' ----------MENU----------' << fin ;
cout << ' \t 1. Jeu à 1 joueur' << fin ;
cout << ' \t 2. Jeu à 2 joueurs' << fin ;
cout << ' \t 3. Pour quitter ' << fin ;
cout << ' ----------' << fin ;
cout << fin ;
cout << ' \t Choisir une option' <> ch ;
changer ( ch ) {
cas 1 : {
Jeu * jeu = nouveau Jeu ;
jeu - > chaleur ( ) ;
jeu - > unJoueurJeu ( ) ;
}
casser ;
cas 2 : {
Jeu * jeu = nouveau Jeu ;
jeu - > chaleur ( ) ;
jeu - > jeu à deux joueurs ( ) ;
}
casser ;
cas 3 :
retour 0 ;
défaut :
cout << 'Option non valide pour les POO ! ESSAYEZ À NOUVEAU' ;
}
}
retour 0 ;
}
Il s'agit d'un code complet pour l'exécution du jeu tic-tac-toe, qui peut être joué selon deux modes, soit avec un ordinateur, soit avec un autre humain. Il s'agit d'un code polyvalent, incluant toutes les commandes possibles. Lorsque l'utilisateur saisit un poste déjà pourvu, il n'écrase pas ce poste et considère ce déplacement comme invalide.
Jusqu'à présent, le premier joueur a sélectionné la première case, puis au tour suivant, l'ordinateur a marqué la sixième case :
Les deux joueurs ont sélectionné les deux cases jusqu'à présent et au tour suivant, le joueur I choisit la septième case, ce qui crée un motif vertical consécutif :
L'utilisateur choisit d'utiliser l'ordinateur pour jouer à un jeu, donc après avoir effectué trois coups, l'utilisateur a gagné depuis l'ordinateur et un score est ajouté au record du joueur 1. Une fois le premier match terminé, le compilateur demande la revanche. L'utilisateur décide parmi les options et le programme revient à la section principale. Après avoir choisi la troisième option, le compilateur exécute le code.
Conclusion
Les jeux basés sur du texte reposent sur des caractères de texte et une interface de ligne de commande pour l'interaction avec le joueur. Ils n'ont pas d'images graphiques, de sons ou d'animations. L'utilisateur saisit la commande via la fenêtre de la console. Le jeu de tic-tac-toe convivial basé sur du texte est construit en C++. Il utilise différentes commandes pour créer un jeu qui peut être joué avec un ordinateur ou avec un autre joueur.