Lag et Tic-Tac-Toe-spill i C++
Følgende eksempel gir det grunnleggende for å lage dette interaktive tospillerspillet. Den viser en enkel og enkel tilnærming til å programmere den med C++ og gir en godt dokumentert kildekode for å gjenoppleve barndomsutfordringene med venner i et nytt, digitalt format. La oss se følgende kode.
Eksempel: Grunnleggende konsollbasert Tic-Tac-Toe uten bruk av 2D Array
I dette eksemplet vil vi bruke en 2D-array, funksjoner og if-else-betingelser for å lage tic-tac-toe-spillet i C++. I dette spillet har to spillere lov til å bytte på å legge inn trekk, og det bestemmer spillets tilstand ved å se etter en vinner eller uavgjort. Se følgende gitte kode:
#include
bruker navneområde std ;
tomrom tegnebrett ( røye borde [ 3 ] [ 3 ] ) ;
bool isMoveValid ( røye borde [ 3 ] [ 3 ] , int rad , int kol ) ;
bool erBoardFull ( røye borde [ 3 ] [ 3 ] ) ;
røye sjekk Vinner ( røye borde [ 3 ] [ 3 ] ) ;
int hoved- ( ) {
røye borde [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
int rad , kol ;
røye gjeldende spiller = 'X' ;
samtidig som ( ekte ) {
tegnebrett ( borde ) ;
cout << 'Spiller' << gjeldende spiller << 's tur. Gå inn på rad (1-3) og kolonne (1-3): ' ;
spiser >> rad >> kol ;
rad --;
kol --;
hvis ( isMoveValid ( borde , rad , kol ) ) {
borde [ rad ] [ kol ] = gjeldende spiller ;
røye vinner = sjekk Vinner ( borde ) ;
hvis ( vinner != ' ' ) {
tegnebrett ( borde ) ;
cout << 'Spiller' << vinner << 'er en vinner! \n ' ;
gå i stykker ;
}
hvis ( er BoardFull ( borde ) ) {
tegnebrett ( borde ) ;
cout << «Det er uavgjort! \n ' ;
gå i stykker ;
}
gjeldende spiller = ( gjeldende spiller == 'X' ) ? 'O' : 'X' ;
} ellers {
cout << 'Ugyldig trekk. Velg en annen celle. \n ' ;
} }
komme tilbake 0 ;
}
tomrom tegnebrett ( røye borde [ 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 << '' << borde [ m ] [ t ] ;
hvis ( t < 2 ) cout << ' \t | \t ' ;
}
cout << ' \t | \n ' ;
hvis ( m < 2 ) cout << ' _____________________ \n ' ;
}
cout << ' \n ' ; }
bool isMoveValid ( røye borde [ 3 ] [ 3 ] , int rad , int kol ) {
komme tilbake ( rad >= 0 && rad < 3 && kol >= 0 && kol < 3 && borde [ rad ] [ kol ] == ' ' ) ;
}
bool erBoardFull ( røye borde [ 3 ] [ 3 ] ) {
til ( int m = 0 ; m < 3 ; m ++ ) {
til ( int t = 0 ; t < 3 ; t ++ ) {
hvis ( borde [ m ] [ t ] == ' ' ) {
komme tilbake falsk ;
} } }
komme tilbake ekte ; }
røye sjekk Vinner ( røye borde [ 3 ] [ 3 ] ) {
til ( int m = 0 ; m < 3 ; m ++ ) {
hvis ( borde [ m ] [ 0 ] == borde [ m ] [ 1 ] && borde [ m ] [ 1 ] == borde [ m ] [ 2 ] && borde [ m ] [ 0 ] != ' ' ) {
komme tilbake borde [ m ] [ 0 ] ;
}
hvis ( borde [ 0 ] [ m ] == borde [ 1 ] [ m ] && borde [ 1 ] [ m ] == borde [ 2 ] [ m ] && borde [ 0 ] [ m ] != ' ' ) {
komme tilbake borde [ 0 ] [ m ] ;
} }
hvis ( borde [ 0 ] [ 0 ] == borde [ 1 ] [ 1 ] && borde [ 1 ] [ 1 ] == borde [ 2 ] [ 2 ] && borde [ 0 ] [ 0 ] != ' ' ) {
komme tilbake borde [ 0 ] [ 0 ] ;
}
hvis ( borde [ 0 ] [ 2 ] == borde [ 1 ] [ 1 ] && borde [ 1 ] [ 1 ] == borde [ 2 ] [ 0 ] && borde [ 0 ] [ 2 ] != ' ' ) {
komme tilbake borde [ 0 ] [ 2 ] ;
}
komme tilbake ' ' ;
}
Her er en oversikt over funksjonaliteten:
'#include
Det er fire funksjonsprototyper i dette programmet – de er drawBoard(), isMoveValid(), isBoardFull() og checkWinner(). Funksjonserklæringen er kjent som en funksjonsprototype. Selv om den kommer etter hovedfunksjonen i programmet, vil den bli brukt. Hovedfunksjonen inneholder spillløkken og logikken for å administrere spillernes svinger og trekk. Innenfor hovedfunksjonen initialiseres spillebrettet med mellomrom.
røye borde [ 3 ] [ 3 ] = { { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } , { ' ' , ' ' , ' ' } } ;
Etter dette defineres to rad- og kolvariabler for å lagre spillerens trekkinngang. 'char currentPlayer = 'X';' definerer at 'X'-spilleren går først.
Nå starter mens (ekte) spillløkken, og den går til det er en vinner eller uavgjort. Denne 'while'-løkken kaller 'drawBoard();' for å vise tavlen. Etter å ha vist tavlen på konsollen, blir brukeren bedt om å velge en celle som skal merkes i følgende kodesetning:
cout << 'Spiller' << gjeldende spiller << 's tur. Gå inn i rad og kolonne (1-3): ' ;
Spilleren legger inn trekket sitt i 'cin >> rad >> col;'.
Når du velger en celle for merking, vil programmet først verifisere gyldigheten av inndata, og sikre at cellen ikke allerede er fylt ved å kalle isMoveValid()-funksjonen.
borde [ rad ] [ kol ] = gjeldende spiller ;Denne uttalelsen setter spillerens preg på brettet.
røye vinner = sjekk Vinner ( borde ) ;hvis ( vinner != ' ' ) {
tegnebrett ( borde ) ;
cout << 'Spiller' << vinner << 'vinner! \n ' ;
Disse uttalelsene ser etter en vinner hver gang en spiller markerer en oppføring på brettet. Vinnerens navn vil bli annonsert hvis det er en vinner, og programmet vil gå ut av spillsløyfen.
hvis ( er BoardFull ( borde ) ) {Denne uttalelsen sjekker for uavgjort. Uavgjort tilstand oppstår i et tilfelle når brettet er fullt og det ikke er noen vinner. I dette tilfellet, 'Det er uavgjort!' skrives ut på skjermen.
gjeldende spiller = ( gjeldende spiller == 'X' ) ? 'O' : 'X' ;Denne uttalelsen bytter spillerne for å gi hver spiller en sjanse til å spille sin tur.
cout << 'Ugyldig trekk. Velg en annen celle. \n ' ;Hvis flyttingen ikke er gyldig, blir brukeren bedt om å skrive inn igjen og velge en hvilken som helst annen celle.
Etter 'hoved'-funksjonen vil funksjonsdefinisjonene for funksjonsprototypene som tidligere er deklarert starte. Den første funksjonen som er definert her er drawBoard() som brukes til å trekke tikken til konsollen. DrawBoard()-funksjonen skriver ut gjeldende status for brettet, inkludert rutenettlinjer.
Den neste funksjonen som er definert her er isMoveValid(). Denne funksjonen brukes til å bestemme om et trekk er tillatt både inne på brettet og på en tom celle. Funksjonen isBoardFull() brukes til å sjekke om brettet ennå er fullt. Dette er en betingelse for uavgjort situasjon når det ikke er noen vinner. isBoardFull() sjekker om alle posisjoner på brettet er fylt, noe som indikerer uavgjort hvis det ikke er noen vinner. Hvis det er en vinner, kan det fastslås ved hjelp av funksjonen checkWinner(). CheckWinner() sjekker alle potensielle vinnende linjer for samme spillers merke ('X' eller 'O') og returnerer vinnerspillerens merke hvis funnet eller et mellomromstegn ' ' hvis det ikke er noen vinner ennå. Følgende er programmets utgang. Den viser hver tur fra hver spiller.
For det første er styret tydelig; spiller 'X' blir bedt om å velge cellen som skal merkes. Her legger spiller 'X' inn 2 og 2. Cellene i rad 2 og kolonne 2 er merket. Se den merkede tavlen i følgende:
Nå er det spilleren O sin tur. Spilleren blir bedt om å velge en celle som skal merkes. Spiller 'O' velger 1 for raden og 1 for kolonnen. Den valgte cellen er merket for spiller 'O' som vist i følgende utdatabit:
Alle runder for hver spiller vil følge samme mønster. Det er spiller X sin tur, og spilleren velger 1 for raden og 2 for kolonnen. Se følgende øyeblikksbilder av utdata:
Nå er turen til spiller 'O'. Spilleren velger 1 for raden og 3 for kolonnen.
Neste tur er igjen på spiller 'X'. Spilleren velger 3 for raden og 1 for kolonnen.
Spiller 'O' velger 3 for raden og 2 for kolonnen.
Spiller 'X' velger den andre raden og den tredje kolonnen.
Spiller 'O' velger nå den andre raden og den første kolonnen.
Spiller 'X' velger den tredje raden og den tredje kolonnen denne gangen.
Ingen spiller kunne lage noen linje horisontalt, vertikalt eller diagonalt, så det er uavgjort. Det er ingen vinner for det valgte utvalget av innganger.
Totalt sett består koden av en hovedspillsløyfe som er ansvarlig for å håndtere spillets tilstand og brukerinndata, sammen med flere hjelpefunksjoner som brukes til å tegne brettet, validere trekkene, se etter et fullt brett og finne ut om det er en vinner .
Konklusjon
Å utvikle et tikk-tac-toe-spill med C++ er en utmerket praktisk øvelse for å forsterke dine programmeringsferdigheter. Artikkelen forklarer nøyaktig hvordan du lager tic-tac-toe i C++. Trinn-for-trinn-veiledningen i denne artikkelen omfattet en 2D-matrise, funksjoner og om-anne-betingelser for at leserne skal forstå spillmekanikken, brukerinteraksjoner og effektiv kodestrukturering. Den detaljerte gjennomgangen av koden og forklaringen av funksjoner som er avgjørende for kjernespillingen, utstyrer leserne med uvurderlig innsikt i både C++-programmeringspraksis og vanskelighetene ved en enkel spillutvikling.