कंप्यूटर गेम कैसे प्रोग्राम करें (चित्रों के साथ)

2024 लेखक: Robert Blare | [email protected]. अंतिम बार संशोधित: 2024-01-31 12:16

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

कदम

3 का भाग 1: टेक्स्ट-आधारित गेम बनाना

चरण 1. प्रोग्रामिंग भाषा चुनें।

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

• भाषा का प्रयोग अधिकतर किस लिए किया जाता है?

  कुछ प्रोग्रामिंग भाषाएं, जैसे जावास्क्रिप्ट, को वेब के लिए उपयोग करने के लिए डिज़ाइन किया गया है, जबकि अन्य, जैसे पायथन, सी, या सी ++, को कंप्यूटर प्रोग्राम चलाने के लिए डिज़ाइन किया गया है। अपने गेम के लिए, व्यापक उपयोग वाली भाषा का लक्ष्य रखें, जैसे कि Python, C, C++, or जावास्क्रिप्ट.

• सीखना कितना कठिन है?

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

• मैं इसका उपयोग कहां कर सकता हूं?

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

यह आलेख टेक्स्ट-आधारित गेम के उदाहरणों के लिए पायथन का उपयोग करेगा, लेकिन आप देख सकते हैं कि किसी अन्य प्रोग्रामिंग भाषा में अवधारणाएं कैसे की जाती हैं।

चरण 2. अपना कंप्यूटर तैयार करें।

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

चरण 3. खिलाड़ी को बधाई देने के लिए कुछ कोड लिखें।

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

• यह पायथन में प्रिंट () फ़ंक्शन के साथ किया जाता है। इसे आज़माने के लिए,.py एक्सटेंशन के साथ एक नई फ़ाइल खोलें, इसमें निम्न कोड दर्ज करें, इसे सहेजें और चलाएं:

  प्रिंट ("संख्या अनुमान लगाने के खेल में आपका स्वागत है!") प्रिंट ("1 और 1000 के बीच एक पूर्ण संख्या दर्ज करें:")
  

चरण 4. एक यादृच्छिक संख्या उत्पन्न करें।

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

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

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

  राइटनम = रैंडम। रैंडिंट (0, 1000)
  

चरण 5. खिलाड़ी से इनपुट प्राप्त करें।

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

• चूंकि आपके द्वारा दर्ज किया गया कोड खिलाड़ी को एक नंबर दर्ज करने के निर्देश को प्रिंट करता है, इसलिए इसे उनके द्वारा दर्ज की गई संख्या को भी पढ़ना चाहिए। यह पायथन 3 में इनपुट () और पायथन 2 में कच्चे_इनपुट () के साथ किया जाता है। आपको पायथन 3 में लिखना चाहिए, क्योंकि पायथन 2 जल्द ही पुराना हो जाएगा। प्लेयर के इनपुट को नंबर नामक वेरिएबल में स्टोर करने के लिए अपने कोड में निम्न लाइन जोड़ें:

  उपयोगकर्ता संख्या = इनपुट ()
  

चरण 6. खिलाड़ी के इनपुट को प्रयोग करने योग्य डेटा प्रकार में बदलें।

खिलाड़ी ने एक नंबर दर्ज किया है-अब क्या?

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

  userNum = int (userNum)
  

चरण 7. खिलाड़ी की संख्या की सही संख्या से तुलना करें।

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

जबकि userNum != rightNum: userNum = int(input ())

चरण 8. खिलाड़ी को प्रतिक्रिया दें।

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

• निश्चित रूप से, आप केवल खिलाड़ी को बता सकते हैं कि उनका नंबर सही है या गलत। लेकिन उस दृष्टिकोण के साथ, खिलाड़ी को सबसे खराब स्थिति में 1000 बार अनुमान लगाना पड़ सकता है, जो बहुत उबाऊ होगा।
• तो खिलाड़ी को बताएं कि उनकी संख्या बहुत छोटी है या बहुत बड़ी है। इससे उनके अनुमानों की संख्या में काफी कमी आएगी। यदि, उदाहरण के लिए, खिलाड़ी पहले 500 का अनुमान लगाता है, और खेल उत्तर देता है "बहुत बड़ा। फिर से प्रयास करें," 1000 के बजाय केवल 500 संभावित संख्याएं होंगी। यह if-constructions के साथ किया जाता है, इसलिए प्रिंट को बदलें ("गलत। पुनः प्रयास करें।") एक के साथ।
• ध्यान रखें कि दो संख्याओं के समान होने की जाँच == के साथ की जाती है, = के साथ नहीं। = इसके मान को इसके बाईं ओर के चर को निर्दिष्ट करता है!

यदि userNum <rightNum: प्रिंट ("बहुत छोटा है। पुनः प्रयास करें:") यदि userNum> rightNum: प्रिंट ("बहुत बड़ा। पुन: प्रयास करें:")

चरण 9. अपने कोड का परीक्षण करें।

एक प्रोग्रामर के रूप में, आपको यह सुनिश्चित करना चाहिए कि आपका कोड समाप्त होने पर विचार करने से पहले काम करता है।

• पायथन में प्रोग्रामिंग करते समय, सुनिश्चित करें कि आपको इंडेंटेशन सही मिले। आपका कोड इस तरह दिखना चाहिए:

  आयात यादृच्छिक प्रिंट ("संख्या अनुमान लगाने वाले खेल में आपका स्वागत है!") प्रिंट ("1 और 1000 के बीच एक पूर्ण संख्या दर्ज करें:") राइटनम = यादृच्छिक। रैंडिंट (0, 1000) उपयोगकर्ता संख्या = इनपुट () उपयोगकर्ता संख्या = int (उपयोगकर्ता संख्या) जबकि userNum != rightNum: if userNum <rightNum: print("बहुत छोटा है। फिर से कोशिश करें:") अगर userNum> rightNum: print("बहुत बड़ा। फिर से कोशिश करें:") userNum = int(input()) print("आपने अनुमान लगाया सही ढंग से।")
  

चरण 10. इनपुट को मान्य करें।

खिलाड़ी केवल गलत चीज़ दर्ज करके आपके खेल को तोड़ने में सक्षम नहीं होना चाहिए। "इनपुट को मान्य करना" का अर्थ है यह सुनिश्चित करना कि खिलाड़ी ने इसे संसाधित करने से पहले सही चीज़ दर्ज की है।

