C++లో ప్రాథమిక వచన-ఆధారిత గేమ్‌ను ఎలా సృష్టించాలి
C++లోని టెక్స్ట్-ఆధారిత గేమ్‌లు ప్లేయర్‌ని కన్సోల్ విండో ద్వారా ఇన్‌పుట్ ఆదేశాలను అనుమతిస్తాయి మరియు ప్రోగ్రామ్ ప్లేయర్ కదలికలను ప్రాసెస్ చేస్తుంది. ఇక్కడ, నేను వినియోగదారు ఆడటానికి రెండు ఎంపికలను అనుమతించే టెక్స్ట్-ఆధారిత టిక్-టాక్-టో గేమ్‌ని సృష్టించాను. వినియోగదారు C++ కంపైలర్‌తో లేదా తోటి మనిషితో ఆడవచ్చు. ఈ గేమ్‌లో గెలిచిన ఆటగాడికి స్కోర్‌ను జోడించే ఫీచర్ ఉంది. మొదటి గేమ్ ఫలితం ప్రకటించిన తర్వాత, మళ్లీ మ్యాచ్ ఎంపిక అందుబాటులో ఉంటుంది.
గేమ్ గెలవడానికి నియమాలు
ఇద్దరు ఆటగాళ్ళు టిక్-టాక్-టో గేమ్ ఆడతారు, త్రీ-బై-త్రీ గ్రిడ్‌లో అందుబాటులో ఉన్న తొమ్మిది ఖాళీలలో ఒకదానిలో ప్రత్యామ్నాయంగా X మరియు 0ని ఉంచారు. నిలువు, క్షితిజ సమాంతర లేదా వికర్ణ దిశలో వరుసగా మూడు మార్కులను పొందిన మొదటి ఆటగాడు గేమ్ గెలుస్తాడు. ప్రతి క్రీడాకారుడు తెలివిగా ఆలోచించాలి మరియు ఇతర ఆటగాడి తదుపరి కదలిక కోసం ఎదురుచూడాలి.
టెక్స్ట్-ఆధారిత టిక్-టాక్-టో గేమ్ రూపకల్పన కోసం కోడ్ విభిన్న విభాగాలను కలిగి ఉంది, కార్యాచరణ ఆధారంగా విభజించబడింది. మొదటి విభాగంలో, వినియోగదారు కంప్యూటర్‌తో ఆడాలా లేదా తోటి మనిషితో ఆడాలా అని నిర్ణయిస్తారు. లాభం యొక్క మోడ్‌ను నిర్ణయించిన తర్వాత, ప్రోగ్రామ్ వినియోగదారుని ఇన్‌పుట్ కోసం అడుగుతుంది. ఇద్దరు ఆటగాళ్లు ఒకదాని తర్వాత మరొకటి ఇన్‌పుట్‌ని నమోదు చేస్తారు.
//ఆటగాళ్ళ నుండి ఇన్‌పుట్ తీసుకోండి
శూన్యం ప్లేయర్‌ఇన్‌పుట్ ( ఆటగాడు & ఆటగాడు ) {
int పోస్ ;
కోట్ << endl ;
కోట్ << ' \t ' << ఆటగాడు. పేరు పొందండి ( ) << 'మలుపు:' ;
కోట్ << ' \t స్థానాన్ని నమోదు చేయండి' <> పోస్ ;
పోస్ - = 1 ;
ఉంటే ( ఖాళీ సూచిక [ పోస్ ] == 1 ) {
కోట్ << '----స్థానం ఖాళీ లేదు------' << endl ;
ప్లేయర్‌ఇన్‌పుట్ ( ఆటగాడు ) ;
} లేకపోతే {
ఖాళీ సూచిక [ పోస్ ] = 1 ;
ఖాళీ కౌంట్ - = 1 ;
ఆటగాడు. పేరు పొందండి ( ) . సరిపోల్చండి ( 'ప్లేయర్ I' ) == 0 ? బోర్డు [ పోస్ ] = 'X' : బోర్డు [ పోస్ ] = 'ఓ' ;
}
}
వినియోగదారు నుండి ఇన్‌పుట్‌లను తీసుకున్న తర్వాత, ఇది గెలుపు నియమాన్ని తనిఖీ చేస్తుంది. చెక్విన్() ఫంక్షన్‌లో ప్లేయర్ గెలిచాడా లేదా అని తనిఖీ చేయడానికి p1 మరియు p2 అనే రెండు పారామీటర్‌లు ఉన్నాయి. i, j, మరియు k అనే ఫంక్షన్‌లో వివిధ వేరియబుల్స్ డిక్లేర్ చేయబడతాయి లూప్ కోసం డిక్లేర్డ్ చేయబడిన పూర్ణాంక వేరియబుల్స్ మరియు ఫ్లాగ్ అనేది విన్ కండిషన్‌ను తనిఖీ చేయడానికి బూలియన్ ఫంక్షన్. లూప్ మొదటి స్థానం నుండి ప్రారంభమవుతుంది మరియు మొత్తం తొమ్మిది స్థానాలకు పునరావృతమవుతుంది. మొదటి_చిహ్నం అనేది ఒక అక్షరం, అది నిజమైతే 0 లేదా X ఉండవచ్చు, అప్పుడు సాధ్యమయ్యే అన్ని కలయికలు గెలిచిన నియమం కోసం తనిఖీ చేయబడతాయి. లేకపోతే, ఇటరేటర్ తదుపరి స్థానానికి వెళుతుంది మరియు సాధ్యమయ్యే అన్ని స్థానాలను తనిఖీ చేసే వరకు అదే కొనసాగుతుంది. ఫ్లాగ్ నిజమని సెట్ చేయబడితే, విజేత ప్రకటించబడుతుంది మరియు ప్రోగ్రామ్ మళ్లీ ఎంపిక చేయమని అడుగుతుంది.
శూన్యం చెక్విన్ ( ఆటగాడు & p1, ప్లేయర్ & p2 ) {
int i,j,k ;
బూల్ జెండా = తప్పుడు ;
చార్ మొదటి_చిహ్నం ;
కోసం ( i = 0 ; i < 8 ; i ++ ) {
మొదటి_చిహ్నం = బోర్డు [ విజేతల జాబితా [ i ] . వరుస [ 0 ] ] ;
ఉంటే ( ( మొదటి_చిహ్నం ! = 'X' ) && ( మొదటి_చిహ్నం ! = 'ఓ' ) ) {
జెండా = తప్పుడు ;
కొనసాగుతుంది ;
}
జెండా = నిజం ;
కోసం ( జె = 0 ; జె < 3 ; జె ++ ) {
ఉంటే ( మొదటి_చిహ్నం ! = బోర్డు [ విజేతల జాబితా [ i ] . వరుస [ జె ] ] ) {
జెండా = తప్పుడు ;
బ్రేక్ ;
}
}
ఉంటే ( జెండా ) {
ఆట మొదలైంది = 0 ;
ఉంటే ( మొదటి_చిహ్నం == 'X' ) {
కోట్ << '------------------------' << endl ;
కోట్ << ' \t నేను గెలిచిన ఆటగాడు' << endl ;
కోట్ << '------------------------' << endl ;
p1. గెలిచాడు ( ) ;
} లేకపోతే {
p2. గెలిచాడు ( ) ;
ఉంటే ( కంప్యూటర్కు వ్యతిరేకంగా ) {
కోట్ << '------------------------' << endl ;
కోట్ << ' \t కంప్యూటర్ గెలిచింది' << endl ;
కోట్ << '------------------------' << endl ;
} లేకపోతే {
కోట్ << '------------------------' << endl ;
కోట్ << ' \t ప్లేయర్ II గెలిచింది' << endl ;
కోట్ << '------------------------' << endl ;
}
}
డిస్ప్లే స్కోర్ ( p1,p2 ) ;
బ్రేక్ ;
}
కోడ్ యొక్క ఈ భాగం గేమ్ స్కోర్‌ను చూపుతుంది. గేమ్ కంప్యూటర్కు వ్యతిరేకంగా ఉంటే, ప్లేయర్ 1 మరియు కంప్యూటర్ యొక్క స్కోర్ ప్రదర్శించబడుతుంది, లేకపోతే ప్లేయర్ 1 మరియు ప్లేయర్ 2 స్కోర్ ప్రదర్శించబడుతుంది.
శూన్యం డిస్ప్లే స్కోర్ ( ఆటగాడు & p1, ప్లేయర్ & p2 ) {
కోట్ << endl ;
కోట్ << ' \t స్కోర్: \t ' ;
ఉంటే ( కంప్యూటర్కు వ్యతిరేకంగా )
కోట్ << 'ప్లేయర్ I:' << p1. గెట్ స్కోర్ ( ) << ' \t కంప్యూటర్: ' << p2. గెట్ స్కోర్ ( ) << endl ;
లేకపోతే
కోట్ << 'ప్లేయర్ I:' << p1. గెట్ స్కోర్ ( ) << ' \t ప్లేయర్ II: ' << p2. గెట్ స్కోర్ ( ) << endl ;
}
ఇద్దరు ఆటగాళ్ల కోసం టిక్-టాక్-టో గేమ్ అమలుకు ఇది ప్రధాన కోడ్. వినియోగదారు స్విచ్ కేస్ స్టేట్‌మెంట్‌ని ఉపయోగించి నిర్వహించాల్సిన వివిధ విధానాల నుండి ఎంచుకోవచ్చు. ఈ కోడ్ C++ కంపైలర్‌లో గేమ్ ఆడేందుకు వినియోగదారు-స్నేహపూర్వక ఇంటర్‌ఫేస్‌ను అందిస్తుంది మరియు వినియోగదారు నిష్క్రమణ ఎంపికను ఎంచుకునే వరకు కోడ్ అమలులో ఉంటుంది.
int ప్రధాన ( ){
int చ ;
అయితే ( 1 ) {
కోట్ << ' ----------మెను----------' << endl ;
కోట్ << ' \t 1. 1 ప్లేయర్ గేమ్' << endl ;
కోట్ << ' \t 2. 2 ప్లేయర్ గేమ్' << endl ;
కోట్ << ' \t 3. నిష్క్రమించడానికి ' << endl ;
కోట్ << ' ----------' << endl ;
కోట్ << endl ;
కోట్ << ' \t ఒక ఎంపికను ఎంచుకోండి' <> చ ;
మారండి ( చ ) {
కేసు 1 : {
గేమ్ * ఆట = కొత్త గేమ్ ;
ఆట - > వేడి ( ) ;
ఆట - > onePlayerGame ( ) ;
}
బ్రేక్ ;
కేసు 2 : {
గేమ్ * ఆట = కొత్త గేమ్ ;
ఆట - > వేడి ( ) ;
ఆట - > రెండు ప్లేయర్ గేమ్ ( ) ;
}
బ్రేక్ ;
కేసు 3 :
తిరిగి 0 ;
డిఫాల్ట్ :
కోట్ << 'అయ్యో చెల్లని ఎంపిక! మళ్లీ ప్రయత్నించండి' ;
}
}
తిరిగి 0 ;
}
టెక్స్ట్-ఆధారిత టిక్-టాక్-టాక్ గేమ్ కోసం పూర్తి కోడ్
ఇది టెక్స్ట్-ఆధారిత టిక్-టాక్-టో గేమ్ రూపకల్పన మరియు అమలు కోసం పూర్తి కోడ్.
#
#చేర్చండి<జాబితా>
#
#include
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
టైప్డెఫ్ నిర్మాణం {
int * వరుస ;
} WinList ;
తరగతి ఆటగాడు {
ప్రైవేట్ :
స్ట్రింగ్ పేరు ;
int స్కోర్ ;
ప్రజా :
ఆటగాడు ( ) : ఆటగాడు { '' } { }
ఆటగాడు ( స్ట్రింగ్ n ) : స్కోర్ { 0 } , పేరు { n } { }
శూన్యం గెలిచాడు ( ) {
//స్కోరును పెంచండి
స్కోర్ ++ ;
}
int గెట్ స్కోర్ ( ) { తిరిగి ఇది - > స్కోర్ ; }
స్ట్రింగ్ getName ( ) { తిరిగి ఇది - > పేరు ; }
} ;
తరగతి గేమ్ {
ప్రైవేట్ :
చార్ బోర్డు [ 9 ] ;
int ఖాళీ సూచిక [ 9 ] ;
int గేమ్‌ఆన్, కంప్యూటర్కు వ్యతిరేకంగా ;
int ఖాళీ కౌంట్ ;
విన్‌లిస్ట్ విన్‌లిస్ట్ [ 8 ] ;
శూన్యం డిస్ప్లేబోర్డ్ ( ) {
కోట్ << endl ;
కోట్ << ' | | ' << endl ;
కోట్ << '' << బోర్డు [ 0 ] << ' | ' << బోర్డు [ 1 ] << ' | ' << బోర్డు [ 2 ] << endl ;
కోట్ << ' | | ' << endl ;
కోట్ << '------------' << endl ;
కోట్ << ' | | ' << endl ;
కోట్ << '' << బోర్డు [ 3 ] << ' | ' << బోర్డు [ 4 ] << ' | ' << బోర్డు [ 5 ] << endl ;
కోట్ << ' | | ' << endl ;
కోట్ << '------------' << endl ;
కోట్ << ' | | ' << endl ;
కోట్ << '' << బోర్డు [ 6 ] << ' | ' << బోర్డు [ 7 ] << ' | ' << బోర్డు [ 8 ] << endl ;
కోట్ << ' | | ' << endl ;
కోట్ << endl ;
}
శూన్యం కంప్యూటర్ ఇన్‌పుట్ ( ) {
int పోస్ ;
పోస్ = రాండ్ ( ) % 10 ;
ఉంటే ( ఖాళీ సూచిక [ పోస్ ] == 1 ) {
ఉంటే ( ఖాళీ కౌంట్ < 0 )
తిరిగి ;
కంప్యూటర్ ఇన్‌పుట్ ( ) ;
} లేకపోతే {
కోట్ << 'కంప్యూటర్ ఎంచుకోండి:' << పోస్ + 1 << endl ;
ఖాళీ సూచిక [ పోస్ ] = 1 ;
ఖాళీ కౌంట్ - = 1 ;
బోర్డు [ పోస్ ] = 'ఓ' ;
}
}
శూన్యం ప్లేయర్‌ఇన్‌పుట్ ( ఆటగాడు & ఆటగాడు ) {
int పోస్ ;
కోట్ << endl ;
కోట్ << ' \t ' << ఆటగాడు. పేరు పొందండి ( ) << 'మలుపు:' ;
కోట్ << ' \t స్థానాన్ని నమోదు చేయండి' <> పోస్ ;
పోస్ - = 1 ;
ఉంటే ( ఖాళీ సూచిక [ పోస్ ] == 1 ) {
కోట్ << '----స్థానం ఖాళీ లేదు------' << endl ;
ప్లేయర్‌ఇన్‌పుట్ ( ఆటగాడు ) ;
} లేకపోతే {
ఖాళీ సూచిక [ పోస్ ] = 1 ;
ఖాళీ కౌంట్ - = 1 ;
ఆటగాడు. పేరు పొందండి ( ) . సరిపోల్చండి ( 'ప్లేయర్ I' ) == 0 ? బోర్డు [ పోస్ ] = 'X' : బోర్డు [ పోస్ ] = 'ఓ' ;
}
}
శూన్యం చెక్విన్ ( ఆటగాడు & p1, ప్లేయర్ & p2 ) {
int i,j,k ;
బూల్ జెండా = తప్పుడు ;
చార్ మొదటి_చిహ్నం ;
కోసం ( i = 0 ; i < 8 ; i ++ ) {
మొదటి_చిహ్నం = బోర్డు [ విజేతల జాబితా [ i ] . వరుస [ 0 ] ] ;
ఉంటే ( ( మొదటి_చిహ్నం ! = 'X' ) && ( మొదటి_చిహ్నం ! = 'ఓ' ) ) {
జెండా = తప్పుడు ;
కొనసాగుతుంది ;
}
జెండా = నిజం ;
కోసం ( j = 0 ; j < 3 ; j ++ ) {
ఉంటే ( మొదటి_చిహ్నం ! = బోర్డు [ విజేతల జాబితా [ i ] . వరుస [ j ] ] ) {
జెండా = తప్పుడు ;
బ్రేక్ ;
}
}
ఉంటే ( జెండా ) {
ఆట మొదలైంది = 0 ;
ఉంటే ( మొదటి_చిహ్నం == 'X' ) {
కోట్ << '------------------------' << endl ;
కోట్ << ' \t నేను గెలిచిన ఆటగాడు' << endl ;
కోట్ << '------------------------' << endl ;
p1. గెలిచాడు ( ) ;
} లేకపోతే {
p2. గెలిచాడు ( ) ;
ఉంటే ( కంప్యూటర్కు వ్యతిరేకంగా ) {
కోట్ << '------------------------' << endl ;
కోట్ << ' \t కంప్యూటర్ గెలిచింది' << endl ;
కోట్ << '------------------------' << endl ;
} లేకపోతే {
కోట్ << '------------------------' << endl ;
కోట్ << ' \t ప్లేయర్ II గెలిచింది' << endl ;
కోట్ << '------------------------' < 0 ) && ( ఆట మొదలైంది ! = 0 ) ) {
ఉంటే ( కంప్యూటర్కు వ్యతిరేకంగా )
చెయ్యి == 1 ? కంప్యూటర్ ఇన్‌పుట్ ( ) : ప్లేయర్‌ఇన్‌పుట్ ( p2 ) ;
లేకపోతే
చెయ్యి == 1 ? ప్లేయర్‌ఇన్‌పుట్ ( p1 ) : ప్లేయర్‌ఇన్‌పుట్ ( p2 ) ;
చెయ్యి = ! చెయ్యి ;
డిస్ప్లేబోర్డ్ ( ) ;
చెక్విన్ ( p1,p2 ) ;
}
ఉంటే ( ఖాళీ కౌంట్ <= 0 ) {
కోట్ << ' ------------------------' << endl ;
కోట్ << ' \t విజేత లేరు' << endl ;
కోట్ << ' ------------------------' << endl ;
}
కోట్ << endl ;
కోట్ <> తిరిగి మ్యాచ్ ;
ఉంటే ( ( తిరిగి మ్యాచ్ == 'మరియు' ) || ( తిరిగి మ్యాచ్ == 'మరియు' ) ) {
వేడి ( ) ;
ప్లే ( p1,p2 ) ;
}
}
శూన్యం డిస్ప్లే స్కోర్ ( ఆటగాడు & p1, ప్లేయర్ & p2 ) {
కోట్ << endl ;
కోట్ << ' \t స్కోర్: \t ' ;
ఉంటే ( కంప్యూటర్కు వ్యతిరేకంగా )
కోట్ << 'ప్లేయర్ I:' << p1. గెట్ స్కోర్ ( ) << ' \t కంప్యూటర్: ' << p2. గెట్ స్కోర్ ( ) << endl ;
లేకపోతే
కోట్ << 'ప్లేయర్ I:' << p1. గెట్ స్కోర్ ( ) << ' \t ప్లేయర్ II: ' << p2. గెట్ స్కోర్ ( ) << endl ;
}
ప్రజా :
గేమ్ ( ) : ఖాళీ కౌంట్ { 0 } , ఆట మొదలైంది { 1 } , కంప్యూటర్కు వ్యతిరేకంగా { 0 } {
వేడి ( ) ;
విజేతల జాబితా [ 0 ] . వరుస = కొత్త int [ 3 ] { 0 , 1 , 2 } ;
విజేతల జాబితా [ 1 ] . వరుస = కొత్త int [ 3 ] { 3 , 4 , 5 } ;
విజేతల జాబితా [ 2 ] . వరుస = కొత్త int [ 3 ] { 6 , 7 , 8 } ;
విజేతల జాబితా [ 3 ] . వరుస = కొత్త int [ 3 ] { 0 , 3 , 6 } ;
విజేతల జాబితా [ 4 ] . వరుస = కొత్త int [ 3 ] { 1 , 4 , 7 } ;
విజేతల జాబితా [ 5 ] . వరుస = కొత్త int [ 3 ] { 2 , 5 , 8 } ;
విజేతల జాబితా [ 6 ] . వరుస = కొత్త int [ 3 ] { 0 , 4 , 8 } ;
విజేతల జాబితా [ 7 ] . వరుస = కొత్త int [ 3 ] { 2 , 4 , 6 } ;
}
శూన్యం వేడి ( ) {
ఆట మొదలైంది = 1 ;
ఖాళీ కౌంట్ = 0 ;
srand ( సమయం ( 0 ) ) ;
కోసం ( పరిమాణం_t i = 0 ; i < 10 ; i ++ ) {
ఖాళీ సూచిక [ i ] = 0 ;
బోర్డు [ i ] = ( i + 1 ) + '0' ;
ఖాళీ కౌంట్ ++ ;
}
ఖాళీ కౌంట్ -- ;
}
శూన్యం onePlayerGame ( ) {
//ప్లేయర్‌ని సృష్టిస్తోంది
ప్లేయర్ పి ( 'ప్లేయర్ I' ) ;
ప్లేయర్ సి ( 'కంప్యూటర్' ) ;
కోట్ << ' ------------------------' << endl ;
కోట్ << ' \t ప్లేయర్ I: X \t కంప్యూటర్: O' << endl ;
కోట్ << ' ------------------------' << endl ;
కోట్ << endl ;
కంప్యూటర్కు వ్యతిరేకంగా = 1 ;
ప్లే ( c,p ) ;
}
శూన్యం రెండు ప్లేయర్ గేమ్ ( ) {
//ప్లేయర్‌ని సృష్టిస్తోంది
ప్లేయర్ పి ( 'ప్లేయర్ I' ) ;
ప్లేయర్ సి ( 'ప్లేయర్ II' ) ;
కోట్ << ' ------------------------' << endl ;
కోట్ << ' \t ప్లేయర్ I: X \t ప్లేయర్ II: O' << endl ;
కోట్ << ' ------------------------' << endl ;
కోట్ << endl ;
కంప్యూటర్కు వ్యతిరేకంగా = 0 ;
ప్లే ( c,p ) ;
}
} ;
int ప్రధాన ( )
{
int చ ;
అయితే ( 1 ) {
కోట్ << ' ----------మెను----------' << endl ;
కోట్ << ' \t 1. 1 ప్లేయర్ గేమ్' << endl ;
కోట్ << ' \t 2. 2 ప్లేయర్ గేమ్' << endl ;
కోట్ << ' \t 3. నిష్క్రమించడానికి ' << endl ;
కోట్ << ' ----------' << endl ;
కోట్ << endl ;
కోట్ << ' \t ఒక ఎంపికను ఎంచుకోండి' <> చ ;
మారండి ( చ ) {
కేసు 1 : {
గేమ్ * ఆట = కొత్త గేమ్ ;
ఆట - > వేడి ( ) ;
ఆట - > onePlayerGame ( ) ;
}
బ్రేక్ ;
కేసు 2 : {
గేమ్ * ఆట = కొత్త గేమ్ ;
ఆట - > వేడి ( ) ;
ఆట - > రెండు ప్లేయర్ గేమ్ ( ) ;
}
బ్రేక్ ;
కేసు 3 :
తిరిగి 0 ;
డిఫాల్ట్ :
కోట్ << 'అయ్యో చెల్లని ఎంపిక! మళ్లీ ప్రయత్నించండి' ;
}
}
తిరిగి 0 ;
}
ఇది టిక్-టాక్-టో గేమ్ అమలుకు సంబంధించిన పూర్తి కోడ్, ఇది కంప్యూటర్‌తో లేదా తోటి మనిషితో రెండు మోడ్‌లలో ఆడవచ్చు. ఇది సాధ్యమయ్యే అన్ని ఆదేశాలతో సహా బహుముఖ కోడ్. వినియోగదారు ఇప్పటికే పూరించిన స్థానాన్ని ఇన్‌పుట్ చేసినప్పుడు, అది ఈ స్థానాన్ని ఓవర్‌రైట్ చేయదు మరియు ఈ తరలింపు చెల్లదని పరిగణిస్తుంది.
ఇప్పటి వరకు ఆటగాడు మొదటి పెట్టెను ఎంచుకున్నాడు మరియు తదుపరి మలుపులో కంప్యూటర్ ఆరవ పెట్టెను గుర్తించింది:
ఇద్దరు ఆటగాళ్ళు ఇప్పటి వరకు రెండు పెట్టెలను ఎంచుకున్నారు మరియు తదుపరి మలుపులో నేను ఏడవ బాక్స్‌ను ఎంచుకున్నాను, ఫలితంగా వరుసగా నిలువుగా ఉండే నమూనా ఏర్పడుతుంది:
వినియోగదారు గేమ్ ఆడటానికి కంప్యూటర్‌ను ఉపయోగించాలని ఎంచుకుంటారు, కాబట్టి మూడు కదలికలు తీసుకున్న తర్వాత, వినియోగదారు కంప్యూటర్ నుండి గెలిచారు మరియు ప్లేయర్ 1 యొక్క రికార్డ్‌కు ఒక స్కోర్ జోడించబడుతుంది. మొదటి మ్యాచ్ ముగిసిన తర్వాత, కంపైలర్ రీమ్యాచ్ కోసం అడుగుతాడు. వినియోగదారు ఎంపికల నుండి నిర్ణయిస్తారు మరియు ప్రోగ్రామ్ ప్రధాన విభాగానికి తిరిగి వస్తుంది. మూడు ఎంపికను ఎంచుకున్న తర్వాత కంపైలర్ కోడ్ అమలులో ఉంది.
ముగింపు
టెక్స్ట్-ఆధారిత గేమ్‌లు ప్లేయర్‌తో పరస్పర చర్య కోసం టెక్స్ట్ అక్షరాలు మరియు కమాండ్ లైన్ ఇంటర్‌ఫేస్‌పై ఆధారపడతాయి. వాటికి గ్రాఫికల్ ఇమేజ్‌లు, సౌండ్‌లు లేదా యానిమేషన్‌లు లేవు. వినియోగదారు కన్సోల్ విండో ద్వారా ఆదేశాన్ని ఇన్‌పుట్ చేస్తారు. వినియోగదారు-స్నేహపూర్వక టెక్స్ట్-ఆధారిత టిక్-టాక్-టో గేమ్ C++ని ఉపయోగించి రూపొందించబడింది. ఇది కంప్యూటర్‌తో లేదా మరొక తోటి ప్లేయర్‌తో ఆడగలిగే గేమ్‌ను రూపొందించడానికి వివిధ ఆదేశాలను ఉపయోగిస్తుంది.