आप जैसे पाठक MUO का समर्थन करने में मदद करते हैं। जब आप हमारी साइट पर लिंक का उपयोग करके खरीदारी करते हैं, तो हम संबद्ध कमीशन अर्जित कर सकते हैं। और पढ़ें।

अनुमानित 2.5 बिलियन प्रशंसकों के साथ, क्रिकेट दुनिया के सबसे बड़े और सबसे लोकप्रिय खेलों में से एक है। अकेले भारत में क्रिकेट की कीमत 5.3 बिलियन डॉलर है। सचिन तेंदुलकर, डोनाल्ड ब्रैडमैन, ब्रायन लारा और एमएस धोनी कुछ ऐसे दिग्गज हैं जिनके नाम लाखों लोगों के दिलों में बसते हैं।

यह कोई आश्चर्य की बात नहीं है कि क्रिकेट ने आभासी वास्तविकता, वीडियो गेम और किताब और हाथ क्रिकेट जैसी अन्य विविधताओं के लिए अपना रास्ता खोज लिया है। Python का उपयोग करके हैंड क्रिकेट गेम बनाकर इस गेम को एक कदम आगे ले जाएं।

हैंड क्रिकेट क्या है?

हैंड क्रिकेट एक ऐसा खेल है जिसमें दो खिलाड़ी अपनी उंगलियों का उपयोग करके एक दूसरे के खिलाफ प्रतिस्पर्धा करते हैं। प्रत्येक मोड़ में, दोनों खिलाड़ी एक ही समय में अपनी उंगलियों का उपयोग करके एक संख्या प्रदर्शित करते हैं। यदि स्कोर मेल खाते हैं, तो बल्लेबाज आउट हो जाता है, अन्यथा वे रन के रूप में अपनी संख्या हासिल कर लेते हैं। अंत में, सबसे अधिक स्कोर करने वाला खिलाड़ी गेम जीतता है।

instagram viewer

आप इस गेम को बना सकते हैं और इसे कंप्यूटर के खिलाफ भी खेल सकते हैं। स्कोर का प्रतिनिधित्व करने के लिए उंगलियां बाहर निकालने के बजाय, आप इसे प्रोग्राम में दर्ज करते हैं। पायथन उपयोग करने के लिए सबसे आसान और सबसे सुविधाजनक भाषाओं में से एक है। यदि आपके पास पायथन का उपयोग करने का कोई पूर्व अनुभव नहीं है, तो आप इनमें से किसी के साथ गति प्राप्त कर सकते हैं शुरुआती लोगों के लिए मुफ्त ऑनलाइन पायथन पाठ्यक्रम.

एक बार जब आप मूल सिद्धांतों को सीख लेते हैं, तो अपने सीखने को ठोस बनाने के लिए मिनी-प्रोजेक्ट्स और गेम बनाना एक अच्छा विचार है। आप एक डिजिटल घड़ी, रोलिंग पासा, प्रश्नोत्तरी, या एक शब्द काउंटर बनाकर शुरू कर सकते हैं। आप भी इनसे प्रेरणा प्राप्त कर सकते हैं शुरुआती के लिए पायथन परियोजना के विचार.

पायथन का उपयोग करके हैंड क्रिकेट गेम कैसे बनाएं

आप इसमें Python का उपयोग करके हैंड क्रिकेट का स्रोत कोड पा सकते हैं GitHub भंडार।

प्रारंभिक टॉस और कंप्यूटर की पसंद के लिए आवश्यक रैंडम लाइब्रेरी आयात करें। नामित एक समारोह को परिभाषित करें input_num जो दो तर्कों को स्वीकार करता है, मिन और अधिकतम क्रमशः उपयोगकर्ता के इनपुट को मान्य करने के लिए। का उपयोग इनपुट () फ़ंक्शन, उस नंबर को स्टोर करें जो उपयोगकर्ता चर में प्रवेश करता है अंक, और इसे डिफ़ॉल्ट स्ट्रिंग से इंटीजर प्रकार का उपयोग करके कास्ट करें इंट ().

यदि उपयोगकर्ता द्वारा दर्ज की गई संख्या अधिकतम सीमा से अधिक या न्यूनतम सीमा से कम है, तो उपयोगकर्ता से एक वैध विकल्प दर्ज करने के लिए कहें फ़ंक्शन को पुनरावर्ती रूप से कॉल करना. यदि संख्या सीमा के भीतर है, तो उसे वापस कर दें।

आयात अनियमित
डीईएफ़input_num(न्यूनतम अधिकतम):
 संख्या = इंट (इनपुट ())
