द्वारा शर्लिन खान

अपने पायथन प्रोग्रामिंग अवधारणाओं को ठोस बनाने के लिए इस सरल गेम का निर्माण करें।

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

पायथन में गेम बनाना बुनियादी प्रोग्रामिंग अवधारणाओं को सीखने और प्रोग्रामिंग में एक मजबूत नींव बनाने का एक शानदार तरीका है। आपके द्वारा बनाए जा सकने वाले खेलों में से एक सरल संख्या-अनुमान लगाने वाला गेम है।

आप केवल एक Python स्क्रिप्ट का उपयोग करके संख्या अनुमान लगाने वाला गेम बना सकते हैं। गेम खेलने के लिए, कमांड लाइन या टर्मिनल का उपयोग करके स्क्रिप्ट चलाएँ।

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

कैसे एक यादृच्छिक संख्या उत्पन्न करने के लिए

आप एक के साथ एक नया पायथन स्क्रिप्ट बनाकर शुरू कर सकते हैं .py खेल के लिए तर्क रखने के लिए विस्तार। अंदर, खिलाड़ी के अनुमान लगाने के लिए 1 और 50 के बीच एक यादृच्छिक संख्या उत्पन्न करने के लिए कुछ शुरुआती कोड जोड़ें।

instagram viewer

यदि आप पायथन सिंटैक्स से परिचित नहीं हैं, तो कुछ पर नज़र डालें बुनियादी पायथन उदाहरण आपको गति देने के लिए।

  1. नामक एक नई फाइल बनाएं संख्या-अनुमान-game.py. फ़ाइल को किसी भी पाठ संपादक, जैसे विजुअल स्टूडियो या एटम.
  2. फ़ाइल के शीर्ष पर, आयात करें अनियमित मापांक:
    आयात अनियमित
  3. उपयोग अनियमित मॉड्यूल के रैंडिंट () विधि 1 और 50 के बीच एक यादृच्छिक संख्या उत्पन्न करने के लिए:
    अनुमान_रेंज = 50
    उत्तर = यादृच्छिक रैंडिंट (1, अनुमान_रेंज)
  4. खेल शुरू करें, और खिलाड़ी से संख्या का अनुमान लगाने के लिए कहें:
    प्रिंट ("संख्या अनुमान लगाने के खेल में आपका स्वागत है!")
    प्रिंट ("")
    उपयोगकर्ता इनपुट = इनपुट ("1 और के बीच एक संख्या का अनुमान लगाएं" + स्ट्र (अनुमान_रेंज) + ": ")
    अनुमान = int (उपयोगकर्ता इनपुट)

कैसे जांचें कि उपयोगकर्ता ने सही संख्या का अनुमान लगाया है या नहीं

उपयोगकर्ता को गेम जीतने के लिए, उपयोगकर्ता के इनपुट की तुलना यादृच्छिक संख्या से करें और जांचें कि क्या यह मेल खाता है।

  1. जबकि उपयोगकर्ता ने अभी तक सही उत्तर का अनुमान नहीं लगाया है, उन्हें एक नया इनपुट दर्ज करने के लिए पुनः पूछें। किसी नेस्टेड कोड को इंडेंट करना सुनिश्चित करें, क्योंकि पायथन की संरचना सही इंडेंटेशन पर निर्भर करती है:
    अनुमान = ""
    जबकि अनुमान! = उत्तर:
    उपयोगकर्ता इनपुट = इनपुट ("1 और के बीच एक संख्या का अनुमान लगाएं" + स्ट्र (अनुमान_रेंज) + ": ")
    अनुमान = int (उपयोगकर्ता इनपुट)
  2. यदि कोड लूप के बाद निष्पादित होता है, तो इसका मतलब है कि उन्होंने सही उत्तर का अनुमान लगाया है:
    प्रिंट ("बधाई हो! आपने सही संख्या का अनुमान लगाया। आप जीतते हैं!") 

