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

विचार

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

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

सुविधा की सूची

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

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

डिज़्डोकी

तो कैसे बनाएं नया खेलइस दस्तावेज़ के बिना यह लगभग असंभव है, आपको इस पर भी काम करना होगा। Dizdok "डिज़ाइन दस्तावेज़" का संक्षिप्त नाम है, इसमें सबसे विस्तृत विवरण शामिल हैं:

• ऑब्जेक्ट मॉडल और इकाई कार्यक्षमता।
• कार्यात्मक विनिर्देश।
• खेल सामग्री।
• इंटरफेस।
• आवश्यकतानुसार ज्ञान का आधार जोड़ा जा सकता है।
• वस्तु मॉडल।

वस्तु मॉडल

ऑब्जेक्ट मॉडल में प्रत्येक गेम इकाई के बारे में जानकारी होती है: हथियार, कवच, एनपीसी, मंत्र, खिलाड़ी। यह प्रत्येक खेल के लिए अद्वितीय है।

कार्यक्षमता को इस प्रकार समझा जाना चाहिए:

• क्या मैं चालू/टेक ऑफ/खरीद/बिक्री/सुधार कर सकता हूं।
• क्या यह मृत्यु के बाद सूची में रहेगा।
• क्या यह समय के साथ या किसी प्रकार की कार्रवाई से ताकत खो देगा।
• चाहे वह किसी चरित्र या समूह की विशेषताओं को बढ़ाता हो।
• क्या सेट में विशेष गुण हैं।

ऊपर वर्णित बिंदु वैकल्पिक हैं, संस्थाओं के प्रत्येक व्यक्तिगत समूह के लिए उनकी संख्या को घटाया या बढ़ाया जा सकता है।

कार्यात्मक विनिर्देश

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

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

विषय

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

इंटरफेस

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

इंजन या कंस्ट्रक्टर चुनना

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

इंजन का चुनाव उसकी कुछ विशेषताओं के आधार पर किया जाना चाहिए:

• उपयोग की शर्तें।
• संभावनाएं।
• कीमत।
• डेवलपर समर्थन।
• दस्तावेज़ीकरण।
• समुदाय का आकार।
• सादगी।
• विस्तारशीलता।

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

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

सहायता: सबसे पहले यह पता लगाना जरूरी है कि क्या उत्पाद का विकास हुआ है? क्या संस्करण से संस्करण में बग तय किए गए हैं? क्या यह नई कार्यक्षमता और उपकरण प्राप्त कर रहा है? एक इंजन जो तेजी से विकसित हो रहा है, उस इंजन पर बढ़त है जो कुछ साल पहले जमी हुई थी।

समुदाय: कितने लोग कंस्ट्रक्टर का उपयोग करते हैं? यदि उपयोगकर्ता भारी संख्या मे, प्रलेखन, पाठ, मास्टर कक्षाएं, उदाहरण खोजना कोई समस्या नहीं है। यदि अपेक्षाकृत कम उपयोगकर्ता हैं, तो यह जानकारी उस सीमा तक उपलब्ध नहीं हो सकती है जो आपको कुछ प्रतिस्पर्धी करने की अनुमति देगी।

तानाना: अपना खुद का गेम बनाने से पहले, यह पता लगाने की कोशिश करें कि क्या बाहरी मॉड्यूल को चयनित इंजन से जोड़ना संभव है। वे आमतौर पर 3D मॉडल, ध्वनियाँ, स्क्रिप्ट, स्प्राइट्स को निर्यात या आयात करने के लिए उपयोग किए जाते हैं। यदि ऐसे उपकरणों के लिए समर्थन है, तो कंस्ट्रक्टर केवल सामग्री बनाने के लिए आंतरिक उपयोगिताओं तक ही सीमित नहीं है।

यूडीके

अवास्तविक विकास किट सीखना सबसे आसान नहीं है खेल यंत्र, लेकिन सबसे शक्तिशाली में से एक। इसका उपयोग न केवल नौसिखिए डेवलपर्स द्वारा किया जाता है, बल्कि बड़े निगमों द्वारा भी किया जाता है। यदि आप इस प्रश्न का उत्तर ढूंढ रहे हैं: "3D गेम कैसे बनाएं और इसके लिए कौन सा इंजन चुनें?" - आपको यूडीके की संभावनाओं का पता लगाना चाहिए।

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

टॉर्क 2D / 3D

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

कंस्ट्रक्टर प्रलेखन के साथ आता है जो अधिकांश विशेषताओं का वर्णन करता है। आधिकारिक साइट पर आप कई तैयार खेलों के लिए ट्यूटोरियल और स्रोत कोड पा सकते हैं।

स्क्रिप्ट लिखने के लिए, टॉर्क में एक अंतर्निहित टॉर्क स्क्रिप्ट भाषा है। प्रत्येक वस्तु के गुणों को पूर्वनिर्धारित किया जा सकता है। इसके अलावा, कंस्ट्रक्टर के पास एक अंतर्निहित Box2D सेट है, जो भौतिक गणनाओं से संबंधित है।

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

द स्टडी

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

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

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

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

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

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

1. विचार या परिदृश्य।
2. इच्छा और धैर्य।
3. गेम कंस्ट्रक्टर।

और अगर सफलता के पहले दो घटकों के साथ सब कुछ कमोबेश स्पष्ट है, तो हमें तीसरे घटक पर अधिक विस्तार से ध्यान देने की आवश्यकता है।

गेम कंस्ट्रक्टर क्या है

हम एक ऐसे कार्यक्रम के बारे में बात कर रहे हैं जो खेलों के विकास को बहुत सरल करता है, जिससे यह उन लोगों के लिए सुलभ हो जाता है जिनके पास प्रोग्रामिंग कौशल नहीं है। गेम डिजाइनर एक एकीकृत विकास वातावरण, एक गेम इंजन और एक स्तर संपादक को जोड़ता है जो एक दृश्य संपादक के रूप में काम करता है ( WYSIWYG- अंग्रेज़ी। संक्षिप्त नाम "आप जो देखते हैं वही आपको मिलता है")।

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

