Erstellen Sie ein Tic-Tac-Toe-Spiel in C++
Das folgende Beispiel vermittelt die Grundlagen für die Erstellung dieses interaktiven Tic-Tac-Toe-Spiels für zwei Spieler. Es zeigt einen einfachen und unkomplizierten Ansatz zur Programmierung mit C++ und bietet einen gut dokumentierten Quellcode, um die Herausforderungen der Kindheit mit Freunden in einem neuen, digitalen Format noch einmal zu erleben. Sehen wir uns den folgenden Code an.
Beispiel: Einfaches konsolenbasiertes Tic-Tac-Toe ohne Verwendung des 2D-Arrays
In diesem Beispiel verwenden wir ein 2D-Array, Funktionen und if-else-Bedingungen, um das Tic-Tac-Toe-Spiel in C++ zu erstellen. Bei diesem Spiel dürfen zwei Spieler abwechselnd ihre Züge eingeben und der Spielstand wird durch Prüfung auf Sieger oder Unentschieden bestimmt. Siehe den folgenden angegebenen Code:
#include
Verwenden des Namensraums std ;
Leere Zeichenbrett ( verkohlen Planke [ 3 ] [ 3 ] ) ;
bool istMoveValid ( verkohlen Planke [ 3 ] [ 3 ] , int Reihe , int Kol ) ;
bool istBoardFull ( verkohlen Planke [ 3 ] [ 3 ] ) ;
verkohlen checkGewinner ( verkohlen Planke [ 3 ] [ 3 ] ) ;
int hauptsächlich ( ) {
verkohlen Planke [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
int Reihe , Kol ;
verkohlen aktuellerSpieler = 'X' ;
während ( WAHR ) {
Zeichenbrett ( Planke ) ;
cout << 'Spieler ' << aktuellerSpieler << ' ist an der Reihe. Geben Sie Zeile (1-3) und Spalte (1-3) ein: ' ;
Essen >> Reihe >> Kol ;
Reihe --;
Kol --;
Wenn ( isMoveValid ( Planke , Reihe , Kol ) ) {
Planke [ Reihe ] [ Kol ] = aktuellerSpieler ;
verkohlen Gewinner = checkGewinner ( Planke ) ;
Wenn ( Gewinner != ' ' ) {
Zeichenbrett ( Planke ) ;
cout << 'Spieler ' << Gewinner << „ist ein Gewinner! \N ' ;
brechen ;
}
Wenn ( isBoardFull ( Planke ) ) {
Zeichenbrett ( Planke ) ;
cout << 'Es ist eine Krawatte! \N ' ;
brechen ;
}
aktuellerSpieler = ( aktuellerSpieler == 'X' ) ? 'Ö' : 'X' ;
} anders {
cout << „Ungültiger Zug. Wählen Sie eine andere Zelle. \N ' ;
} }
zurückkehren 0 ;
}
Leere Zeichenbrett ( verkohlen Planke [ 3 ] [ 3 ] ) {
cout << 'b| \T 1 \T | \T 2 \T | \T 3 \T | \N ' ;
cout << „______________________ \N ' ;
für ( int M = 0 ; M < 3 ; M ++ ) {
cout << M + 1 << „|“ ;
für ( int T = 0 ; T < 3 ; T ++ ) {
cout << „“ << Planke [ M ] [ T ] ;
Wenn ( T < 2 ) cout << ' \T | \T ' ;
}
cout << ' \T | \N ' ;
Wenn ( M < 2 ) cout << „______________________ \N ' ;
}
cout << ' \N ' ; }
bool istMoveValid ( verkohlen Planke [ 3 ] [ 3 ] , int Reihe , int Kol ) {
zurückkehren ( Reihe >= 0 && Reihe < 3 && Kol >= 0 && Kol < 3 && Planke [ Reihe ] [ Kol ] == ' ' ) ;
}
bool istBoardFull ( verkohlen Planke [ 3 ] [ 3 ] ) {
für ( int M = 0 ; M < 3 ; M ++ ) {
für ( int T = 0 ; T < 3 ; T ++ ) {
Wenn ( Planke [ M ] [ T ] == ' ' ) {
zurückkehren FALSCH ;
} } }
zurückkehren WAHR ; }
verkohlen checkGewinner ( verkohlen Planke [ 3 ] [ 3 ] ) {
für ( int M = 0 ; M < 3 ; M ++ ) {
Wenn ( Planke [ M ] [ 0 ] == Planke [ M ] [ 1 ] && Planke [ M ] [ 1 ] == Planke [ M ] [ 2 ] && Planke [ M ] [ 0 ] != ' ' ) {
zurückkehren Planke [ M ] [ 0 ] ;
}
Wenn ( Planke [ 0 ] [ M ] == Planke [ 1 ] [ M ] && Planke [ 1 ] [ M ] == Planke [ 2 ] [ M ] && Planke [ 0 ] [ M ] != ' ' ) {
zurückkehren Planke [ 0 ] [ M ] ;
} }
Wenn ( Planke [ 0 ] [ 0 ] == Planke [ 1 ] [ 1 ] && Planke [ 1 ] [ 1 ] == Planke [ 2 ] [ 2 ] && Planke [ 0 ] [ 0 ] != ' ' ) {
zurückkehren Planke [ 0 ] [ 0 ] ;
}
Wenn ( Planke [ 0 ] [ 2 ] == Planke [ 1 ] [ 1 ] && Planke [ 1 ] [ 1 ] == Planke [ 2 ] [ 0 ] && Planke [ 0 ] [ 2 ] != ' ' ) {
zurückkehren Planke [ 0 ] [ 2 ] ;
}
zurückkehren ' ' ;
}
Hier ist eine Aufschlüsselung seiner Funktionalität:
„#include
In diesem Programm gibt es vier Funktionsprototypen: drawBoard(), isMoveValid(), isBoardFull() und checkWinner(). Die Funktionsdeklaration wird als Funktionsprototyp bezeichnet. Obwohl es nach der Hauptfunktion im Programm steht, wird es verwendet. Die Hauptfunktion enthält die Spielschleife und die Logik zur Verwaltung der Züge und Bewegungen der Spieler. Innerhalb der Hauptfunktion wird das Spielbrett mit Leerzeichen initialisiert.
verkohlen Planke [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
Danach werden zwei Zeilen- und Spaltenvariablen definiert, um die Zugeingaben des Spielers zu speichern. Das „char currentPlayer = ‚X‘;“ legt fest, dass der Spieler „X“ zuerst beginnt.
Jetzt beginnt die while-Spielschleife (true), die so lange läuft, bis es einen Gewinner oder ein Unentschieden gibt. Diese „while“-Schleife ruft „drawBoard();“ auf. um die Tafel anzuzeigen. Nachdem das Board auf der Konsole angezeigt wurde, wird der Benutzer aufgefordert, eine Zelle auszuwählen, die in der folgenden Codeanweisung markiert werden soll:
cout << 'Spieler ' << aktuellerSpieler << „ist an der Reihe. Geben Sie Zeile und Spalte (1-3) ein:“ ;
Der Spieler gibt seinen Zug in „cin >> row >> col;“ ein.
Beim Auswählen einer Zelle zum Markieren überprüft das Programm zunächst die Gültigkeit der Eingabe und stellt sicher, dass die Zelle nicht bereits gefüllt ist, indem es die Funktion isMoveValid() aufruft.
Planke [ Reihe ] [ Kol ] = aktuellerSpieler ;Mit dieser Aussage wird die Markierung des Spielers auf der Tafel angebracht.
verkohlen Gewinner = checkGewinner ( Planke ) ;Wenn ( Gewinner != ' ' ) {
Zeichenbrett ( Planke ) ;
cout << 'Spieler ' << Gewinner << ' Gewinnt! \N ' ;
Diese Aussagen prüfen jedes Mal, ob ein Gewinner einen Eintrag auf der Tafel markiert. Wenn es einen Gewinner gibt, wird der Name des Gewinners bekannt gegeben und das Programm verlässt die Spielschleife.
Wenn ( isBoardFull ( Planke ) ) {Diese Anweisung prüft auf Gleichstand. Die Gleichstandsbedingung liegt vor, wenn das Brett voll ist und es keinen Gewinner gibt. In diesem Fall: „Es ist ein Unentschieden!“ wird auf dem Bildschirm gedruckt.
aktuellerSpieler = ( aktuellerSpieler == 'X' ) ? 'Ö' : 'X' ;Diese Anweisung wechselt die Spieler, um jedem Spieler die Möglichkeit zu geben, an der Reihe zu sein.
cout << „Ungültiger Zug. Wählen Sie eine andere Zelle. \N ' ;Wenn die Verschiebung ungültig ist, wird der Benutzer aufgefordert, die Eingabe erneut vorzunehmen und eine andere Zelle auszuwählen.
Nach der „Haupt“-Funktion beginnen die Funktionsdefinitionen für die zuvor deklarierten Funktionsprototypen. Die erste hier definierte Funktion ist drawBoard(), mit der das Tic-Tac-Toe-Board auf die Konsole gezeichnet wird. Die Funktion drawBoard() gibt den aktuellen Zustand der Platine inklusive Gitterlinien aus.
Die nächste Funktion, die hier definiert wird, ist isMoveValid(). Mit dieser Funktion wird ermittelt, ob ein Zug sowohl innerhalb des Spielbretts als auch auf einem leeren Feld erlaubt ist. Mit der Funktion isBoardFull() wird überprüft, ob das Board noch voll ist. Dies ist eine Voraussetzung für ein Unentschieden, wenn es keinen Sieger gibt. isBoardFull() prüft, ob alle Positionen auf dem Brett besetzt sind, was ein Unentschieden anzeigt, wenn es keinen Gewinner gibt. Ob es einen Gewinner gibt, kann dieser mit der Funktion checkWinner() ermittelt werden. checkWinner() überprüft alle potenziellen Gewinnlinien auf die Markierung desselben Spielers („X“ oder „O“) und gibt die Markierung des gewinnenden Spielers zurück, falls sie gefunden wurde, oder ein Leerzeichen „ “, wenn es noch keinen Gewinner gibt. Das Folgende ist die Ausgabe des Programms. Es zeigt jeden Spielzug jedes Spielers.
Erstens ist die Tafel klar; Spieler „X“ wird aufgefordert, die zu markierende Zelle auszuwählen. Hier gibt Spieler „X“ 2 und 2 ein. Die Zellen von Zeile 2 und Spalte 2 sind markiert. Beachten Sie die markierte Tafel im Folgenden:
Nun ist Spieler O an der Reihe. Der Spieler wird aufgefordert, eine zu markierende Zelle auszuwählen. Spieler „O“ wählt 1 für die Reihe und 1 für die Spalte. Die ausgewählte Zelle wird für Spieler „O“ markiert, wie im folgenden Ausgabeausschnitt gezeigt:
Alle Züge jedes Spielers folgen dem gleichen Muster. Jetzt ist Spieler X an der Reihe und wählt 1 für die Reihe und 2 für die Spalte. Sehen Sie sich die folgenden Ausgabe-Snapshots an:
Jetzt ist Spieler „O“ an der Reihe. Der Spieler wählt 1 für die Reihe und 3 für die Spalte.
Der nächste Zug ist wieder Spieler „X“. Der Spieler wählt 3 für die Reihe und 1 für die Spalte.
Spieler „O“ wählt 3 für die Reihe und 2 für die Spalte.
Spieler „X“ wählt die zweite Reihe und die dritte Spalte.
Spieler „O“ wählt nun die zweite Reihe und die erste Spalte aus.
Spieler „X“ wählt dieses Mal die dritte Reihe und die dritte Spalte.
Kein Spieler konnte eine Linie horizontal, vertikal oder diagonal bilden, es ist also ein Unentschieden. Es gibt keinen Gewinner für die ausgewählte Eingabereihe.
Insgesamt umfasst der Code eine Hauptspielschleife, die für die Verarbeitung des Spielstatus und der Benutzereingaben verantwortlich ist, sowie mehrere Hilfsfunktionen, die zum Zeichnen des Spielbretts, zur Validierung der Züge, zur Überprüfung, ob ein Spielbrett voll ist, und zur Feststellung, ob es einen Gewinner gibt, verwendet werden .
Abschluss
Die Entwicklung eines Tic-Tac-Toe-Spiels mit C++ ist eine hervorragende praktische Übung, um Ihre Programmierkenntnisse zu vertiefen. Der Artikel erklärt genau, wie man Tic-Tac-Toe in C++ erstellt. Die in diesem Artikel bereitgestellte Schritt-für-Schritt-Anleitung umfasste ein 2D-Array, Funktionen und If-Else-Bedingungen, damit die Leser die Spielmechanik, Benutzerinteraktionen und effiziente Codestrukturierung verstehen können. Die detaillierte Anleitung des Codes und die Erläuterung der Funktionen, die für das Kern-Gameplay von entscheidender Bedeutung sind, verschaffen den Lesern unschätzbare Einblicke sowohl in die C++-Programmierpraktiken als auch in die Feinheiten einer einfachen Spieleentwicklung.