So erstellen Sie ein einfaches textbasiertes Spiel in C++
Bei textbasierten Spielen in C++ kann der Spieler Befehle über ein Konsolenfenster eingeben und das Programm verarbeitet die Bewegungen des Spielers. Hier habe ich ein textbasiertes Tic-Tac-Toe-Spiel erstellt, das dem Benutzer zwei Spieloptionen bietet. Der Benutzer kann entweder mit dem C++-Compiler oder mit einem Mitmenschen spielen. Dieses Spiel verfügt über eine Funktion, die die Punktzahl für den Gewinner fortlaufend addiert. Nachdem das Ergebnis des ersten Spiels bekannt gegeben wurde, ist eine Rückkampfoption verfügbar.
Regeln zum Gewinnen des Spiels
Zwei Spieler spielen ein Tic-Tac-Toe-Spiel, bei dem sie X und 0 abwechselnd auf einem der neun verfügbaren Felder eines Drei-mal-Drei-Rasters platzieren. Das Spiel gewinnt der Spieler, der als erster drei seiner aufeinanderfolgenden Punkte in vertikaler, horizontaler oder diagonaler Richtung erzielt. Jeder Spieler muss klug denken und vorausschauend auf den nächsten Zug des anderen Spielers achten.
Der Code zum Entwerfen eines textbasierten Tic-Tac-Toe-Spiels besteht aus verschiedenen Abschnitten, die nach Funktionalität unterteilt sind. Im ersten Abschnitt entscheidet der Nutzer, ob er mit einem Computer oder einem Mitmenschen spielt. Nachdem der Verstärkungsmodus festgelegt wurde, fordert das Programm den Benutzer zur Eingabe auf. Beide Spieler geben nacheinander Eingaben ein.
//Nehmen Sie Input von Spielern entgegen
Leere Spielereingabe ( Spieler & Spieler ) {
int Pos ;
cout << endl ;
cout << ' \T ' << Spieler. getName ( ) << ' Drehen: ' ;
cout << ' \T Geben Sie die Position ein ' <> Pos ;
Pos - = 1 ;
Wenn ( emptyIndex [ Pos ] == 1 ) {
cout << „-----Position nicht leer-------“ << endl ;
Spielereingabe ( Spieler ) ;
} anders {
emptyIndex [ Pos ] = 1 ;
emptyCount - = 1 ;
Spieler. getName ( ) . vergleichen ( „Spieler I“ ) == 0 ? Planke [ Pos ] = 'X' : Planke [ Pos ] = 'Ö' ;
}
}
Nachdem Eingaben vom Benutzer entgegengenommen wurden, überprüft es die Win-Regel. Die Funktion checkWin() verfügt über zwei Parameter p1 und p2, um zu überprüfen, ob der Spieler gewonnen hat oder nicht. In der Funktion werden verschiedene Variablen deklariert. i, j und k sind ganzzahlige Variablen, die für die Schleife deklariert werden, und das Flag ist eine boolesche Funktion zur Überprüfung der Gewinnbedingung. Die Schleife beginnt an der allerersten Position und wird für alle neun Positionen wiederholt. Das erste_Symbol ist ein Zeichen, das 0 oder X sein kann. Wenn es wahr ist, werden alle möglichen Kombinationen auf die Gewinnregel überprüft. Andernfalls bewegt sich der Iterator zur nächsten Position und macht so weiter, bis alle möglichen Positionen überprüft wurden. Wenn das Flag auf „true“ gesetzt ist, wird ein Gewinner erklärt und das Programm fordert Sie auf, die Auswahl erneut zu treffen.
Leere checkWin ( Spieler & p1,Spieler & p2 ) {
int i,j,k ;
bool Flagge = FALSCH ;
verkohlen erstes_symbol ;
für ( ich = 0 ; ich < 8 ; ich ++ ) {
erstes_symbol = Planke [ Winlist [ ich ] . Reihe [ 0 ] ] ;
Wenn ( ( erstes_symbol ! = 'X' ) && ( erstes_symbol ! = 'Ö' ) ) {
Flagge = FALSCH ;
weitermachen ;
}
Flagge = WAHR ;
für ( J = 0 ; J < 3 ; J ++ ) {
Wenn ( erstes_symbol ! = Planke [ Winlist [ ich ] . Reihe [ J ] ] ) {
Flagge = FALSCH ;
brechen ;
}
}
Wenn ( Flagge ) {
Spiel weiter = 0 ;
Wenn ( erstes_symbol == 'X' ) {
cout << „----------“ << endl ;
cout << ' \T Spieler, den ich GEWONNEN habe“ << endl ;
cout << „----------“ << endl ;
p1. gewonnen ( ) ;
} anders {
p2. gewonnen ( ) ;
Wenn ( gegenComputer ) {
cout << „----------“ << endl ;
cout << ' \T Computer GEWONNEN“ << endl ;
cout << „----------“ << endl ;
} anders {
cout << „----------“ << endl ;
cout << ' \T Spieler II GEWONNEN“ << endl ;
cout << „----------“ << endl ;
}
}
displayScore ( p1,p2 ) ;
brechen ;
}
Dieser Teil des Codes zeigt den Punktestand des Spiels. Wenn das Spiel gegen einen Computer ist, wird der Punktestand für Spieler 1 und den Computer angezeigt, andernfalls wird der Punktestand für Spieler 1 und Spieler 2 angezeigt.
Leere displayScore ( Spieler & p1, Spieler & p2 ) {
cout << endl ;
cout << ' \T PUNKTZAHL: \T ' ;
Wenn ( gegenComputer )
cout << „Spieler I:“ << p1. getScore ( ) << ' \T Computer: ' << p2. getScore ( ) << endl ;
anders
cout << „Spieler I:“ << p1. getScore ( ) << ' \T Spieler II: „ << p2. getScore ( ) << endl ;
}
Dies ist der Hauptcode für die Ausführung des Tic-Tac-Toe-Spiels für zwei Spieler. Mit der switch-case-Anweisung kann der Benutzer aus einer Vielzahl von auszuführenden Prozeduren auswählen. Dieser Code bietet eine benutzerfreundliche Schnittstelle zum Spielen eines Spiels auf einem C++-Compiler und wird so lange ausgeführt, bis der Benutzer die Exit-Option auswählt.
int hauptsächlich ( ){
int CH ;
während ( 1 ) {
cout << ' ----------SPEISEKARTE----------' << endl ;
cout << ' \T 1. 1-Spieler-Spiel“ << endl ;
cout << ' \T 2. 2-Spieler-Spiel“ << endl ;
cout << ' \T 3. Zum Beenden „ << endl ;
cout << „ ----------“ << endl ;
cout << endl ;
cout << ' \T Wähle eine Option' <> CH ;
schalten ( CH ) {
Fall 1 : {
Spiel * Spiel = neu Spiel ;
Spiel - > Hitze ( ) ;
Spiel - > onePlayerGame ( ) ;
}
brechen ;
Fall 2 : {
Spiel * Spiel = neu Spiel ;
Spiel - > Hitze ( ) ;
Spiel - > TwoPlayerGame ( ) ;
}
brechen ;
Fall 3 :
zurückkehren 0 ;
Standard :
cout << „OOPs ungültige Option! VERSUCHEN SIE ES NOCHMAL“ ;
}
}
zurückkehren 0 ;
}
Vollständiger Code für ein textbasiertes Tic-Tac-Toc-Spiel
Dies ist ein vollständiger Code für den Entwurf und die Ausführung eines textbasierten Tic-Tac-Toe-Spiels.
#include
#include
#include
#include
#include
verwenden Namensraum std ;
Typdefinition Struktur {
int * Reihe ;
} WinList ;
Klasse Spieler {
Privat :
String-Name ;
int Punktzahl ;
öffentlich :
Spieler ( ) : Spieler { „“ } { }
Spieler ( Zeichenfolge n ) : Punktzahl { 0 } , Name { N } { }
Leere gewonnen ( ) {
//Erhöhe die Punktzahl
Punktzahl ++ ;
}
int getScore ( ) { zurückkehren Das - > Punktzahl ; }
Zeichenfolge getName ( ) { zurückkehren Das - > Name ; }
} ;
Klasse Spiel {
Privat :
verkohlen Planke [ 9 ] ;
int emptyIndex [ 9 ] ;
int gameOn, gegenComputer ;
int emptyCount ;
WinList Winlist [ 8 ] ;
Leere Anzeigetafel ( ) {
cout << endl ;
cout << ' | | ' << endl ;
cout << ' ' << Planke [ 0 ] << ' | ' << Planke [ 1 ] << ' | ' << Planke [ 2 ] << endl ;
cout << ' | | ' << endl ;
cout << „-----------“ << endl ;
cout << ' | | ' << endl ;
cout << ' ' << Planke [ 3 ] << ' | ' << Planke [ 4 ] << ' | ' << Planke [ 5 ] << endl ;
cout << ' | | ' << endl ;
cout << „-----------“ << endl ;
cout << ' | | ' << endl ;
cout << ' ' << Planke [ 6 ] << ' | ' << Planke [ 7 ] << ' | ' << Planke [ 8 ] << endl ;
cout << ' | | ' << endl ;
cout << endl ;
}
Leere computerInput ( ) {
int Pos ;
Pos = Rand ( ) % 10 ;
Wenn ( emptyIndex [ Pos ] == 1 ) {
Wenn ( emptyCount < 0 )
zurückkehren ;
computerInput ( ) ;
} anders {
cout << „Computer wählen:“ << Pos + 1 << endl ;
emptyIndex [ Pos ] = 1 ;
emptyCount - = 1 ;
Planke [ Pos ] = 'Ö' ;
}
}
Leere Spielereingabe ( Spieler & Spieler ) {
int Pos ;
cout << endl ;
cout << ' \T ' << Spieler. getName ( ) << ' Drehen: ' ;
cout << ' \T Geben Sie die Position ein ' <> Pos ;
Pos - = 1 ;
Wenn ( emptyIndex [ Pos ] == 1 ) {
cout << „-----Position nicht leer-------“ << endl ;
Spielereingabe ( Spieler ) ;
} anders {
emptyIndex [ Pos ] = 1 ;
emptyCount - = 1 ;
Spieler. getName ( ) . vergleichen ( „Spieler I“ ) == 0 ? Planke [ Pos ] = 'X' : Planke [ Pos ] = 'Ö' ;
}
}
Leere checkWin ( Spieler & p1,Spieler & p2 ) {
int i,j,k ;
bool Flagge = FALSCH ;
verkohlen erstes_symbol ;
für ( ich = 0 ; ich < 8 ; ich ++ ) {
erstes_symbol = Planke [ Winlist [ ich ] . Reihe [ 0 ] ] ;
Wenn ( ( erstes_symbol ! = 'X' ) && ( erstes_symbol ! = 'Ö' ) ) {
Flagge = FALSCH ;
weitermachen ;
}
Flagge = WAHR ;
für ( J = 0 ; J < 3 ; J ++ ) {
Wenn ( erstes_symbol ! = Planke [ Winlist [ ich ] . Reihe [ J ] ] ) {
Flagge = FALSCH ;
brechen ;
}
}
Wenn ( Flagge ) {
Spiel weiter = 0 ;
Wenn ( erstes_symbol == 'X' ) {
cout << „----------“ << endl ;
cout << ' \T Spieler, den ich GEWONNEN habe“ << endl ;
cout << „----------“ << endl ;
p1. gewonnen ( ) ;
} anders {
p2. gewonnen ( ) ;
Wenn ( gegenComputer ) {
cout << „----------“ << endl ;
cout << ' \T Computer GEWONNEN“ << endl ;
cout << „----------“ << endl ;
} anders {
cout << „----------“ << endl ;
cout << ' \T Spieler II GEWONNEN“ << endl ;
cout << „----------“ < 0 ) && ( Spiel weiter ! = 0 ) ) {
Wenn ( gegenComputer )
Hand == 1 ? computerInput ( ) : Spielereingabe ( p2 ) ;
anders
Hand == 1 ? Spielereingabe ( p1 ) : Spielereingabe ( p2 ) ;
Hand = ! Hand ;
Anzeigetafel ( ) ;
checkWin ( p1,p2 ) ;
}
Wenn ( emptyCount <= 0 ) {
cout << „ ----------------------“ << endl ;
cout << ' \T Kein GEWINNER“ << endl ;
cout << „ ----------------------“ << endl ;
}
cout << endl ;
cout <> Rückkampf ;
Wenn ( ( Rückkampf == 'UND' ) || ( Rückkampf == 'Und' ) ) {
Hitze ( ) ;
spielen ( p1,p2 ) ;
}
}
Leere displayScore ( Spieler & p1, Spieler & p2 ) {
cout << endl ;
cout << ' \T PUNKTZAHL: \T ' ;
Wenn ( gegenComputer )
cout << „Spieler I:“ << p1. getScore ( ) << ' \T Computer: ' << p2. getScore ( ) << endl ;
anders
cout << „Spieler I:“ << p1. getScore ( ) << ' \T Spieler II: „ << p2. getScore ( ) << endl ;
}
öffentlich :
Spiel ( ) : emptyCount { 0 } , Spiel weiter { 1 } , gegenComputer { 0 } {
Hitze ( ) ;
Winlist [ 0 ] . Reihe = neu int [ 3 ] { 0 , 1 , 2 } ;
Winlist [ 1 ] . Reihe = neu int [ 3 ] { 3 , 4 , 5 } ;
Winlist [ 2 ] . Reihe = neu int [ 3 ] { 6 , 7 , 8 } ;
Winlist [ 3 ] . Reihe = neu int [ 3 ] { 0 , 3 , 6 } ;
Winlist [ 4 ] . Reihe = neu int [ 3 ] { 1 , 4 , 7 } ;
Winlist [ 5 ] . Reihe = neu int [ 3 ] { 2 , 5 , 8 } ;
Winlist [ 6 ] . Reihe = neu int [ 3 ] { 0 , 4 , 8 } ;
Winlist [ 7 ] . Reihe = neu int [ 3 ] { 2 , 4 , 6 } ;
}
Leere Hitze ( ) {
Spiel weiter = 1 ;
emptyCount = 0 ;
Sand ( Zeit ( 0 ) ) ;
für ( size_t ich = 0 ; ich < 10 ; ich ++ ) {
emptyIndex [ ich ] = 0 ;
Planke [ ich ] = ( ich + 1 ) + '0' ;
emptyCount ++ ;
}
emptyCount -- ;
}
Leere onePlayerGame ( ) {
//Spieler wird erstellt
Spieler S ( „Spieler I“ ) ;
Spieler c ( 'Computer' ) ;
cout << „ ---------“ << endl ;
cout << ' \T Spieler I: X \T Computer: O' << endl ;
cout << „ ---------“ << endl ;
cout << endl ;
gegenComputer = 1 ;
spielen ( c,p ) ;
}
Leere TwoPlayerGame ( ) {
//Spieler wird erstellt
Spieler S ( „Spieler I“ ) ;
Spieler c ( „Spieler II“ ) ;
cout << „ ---------“ << endl ;
cout << ' \T Spieler I: X \T Spieler II: O' << endl ;
cout << „ ---------“ << endl ;
cout << endl ;
gegenComputer = 0 ;
spielen ( c,p ) ;
}
} ;
int hauptsächlich ( )
{
int CH ;
während ( 1 ) {
cout << ' ----------SPEISEKARTE----------' << endl ;
cout << ' \T 1. 1-Spieler-Spiel“ << endl ;
cout << ' \T 2. 2-Spieler-Spiel“ << endl ;
cout << ' \T 3. Zum Beenden „ << endl ;
cout << ' ----------' << endl ;
cout << endl ;
cout << ' \T Wähle eine Option' <> CH ;
schalten ( CH ) {
Fall 1 : {
Spiel * Spiel = neu Spiel ;
Spiel - > Hitze ( ) ;
Spiel - > onePlayerGame ( ) ;
}
brechen ;
Fall 2 : {
Spiel * Spiel = neu Spiel ;
Spiel - > Hitze ( ) ;
Spiel - > TwoPlayerGame ( ) ;
}
brechen ;
Fall 3 :
zurückkehren 0 ;
Standard :
cout << „OOPs ungültige Option! VERSUCHEN SIE ES NOCHMAL“ ;
}
}
zurückkehren 0 ;
}
Dabei handelt es sich um einen vollständigen Code zur Ausführung des Tic-Tac-Toe-Spiels, das in zwei Modi gespielt werden kann, entweder mit einem Computer oder einem Mitmenschen. Dies ist ein vielseitiger Code, der alle möglichen Befehle enthält. Wenn der Benutzer eine Position eingibt, die bereits besetzt ist, überschreibt er diese Position nicht und betrachtet diesen Umzug als ungültig.
Bisher hat Spieler eins das erste Kästchen ausgewählt und in der nächsten Runde markierte der Computer das sechste Kästchen:
Bisher haben beide Spieler die beiden Kästchen ausgewählt und in der nächsten Runde wählt Spieler I das siebte Kästchen, wodurch ein aufeinanderfolgendes vertikales Muster entsteht:
Der Benutzer entscheidet sich dafür, den Computer zum Spielen eines Spiels zu verwenden. Nach drei Zügen gewinnt der Benutzer am Computer und ein Punktestand wird zum Rekord von Spieler 1 hinzugefügt. Nachdem das erste Spiel vorbei ist, fordert der Compiler zum erneuten Spiel auf. Der Benutzer entscheidet aus den Optionen und das Programm kehrt zum Hauptabschnitt zurück. Nach Auswahl von Option drei führt der Compiler den Code aus.
Abschluss
Textbasierte Spiele basieren auf Textzeichen und einer Befehlszeilenschnittstelle für die Interaktion mit dem Spieler. Sie enthalten keine grafischen Bilder, Töne oder Animationen. Der Benutzer gibt den Befehl über das Konsolenfenster ein. Das benutzerfreundliche textbasierte Tic-Tac-Toe-Spiel wurde mit C++ erstellt. Es verwendet verschiedene Befehle, um ein Spiel zu erstellen, das entweder mit einem Computer oder einem anderen Mitspieler gespielt werden kann.