C++ Tic Tac Toe-Spiel
- C++ Tic Tac Toe-Spiel
- Schritt 1: Erstellen Sie eine Funktion, die ein 3-mal-3-Gitter zeichnet
- Schritt 2: Bitten Sie den Benutzer, Zeilen- und Spaltennummern einzugeben
- Schritt 3: Überprüfen Sie, ob die vom Benutzer eingegebene Position besetzt ist
- Schritt 4: Erstellen Sie eine Funktion zur Überprüfung des Spielgewinners
In diesem Tutorial wird das Erstellen des Tic Tac Toe-Spiels mit bedingten Anweisungen und Schleifen in C++ erläutert.
C++ Tic Tac Toe-Spiel
Tic Tac Toe ist ein Spiel mit zwei Spielern, bei dem jeder Spieler einen Platz innerhalb eines 3-mal-3-Rasters markiert und der Spieler, der erfolgreich drei Markierungen auf einer geraden horizontalen, vertikalen oder diagonalen Linie platziert, der Gewinner des Spiels ist . Ein Beispielbild des Spiels ist unten gezeigt.
Wir können sehen, dass Spieler X der Gewinner des Tic Tac Toe-Spiels ist, weil die drei Markierungen von Spieler X in einer geraden diagonalen Linie liegen. Um dasselbe Spiel in C++ zu erstellen, müssen wir denselben Algorithmus verwenden, um das Spiel mit Stift und Papier zu spielen.
Mit dem Stift zeichnen wir das 3-mal-3-Raster auf das Papier, und dann dreht sich jeder Spieler um, um eine Markierung innerhalb des Rasters auf dem freien Feld zu platzieren. Wenn es einem Spieler gelingt, drei Markierungen in einer geraden Linie zu platzieren, gewinnt dieser Spieler das Spiel und das Spiel ist vorbei.
Wenn keiner der Spieler drei Marker in einer geraden Linie platziert oder alle Plätze innerhalb des Rasters besetzt sind, endet das Spiel mit einem Unentschieden. Wir können denselben Algorithmus verwenden, um das Tic-Tac-Toe-Spiel in C++ zu erstellen.
Im ersten Schritt müssen wir eine Funktion erstellen, die ein 3-mal-3-Raster zeichnet. Im zweiten Schritt müssen wir Eingaben des Benutzers in Form von Zeilen- und Spaltennummern entgegennehmen und prüfen, ob die Eingabe gültig ist.
Im dritten Schritt müssen wir überprüfen, ob die vom Benutzer eingegebene Position besetzt ist oder nicht, und wenn sie nicht besetzt ist, platzieren wir die Markierung des Spielers innerhalb des Rasters an der vom Benutzer eingegebenen Position, und wenn die Platz besetzt ist, werden wir den Spieler bitten, eine andere Position einzugeben. Wenn alle Positionen besetzt sind, beenden wir das Spiel und verkünden Unentschieden.
Im vierten Schritt prüfen wir, ob drei Markierungen eines der Spieler in einer geraden Linie sind oder nicht. Wenn die Markierungen eines Spielers in einer geraden Linie sind, beenden wir das Spiel und geben den Namen des Spielers bekannt, der das Spiel gewonnen hat, und wenn die Markierungen nicht in einer geraden Linie sind, gehen wir zurück zum zweiten Schritt und wiederholen es.
Schritt 1: Erstellen Sie eine Funktion, die ein 3-mal-3-Gitter zeichnet
Beginnen wir nun mit der Erstellung des Spiels vom ersten Schritt an, in dem wir ein 3-mal-3-Brett zeichnen müssen. Wir können ein Brett zeichnen, indem wir eine Kombination aus Pipe-Zeichen | und Bindestrich - von der Tastatur.
Wir können die Bindestriche - verwenden, um die horizontale Linie zu zeichnen, und das Pipe-Zeichen | um die in einem Raster vorhandene vertikale Linie zu zeichnen, und wir können Zahlen verwenden, um die Zeilen- und Spaltennummer des Rasters zu markieren. Verwenden wir beispielsweise die C++-Funktion cout(), um das 3-mal-3-Raster zu zeichnen.
Siehe Code unten.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
int main() {
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
drawGameBoard(Gameboard);
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
Ausgang:
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
Der obige Code verwendet die endl-Anweisung, um den Cursor in die neue Zeile zu bewegen. In der obigen Ausgabe stellen die vertikal gespielten Zahlen die Zeilennummer dar, und die horizontalen Zahlen repräsentieren die Spaltennummer.
Schritt 2: Bitten Sie den Benutzer, Zeilen- und Spaltennummern einzugeben
Im zweiten Schritt können wir den Benutzer bitten, die Zeilen- und Spaltennummer einzugeben, in der der Benutzer seine Markierung platzieren möchte. Wir verwenden eine bedingte Anweisung, um die Benutzereingabe zu überprüfen, und wenn die Zeilen- oder Spaltennummer nicht im Bereich von 1 bis 3 liegt, zeigen wir einen Fehler an und fordern den Benutzer auf, die Eingabe erneut einzugeben.
Wir verwenden eine Schleife, um die Eingabe des Benutzers entgegenzunehmen, und die Schleife wird fortgesetzt, bis der Benutzer eine gültige Zeilen- und Spaltennummer eingibt. Lassen Sie uns beispielsweise eine while-Schleife und eine if-else-Anweisung verwenden, um Eingaben vom Benutzer entgegenzunehmen.
Siehe Code unten.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
int main() {
int Boardrow;
int Boardcolumn;
bool is_Boardrow;
bool is_Boardcolumn;
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
drawGameBoard(Gameboard);
is_Boardrow = false;
while (!is_Boardrow) {
cout << "BoardRow: ";
cin >> Boardrow;
if (Boardrow == 1 || Boardrow == 2 || Boardrow == 3) {
is_Boardrow = true;
} else {
cout << endl << "Invalid Boardrow!" << endl;
}
}
is_Boardcolumn = false;
while (!is_Boardcolumn) {
cout << "BoardColumn: ";
cin >> Boardcolumn;
if (Boardcolumn == 1 || Boardcolumn == 2 || Boardcolumn == 3) {
is_Boardcolumn = true;
} else {
cout << endl << "Invalid Boardcolumn!" << endl;
}
}
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
Ausgang:
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
BoardRow: 5
Invalid Boardrow!
BoardRow: 1
BoardColumn: 6
Invalid Boardcolumn!
BoardColumn: 2
Im obigen Code haben wir zwei Integer verwendet, Boardrow und Boardcolumn, um die Benutzereingaben zu speichern. Wir haben zwei boolesche Variablen, is_boardRow und is_boardColumn, verwendet, um den Status des Eingangs zu speichern.
Wir setzen die beiden booleschen Variablen auf false, und die Schleife wiederholt sich und fordert den Benutzer auf, die Zeilen- und Spaltennummer einzugeben, und wenn die eingegebene Zahl gültig ist, wird die boolesche Variable auf true gesetzt, und die Schleife wird brechen. Wir haben zwei Schleifen verwendet, eine für die Zeilennummer und die andere für die Spaltennummer.
Die obige Ausgabe zeigt, dass der Code bei Eingabe einer ungültigen Zeilen- oder Spaltennummer eine ungültige Zeilen- oder Spaltennummer anzeigt und den Benutzer auffordert, die Eingabe erneut einzugeben.
Schritt 3: Überprüfen Sie, ob die vom Benutzer eingegebene Position besetzt ist
Im dritten Schritt müssen wir den Spielermarker an der vom Benutzer eingegebenen Position platzieren, aber vorher müssen wir prüfen, ob die eingegebene Position besetzt ist.
Wenn die Position besetzt ist, bitten wir den Benutzer, eine andere Position einzugeben, und wenn die Position nicht besetzt ist, platzieren wir die Markierung des Spielers an der eingegebenen Position im Inneren des Bretts.
Wir müssen den Spieler wechseln, nachdem ein Spieler erfolgreich einen Marker auf dem Spielbrett oder Gitter platziert hat. Verwenden wir zum Beispiel eine Schleife und Bedingungsanweisungen, um die Markierung auf der Tafel zu platzieren.
Siehe Code unten.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
char checkGameWinner3by3(char Gameboard[][3]);
int main() {
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
char Gameplayer = 'X';
char Gamewinner = ' ';
int Boardrow;
int Boardcolumn;
bool is_Validmove;
bool is_Boardrow;
bool is_Boardcolumn;
cout << "************ TIC TAC TOE Game ************\n";
while (Gamewinner == ' ') {
is_Validmove = false;
is_Boardrow = false;
is_Boardcolumn = false;
drawGameBoard(Gameboard);
cout << "GamePlayer ";
if (Gameplayer == 'X') {
cout << 'X';
} else {
cout << 'O';
}
cout << "'s turn:" << endl;
is_Validmove = false;
while (!is_Validmove) {
is_Boardrow = false;
while (!is_Boardrow) {
cout << "BoardRow: ";
cin >> Boardrow;
if (Boardrow == 1 || Boardrow == 2 || Boardrow == 3) {
is_Boardrow = true;
} else {
cout << endl << "Invalid Boardrow!" << endl;
}
}
is_Boardcolumn = false;
while (!is_Boardcolumn) {
cout << "BoardColumn: ";
cin >> Boardcolumn;
if (Boardcolumn == 1 || Boardcolumn == 2 || Boardcolumn == 3) {
is_Boardcolumn = true;
} else {
cout << endl << "Invalid Boardcolumn!" << endl;
}
}
if (Gameboard[Boardrow - 1][Boardcolumn - 1] == ' ') {
Gameboard[Boardrow - 1][Boardcolumn - 1] = Gameplayer;
is_Validmove = true;
if (Gameplayer == 'X') {
Gameplayer = 'O';
} else {
Gameplayer = 'X';
}
} else {
cout << "The selected space is occupied!" << endl;
cout << "Select a different space:" << endl << endl;
drawGameBoard(Gameboard);
}
}
cout << endl;
}
system("pause");
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
Ausgang:
************ TIC TAC TOE Game ************
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow: 1
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer O's turn:
BoardRow: 2
BoardColumn: 2
1 2 3
-------------
1 | X | | |
-------------
2 | | O | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow:
Im obigen Code haben wir eine weitere boolesche Variable, is_validMove, verwendet, um den Status der eingegebenen Position zu speichern. Der boolesche Wert wird auf false gesetzt und die while-Schleife wiederholt sich; der boolesche Wert wird auf true gesetzt, und wir setzen ihn auf true, wenn der Benutzer eine Position betritt, die noch nicht besetzt ist.
Wir haben eine weitere Variable, Gamewinner, verwendet, die auf einen leeren String gesetzt ist, und diese wird im nächsten Schritt verwendet, um den Gewinner zu erklären und das Spiel zu beenden.
Unterhalb der while-Schleife, die Eingaben vom Benutzer entgegennimmt, haben wir eine if-else-Anweisung verwendet, um die eingegebene Position innerhalb des Gameboard-Arrays zu überprüfen, und wenn die Position frei ist, werden wir die Markierung und das Set des Spielers hinzufügen den Boolean is_validmove auf true, und wir ändern den Spieler, und wenn der Platz nicht frei ist, zeigen wir an, dass der Platz belegt ist, und bitten den Benutzer, einen anderen Platz oder eine andere Position einzugeben, und danach werden wir es tun Zeichne das Spielbrett.
Wir können in der obigen Ausgabe sehen, dass die Spielermarker innerhalb des Spielbretts platziert werden.
Schritt 4: Erstellen Sie eine Funktion zur Überprüfung des Spielgewinners
Im letzten Schritt erstellen wir eine Funktion, um den Gewinner des Spiels zu überprüfen. Um den Spielgewinner zu ermitteln, müssen wir jede Zeile, Spalte und jeden diagonalen Eintrag des Rasters oder Spielbretts prüfen.
Wenn eine der Reihen, Spalten oder Diagonaleinträge der Tafel drei gleiche Markierungen hat, geben wir diese Markierung zurück, und wenn keiner von ihnen drei Markierungen hat, geben wir eine leere Zeichenfolge zurück.
Wir speichern die Ausgabe der Spielgewinnerfunktion in der Variable Gamewinner, und die Hauptschleife wird beendet, wenn es einen Spielgewinner gibt; andernfalls wird es fortgesetzt.
Wenn es einen Gewinner gibt, werden wir ihn bekannt geben und das Spiel beenden; Andernfalls endet das Spiel unentschieden. Lassen Sie uns zum Beispiel die Game Winner-Funktion mit for-Schleifen und bedingten Anweisungen erstellen.
Siehe Code unten.
#include <iomanip>
#include <iostream>
using namespace std;
void drawGameBoard(char Gameboard[][3]);
char checkGameWinner3by3(char Gameboard[][3]);
int main() {
char Gameboard[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
char Gameplayer = 'X';
char Gamewinner = ' ';
int Boardrow;
int Boardcolumn;
bool is_Validmove;
bool is_Boardrow;
bool is_Boardcolumn;
cout << "************ TIC TAC TOE Game ************\n";
while (Gamewinner == ' ') {
is_Validmove = false;
is_Boardrow = false;
is_Boardcolumn = false;
drawGameBoard(Gameboard);
cout << "GamePlayer ";
if (Gameplayer == 'X') {
cout << 'X';
} else {
cout << 'O';
}
cout << "'s turn:" << endl;
is_Validmove = false;
while (!is_Validmove) {
is_Boardrow = false;
while (!is_Boardrow) {
cout << "BoardRow: ";
cin >> Boardrow;
if (Boardrow == 1 || Boardrow == 2 || Boardrow == 3) {
is_Boardrow = true;
} else {
cout << endl << "Invalid Boardrow!" << endl;
}
}
is_Boardcolumn = false;
while (!is_Boardcolumn) {
cout << "BoardColumn: ";
cin >> Boardcolumn;
if (Boardcolumn == 1 || Boardcolumn == 2 || Boardcolumn == 3) {
is_Boardcolumn = true;
} else {
cout << endl << "Invalid Boardcolumn!" << endl;
}
}
if (Gameboard[Boardrow - 1][Boardcolumn - 1] == ' ') {
Gameboard[Boardrow - 1][Boardcolumn - 1] = Gameplayer;
is_Validmove = true;
if (Gameplayer == 'X') {
Gameplayer = 'O';
} else {
Gameplayer = 'X';
}
} else {
cout << "The selected space is occupied!" << endl;
cout << "Select a different space:" << endl << endl;
drawGameBoard(Gameboard);
}
}
cout << endl;
Gamewinner = checkGameWinner3by3(Gameboard);
if (Gamewinner == 'X' || Gamewinner == 'O') {
drawGameBoard(Gameboard);
cout << "Congratulations! GamePlayer ";
if (Gamewinner == 'X') {
cout << 'X';
} else {
cout << 'O';
}
cout << " is the Gamewinner!" << endl;
} else if (Gamewinner == 'T') {
drawGameBoard(Gameboard);
cout << "It's a tie!" << endl;
}
}
system("pause");
return 0;
}
void drawGameBoard(char Gameboard[][3]) {
cout << " 1 2 3" << endl;
cout << " -------------" << endl;
cout << " 1"
<< " | " << Gameboard[0][0] << " | " << Gameboard[0][1] << " | "
<< Gameboard[0][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 2"
<< " | " << Gameboard[1][0] << " | " << Gameboard[1][1] << " | "
<< Gameboard[1][2] << " | " << endl;
cout << " -------------" << endl;
cout << " 3"
<< " | " << Gameboard[2][0] << " | " << Gameboard[2][1] << " | "
<< Gameboard[2][2] << " | " << endl;
cout << " -------------" << endl;
}
char checkGameWinner3by3(char Gameboard[][3]) {
for (int i = 0; i < 3; i++) {
if (Gameboard[i][0] == Gameboard[i][1] &&
Gameboard[i][0] == Gameboard[i][2]) {
return Gameboard[i][0];
}
}
for (int i = 0; i < 3; i++) {
if (Gameboard[0][i] == Gameboard[1][i] &&
Gameboard[0][i] == Gameboard[2][i]) {
return Gameboard[0][i];
}
}
if (Gameboard[0][0] == Gameboard[1][1] &&
Gameboard[1][1] == Gameboard[2][2]) {
return Gameboard[0][0];
}
if (Gameboard[0][2] == Gameboard[1][1] &&
Gameboard[1][1] == Gameboard[2][0]) {
return Gameboard[0][2];
}
return ' ';
}
Ausgang:
************ TIC TAC TOE Game ************
1 2 3
-------------
1 | | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow: 1
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | | | |
-------------
3 | | | |
-------------
GamePlayer O's turn:
BoardRow: 2
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | O | | |
-------------
3 | | | |
-------------
GamePlayer X's turn:
BoardRow: 2
BoardColumn: 2
1 2 3
-------------
1 | X | | |
-------------
2 | O | X | |
-------------
3 | | | |
-------------
GamePlayer O's turn:
BoardRow: 3
BoardColumn: 1
1 2 3
-------------
1 | X | | |
-------------
2 | O | X | |
-------------
3 | O | | |
-------------
GamePlayer X's turn:
BoardRow: 3
BoardColumn: 3
1 2 3
-------------
1 | X | | |
-------------
2 | O | X | |
-------------
3 | O | | X |
-------------
Congratulations! GamePlayer X is the Gamewinner!
Im Code sehen wir die Funktion checkGameWinner3by3(), die das Board als Eingabe akzeptiert und zwei for-Schleifen und zwei if-Anweisungen enthält. Mit den for-Schleifen werden die Zeilen und Spalten geprüft, mit den if-Anweisungen die diagonalen Einträge.