• खेल को फिर से खोलें और कुछ भी दर्ज करने का प्रयास करें जो एक संख्या नहीं है। खेल एक ValueError के साथ बाहर निकल जाएगा। इससे बचने के लिए, आप यह जांचने का एक तरीका लागू कर सकते हैं कि इनपुट एक संख्या थी या नहीं।
• एक फ़ंक्शन को परिभाषित करें। चूंकि इनपुट को मान्य करना काफी लंबा है, और आपको इसे कई बार करना होगा, आपको एक फ़ंक्शन परिभाषित करना चाहिए। यह कोई तर्क नहीं लेगा और एक नंबर लौटाएगा। सबसे पहले, अपने कोड के शीर्ष पर def numInput (): सीधे आयात यादृच्छिक के तहत लिखें।
• एक बार खिलाड़ी का इनपुट प्राप्त करें। इनपुट () फ़ंक्शन का उपयोग करें और परिणाम को वेरिएबल inp पर असाइन करें।
• जब खिलाड़ी का इनपुट कोई संख्या नहीं है, तो उन्हें एक नंबर दर्ज करने के लिए कहें। यह जांचने के लिए कि क्या कोई स्ट्रिंग एक संख्या है, isdigit () फ़ंक्शन का उपयोग करें, जो केवल एक पूर्ण संख्या की अनुमति देता है, इसलिए आपको इसके लिए अलग से जांच करने की आवश्यकता नहीं होगी।
• यदि इनपुट एक संख्या है, तो इसे स्ट्रिंग से संख्या में बदलें और परिणाम लौटाएं। स्ट्रिंग को पूर्णांक में बदलने के लिए int() फ़ंक्शन का उपयोग करें। यह मुख्य कोड में रूपांतरण को अनावश्यक बना देगा, और आपको इसे वहां से हटा देना चाहिए।
• सभी कॉलों को इनपुट () में मुख्य कोड में कॉल के साथ numInput () में बदलें।
• numInput() फ़ंक्शन का कोड इस तरह दिखेगा:

def numInput (): inp = इनपुट () जबकि inp.isdigit (): प्रिंट ("आपको एक पूर्ण संख्या दर्ज करने के लिए कहा गया था! एक पूर्ण संख्या दर्ज करें:") inp = इनपुट () वापसी int (inp)

चरण 11. खेल का फिर से परीक्षण करें।

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

जब प्रोग्राम आपसे नंबर मांगे तो कुछ टेक्स्ट दर्ज करने का प्रयास करें। अब, एक त्रुटि संदेश के साथ बाहर निकलने के बजाय, प्रोग्राम आपसे फिर से एक नंबर मांगेगा।

चरण 12. खेल समाप्त होने पर पुनः आरंभ करने का सुझाव दें।

इस तरह, खिलाड़ी आपके गेम को लगातार पुनरारंभ किए बिना लंबे समय तक खेल सकता है।

