🌋 🏇 👨🏿‍⚖️ जैसा कि मैंने Pacman लिखा है, और इसके बारे में क्या आया। भाग 1 🤧 👨🏿‍💻 🕵🏾

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

पैमाना क्यों?

इस प्रश्न का उत्तर काफी सरल है, और शायद पाठकों में से एक ने पहले ही विचारों में झिलमिला दिया है। हां, यह सही है, यह ZeptoLab के लिए एक परीक्षण मामला था। इस असाइनमेंट की आवश्यकताओं से, विकास में उपयोग किए जाने वाले उपकरण भी स्पष्ट हैं: Android NDK, C ++, OpenGL।

Pacman: शुरुआत

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

पहली चीज जो मैंने स्थापित की थी, वह एनडीके (इंस्टॉलेशन कई प्रकार के संसाधनों पर आधारित है, विदेशी और रनवे दोनों पर विस्तृत है) और इसके वितरण से कई उदाहरण लॉन्च किए गए: पहला, GL2JNI उदाहरण, और दूसरा सैन सेंजेल्स। पहला OpenGL ES 2.0 का उपयोग करके एक त्रिभुज खींचता है, दूसरा OpenGL ES का उपयोग करके प्राइमेट से इकट्ठे एक 3D फिल्म दिखाता है। पहली नज़र में कोड डरावना लगता है। हाँ, और दूसरा भी। दरअसल, GL2JNI प्रोजेक्ट की gl_code.cpp फाइल मेरे लिए शुरुआती बिंदु थी।

OpenGL ES 2.0 क्यों?

बेशक, एक साधारण 2 डी गेम के लिए, ओपनजीएल ईएस स्थिर पाइपलाइन पर्याप्त है, कोई शेड की आवश्यकता नहीं है, यह सब क्यों? जवाब: मैं कोशिश करना चाहता था। कंप्यूटर ग्राफिक्स पर प्रयोगशाला के काम में, शेड्स को छूना संभव नहीं था, तो क्यों नहीं पकड़ा गया?

ओपनजीएल ईएस 2.0 का अध्ययन यहां से शुरू हुआ, हब्बरब्र के साथ, लेख के अनुवाद के साथ सभी ओपनगेल ईएस 2.x के बारे में - (भाग 1/3) । दुर्भाग्य से, मैं अब अनुवाद नहीं खोज सकता, शायद लेखक ने इसे मसौदा प्रतियों में डाल दिया है। लेख के लेखक iOS के संबंध में OpenGL ES 2.x के बारे में बात करते हैं, लेकिन लगभग सभी Android के लिए सच है। रूसी में पहले भाग को पढ़ने और यह महसूस करने के बाद कि यह पर्याप्त नहीं है, मैं अंग्रेजी-भाषा के संसाधनों (मुख्य रूप से उपरोक्त लेख के भाग 2 और 3, लेकिन अन्य स्रोतों का भी उपयोग करता हूं) पर पहुंच गया, जहां मुझे ओपनजीएल ईएस 2.0 पर सभी ज्ञान मिला, जो बाद में उपयोग किया गया था ।

यह एक स्क्रीनशॉट के लिए समय है

यह मेरे भविष्य के खेल के पहले स्क्रीनशॉट में से एक है। पहले वाले सभी प्रकार के स्क्रीन थे, त्रिकोण और रस्तमण त्रिकोण के साथ प्रशस्त, काल्पनिक रूप से बदलते रंग।
इस प्रतीत होता है आदिम स्क्रीनशॉट में क्या देखा जा सकता है? पर्याप्त है:

लोड हो रहा है बनावट। हां, यह महत्वपूर्ण है, यह एक बड़ा कदम था;
मानचित्र। यह है, उस पर दीवारें, भोजन और खाली जगह प्रतिष्ठित हैं;
जीयूआई। निचले बाएँ कोने में एक बटन दिखाई देता है। हां, यह पहला बटन था।

प्रत्येक आइटम के लिए विवरण:

बनावट लोड हो रहा है

Android NDK में बनावट लोडिंग कई मायनों में संभव है:

एपीके संसाधन फ़ाइलों को सीधे एक्सेस करने के लिए libpng और libzip का उपयोग करें;
AAssetManager का उपयोग करें, फ़ाइल पढ़ें और मैन्युअल रूप से चित्र के रूप में इसकी सामग्री की व्याख्या करें;
Android.graphics.Bitmap पर पहुंचने के लिए jni का उपयोग करें।

शायद अभी भी तरीके हैं, लेकिन मैंने उन्हें नहीं पाया है। तीसरा विकल्प सबसे स्वीकार्य लगा; मैंने इसे लागू किया।

