Gumawa ng Tic-Tac-Toe Game sa C++
Ang sumusunod na halimbawa ay nagbibigay ng mga pangunahing kaalaman sa paggawa ng interactive na two-player na tic-tac-toe na laro. Nagpapakita ito ng simple at madaling diskarte sa pagprograma nito gamit ang C++ at nagbibigay ng mahusay na dokumentado na source code upang muling buhayin ang mga hamon sa pagkabata kasama ang mga kaibigan sa isang bagong digital na format. Tingnan natin ang sumusunod na code.
Halimbawa: Basic Console-Based Tic-Tac-Toe nang hindi Gumagamit ng 2D Array
Sa halimbawang ito, gagamit kami ng 2D array, function, at if-else na kundisyon para gawin ang tic-tac-toe na laro sa C++. Sa larong ito, ang dalawang manlalaro ay pinahihintulutan na magpalit-palit sa pag-input ng kanilang mga galaw, at tinutukoy nito ang estado ng laro sa pamamagitan ng pagsuri para sa isang nanalo o isang tie. Tingnan ang sumusunod na ibinigay na code:
#include
gamit ang namespace std ;
walang bisa drawBoard ( char board [ 3 ] [ 3 ] ) ;
bool ayMoveValid ( char board [ 3 ] [ 3 ] , int hilera , int col ) ;
bool isBoardFull ( char board [ 3 ] [ 3 ] ) ;
char checkWinner ( char board [ 3 ] [ 3 ] ) ;
int pangunahing ( ) {
char board [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
int hilera , col ;
char kasalukuyang Manlalaro = 'X' ;
habang ( totoo ) {
drawBoard ( board ) ;
cout << 'Manlalaro ' << kasalukuyang Manlalaro << ''s turn. Ipasok ang row (1-3) at column (1-3): ' ;
kumakain >> hilera >> col ;
hilera --;
col --;
kung ( isMoveValid ( board , hilera , col ) ) {
board [ hilera ] [ col ] = kasalukuyang Manlalaro ;
char nagwagi = checkWinner ( board ) ;
kung ( nagwagi != '' ) {
drawBoard ( board ) ;
cout << 'Manlalaro ' << nagwagi << 'ay panalo! \n ' ;
pahinga ;
}
kung ( isBoardFull ( board ) ) {
drawBoard ( board ) ;
cout << 'Ito ay pantay! \n ' ;
pahinga ;
}
kasalukuyang Manlalaro = ( kasalukuyang Manlalaro == 'X' ) ? 'O' : 'X' ;
} iba pa {
cout << 'Di-wastong paglipat. Pumili ng ibang cell. \n ' ;
} }
bumalik 0 ;
}
walang bisa drawBoard ( char board [ 3 ] [ 3 ] ) {
cout << 'b| \t 1 \t | \t 2 \t | \t 3 \t | \n ' ;
cout << ' ____________________ \n ' ;
para sa ( int m = 0 ; m < 3 ; m ++ ) {
cout << m + 1 << '| ' ;
para sa ( int t = 0 ; t < 3 ; t ++ ) {
cout << '' << board [ m ] [ t ] ;
kung ( t < 2 ) cout << ' \t | \t ' ;
}
cout << ' \t | \n ' ;
kung ( m < 2 ) cout << ' ____________________ \n ' ;
}
cout << ' \n ' ; }
bool ayMoveValid ( char board [ 3 ] [ 3 ] , int hilera , int col ) {
bumalik ( hilera >= 0 && hilera < 3 && col >= 0 && col < 3 && board [ hilera ] [ col ] == '' ) ;
}
bool isBoardFull ( char board [ 3 ] [ 3 ] ) {
para sa ( int m = 0 ; m < 3 ; m ++ ) {
para sa ( int t = 0 ; t < 3 ; t ++ ) {
kung ( board [ m ] [ t ] == '' ) {
bumalik mali ;
} } }
bumalik totoo ; }
char checkWinner ( char board [ 3 ] [ 3 ] ) {
para sa ( int m = 0 ; m < 3 ; m ++ ) {
kung ( board [ m ] [ 0 ] == board [ m ] [ 1 ] && board [ m ] [ 1 ] == board [ m ] [ 2 ] && board [ m ] [ 0 ] != '' ) {
bumalik board [ m ] [ 0 ] ;
}
kung ( board [ 0 ] [ m ] == board [ 1 ] [ m ] && board [ 1 ] [ m ] == board [ 2 ] [ m ] && board [ 0 ] [ m ] != '' ) {
bumalik board [ 0 ] [ m ] ;
} }
kung ( board [ 0 ] [ 0 ] == board [ 1 ] [ 1 ] && board [ 1 ] [ 1 ] == board [ 2 ] [ 2 ] && board [ 0 ] [ 0 ] != '' ) {
bumalik board [ 0 ] [ 0 ] ;
}
kung ( board [ 0 ] [ 2 ] == board [ 1 ] [ 1 ] && board [ 1 ] [ 1 ] == board [ 2 ] [ 0 ] && board [ 0 ] [ 2 ] != '' ) {
bumalik board [ 0 ] [ 2 ] ;
}
bumalik '' ;
}
Narito ang isang breakdown ng functionality nito:
Ang “#include
Mayroong apat na function prototype sa program na ito – sila ay drawBoard(), isMoveValid(), isBoardFull(), at checkWinner(). Ang deklarasyon ng function ay kilala bilang isang function prototype. Kahit na ito ay pagkatapos ng pangunahing pag-andar sa programa, ito ay gagamitin. Ang pangunahing function ay naglalaman ng loop ng laro at lohika upang pamahalaan ang mga liko at galaw ng mga manlalaro. Sa loob ng pangunahing function, ang game board ay sinisimulan na may mga puwang.
char board [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
Pagkatapos nito, dalawang row at col na variable ang tinukoy para iimbak ang paglipat ng input ng player. Ang 'char currentPlayer = 'X';' tumutukoy na ang 'X' na manlalaro ay mauna.
Ngayon, magsisimula na ang while (true) game loop, at tatakbo ito hanggang sa magkaroon ng panalo o tie. Ang 'habang' loop na ito ay tinatawag na 'drawBoard();' para ipakita ang board. Pagkatapos ipakita ang board sa console, hihilingin sa user na pumili ng cell na mamarkahan sa sumusunod na code statement:
cout << 'Manlalaro ' << kasalukuyang Manlalaro << ''s turn. Ipasok ang row at column (1-3): ' ;
Inilalagay ng manlalaro ang kanilang paglipat sa 'cin >> row >> col;'.
Sa pagpili ng cell para sa pagmamarka, ibe-verify muna ng program ang validity ng input, tinitiyak na hindi pa napupunan ang cell sa pamamagitan ng pagtawag sa isMoveValid() function.
board [ hilera ] [ col ] = kasalukuyang Manlalaro ;Ang pahayag na ito ay naglalagay ng marka ng manlalaro sa pisara.
char nagwagi = checkWinner ( board ) ;kung ( nagwagi != '' ) {
drawBoard ( board ) ;
cout << 'Manlalaro ' << nagwagi << 'panalo! \n ' ;
Ang mga pahayag na ito ay tumitingin ng isang nagwagi sa tuwing ang isang manlalaro ay nagmamarka ng isang entry sa board. Ang pangalan ng nanalo ay iaanunsyo kung mayroong nanalo, at lalabas ang programa sa loop ng laro.
kung ( isBoardFull ( board ) ) {Sinusuri ng pahayag na ito ang pagkakatali. Ang kondisyon ng pagkakatali ay nangyayari sa isang kaso kapag ang board ay puno at walang nanalo. Sa kasong ito, 'Ito ay isang kurbatang!' ay naka-print sa screen.
kasalukuyang Manlalaro = ( kasalukuyang Manlalaro == 'X' ) ? 'O' : 'X' ;Ang pahayag na ito ay nagpapalit sa mga manlalaro upang bigyan ang bawat manlalaro ng pagkakataong maglaro ng kanilang pagkakataon.
cout << 'Di-wastong paglipat. Pumili ng ibang cell. \n ' ;Kung hindi wasto ang paglipat, ipo-prompt ang user na mag-input muli at pumili ng anumang iba pang cell.
Pagkatapos ng 'pangunahing' function, magsisimula ang mga kahulugan ng function para sa mga prototype ng function na dati nang idineklara. Ang unang function na tinukoy dito ay drawBoard() na ginagamit upang iguhit ang tic-tac-toe board sa console. Ang drawBoard() function ay nagpi-print ng kasalukuyang estado ng board, kabilang ang mga linya ng grid.
Ang susunod na function na tinukoy dito ay ang MoveValid(). Ang function na ito ay ginagamit upang matukoy kung ang isang paglipat ay pinapayagan sa loob ng board at sa isang walang laman na cell. Ang isBoardFull() function ay ginagamit upang suriin kung puno pa ang board. Ito ay isang kundisyon para sa isang sitwasyon ng tie kapag walang nanalo. Ang isBoardFull() ay nagsusuri kung ang lahat ng mga posisyon sa board ay napunan na nagpapahiwatig ng isang tie kung walang nanalo. Kung mayroong nanalo, maaari itong matiyak gamit ang checkWinner() function. Sinusuri ng checkWinner() ang lahat ng potensyal na panalong linya para sa marka ng parehong manlalaro (“X” o “O”) at ibabalik ang marka ng nanalong manlalaro kung natagpuan o isang space character na “ “ kung wala pang panalo. Ang sumusunod ay ang output ng programa. Ipinapakita nito ang bawat pagliko mula sa bawat manlalaro.
Una, malinaw ang board; ang player na 'X' ay sinenyasan na piliin ang cell na mamarkahan. Dito, ang player na 'X' ay pumapasok sa 2 at 2. Ang mga cell ng row 2 at column 2 ay minarkahan. Sumangguni sa minarkahang pisara sa sumusunod:
Ngayon, turn na ng player O. Ang player ay sinenyasan na pumili ng isang cell na mamarkahan. Pinipili ng manlalaro na 'O' ang 1 para sa row at 1 para sa column. Ang napiling cell ay minarkahan para sa player na 'O' tulad ng ipinapakita sa sumusunod na output snippet:
Ang lahat ng mga liko para sa bawat manlalaro ay susunod sa parehong pattern. Oras na ng player X, at pipili ang player ng 1 para sa row at 2 para sa column. Sumangguni sa mga sumusunod na ibinigay na mga snapshot ng output:
Ngayon, ang turn ay para sa player na 'O'. Pinipili ng player ang 1 para sa row at 3 para sa column.
Ang susunod na turn ay muli sa player na 'X'. Pinipili ng player ang 3 para sa row at 1 para sa column.
Pinipili ng manlalaro na 'O' ang 3 para sa row at 2 para sa column.
Pinipili ng manlalaro na 'X' ang pangalawang row at ang ikatlong column.
Pinipili na ngayon ng manlalaro na 'O' ang pangalawang row at ang unang column.
Pinipili ng manlalaro na 'X' ang ikatlong hanay at ang ikatlong hanay sa pagkakataong ito.
Walang manlalaro ang makakagawa ng anumang linya nang pahalang, patayo, o pahilis, kaya ito ay isang tali. Walang nanalo para sa napiling hanay ng mga input.
Sa pangkalahatan, ang code ay binubuo ng isang pangunahing loop ng laro na may pananagutan sa paghawak sa estado ng laro at pag-input ng user, kasama ang ilang mga function ng utility na ginagamit upang iguhit ang board, i-validate ang mga galaw, tingnan kung may full board, at tukuyin kung mayroong panalo. .
Konklusyon
Ang pagbuo ng isang tic-tac-toe na laro gamit ang C++ ay isang mahusay na praktikal na ehersisyo upang palakasin ang iyong mga kasanayan sa programming. Tumpak na ipinapaliwanag ng artikulo kung paano gumawa ng tic-tac-toe sa C++. Ang sunud-sunod na gabay na ibinigay sa artikulong ito ay sumasaklaw sa isang 2D array, function, at kung-iba pang mga kundisyon para maunawaan ng mga mambabasa ang mekanika ng laro, mga pakikipag-ugnayan ng user, at mahusay na pag-istruktura ng code. Ang detalyadong walkthrough ng code at ang paliwanag ng mga function na mahalaga sa pangunahing gameplay ay nagbibigay sa mga mambabasa ng napakahalagang mga insight sa parehong mga kasanayan sa programming ng C++ at ang mga intricacies ng isang simpleng pagbuo ng laro.