• आयात और फ़ंक्शन परिभाषा को छोड़कर सभी कोड को थोड़ी देर के लूप में रखें। शर्त के रूप में सही सेट करें: यह हमेशा सत्य रहेगा, इसलिए लूप हमेशा के लिए जारी रहेगा।
• खिलाड़ी से पूछें कि क्या वे संख्या का सही अनुमान लगाने के बाद फिर से खेलना चाहते हैं। प्रिंट () फ़ंक्शन का उपयोग करें।
• अगर वे "नहीं" का जवाब देते हैं, तो नज़र से बाहर निकलें। अगर वे कुछ और जवाब देते हैं, तो जारी रखें। लूप से ब्रेक आउट ब्रेक स्टेटमेंट के साथ किया जाता है।
• लूप के बाहर "संख्या अनुमान लगाने के खेल में आपका स्वागत है" को स्थानांतरित करें। खिलाड़ी शायद हर बार जब वे खेल खेलते हैं तो उनका स्वागत नहीं करना चाहता। इंस्ट्रक्शन प्रिंट को मूव करें ("नंबर अनुमान लगाने वाले गेम में आपका स्वागत है!" जबकि ट्रू: से ऊपर, इसलिए यह केवल एक बार प्रिंट होगा, जब उपयोगकर्ता पहला गेम शुरू करेगा।

चरण 13. खेल का परीक्षण करें।

हर बार जब आप कोई नई सुविधा लागू करते हैं तो आपको अपने गेम का परीक्षण करना होगा।

• यह सुनिश्चित करने के लिए कि दोनों विकल्प काम करते हैं, कम से कम एक बार "हां" और "नहीं" दोनों का उत्तर देना सुनिश्चित करें। यहां आपका कोड कैसा दिखना चाहिए:

  आयात यादृच्छिक def numInput(): inp = input() जबकि inp.isdigit() नहीं: प्रिंट ("आपको एक पूर्ण संख्या दर्ज करने के लिए कहा गया था! एक पूर्ण संख्या दर्ज करें:") inp = इनपुट() वापसी int (inp) प्रिंट ("संख्या अनुमान लगाने वाले गेम में आपका स्वागत है!") जबकि ट्रू: प्रिंट ("1 और 1000 के बीच एक पूर्ण संख्या दर्ज करें:") राइटनम = रैंडम। रैंडिंट (0, 1000) यूजरनम = numInput () जबकि यूजरनम! = राइटनम: अगर userNum <rightNum: प्रिंट ("बहुत छोटा है। पुनः प्रयास करें:") यदि userNum> rightNum: प्रिंट ("बहुत बड़ा। पुनः प्रयास करें:") userNum = numInput () प्रिंट ("आपने सही अनुमान लगाया।") प्रिंट ("क्या आप फिर से खेलना चाहते हैं? छोड़ने के लिए नहीं दर्ज करें।") अगर इनपुट () == "नहीं": ब्रेक
  

चरण 14. अन्य पाठ-आधारित खेल लिखें।

आगे एक टेक्स्ट एडवेंचर लिखने के बारे में कैसे? या एक प्रश्नोत्तरी खेल? रचनात्मक बनो।

टिप: यदि आप सुनिश्चित नहीं हैं कि कुछ कैसे किया जाता है या किसी फ़ंक्शन का उपयोग कैसे किया जाता है, तो कभी-कभी दस्तावेज़ीकरण में देखना सहायक होता है। पायथन 3 प्रलेखन https://docs.python.org/3/ पर पाया जाता है। कभी-कभी आप जो कुछ भी करना चाहते हैं उसे इंटरनेट पर खोजना भी अच्छे परिणाम देता है।

3 का भाग 2: 2डी ग्राफ़िक्स के साथ गेम बनाना

चरण 1. एक ग्राफिक्स लाइब्रेरी चुनें।

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

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

यह लेख एक साधारण 2D प्लेटफ़ॉर्मर बनाने का तरीका दिखाने के लिए Cocos2D के साथ Python का उपयोग करेगा। कुछ उल्लिखित अवधारणाएं अन्य गेम इंजनों में मौजूद नहीं हो सकती हैं। अधिक जानकारी के लिए उनके दस्तावेज़ देखें।

चरण 2. आपके द्वारा चुनी गई ग्राफिक्स लाइब्रेरी स्थापित करें।

पायथन के लिए Cocos2D स्थापित करना आसान है। आप इसे https://python.cocos2d.org/index.html से प्राप्त कर सकते हैं, या यदि आप Linux का उपयोग कर रहे हैं तो sudo pip3 install cocos2d चलाकर प्राप्त कर सकते हैं।

चरण 3. अपने खेल और मीडिया के लिए एक नई निर्देशिका बनाएं।

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

चरण 4. नई निर्देशिका में एक नई कोड फ़ाइल बनाएँ।

अपनी प्रोग्रामिंग भाषा के लिए फ़ाइल एक्सटेंशन के साथ इसे मुख्य कहें। यदि आप एक बड़ा और जटिल प्रोग्राम लिखते हैं, जहाँ कई प्रोग्राम फ़ाइलों का होना समझ में आता है, तो यह आपको दिखाएगा कि मुख्य फ़ाइल कौन सी है।

इस उदाहरण में, हम main.py नाम की एक फाइल बनाएंगे जिसमें हमारा पूरा कोड होगा।

चरण 5. गेम विंडो बनाएं।

ग्राफिक्स वाले गेम के लिए यह मूल शर्त है।

• आवश्यक cocos2d उप-मॉड्यूल आयात करें: cocos.director, cocos.scene और cocos.layer। यह सबमॉड्यूलनाम आयात * से किया जाता है, जहां उप-मॉड्यूल नाम वह सबमॉड्यूल है जिसे आप आयात करना चाहते हैं। से … आयात * और आयात … के बीच का अंतर यह है कि आपको उस मॉड्यूल से पूर्व के साथ उपयोग की जाने वाली हर चीज के सामने मॉड्यूल का नाम नहीं रखना है।
• ColorLayer के उपवर्ग MainMenuBgr को परिभाषित करें। इसका मूल रूप से मतलब है कि आपके द्वारा बनाई गई कोई भी मुख्य मेनू पृष्ठभूमि आपके द्वारा किए गए कुछ परिवर्तनों के साथ रंग परत की तरह व्यवहार करेगी।
• कोकोस निदेशक शुरू करें। यह आपको एक नई विंडो देगा। यदि आप कोई कैप्शन सेट नहीं करते हैं, तो विंडो में फ़ाइल नाम (main.py) के समान कैप्शन होगा, जो पेशेवर नहीं लगेगा। आकार बदलने योग्य को True पर सेट करके विंडो को आकार बदलने की अनुमति दें।
• एक फ़ंक्शन शोमेनमेनू को परिभाषित करें। आपको मुख्य मेनू को किसी फ़ंक्शन में दिखाने के लिए कोड डालना चाहिए क्योंकि यह आपको फ़ंक्शन को फिर से कॉल करके आसानी से मुख्य मेनू पर वापस जाने की अनुमति देगा।
• एक दृश्य बनाएँ। इस दृश्य में अभी के लिए एक परत है, जो आपके द्वारा परिभाषित MainMenuBgr वर्ग का एक ऑब्जेक्ट है।
• इस दृश्य को विंडो में चलाएँ।

cocos.director से आयात * cocos.scene आयात से * cocos.layer आयात से * वर्ग MainMenuBgr(ColorLayer): def _init_(self): super(MainMenu, self)._init_(0, 200, 255, 255) def showMainMenu(): मेनूएससी = दृश्य (मेनमेनूबीजीआर ()) निदेशक। रन (मेनूएससी) निदेशक।

चरण 6. विंडो में एक मुख्य मेनू जोड़ें।

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

• आयात cocos.menu (फिर से निर्देश के साथ) और pyglet.app (इस बार आयात के साथ)।
• मेनमेनू को मेनू के उपवर्ग के रूप में परिभाषित करें।
• मुख्य मेनू का संरेखण सेट करें। आपको लंबवत और क्षैतिज संरेखण अलग-अलग सेट करना होगा।
• मेनू आइटम की एक सूची बनाएं और उन्हें मेनू में जोड़ें। आपके पास कम से कम मेनू आइटम "स्टार्ट गेम" और "क्विट" होना चाहिए। प्रत्येक मेनू आइटम को कोष्ठक के अंदर रखा जाना चाहिए। प्रत्येक आइटम में एक लेबल और एक कॉलबैक फ़ंक्शन होना चाहिए जो यह निर्धारित करता है कि जब खिलाड़ी उस पर क्लिक करता है तो क्या होता है। "गेम शुरू करें" आइटम के लिए, स्टार्टगेम फ़ंक्शन का उपयोग करें (आप इसे जल्द ही लिखेंगे), "छोड़ें" आइटम के लिए, "pyglet.app.exit" (पहले से मौजूद) का उपयोग करें। Self.create_menu(menuItems) पर कॉल करके वास्तविक मेनू बनाएं।
• स्टार्टगेम () को परिभाषित करें। अभी के लिए परिभाषा में पास डालें, जब आप वास्तविक गेम लिखेंगे तो आप उसे बदल देंगे।
• अपने कोड में उस स्थान पर जाएं जहां आपने मेन्यूएससी दृश्य बनाया है, और इसमें मेनमेनू ऑब्जेक्ट जोड़ें।

• आपका पूरा कोड अब इस तरह दिखना चाहिए:

  cocos.director से आयात * cocos.menu से आयात * cocos.scene आयात से * cocos.layer आयात से * आयात pyglet.app वर्ग MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0), २००, २५५, २५५) वर्ग मेनमेनू (मेनू): def _init _ (स्वयं): सुपर (मेनमेनू, स्वयं)। ", startGame)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) def startGame(): पास def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu ()) Director.run(menuSc) Director.init(caption="IcyPlat - a simple platformer", resizable=True) showMainMenu()
  

