Hozzon létre egy Tic-Tac-Toe játékot C++ nyelven
A következő példa bemutatja ennek az interaktív, kétjátékos tic-tac-toe játéknak az alapjait. Bemutat egy egyszerű és egyszerű megközelítést a C++ programozáshoz, és egy jól dokumentált forráskódot biztosít a gyermekkori kihívások újraéléséhez a barátokkal egy új, digitális formátumban. Lássuk a következő kódot.
Példa: Alapvető konzol alapú Tic-Tac-Toe a 2D tömb használata nélkül
Ebben a példában egy 2D tömböt, függvényeket és if-else feltételeket fogunk használni a tic-tac-toe játék C++ nyelven való létrehozásához. Ebben a játékban két játékos felváltva adhatja meg lépéseit, és ez határozza meg a játék állapotát a győztes vagy a döntetlen keresésével. Lásd a következő megadott kódot:
#include
névtér std használatával ;
üres húzótábla ( char tábla [ 3 ] [ 3 ] ) ;
bool isMoveValid ( char tábla [ 3 ] [ 3 ] , int sor , int col ) ;
bool isBoardFull ( char tábla [ 3 ] [ 3 ] ) ;
char checkWinner ( char tábla [ 3 ] [ 3 ] ) ;
int fő- ( ) {
char tábla [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
int sor , col ;
char currentPlayer = 'X' ;
míg ( igaz ) {
húzótábla ( tábla ) ;
cout << 'Játékos' << currentPlayer << ' fordul. Írja be az (1-3) sort és az (1-3) oszlopot: ' ;
enni >> sor >> col ;
sor --;
col --;
ha ( isMoveValid ( tábla , sor , col ) ) {
tábla [ sor ] [ col ] = currentPlayer ;
char győztes = checkWinner ( tábla ) ;
ha ( győztes != '' ) {
húzótábla ( tábla ) ;
cout << 'Játékos' << győztes << 'győztes! \n ' ;
szünet ;
}
ha ( isBoardFull ( tábla ) ) {
húzótábla ( tábla ) ;
cout << 'Ez egy nyakkendő! \n ' ;
szünet ;
}
currentPlayer = ( currentPlayer == 'X' ) ? 'O' : 'X' ;
} más {
cout << 'Érvénytelen áthelyezés. Válasszon másik cellát. \n ' ;
} }
Visszatérés 0 ;
}
üres húzótábla ( char tábla [ 3 ] [ 3 ] ) {
cout << 'b| \t 1 \t | \t 2 \t | \t 3 \t | \n ' ;
cout << '____________________________ \n ' ;
számára ( int m = 0 ; m < 3 ; m ++ ) {
cout << m + 1 << '| ' ;
számára ( int t = 0 ; t < 3 ; t ++ ) {
cout << '' << tábla [ m ] [ t ] ;
ha ( t < 2 ) cout << ' \t | \t ' ;
}
cout << ' \t | \n ' ;
ha ( m < 2 ) cout << '____________________________ \n ' ;
}
cout << ' \n ' ; }
bool isMoveValid ( char tábla [ 3 ] [ 3 ] , int sor , int col ) {
Visszatérés ( sor >= 0 && sor < 3 && col >= 0 && col < 3 && tábla [ sor ] [ col ] == '' ) ;
}
bool isBoardFull ( char tábla [ 3 ] [ 3 ] ) {
számára ( int m = 0 ; m < 3 ; m ++ ) {
számára ( int t = 0 ; t < 3 ; t ++ ) {
ha ( tábla [ m ] [ t ] == '' ) {
Visszatérés hamis ;
} } }
Visszatérés igaz ; }
char checkWinner ( char tábla [ 3 ] [ 3 ] ) {
számára ( int m = 0 ; m < 3 ; m ++ ) {
ha ( tábla [ m ] [ 0 ] == tábla [ m ] [ 1 ] && tábla [ m ] [ 1 ] == tábla [ m ] [ 2 ] && tábla [ m ] [ 0 ] != '' ) {
Visszatérés tábla [ m ] [ 0 ] ;
}
ha ( tábla [ 0 ] [ m ] == tábla [ 1 ] [ m ] && tábla [ 1 ] [ m ] == tábla [ 2 ] [ m ] && tábla [ 0 ] [ m ] != '' ) {
Visszatérés tábla [ 0 ] [ m ] ;
} }
ha ( tábla [ 0 ] [ 0 ] == tábla [ 1 ] [ 1 ] && tábla [ 1 ] [ 1 ] == tábla [ 2 ] [ 2 ] && tábla [ 0 ] [ 0 ] != '' ) {
Visszatérés tábla [ 0 ] [ 0 ] ;
}
ha ( tábla [ 0 ] [ 2 ] == tábla [ 1 ] [ 1 ] && tábla [ 1 ] [ 1 ] == tábla [ 2 ] [ 0 ] && tábla [ 0 ] [ 2 ] != '' ) {
Visszatérés tábla [ 0 ] [ 2 ] ;
}
Visszatérés '' ;
}
Íme a funkcióinak lebontása:
Az „#include
Ebben a programban négy függvényprototípus található – ezek a drawBoard(), az isMoveValid(), az isBoardFull() és a checkWinner(). A függvénydeklaráció függvény prototípusként ismert. Bár a programban a fő funkció után jön, használatban lesz. A fő funkció tartalmazza a játékhurkot és a logikát a játékosok köreinek és lépéseinek kezeléséhez. A fő funkción belül a játéktábla szóközökkel van inicializálva.
char tábla [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
Ezt követően két sor- és oszlopváltozót definiálunk a játékos mozgásbevitelének tárolására. A „char currentPlayer = „X”;” meghatározza, hogy az „X” játékos megy először.
Most kezdődik a while (igaz) játékhurok, és addig tart, amíg nincs győztes vagy döntetlen. Ez a 'while' ciklus meghívja a 'drawBoard();' a tábla megjelenítéséhez. A tábla konzolon való megjelenítése után a felhasználót arra kérik, hogy válasszon egy cellát, amelyet meg szeretne jelölni a következő kódutasításban:
cout << 'Játékos' << currentPlayer << ' fordul. Írja be a sort és az oszlopot (1-3): ' ;
A játékos beírja a lépését a „cin >> sor >> col;” mezőbe.
Amikor kiválasztunk egy cellát jelölésre, a program először ellenőrzi a bemenet érvényességét, és az isMoveValid() függvény meghívásával biztosítja, hogy a cella még nincs-e kitöltve.
tábla [ sor ] [ col ] = currentPlayer ;Ez a kijelentés felhelyezi a játékos jelét a táblára.
char győztes = checkWinner ( tábla ) ;ha ( győztes != '' ) {
húzótábla ( tábla ) ;
cout << 'Játékos' << győztes << 'győz! \n ' ;
Ezek az állítások minden alkalommal ellenőrzik a nyertest, amikor egy játékos megjelöl egy bejegyzést a táblán. A nyertes nevét kihirdetik, ha van nyertes, és a program kilép a játékból.
ha ( isBoardFull ( tábla ) ) {Ez a kijelentés a döntetlent ellenőrzi. A döntetlen akkor következik be, ha a tábla megtelt, és nincs győztes. Ebben az esetben: 'Döntetlen!' ki van nyomtatva a képernyőre.
currentPlayer = ( currentPlayer == 'X' ) ? 'O' : 'X' ;Ez a kijelentés átváltoztatja a játékosokat, hogy minden játékosnak legyen esélye játszani a saját körét.
cout << 'Érvénytelen áthelyezés. Válasszon másik cellát. \n ' ;Ha az áthelyezés nem érvényes, a felhasználónak újra be kell írnia, és válasszon egy másik cellát.
A „fő” függvény után elindulnak a függvénydefiníciók az előzőleg deklarált függvényprototípusokhoz. Az első itt definiált függvény a drawBoard(), amely a tic-tac-toe táblát a konzolra rajzolja. A drawBoard() függvény kiírja a tábla aktuális állapotát, beleértve a rácsvonalakat is.
A következő itt definiált függvény az isMoveValid(). Ez a funkció annak meghatározására szolgál, hogy engedélyezett-e a mozgás a táblán belül és egy üres cellán is. Az isBoardFull() függvény annak ellenőrzésére szolgál, hogy a tábla megtelt-e. Ez a feltétele a döntetlen helyzetnek, amikor nincs győztes. Az isBoardFull() ellenőrzi, hogy a táblán minden pozíció betelt-e, ami döntetlent jelez, ha nincs győztes. Ha van nyertes, azt a checkWinner() függvény segítségével állapíthatjuk meg. A checkWinner() ellenőrzi az összes lehetséges nyerősort ugyanannak a játékosnak a jele ('X' vagy 'O'), és visszaadja a nyertes játékos jelét, ha megtalálta, vagy egy szóköz karaktert ' ', ha még nincs nyertes. A következő a program kimenete. Minden játékos minden fordulóját mutatja.
Először is, a tábla tiszta; Az „X” játékosnak ki kell választania a megjelölni kívánt cellát. Itt az „X” játékos beírja a 2-t és a 2-t. A 2. sor és a 2. oszlop cellái meg vannak jelölve. Lásd a megjelölt táblát a következőkben:
Most az O játékoson van a sor. A játékos felkéri, hogy válasszon kijelölendő cellát. Az „O” játékos 1-et választ a sornak és 1-et az oszlopnak. A kiválasztott cella az „O” játékos számára van megjelölve, ahogy az a következő kimeneti részletben látható:
Minden játékos köre ugyanazt a mintát követi. Az X játékoson a sor, és a játékos 1-et választ a sorhoz és 2-t az oszlophoz. Tekintse meg a következő megadott kimeneti pillanatképeket:
Most az „O” játékosé a kör. A játékos 1-et választ a sorhoz és 3-at az oszlophoz.
A következő kör ismét az „X” játékosnál következik. A játékos 3-at választ a sornak és 1-et az oszlopnak.
Az „O” játékos 3-at választ a sornak és 2-t az oszlopnak.
Az „X” játékos kiválasztja a második sort és a harmadik oszlopot.
Az „O” játékos most kiválasztja a második sort és az első oszlopot.
Az „X” játékos ezúttal a harmadik sort és a harmadik oszlopot választja.
Egyetlen játékos sem tudott vonalat csinálni vízszintesen, függőlegesen vagy átlósan, tehát döntetlen. A kiválasztott bemeneti tömbnek nincs nyertese.
Összességében a kód tartalmaz egy fő játékhurkot, amely a játék állapotának és felhasználói bevitelének kezeléséért felelős, valamint számos segédfunkciót, amelyek a tábla felhúzására, a lépések érvényesítésére, a teljes tábla ellenőrzésére és annak megállapítására szolgálnak, hogy van-e nyertes. .
Következtetés
Egy tic-tac-toe játék fejlesztése C++ használatával kiváló gyakorlati gyakorlat programozási készségeid erősítésére. A cikk pontosan elmagyarázza, hogyan hozhat létre tic-tac-toe-t C++ nyelven. Az ebben a cikkben található, lépésről lépésre bemutatott útmutatás egy 2D-s tömböt, funkciókat és if-else feltételeket tartalmazott, hogy az olvasók megértsék a játék mechanikáját, a felhasználói interakciókat és a hatékony kódstruktúrát. A kód részletes végigjátszása és az alapvető játékmenet szempontjából kulcsfontosságú funkciók magyarázata felbecsülhetetlen értékű betekintést enged az olvasóknak a C++ programozási gyakorlatokba és az egyszerű játékfejlesztés bonyolultságába.