अगर संख्या > अधिकतम या संख्या  प्रिंट ("वैध विकल्प दर्ज करें")
वापस करना input_num (न्यूनतम, अधिकतम)
अन्य:
वापस करना अंक

एक समारोह परिभाषित करें पारी जो वर्तमान बल्लेबाज और पीछा करने के लिए रन को इनपुट तर्क के रूप में स्वीकार करता है। उपयोगकर्ता को एक से छह की सीमा के भीतर संख्याएँ दर्ज करने के लिए कहें। हैंड क्रिकेट के नियमों के अनुसार, यदि उपयोगकर्ता और कंप्यूटर दोनों एक ही नंबर चुनते हैं, तो वर्तमान बल्लेबाज आउट हो जाता है।

एक चर प्रारंभ करें कुल एक बल्लेबाज द्वारा बनाए गए कुल रन को स्टोर करने के लिए और इसे शून्य पर सेट करने के लिए। एक अनंत प्रारंभ करें जबकि लूप करें और कॉल करें इनपुट_नंबर () उपयोगकर्ता के इनपुट को स्टोर और मान्य करने का कार्य। यादृच्छिक मॉड्यूल का प्रयोग करें रैंडिंट () कंप्यूटर के लिए एक और छह के बीच एक यादृच्छिक संख्या चुनने का कार्य।

दोनों खिलाड़ियों की पसंद प्रदर्शित करें, फिर जांचें कि क्या वे समान हैं। यदि वे हैं, तो प्रदर्शित करें कि बल्लेबाज आउट है और उस पारी में उनके द्वारा बनाए गए कुल रन लौटाएं।

अन्यथा, जांचें कि कौन बल्लेबाजी कर रहा है और कुल स्कोर में उचित मान जोड़ें pnum या cnum. बल्लेबाज के वर्तमान स्कोर को प्रदर्शित करें।

दूसरी पारी के मामले में, आप यह जांचना चाहते हैं कि बल्लेबाज ने अपने प्रतिद्वंद्वी के स्कोर को पहले ही पार कर लिया है या नहीं। ऐसा करने के लिए, जांचें कि क्या पीछा करना मान खाली नहीं है और यदि बल्लेबाज का स्कोर अधिक है। यदि ऐसा है, तो उनका विजयी स्कोर लौटाएँ।

डीईएफ़पारी(बल्लेबाज, to_chase):
 प्रिंट ("1 और 6 के बीच संख्याएँ दर्ज करें। अगर आप दोनों एक ही नंबर चुनते हैं तो " + बल्लेबाज + " बाहर है")
 कुल = 0
जबकिसत्य:
 pnum = input_num (1, 6)
 सीएनयूएम = यादृच्छिक रैंडिंट (1, 6)


 प्रिंट ("उपयोगकर्ता ने चुना", पनम)
 प्रिंट ("कंप्यूटर चुना", सीएनयूएम)
अगर पीनम == सीएनयूएम:
 प्रिंट (बल्लेबाज + " बाहर है")
वापस करना कुल
अन्य:
 कुल = कुल + (pnum अगर बल्लेबाज == "उपयोगकर्ता"अन्य सीएनयूएम)
 प्रिंट (बल्लेबाज + "स्कोर है", कुल)
अगर पीछा करना हैनहींकोई नहींऔर कुल> to_chase:
वापस करना कुल

टॉस के लिए संदेश प्रदर्शित करें और उपयोग करके उपयोगकर्ता की पसंद को मान्य करें इनपुट_नंबर () समारोह। सिक्के को उछालें और परिणाम को वेरिएबल में स्टोर करें सिक्का. के डिफ़ॉल्ट मान को प्रारंभ करें खिलाड़ी_कटोरे असत्य को। यदि सिक्का फ्लिप उपयोगकर्ता की पसंद से मेल खाता है, तो उपयोगकर्ता टॉस जीतता है और बल्लेबाजी और गेंदबाजी के बीच चयन करता है।

उपयोगकर्ता की पसंद लें और जांचें कि क्या उसने एक दर्ज किया है। यदि हाँ, तो अभिव्यक्ति का सत्य पर मूल्यांकन करें और इसमें स्टोर करें खिलाड़ी_कटोरे चर। उपयोगकर्ता की पसंद प्रदर्शित करें। दूसरी ओर, यदि कंप्यूटर टॉस जीतता है, तो निष्पादित करें रैंडिंट () और उचित मूल्य का मूल्यांकन करें खिलाड़ी_कटोरे.

कंप्यूटर की पसंद प्रदर्शित करें और पारी शुरू करें।