चरण 7. अपने कोड का परीक्षण करें।

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

निर्देशों के कोड को "IcyPlat - एक साधारण प्लेटफ़ॉर्मर" शीर्षक वाली एक विंडो खोलनी चाहिए। बैकग्राउंड हल्का नीला है और आप विंडो का आकार बदल सकते हैं। जब आप मेनू पर "स्टार्ट गेम" पर क्लिक करते हैं, तो कुछ भी नहीं होना चाहिए (अभी तक)। जब आप "छोड़ो" पर क्लिक करते हैं, तो विंडो बंद हो जाएगी।

चरण 8. एक स्प्राइट बनाएं।

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

• कोकोस.स्प्राइट सबमॉड्यूल को इम्पोर्ट-एक्सप्रेशन से इंपोर्ट करें।
• स्प्राइट का प्रतिनिधित्व करने के लिए एक छवि खोजें। यदि आपके पास इसके लिए कोई चित्र नहीं है तो आप स्प्राइट प्रदर्शित नहीं कर सकते। आप एक आकर्षित कर सकते हैं, या आप इंटरनेट से एक प्राप्त कर सकते हैं (लाइसेंस के लिए देखें, हालांकि, यदि आप अपना गेम प्रकाशित करने की योजना बना रहे हैं)। इस उदाहरण के लिए, https://opengameart.org/content/tux-classic-hero-style पर जाएं और अपने कंप्यूटर पर पेंगुइन चलाने की-p.webp" />
• स्क्रॉल करने योग्य परत वर्ग की एक नई वस्तु के रूप में एक परत बनाएं। फिर, स्प्राइट को स्प्राइट ऑब्जेक्ट के रूप में बनाएं और इसकी स्थिति (8, 250) पर सेट करें। संदर्भ के लिए, बिंदु (0, 0) निचले बाएँ कोने में है। यह काफी अधिक है, लेकिन यह सुनिश्चित करेगा कि पेंगुइन बर्फ में फंस न जाए।
• स्प्राइट को स्प्राइट की परत में जोड़ें।
• स्प्राइट की परत से एक नया दृश्य बनाएं और इसे चलाएं।

def startGame(): figLayer = ScrollableLayer() fig = Sprite('pingu.png') fig.position = (75, 100) figLayer.add(fig) # gameSc = Scene(figLayer) Director.run(gameSc)

• कोड चलाएँ। क्लिक करने के बाद आपको एक काली पृष्ठभूमि पर पेंगुइन की एक छोटी आकृति (या जो भी आपने बनाई है) दिखाई देनी चाहिए खेल शुरू.

चरण 9. अपने परिदृश्य का सपना देखें।

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

• एक टाइल सेट बनाएं।इस गेम के लिए निर्धारित टाइल बहुत ही बुनियादी होगी: बर्फ के लिए एक टाइल और आकाश के लिए एक टाइल। इस उदाहरण में उपयोग की गई बर्फ की टाइल यहाँ से CC-BY-SA 3.0 के अंतर्गत है।
• एक टाइल सेट चित्र बनाएँ। यह सभी टाइलों की एक तस्वीर है, जो सभी एक ही आकार की होनी चाहिए (यदि वे नहीं हैं तो उन्हें संपादित करें) और एक दूसरे के बगल में, जिस आकार को आप खेल में देखना चाहते हैं। अपनी तस्वीर को IceTiles-p.webp" />

• टाइल सेट विवरण बनाएं। वह एक एक्सएमएल फाइल है। XML फ़ाइल में इस बात की जानकारी होती है कि टाइल सेट चित्र में टाइलें कितनी बड़ी हैं, किस चित्र का उपयोग करना है, और वहां कौन सी टाइल ढूँढनी है। नीचे दिए गए कोड के साथ icyTiles.xml नाम की एक XML फ़ाइल बनाएँ:

चरण 10. अपने परिदृश्य के लिए एक टाइल मानचित्र बनाएं।

एक टाइल नक्शा एक नक्शा है जो परिभाषित करता है कि आपके स्तर पर कौन सी टाइल किस स्थान पर है। उदाहरण में, आपको टाइल के नक्शे बनाने के लिए एक फ़ंक्शन को परिभाषित करना चाहिए क्योंकि हाथ से टाइल के नक्शे को डिजाइन करना बहुत कठिन है। एक अधिक उन्नत गेम में आमतौर पर किसी प्रकार का स्तर संपादक होता है, लेकिन 2D गेम विकास से परिचित होने के लिए, एक एल्गोरिदम पर्याप्त स्तर प्रदान कर सकता है।

• पता करें कि कितनी पंक्तियों और स्तंभों की आवश्यकता है। इसके लिए, स्क्रीन के आकार को टाइल के आकार से क्षैतिज (कॉलम) और लंबवत (पंक्तियों) दोनों में विभाजित करें। संख्या को ऊपर की ओर गोल करें; इसके लिए आपको गणित मॉड्यूल के एक फ़ंक्शन की आवश्यकता है, इसलिए गणित आयात छत से अपने कोड के शीर्ष पर आयात में जोड़ें।
• लिखने के लिए एक फ़ाइल खोलें। यह फ़ाइल की सभी पिछली सामग्री को मिटा देगा, इसलिए ऐसा नाम चुनें जो निर्देशिका में अभी तक किसी भी फ़ाइल में नहीं है, जैसे levelMap.xml।
• फ़ाइल में उद्घाटन टैग लिखें।
• एल्गोरिथम के अनुसार टाइल मैप तैयार करें। आप नीचे दिए गए कोड में से एक का उपयोग करते हैं, या आप स्वयं एक के साथ आ सकते हैं। मॉड्यूल से रैंडिंट फ़ंक्शन को यादृच्छिक रूप से आयात करना सुनिश्चित करें: नीचे दिए गए कोड के काम करने के लिए यह आवश्यक है, और जो कुछ भी आप के साथ आते हैं उसे शायद यादृच्छिक पूर्णांक की भी आवश्यकता होगी। इसके अलावा, अलग-अलग परतों में स्काई टाइल्स और आइस टाइल्स लगाना सुनिश्चित करें: बर्फ ठोस है, आकाश नहीं है।
• फाइल में क्लोजिंग टैग लिखें और फाइल को बंद करें।