जावा कोड का एक बिट

import android.content.res.AssetManager; import android.graphics.Bitmap; import android.graphics.BitmapFactory; /*   Bitmap,       jni*/ public class PngManager { private AssetManager amgr; public PngManager(AssetManager manager){ amgr = manager; } public Bitmap open(String path){ try{ return BitmapFactory.decodeStream(amgr.open(path)); }catch (Exception e) { } return null; } public int getWidth(Bitmap bmp) { return bmp.getWidth(); } public int getHeight(Bitmap bmp) { return bmp.getHeight(); } public void getPixels(Bitmap bmp, int[] pixels){ int w = bmp.getWidth(); int h = bmp.getHeight(); bmp.getPixels(pixels, 0, w, 0, 0, w, h); } public void close(Bitmap bmp){ bmp.recycle(); } }

C ++ कोड का एक बिट

 /*    */ struct Texture{ char* pixels; /*should be allocated with new[width*height*4]; RGBA*/ int width; int height; Texture(): pixels(NULL), width(0), height(0){} Texture(char* p, int w, int h): pixels(p), width(w), height(h){}; ~Texture(){ if(pixels){ delete[] pixels; pixels = NULL; } } }; /* ,     .    jni  Java */ void Art::init(JNIEnv* env, jint _screenWidth, jint _screenHeight, jobject _pngManager, jobject javaAssetManager){ LOGI("Art::init"); free(env); /*  - */ pngManager = env->NewGlobalRef(_pngManager); pmEnv = env; pmClass = env->GetObjectClass(pngManager); pmOpenId = env->GetMethodID(pmClass, "open", "(Ljava/lang/String;)Landroid/graphics/Bitmap;"); pmCloseId = env->GetMethodID(pmClass, "close", "(Landroid/graphics/Bitmap;)V"); pmGetWidthId = env->GetMethodID(pmClass, "getWidth", "(Landroid/graphics/Bitmap;)I"); pmGetHeightId = env->GetMethodID(pmClass, "getHeight", "(Landroid/graphics/Bitmap;)I"); pmGetPixelsId = env->GetMethodID(pmClass, "getPixels", "(Landroid/graphics/Bitmap;[I)V"); /*...*/ } /* jni     */ Texture* Art::loadPng(const char* filename){ LOGI("Art::loadPng(%s)", filename); Texture* result = new Texture(); jstring name = pmEnv->NewStringUTF(filename); jobject png = pmEnv->CallObjectMethod(pngManager, pmOpenId, name); pmEnv->DeleteLocalRef(name); pmEnv->NewGlobalRef(png); jint width = pmEnv->CallIntMethod(pngManager, pmGetWidthId, png); jint height = pmEnv->CallIntMethod(pngManager, pmGetHeightId, png); jintArray array = pmEnv->NewIntArray(width * height); pmEnv->NewGlobalRef(array); pmEnv->CallVoidMethod(pngManager, pmGetPixelsId, png, array); jint *pixels = pmEnv->GetIntArrayElements(array, 0); result->pixels = argb2rgba((unsigned int*)pixels, width, height); result->width = width; result->height = height; pmEnv->ReleaseIntArrayElements(array, pixels, 0); pmEnv->CallVoidMethod(pngManager, pmCloseId, png); return result; }

Art क्लास में रुकने लायक है। स्थैतिक विधियों और सदस्यों के साथ इस वर्ग के लिए विचार Notch (उनके ओपन सोर्स गेम्स में से) से लिया गया था, जैसा कि कक्षा का नाम था। यह कला से संबंधित सभी चीजों को संग्रहीत करता है: बनावट, संगीत, आवाज़, आदि। कक्षा में स्थिर तरीके init(), free(), getTexture(int id) और init(), free(), getTexture(int id) एक init(), free(), getTexture(int id) ।

यह नक्शे

विकास की शुरुआत से, मैं इस बारे में सोच रहा था कि लोडिंग स्तरों के लिए एक तंत्र कैसे बनाया जाए। "हार्डकोड" और "टेक्स्ट फ़ाइल से पढ़ा" विकल्प दिमाग में आते हैं। यह, निश्चित रूप से, संभव है, लेकिन तब कार्ड के किसी भी आसान संपादन के बारे में बात करने की आवश्यकता नहीं है। स्तर के संपादक के बारे में विचार दिमाग में आते हैं, हाल ही में मैंने एक स्वादिष्ट लेख देखा ... नहीं! तो जंगल के वृक्ष दिखाई नहीं पड़ेंगे। मैं खुद को याद दिलाता हूं कि लक्ष्य पचमन और जितनी जल्दी हो सके काम कर रहा है।
लेकिन मैं सिर्फ png डाउनलोड करना सीख गया! विभिन्न रंगों के पिक्सेल दीवारों की कोशिकाओं, भोजन, खाली जगह, पैकमैन आदि को दर्शाते हैं। और पेंट एक स्तर संपादक के रूप में काफी उपयुक्त है। कार्ड का आकार अलग-अलग हो सकता है, 32x32 तक।
यह दृष्टिकोण 100% ही साबित हुआ है। मुझे बहुत आसानी से लगभग मुफ्त में संपादन योग्य स्तर मिल गया।

