C++ में बेसिक टेक्स्ट-आधारित गेम कैसे बनाएं
C++ में टेक्स्ट-आधारित गेम खिलाड़ी को कंसोल विंडो के माध्यम से कमांड इनपुट करने की अनुमति देते हैं, और प्रोग्राम खिलाड़ी की चाल को संसाधित करता है। यहां, मैंने एक टेक्स्ट-आधारित टिक-टैक-टो गेम बनाया है जो उपयोगकर्ता को खेलने के लिए दो विकल्प देता है। उपयोगकर्ता या तो C++ कंपाइलर के साथ या किसी साथी इंसान के साथ खेल सकता है। इस गेम में एक फीचर है जो जीतने वाले खिलाड़ी का स्कोर जोड़ता रहता है। पहले गेम का परिणाम घोषित होने के बाद, दोबारा मैच का विकल्प उपलब्ध है।
गेम जीतने के नियम
दो खिलाड़ी टिक-टैक-टो गेम खेलते हैं, जिसमें तीन-बाई-तीन ग्रिड पर नौ उपलब्ध स्थानों में से एक में वैकल्पिक रूप से एक्स और 0 रखते हैं। खेल ऊर्ध्वाधर, क्षैतिज या विकर्ण दिशा में अपने लगातार तीन अंक प्राप्त करने वाले पहले खिलाड़ी द्वारा जीता जाता है। प्रत्येक खिलाड़ी को चतुराई से सोचना होगा और दूसरे खिलाड़ी की अगली चाल का इंतजार करना होगा।
टेक्स्ट-आधारित टिक-टैक-टो गेम को डिज़ाइन करने के लिए कोड में अलग-अलग अनुभाग होते हैं, जो कार्यक्षमता के आधार पर विभाजित होते हैं। पहले खंड में, उपयोगकर्ता निर्णय लेता है कि उसे कंप्यूटर के साथ खेलना है या किसी साथी इंसान के साथ। लाभ का तरीका तय करने के बाद, प्रोग्राम उपयोगकर्ता से इनपुट मांगता है। दोनों खिलाड़ी एक के बाद एक इनपुट दर्ज करते हैं।
//खिलाड़ियों से इनपुट लें
खालीपन प्लेयरइनपुट ( खिलाड़ी & खिलाड़ी ) {
int यहाँ पीओ ;
अदालत << अंतः ;
अदालत << ' \टी ' << खिलाड़ी. नाम प्राप्त करें ( ) << ' मोड़: ' ;
अदालत << ' \टी स्थिति दर्ज करें ' <> पीओ ;
पीओ - = 1 ;
अगर ( खालीसूचकांक [ पीओ ] == 1 ) {
अदालत << '-----पद रिक्त नहीं-------' << अंतः ;
प्लेयरइनपुट ( खिलाड़ी ) ;
} अन्य {
खालीसूचकांक [ पीओ ] = 1 ;
खाली गिनती - = 1 ;
खिलाड़ी. नाम प्राप्त करें ( ) . तुलना करना ( 'खिलाड़ी मैं' ) == 0 ? तख़्ता [ पीओ ] = 'एक्स' : तख़्ता [ पीओ ] = 'ओ' ;
}
}
उपयोगकर्ता से इनपुट लेने के बाद, यह जीत नियम की जांच करता है। चेकविन () फ़ंक्शन में यह जांचने के लिए दो पैरामीटर पी 1 और पी 2 हैं कि खिलाड़ी जीता है या नहीं। फ़ंक्शन में अलग-अलग वेरिएबल घोषित किए गए हैं i, j, और k लूप के लिए घोषित पूर्णांक वैरिएबल हैं और जीत की स्थिति की जांच करने के लिए ध्वज एक बूलियन फ़ंक्शन है। लूप पहली स्थिति से शुरू होता है और सभी नौ स्थितियों के लिए पुनरावृत्त होता रहता है। पहला_प्रतीक एक ऐसा वर्ण है जो 0 या X हो सकता है यदि यह सत्य है तो जीतने वाले नियम के लिए इसके सभी संभावित संयोजनों की जाँच की जाती है। अन्यथा, पुनरावर्तक अगली स्थिति में चला जाता है, और यह तब तक चलता रहता है जब तक कि सभी संभावित स्थितियों की जाँच नहीं हो जाती। यदि ध्वज सत्य पर सेट है, तो विजेता घोषित किया जाता है, और प्रोग्राम फिर से चुनाव करने के लिए कहता है।
खालीपन चेकविन ( खिलाड़ी & पी1, प्लेयर & पी2 ) {
int यहाँ मैं, जे, के ;
बूल झंडा = असत्य ;
चार पहला_चिह्न ;
के लिए ( मैं = 0 ; मैं < 8 ; मैं ++ ) {
पहला_चिह्न = तख़्ता [ विजेता सूची [ मैं ] . पंक्ति [ 0 ] ] ;
अगर ( ( पहला_चिह्न ! = 'एक्स' ) && ( पहला_चिह्न ! = 'ओ' ) ) {
झंडा = असत्य ;
जारी रखना ;
}
झंडा = सत्य ;
के लिए ( जे = 0 ; जे < 3 ; जे ++ ) {
अगर ( पहला_चिह्न ! = तख़्ता [ विजेता सूची [ मैं ] . पंक्ति [ जे ] ] ) {
झंडा = असत्य ;
तोड़ना ;
}
}
अगर ( झंडा ) {
खेल शुरू = 0 ;
अगर ( पहला_चिह्न == 'एक्स' ) {
अदालत << '----------------------' << अंतः ;
अदालत << ' \टी खिलाड़ी मैं जीत गया' << अंतः ;
अदालत << '----------------------' << अंतः ;
पी1. जीत गया ( ) ;
} अन्य {
पी2. जीत गया ( ) ;
अगर ( कंप्यूटर के विरुद्ध ) {
अदालत << '----------------------' << अंतः ;
अदालत << ' \टी कंप्यूटर जीत गया' << अंतः ;
अदालत << '----------------------' << अंतः ;
} अन्य {
अदालत << '----------------------' << अंतः ;
अदालत << ' \टी खिलाड़ी द्वितीय जीता' << अंतः ;
अदालत << '----------------------' << अंतः ;
}
}
डिस्प्लेस्कोर ( पी1,पी2 ) ;
तोड़ना ;
}
कोड का यह भाग गेम का स्कोर दिखाता है। यदि खेल कंप्यूटर के विरुद्ध है, तो खिलाड़ी 1 और कंप्यूटर का स्कोर प्रदर्शित होता है, अन्यथा, खिलाड़ी 1 और खिलाड़ी 2 का स्कोर प्रदर्शित होता है।
खालीपन डिस्प्लेस्कोर ( खिलाड़ी & पी1, प्लेयर & पी2 ) {
अदालत << अंतः ;
अदालत << ' \टी अंक: \टी ' ;
अगर ( कंप्यूटर के विरुद्ध )
अदालत << 'खिलाड़ी मैं:' << पी1. स्कोर प्राप्त करें ( ) << ' \टी कंप्यूटर: ' << पी2. स्कोर प्राप्त करें ( ) << अंतः ;
अन्य
अदालत << 'खिलाड़ी मैं:' << पी1. स्कोर प्राप्त करें ( ) << ' \टी खिलाड़ी द्वितीय: ' << पी2. स्कोर प्राप्त करें ( ) << अंतः ;
}
यह दो खिलाड़ियों के लिए टिक-टैक-टो गेम के निष्पादन के लिए मुख्य कोड है। उपयोगकर्ता स्विच केस स्टेटमेंट का उपयोग करके की जाने वाली विभिन्न प्रक्रियाओं में से चयन कर सकता है। यह कोड C++ कंपाइलर पर गेम खेलने के लिए एक उपयोगकर्ता-अनुकूल इंटरफ़ेस प्रदान करता है, और जब तक उपयोगकर्ता निकास विकल्प का चयन नहीं करता तब तक कोड निष्पादित होता रहता है।
int यहाँ मुख्य ( ){
int यहाँ चौधरी ;
जबकि ( 1 ) {
अदालत << ' ----------मेन्यू----------' << अंतः ;
अदालत << ' \टी 1. 1 खिलाड़ी खेल' << अंतः ;
अदालत << ' \टी 2. 2 खिलाड़ियों वाला गेम' << अंतः ;
अदालत << ' \टी 3. बाहर निकलने के लिए ' << अंतः ;
अदालत << ' --------' << अंतः ;
अदालत << अंतः ;
अदालत << ' \टी कोई विकल्प चुनें' <> चौधरी ;
बदलना ( चौधरी ) {
मामला 1 : {
खेल * खेल = नया खेल ;
खेल - > गर्मी ( ) ;
खेल - > onePlayerGame ( ) ;
}
तोड़ना ;
मामला 2 : {
खेल * खेल = नया खेल ;
खेल - > गर्मी ( ) ;
खेल - > दो खिलाड़ी खेल ( ) ;
}
तोड़ना ;
मामला 3 :
वापस करना 0 ;
गलती करना :
अदालत << 'उफ़ अमान्य विकल्प! पुनः प्रयास करें' ;
}
}
वापस करना 0 ;
}
टेक्स्ट-आधारित टिक-टैक-टोक गेम के लिए पूरा कोड
यह टेक्स्ट-आधारित टिक-टैक-टो गेम के डिज़ाइन और निष्पादन के लिए एक संपूर्ण कोड है।
#शामिल करें
#शामिल<सूची>
#शामिल करें
#शामिल<स्ट्रिंग>
#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
टाइपडेफ़ struct {
int यहाँ * पंक्ति ;
} विनलिस्ट ;
कक्षा खिलाड़ी {
निजी :
स्ट्रिंग नाम ;
int यहाँ अंक ;
जनता :
खिलाड़ी ( ) : खिलाड़ी { '' } { }
खिलाड़ी ( स्ट्रिंग एन ) : अंक { 0 } , नाम { एन } { }
खालीपन जीत गया ( ) {
//स्कोर बढ़ाएँ
अंक ++ ;
}
int यहाँ स्कोर प्राप्त करें ( ) { वापस करना यह - > अंक ; }
स्ट्रिंग getName ( ) { वापस करना यह - > नाम ; }
} ;
कक्षा खेल {
निजी :
चार तख़्ता [ 9 ] ;
int यहाँ खालीसूचकांक [ 9 ] ;
int यहाँ गेमऑन, विरुद्धकंप्यूटर ;
int यहाँ खाली गिनती ;
विनलिस्ट विनलिस्ट [ 8 ] ;
खालीपन प्रदर्शन बोर्ड ( ) {
अदालत << अंतः ;
अदालत << ' | · | · ' << अंतः ;
अदालत << ' ' << तख़्ता [ 0 ] << ' | ' << तख़्ता [ 1 ] << ' | ' << तख़्ता [ 2 ] << अंतः ;
अदालत << ' | · | · ' << अंतः ;
अदालत << '-------' << अंतः ;
अदालत << ' | · | · ' << अंतः ;
अदालत << ' ' << तख़्ता [ 3 ] << ' | ' << तख़्ता [ 4 ] << ' | ' << तख़्ता [ 5 ] << अंतः ;
अदालत << ' | · | · ' << अंतः ;
अदालत << '-------' << अंतः ;
अदालत << ' | · | · ' << अंतः ;
अदालत << ' ' << तख़्ता [ 6 ] << ' | ' << तख़्ता [ 7 ] << ' | ' << तख़्ता [ 8 ] << अंतः ;
अदालत << ' | · | · ' << अंतः ;
अदालत << अंतः ;
}
खालीपन कंप्यूटरइनपुट ( ) {
int यहाँ पीओ ;
पीओ = हाशिया ( ) % 10 ;
अगर ( खालीसूचकांक [ पीओ ] == 1 ) {
अगर ( खाली गिनती < 0 )
वापस करना ;
कंप्यूटरइनपुट ( ) ;
} अन्य {
अदालत << 'कंप्यूटर चुनें:' << पीओ + 1 << अंतः ;
खालीसूचकांक [ पीओ ] = 1 ;
खाली गिनती - = 1 ;
तख़्ता [ पीओ ] = 'ओ' ;
}
}
खालीपन प्लेयरइनपुट ( खिलाड़ी & खिलाड़ी ) {
int यहाँ पीओ ;
अदालत << अंतः ;
अदालत << ' \टी ' << खिलाड़ी. नाम प्राप्त करें ( ) << ' मोड़: ' ;
अदालत << ' \टी स्थिति दर्ज करें ' <> पीओ ;
पीओ - = 1 ;
अगर ( खालीसूचकांक [ पीओ ] == 1 ) {
अदालत << '-----पद रिक्त नहीं-------' << अंतः ;
प्लेयरइनपुट ( खिलाड़ी ) ;
} अन्य {
खालीसूचकांक [ पीओ ] = 1 ;
खाली गिनती - = 1 ;
खिलाड़ी. नाम प्राप्त करें ( ) . तुलना करना ( 'खिलाड़ी मैं' ) == 0 ? तख़्ता [ पीओ ] = 'एक्स' : तख़्ता [ पीओ ] = 'ओ' ;
}
}
खालीपन चेकविन ( खिलाड़ी & पी1, प्लेयर & पी2 ) {
int यहाँ मैं, जे, के ;
बूल झंडा = असत्य ;
चार पहला_चिह्न ;
के लिए ( मैं = 0 ; मैं < 8 ; मैं ++ ) {
पहला_चिह्न = तख़्ता [ विजेता सूची [ मैं ] . पंक्ति [ 0 ] ] ;
अगर ( ( पहला_चिह्न ! = 'एक्स' ) && ( पहला_चिह्न ! = 'ओ' ) ) {
झंडा = असत्य ;
जारी रखना ;
}
झंडा = सत्य ;
के लिए ( जे = 0 ; जे < 3 ; जे ++ ) {
अगर ( पहला_चिह्न ! = तख़्ता [ विजेता सूची [ मैं ] . पंक्ति [ जे ] ] ) {
झंडा = असत्य ;
तोड़ना ;
}
}
अगर ( झंडा ) {
खेल शुरू = 0 ;
अगर ( पहला_चिह्न == 'एक्स' ) {
अदालत << '----------------------' << अंतः ;
अदालत << ' \टी खिलाड़ी मैं जीत गया' << अंतः ;
अदालत << '----------------------' << अंतः ;
पी1. जीत गया ( ) ;
} अन्य {
पी2. जीत गया ( ) ;
अगर ( कंप्यूटर के विरुद्ध ) {
अदालत << '----------------------' << अंतः ;
अदालत << ' \टी कंप्यूटर जीत गया' << अंतः ;
अदालत << '----------------------' << अंतः ;
} अन्य {
अदालत << '----------------------' << अंतः ;
अदालत << ' \टी खिलाड़ी द्वितीय जीता' << अंतः ;
अदालत << '----------------------' < 0 ) && ( खेल शुरू ! = 0 ) ) {
अगर ( कंप्यूटर के विरुद्ध )
हाथ == 1 ? कंप्यूटरइनपुट ( ) : प्लेयरइनपुट ( पी2 ) ;
अन्य
हाथ == 1 ? प्लेयरइनपुट ( पी1 ) : प्लेयरइनपुट ( पी2 ) ;
हाथ = ! हाथ ;
प्रदर्शन बोर्ड ( ) ;
चेकविन ( पी1,पी2 ) ;
}
अगर ( खाली गिनती <= 0 ) {
अदालत << ' --------------------------------------' << अंतः ;
अदालत << ' \टी कोई विजेता नहीं' << अंतः ;
अदालत << ' --------------------------------------' << अंतः ;
}
अदालत << अंतः ;
अदालत <> दोबारा मैच ;
अगर ( ( दोबारा मैच == 'और' ) || ( दोबारा मैच == 'और' ) ) {
गर्मी ( ) ;
खेल ( पी1,पी2 ) ;
}
}
खालीपन डिस्प्लेस्कोर ( खिलाड़ी & पी1, प्लेयर & पी2 ) {
अदालत << अंतः ;
अदालत << ' \टी अंक: \टी ' ;
अगर ( कंप्यूटर के विरुद्ध )
अदालत << 'खिलाड़ी मैं:' << पी1. स्कोर प्राप्त करें ( ) << ' \टी कंप्यूटर: ' << पी2. स्कोर प्राप्त करें ( ) << अंतः ;
अन्य
अदालत << 'खिलाड़ी मैं:' << पी1. स्कोर प्राप्त करें ( ) << ' \टी खिलाड़ी द्वितीय: ' << पी2. स्कोर प्राप्त करें ( ) << अंतः ;
}
जनता :
खेल ( ) : खाली गिनती { 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 मैं = 0 ; मैं < 10 ; मैं ++ ) {
खालीसूचकांक [ मैं ] = 0 ;
तख़्ता [ मैं ] = ( मैं + 1 ) + '0' ;
खाली गिनती ++ ;
}
खाली गिनती -- ;
}
खालीपन onePlayerGame ( ) {
// प्लेयर बनाना
खिलाड़ी पी ( 'खिलाड़ी मैं' ) ;
खिलाड़ी सी ( 'कंप्यूटर' ) ;
अदालत << ' ----------------------' << अंतः ;
अदालत << ' \टी खिलाड़ी I: एक्स \टी कंप्यूटर: ओ' << अंतः ;
अदालत << ' ----------------------' << अंतः ;
अदालत << अंतः ;
कंप्यूटर के विरुद्ध = 1 ;
खेल ( सी,पी ) ;
}
खालीपन दो खिलाड़ी खेल ( ) {
// प्लेयर बनाना
खिलाड़ी पी ( 'खिलाड़ी मैं' ) ;
खिलाड़ी सी ( 'खिलाड़ी द्वितीय' ) ;
अदालत << ' ----------------------' << अंतः ;
अदालत << ' \टी खिलाड़ी I: एक्स \टी खिलाड़ी II: ओ' << अंतः ;
अदालत << ' ----------------------' << अंतः ;
अदालत << अंतः ;
कंप्यूटर के विरुद्ध = 0 ;
खेल ( सी,पी ) ;
}
} ;
int यहाँ मुख्य ( )
{
int यहाँ चौधरी ;
जबकि ( 1 ) {
अदालत << ' ----------मेन्यू----------' << अंतः ;
अदालत << ' \टी 1. 1 खिलाड़ी खेल' << अंतः ;
अदालत << ' \टी 2. 2 खिलाड़ियों वाला गेम' << अंतः ;
अदालत << ' \टी 3. बाहर निकलने के लिए ' << अंतः ;
अदालत << ' --------' << अंतः ;
अदालत << अंतः ;
अदालत << ' \टी कोई विकल्प चुनें' <> चौधरी ;
बदलना ( चौधरी ) {
मामला 1 : {
खेल * खेल = नया खेल ;
खेल - > गर्मी ( ) ;
खेल - > onePlayerGame ( ) ;
}
तोड़ना ;
मामला 2 : {
खेल * खेल = नया खेल ;
खेल - > गर्मी ( ) ;
खेल - > दो खिलाड़ी खेल ( ) ;
}
तोड़ना ;
मामला 3 :
वापस करना 0 ;
गलती करना :
अदालत << 'उफ़ अमान्य विकल्प! पुनः प्रयास करें' ;
}
}
वापस करना 0 ;
}
यह टिक-टैक-टो गेम के निष्पादन के लिए एक पूर्ण कोड है, जिसे दो मोड में खेला जा सकता है, या तो कंप्यूटर के साथ या किसी साथी इंसान के साथ। यह एक बहुमुखी कोड है, जिसमें सभी संभावित कमांड शामिल हैं। जब उपयोगकर्ता किसी ऐसी स्थिति को इनपुट करता है जो पहले से ही भरी हुई है, तो वह इस स्थिति को अधिलेखित नहीं करता है और इस कदम को अमान्य मानता है।
अब तक खिलाड़ी ने पहले बॉक्स का चयन कर लिया है और फिर अगली बारी में कंप्यूटर ने छठे बॉक्स को चिह्नित किया है:
दोनों खिलाड़ियों ने अब तक दो बक्सों का चयन कर लिया है और अगली बारी में खिलाड़ी सातवाँ बक्सा चुनता है जिसके परिणामस्वरूप एक लगातार ऊर्ध्वाधर पैटर्न बनता है:
उपयोगकर्ता गेम खेलने के लिए कंप्यूटर का उपयोग करना चुनता है, इसलिए तीन चालें चलने के बाद, उपयोगकर्ता कंप्यूटर से जीत जाता है और एक अंक खिलाड़ी 1 के रिकॉर्ड में जोड़ा जाता है। पहला मैच खत्म होने के बाद, कंपाइलर रीमैच के लिए कहता है। उपयोगकर्ता विकल्पों में से निर्णय लेता है और प्रोग्राम मुख्य अनुभाग पर वापस आ जाता है। विकल्प तीन चुनने के बाद कंपाइलर कोड का निष्पादन करता है।
निष्कर्ष
टेक्स्ट-आधारित गेम खिलाड़ी के साथ बातचीत के लिए टेक्स्ट वर्णों और कमांड लाइन इंटरफ़ेस पर निर्भर करते हैं। उनके पास ग्राफिकल छवियां, ध्वनियां या एनिमेशन नहीं हैं। उपयोगकर्ता कंसोल विंडो के माध्यम से कमांड इनपुट करता है। उपयोगकर्ता के अनुकूल टेक्स्ट-आधारित टिक-टैक-टो गेम C++ का उपयोग करके बनाया गया है। यह एक गेम बनाने के लिए विभिन्न कमांड का उपयोग करता है जिसे या तो कंप्यूटर या किसी अन्य साथी खिलाड़ी के साथ खेला जा सकता है।