def GenerateTilemap (): colAmount = ceil(800/16)*3 # (स्क्रीन की चौड़ाई / टाइल का आकार) * 3 rowAmount = छत (600/16) # स्क्रीन की ऊंचाई / टाइल का आकार टाइलफाइल = ओपन ("लेवलमैप.एक्सएमएल", " w") टाइलफाइल.राइट ('\n\n\n') IceHeight = randint(1, 10) मेरे लिए रेंज में (0, colAmount): टाइलफाइल.राइट ('') मेकहोल = गलत अगर रैंडिंट (0, 50)) == १० और मैं != ०: # स्पॉनपॉइंट पर छेद की अनुमति न दें makeHole = ट्रू j के लिए रेंज में (0, rowAmount): यदि मेकहोल: टाइलफाइल.राइट ('\ n') अन्य: यदि j <= IceHeight: टाइलफाइल.राइट ('\n') और: टाइलफाइल.राइट ('\n') IceHeight = randint (iceHeight-5, IceHeight+5) अगर IceHeight <0: # टाइल्स को बहुत कम जाने से रोकें IceHeight = randint(१, ५) यदि आइसहाइट> रोअमाउंट: # टाइलों को बहुत अधिक बर्फ में जाने से रोकें ('\n\n') के लिए i इन रेंज(0, colAmount): टाइलफाइल.राइट('') j के लिए रेंज में(0, rowAmount): टाइलफाइल.राइट ('\n') टाइलफाइल.राइट ('\ n') टाइलफाइल.राइट ('\n\n') टाइलफाइल.क्लोज ()

चरण 11. टाइल मानचित्र प्रदर्शित करें।

Cocos.tiles से सब कुछ आयात करें और फिर उसके लिए startGame फ़ंक्शन में जाएं।

• अपने startGame फ़ंक्शन की शुरुआत में, उस फ़ंक्शन का उपयोग करके एक टाइल मैप बनाएं जिसे आपने उसके लिए परिभाषित किया था।
• एक नया स्क्रॉलिंग मैनेजर बनाएं। इसे सीधे उस लाइन के नीचे करें जहां आप स्प्राइट को उसकी परत में जोड़ते हैं।
• टाइलों वाली एक नई परत बनाएं, जो आपके जनरेट किए गए जेनरेट टाइलमैप फ़ंक्शन के levelMap.xml टाइल मैप से लोड की जाएगी।
• स्क्रॉलिंग मैनेजर में नॉन-सॉलिड लेयर, सॉलिड लेयर और स्प्राइट लेयर को ठीक इसी क्रम में जोड़ें। आप चाहें तो z- स्थिति जोड़ सकते हैं।
• स्प्राइट लेयर से सीन बनाने के बजाय, इसे स्क्रॉलिंग मैनेजर से बनाएं।

• आपका स्टार्टगेम फ़ंक्शन अब इस तरह दिखना चाहिए:

  def startGame(): GenerateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer() figLayer.add(fig) # टाइललेयर = लोड ('levelMap.xml') सॉलिडटाइल्स = टाइललेयर ['सॉलिड'] एनएसोलीटाइल्स = टाइललेयर ['नॉट_सॉलिड'] # स्क्रैमंग = स्क्रॉलिंगमैनेजर () स्क्रैमंग.एड (एनएसोलीटाइल्स, जेड = -1) स्क्रैमंग.एड (सॉलिडटाइल्स, जेड = 0) स्क्रैमंग। एड (फिगलेयर, जेड) = 1) # गेमएससी = सीन (स्क्रैमंग) निदेशक। रन (गेमएससी)
  

चरण 12. अपने कोड का परीक्षण करें।

आपको यह सुनिश्चित करने के लिए अक्सर अपने कोड का परीक्षण करना चाहिए कि आपके द्वारा लागू की गई नई सुविधाएं वास्तव में काम करती हैं।

उदाहरण में कोड अब पेंगुइन के पीछे कुछ बर्फीले परिदृश्य दिखाना चाहिए। अगर पेंगुइन ऐसा लगता है कि वह बर्फ के ऊपर बहुत दूर मंडरा रहा है, तो आपने कुछ भी गलत नहीं किया और इसे अगले चरण में ठीक कर दिया जाएगा।

चरण 13. नियंत्रण जोड़ें।

टेक्स्ट-आधारित गेम की तुलना में खिलाड़ी के पास 2D गेम में प्रोग्राम के साथ इंटरैक्ट करने के कई और तरीके हैं। जब सही कुंजी दबाया जाता है तो एक आम में उनकी आकृति को स्थानांतरित करना शामिल होता है।

• Cocos.mapcolliders और cocos.actions से सब कुछ आयात करें। pyglet.window से कुंजी भी आयात करें।

• कुछ वैश्विक चर "घोषित" करें। वैश्विक चर कार्यों के बीच साझा किए जाते हैं। आप वास्तव में पायथन में चर घोषित नहीं कर सकते हैं, लेकिन आपको यह कहना होगा कि इसका उपयोग करने से पहले मुख्य कोड में एक वैश्विक चर मौजूद है। आप 0 को मान के रूप में असाइन कर सकते हैं क्योंकि एक फ़ंक्शन बाद में सही मान निर्दिष्ट करने का ध्यान रखेगा। तो आयात अभिव्यक्तियों के तहत जोड़ें:

  # "घोषणा" वैश्विक चर कीबोर्ड = 0 स्क्रैमंग = 0
  

• अपना startGame फ़ंक्शन समायोजित करें:

  • मान लें कि आप वैश्विक चर कीबोर्ड और स्क्रैमंग का उपयोग करते हैं। फ़ंक्शन के शीर्ष पर ग्लोबल कीबोर्ड, स्क्रैमंग लिखकर ऐसा करें।
  • विंडो को कीबोर्ड ईवेंट सुनें।
  • प्लेटफ़ॉर्मर नियंत्रक के आधार पर कार्य करने के लिए आंकड़ा बताएं। आप उस PlatformerController को जल्द ही लागू करेंगे।
  • ठोस टाइलों और आकृति के बीच टकराव को संभालने के लिए मानचित्र कोलाइडर बनाएं।

  def startGame (): वैश्विक कीबोर्ड, स्क्रैमंग जनरेट टाइलमैप () # अंजीर = स्प्राइट ('पिंगु.पीएनजी') अंजीर। स्थिति = (8, 250) अंजीर = स्क्रॉल करने योग्य परत () अंजीर। जोड़ें (अंजीर) # टाइललेयर = लोड ('लेवलमैप.xml') सॉलिडटाइल्स = टाइललेयर ['सॉलिड'] nsoliTiles = टाइललेयर ['not_solिड'] # कीबोर्ड = key. KeyStateHandler() Director.window.push_handlers(keyboard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump) ='स्लाइड') fig.collision_handler = make_collision_handler(mapcollision_handler(mapcollider, सॉलिडटाइल्स) # स्क्रैमंग = स्क्रॉलिंगमैनेजर() scMang.add(nsoliTiles, z=-1) scMang.add (सॉलिडटाइल्स, z=0) scMang.add(figLayer, z= 1) # गेमएससी = सीन (स्क्रैमंग) निदेशक। रन (गेमएससी)
  

