Skapa ett Tic-Tac-Toe-spel i C++

Skapa Ett Tic Tac Toe Spel I C



Tic-tac-toe är ett intressant, gammalt och klassiskt spel som har underhållit generationerna. I tic-tac-toe tävlar två spelare på ett rutnät på 9 kvadrat som är markerat med ett hashmönster. Varje spelare tar sin tur och placerar symbolen (O eller X) i en av de tomma rutorna. I den här artikeln kommer vi att utforska hur man skapar ett tic-tac-toe-spel i programmeringsspråket C++. Följande exempel guidar dig genom att bygga ett enkelt men engagerande tic-tac-toe-spel, som täcker de väsentliga koncepten, koduppdelningar och överväganden för att skapa en interaktiv spelupplevelse.

Skapa ett Tic-Tac-Toe-spel i C++

Följande exempel ger grunderna för att göra detta interaktiva tvåspelares tick-tac-toe-spel. Den visar upp en enkel och enkel metod för att programmera den med C++ och tillhandahåller en väldokumenterad källkod för att återuppleva barndomens utmaningar med vänner i ett nytt, digitalt format. Låt oss se följande kod.

Exempel: Basic Console-Based Tic-Tac-Toe utan att använda 2D Array

I det här exemplet kommer vi att använda en 2D-array, funktioner och if-else-villkor för att göra tic-tac-toe-spelet i C++. I det här spelet tillåts två spelare turas om att mata in sina drag, och det bestämmer spelets tillstånd genom att leta efter en vinnare eller oavgjort. Se följande givna kod:







#include

använder namnutrymme std ;

tomhet dragbräda ( röding styrelse [ 3 ] [ 3 ] ) ;

bool isMoveValid ( röding styrelse [ 3 ] [ 3 ] , int rad , int kol ) ;

bool är BoardFull ( röding styrelse [ 3 ] [ 3 ] ) ;

röding checkvinnare ( röding styrelse [ 3 ] [ 3 ] ) ;

int huvud ( ) {

röding styrelse [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;

int rad , kol ;

röding nuvarande spelare = 'X' ;

medan ( Sann ) {

dragbräda ( styrelse ) ;

cout << 'Spelare ' << nuvarande spelare << 's tur. Gå in på rad (1-3) och kolumn (1-3): ' ;

äter >> rad >> kol ;

rad --;

kol --;

om ( isMoveValid ( styrelse , rad , kol ) ) {

styrelse [ rad ] [ kol ] = nuvarande spelare ;

röding vinnare = checkvinnare ( styrelse ) ;

om ( vinnare != ' ' ) {

dragbräda ( styrelse ) ;

cout << 'Spelare ' << vinnare << 'är en vinnare! \n ' ;

ha sönder ;

}

om ( är BoardFull ( styrelse ) ) {

dragbräda ( styrelse ) ;

cout << 'Det är oavgjort! \n ' ;

ha sönder ;

}

nuvarande spelare = ( nuvarande spelare == 'X' ) ? 'O' : 'X' ;

} annan {

cout << 'Ogiltigt drag. Välj annan cell. \n ' ;

} }

lämna tillbaka 0 ;

}

tomhet dragbräda ( röding styrelse [ 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 << '' << styrelse [ m ] [ t ] ;

om ( t < 2 ) cout << ' \t | \t ' ;

}

cout << ' \t | \n ' ;

om ( m < 2 ) cout << ' _______________ \n ' ;

}

cout << ' \n ' ; }

bool isMoveValid ( röding styrelse [ 3 ] [ 3 ] , int rad , int kol ) {

lämna tillbaka ( rad >= 0 && rad < 3 && kol >= 0 && kol < 3 && styrelse [ rad ] [ kol ] == ' ' ) ;

}

bool är BoardFull ( röding styrelse [ 3 ] [ 3 ] ) {

för ( int m = 0 ; m < 3 ; m ++ ) {

för ( int t = 0 ; t < 3 ; t ++ ) {

om ( styrelse [ m ] [ t ] == ' ' ) {

lämna tillbaka falsk ;

} } }

lämna tillbaka Sann ; }

