C++ இல் ஒரு அடிப்படை உரை அடிப்படையிலான விளையாட்டை எவ்வாறு உருவாக்குவது
C++ இல் உள்ள உரை அடிப்படையிலான கேம்கள் கன்சோல் சாளரத்தின் மூலம் கட்டளைகளை உள்ளிட பிளேயரை அனுமதிக்கின்றன, மேலும் நிரல் பிளேயரின் நகர்வுகளை செயல்படுத்துகிறது. இங்கே, நான் உரை அடிப்படையிலான டிக்-டாக்-டோ விளையாட்டை உருவாக்கியுள்ளேன், இது பயனர் விளையாடுவதற்கு இரண்டு விருப்பங்களை அனுமதிக்கிறது. பயனர் C++ கம்பைலருடன் அல்லது சக மனிதருடன் விளையாடலாம். இந்த விளையாட்டில் வெற்றிபெறும் வீரருக்கான ஸ்கோரைத் தொடர்ந்து சேர்க்கும் அம்சம் உள்ளது. முதல் ஆட்டத்தின் முடிவு அறிவிக்கப்பட்ட பிறகு, மீண்டும் போட்டிக்கான விருப்பம் உள்ளது.
விளையாட்டில் வெற்றி பெறுவதற்கான விதிகள்
இரண்டு வீரர்கள் டிக்-டாக்-டோ விளையாட்டை விளையாடுகிறார்கள், மூன்று-மூன்று-கட்டத்தில் கிடைக்கும் ஒன்பது இடைவெளிகளில் ஒன்றில் மாற்றாக X மற்றும் 0 ஐ வைக்கிறார்கள். செங்குத்து, கிடைமட்ட அல்லது மூலைவிட்ட திசையில் தனது தொடர்ச்சியான மூன்று மதிப்பெண்களைப் பெறும் முதல் வீரர் கேம் வென்றார். ஒவ்வொரு வீரரும் புத்திசாலித்தனமாக சிந்திக்க வேண்டும் மற்றும் மற்ற வீரரின் அடுத்த நகர்வை எதிர்நோக்க வேண்டும்.
உரை அடிப்படையிலான டிக்-டாக்-டோ விளையாட்டை வடிவமைப்பதற்கான குறியீடு பல்வேறு பிரிவுகளைக் கொண்டுள்ளது, செயல்பாட்டின் அடிப்படையில் பிரிக்கப்பட்டுள்ளது. முதல் பிரிவில், கணினியுடன் விளையாடுவதா அல்லது சக மனிதனுடன் விளையாடுவதா என்பதை பயனர் தீர்மானிக்கிறார். ஆதாய முறையைத் தீர்மானித்த பிறகு, நிரல் பயனரிடம் உள்ளீட்டைக் கேட்கிறது. இரண்டு வீரர்களும் ஒன்றன் பின் ஒன்றாக உள்ளீட்டை உள்ளிடுகின்றனர்.
//வீரர்களிடமிருந்து உள்ளீட்டைப் பெறுங்கள்
வெற்றிடமானது பிளேயர் உள்ளீடு ( ஆட்டக்காரர் & ஆட்டக்காரர் ) {
முழு எண்ணாக pos ;
கூட் << endl ;
கூட் << ' \t ' << ஆட்டக்காரர். பெற பெயர் ( ) << 'திருப்பு:' ;
கூட் << ' \t நிலையை உள்ளிடவும்' <> pos ;
pos - = 1 ;
என்றால் ( வெற்று அட்டவணை [ pos ] == 1 ) {
கூட் << '----நிலை காலியாக இல்லை -------' << endl ;
பிளேயர் உள்ளீடு ( ஆட்டக்காரர் ) ;
} வேறு {
வெற்று அட்டவணை [ pos ] = 1 ;
வெற்று எண்ணிக்கை - = 1 ;
ஆட்டக்காரர். பெற பெயர் ( ) . ஒப்பிடு ( 'வீரர் நான்' ) == 0 ? பலகை [ pos ] = 'எக்ஸ்' : பலகை [ pos ] = 'ஓ' ;
}
}
பயனரிடமிருந்து உள்ளீடுகளை எடுத்த பிறகு, அது வெற்றி விதியை சரிபார்க்கிறது. ஆட்டக்காரர் வெற்றி பெற்றாரா இல்லையா என்பதை சரிபார்க்க checkWin() செயல்பாட்டில் p1 மற்றும் p2 இரண்டு அளவுருக்கள் உள்ளன. வெவ்வேறு மாறிகள் i, j, மற்றும் k ஆகியவை லூப்பிற்காக அறிவிக்கப்பட்ட முழு எண் மாறிகள் மற்றும் வெற்றி நிலையை சரிபார்க்க ஒரு பூலியன் செயல்பாடு ஆகும். லூப் முதல் நிலையிலிருந்து தொடங்கி ஒன்பது நிலைகளுக்கும் திரும்பத் திரும்பச் செல்கிறது. முதல்_குறியீடு என்பது 0 அல்லது X ஆக இருக்கலாம், அது உண்மையாக இருந்தால், அது சாத்தியமான அனைத்து சேர்க்கைகளும் வெற்றிபெறும் விதிக்காக சரிபார்க்கப்படும். இல்லையெனில், இட்டேட்டர் அடுத்த நிலைக்கு நகர்கிறது, மேலும் சாத்தியமான அனைத்து நிலைகளும் சரிபார்க்கப்படும் வரை அது தொடர்ந்து செல்லும். கொடி உண்மையாக இருந்தால், வெற்றியாளர் அறிவிக்கப்படுவார், மேலும் நிரல் மீண்டும் தேர்வு செய்யும்படி கேட்கிறது.
வெற்றிடமானது சரிபார்க்கவும் ( ஆட்டக்காரர் & p1, பிளேயர் & ப2 ) {
முழு எண்ணாக i,j,k ;
பூல் கொடி = பொய் ;
கரி முதல்_சின்னம் ;
க்கான ( நான் = 0 ; நான் < 8 ; நான் ++ ) {
முதல்_சின்னம் = பலகை [ வெற்றி பட்டியல் [ நான் ] . வரிசை [ 0 ] ] ;
என்றால் ( ( முதல்_சின்னம் ! = 'எக்ஸ்' ) && ( முதல்_சின்னம் ! = 'ஓ' ) ) {
கொடி = பொய் ;
தொடரவும் ;
}
கொடி = உண்மை ;
க்கான ( ஜே = 0 ; ஜே < 3 ; ஜே ++ ) {
என்றால் ( முதல்_சின்னம் ! = பலகை [ வெற்றி பட்டியல் [ நான் ] . வரிசை [ ஜே ] ] ) {
கொடி = பொய் ;
உடைக்க ;
}
}
என்றால் ( கொடி ) {
தொடங்கியது விளையாட்டு = 0 ;
என்றால் ( முதல்_சின்னம் == 'எக்ஸ்' ) {
கூட் << '------------------------' << endl ;
கூட் << ' \t நான் வென்ற வீரர்' << endl ;
கூட் << '------------------------' << endl ;
ப1. வெற்றி பெற்றார் ( ) ;
} வேறு {
ப2. வெற்றி பெற்றார் ( ) ;
என்றால் ( கணினிக்கு எதிராக ) {
கூட் << '------------------------' << endl ;
கூட் << ' \t கணினி வென்றது' << endl ;
கூட் << '------------------------' << endl ;
} வேறு {
கூட் << '------------------------' << endl ;
கூட் << ' \t இரண்டாம் ஆட்டக்காரர் வென்றார்' << endl ;
கூட் << '------------------------' << endl ;
}
}
டிஸ்ப்ளே ஸ்கோர் ( p1,p2 ) ;
உடைக்க ;
}
குறியீட்டின் இந்த பகுதி விளையாட்டின் மதிப்பெண்ணைக் காட்டுகிறது. கேம் கணினிக்கு எதிராக இருந்தால், பிளேயர் 1 மற்றும் கணினிக்கான மதிப்பெண் காட்டப்படும், இல்லையெனில், பிளேயர் 1 மற்றும் பிளேயர் 2க்கான மதிப்பெண் காட்டப்படும்.
வெற்றிடமானது டிஸ்ப்ளே ஸ்கோர் ( ஆட்டக்காரர் & p1, பிளேயர் & ப2 ) {
கூட் << endl ;
கூட் << ' \t ஸ்கோர்: \t ' ;
என்றால் ( கணினிக்கு எதிராக )
கூட் << 'வீரர் I:' << ப1. பெறுமதி ( ) << ' \t கணினி: ' << ப2. பெறுமதி ( ) << endl ;
வேறு
கூட் << 'வீரர் I:' << ப1. பெறுமதி ( ) << ' \t பிளேயர் II: ' << ப2. பெறுமதி ( ) << endl ;
}
இரண்டு வீரர்களுக்கான டிக்-டாக்-டோ விளையாட்டை செயல்படுத்துவதற்கான முக்கிய குறியீடு இதுவாகும். ஸ்விட்ச் கேஸ் ஸ்டேட்மென்ட்டைப் பயன்படுத்தி மேற்கொள்ள வேண்டிய பல்வேறு நடைமுறைகளிலிருந்து பயனர் தேர்ந்தெடுக்கலாம். இந்த குறியீடு C++ கம்பைலரில் கேம் விளையாடுவதற்கு பயனர் நட்பு இடைமுகத்தை வழங்குகிறது, மேலும் பயனர் வெளியேறும் விருப்பத்தைத் தேர்ந்தெடுக்கும் வரை குறியீடு தொடர்ந்து இயங்கும்.
முழு எண்ணாக முக்கிய ( ){
முழு எண்ணாக ch ;
போது ( 1 ) {
கூட் << ' ----------பட்டியல்----------' << endl ;
கூட் << ' \t 1. 1 பிளேயர் கேம்' << endl ;
கூட் << ' \t 2. 2 பிளேயர் கேம்' << endl ;
கூட் << ' \t 3. வெளியேற ' << endl ;
கூட் << ' ----------' << endl ;
கூட் << endl ;
கூட் << ' \t ஒரு விருப்பத்தைத் தேர்ந்தெடு' <> ch ;
சொடுக்கி ( ch ) {
வழக்கு 1 : {
விளையாட்டு * விளையாட்டு = புதிய விளையாட்டு ;
விளையாட்டு - > வெப்பம் ( ) ;
விளையாட்டு - > onePlayerGame ( ) ;
}
உடைக்க ;
வழக்கு 2 : {
விளையாட்டு * விளையாட்டு = புதிய விளையாட்டு ;
விளையாட்டு - > வெப்பம் ( ) ;
விளையாட்டு - > இரண்டு பிளேயர் கேம் ( ) ;
}
உடைக்க ;
வழக்கு 3 :
திரும்ப 0 ;
இயல்புநிலை :
கூட் << 'OOPs தவறான விருப்பம்! மீண்டும் முயற்சிக்கவும்' ;
}
}
திரும்ப 0 ;
}
உரை அடிப்படையிலான டிக்-டாக்-டாக் கேமிற்கான முழுமையான குறியீடு
இது உரை அடிப்படையிலான டிக்-டாக்-டோ விளையாட்டின் வடிவமைப்பு மற்றும் செயல்பாட்டிற்கான முழுமையான குறியீடாகும்.
#
#அடங்கும்<பட்டியல்>
#
#அடங்கும்
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
typedef கட்டமைக்க {
முழு எண்ணாக * வரிசை ;
} வின்லிஸ்ட் ;
வர்க்கம் ஆட்டக்காரர் {
தனிப்பட்ட :
சரம் பெயர் ;
முழு எண்ணாக மதிப்பெண் ;
பொது :
ஆட்டக்காரர் ( ) : ஆட்டக்காரர் { '' } { }
ஆட்டக்காரர் ( சரம் n ) : மதிப்பெண் { 0 } , பெயர் { n } { }
வெற்றிடமானது வெற்றி பெற்றார் ( ) {
//மதிப்பீட்டை அதிகரிக்கவும்
மதிப்பெண் ++ ;
}
முழு எண்ணாக பெறுமதி ( ) { திரும்ப இது - > மதிப்பெண் ; }
சரம் getName ( ) { திரும்ப இது - > பெயர் ; }
} ;
வர்க்கம் விளையாட்டு {
தனிப்பட்ட :
கரி பலகை [ 9 ] ;
முழு எண்ணாக வெற்று அட்டவணை [ 9 ] ;
முழு எண்ணாக கேம் ஆன், கம்ப்யூட்டருக்கு எதிராக ;
முழு எண்ணாக வெற்று எண்ணிக்கை ;
வெற்றி பட்டியல் வெற்றி பட்டியல் [ 8 ] ;
வெற்றிடமானது காட்சி பலகை ( ) {
கூட் << endl ;
கூட் << ' | | ' << endl ;
கூட் << '' << பலகை [ 0 ] << ' | ' << பலகை [ 1 ] << ' | ' << பலகை [ 2 ] << endl ;
கூட் << ' | | ' << endl ;
கூட் << '------------' << endl ;
கூட் << ' | | ' << endl ;
கூட் << '' << பலகை [ 3 ] << ' | ' << பலகை [ 4 ] << ' | ' << பலகை [ 5 ] << endl ;
கூட் << ' | | ' << endl ;
கூட் << '------------' << endl ;
கூட் << ' | | ' << endl ;
கூட் << '' << பலகை [ 6 ] << ' | ' << பலகை [ 7 ] << ' | ' << பலகை [ 8 ] << endl ;
கூட் << ' | | ' << endl ;
கூட் << endl ;
}
வெற்றிடமானது கணினி உள்ளீடு ( ) {
முழு எண்ணாக pos ;
pos = ராண்ட் ( ) % 10 ;
என்றால் ( வெற்று அட்டவணை [ pos ] == 1 ) {
என்றால் ( வெற்று எண்ணிக்கை < 0 )
திரும்ப ;
கணினி உள்ளீடு ( ) ;
} வேறு {
கூட் << 'கணினி தேர்வு:' << pos + 1 << endl ;
வெற்று அட்டவணை [ pos ] = 1 ;
வெற்று எண்ணிக்கை - = 1 ;
பலகை [ pos ] = 'ஓ' ;
}
}
வெற்றிடமானது பிளேயர் உள்ளீடு ( ஆட்டக்காரர் & ஆட்டக்காரர் ) {
முழு எண்ணாக pos ;
கூட் << endl ;
கூட் << ' \t ' << ஆட்டக்காரர். பெற பெயர் ( ) << 'திருப்பு:' ;
கூட் << ' \t நிலையை உள்ளிடவும்' <> pos ;
pos - = 1 ;
என்றால் ( வெற்று அட்டவணை [ pos ] == 1 ) {
கூட் << '----நிலை காலியாக இல்லை -------' << endl ;
பிளேயர் உள்ளீடு ( ஆட்டக்காரர் ) ;
} வேறு {
வெற்று அட்டவணை [ pos ] = 1 ;
வெற்று எண்ணிக்கை - = 1 ;
ஆட்டக்காரர். பெற பெயர் ( ) . ஒப்பிடு ( 'வீரர் நான்' ) == 0 ? பலகை [ pos ] = 'எக்ஸ்' : பலகை [ pos ] = 'ஓ' ;
}
}
வெற்றிடமானது சரிபார்க்கவும் ( ஆட்டக்காரர் & p1, பிளேயர் & ப2 ) {
முழு எண்ணாக i,j,k ;
பூல் கொடி = பொய் ;
கரி முதல்_சின்னம் ;
க்கான ( நான் = 0 ; நான் < 8 ; நான் ++ ) {
முதல்_சின்னம் = பலகை [ வெற்றி பட்டியல் [ நான் ] . வரிசை [ 0 ] ] ;
என்றால் ( ( முதல்_சின்னம் ! = 'எக்ஸ்' ) && ( முதல்_சின்னம் ! = 'ஓ' ) ) {
கொடி = பொய் ;
தொடரவும் ;
}
கொடி = உண்மை ;
க்கான ( ஜே = 0 ; ஜே < 3 ; ஜே ++ ) {
என்றால் ( முதல்_சின்னம் ! = பலகை [ வெற்றி பட்டியல் [ நான் ] . வரிசை [ ஜே ] ] ) {
கொடி = பொய் ;
உடைக்க ;
}
}
என்றால் ( கொடி ) {
தொடங்கியது விளையாட்டு = 0 ;
என்றால் ( முதல்_சின்னம் == 'எக்ஸ்' ) {
கூட் << '------------------------' << endl ;
கூட் << ' \t நான் வென்ற வீரர்' << endl ;
கூட் << '------------------------' << endl ;
ப1. வெற்றி பெற்றார் ( ) ;
} வேறு {
ப2. வெற்றி பெற்றார் ( ) ;
என்றால் ( கணினிக்கு எதிராக ) {
கூட் << '------------------------' << endl ;
கூட் << ' \t கணினி வென்றது' << endl ;
கூட் << '------------------------' << endl ;
} வேறு {
கூட் << '------------------------' << endl ;
கூட் << ' \t இரண்டாம் ஆட்டக்காரர் வென்றார்' << endl ;
கூட் << '------------------------' < 0 ) && ( தொடங்கியது விளையாட்டு ! = 0 ) ) {
என்றால் ( கணினிக்கு எதிராக )
கை == 1 ? கணினி உள்ளீடு ( ) : பிளேயர் உள்ளீடு ( ப2 ) ;
வேறு
கை == 1 ? பிளேயர் உள்ளீடு ( ப1 ) : பிளேயர் உள்ளீடு ( ப2 ) ;
கை = ! கை ;
காட்சி பலகை ( ) ;
சரிபார்க்கவும் ( p1,p2 ) ;
}
என்றால் ( வெற்று எண்ணிக்கை <= 0 ) {
கூட் << ' ------------------------' << endl ;
கூட் << ' \t வெற்றியாளர் இல்லை' << endl ;
கூட் << ' ------------------------' << endl ;
}
கூட் << endl ;
கூட் <> மறுபோட்டி ;
என்றால் ( ( மறுபோட்டி == 'மற்றும்' ) || ( மறுபோட்டி == 'மற்றும்' ) ) {
வெப்பம் ( ) ;
விளையாடு ( p1,p2 ) ;
}
}
வெற்றிடமானது டிஸ்ப்ளே ஸ்கோர் ( ஆட்டக்காரர் & p1, பிளேயர் & ப2 ) {
கூட் << endl ;
கூட் << ' \t ஸ்கோர்: \t ' ;
என்றால் ( கணினிக்கு எதிராக )
கூட் << 'வீரர் I:' << ப1. பெறுமதி ( ) << ' \t கணினி: ' << ப2. பெறுமதி ( ) << endl ;
வேறு
கூட் << 'வீரர் I:' << ப1. பெறுமதி ( ) << ' \t பிளேயர் II: ' << ப2. பெறுமதி ( ) << endl ;
}
பொது :
விளையாட்டு ( ) : வெற்று எண்ணிக்கை { 0 } , தொடங்கியது விளையாட்டு { 1 } , கணினிக்கு எதிராக { 0 } {
வெப்பம் ( ) ;
வெற்றி பட்டியல் [ 0 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 0 , 1 , 2 } ;
வெற்றி பட்டியல் [ 1 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 3 , 4 , 5 } ;
வெற்றி பட்டியல் [ 2 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 6 , 7 , 8 } ;
வெற்றி பட்டியல் [ 3 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 0 , 3 , 6 } ;
வெற்றி பட்டியல் [ 4 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 1 , 4 , 7 } ;
வெற்றி பட்டியல் [ 5 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 2 , 5 , 8 } ;
வெற்றி பட்டியல் [ 6 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 0 , 4 , 8 } ;
வெற்றி பட்டியல் [ 7 ] . வரிசை = புதிய முழு எண்ணாக [ 3 ] { 2 , 4 , 6 } ;
}
வெற்றிடமானது வெப்பம் ( ) {
தொடங்கியது விளையாட்டு = 1 ;
வெற்று எண்ணிக்கை = 0 ;
srand ( நேரம் ( 0 ) ) ;
க்கான ( அளவு_டி நான் = 0 ; நான் < 10 ; நான் ++ ) {
வெற்று அட்டவணை [ நான் ] = 0 ;
பலகை [ நான் ] = ( நான் + 1 ) + '0' ;
வெற்று எண்ணிக்கை ++ ;
}
வெற்று எண்ணிக்கை -- ;
}
வெற்றிடமானது onePlayerGame ( ) {
//பிளேயரை உருவாக்குதல்
வீரர் ப ( 'வீரர் நான்' ) ;
வீரர் சி ( 'கணினி' ) ;
கூட் << ' ------------------------' << endl ;
கூட் << ' \t வீரர் I: X \t கணினி: ஓ' << endl ;
கூட் << ' ------------------------' << endl ;
கூட் << endl ;
கணினிக்கு எதிராக = 1 ;
விளையாடு ( c,p ) ;
}
வெற்றிடமானது இரண்டு பிளேயர் கேம் ( ) {
//பிளேயரை உருவாக்குதல்
வீரர் ப ( 'வீரர் நான்' ) ;
வீரர் சி ( 'பிளேயர் II' ) ;
கூட் << ' ------------------------' << endl ;
கூட் << ' \t வீரர் I: X \t வீரர் II: ஓ' << endl ;
கூட் << ' ------------------------' << endl ;
கூட் << endl ;
கணினிக்கு எதிராக = 0 ;
விளையாடு ( c,p ) ;
}
} ;
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக ch ;
போது ( 1 ) {
கூட் << ' ----------பட்டியல்----------' << endl ;
கூட் << ' \t 1. 1 பிளேயர் கேம்' << endl ;
கூட் << ' \t 2. 2 பிளேயர் கேம்' << endl ;
கூட் << ' \t 3. வெளியேற ' << endl ;
கூட் << ' ----------' << endl ;
கூட் << endl ;
கூட் << ' \t ஒரு விருப்பத்தைத் தேர்ந்தெடு' <> ch ;
சொடுக்கி ( ch ) {
வழக்கு 1 : {
விளையாட்டு * விளையாட்டு = புதிய விளையாட்டு ;
விளையாட்டு - > வெப்பம் ( ) ;
விளையாட்டு - > onePlayerGame ( ) ;
}
உடைக்க ;
வழக்கு 2 : {
விளையாட்டு * விளையாட்டு = புதிய விளையாட்டு ;
விளையாட்டு - > வெப்பம் ( ) ;
விளையாட்டு - > இரண்டு பிளேயர் கேம் ( ) ;
}
உடைக்க ;
வழக்கு 3 :
திரும்ப 0 ;
இயல்புநிலை :
கூட் << 'OOPs தவறான விருப்பம்! மீண்டும் முயற்சிக்கவும்' ;
}
}
திரும்ப 0 ;
}
இது டிக்-டாக்-டோ விளையாட்டின் செயல்பாட்டிற்கான முழுமையான குறியீடாகும், இது ஒரு கணினி அல்லது சக மனிதருடன் இரண்டு முறைகளில் விளையாடப்படலாம். இது சாத்தியமான அனைத்து கட்டளைகளையும் உள்ளடக்கிய பல்துறை குறியீடு. ஏற்கனவே நிரப்பப்பட்ட நிலையை பயனர் உள்ளீடு செய்யும் போது, அது இந்த நிலையை மேலெழுதவில்லை மேலும் இந்த நடவடிக்கை தவறானது எனக் கருதுகிறது.
இதுவரை, வீரர் ஒருவர் முதல் பெட்டியைத் தேர்ந்தெடுத்து, அடுத்த திருப்பத்தில் கணினி ஆறாவது பெட்டியைக் குறித்தது:
இரண்டு வீரர்களும் இதுவரை இரண்டு பெட்டிகளைத் தேர்ந்தெடுத்துள்ளனர், அடுத்த திருப்பத்தில் நான் ஏழாவது பெட்டியைத் தேர்வு செய்கிறேன், இதன் விளைவாக தொடர்ச்சியான செங்குத்து வடிவத்தை உருவாக்குகிறது:
பயனர் ஒரு விளையாட்டை விளையாட கணினியைப் பயன்படுத்தத் தேர்வு செய்கிறார், எனவே மூன்று நகர்வுகளை எடுத்த பிறகு, பயனர் கணினியிலிருந்து வெற்றி பெற்றார் மற்றும் பிளேயர் 1 இன் பதிவில் ஒரு மதிப்பெண் சேர்க்கப்படும். முதல் போட்டி முடிந்ததும், கம்பைலர் மீண்டும் போட்டியைக் கேட்கிறார். பயனர் விருப்பங்களிலிருந்து முடிவு செய்கிறார் மற்றும் நிரல் பிரதான பகுதிக்குத் திரும்பும். மூன்று விருப்பத்தைத் தேர்ந்தெடுத்த பிறகு, கம்பைலர் குறியீட்டை செயல்படுத்துகிறது.
முடிவுரை
உரை அடிப்படையிலான கேம்கள் பிளேயருடன் தொடர்புகொள்வதற்காக உரை எழுத்துக்கள் மற்றும் கட்டளை வரி இடைமுகத்தை நம்பியுள்ளன. அவர்களிடம் வரைகலை படங்கள், ஒலிகள் அல்லது அனிமேஷன்கள் இல்லை. பயனர் கன்சோல் சாளரத்தின் மூலம் கட்டளையை உள்ளிடுகிறார். பயனர் நட்பு உரை அடிப்படையிலான டிக்-டாக்-டோ கேம் C++ ஐப் பயன்படுத்தி உருவாக்கப்பட்டுள்ளது. கணினி அல்லது மற்றொரு சக வீரருடன் விளையாடக்கூடிய விளையாட்டை உருவாக்க இது வெவ்வேறு கட்டளைகளைப் பயன்படுத்துகிறது.