• एक प्लेटफ़ॉर्मर नियंत्रक बनाएँ। यह वही है जो आपके कीप्रेस के अनुसार फिगर को मूव करेगा।

  • प्लेटफ़ॉर्मर नियंत्रक को क्रिया के उपवर्ग के रूप में परिभाषित करें।
  • चाल की गति, कूदने की गति और गुरुत्वाकर्षण को परिभाषित करें।
  • प्रारंभ फ़ंक्शन को परिभाषित करें। इस फ़ंक्शन को एक बार कहा जाता है, जब प्लेटफ़ॉर्मर नियंत्रक आकृति से जुड़ा होता है। इसे x और y दोनों दिशाओं में अपनी गति 0 पर सेट करनी चाहिए।
  • स्टेप फंक्शन को परिभाषित करें। सीन के चलने के दौरान इसे दोहराया जाएगा।
  • वैश्विक चर कीबोर्ड और स्क्रैमंग का उपयोग करने के लिए चरण फ़ंक्शन को बताएं।
  • वेग प्राप्त करें और बदलें। x और y वेग को अलग-अलग चरों में सहेजें। एक्स वेग को 1 या -1 पर सेट करें (इस पर निर्भर करता है कि बाएं या दाएं कुंजी को दबाया गया था) चाल की गति से गुणा किया गया। y वेग में गुरुत्वाकर्षण जोड़ें। इसे डाउनटाइम से गुणा करें ताकि यह धीमे उपकरणों पर उसी तरह काम करे। यदि स्पेस कुंजी को दबाया जाता है और आकृति जमीन पर खड़ी होती है, तो y वेग को कूदने की गति में बदलकर कूदें।
  • गणना करें कि आंकड़ा कहाँ जाना चाहिए। फिर टक्कर हैंडलर को उस स्थिति को समायोजित करने दें यदि वह एक ठोस टाइल के अंदर है। अंत में, आकृति को नई समायोजित स्थिति में ले जाएं।
  • स्क्रॉलिंग मैनेजर का फोकस फिगर पर सेट करें। यह कैमरे को एक उचित तरीके से स्थानांतरित करने का कारण बनता है जब आंकड़ा चलता है।

  क्लास प्लेटफ़ॉर्मरकंट्रोलर (एक्शन): ग्लोबल कीबोर्ड, स्क्रैमंग ऑन_ग्राउंड = ट्रू MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 डिफ स्टार्ट (सेल्फ): सेल्फ.टारगेट। वेलोसिटी = (0, 0) डीईएफ़ स्टेप (सेल्फ, डीटी): ग्लोबल कीबोर्ड, स्क्रोलर अगर डीटी> 0.1: # डाउनटाइम के दौरान बड़े रिटर्न के लिए कुछ भी न करें vx, vy = self.target.velocity vx = (कीबोर्ड [की। राइट] - कीबोर्ड [की। लेफ्ट]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground और कीबोर्ड [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y += dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(*new.center)
  

चरण 14. अपने कोड का परीक्षण करें।

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

चरण 15. खेल के लिए एक अंत बनाएँ।

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

• प्लेटफ़ॉर्मर नियंत्रक के अंदर, फ़ोकस सेट करने के बाद, आकृति की x और y स्थिति प्राप्त करें। यदि y स्थिति 0 से कम है, तो फ़ंक्शन फिनिशगेम() (आप इसे बाद में लिखेंगे) को तर्क के रूप में "गेम ओवर" के साथ कॉल करें। यदि x स्थान स्क्रीन के आकार से बड़ा है तो 3 से गुणा करें (आपने इसे पहले स्तर के आकार के रूप में सेट किया था)।

  posX, posY = self.target.position अगर posY <0: फिनिशगेम ("गेम ओवर") रिटर्न अगर पॉज़> 800 * 3: # लेवल साइज फिनिशगेम ("लेवल कम्प्लीट") रिटर्न
  

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

  क्लास फिनिशमेनू (मेनू): डीईएफ़ _init_ (सेल्फ, टेक्स्ट): सुपर (फिनिशमेनू, सेल्फ)। (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems)
  

• फंक्शन फिनिशगेम () को परिभाषित करें। इसे तर्क के रूप में पाठ लेना चाहिए। इसे मुख्य मेनू पृष्ठभूमि से एक दृश्य बनाना चाहिए, इस मेनू पर टेक्स्ट तर्क के साथ एक फिनिशमेनू। फिर उसे यह सीन चलाना चाहिए।

  डीईएफ़ फिनिशगेम (टेक्स्ट): मेन्यूएससी = सीन (मेनमेनूबीजीआर ()) मेन्यूएससी.एड (फिनिशमेनू (टेक्स्ट)) डायरेक्टर.रन (मेनूएससी)
  

चरण 16. क्रेडिट जोड़ें।

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

• क्रेडिट फ़ाइल बनाएं और वहां अपने सभी क्रेडिट दर्ज करें, इस तरह:

  पेंगुइन: केल्विन शैड्यूइंग, CC0 आइस ब्लॉक के तहत: Michał बनास digit1024 opengameart.org पर CC-BY-SA 3.0 के तहत
  

• अपने पायथन कोड पर वापस जाएं और cocos.text से लेबल आयात करें।

• परत के उपवर्ग क्रेडिट को परिभाषित करें। इसके _init_ फ़ंक्शन में, CREDITS फ़ाइल पढ़ें और इसमें प्रत्येक पंक्ति से सही स्थिति में एक टेक्स्ट लेबल बनाएं।

  वर्ग क्रेडिट (परत): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n ") के लिए मैं रेंज में (0, लेन (क्रेडिट)): क्रेडिट लेबल = लेबल (क्रेडिट , font_size = 32, एंकर_x = "बाएं", एंकर_वाई = "शीर्ष") क्रेडिट लेबल। स्थिति = 25, 500- (i +1)*40 स्वयं जोड़ें (क्रेडिट लेबल)
  