अनुमानों की सीमित संख्या कैसे जोड़ें

खिलाड़ी को अनंत बार पूछने से रोकने के लिए, आप उनके अनुमानों की संख्या सीमित कर सकते हैं।

  1. खिलाड़ी द्वारा अनुमत अनुमानों की संख्या का ट्रैक रखने के लिए, फ़ाइल की शुरुआत में एक नया चर घोषित करें। आरंभ करने के लिए इसे 10 पर सेट करें:
    अनुमान_अनुमति = 10
  2. थोड़ी देर के बयान को लूप के लिए बदलें, जो केवल अनुमानों की सीमित मात्रा के लिए दोहराता है:
    के लिए मैं में रेंज (अनुमान_अनुमति):
    उपयोगकर्ता इनपुट = इनपुट ("1 और के बीच एक संख्या का अनुमान लगाएं" + स्ट्र (अनुमान_रेंज) + ": ")
    अनुमान = int (उपयोगकर्ता इनपुट)
  3. लूप के अंदर, यदि अनुमानों में से कोई एक सही उत्तर है, तो लूप के लिए बाहर निकलें:
    अगर अनुमान == उत्तर:
    प्रिंट ("बधाई हो! आपने सही संख्या का अनुमान लगाया। आप जीतते हैं!")
    तोड़ना
  4. फिर भी, के लिए लूप के अंदर, यह जांचने के लिए कि क्या खिलाड़ी अपने अनुमानों की सीमा तक पहुंच गया है, एक और if स्टेटमेंट जोड़ें। यदि ऐसा है, तो खेल समाप्त करें:
    अगर (मैं == अनुमान_अनुमति - 1):
    प्रिंट ("क्षमा करें, आपका अनुमान समाप्त हो गया है। तुम हारे!")

गेम में संकेत कैसे जोड़ें

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

एक और संकेत उन्हें यह बताना है कि वे उत्तर से कितने करीब या दूर हैं। उदाहरण के लिए, खेल को उन्हें सूचित करना चाहिए कि क्या वे "गर्म" हो रहे हैं। अन्यथा, यदि वे संख्या से बहुत दूर हैं, तो खेल को उन्हें बताना चाहिए कि वे "ठंडा" हो रहे हैं।

  1. उस कथन को संशोधित करें जो उपयोगकर्ता को बताता है कि क्या वे जीत गए हैं। यदि वे अभी भी सही उत्तर का अनुमान नहीं लगा पाते हैं, तो उन्हें बताएं कि वास्तविक उत्तर उच्च या निम्न है।
    अगर अनुमान == उत्तर:
    प्रिंट ("बधाई हो! आपने सही संख्या का अनुमान लगाया। आप जीतते हैं!")
    तोड़ना
    elif अनुमान प्रिंट ("संख्या अधिक है।")
    अन्य:
    प्रिंट ("संख्या कम है।")
  2. अतिरिक्त संकेत जोड़ने के लिए एक और if कथन जोड़ें। यह उन्हें बताएगा कि क्या वे संख्या के करीब या "गर्म" हो रहे हैं। अनुमान और उत्तर के बीच की दूरी निर्धारित करने के लिए निरपेक्ष फ़ंक्शन का उपयोग करें। उदाहरण के लिए, यदि वे उत्तर से 10 अंकों से कम दूर हैं, तो गेम "यू आर वार्म" प्रिंट करेगा:
    अगर एब्स (अनुमान - उत्तर) <= 10:
    प्रिंट ("तुम गर्म हो!")
    elif एब्स (अनुमान - उत्तर) <= 20:
    प्रिंट ("आप गर्म हो रहे हैं।")
    elif एब्स (अनुमान - उत्तर) <= 30:
    प्रिंट ("आपको ठंड लग रही है।")
    अन्य:
    प्रिंट ("आप ठंड कर रहे हैं।")

गेम की कठिनाई को कैसे बदलें

