C++ में एक टिक-टैक-टो गेम बनाएं
निम्नलिखित उदाहरण इस इंटरैक्टिव दो-खिलाड़ियों वाले टिक-टैक-टो गेम को बनाने की मूल बातें प्रदान करता है। यह C++ के साथ प्रोग्रामिंग करने के लिए एक सरल और आसान तरीका दिखाता है और एक नए, डिजिटल प्रारूप में दोस्तों के साथ बचपन की चुनौतियों को फिर से जीने के लिए एक अच्छी तरह से प्रलेखित स्रोत कोड प्रदान करता है। आइए निम्नलिखित कोड देखें।
उदाहरण: 2डी ऐरे का उपयोग किए बिना बेसिक कंसोल-आधारित टिक-टैक-टो
इस उदाहरण में, हम C++ में टिक-टैक-टो गेम बनाने के लिए 2डी ऐरे, फ़ंक्शंस और यदि-अन्यथा स्थितियों का उपयोग करेंगे। इस खेल में, दो खिलाड़ियों को बारी-बारी से अपनी चालें डालने की अनुमति होती है, और यह विजेता या टाई की जाँच करके खेल की स्थिति निर्धारित करता है। निम्नलिखित दिए गए कोड को देखें:
#शामिल करें
नेमस्पेस एसटीडी का उपयोग करना ;
खालीपन ड्राबोर्ड ( चार तख़्ता [ 3 ] [ 3 ] ) ;
बूल isMoveValid है ( चार तख़्ता [ 3 ] [ 3 ] , int यहाँ पंक्ति , int यहाँ कर्नल ) ;
बूल बोर्डफुल है ( चार तख़्ता [ 3 ] [ 3 ] ) ;
चार चेकविजेता ( चार तख़्ता [ 3 ] [ 3 ] ) ;
int यहाँ मुख्य ( ) {
चार तख़्ता [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
int यहाँ पंक्ति , कर्नल ;
चार वर्तमान खिलाड़ी = 'एक्स' ;
जबकि ( सत्य ) {
ड्राबोर्ड ( तख़्ता ) ;
अदालत << 'खिलाड़ी' << वर्तमान खिलाड़ी << 'की बारी। पंक्ति (1-3) और कॉलम (1-3) दर्ज करें: ' ;
खाना >> पंक्ति >> कर्नल ;
पंक्ति --;
कर्नल --;
अगर ( isMoveValid ( तख़्ता , पंक्ति , कर्नल ) ) {
तख़्ता [ पंक्ति ] [ कर्नल ] = वर्तमान खिलाड़ी ;
चार विजेता = चेकविजेता ( तख़्ता ) ;
अगर ( विजेता != '' ) {
ड्राबोर्ड ( तख़्ता ) ;
अदालत << 'खिलाड़ी' << विजेता << 'विजेता है! \एन ' ;
तोड़ना ;
}
अगर ( isBoardFull ( तख़्ता ) ) {
ड्राबोर्ड ( तख़्ता ) ;
अदालत << 'यह एक टाई है! \एन ' ;
तोड़ना ;
}
वर्तमान खिलाड़ी = ( वर्तमान खिलाड़ी == 'एक्स' ) ? 'ओ' : 'एक्स' ;
} अन्य {
अदालत << 'अमान्य चाल। अन्य सेल चुनें। \एन ' ;
} }
वापस करना 0 ;
}
खालीपन ड्राबोर्ड ( चार तख़्ता [ 3 ] [ 3 ] ) {
अदालत << 'बी| \टी 1 \टी | \टी 2 \टी | \टी 3 \टी | \एन ' ;
अदालत << ' ______________________ \एन ' ;
के लिए ( int यहाँ एम = 0 ; एम < 3 ; एम ++ ) {
अदालत << एम + 1 << '|' ;
के लिए ( int यहाँ टी = 0 ; टी < 3 ; टी ++ ) {
अदालत << '' << तख़्ता [ एम ] [ टी ] ;
अगर ( टी < 2 ) अदालत << ' \टी | \टी ' ;
}
अदालत << ' \टी | \एन ' ;
अगर ( एम < 2 ) अदालत << ' ______________________ \एन ' ;
}
अदालत << ' \एन ' ; }
बूल isMoveValid है ( चार तख़्ता [ 3 ] [ 3 ] , int यहाँ पंक्ति , int यहाँ कर्नल ) {
वापस करना ( पंक्ति >= 0 && पंक्ति < 3 && कर्नल >= 0 && कर्नल < 3 && तख़्ता [ पंक्ति ] [ कर्नल ] == '' ) ;
}
बूल बोर्डफुल है ( चार तख़्ता [ 3 ] [ 3 ] ) {
के लिए ( int यहाँ एम = 0 ; एम < 3 ; एम ++ ) {
के लिए ( int यहाँ टी = 0 ; टी < 3 ; टी ++ ) {
अगर ( तख़्ता [ एम ] [ टी ] == '' ) {
वापस करना असत्य ;
} } }
वापस करना सत्य ; }
चार चेकविजेता ( चार तख़्ता [ 3 ] [ 3 ] ) {
के लिए ( int यहाँ एम = 0 ; एम < 3 ; एम ++ ) {
अगर ( तख़्ता [ एम ] [ 0 ] == तख़्ता [ एम ] [ 1 ] && तख़्ता [ एम ] [ 1 ] == तख़्ता [ एम ] [ 2 ] && तख़्ता [ एम ] [ 0 ] != '' ) {
वापस करना तख़्ता [ एम ] [ 0 ] ;
}
अगर ( तख़्ता [ 0 ] [ एम ] == तख़्ता [ 1 ] [ एम ] && तख़्ता [ 1 ] [ एम ] == तख़्ता [ 2 ] [ एम ] && तख़्ता [ 0 ] [ एम ] != '' ) {
वापस करना तख़्ता [ 0 ] [ एम ] ;
} }
अगर ( तख़्ता [ 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
इस प्रोग्राम में चार फ़ंक्शन प्रोटोटाइप हैं - वे हैं ड्रॉबोर्ड(), isMoveValid(), isBoardFull(), और checkWinner()। फ़ंक्शन घोषणा को फ़ंक्शन प्रोटोटाइप के रूप में जाना जाता है। हालाँकि यह प्रोग्राम में मुख्य कार्य के बाद आता है, इसका उपयोग किया जाएगा। मुख्य फ़ंक्शन में खिलाड़ियों के मोड़ और चाल को प्रबंधित करने के लिए गेम लूप और तर्क शामिल हैं। मुख्य फ़ंक्शन के भीतर, गेम बोर्ड को रिक्त स्थान के साथ प्रारंभ किया गया है।
चार तख़्ता [ 3 ] [ 3 ] = { { '' , '' , '' } , { '' , '' , '' } , { '' , '' , '' } } ;
इसके बाद, खिलाड़ी के चाल इनपुट को संग्रहीत करने के लिए दो पंक्ति और कॉलम चर परिभाषित किए जाते हैं। 'चार करंटप्लेयर = 'एक्स';' परिभाषित करता है कि 'X' खिलाड़ी पहले जाता है।
अब, जबकि (सही) गेम लूप शुरू होता है, और यह तब तक चलता है जब तक कोई विजेता या टाई न हो जाए। यह 'जबकि' लूप 'ड्रॉबोर्ड ();' को कॉल करता है बोर्ड प्रदर्शित करने के लिए. कंसोल पर बोर्ड प्रदर्शित करने के बाद, उपयोगकर्ता को निम्नलिखित कोड स्टेटमेंट में चिह्नित करने के लिए एक सेल चुनने के लिए कहा जाता है:
अदालत << 'खिलाड़ी' << वर्तमान खिलाड़ी << 'की बारी। पंक्ति और स्तंभ दर्ज करें (1-3): ' ;
खिलाड़ी अपनी चाल को 'cin >> row >> col;' में इनपुट करता है।
मार्किंग के लिए एक सेल का चयन करने पर, प्रोग्राम पहले इनपुट की वैधता को सत्यापित करेगा, यह सुनिश्चित करते हुए कि सेल पहले से ही isMoveValid() फ़ंक्शन को कॉल करके भरा हुआ नहीं है।
तख़्ता [ पंक्ति ] [ कर्नल ] = वर्तमान खिलाड़ी ;यह कथन खिलाड़ी का चिह्न बोर्ड पर रखता है।
चार विजेता = चेकविजेता ( तख़्ता ) ;अगर ( विजेता != '' ) {
ड्राबोर्ड ( तख़्ता ) ;
अदालत << 'खिलाड़ी' << विजेता << ' जीतता है! \एन ' ;
जब भी कोई खिलाड़ी बोर्ड पर प्रविष्टि अंकित करता है तो ये विवरण विजेता की जाँच करते हैं। यदि कोई विजेता है तो उसके नाम की घोषणा की जाएगी और प्रोग्राम गेम लूप से बाहर हो जाएगा।
अगर ( isBoardFull ( तख़्ता ) ) {यह कथन टाई की जाँच करता है। टाई की स्थिति उस स्थिति में होती है जब बोर्ड भरा हुआ हो और कोई विजेता न हो। इस मामले में, 'यह एक टाई है!' स्क्रीन पर मुद्रित होता है.
वर्तमान खिलाड़ी = ( वर्तमान खिलाड़ी == 'एक्स' ) ? 'ओ' : 'एक्स' ;यह कथन प्रत्येक खिलाड़ी को अपनी बारी खेलने का मौका देने के लिए खिलाड़ियों को बदल देता है।
अदालत << 'अमान्य चाल। अन्य सेल चुनें। \एन ' ;यदि चाल वैध नहीं है, तो उपयोगकर्ता को दोबारा इनपुट करने और कोई अन्य सेल चुनने के लिए कहा जाता है।
'मुख्य' फ़ंक्शन के बाद, पहले से घोषित फ़ंक्शन प्रोटोटाइप के लिए फ़ंक्शन परिभाषाएँ शुरू हो जाएंगी। यहां परिभाषित पहला फ़ंक्शन ड्रॉबोर्ड() है जिसका उपयोग टिक-टैक-टो बोर्ड को कंसोल पर खींचने के लिए किया जाता है। ड्रॉबोर्ड() फ़ंक्शन ग्रिड लाइनों सहित बोर्ड की वर्तमान स्थिति को प्रिंट करता है।
यहां परिभाषित अगला फ़ंक्शन isMoveValid() है। इस फ़ंक्शन का उपयोग यह निर्धारित करने के लिए किया जाता है कि बोर्ड के अंदर और खाली सेल दोनों पर किसी चाल की अनुमति है या नहीं। isBoardFull() फ़ंक्शन का उपयोग यह जांचने के लिए किया जाता है कि बोर्ड अभी तक भरा है या नहीं। यह बराबरी की स्थिति के लिए एक शर्त है जब कोई विजेता नहीं होता है। IsBoardFull() जाँच करता है कि बोर्ड पर सभी पद भरे हुए हैं या नहीं, जो कि कोई विजेता नहीं होने पर टाई होने का संकेत देता है। यदि कोई विजेता है, तो उसे checkWinner() फ़ंक्शन का उपयोग करके पता लगाया जा सकता है। चेकविनर() एक ही खिलाड़ी के चिह्न ('एक्स' या 'ओ') के लिए सभी संभावित विजेता पंक्तियों की जांच करता है और यदि कोई विजेता नहीं है तो विजेता खिलाड़ी का चिह्न या एक स्पेस कैरेक्टर ' ' लौटाता है। निम्नलिखित प्रोग्राम का आउटपुट है। यह प्रत्येक खिलाड़ी के प्रत्येक मोड़ को दर्शाता है।
सबसे पहले, बोर्ड स्पष्ट है; खिलाड़ी 'X' को चिह्नित किए जाने वाले सेल को चुनने के लिए प्रेरित किया जाता है। यहां, खिलाड़ी 'X' 2 और 2 में प्रवेश करता है। पंक्ति 2 और कॉलम 2 की कोशिकाओं को चिह्नित किया गया है। निम्नलिखित में चिह्नित बोर्ड देखें:
अब, खिलाड़ी O की बारी है। खिलाड़ी को चिह्नित किए जाने वाले सेल को चुनने के लिए प्रेरित किया जाता है। खिलाड़ी 'O' पंक्ति के लिए 1 और कॉलम के लिए 1 चुनता है। चयनित सेल को प्लेयर 'O' के लिए चिह्नित किया गया है जैसा कि निम्नलिखित आउटपुट स्निपेट में दिखाया गया है:
प्रत्येक खिलाड़ी के लिए सभी मोड़ एक ही पैटर्न का पालन करेंगे। अब खिलाड़ी X की बारी है, और खिलाड़ी पंक्ति के लिए 1 और कॉलम के लिए 2 चुनता है। निम्नलिखित दिए गए आउटपुट स्नैपशॉट देखें:
अब, बारी खिलाड़ी 'O' की है। खिलाड़ी पंक्ति के लिए 1 और कॉलम के लिए 3 चुनता है।
अगली बारी फिर से खिलाड़ी 'X' पर है। खिलाड़ी पंक्ति के लिए 3 और स्तंभ के लिए 1 चुनता है।
खिलाड़ी 'O' पंक्ति के लिए 3 और कॉलम के लिए 2 चुनता है।
प्लेयर 'X' दूसरी पंक्ति और तीसरे कॉलम का चयन करता है।
प्लेयर 'O' अब दूसरी पंक्ति और पहले कॉलम का चयन करता है।
खिलाड़ी 'X' इस बार तीसरी पंक्ति और तीसरा कॉलम चुनता है।
कोई भी खिलाड़ी क्षैतिज, लंबवत या विकर्ण रूप से कोई रेखा नहीं बना सकता है, इसलिए यह एक टाई है। इनपुट की चुनी गई श्रृंखला के लिए कोई विजेता नहीं है।
कुल मिलाकर, कोड में एक मुख्य गेम लूप शामिल होता है जो गेम की स्थिति और उपयोगकर्ता इनपुट को संभालने के लिए जिम्मेदार होता है, साथ ही कई उपयोगिता फ़ंक्शन भी होते हैं जिनका उपयोग बोर्ड को खींचने, चालों को सत्यापित करने, पूर्ण बोर्ड की जांच करने और यह निर्धारित करने के लिए किया जाता है कि कोई विजेता है या नहीं। .
निष्कर्ष
C++ का उपयोग करके टिक-टैक-टो गेम विकसित करना आपके प्रोग्रामिंग कौशल को सुदृढ़ करने के लिए एक उत्कृष्ट व्यावहारिक अभ्यास है। आलेख सटीक रूप से बताता है कि C++ में टिक-टैक-टो कैसे बनाया जाए। इस आलेख में प्रदान किए गए चरण-दर-चरण मार्गदर्शन में पाठकों के लिए गेम मैकेनिक्स, उपयोगकर्ता इंटरैक्शन और कुशल कोड संरचना को समझने के लिए 2डी सरणी, फ़ंक्शंस और यदि-अन्यथा स्थितियाँ शामिल हैं। कोड का विस्तृत विवरण और मुख्य गेमप्ले के लिए महत्वपूर्ण कार्यों की व्याख्या पाठकों को C++ प्रोग्रामिंग प्रथाओं और एक सरल गेम विकास की जटिलताओं दोनों में अमूल्य अंतर्दृष्टि प्रदान करती है।