• अपने मुख्य मेनू वर्ग पर जाएं और "क्रेडिट" लेबल वाला एक मेनू आइटम जोड़ें जो क्लिक किए जाने पर फ़ंक्शन शो क्रेडिट को कॉल करता है।

• मेनू के उपवर्ग BackToMainMenuButton को परिभाषित करें। इसे "बैक" लेबल वाले एक आइटम के साथ एक मेनू बनाएं, जो शोमेनमेनू फ़ंक्शन को कॉल करता है। यह "मेनू", जो एक बटन की तरह अधिक है, नीचे की ओर लंबवत और ऊपर से क्षैतिज रूप से संरेखित होना चाहिए।

  वर्ग BackToMainMenuButton(Menu): def _init_(self): super(BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self. create_menu (मेनू आइटम)
  

• फ़ंक्शन शो क्रेडिट को परिभाषित करें। इसे MainMenuBgr परत और क्रेडिट परत से एक दृश्य बनाना चाहिए और उस दृश्य को चलाना चाहिए।

  डीईएफ़ शो क्रेडिट (): क्रेडिटस्क = सीन (मेनमेनूबीजीआर ()) क्रेडस्क.एड (क्रेडिट ()) क्रेडिटएससी.एड (बैकटोमेनमेनूबटन ()) निदेशक। रन (क्रेडएससी)
  

चरण 17. अपना कोड जांचें।

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

कोकोस.डायरेक्टर से आयात * कोकोस से।.पाठ्य आयात लेबल आयात pyglet.app pyglet से। self)._init_(0, 200, 255, 255) वर्ग मेनमेनू(मेनू): def _init_(self): सुपर(मेनमेनू, सेल्फ)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Start Game", startGame)), (MenuItem("Credits", ShowCredits)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) Class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n") for i in range (0, लेन (क्रेडिट)): क्रेडिट लेबल = लेबल (क्रेडिट , फॉन्ट_साइज = 32, एंकर_एक्स = "बाएं", एंकर_वाई = "टॉप") क्रेडिट लेबल। स्थिति = 25, 500- (i + 1) * 40 स्वयं जोड़ें (क्रेड लेबल) वर्ग बैकटोमेनमेनू बटन (मेनू): डीईएफ़ _init_ (स्वयं): सुपर (BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self.create_menu(menuItems) class FinishMenu(Menu): def _init_(स्वयं, पाठ): सुपर (फिनिशमेनू, स्वयं)। app.exit))] self.create_menu(menuItems) class PlatformerController(Action): ग्लोबल कीबोर्ड, स्क्रैमंग ऑन_ग्राउंड = ट्रू MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 डीईएफ़ स्टार्ट (सेल्फ): self.target.velocity = (0, ०) डीईएफ़ स्टेप (सेल्फ, डीटी): ग्लोबल कीबोर्ड, स्क्रोलर अगर डीटी> ०.१: # डाउनटाइम बहुत बड़ा रिटर्न करते हुए कुछ भी न करें vx, vy = self.target.velocity vx = (कीबोर्ड [की। राइट] - कीबोर्ड [कुंजी.बाएं]) *स्वयं. MOVE_SPEED vy += self. GRAVITY * dt if self.on _ग्राउंड और कीबोर्ड [की.स्पेस]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y + = डाई self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(* new.center) posX, posY = self.target.position अगर posY <0: फिनिशगेम ("गेम ओवर") posX> 800 * 3: # लेवल साइज फिनिशगेम ("लेवल कम्प्लीट") रिटर्न डिफ फिनिशगेम (टेक्स्ट): मेन्यूएससी = सीन (मेनमेनूबीजीआर ()) मेन्यूएससी.एड (फिनिशमेनू (टेक्स्ट)) डायरेक्टर। रन (मेनूएससी) डेफ शो क्रेडिट्स (): क्रेडिटस्क = सीन (मेनमेनूबीजीआर ()) क्रेडिटएससी.एड (क्रेडिट ()) क्रेडिटएससी।)) Director.run(credSc) def GenerateTilemap(): colAmount = ceil(800/16)*3 # (स्क्रीन चौड़ाई / टाइल आकार) * 3 rowAmount = छत (600/16) # स्क्रीन ऊंचाई / टाइल आकार टाइलफाइल = खुला ("levelMap.xml", "w") टाइलफाइल.राइट ('\n\n\n') IceHeight = randint(1, 10) के लिए i रेंज में (0, colAmount): टाइलफाइल.राइट ('') मेकहोल = असत्य अगर रैंड int(0, ५०) == १० और i != ०: # स्पॉनपॉइंट पर छेद की अनुमति न दें मेकहोल = ट्रू j के लिए रेंज में (0, रोअमाउंट): अगर मेकहोल: टाइलफाइल.राइट ('\ n') और: अगर j <= IceHeight: टाइलफाइल.राइट ('\n') और: टाइलफाइल.राइट ('\n') iceHeight = randint(iceHeight-5, IceHeight+5) अगर IceHeight <0: # टाइल्स को भी जाने से रोकें कम बर्फ की ऊंचाई = रैंडिंट (1, 5) अगर बर्फ की ऊंचाई> पंक्ति राशि: # टाइल को बहुत अधिक बर्फ से जाने से रोकें ') टाइलफाइल.राइट ('\ n / n') के लिए i रेंज में (0, colAmount): टाइलफाइल.राइट ('') j इन रेंज (0, रोअमाउंट) के लिए: टाइलफाइल। राइट ('\ n') टाइलफाइल.लिखें ('\ n') टाइलफाइल.राइट ('\ n / n') टाइलफाइल। क्लोज () डीईएफ़ स्टार्टगेम (): वैश्विक कीबोर्ड, स्क्रैमंग जनरेट टाइलमैप () # अंजीर = स्प्राइट ('पिंगु.पीएनजी') अंजीर। स्थिति = (8, 250) figLayer = स्क्रॉल करने योग्य लेयर () figLayer.add(fig) # टाइललेयर = लोड ('levelMap.xml') सॉलिडटाइल्स = टाइललेयर['सॉलिड'] nsoliTiles = टाइललेयर['not_solid'] # कीबोर्ड = key. KeyStateHandler () निदेशक.विंडो.पुश_हैंडलर (कीबो) ard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump='slide') fig.collision_handler = make_collision_handler(mapcollider, सॉलिडटाइल्स) # स्क्रैमंग = स्क्रॉलिंगमैनेजर () scMang.add(nsoliTiles, z=-1) scrMang.add(nsoliTiles, z=-1) जोड़ें (सॉलिडटाइल्स, जेड = 0) स्क्रूमैंग.एड (फिगलेयर, जेड = 1) # गेमएससी = सीन (स्क्रैमंग) डायरेक्टर। रन (गेमएससी) डीईएफ़ शोमेनमेनू (): मेन्यूएससी = सीन (मेनमेनूबीजीआर ()) मेन्यूएससी.एड (मेनमेनू))) Director.run(menuSc) window =director.init(caption="IcyPlat - a simple platformer", resizable=True) showMainMenu()

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

