जैसा कि मैंने Android पर Bomberman लिखा है

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

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

छोटा विषयांतर

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

आर्किटेक्चर

वास्तुकला के लिए, यह मुझे प्रतीत हुआ कि एमवीसी सबसे उपयुक्त है। मैंने पहले ही वास्तुकला के बारे में एक लेख में इस बारे में बात की थी।

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

दृश्य के रूप में, हमारे पास स्क्रीन और इनपुटप्रोसेसर इंटरफेस (उनके बीच, बॉम्बर मैन वर्ग स्विच) को लागू करने वाली कक्षाएं हैं। कक्षा में, हम उपयोगकर्ता कार्यों को संसाधित करते हैं और वस्तुओं को प्रस्तुत करते हैं। वस्तुओं को बदलना और बाद में प्रतिपादन इस वर्ग की एक विधि में होता है। सबसे पहले, वस्तुओं की स्थिति को बदलें, यदि आवश्यक हो (मोटे तौर पर बोलकर, हम भौतिकी के साथ काम करते हैं), और फिर प्रस्तुत करें:

 @Override public void render(float delta) { controller.update(delta); renderer.render(); } 

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

 public void update(float delta) { processInput(); checkBombsTimer(); if(!world.bonus) destroyBricks(); removeDeadNpc(); killByBoom(); removeHiddenObjects(); bomberman.update(delta); for(NpcBase npc : world.getNpcs()){ npc.update(delta); } removeBooms(); } 

मॉडल की व्याख्या करने के लिए, मुझे लगता है कि आरेख प्रदान करना आसान है:


World एक कंटेनर है जिसमें सभी ऑब्जेक्ट शामिल हैं: ब्लॉक, बोनस, प्लेयर, एनपीसी। इसमें कोई तर्क नहीं है। केवल वस्तुओं में ही उनके लिए तर्क का एक हिस्सा है (जैसा कि मैंने ऊपर लिखा है)। मैंने पूरी क्लास का आरेख नहीं दिया।
सभी npc प्रकार NpcBase से विरासत में मिलते हैं। HiddenObject से सभी ऑब्जेक्ट्स (दरवाजा, बोनस)।

प्रोटोटाइप

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

तो:
1) बहुत बड़े एटलस न बनाएं।
2) आयाम दो की शक्ति होना चाहिए।

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

अधिकांश वस्तुओं में पूर्णांक निर्देशांक होते हैं, और वे इतनी बार नहीं बदलते हैं। एक सरणी public int[][] map परिभाषित किया और वस्तुओं की सूचियों को लगातार नहीं चलाने के लिए इसे एक्सेस किया। लब्बोलुआब यह है कि सभी ब्लॉक पूर्णांक निर्देशांक पर हैं, इसलिए सरणी का उपयोग करके चीजों को गति देने में मदद मिली है। जब हम भौतिकी को अद्यतन करते हैं, तो हम बस खिलाड़ी / npc से उसके आस-पास की वस्तुओं की दूरी को देखते हैं।
कुछ इस तरह:

 if(around[0][1] ==0 && Math.abs(getPosition().x-x1)<SIZE/2 && Math.abs(getPosition().x-x1)>0.05){ if(getPosition().x-x1<0){ getVelocity().x = +speed; getVelocity().y = +speed; } if(getPosition().x-x1>0){ getVelocity().x = -speed; getVelocity().y = +speed; } } 

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

एनपीसी

जब मैंने बनावट और टकराव से निपटने के बारे में सोचा, तो मैंने खेल में npc जोड़ा। संक्षेप में, उनके पास व्यवहार की केवल तीन रणनीतियाँ हैं:
1) एक यादृच्छिक दिशा में ले जाएँ। एक निश्चित समय के बाद, वे दिशा को यादृच्छिक में बदल देते हैं।
2) एक पूरे के रूप में पहले की तरह। लेकिन, अगर npc खिलाड़ी को देखता है, तो वह उसकी ओर बढ़ना शुरू कर देता है। यदि खिलाड़ी देखने के क्षेत्र से गायब हो जाता है, तो एनपीसी आंदोलन की दिशा को यादृच्छिक रूप से बदल देता है।
3) सामान्य तौर पर, दूसरी रणनीति के रूप में। लेकिन अगर वह खिलाड़ी की दृष्टि खो देता है, तब भी वह उस दिशा में जाता है जहां उसने अंतिम बार खिलाड़ी को देखा था।

सभी प्रकार की npc NpcBase से विरासत में मिली हैं और उन्हें विधियों को लागू करना चाहिए:

 public abstract void changeDirection(float delta); public abstract void update(float delta) ; 

जीयूआई

GUI को LibGDX का उपयोग करके भी लागू किया जाता है। सभी इंटरफ़ेस तत्वों को कक्षाओं के रूप में प्रस्तुत किया जाता है, जिनमें से उदाहरण World वर्ग में निहित हैं। प्रत्येक तत्व के गुणों में अपने निर्देशांक और आकार होते हैं, जो हमें स्क्रीन पर टेपों के साथ यह निर्धारित करने की अनुमति देता है कि उपयोगकर्ता वास्तव में किस तत्व पर क्लिक करता है।

दो नियंत्रण विधियों को लागू किया गया:
1) तीर।

2) जॉयस्टिक।


सेटिंग्स में आप इच्छित वस्तुओं की स्थिति निर्धारित कर सकते हैं:

परिणाम

एक पोस्ट में पूरी विकास प्रक्रिया फिट नहीं बैठती है। मुझे लगा कि शायद लोग स्वयं इस लेख के लिए किसी विषय का प्रस्ताव रखेंगे यदि वे इस इंजन में रुचि रखते हैं। मैं आपको LibGDX के साथ काम करते समय विकास के कुछ सबसे दिलचस्प पहलुओं या सबसे दिलचस्प बिंदुओं के बारे में बताऊंगा।

मैंने गीथूब पर सूत्रों को अपलोड किया।
यदि आप किसी को इस इंजन के साथ काम करना चाहते हैं, तो आप LibGDX पर मेरे पाठ भी देख सकते हैं।