केवल वही पढ़ने के बाद जो पहले ही लिखा जा चुका है, यह स्पष्ट हो जाता है कि एक नौसिखिया डेवलपर के लिए जिसने एंड्रॉइड ओएस सहित किसी भी ऑपरेटिंग सिस्टम के लिए एक गेम लिखने का फैसला किया है, एक उपयुक्त कंस्ट्रक्टर का चुनाव मुख्य कार्य है, क्योंकि भाग्य का भाग्य भविष्य की परियोजना इस उपकरण की कार्यक्षमता और क्षमताओं पर निर्भर करती है।

सही कंस्ट्रक्टर कैसे चुनें

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

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

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

शीर्ष 5 सर्वश्रेष्ठ गेम निर्माता

निर्माण 2

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

बड़ी संख्या में सहायक उपकरणों को ध्यान में रखते हुए, नौसिखिए उपयोगकर्ता भी कार्यक्रम में महारत हासिल करने में सक्षम होंगे।

कंस्ट्रक्ट 2 के साथ काम करने में महारत हासिल करने के लिए, लाइसेंस खरीदने की कोई आवश्यकता नहीं है, मुफ्त मुफ्त संस्करण पर्याप्त उपकरण और निर्यात करने की क्षमता प्रदान करता है तैयार परियोजनाकुछ प्लेटफार्मों के लिए। हालांकि, मोबाइल प्लेटफॉर्म के लिए तैयार उत्पाद को कोड करना और पूर्ण कार्यक्षमता तक पहुंचना $ 129 के लिए एक व्यक्तिगत लाइसेंस प्रदान करेगा। यदि गेम बनाने में आपका कौशल अपने चरमोत्कर्ष पर पहुंच गया है, और आप पहले से ही अपने प्रोजेक्ट से 5,000 डॉलर से अधिक की आय प्राप्त करना शुरू कर चुके हैं, तो आपको व्यवसाय विकल्प के लिए फोर्क आउट करना होगा, जिसकी लागत $ 429 होगी।

अब, कंस्ट्रक्ट 2 के साथ गेमिंग एप्लिकेशन बनाने पर कुछ व्यावहारिक वीडियो ट्यूटोरियल देखें:

क्लिकटीम फ्यूजन

Clickteam Fusion एक उत्कृष्ट पूर्ण विकसित गेम कंस्ट्रक्टर का एक और उदाहरण है जो एक शुरुआत करने वाले को भी एक पूर्ण गेम बनाने में मदद करता है। कार्यक्रम HTML5 प्रारूप में बनाए गए एप्लिकेशन को पूरी तरह से नि: शुल्क निर्यात करने की क्षमता प्रदान करता है, जिसका अर्थ है कि ब्राउज़र गेम प्रकाशित करना और इसके अलावा, उन्हें विभिन्न मोबाइल बाजारों में प्रकाशन के लिए परिवर्तित करना संभव होगा, उदाहरण के लिए, Google Play।

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

कार्यक्रम का भुगतान किया गया डेवलपर संस्करण रूसी संघ के निवासियों के लिए उपलब्ध नहीं है, लेकिन इसकी लाइसेंस प्राप्त डिस्क को उसी अमेज़ॅन से ऑर्डर किया जा सकता है, व्यक्तिगत बजट को $ 100 के औसत से हल्का कर सकता है। तृतीय-पक्ष दरार के माध्यम से मेनू को Russify करना संभव है।

एप्लिकेशन के साथ कैसे काम करें, एक विशेष वीडियो कोर्स देखें:

स्टेंसिल

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

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

एक उत्कृष्ट ग्राफिक संपादक सीन डिजाइनर की उपस्थिति उपयोगकर्ता को अपनी कल्पना को ड्राइंग गेम की दुनिया में लागू करने की अनुमति देती है।

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

कार्यक्रम नि: शुल्क वितरित किया जाता है, लेकिन डेस्कटॉप प्रारूपों में निर्यात के लिए एक सदस्यता की आवश्यकता होती है, जिसकी लागत एक वर्ष के लिए $ 99 होगी, और इसके लिए लाइसेंस मोबाइल गेम्स- $ 199 प्रति वर्ष।

स्टेंसिल के साथ काम करने पर क्रैश कोर्स देखना:

गेम निर्माता

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

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

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

इस कार्यक्रम में कौन रुचि रखता है, हम प्रशिक्षण वीडियो देखने का सुझाव देते हैं:

एकता ३डी

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

यूनिटी के साथ बनाए गए गेम आईओएस या एंड्रॉइड मोबाइल डिवाइस से लेकर स्मार्ट टीवी तक सभी लोकप्रिय प्लेटफॉर्म के साथ संगत हैं।

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

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

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

यूनिटी 3डी के साथ गेम बनाने पर पाठों की एक श्रृंखला:

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

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

चरण 1. खेल के विचार के साथ आ रहा है
आइए एक उदाहरण के रूप में काफी सरल विचार लें:

स्क्रीन के नीचे एक स्पेसशिप है। यह संबंधित बटनों को दबाकर बाएँ और दाएँ घूम सकता है। क्षुद्रग्रह ऊपर से लंबवत नीचे की ओर चलते हैं। वे स्क्रीन की पूरी चौड़ाई में दिखाई देते हैं और अलग-अलग गति से चलते हैं। जहाज को यथासंभव लंबे समय तक उल्कापिंडों को चकमा देना चाहिए। यदि कोई उल्कापिंड टकराता है, तो खेल समाप्त हो जाता है।

चरण 2. एक प्रोजेक्ट बनाएं
Android Studio में, शीर्ष मेनू में, फ़ाइल → नया → नया प्रोजेक्ट चुनें।

यहां हम एप्लिकेशन, डोमेन और पथ का नाम दर्ज करते हैं। अगला पर क्लिक करें।