आप उपयोगकर्ता को कठिनाई स्तर चुनने के लिए कह सकते हैं। कठिनाई स्तर यह निर्धारित करता है कि खिलाड़ी के कितने अनुमान प्रयास हैं, और अनुमान सीमा कितनी दूर है।

  1. खेल की शुरुआत में, उपयोगकर्ता को कठिनाई स्तर चुनने के लिए कहें:
    प्रिंट ("संख्या अनुमान लगाने के खेल में आपका स्वागत है!")
    प्रिंट ("")
    जबकिसत्य:
    स्तर = इनपुट ("कठिनाई स्तर चुनें (आसान, मध्यम, कठिन):")।निचला()
  2. यह सुनिश्चित करने के लिए कुछ सत्यापन जोड़ें कि खिलाड़ी केवल "आसान", "मध्यम", या "कठोर" विकल्प टाइप करता है। यदि उपयोगकर्ता अमान्य प्रतिक्रिया दर्ज करता है, तो गेम उन्हें कठिनाई स्तर फिर से दर्ज करने के लिए कहेगा।
    अगर स्तर में ["आसान", "मध्यम", "मुश्किल"]:
    तोड़ना
    अन्य:
    प्रिंट ("अमान्य निवेश। कृपया 'आसान', 'मध्यम' या 'कठिन' में से किसी एक का चयन करें।")
  3. यादृच्छिक संख्या उत्पन्न करने से पहले, यह निर्धारित करने के लिए कि वे कितने अनुमान लगा सकते हैं, खिलाड़ी की कठिनाई का उपयोग करें। अनुमान सीमा कितनी बड़ी है यह निर्धारित करने के लिए आप उनके चयनित कठिनाई स्तर का भी उपयोग कर सकते हैं:
    अगर स्तर == "आसान":
    अनुमान_रेंज = 50
    अनुमान_अनुमति = 20
    elif स्तर == "मध्यम":
    अनुमान_रेंज = 100
    अनुमान_अनुमति = 15
    अन्य:
    अनुमान_रेंज = 150
    अनुमान_अनुमति = 10

    उत्तर = यादृच्छिक रैंडिंट (1, अनुमान_रेंज)

गेम कैसे खेलें

अब जब आपके पास खेल के लिए सभी तर्क हैं, तो आप इसे कमांड प्रॉम्प्ट में खेल सकते हैं। आप पूर्ण संख्या अनुमान लगाने के खेल का उदाहरण भी देख सकते हैं GitHub.

  1. एक कमांड प्रॉम्प्ट या टर्मिनल खोलें, और उस फ़ोल्डर पर जाएँ जहाँ आपने अपनी पायथन स्क्रिप्ट संग्रहीत की थी। उदाहरण के लिए, यदि आपने अपनी स्क्रिप्ट को डेस्कटॉप पर संग्रहीत किया है, तो कमांड इस तरह दिखाई देगी:
    सीडी सी: उपयोगकर्ता Sharl Desktop
  2. उपयोग अजगर अपनी पायथन स्क्रिप्ट चलाने की आज्ञा:
    अजगर संख्या-अनुमान-game.py
  3. एक कठिनाई स्तर दर्ज करें।
  4. संख्या को आज़माने और अनुमान लगाने के लिए कमांड प्रॉम्प्ट में संख्याएँ दर्ज करें।

सरल गेम बनाकर प्रोग्रामिंग सीखें

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

हमारे न्युजलेटर की सदस्यता प्राप्त करें

टिप्पणियाँ

शेयर करनाकरेंशेयर करनाशेयर करनाशेयर करना
प्रतिलिपि
ईमेल
शेयर करना
शेयर करनाकरेंशेयर करनाशेयर करनाशेयर करना
प्रतिलिपि
ईमेल

लिंक को क्लिपबोर्ड पर कॉपी किया गया

संबंधित विषय

  • प्रोग्रामिंग
  • अजगर
  • खेल का विकास

लेखक के बारे में

शर्लिन खान (82 लेख प्रकाशित)

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