प्रिंट ("टॉस का समय, हेड के लिए 0 और टेल के लिए 1 दर्ज करें")
पसंद = इनपुट_नम (0, 1)
सिक्का = यादृच्छिक रैंडिंट (0, 1)
खिलाड़ी_कटोरे = असत्य
अगर सिक्का == पसंद:
 प्रिंट ("आपने टॉस जीत लिया है")
 प्रिंट ("बल्लेबाजी के लिए 0 चुनें, गेंदबाजी के लिए 1")
 खिलाड़ी_कटोरी = इनपुट_संख्या (0, 1) == 1


अगर खिलाड़ी_कटोरे:
 प्रिंट ("आपने गेंदबाजी करना चुना")
अन्य:
 प्रिंट ("आपने बल्लेबाजी करना चुना")
अन्य:
 प्रिंट ("कंप्यूटर ने टॉस जीता")
 खिलाड़ी_बॉल्स = यादृच्छिक.रैंडिंट (0, 1) == 1
अगर खिलाड़ी_कटोरे:
 प्रिंट ("कंप्यूटर ने बल्लेबाजी करना चुना")
अन्य:
 प्रिंट ("कंप्यूटर ने गेंदबाजी करना चुना")

अगर खिलाड़ी_कटोरे सच है, कंप्यूटर पहले बल्लेबाजी करता है और इसके विपरीत। आपके द्वारा पहले परिभाषित किए गए फ़ंक्शन का उपयोग करके एक पारी में बनाए गए रनों की गणना करें। फ़ंक्शन को वर्तमान बल्लेबाज के नाम और पीछा करने के लिए रनों की आवश्यकता होती है। जैसा कि पहला बल्लेबाज स्कोर सेट करता है, इसे एक वैकल्पिक पैरामीटर बनाएं और पास करें कोई नहीं. दूसरी पारी के लिए लक्ष्य निर्धारित करने वाले बल्लेबाज के स्कोर को पास करें।

अगर खिलाड़ी_कटोरे:
 comp_score = पारी ("कंप्यूटर", कोई नहीं)
 user_score = पारी ("उपयोगकर्ता", कॉम्प_स्कोर)
अन्य:
 user_score = पारी ("उपयोगकर्ता", कोई नहीं)
 comp_score = पारी ("कंप्यूटर", उपयोगकर्ता_स्कोर)

यदि कंप्यूटर उपयोगकर्ता से कम स्कोर करता है, तो उपयोगकर्ता जीत जाता है, और इसके विपरीत। यदि स्कोर समान हैं, तो टाई प्रदर्शित करें।

अगर comp_score  प्रिंट ("उपयोगकर्ता जीतता है")
elif user_score  प्रिंट ("कंप्यूटर जीतता है")
अन्य:
 प्रिंट ("मैच ड्रॉ")

सभी कोड को एक साथ रखें और कभी भी, कहीं भी सीधे अपनी उंगलियों पर हैंड क्रिकेट खेलने के लिए तैयार हो जाएं।

पायथन का उपयोग करते हुए हैंड क्रिकेट का आउटपुट

आप पायथन का उपयोग करते हुए हैंड क्रिकेट के खेल का आउटपुट इस प्रकार देख सकते हैं:

जब आप प्रोग्राम निष्पादित करते हैं, तो प्रोग्राम आपको टॉस के लिए एक विकल्प चुनने के लिए कहता है और उचित परिणाम प्रदान करता है। यदि आप जीतते हैं, तो आप तय कर सकते हैं कि आप बल्लेबाजी करना चाहते हैं या गेंदबाजी करना चाहते हैं, अन्यथा कंप्यूटर निर्णय लेता है। प्रत्येक पारी तब तक जारी रहती है जब तक कि संख्याएँ मेल नहीं खातीं और एक बाहर हो जाता है। अंत में, कंप्यूटर अंतिम स्कोर की तुलना करता है और विजेता घोषित करता है।

पायथन में टर्मिनल-आधारित गेम

गेम बनाना पाइथन सीखने का एक अद्भुत तरीका है और यह बहुत मजेदार है। पायथन में कोडिंग और प्रयोग शुरू करने के लिए आपको विशेषज्ञ होने की आवश्यकता नहीं है। केवल सही मूल सिद्धांतों के साथ, आप कुछ अद्भुत टर्मिनल गेम बना सकते हैं।

मैजिक 8 बॉल, जल्लाद, रॉक पेपर कैंची, मैड लिब्स जेनरेटर और नंबर गेसिंग गेम का निर्माण शुरू करें। जैसे-जैसे आप आगे बढ़ते हैं, अपने स्वयं के ग्राफिकल वीडियो गेम बनाने के लिए PyGame लाइब्रेरी का अन्वेषण करें।