यहां आप Android संस्करण दर्ज कर सकते हैं। आप एक एंड्रॉइड घड़ी और एक टीवी भी चुन सकते हैं। लेकिन मुझे यकीन नहीं है कि हमारा आवेदन इस सब पर काम करेगा। इसलिए बेहतर है कि आप स्क्रीनशॉट की तरह ही सब कुछ दर्ज करें। अगला पर क्लिक करें।

यहां, खाली गतिविधि का चयन करना सुनिश्चित करें। और नेक्स्ट पर क्लिक करें।

यहां हम सब कुछ वैसे ही छोड़ देते हैं और समाप्त पर क्लिक करते हैं। इसलिए प्रोजेक्ट बनाया गया है। चलिए तीसरे चरण पर चलते हैं।

चरण 3. चित्र जोड़ें

चरण 5. MainActivity वर्ग का संपादन

सबसे पहले, क्लास डेफिनिशन में इम्प्लीमेंट्स View.OnTouchListener जोड़ें। वर्ग की परिभाषा अब इस प्रकार होगी:

सार्वजनिक वर्ग MainActivity AppCompatActivity लागू करता है View.OnTouchListener को बढ़ाता है (
कक्षा में आवश्यक स्थिर चर (वर्ग चर) जोड़ें:

सार्वजनिक स्थैतिक बूलियन isLeftPressed = false; // बायां बटन दबाया गया सार्वजनिक स्थैतिक बूलियन isRightPressed = false; // दायां बटन दबाया गया
क्रिएट पर रक्षित शून्य प्रक्रिया के लिए (बंडल सेव्ड इंस्टेंसस्टेट) (
लाइनें जोड़ें:

गेम व्यू गेम व्यू = नया गेम व्यू (यह); // गेमव्यू बनाएं LinearLayout gameLayout = (LinearLayout) findViewById (R.id.gameLayout); // gameLayout gameLayout.addView (gameView) खोजें; // और गेमव्यू बटन जोड़ें लेफ्टबटन = (बटन) findViewById (R.id.leftButton); // बटन ढूंढें बटन राइटबटन = (बटन) findViewById (R.id.rightButton); leftButton.setOnTouchListener (यह); // और इस वर्ग को श्रोता के रूप में जोड़ें (क्लिक करने पर ऑनटच ट्रिगर हो जाएगा) rightButton.setOnTouchListener (यह);
कक्षाएं लीनियरलाउट, बटन, आदि। लाल रंग में हाइलाइट किया गया क्योंकि उन्हें अभी तक आयात में नहीं जोड़ा गया है।
आयात में जोड़ने और लाल हाइलाइट को हटाने के लिए, आपको प्रत्येक के लिए Alt + Enter दबाना होगा।
GameView को लाल रंग में हाइलाइट किया जाएगा क्योंकि यह वर्ग अभी तक मौजूद नहीं है। हम इसे बाद में बनाएंगे।

अब हम प्रक्रिया जोड़ते हैं:

सार्वजनिक बूलियन ऑनटच (व्यू बटन, मोशनइवेंट मोशन) (स्विच (बटन.गेटआईड ()) (// परिभाषित करें कि कौन सा बटन केस R.id.leftबटन: स्विच (मोशन.गेटएक्शन ())) (// दबाए गए या जारी किए गए केस मोशनइवेंट को परिभाषित करें। ACTION_DOWN: isLeftPressed = true; break; case MotionEvent.ACTION_UP: isLeftPressed = false; break;) break; case R.id.rightButton: switch (motion.getAction ()) (// दबाए गए या जारी किए गए केस MotionEvent को परिभाषित करें। ACTION_DOWN: isRightPressed = सच; तोड़; मामला MotionEvent.ACTION_UP: isRightPressed = झूठा; तोड़;) तोड़;) सच वापस;)
यदि कोई भ्रमित है, तो परिणाम के रूप में MainActivity वर्ग इस तरह दिखना चाहिए:

पैकेज com.spaceavoider.spaceavoider; android.support.v7.app.AppCompatActivity आयात करें; आयात android.os.Bundle; आयात android.view.MotionEvent; आयात android.view.View; आयात android.widget.Button; आयात android.widget.LinearLayout; सार्वजनिक वर्ग MainActivity AppCompatActivity लागू करता है View.OnTouchListener (सार्वजनिक स्थैतिक बूलियन isLeftPressed = false; // बायां बटन दबाया गया सार्वजनिक स्थैतिक बूलियन isRightPressed = false; // दायां बटन दबाया गया @ ओवरराइड संरक्षित शून्य पर क्रिएट (बंडल सहेजा गया इंस्टेंसस्टेट) (सुपर.ऑनक्रेट) (savedInstanceState) ) ; setContentView (R.layout.activity_main); GameView gameView = new GameView (यह); // गेमव्यू बनाएं LinearLayout gameLayout = (LinearLayout) findViewById (R.id.gameLayout); // gameLayout gameLayout.addView (gameView) खोजें; // और गेमव्यू बटन जोड़ें लेफ्टबटन = (बटन) findViewById (R.id.leftButton); // बटन बटन ढूंढें राइटबटन = (बटन) findViewById (R.id.rightButton); leftButton.setOnTouchListener (यह); // और जोड़ें श्रोता के रूप में यह वर्ग (जब क्लिक किया जाता है, ऑनटच चालू हो जाएगा) rightButton.setOnTouchListener (यह);) सार्वजनिक बूलियन ऑनटच (देखें बटन, मोशनवेन्ट मोशन) (स्विच (बटन.getId ()) (// परिभाषित करें कि कौन सा बटन केस आर .id.leftButton: स्विच (मोशन.गेटएक्शन ()) (// दबाए गए या जारी किए गए केस को परिभाषित करें MotionEvent.ACTION_DOWN: isLeftPressed = true; टूटना; मामला MotionEvent.ACTION_UP: isLeftPressed = false; टूटना; ) टूटना; केस R.id.rightButton: स्विच (मोशन.गेटएक्शन ()) (// दबाए गए या रिलीज़ किए गए केस MotionEvent को परिभाषित करें। ) सच लौटें; ))
तो मुख्य गतिविधि वर्ग तैयार है! GameView वर्ग, जो अभी तक नहीं बनाया गया है, इसमें आरंभ किया गया है। और जब बायां बटन दबाया जाता है, तो स्थिर चर isLeftPressed = true, और जब दायां बटन दबाया जाता है, isRightPressed = true। सामान्य तौर पर, वह यही सब करता है।

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

चरण 6. GameView वर्ग बनाएं

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

सार्वजनिक स्थैतिक इंट मैक्सएक्स = 20; // क्षैतिज आकार सार्वजनिक स्थैतिक int maxY = 28; // लंबवत आकार सार्वजनिक स्थैतिक फ्लोट इकाईW = 0; // पिक्सल प्रति यूनिट क्षैतिज रूप से सार्वजनिक स्थैतिक फ्लोट यूनिटएच = 0; // पिक्सल प्रति यूनिट लंबवत
यूनिट डब्ल्यू और यूनिट डब्ल्यू की गणना बाद में की जाएगी। हमें अन्य चर की भी आवश्यकता है:

निजी बूलियन फर्स्टटाइम = सच; निजी बूलियन गेमरनिंग = सच; निजी जहाज जहाज; निजी थ्रेड गेम थ्रेड = शून्य; निजी पेंट पेंट; निजी कैनवास कैनवास; निजी सरफेसहोल्डर सरफेसहोल्डर;
कंस्ट्रक्टर इस तरह होगा:

पब्लिक गेम व्यू (संदर्भ संदर्भ) (सुपर (संदर्भ); // सरफेसहोल्डर = गेटहोल्डर (); पेंट = नया पेंट (); // इनिशियलाइज़ थ्रेड गेमथ्रेड = नया थ्रेड (यह); gameThread.start ();)
रन () विधि में एक अनंत लूप होगा। लूप की शुरुआत में, अद्यतन () विधि निष्पादित की जाती है
जो जहाज के नए निर्देशांक की गणना करेगा। फिर ड्रा () विधि जहाज को स्क्रीन पर खींचती है। और अंत में, नियंत्रण () विधि 17 मिलीसेकंड के लिए रुक जाएगी। 17 मिलीसेकंड के बाद, रन () फिर से शुरू होगा। और इसी तरह चर gameRunning == true तक। ये तरीके हैं:

@Override सार्वजनिक शून्य रन () (जबकि (गेमरनिंग) (अद्यतन (); ड्रा (); नियंत्रण ();)) निजी शून्य अद्यतन () (अगर (! फर्स्टटाइम) (जहाज.अपडेट ();)) निजी शून्य ड्रा () (अगर (surfaceHolder.getSurface ()। isValid ()) (// जांचें कि क्या सतह मान्य है अगर (फर्स्टटाइम) (// पहली बार शुरू होने पर पहला समय = झूठा; यूनिटडब्ल्यू = सतहहोल्डर। getSurfaceFrame ()। चौड़ाई () / maxX ; // यूनिट यूनिट में पिक्सेल की संख्या की गणना करेंH = SurfaceHolder.getSurfaceFrame ()। ऊंचाई () / maxY; जहाज = नया जहाज (getContext ()); // जहाज जोड़ें) कैनवास = सतहहोल्डर।लॉककैनवास (); // कैनवास कैनवास बंद करें .drawColor (Color.BLACK); // ब्लैक शिप के साथ बैकग्राउंड भरें। शून्य नियंत्रण () (// 17 मिलीसेकंड के लिए रोकें कोशिश करें (gameThread.sleep (17);) पकड़ें (इंटरप्टेड एक्सेप्शन ई) (ई.प्रिंटस्टैकट्रेस ();))
पहली शुरुआत में इनिशियलाइज़ेशन पर ध्यान दें। वहां हम इकाई में पिक्सेल की संख्या की गणना करते हैं और जहाज जोड़ते हैं। हमने अभी तक जहाज नहीं बनाया है। लेकिन पहले, हम इसका पैरेंट क्लास बनाएंगे।

चरण 7. स्पेसबॉडी क्लास बनाएं

यह जहाज और क्षुद्रग्रह वर्ग का जनक होगा। इसमें इन दो वर्गों के लिए सामान्य सभी चर और विधियां शामिल होंगी। चर जोड़ें:

संरक्षित फ्लोट एक्स; // संरक्षित फ्लोट y निर्देशांक; संरक्षित फ्लोट आकार; // आकार संरक्षित फ्लोट गति; // गति संरक्षित int bitmapId; // छवि आईडी संरक्षित बिटमैप बिटमैप; // चित्र
और तरीके

शून्य init (संदर्भ संदर्भ) (// छवि को वांछित आकार में संपीड़ित करें बिटमैप cBitmap = BitmapFactory.decodeResource (context.getResources (), bitmapId); बिटमैप = बिटमैप.क्रिएट स्केल्ड बिटमैप (cBitmap, (int) (आकार * GameView.unitW) , ( int) (आकार * GameView.unitH), असत्य); cBitmap.recycle ();) शून्य अद्यतन () (// नए निर्देशांक की गणना यहां की जाएगी) शून्य ड्रो (पेंट पेंट, कैनवास कैनवास) (// ड्रा ए चित्र कैनवास.ड्राबिटमैप (बिटमैप, x * GameView.unitW, y * GameView.unitH, पेंट);)
चरण 8. शिप क्लास बनाएं

अब एक शिप क्लास बनाते हैं। यह स्पेसबॉडी क्लास को इनहेरिट करता है, इसलिए हम स्पेसबॉडी को क्लास डेफिनिशन में जोड़ते हैं।

आइए एक कंस्ट्रक्टर लिखें:

पब्लिक शिप (संदर्भ संदर्भ) (बिटमैप आईडी = आर ड्रॉएबल.शिप; // प्रारंभिक पैरामीटर आकार = 5 परिभाषित करें; x = 7; y = GameView.maxY - आकार -1; गति = (फ्लोट) 0.2; init (संदर्भ); // जहाज को इनिशियलाइज़ करें)
और अद्यतन () विधि को ओवरराइड करें

@Override सार्वजनिक शून्य अद्यतन () (// दबाए गए बटन के आधार पर जहाज को स्थानांतरित करें यदि (MainActivity.isLeftPressed && x> = 0) (x - = speed;) if (MainActivity.isRightPressed && x<= GameView.maxX - 5){ x += speed; } }
इस पर स्पेसशिप तैयार है! हम सब कुछ संकलित और चलाते हैं। स्क्रीन पर एक स्पेसशिप दिखाई देनी चाहिए। जब आप बटन दबाते हैं, तो इसे दाएं और बाएं जाना चाहिए। अब ऊपर से गिरने वाले क्षुद्रग्रहों को जोड़ें। एक जहाज से टकराने पर खेल समाप्त हो जाता है।

चरण 9. क्षुद्रग्रह वर्ग बनाएं

आइए एक क्षुद्रग्रह वर्ग जोड़ें। यह स्पेसबॉडी क्लास को भी इनहेरिट करता है, इसलिए हम स्पेसबॉडी को क्लास डेफिनिशन में जोड़ते हैं।

आइए वे चर जोड़ें जिनकी हमें आवश्यकता है:

निजी अंतर त्रिज्या = 2; // त्रिज्या निजी फ्लोट मिनस्पीड = (फ्लोट) 0.1; // न्यूनतम गति निजी फ्लोट मैक्सस्पीड = (फ्लोट) 0.5; // अधिकतम गति
क्षुद्रग्रह स्क्रीन के शीर्ष पर एक यादृच्छिक बिंदु पर दिखाई देना चाहिए और एक यादृच्छिक गति से नीचे उड़ना चाहिए। ऐसा करने के लिए, इसके कंस्ट्रक्टर में एक यादृच्छिक संख्या जनरेटर का उपयोग करके x और गति निर्धारित की जाती है।

सार्वजनिक क्षुद्रग्रह (संदर्भ संदर्भ) (रैंडम रैंडम = नया रैंडम (); बिटमैपआईडी = आर ड्रॉएबल.एस्टरॉयड; y = 0; x = random.nextInt (GameView.maxX) - त्रिज्या; आकार = त्रिज्या * 2; गति = न्यूनतम गति + (मैक्सस्पीड - मिनस्पीड) * random.nextFloat (); init (संदर्भ);)
क्षुद्रग्रह को एक निश्चित गति से लंबवत नीचे की ओर बढ़ना चाहिए। इसलिए, अद्यतन () विधि में, हम x निर्देशांक में गति जोड़ते हैं।

@ ओवरराइड सार्वजनिक शून्य अद्यतन () (y + = गति;)
हमें यह निर्धारित करने के लिए एक विधि की भी आवश्यकता होगी कि क्या क्षुद्रग्रह जहाज से टकराया है।

सार्वजनिक बूलियन टकराव है (फ्लोट शिपएक्स, फ्लोट शिपवाई, फ्लोट शिप साइज) (वापसी! (((एक्स + आकार)< shipX)||(x >(शिपएक्स + शिपसाइज)) || ((वाई + साइज)< shipY)||(y >(शिपवाई + शिपसाइज))); )
आइए इसे और अधिक विस्तार से विचार करें। सादगी के लिए, हम मानते हैं कि जहाज और क्षुद्रग्रह वर्ग हैं। यहाँ मैं विपरीत से चला गया। यही है, मैं यह निर्धारित करता हूं कि वर्ग कब प्रतिच्छेद नहीं करते हैं।

((एक्स + आकार)< shipX) - корабль слева от астероида.
(x> (शिपएक्स + शिप साइज)) - क्षुद्रग्रह के दाईं ओर जहाज।
((वाई + आकार)< shipY) - корабль сверху астероида.
(y> (जहाज + जहाज आकार)) - क्षुद्रग्रह के नीचे जहाज।

इन चार भावों के बीच है || (या)। अर्थात्, यदि कम से कम एक व्यंजक सत्य है (जिसका अर्थ है कि वर्ग प्रतिच्छेद नहीं करते हैं) - परिणामी व्यंजक भी सत्य हैं।

मैं इस सभी अभिव्यक्ति को एक चिन्ह के साथ उलट देता हूँ! परिणामस्वरूप, जब वर्ग प्रतिच्छेद करते हैं तो विधि सत्य हो जाती है। हमें क्या चाहिये।

आप अधिक जटिल आकृतियों के प्रतिच्छेदन की परिभाषा के बारे में पढ़ सकते हैं।

चरण 10. गेम व्यू में क्षुद्रग्रह जोड़ें

GameView में चर जोड़ें:

निजी ArrayList क्षुद्रग्रह = नया ArrayList<>(); // क्षुद्रग्रहों को यहां परेशान किया जाएगा निजी अंतिम int ASTEROID_INTERVAL = 50; // वह समय जिसके बाद क्षुद्रग्रह दिखाई देते हैं (पुनरावृत्तियों में) निजी int currentTime = 0;
2 विधियाँ भी जोड़ें:

निजी शून्य चेक कोलिशन () (// सभी क्षुद्रग्रहों पर पुनरावृति करें और जांचें कि क्या उनमें से एक जहाज को छूता है (क्षुद्रग्रह क्षुद्रग्रह: क्षुद्रग्रह) (यदि (क्षुद्रग्रह.isCollision (ship.x, ship.y, जहाज। आकार)) (/ / खिलाड़ी ने गेम खो दिया हैरनिंग = झूठा; // खेल को रोकें // TODO एक विस्फोट एनीमेशन जोड़ें))) निजी शून्य चेकआईएफन्यूएस्टेरॉइड () (// हर 50 पुनरावृत्तियों में एक नया क्षुद्रग्रह जोड़ें यदि (वर्तमान समय> = AsterOID_INTERVAL) (क्षुद्रग्रह क्षुद्रग्रह = नया क्षुद्रग्रह (getContext ()); क्षुद्रग्रह। जोड़ें (क्षुद्रग्रह); वर्तमान समय = 0;) अन्य (वर्तमान समय ++;))
और रन () विधि में, नियंत्रण () को कॉल करने से पहले इन विधियों में कॉल जोड़ें।

@ ओवरराइड सार्वजनिक शून्य रन () (जबकि (गेमरनिंग) (अपडेट (); ड्रा (); चेककॉलिशन (); checkIfNewAsteroid (); नियंत्रण ();))
इसके बाद, अपडेट () विधि में, एक लूप जोड़ें जो सभी क्षुद्रग्रहों पर पुनरावृति करता है और उन पर अपडेट () विधि को कॉल करता है।

निजी शून्य अद्यतन () (यदि (! फर्स्टटाइम) (जहाज। अद्यतन (); के लिए (क्षुद्रग्रह क्षुद्रग्रह: क्षुद्रग्रह) (क्षुद्रग्रह। अद्यतन ();)))
उसी लूप को ड्रा () विधि में जोड़ें।

निजी शून्य ड्रा () (यदि (surfaceHolder.getSurface ()। IsValid ())) (// जांचें कि क्या सतह मान्य है अगर (फर्स्टटाइम) (// पहले रन पर आरंभीकरण फर्स्टटाइम = झूठा; यूनिटडब्ल्यू = सतहहोल्डर। गेटसर्फेसफ्रेम ()। चौड़ाई ( ) / maxX; // यूनिट यूनिट में पिक्सेल की संख्या की गणना करेंH = SurfaceHolder.getSurfaceFrame ()। ऊंचाई () / maxY; जहाज = नया जहाज (getContext ()); // जहाज जोड़ें) कैनवास = सतहहोल्डर।लॉककैनवास (); // कैनवास कैनवास को बंद करें। ड्रॉकलर (रंग। काला); // काले जहाज के साथ पृष्ठभूमि भरें। ड्रॉ (पेंट, कैनवास); // जहाज को (क्षुद्रग्रह क्षुद्रग्रह: क्षुद्रग्रह) के लिए खींचें (// क्षुद्रग्रहों को आकर्षित करें क्षुद्रग्रह। ड्रो (पेंट, कैनवास); ) सतह धारक। अनलॉककैनवासएंडपोस्ट (कैनवास); // कैनवास खोलें))
बस इतना ही! सबसे आसान 2डी गेम तैयार है। हम संकलित करते हैं, दौड़ते हैं और देखते हैं कि क्या हुआ!
अगर कोई भ्रमित है या कुछ काम नहीं करता है, तो आप स्रोत डाउनलोड कर सकते हैं।

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

बस इतना ही। जारी रखने के लिए समीक्षाएँ, प्रश्न, रुचि के विषय लिखें।

एकता में जल्दी से एंड्रॉइड गेम कैसे लिखें

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

ऐसा कुछ लिखना कितना आसान है, यह प्रदर्शित करने के लिए, आज हम अपनी Flappy Bird with Unity को केवल 10 मिनट में लिखेंगे।

बजाने योग्य पात्र

पहले एक नया प्रोजेक्ट बनाएं और सुनिश्चित करें कि 2D चुना गया है।

अपने पक्षी स्प्राइट को दृश्य में लोड करें। अपनी कल्पना को चालू करना न भूलें!

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

कैमरे को पक्षी पर खींचें और छोड़ें। कैमरा पक्षी के नीचे होना चाहिए, जिसका अर्थ है कि कैमरा अब पक्षी का "बच्चा" है। अब कैमरे की स्थिति पक्षी के सापेक्ष तय की जाएगी। अगर चिड़िया आगे बढ़ती है तो कैमरा भी ऐसा ही करता है।

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

अब ऐड कंपोनेंट पर क्लिक करें। भौतिकी 2 डी> रिगिडबॉडी 2 डी चुनें - यह हमारे चरित्र पर गुरुत्वाकर्षण लागू करने के लिए निर्देशों का एक तैयार सेट है। इस पैनल में बाधाओं पर क्लिक करें और फिर फ्रीज रोटेशन जेड चुनें। यह पक्षी को कैमरे के साथ एक सर्कल में घूमने से रोकेगा।

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

अब तक सब ठीक है!

अब चरित्र को उड़ाना शुरू करने का समय आ गया है, क्योंकि यह मुश्किल नहीं होगा।

सबसे पहले आपको C# स्क्रिप्ट बनानी होगी। इसके लिए एक फोल्डर बनाएं (एसेट में कहीं राइट-क्लिक करें और "स्क्रिप्ट्स" फोल्डर बनाएं), राइट-क्लिक करें और क्रिएट> सी # स्क्रिप्ट चुनें।

चलो इसे "चरित्र" कहते हैं। इसे अपने IDE में खोलने के लिए उस पर डबल क्लिक करें, चाहे वह MonoDevelop हो या Visual Studio। फिर निम्नलिखित कोड जोड़ें:

पब्लिक क्लास कैरेक्टर: मोनोबिहेवियर (पब्लिक रिगिडबॉडी 2 डी आरबी; पब्लिक फ्लोट मूवस्पीड; पब्लिक फ्लोट फ्लैपहाइट; // यह इनिशियलाइज़ेशन शून्य स्टार्ट () (आरबी = गेटकंपोनेंट ();) के लिए आवश्यक है। आरबी .वेलोसिटी = नया वेक्टर 2 (मूवस्पीड, आरबी.वेलोसिटी। वाई); अगर (इनपुट। गेटमाउसबटनडाउन (0)) (आरबी.वेलोसिटी = नया वेक्टर 2 (आरबी.वेलोसिटी.एक्स, फ्लैपहाइट);) अगर (ट्रांसफॉर्म। पोजीशन.वाई) > 18 ||< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }

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

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

प्रत्येक क्लिक के बाद पक्षी की उड़ान की ऊंचाई में वृद्धि के लिए चाल गति चर आंदोलन की गति के लिए जिम्मेदार होगा, और फ्लैपहाइट चर। चूंकि इन चरों को सार्वजनिक घोषित किया जाता है, इसलिए हम इन्हें स्क्रिप्ट के बाहर बदल सकते हैं।

डेथ () विधि को भी सार्वजनिक घोषित किया जाता है, जिसका अर्थ है कि अन्य ऑब्जेक्ट और स्क्रिप्ट इसे कॉल कर सकते हैं। यह विधि केवल चरित्र की स्थिति को शुरुआत में लौटाती है। इसका उपयोग हर बार चरित्र के बहुत अधिक या निम्न उड़ान भरने पर भी किया जाएगा। आप जल्द ही समझ जाएंगे कि इसे सार्वजनिक क्यों घोषित किया जाता है। रेखा आरबी.वेग = वेक्टर3.शून्य; आवेग को दूर करने के लिए आवश्यक है - हम नहीं चाहते कि चरित्र प्रत्येक मृत्यु के बाद तेजी से और तेजी से गिरे, है ना?

अब आप आईडीई से बाहर निकल सकते हैं और स्क्रिप्ट को अपने चरित्र में एक घटक के रूप में जोड़ सकते हैं। ऐसा करने के लिए, हमारे पक्षी का चयन करें और घटक जोड़ें> लिपियों> चरित्र पर क्लिक करें। अब हम इंस्पेक्टर में मूवस्पीड और फ्लैपहाइट को परिभाषित कर सकते हैं (यही सार्वजनिक चर के लिए है)। आइए वेरिएबल को क्रमशः 3 और 5 मान दें।

और एक और बात: निरीक्षक में, आपको चरित्र में एक टैग जोड़ना होगा। ऐसा करने के लिए, जहां टैग: अनटैग किया गया है वहां क्लिक करें और फिर ड्रॉप-डाउन सूची में प्लेयर चुनें।

बाधाएं

अब बाधाओं को जोड़ते हैं: पाइप। किसी को पाइप में मशरूम मिलते हैं, और किसी को - उनकी मृत्यु।

पाइप स्प्राइट को उस दृश्य में खींचें जहां पहली बाधा होनी चाहिए और इसे pipe_up नाम दें।
अब पाइप नामक एक नई स्क्रिप्ट बनाते हैं:

पब्लिक क्लास पाइप: मोनोबिहेवियर (निजी कैरेक्टर कैरेक्टर; // यह इनिशियलाइज़ेशन शून्य स्टार्ट () (कैरेक्टर = फाइंडऑब्जेक्टऑफ टाइप ();) के लिए आवश्यक है। एक्स - परिवर्तन। स्थिति। x>

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

हर बार जब पाइप चरित्र के साथ इंटरैक्ट करता है तो OnCollisionEnter2D () विधि को कॉल किया जाता है। उसके बाद, पहले से बनाई गई डेथ () विधि को कहा जाता है, खिलाड़ी को शुरुआती बिंदु पर लौटाता है।

तो हमारे पास एक पाइप है जो समय-समय पर स्क्रीन के दूसरे छोर पर अंदर और बाहर फीका होगा। मारोगे तो मर जाओगे।

उल्टे पाइप

अभी हमारे पास केवल एक पाइप स्प्राइट है। आइए एक और जोड़ें। ऐसा करने के लिए, पदानुक्रम विंडो में राइट-क्लिक करें, नया 2D ऑब्जेक्ट> स्प्राइट पर क्लिक करें और फिर उस स्प्राइट का चयन करें जिसका आप उपयोग करना चाहते हैं। फ़ाइल को फिर से सीन में ड्रैग और ड्रॉप करना और भी आसान है।

इस स्प्राइट को पाइप_डाउन नाम दें। स्प्राइट रेंडरर के तहत इंस्पेक्टर में, पाइप को उल्टा फ्लिप करने के लिए Flip Y विकल्प चुनें। वही RigidBody2D जोड़ें।

अब एक नई C# स्क्रिप्ट लिखते हैं जिसे PipeD कहा जाता है। इसमें समान कोड होगा:

पब्लिक क्लास पाइपडी: मोनोबिहेवियर (निजी कैरेक्टर कैरेक्टर; // यह इनिशियलाइज़ेशन शून्य स्टार्ट () (कैरेक्टर = फाइंडऑब्जेक्टऑफ टाइप ();) के लिए आवश्यक है। x - परिवर्तन.स्थिति.x> 30) ()) शून्य OnCollisionEnter2D (Collision2D अन्य) (यदि (other.gameObject.tag == "प्लेयर") (character.Death ();)))

प्रीफ़ैब्स

तो, यह कोड हमारे लिए पूरे खेल को बनाने के लिए पर्याप्त है। हम हर बार गायब होने पर स्क्रीन के दाईं ओर पाइप ले जा सकते हैं, या जितने पाइप हम पूरे खेल में देखना चाहते हैं, कॉपी और पेस्ट कर सकते हैं।

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

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

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

ऐसा करने के लिए, एक नया फ़ोल्डर "प्रीफ़ैब्स" बनाएं। फिर पाइप_अप और पाइप_डाउन को पदानुक्रम विंडो से फ़ोल्डर में खींचें।

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

जैसा कि आप कल्पना कर सकते हैं, इससे हमारे संसाधनों की अत्यधिक बचत होगी। इसका मतलब यह भी है कि हम कोड से वस्तुओं के साथ बातचीत कर सकते हैं। हम अपने पाइप के उदाहरण बना सकते हैं।

सबसे पहले, इस कोड को पाइप स्क्रिप्ट के अपडेट () विधि में सशर्त विवरण में जोड़ें, जिसे हमने खाली छोड़ दिया था:

शून्य अद्यतन () (यदि (character.transform.position.x - परिवर्तन। स्थिति। x> 30) (फ्लोट xRan = Random.Range (0, 10); फ्लोट yRan = Random.Range (-5, 5); तत्काल (गेमऑब्जेक्ट, नया वेक्टर 2 (कैरेक्टर.ट्रांसफॉर्म.पोजिशन.एक्स + 15 + एक्सरान, -10 + वाईरान), ट्रांसफॉर्म। रोटेशन); नष्ट (गेमऑब्जेक्ट);))

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

हम अपने पाइपों को और अधिक मजेदार बनाने के लिए यादृच्छिक विविधताओं में पुन: उत्पन्न कर रहे हैं।

लेकिन PipeD लिपि में एक ही काम करने के बजाय, हम दोनों वस्तुओं को एक ही स्थान पर उत्पन्न करते हैं। इस प्रकार, हम आसानी से पहले के सापेक्ष दूसरे पाइप की स्थिति निर्धारित कर सकते हैं। इसका मतलब यह भी है कि हमें PipeD के लिए कम कोड की आवश्यकता है।

पाइपडाउन नाम का एक सार्वजनिक गेमऑब्जेक्ट बनाएं। फिर अपना कोड इस तरह अपडेट करें:

अगर (character.transform.position.x -transform.position.x> 30) (फ्लोट xRan = Random.Range (0, 10); फ्लोट yRan = Random.Range (-5, 5); फ्लोट गैपरान = रैंडम। रेंज (०, ३); इंस्टेंटिएट (गेमऑब्जेक्ट, नया वेक्टर २ (character.transform.position.x + १५ + xRan, -11 + yRan), ट्रांसफॉर्म। रोटेशन); इंस्टेंटिएट (पाइपडाउन, नया वेक्टर २ (character.transform.position.x) + 15 + xRan, 12 + गैपरान + yRan), ट्रांसफॉर्म.रोटेशन); नष्ट (गेमऑब्जेक्ट);)

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

PipeD स्क्रिप्ट में हम जो कुछ भी एक ही स्थान पर जोड़ते हैं, वह बस नष्ट (गेमऑब्जेक्ट) है ताकि स्क्रीन के बाएं किनारे से जाने पर पाइप स्वयं नष्ट हो जाए।

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

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

इस प्रकार, हम खेल के प्रत्येक भार के दौरान पहले कुछ पाइप बना सकते हैं और चरित्र की मृत्यु के बाद सब कुछ अपने स्थान पर वापस कर सकते हैं।

अंतहीन उड़ान

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

हमें इन चरों को जोड़ने की आवश्यकता है:

सार्वजनिक गेमऑब्जेक्ट पाइप_अप; सार्वजनिक गेमऑब्जेक्ट पाइप_डाउन;

फिर हम इस तरह की एक विधि लिखेंगे:

सार्वजनिक शून्य बिल्डलेवल () (तत्काल (पाइप_डाउन, नया वेक्टर 3 (14, 12), परिवर्तन। रोटेशन); इंस्टेंटिएट (पाइप_अप, नया वेक्टर 3 (14, -11), ट्रांसफॉर्म। रोटेशन); इंस्टेंटिएट (पाइप_डाउन, नया वेक्टर 3 (26, १४), ट्रांसफॉर्म.रोटेशन); इंस्टेंटिएट (पाइप_अप, नया वेक्टर ३ (२६, -10), ट्रांसफॉर्म। रोटेशन); इंस्टेंटिएट (पाइप_डाउन, न्यू वेक्टर३ (३८, १०), ट्रांसफॉर्म। रोटेशन); इंस्टेंटिएट (पाइप_अप, नया वेक्टर ३ ( 38, -14), ट्रांसफॉर्म.रोटेशन); इंस्टेंटिएट (पाइप_डाउन, न्यू वेक्टर3 (50, 16), ट्रांसफॉर्म। रोटेशन); इंस्टेंटिएट (पाइप_अप, नया वेक्टर 3 (50, -8), ट्रांसफॉर्म। रोटेशन); इंस्टेंटिएट (पाइप_डाउन, नया वेक्टर ३ (६१, ११), ट्रांसफ़ॉर्म। रोटेशन); इंस्टेंटिएट (पाइप_अप, नया वेक्टर ३ (६१, -१३), ट्रांसफ़ॉर्म। रोटेशन);)

हम इसे एक बार Update () मेथड में और एक बार डेथ () मेथड में कॉल करेंगे।

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

एकता में दृश्य पर वापस जाएं और वहां मौजूद दो पाइपों को हटा दें। आपका "गेम" एक पक्षी के साथ एक खाली स्क्रीन की तरह दिखेगा। प्रेस प्ले और पाइप दिखाई देंगे, पहले कुछ के बाद, उनकी स्थिति बेतरतीब ढंग से निर्धारित की जाएगी।

आखिरकार

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

Android ऐप्स लिखना चाहते हैं लेकिन यह नहीं जानते कि कहां से शुरू करें? फिर Android विकास सीखने के लिए हमारे महान देखें।

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

आज, कंप्यूटर और मोबाइल प्लेटफ़ॉर्म दोनों के लिए गेम बनाना बहुत आसान हो गया है, क्योंकि सार्वभौमिक इंजन और विकास के वातावरण दिखाई दिए हैं, या बोल रहे हैं सरल भाषा – Android के लिए गेम बनाने के लिए कार्यक्रमऔर पर्सनल कंप्यूटर। लगभग छह महीने पहले मैंने विचार किया था, और आज हम पूर्ण विकसित गेम बनाने के लिए टूल के बारे में बात करेंगे।

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

एकता ३डी

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

एकता 3 डी का उपयोग कर उदाहरण:

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

डीएक्स स्टूडियो

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

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

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

क्या आप जानते हैं कि कौन से सबसे अच्छे हैं?