röding checkvinnare ( röding styrelse [ 3 ] [ 3 ] ) {

för ( int m = 0 ; m < 3 ; m ++ ) {

om ( styrelse [ m ] [ 0 ] == styrelse [ m ] [ 1 ] && styrelse [ m ] [ 1 ] == styrelse [ m ] [ 2 ] && styrelse [ m ] [ 0 ] != ' ' ) {

lämna tillbaka styrelse [ m ] [ 0 ] ;

}

om ( styrelse [ 0 ] [ m ] == styrelse [ 1 ] [ m ] && styrelse [ 1 ] [ m ] == styrelse [ 2 ] [ m ] && styrelse [ 0 ] [ m ] != ' ' ) {

lämna tillbaka styrelse [ 0 ] [ m ] ;

} }

om ( styrelse [ 0 ] [ 0 ] == styrelse [ 1 ] [ 1 ] && styrelse [ 1 ] [ 1 ] == styrelse [ 2 ] [ 2 ] && styrelse [ 0 ] [ 0 ] != ' ' ) {

lämna tillbaka styrelse [ 0 ] [ 0 ] ;

}

om ( styrelse [ 0 ] [ 2 ] == styrelse [ 1 ] [ 1 ] && styrelse [ 1 ] [ 1 ] == styrelse [ 2 ] [ 0 ] && styrelse [ 0 ] [ 2 ] != ' ' ) {

lämna tillbaka styrelse [ 0 ] [ 2 ] ;

}

lämna tillbaka ' ' ;

}

Här är en uppdelning av dess funktionalitet:



'#include ' är ett förprocessordirektiv som inkluderar I/O-strömbiblioteket för in-/utgångsoperationer. Genom att använda 'namespace std' kan man direkt använda funktionerna cout, cin, etc. i ett C++-program, utan att kräva prefixet 'std::'.



Det finns fyra funktionsprototyper i det här programmet – de är drawBoard(), isMoveValid(), isBoardFull() och checkWinner(). Funktionsdeklarationen är känd som en funktionsprototyp. Även om det kommer efter huvudfunktionen i programmet kommer det att användas. Huvudfunktionen innehåller spelslingan och logiken för att hantera spelarnas vändningar och drag. Inom huvudfunktionen initieras spelplanen med mellanslag.