जीयूआई

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

एक मूल अमूर्त वर्ग है IRenderable , जिसमें से Control विरासत में मिला है, जिसमें से Label, Button, CheckBox और Menu ( Contro एक सूची को Contro ) विरासत में मिले हैं। अन्य सभी मेनू ( Pause/Game/GameOver , आदि) Menu से विरासत में मिले हैं। वे सभी करने की आवश्यकता है - बनाते समय, नियंत्रण ( Button, Label , आदि) की एक सूची निर्धारित करें जो मेनू सक्रिय होने पर दिखाई देगी। इसके अलावा, वे घटनाओं के लिए अपनी प्रतिक्रिया निर्धारित कर सकते हैं (उदाहरण के लिए, GameMenu स्वाइप को ट्रैक करता है)। render() पद्धति पिछले एक से प्रत्येक अगली कक्षा को बुलाती है।
इसके अलावा, एक Engine वर्ग है जो खेल के वैश्विक तर्क के लिए जिम्मेदार है। डाउनलोड करें, मेनू के बीच स्विच करें, उपयोगकर्ता कार्यों के बारे में संदेश प्राप्त करें, आदि। इसमें Menu* currentMenu , जिसे वह उपयोगकर्ता की कार्रवाई के लिए प्रतिक्रिया के लिए कहता है। Engine भी Menu::onShow() कहता है।

खेल तर्क

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

StupidMonster और StupidMonster , newDirectionEvent() विधि द्वारा परिभाषित उनके व्यवहार में भिन्न हैं: StupidMonster बेतरतीब ढंग से भूलभुलैया के माध्यम से चलता है, Pacman 'a पर ध्यान नहीं देता। CleverMonster सबसे इष्टतम मार्ग पर CleverMonster पीछा कर रहा है। इस बिंदु पर, मैंने वास्तव में एक साइकिल को लागू किया, जिसे वैज्ञानिक रूप से "रणनीति" डिजाइन पैटर्न कहा जाता है

सबसे अच्छा तरीका के लिए खोजें।

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

समय पर हर पल एक रास्ता खोजने के लिए एल्गोरिथ्म:

Pacman (pX, pY) के निर्देशांक का पता लगाएं;
निर्देशांक पर नक्शे की सरणी देखें: नक्शे [pX, pY];
- यदि संबंधित मानचित्र अभी तक नहीं बना है (NULL), तो चरण 3 पर जाएं;
- अन्यथा चरण 5 पर जाएं
मूल के समान आकार का एक मानचित्र बनाएं, नक्शे में सहेजें [pX, pY];
सेल (pX, pY) से शुरू करते हुए, लहर एल्गोरिथ्म का उपयोग करके, बनाए गए नक्शे को पूरी तरह से भरें;
नक्शे के नक्शे के आधार पर एक पथ बनाएं [pX, pY];

एक ही मार्गों को बार-बार नहीं गिनने के लिए इन ट्रिक्स की जरूरत होती है। सभी स्मार्ट राक्षस एक ही कार्ड का उपयोग करते हैं। प्रत्येक नक्शा एक बार से अधिक नहीं बनाया गया है। बहुत सारे कार्ड कभी भी नहीं बनाए जाते हैं (क्योंकि पीकमान दीवारों के माध्यम से नहीं चल सकता है)।
सबसे खराब स्थिति में 20x20 कोशिकाओं को मापने वाली दीवारों के बिना एक कार्ड के लिए, 20 * 20 * 20 * 20 * 4 = 640,000 बाइट्स या 625 किलोबाइट मेमोरी का उपयोग किया जाएगा। वास्तव में, यह संख्या दीवारों की उपस्थिति के कारण बहुत छोटी है।

पहले भाग का परिणाम

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

यह परियोजना सार्वजनिक रूप से जीथब पर उपलब्ध है।
~~और Google Play Market~~ लिंक में हटा दिया गया है ताकि प्रोफाइल हब में कोई विज्ञापन न हो।

दूसरे भाग का लिंक

जैसा कि मैंने Pacman लिखा है, और इसके बारे में क्या आया। भाग 1