Opret et Tic-Tac-Toe-spil i C++
Følgende eksempel giver det grundlæggende i at lave dette interaktive to-spillers tic-tac-toe-spil. Det viser en enkel og nem tilgang til programmering med C++ og giver en veldokumenteret kildekode til at genopleve disse barndoms udfordringer med venner i et nyt, digitalt format. Lad os se følgende kode.
Eksempel: Grundlæggende konsolbaseret Tic-Tac-Toe uden brug af 2D Array
I dette eksempel vil vi bruge et 2D-array, funktioner og if-else-betingelser til at lave tic-tac-toe-spillet i C++. I dette spil har to spillere lov til at skiftes til at indtaste deres træk, og det bestemmer spillets tilstand ved at tjekke for en vinder eller uafgjort. Se følgende givne kode:
#include
bruger navneområde std ;
ugyldig tegnebræt ( char bestyrelse [ 3 ] [ 3 ] ) ;
bool erMoveValid ( char bestyrelse [ 3 ] [ 3 ] , int række , int col ) ;
bool er BoardFull ( char bestyrelse [ 3 ] [ 3 ] ) ;
char checkVinder ( char bestyrelse [ 3 ] [ 3 ] ) ;
int vigtigste ( ) {
char bestyrelse [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
int række , col ;
char nuværende afspiller = 'X' ;
mens ( rigtigt ) {
tegnebræt ( bestyrelse ) ;
cout << 'spiller' << nuværende afspiller << 's tur. Indtast række (1-3) og kolonne (1-3): ' ;
spise >> række >> col ;
række --;
col --;
hvis ( erMoveValid ( bestyrelse , række , col ) ) {
bestyrelse [ række ] [ col ] = nuværende afspiller ;
char vinder = checkVinder ( bestyrelse ) ;
hvis ( vinder != ' ' ) {
tegnebræt ( bestyrelse ) ;
cout << 'spiller' << vinder << 'er en vinder! \n ' ;
pause ;
}
hvis ( er BoardFull ( bestyrelse ) ) {
tegnebræt ( bestyrelse ) ;
cout << 'Det er et slips! \n ' ;
pause ;
}
nuværende afspiller = ( nuværende afspiller == 'X' ) ? 'O' : 'X' ;
} andet {
cout << 'Ugyldigt træk. Vælg en anden celle. \n ' ;
} }
Vend tilbage 0 ;
}
ugyldig tegnebræt ( char bestyrelse [ 3 ] [ 3 ] ) {
cout << 'b| \t 1 \t | \t 2 \t | \t 3 \t | \n ' ;
cout << ' _____________________ \n ' ;
til ( int m = 0 ; m < 3 ; m ++ ) {
cout << m + 1 << '| ' ;
til ( int t = 0 ; t < 3 ; t ++ ) {
cout << '' << bestyrelse [ m ] [ t ] ;
hvis ( t < 2 ) cout << ' \t | \t ' ;
}
cout << ' \t | \n ' ;
hvis ( m < 2 ) cout << ' _____________________ \n ' ;
}
cout << ' \n ' ; }
bool erMoveValid ( char bestyrelse [ 3 ] [ 3 ] , int række , int col ) {
Vend tilbage ( række >= 0 && række < 3 && col >= 0 && col < 3 && bestyrelse [ række ] [ col ] == ' ' ) ;
}
bool er BoardFull ( char bestyrelse [ 3 ] [ 3 ] ) {
til ( int m = 0 ; m < 3 ; m ++ ) {
til ( int t = 0 ; t < 3 ; t ++ ) {
hvis ( bestyrelse [ m ] [ t ] == ' ' ) {
Vend tilbage falsk ;
} } }
Vend tilbage rigtigt ; }
char checkVinder ( char bestyrelse [ 3 ] [ 3 ] ) {
til ( int m = 0 ; m < 3 ; m ++ ) {
hvis ( bestyrelse [ m ] [ 0 ] == bestyrelse [ m ] [ 1 ] && bestyrelse [ m ] [ 1 ] == bestyrelse [ m ] [ 2 ] && bestyrelse [ m ] [ 0 ] != ' ' ) {
Vend tilbage bestyrelse [ m ] [ 0 ] ;
}
hvis ( bestyrelse [ 0 ] [ m ] == bestyrelse [ 1 ] [ m ] && bestyrelse [ 1 ] [ m ] == bestyrelse [ 2 ] [ m ] && bestyrelse [ 0 ] [ m ] != ' ' ) {
Vend tilbage bestyrelse [ 0 ] [ m ] ;
} }
hvis ( bestyrelse [ 0 ] [ 0 ] == bestyrelse [ 1 ] [ 1 ] && bestyrelse [ 1 ] [ 1 ] == bestyrelse [ 2 ] [ 2 ] && bestyrelse [ 0 ] [ 0 ] != ' ' ) {
Vend tilbage bestyrelse [ 0 ] [ 0 ] ;
}
hvis ( bestyrelse [ 0 ] [ 2 ] == bestyrelse [ 1 ] [ 1 ] && bestyrelse [ 1 ] [ 1 ] == bestyrelse [ 2 ] [ 0 ] && bestyrelse [ 0 ] [ 2 ] != ' ' ) {
Vend tilbage bestyrelse [ 0 ] [ 2 ] ;
}
Vend tilbage ' ' ;
}
Her er en oversigt over dens funktionalitet:
'#include
Der er fire funktionsprototyper i dette program - de er drawBoard(), isMoveValid(), isBoardFull() og checkWinner(). Funktionserklæringen er kendt som en funktionsprototype. Selvom det kommer efter hovedfunktionen i programmet, vil det blive brugt. Hovedfunktionen indeholder spilløkken og logikken til at styre spillernes vendinger og træk. Inden for hovedfunktionen initialiseres spillepladen med mellemrum.
char bestyrelse [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
Herefter defineres to række- og kolvariabler for at gemme spillerens træk-input. 'char currentPlayer = 'X';' definerer, at 'X'-spilleren går først.
Nu starter mens (ægte) spilløkke, og den kører, indtil der er en vinder eller uafgjort. Denne 'mens'-løkke kalder 'drawBoard();' for at vise tavlen. Efter at have vist tavlen på konsollen, bliver brugeren bedt om at vælge en celle, der skal markeres i følgende kodesætning:
cout << 'spiller' << nuværende afspiller << 's tur. Indtast række og kolonne (1-3): ' ;
Spilleren indtaster deres træk i 'cin >> række >> col;'.
Når du vælger en celle til markering, vil programmet først verificere gyldigheden af inputtet og sikre, at cellen ikke allerede er udfyldt ved at kalde funktionen isMoveValid().
bestyrelse [ række ] [ col ] = nuværende afspiller ;Denne erklæring sætter spillerens præg på brættet.
char vinder = checkVinder ( bestyrelse ) ;hvis ( vinder != ' ' ) {
tegnebræt ( bestyrelse ) ;
cout << 'spiller' << vinder << 'vinder! \n ' ;
Disse udsagn tjekker efter en vinder, hver gang en spiller markerer en post på tavlen. Vinderens navn vil blive annonceret, hvis der er en vinder, og programmet vil forlade spilsløjfen.
hvis ( er BoardFull ( bestyrelse ) ) {Denne erklæring kontrollerer for uafgjort. Uafgjort tilstand opstår i et tilfælde, hvor brættet er fyldt, og der ikke er nogen vinder. I dette tilfælde: 'Det er uafgjort!' udskrives på skærmen.
nuværende afspiller = ( nuværende afspiller == 'X' ) ? 'O' : 'X' ;Denne erklæring skifter spillerne til at give hver spiller en chance for at spille deres tur.
cout << 'Ugyldigt træk. Vælg en anden celle. \n ' ;Hvis flytningen ikke er gyldig, bliver brugeren bedt om at indtaste igen og vælge en hvilken som helst anden celle.
Efter 'hoved'-funktionen starter funktionsdefinitionerne for de funktionsprototyper, der tidligere er deklareret. Den første funktion, der er defineret her, er drawBoard() som bruges til at trække tic-tac-toe-brættet til konsollen. DrawBoard()-funktionen udskriver brættets aktuelle tilstand, inklusive gitterlinjer.
Den næste funktion, der er defineret her, er isMoveValid(). Denne funktion bruges til at bestemme, om et træk er tilladt både inde på brættet og på en tom celle. Funktionen isBoardFull() bruges til at kontrollere, om tavlen endnu er fuld. Dette er en betingelse for en uafgjort situation, når der ikke er nogen vinder. isBoardFull() kontrollerer, om alle positioner på brættet er besat, hvilket indikerer uafgjort, hvis der ikke er nogen vinder. Hvis der er en vinder, kan det konstateres ved hjælp af checkWinner()-funktionen. CheckWinner() tjekker alle potentielle vinderlinjer for den samme spillers mærke ('X' eller 'O') og returnerer den vindende spillers mærke, hvis den findes, eller et mellemrumstegn ' ', hvis der ikke er nogen vinder endnu. Følgende er programmets output. Det viser hver tur fra hver spiller.
For det første er tavlen klar; spiller 'X' bliver bedt om at vælge den celle, der skal markeres. Her indtaster spiller 'X' 2 og 2. Cellerne i række 2 og kolonne 2 er markeret. Se den markerede tavle i det følgende:
Nu er det spilleren O's tur. Spilleren bliver bedt om at vælge en celle, der skal markeres. Spiller 'O' vælger 1 for rækken og 1 for kolonnen. Den valgte celle er markeret for spiller 'O' som vist i følgende output-uddrag:
Alle omgange for hver spiller følger det samme mønster. Det er spiller X's tur, og spilleren vælger 1 til rækken og 2 til kolonnen. Se følgende givne output-snapshots:
Nu er turen til spiller 'O'. Spilleren vælger 1 for rækken og 3 for kolonnen.
Næste tur er igen på spiller 'X'. Spilleren vælger 3 for rækken og 1 for kolonnen.
Spiller 'O' vælger 3 for rækken og 2 for kolonnen.
Spiller 'X' vælger den anden række og den tredje kolonne.
Spiller 'O' vælger nu den anden række og den første kolonne.
Spiller 'X' vælger den tredje række og den tredje kolonne denne gang.
Ingen spiller kunne lave nogen linje vandret, lodret eller diagonalt, så det er uafgjort. Der er ingen vinder for den valgte række af input.
Samlet set omfatter koden en hovedspilsløjfe, der er ansvarlig for at håndtere spillets tilstand og brugerinput, sammen med flere hjælpefunktioner, der bruges til at tegne brættet, validere træk, tjekke for en fuld bræt og afgøre, om der er en vinder .
Konklusion
At udvikle et tic-tac-toe-spil ved hjælp af C++ er en fremragende praktisk øvelse til at styrke dine programmeringsevner. Artiklen forklarer præcist, hvordan man laver tic-tac-toe i C++. Trin-for-trin vejledningen i denne artikel omfattede et 2D-array, funktioner og om-andet-betingelser for, at læserne kan forstå spilmekanikken, brugerinteraktioner og effektiv kodestrukturering. Den detaljerede gennemgang af koden og forklaringen af funktioner, der er afgørende for kernegameplayet, udstyrer læserne med uvurderlig indsigt i både C++-programmeringspraksis og forviklingerne i en simpel spiludvikling.