röding styrelse [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;

Efter detta definieras två rad- och kolvariabler för att lagra spelarens draginmatning. 'char currentPlayer = 'X';' definierar att 'X'-spelaren går först.

Nu startar while (sann) spelslingan, och den pågår tills det finns en vinnare eller oavgjort. Denna 'while'-loop anropar 'drawBoard();' för att visa tavlan. Efter att ha visat tavlan på konsolen uppmanas användaren att välja en cell att markera i följande kodsats:



cout << 'Spelare ' << nuvarande spelare << 's tur. Ange rad och kolumn (1-3): ' ;

Spelaren matar in sitt drag i 'cin >> rad >> kol;'.

När du väljer en cell för markering, kommer programmet först att verifiera giltigheten av inmatningen och säkerställa att cellen inte redan är fylld genom att anropa funktionen isMoveValid().

styrelse [ rad ] [ kol ] = nuvarande spelare ;

Detta uttalande sätter spelarens prägel på tavlan.

röding vinnare = checkvinnare ( styrelse ) ;

om ( vinnare != ' ' ) {

dragbräda ( styrelse ) ;

cout << 'Spelare ' << vinnare << 'vinner! \n ' ;

Dessa uttalanden letar efter en vinnare varje gång en spelare markerar ett bidrag på tavlan. Vinnarens namn tillkännages om det finns en vinnare, och programmet kommer att lämna spelslingan.

om ( är BoardFull ( styrelse ) ) {

Detta uttalande kontrollerar om det är oavgjort. Oavgjort tillstånd uppstår i ett fall när tavlan är full och det inte finns någon vinnare. I det här fallet, 'Det är en slips!' skrivs ut på skärmen.

nuvarande spelare = ( nuvarande spelare == 'X' ) ? 'O' : 'X' ;

Detta uttalande växlar spelarna för att ge varje spelare en chans att spela sin tur.

cout << 'Ogiltigt drag. Välj annan cell. \n ' ;

Om flytten inte är giltig uppmanas användaren att skriva in igen och välja valfri annan cell.

Efter 'huvud'-funktionen startar funktionsdefinitionerna för funktionsprototyperna som tidigare deklarerats. Den första funktionen som definieras här är drawBoard() som används för att dra tick-tac-toe-brädet till konsolen. DrawBoard()-funktionen skriver ut kortets nuvarande tillstånd, inklusive rutnätslinjer.

Nästa funktion som definieras här är isMoveValid(). Denna funktion används för att avgöra om ett drag är tillåtet både inne på brädet och på en tom cell. Funktionen isBoardFull() används för att kontrollera om kortet ännu är fullt. Detta är ett villkor för oavgjort situation när det inte finns någon vinnare. isBoardFull() kontrollerar om alla positioner på tavlan är fyllda, vilket indikerar oavgjort om det inte finns någon vinnare. Om det finns en vinnare kan det fastställas med hjälp av checkWinner()-funktionen. CheckWinner() kontrollerar alla potentiella vinstlinjer för samma spelares märke ('X' eller 'O') och returnerar den vinnande spelarens märke om den hittas eller ett mellanslagstecken ' ' om det inte finns någon vinnare ännu. Följande är programmets utdata. Den visar varje tur från varje spelare.

För det första är tavlan tydlig; spelare 'X' uppmanas att välja den cell som ska markeras. Här anger spelare 'X' 2 och 2. Cellerna i rad 2 och kolumn 2 är markerade. Se den markerade tavlan i följande:

Nu är det spelaren O:s tur. Spelaren uppmanas att välja en cell som ska markeras. Spelaren 'O' väljer 1 för raden och 1 för kolumnen. Den valda cellen är markerad för spelare 'O' som visas i följande utdatautdrag:

Alla varv för varje spelare kommer att följa samma mönster. Det är spelaren X:s tur och spelaren väljer 1 för raden och 2 för kolumnen. Se följande givna ögonblicksbilder av utdata:

Nu är det tur för spelaren 'O'. Spelaren väljer 1 för raden och 3 för kolumnen.

Nästa tur är igen på spelare 'X'. Spelaren väljer 3 för raden och 1 för kolumnen.

Spelaren 'O' väljer 3 för raden och 2 för kolumnen.

Spelaren 'X' väljer den andra raden och den tredje kolumnen.

Spelaren 'O' väljer nu den andra raden och den första kolumnen.

Spelaren 'X' väljer den tredje raden och den tredje kolumnen denna gång.

Ingen spelare kunde göra någon linje horisontellt, vertikalt eller diagonalt, så det är oavgjort. Det finns ingen vinnare för den valda uppsättningen av ingångar.

Sammantaget består koden av en huvudspelslinga som är ansvarig för att hantera spelets status och användarinmatning, tillsammans med flera verktygsfunktioner som används för att rita brädan, validera dragen, kontrollera om det finns en hel bräda och avgöra om det finns en vinnare .

Slutsats

Att utveckla ett tic-tac-toe-spel med C++ är en utmärkt praktisk övning för att stärka dina programmeringsfärdigheter. Artikeln förklarar exakt hur man skapar tic-tac-toe i C++. Den steg-för-steg-vägledning som ges i den här artikeln omfattade en 2D-array, funktioner och om-annat-villkor för att läsarna ska förstå spelmekaniken, användarinteraktioner och effektiv kodstrukturering. Den detaljerade genomgången av koden och förklaringen av funktioner som är avgörande för kärnspelet utrustar läsarna med ovärderliga insikter i både C++-programmeringsmetoder och krångligheterna i en enkel spelutveckling.