चरण 18. समाप्त।

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

3 का भाग 3: एक गेम प्रकाशित करना

चरण 1. निर्भरताएँ लिखिए।

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

चरण 2. सुनिश्चित करें कि आपके पास सभी मीडिया का उपयोग करने की अनुमति है।

यह 3D मॉडल, संगीत, संवाद, संगीत, लाइब्रेरी, और आपके गेम के लिए आपके द्वारा उपयोग किए गए फ़्रेमवर्क सहित सभी ग्राफ़िक्स पर लागू होता है। जो कुछ भी आपने खुद नहीं लिखा।

• अक्सर कुछ शर्तें होती हैं, जैसे लेखक को श्रेय देना या उसी लाइसेंस के तहत मीडिया के संशोधनों को साझा करना। कभी-कभी जब तक आप गेम के लिए शुल्क नहीं लेते, तब तक आप क्रिएटर्स को एट्रिब्यूट किए बिना ग्राफ़िक्स का उपयोग कर पाएंगे। यदि आपको लेखक को श्रेय देना है, तो इसे अपने खेल में "क्रेडिट" टैब की तरह एक अच्छी तरह से दिखाई देने वाली जगह पर करें।
• कॉपीराइट का दावा करने वाला मीडिया भी है और कोई लाइसेंस निर्दिष्ट नहीं है, कभी-कभी "सर्वाधिकार सुरक्षित" जैसे कुछ पाठ के साथ।अगर ऐसा है, तो आपको इसे अपने गेम में शामिल करने से पहले लेखक से स्पष्ट अनुमति लेनी होगी।
• पुस्तकालय आमतौर पर लाइसेंस के तहत जारी किए जाते हैं जो उन्हें पुस्तकालय के रूप में उपयोग करने की अनुमति देते हैं। अपवाद को जोड़ने के बिना जीपीएल एक उल्लेखनीय अपवाद है: ऐसा लाइसेंस केवल कुछ लाइसेंस वाले प्रोग्राम में इसका उपयोग करने की अनुमति देता है। और यह सुनिश्चित करने के लिए कि आप मीडिया या पुस्तकालय के साथ जो कुछ भी कर रहे हैं, उसकी अनुमति है, आपको हमेशा लाइसेंस के कम से कम बुनियादी बिंदुओं को पढ़ना चाहिए।

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

चरण 3. उन शर्तों पर निर्णय लें जिन पर आप अपना गेम प्रकाशित करना चाहते हैं।

क्या आप अपना खेल बेच रहे होंगे? क्या आप दूसरों को अपनी छवियों और विचारों का उपयोग करने की अनुमति देना चाहते हैं? जबकि आपको अपने प्रोजेक्ट में उपयोग किए जाने वाले मीडिया के बारे में सावधान रहना होगा, आप आमतौर पर यह तय कर सकते हैं कि आप दूसरों को अपने गेम का उपयोग करने की अनुमति कैसे देना चाहते हैं। आप अपने गेम को सार्वजनिक डोमेन में रिलीज़ करने के लिए Creative Commons CC0 लाइसेंस का उपयोग कर सकते हैं। कुछ अधिकारों को बनाए रखते हुए कुछ शर्तों के तहत वितरण और संशोधन की अनुमति देने के लिए, Gnu जनरल पब्लिक लाइसेंस (GPL) या बर्कले सॉफ़्टवेयर वितरण (BSD) लाइसेंस आज़माएं। या, आप अपने सॉफ़्टवेयर को मालिकाना बना सकते हैं, जिसका अर्थ है कि किसी को भी आपकी अनुमति के बिना इसे वितरित या संशोधित करने की अनुमति नहीं है।

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

चरण 4. तय करें कि आप अपना गेम कैसे प्रकाशित करना चाहते हैं।

हर तरीके के कुछ फायदे और नुकसान होते हैं, इसलिए आपको खुद फैसला करना होगा।

• इसे एक वेबसाइट पर प्रकाशित करना:

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

• पैकेज मैनेजर के लिए पैकेज बनाना:

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

चरण 5. सीधे अपने कार्यक्रम पर ध्यान दें।

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

टिप्स

• धैर्य रखें और सीखने के लिए तैयार रहें। प्रोग्रामिंग कई बार निराशाजनक हो सकती है!
• यदि आपको आश्चर्य है कि किसी अन्य गेम में कुछ कैसे किया जाता है, और गेम ओपन-सोर्स है, तो आप इसके स्रोत कोड को देख सकते हैं।
• मीडिया की तलाश करते समय, सार्वजनिक डोमेन में मौजूद सामग्री को खोजने का प्रयास करें। "क्रिएटिव कॉमन्स" या "पब्लिक डोमेन" छवियों और संगीत के लिए खोजें, और https://opengameart.org या https://publicdomainPictures.net जैसी वेबसाइटों का उपयोग करें।
• लाइसेंस की जांच किए बिना कोड के बड़े हिस्से को कॉपी न करें। यह अक्सर निषिद्ध है, और यदि नहीं, तो आमतौर पर एट्रिब्यूशन की आवश्यकता होती है।
• अपने गेम का प्रचार करते समय अनुचित स्थानों पर स्पैम या पोस्ट न करें। यह आपको पेज से ब्लॉक कर सकता है, बस कष्टप्रद है, और आपकी प्रतिष्ठा को नुकसान पहुंचाएगा।