C++లో Tic-Tac-Toe గేమ్‌ని సృష్టించండి
కింది ఉదాహరణ ఈ ఇంటరాక్టివ్ టూ-ప్లేయర్ టిక్-టాక్-టో గేమ్‌ను రూపొందించడానికి ప్రాథమికాలను అందిస్తుంది. ఇది C++తో ప్రోగ్రామింగ్ చేయడానికి సులభమైన మరియు సులభమైన విధానాన్ని ప్రదర్శిస్తుంది మరియు కొత్త, డిజిటల్ ఫార్మాట్‌లో స్నేహితులతో చిన్ననాటి సవాళ్లను పునరుద్ధరించడానికి చక్కగా డాక్యుమెంట్ చేయబడిన సోర్స్ కోడ్‌ను అందిస్తుంది. ఈ క్రింది కోడ్ చూద్దాం.
ఉదాహరణ: 2D అర్రేని ఉపయోగించకుండా ప్రాథమిక కన్సోల్-ఆధారిత టిక్-టాక్-టో
ఈ ఉదాహరణలో, మేము C++లో టిక్-టాక్-టో గేమ్‌ను రూపొందించడానికి 2D శ్రేణి, ఫంక్షన్‌లు మరియు if-else షరతులను ఉపయోగిస్తాము. ఈ గేమ్‌లో, ఇద్దరు ఆటగాళ్లు తమ కదలికలను ఇన్‌పుట్ చేయడంలో మలుపులు తీసుకోవడానికి అనుమతించబడతారు మరియు ఇది విజేత లేదా టై కోసం తనిఖీ చేయడం ద్వారా గేమ్ స్థితిని నిర్ణయిస్తుంది. కింది ఇచ్చిన కోడ్‌ని చూడండి:
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
శూన్యం డ్రాబోర్డు ( చార్ బోర్డు [ 3 ] [ 3 ] ) ;
bool isMoveValid ( చార్ బోర్డు [ 3 ] [ 3 ] , int వరుస , int కల్ ) ;
bool isBoardFull ( చార్ బోర్డు [ 3 ] [ 3 ] ) ;
చార్ చెక్ విన్నర్ ( చార్ బోర్డు [ 3 ] [ 3 ] ) ;
int ప్రధాన ( ) {
చార్ బోర్డు [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
int వరుస , కల్ ;
చార్ ప్రస్తుత ఆటగాడు = 'X' ;
అయితే ( నిజం ) {
డ్రాబోర్డు ( బోర్డు ) ;
కోట్ << 'ఆటగాడు' << ప్రస్తుత ఆటగాడు << 'యొక్క మలుపు. అడ్డు వరుస (1-3) మరియు నిలువు వరుస (1-3) నమోదు చేయండి: ' ;
ఆహారపు >> వరుస >> కల్ ;
వరుస --;
కల్ --;
ఉంటే ( మూవ్ చెల్లుబాటు అవుతుంది ( బోర్డు , వరుస , కల్ ) ) {
బోర్డు [ వరుస ] [ కల్ ] = ప్రస్తుత ఆటగాడు ;
చార్ విజేత = చెక్ విన్నర్ ( బోర్డు ) ;
ఉంటే ( విజేత != '' ) {
డ్రాబోర్డు ( బోర్డు ) ;
కోట్ << 'ఆటగాడు' << విజేత << 'ఒక విజేత! \n ' ;
బ్రేక్ ;
}
ఉంటే ( isBoardFull ( బోర్డు ) ) {
డ్రాబోర్డు ( బోర్డు ) ;
కోట్ << 'ఇది టై! \n ' ;
బ్రేక్ ;
}
ప్రస్తుత ఆటగాడు = ( ప్రస్తుత ఆటగాడు == 'X' ) ? 'ఓ' : 'X' ;
} లేకపోతే {
కోట్ << 'చెల్లని తరలింపు. ఇతర గడిని ఎంచుకోండి. \n ' ;
} }
తిరిగి 0 ;
}
శూన్యం డ్రాబోర్డు ( చార్ బోర్డు [ 3 ] [ 3 ] ) {
కోట్ << 'బి| \t 1 \t | \t 2 \t | \t 3 \t | \n ' ;
కోట్ << '________________________ \n ' ;
కోసం ( int m = 0 ; m < 3 ; m ++ ) {
కోట్ << m + 1 << '|' ;
కోసం ( int t = 0 ; t < 3 ; t ++ ) {
కోట్ << '' << బోర్డు [ m ] [ t ] ;
ఉంటే ( t < 2 ) కోట్ << ' \t | \t ' ;
}
కోట్ << ' \t | \n ' ;
ఉంటే ( m < 2 ) కోట్ << '________________________ \n ' ;
}
కోట్ << ' \n ' ; }
bool isMoveValid ( చార్ బోర్డు [ 3 ] [ 3 ] , int వరుస , int కల్ ) {
తిరిగి ( వరుస >= 0 && వరుస < 3 && కల్ >= 0 && కల్ < 3 && బోర్డు [ వరుస ] [ కల్ ] == '' ) ;
}
bool isBoardFull ( చార్ బోర్డు [ 3 ] [ 3 ] ) {
కోసం ( int m = 0 ; m < 3 ; m ++ ) {
కోసం ( int t = 0 ; t < 3 ; t ++ ) {
ఉంటే ( బోర్డు [ m ] [ t ] == '' ) {
తిరిగి తప్పుడు ;
} } }
తిరిగి నిజం ; }
చార్ చెక్ విన్నర్ ( చార్ బోర్డు [ 3 ] [ 3 ] ) {
కోసం ( int m = 0 ; m < 3 ; m ++ ) {
ఉంటే ( బోర్డు [ m ] [ 0 ] == బోర్డు [ m ] [ 1 ] && బోర్డు [ m ] [ 1 ] == బోర్డు [ m ] [ 2 ] && బోర్డు [ m ] [ 0 ] != '' ) {
తిరిగి బోర్డు [ m ] [ 0 ] ;
}
ఉంటే ( బోర్డు [ 0 ] [ m ] == బోర్డు [ 1 ] [ m ] && బోర్డు [ 1 ] [ m ] == బోర్డు [ 2 ] [ m ] && బోర్డు [ 0 ] [ m ] != '' ) {
తిరిగి బోర్డు [ 0 ] [ m ] ;
} }
ఉంటే ( బోర్డు [ 0 ] [ 0 ] == బోర్డు [ 1 ] [ 1 ] && బోర్డు [ 1 ] [ 1 ] == బోర్డు [ 2 ] [ 2 ] && బోర్డు [ 0 ] [ 0 ] != '' ) {
తిరిగి బోర్డు [ 0 ] [ 0 ] ;
}
ఉంటే ( బోర్డు [ 0 ] [ 2 ] == బోర్డు [ 1 ] [ 1 ] && బోర్డు [ 1 ] [ 1 ] == బోర్డు [ 2 ] [ 0 ] && బోర్డు [ 0 ] [ 2 ] != '' ) {
తిరిగి బోర్డు [ 0 ] [ 2 ] ;
}
తిరిగి '' ;
}
దాని కార్యాచరణ యొక్క విచ్ఛిన్నం ఇక్కడ ఉంది:
“#include
ఈ ప్రోగ్రామ్‌లో నాలుగు ఫంక్షన్ ప్రోటోటైప్‌లు ఉన్నాయి - అవి drawBoard(), isMoveValid(), isBoardFull(), మరియు checkWinner(). ఫంక్షన్ డిక్లరేషన్‌ని ఫంక్షన్ ప్రోటోటైప్ అంటారు. ఇది ప్రోగ్రామ్‌లోని ప్రధాన ఫంక్షన్ తర్వాత వచ్చినప్పటికీ, ఇది ఉపయోగించబడుతుంది. ప్రధాన విధి ఆటగాళ్ళ మలుపులు మరియు కదలికలను నిర్వహించడానికి గేమ్ లూప్ మరియు లాజిక్‌ను కలిగి ఉంటుంది. ప్రధాన ఫంక్షన్‌లో, గేమ్ బోర్డ్ ఖాళీలతో ప్రారంభించబడుతుంది.
చార్ బోర్డు [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
దీని తర్వాత, ప్లేయర్ యొక్క తరలింపు ఇన్‌పుట్‌ను నిల్వ చేయడానికి రెండు అడ్డు వరుసలు మరియు కోల్ వేరియబుల్స్ నిర్వచించబడతాయి. 'చార్ కరెంట్ ప్లేయర్ = 'X';' 'X' ప్లేయర్ ముందుగా వెళ్తుందని నిర్వచిస్తుంది.
ఇప్పుడు, అయితే (నిజమైన) గేమ్ లూప్ ప్రారంభమవుతుంది మరియు విజేత లేదా టై అయ్యే వరకు ఇది నడుస్తుంది. ఈ “వేళ” లూప్ “drawBoard();” బోర్డుని ప్రదర్శించడానికి. కన్సోల్‌లో బోర్డుని ప్రదర్శించిన తర్వాత, కింది కోడ్ స్టేట్‌మెంట్‌లో మార్క్ చేయడానికి సెల్‌ను ఎంచుకోమని వినియోగదారుని అడుగుతారు:
కోట్ << 'ఆటగాడు' << ప్రస్తుత ఆటగాడు << 'యొక్క మలుపు. అడ్డు వరుస మరియు నిలువు వరుస (1-3) నమోదు చేయండి: ' ;
ఆటగాడు వారి కదలికను “cin >> row >> col;”లో ఇన్‌పుట్ చేస్తాడు.
మార్కింగ్ కోసం సెల్‌ను ఎంచుకున్న తర్వాత, ప్రోగ్రామ్ ముందుగా ఇన్‌పుట్ యొక్క చెల్లుబాటును ధృవీకరిస్తుంది, isMoveValid() ఫంక్షన్‌కు కాల్ చేయడం ద్వారా సెల్ ఇప్పటికే పూరించబడలేదని నిర్ధారిస్తుంది.
బోర్డు [ వరుస ] [ కల్ ] = ప్రస్తుత ఆటగాడు ;ఈ ప్రకటన ప్లేయర్ యొక్క గుర్తును బోర్డుపై ఉంచుతుంది.
చార్ విజేత = చెక్ విన్నర్ ( బోర్డు ) ;ఉంటే ( విజేత != '' ) {
డ్రాబోర్డు ( బోర్డు ) ;
కోట్ << 'ఆటగాడు' << విజేత << 'గెలుస్తుంది! \n ' ;
ఈ స్టేట్‌మెంట్‌లు ఒక ఆటగాడు బోర్డులో ఎంట్రీని గుర్తించిన ప్రతిసారీ విజేత కోసం తనిఖీ చేస్తాయి. విజేత ఉన్నట్లయితే విజేత పేరు ప్రకటించబడుతుంది మరియు ప్రోగ్రామ్ గేమ్ లూప్ నుండి నిష్క్రమిస్తుంది.
ఉంటే ( isBoardFull ( బోర్డు ) ) {ఈ ప్రకటన టై కోసం తనిఖీ చేస్తుంది. బోర్డు నిండినప్పుడు మరియు విజేత లేనప్పుడు టై పరిస్థితి ఏర్పడుతుంది. ఈ సందర్భంలో, 'ఇది టై!' తెరపై ముద్రించబడింది.
ప్రస్తుత ఆటగాడు = ( ప్రస్తుత ఆటగాడు == 'X' ) ? 'ఓ' : 'X' ;ఈ ప్రకటన ప్రతి క్రీడాకారుడు తమ వంతును ఆడేందుకు ఆటగాళ్లను మారుస్తుంది.
కోట్ << 'చెల్లని తరలింపు. ఇతర గడిని ఎంచుకోండి. \n ' ;తరలింపు చెల్లుబాటు కాకపోతే, వినియోగదారు మళ్లీ ఇన్‌పుట్ చేయమని మరియు ఏదైనా ఇతర సెల్‌ను ఎంచుకోమని ప్రాంప్ట్ చేయబడతారు.
'ప్రధాన' ఫంక్షన్ తర్వాత, గతంలో ప్రకటించిన ఫంక్షన్ ప్రోటోటైప్‌ల కోసం ఫంక్షన్ నిర్వచనాలు ప్రారంభమవుతాయి. ఇక్కడ నిర్వచించబడిన మొదటి ఫంక్షన్ డ్రాబోర్డ్() టిక్-టాక్-టో బోర్డ్‌ను కన్సోల్‌కు గీయడానికి ఉపయోగించబడుతుంది. డ్రాబోర్డ్() ఫంక్షన్ గ్రిడ్ లైన్‌లతో సహా బోర్డు యొక్క ప్రస్తుత స్థితిని ముద్రిస్తుంది.
ఇక్కడ నిర్వచించబడిన తదుపరి ఫంక్షన్ isMoveValid(). బోర్డు లోపల మరియు ఖాళీ సెల్‌లో కదలిక అనుమతించబడుతుందో లేదో తెలుసుకోవడానికి ఈ ఫంక్షన్ ఉపయోగించబడుతుంది. బోర్డ్ ఇంకా నిండి ఉందో లేదో తనిఖీ చేయడానికి isBoardFull() ఫంక్షన్ ఉపయోగించబడుతుంది. విజేత లేనప్పుడు టై పరిస్థితికి ఇది ఒక షరతు. isBoardFull() బోర్డ్‌లోని అన్ని స్థానాలు నిండి ఉన్నాయో లేదో తనిఖీ చేస్తుంది, ఇది విజేత లేనట్లయితే టై అని సూచిస్తుంది. విజేత ఉన్నట్లయితే, చెక్ విన్నర్() ఫంక్షన్‌ని ఉపయోగించి దాన్ని నిర్ధారించవచ్చు. చెక్‌విన్నర్() ఒకే ప్లేయర్ మార్క్ ('X' లేదా 'O') కోసం అన్ని సంభావ్య విజేత పంక్తులను తనిఖీ చేస్తుంది మరియు కనుగొనబడితే గెలిచిన ఆటగాడి గుర్తును లేదా ఇంకా విజేత లేకుంటే '' స్పేస్ క్యారెక్టర్‌ను అందిస్తుంది. కిందిది ప్రోగ్రామ్ యొక్క అవుట్‌పుట్. ఇది ప్రతి ఆటగాడి నుండి ప్రతి మలుపును చూపుతుంది.
మొదట, బోర్డు స్పష్టంగా ఉంది; ప్లేయర్ “X” మార్క్ చేయాల్సిన సెల్‌ను ఎంచుకోమని ప్రాంప్ట్ చేయబడుతుంది. ఇక్కడ, ప్లేయర్ 'X' 2 మరియు 2లోకి ప్రవేశిస్తుంది. అడ్డు వరుస 2 మరియు నిలువు వరుస 2 యొక్క సెల్‌లు గుర్తించబడతాయి. కింది వాటిలో గుర్తించబడిన బోర్డుని చూడండి:
ఇప్పుడు, ఇది ఓ ప్లేయర్ వంతు. మార్క్ చేయడానికి సెల్‌ను ఎంచుకోమని ప్లేయర్ ప్రాంప్ట్ చేయబడతాడు. ప్లేయర్ 'O' అడ్డు వరుస కోసం 1 మరియు నిలువు వరుస కోసం 1 ఎంచుకుంటుంది. కింది అవుట్‌పుట్ స్నిప్పెట్‌లో చూపిన విధంగా ఎంచుకున్న సెల్ ప్లేయర్ “O” కోసం గుర్తించబడింది:
ప్రతి ఆటగాడికి అన్ని మలుపులు ఒకే నమూనాను అనుసరిస్తాయి. ఇది ప్లేయర్ X యొక్క వంతు, మరియు ఆటగాడు అడ్డు వరుస కోసం 1 మరియు నిలువు వరుస కోసం 2 ఎంచుకుంటాడు. కింది ఇచ్చిన అవుట్‌పుట్ స్నాప్‌షాట్‌లను చూడండి:
ఇప్పుడు, ప్లేయర్ 'O' కోసం మలుపు. ఆటగాడు అడ్డు వరుస కోసం 1 మరియు నిలువు వరుస కోసం 3 ఎంచుకుంటాడు.
తదుపరి మలుపు మళ్లీ ప్లేయర్ 'X'లో ఉంది. ఆటగాడు అడ్డు వరుస కోసం 3 మరియు నిలువు వరుస కోసం 1 ఎంచుకుంటాడు.
ప్లేయర్ 'O' అడ్డు వరుస కోసం 3 మరియు నిలువు వరుస కోసం 2 ఎంచుకుంటుంది.
ప్లేయర్ 'X' రెండవ అడ్డు వరుస మరియు మూడవ నిలువు వరుసను ఎంచుకుంటుంది.
ప్లేయర్ 'O' ఇప్పుడు రెండవ అడ్డు వరుస మరియు మొదటి నిలువు వరుసను ఎంచుకుంటుంది.
ప్లేయర్ 'X' ఈసారి మూడవ అడ్డు వరుస మరియు మూడవ నిలువు వరుసను ఎంచుకుంటుంది.
ఏ ఆటగాడు ఏ పంక్తిని అడ్డంగా, నిలువుగా లేదా వికర్ణంగా చేయలేరు, కనుక ఇది టై. ఎంచుకున్న ఇన్‌పుట్‌ల శ్రేణికి విజేత లేరు.
మొత్తంమీద, కోడ్ ప్రధాన గేమ్ లూప్‌ను కలిగి ఉంటుంది, ఇది గేమ్ స్థితి మరియు వినియోగదారు ఇన్‌పుట్‌ను నిర్వహించడానికి బాధ్యత వహిస్తుంది, అలాగే బోర్డ్‌ను గీయడానికి, కదలికలను ధృవీకరించడానికి, పూర్తి బోర్డ్‌ను తనిఖీ చేయడానికి మరియు విజేత ఉన్నారో లేదో నిర్ణయించడానికి ఉపయోగించే అనేక యుటిలిటీ ఫంక్షన్‌లతో పాటు. .
ముగింపు
C++ని ఉపయోగించి టిక్-టాక్-టో గేమ్‌ను అభివృద్ధి చేయడం అనేది మీ ప్రోగ్రామింగ్ నైపుణ్యాలను బలోపేతం చేయడానికి ఒక అద్భుతమైన ఆచరణాత్మక వ్యాయామం. C++లో టిక్-టాక్-టోని ఎలా సృష్టించాలో కథనం ఖచ్చితంగా వివరిస్తుంది. ఈ కథనంలో అందించబడిన దశల వారీ మార్గదర్శకత్వం గేమ్ మెకానిక్స్, యూజర్ ఇంటరాక్షన్‌లు మరియు సమర్థవంతమైన కోడ్ నిర్మాణాన్ని అర్థం చేసుకోవడానికి పాఠకులకు 2D శ్రేణి, ఫంక్షన్‌లు మరియు ఇతర పరిస్థితులను కలిగి ఉంటుంది. కోడ్ యొక్క వివరణాత్మక వాక్‌త్రూ మరియు కోర్ గేమ్‌ప్లేకి కీలకమైన ఫంక్షన్‌ల వివరణ C++ ప్రోగ్రామింగ్ పద్ధతులు మరియు సాధారణ గేమ్ డెవలప్‌మెంట్ యొక్క చిక్కులు రెండింటిలోనూ అమూల్యమైన అంతర్దృష్టులతో పాఠకులను సన్నద్ధం చేస్తాయి.