विषय
एंड्रॉइड के लिए गेम बनाने के बहुत सारे तरीके हैं और एक महत्वपूर्ण तरीका यह है कि जावा के साथ एंड्रॉइड स्टूडियो में स्क्रैच करें। यह आपको अधिकतम नियंत्रण प्रदान करता है कि आप अपने खेल को कैसे देखना और व्यवहार करना चाहते हैं और यह प्रक्रिया आपको कौशल सिखाएगी जिसे आप अन्य परिदृश्यों में भी उपयोग कर सकते हैं - चाहे आप किसी ऐप के लिए एक स्प्लैश स्क्रीन बना रहे हों या आप बस चाहते हों कुछ एनिमेशन जोड़ें। इसे ध्यान में रखते हुए, यह ट्यूटोरियल आपको एंड्रॉइड स्टूडियो और जावा का उपयोग करके एक सरल 2 डी गेम बनाने का तरीका दिखाने जा रहा है। आप जीथब पर सभी कोड और संसाधन पा सकते हैं यदि आप साथ चलना चाहते हैं।
की स्थापना
अपना गेम बनाने के लिए, हमें कुछ विशिष्ट अवधारणाओं से निपटने की आवश्यकता है: गेम लूप, थ्रेड और कैनवस। शुरू करने के लिए, एंड्रॉइड स्टूडियो शुरू करें। यदि आपने इसे स्थापित नहीं किया है, तो Android स्टूडियो में हमारे पूर्ण परिचय की जाँच करें, जो कि अधिष्ठापन प्रक्रिया पर जाता है। अब एक नई परियोजना शुरू करें और सुनिश्चित करें कि आप 'खाली गतिविधि' का खाका चुनें। यह एक खेल है, इसलिए निश्चित रूप से आपको FAB बटन जैसे जटिल मामलों की आवश्यकता नहीं है।
पहली चीज जो आप करना चाहते हैं वह है बदलाव AppCompatActivity सेवा मेरे गतिविधि। इसका मतलब है कि हम एक्शन बार सुविधाओं का उपयोग नहीं करेंगे।
इसी तरह, हम भी अपने खेल को पूर्ण स्क्रीन बनाना चाहते हैं। SetContentView () के लिए कॉल करने से पहले onCreate () पर निम्न कोड जोड़ें:
getWindow ()। setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); this.requestWindowFeature (Window.FEATURE_NO_TITLE);
ध्यान दें कि यदि आप कुछ कोड लिखते हैं और यह लाल रंग में रेखांकित होता है, तो इसका मतलब है कि आपको कक्षा आयात करने की आवश्यकता है। दूसरे शब्दों में, आपको एंड्रॉइड स्टूडियो को बताने की आवश्यकता है कि आप कुछ कथनों का उपयोग करना चाहते हैं और उन्हें उपलब्ध कराना चाहते हैं। यदि आप केवल रेखांकित शब्द पर कहीं भी क्लिक करते हैं और फिर Alt + Enter दबाते हैं, तो यह आपके लिए स्वचालित रूप से हो जाएगा!
अपना गेम व्यू बनाना
आप उन ऐप्स के लिए उपयोग किए जा सकते हैं जो बटन, चित्र और लेबल जैसे विचारों के लेआउट को परिभाषित करने के लिए एक XML स्क्रिप्ट का उपयोग करते हैं। यह क्या लाइन है setContentView हमारे लिए कर रहा है।
लेकिन फिर से, यह एक गेम है जिसका अर्थ है कि इसमें ब्राउज़र विंडो या स्क्रॉल रिसाइकलर दृश्य होने की आवश्यकता नहीं है। इसके बजाय, हम इसके बजाय एक कैनवास दिखाना चाहते हैं। एंड्रॉइड स्टूडियो में एक कैनवास वैसा ही होता है जैसा कि यह कला में है: यह एक ऐसा माध्यम है जिसे हम आकर्षित कर सकते हैं।
इसलिए उस पंक्ति को पढ़ने के लिए इस तरह बदलें:
setContentView (नया GameView (यह))
आप पाएंगे कि यह एक बार फिर से रेखांकित किया गया है। परंतु अभी व यदि आप Alt + Enter दबाते हैं, तो आपके पास कक्षा आयात करने का विकल्प नहीं है। इसके बजाय, आपके पास विकल्प है सर्जन करना एक कक्षा। दूसरे शब्दों में, हम अपना वर्ग बनाने वाले हैं जो यह परिभाषित करेगा कि कैनवास पर क्या होने वाला है। यह वही है जो हमें तैयार विचारों को दिखाने के बजाय, स्क्रीन पर आकर्षित करने की अनुमति देगा।
तो बाईं ओर अपने पदानुक्रम में पैकेज नाम पर राइट क्लिक करें और चुनें नई> कक्षा। अब आपको अपनी कक्षा बनाने के लिए एक विंडो के साथ प्रस्तुत किया जाएगा और आप इसे कॉल करने जा रहे हैं GameView। सुपरक्लास के तहत, लिखें: android.view.SurfaceView जिसका मतलब है कि वर्ग मेथड-व्यू से - अपनी क्षमताओं - विरासत में मिलेगा।
इंटरफ़ेस (एस) बॉक्स में, आप लिखेंगे android.view.SurfaceHolder.Callback। किसी भी वर्ग के साथ के रूप में, हमें अब अपना निर्माता बनाने की आवश्यकता है। इस कोड का उपयोग करें:
निजी MainThread धागा; सार्वजनिक GameView (संदर्भ संदर्भ) {सुपर (संदर्भ); । GetHolder () addCallback (this); }
हर बार हमारी कक्षा को एक नई वस्तु बनाने के लिए बुलाया जाता है (इस मामले में हमारी सतह), यह कंस्ट्रक्टर को चलाएगा और यह एक नई सतह बनाएगा। लाइन 'सुपर' सुपरक्लास कहती है और हमारे मामले में, सर्फेस व्यू है।
कॉलबैक जोड़कर, हम ईवेंट को इंटरसेप्ट करने में सक्षम हैं।
अब कुछ तरीकों को ओवरराइड करें:
@Override सार्वजनिक शून्य भूतल (सरफेसहोल्डर होल्डर, इंट फॉर्मेट, इंट चौड़ाई, इंट हाइट) {}
ये मूल रूप से हमें सुपरक्लास (सरफेस व्यू) में तरीकों (इसलिए नाम) को ओवरराइड करने की अनुमति देते हैं। अब आपको अपने कोड में अधिक लाल अंडरलाइन नहीं होना चाहिए। अच्छा लगा।
आपने अभी एक नई कक्षा बनाई है और हर बार जब हम इसका उल्लेख करते हैं, तो यह आपके गेम को चित्रित करने के लिए कैनवास का निर्माण करेगा। कक्षाएं सर्जन करना वस्तुओं और हमें एक और आवश्यकता है।
धागे बनाना
हमारी नई कक्षा को बुलाया जाएगा MainThread। और इसका काम एक धागा बनाना होगा। एक धागा अनिवार्य रूप से कोड के समानांतर कांटा की तरह होता है जो एक साथ चल सकता है मुख्य आपके कोड का हिस्सा। आपके पास बहुत सारे धागे एक साथ चल सकते हैं, जिससे चीजों को एक सख्त अनुक्रम का पालन करने के बजाय एक साथ होने की अनुमति मिलती है। यह एक खेल के लिए महत्वपूर्ण है, क्योंकि हमें यह सुनिश्चित करने की आवश्यकता है कि यह बहुत सुचारू रूप से चलता रहे, तब भी।
अपनी नई कक्षा बनाएं जैसा आपने पहले किया था और इस बार यह आगे बढ़ने जा रही है धागा। कंस्ट्रक्टर में हम सिर्फ कॉल करने जा रहे हैं सुपर()। याद रखें, यह सुपर क्लास है, जो थ्रेड है, और जो हमारे लिए सभी भारी लिफ्टिंग कर सकता है। यह उन व्यंजनों को धोने के लिए एक कार्यक्रम बनाने जैसा है जो सिर्फ कॉल करते हैं वॉशिंग मशीन().
जब इस वर्ग को बुलाया जाता है, तो यह एक अलग थ्रेड बनाने जा रहा है जो मुख्य चीज़ के ऑफ़शूट के रूप में चलता है। और यह से है यहाँ कि हम अपना GameView बनाना चाहते हैं। इसका मतलब है कि हमें GameView वर्ग को भी संदर्भित करना होगा और हम सरफेसहॉर्ड का उपयोग भी कर सकते हैं जिसमें कैनवास शामिल है। इसलिए यदि कैनवास सतह है, तो सरफेसहॉर्डर चित्रफलक है। और GameView क्या यह सब एक साथ रखता है।
पूरी बात ऐसी दिखनी चाहिए:
सार्वजनिक वर्ग MainTread थ्रेड का विस्तार करता है {निजी सरफेसहार्डर सरफेस; निजी GameView gameView; सार्वजनिक MainThread (सरफेसहोल्डर सरफेसहार्ड, गेम व्यू गेम व्यू) {सुपर (); this.surfaceHolder = SurfaceHolder; this.gameView = gameView; }}
Schweet। अब हमारे पास एक GameView और एक धागा है!
गेम लूप बनाना
अब हमारे पास अपना खेल बनाने के लिए कच्चे माल हैं, लेकिन कुछ भी नहीं हो रहा है। यह वह जगह है जहाँ गेम लूप आता है। मूल रूप से, यह कोड का एक लूप होता है जो गोल और गोल होता है और स्क्रीन खींचने से पहले इनपुट और वेरिएबल्स को चेक करता है। हमारा उद्देश्य इसे यथासंभव संगत बनाना है, ताकि फ्रैमर्ट में कोई स्टेटर या हिचकी न हो, जिसे मैं थोड़ी देर बाद पता लगाऊंगा।
अभी के लिए, हम अभी भी अंदर हैं MainThread क्लास और हम सुपरक्लास की एक विधि को ओवरराइड करने जा रहे हैं। यह एक है रन.
और यह कुछ इस तरह से हो जाता है:
@ ओवरराइड सार्वजनिक शून्य रन () {जबकि (चल रहा है) {कैनवास = अशक्त; {कैनवास = this.surfaceHolder.lockCanvas () आज़माएं; सिंक्रोनाइज़ (सरफेसहॉर्डर) {this.gameView.update (); this.gameView.draw (कैनवास); }} पकड़ (अपवाद ई) {} अंत में {अगर (कैनवास! = null) {कोशिश {सरफेसहोल्ड.कुनलकैनवासऑन्डपोस्ट (कैनवास); } पकड़ (अपवाद ई) {e.printStackTrace (); }}}}}}
आपको बहुत कुछ कम दिखाई देगा, इसलिए हमें कुछ और चर और संदर्भ जोड़ने होंगे। शीर्ष पर वापस जाएं और जोड़ें:
निजी सरफेसहार्ड सरफेसहोल्डर; निजी GameView gameView; निजी बूलियन चल रहा है; सार्वजनिक स्थैतिक कैनवास कैनवास;
कैनवस आयात करना याद रखें। कैनवस वह चीज है जिसे हम वास्तव में चित्रित करेंगे। 'लॉककेन' के लिए, यह महत्वपूर्ण है क्योंकि यह अनिवार्य रूप से कैनवास को जमा देता है जिससे हम उस पर आकर्षित हो सकें। यह महत्वपूर्ण है क्योंकि अन्यथा, आपके पास एक ही बार में इसे खींचने के लिए कई सूत्र हो सकते हैं। बस यह जान लें कि कैनवास को संपादित करने के लिए, आपको पहले होना चाहिए ताला कैनवास।
अपडेट एक ऐसी विधि है जिसे हम बनाने जा रहे हैं और यह वह जगह है जहाँ मज़ेदार चीजें बाद में होंगी।
प्रयत्न तथा पकड़ इस बीच जावा की केवल आवश्यकताएं हैं जो दिखाती हैं कि हम प्रयास करने के लिए तैयार हैं और अपवादों (त्रुटियों) को संभालने के लिए तैयार हैं जो कि कैनवस के लिए तैयार नहीं है आदि।
अंत में, हम अपनी थ्रेड शुरू करने में सक्षम होना चाहते हैं जब हमें इसकी आवश्यकता होती है। ऐसा करने के लिए, हमें यहां एक और विधि की आवश्यकता होगी जो हमें गति में चीजों को सेट करने की अनुमति देती है। यही तो है चल रहा है चर है (ध्यान दें कि एक बूलियन एक प्रकार का चर है जो केवल कभी सही या गलत है)। इस विधि को इसमें जोड़ें MainThread वर्ग:
public void setRunning (बूलियन isRunning) {चलन = isRunning; }
लेकिन इस बिंदु पर, एक बात अभी भी उजागर होनी चाहिए और वह है अद्यतन करें। ऐसा इसलिए है क्योंकि हमने अभी तक अपडेट विधि नहीं बनाई है। तो वापस पॉप में GameView और अब विधि जोड़ें।
सार्वजनिक शून्य अद्यतन () {}
हमें भी करने की जरूरत है प्रारंभ सूत्र! हम अपने में ऐसा करने जा रहे हैं surfaceCreated तरीका:
@ ऑवरराइड सार्वजनिक शून्य सतह (सरफेसहोल्डर होल्डर) {थ्रेड.सेट्राइनाइट (सच); thread.start (); }
जब सतह नष्ट हो जाती है तो हमें धागे को बंद करने की भी आवश्यकता होती है। जैसा कि आपने अनुमान लगाया होगा, हम इसे संभालते हैं surfaceDestroyed तरीका। लेकिन यह देखते हुए कि यह वास्तव में एक धागा को रोकने के लिए कई प्रयास कर सकता है, हम इसे एक लूप में डालेंगे और उपयोग करेंगे प्रयत्न तथा पकड़ फिर। इस तरह:
@ ओवरराइड सार्वजनिक शून्य सतहDestroyed (भूतल धारक) {बूलियन रिट्री = सच; जबकि (पुन: प्रयास) {try {थ्रेड .सेटिंग (झूठी); thread.join (); } catch (InterruptedException e) {e.printStackTrace (); } रिट्री = झूठ; }}
और अंत में, कंस्ट्रक्टर के ऊपर जाएं और अपने धागे की नई आवृत्ति बनाना सुनिश्चित करें, अन्यथा आपको खूंखार अशक्त सूचक अपवाद मिलेगा! और फिर हम GameView को ध्यान केंद्रित करने जा रहे हैं, जिसका अर्थ है कि यह घटनाओं को संभाल सकता है।
थ्रेड = नया MainTread (getHolder (), यह); setFocusable (सही);
अब आप कर सकते हैं आखिरकार वास्तव में इस बात का परीक्षण! यह सही है, रन पर क्लिक करें और यह चाहिए वास्तव में बिना किसी त्रुटि के चलते हैं। उड़ाने की तैयारी करो!
यह एक खाली स्क्रीन है! वह सब कोड। एक रिक्त स्क्रीन के लिए। लेकिन, यह एक रिक्त स्क्रीन है अवसर। आपने घटनाओं को संभालने के लिए गेम लूप के साथ अपनी सतह को ऊपर और नीचे किया है। अब वह सब छोड़ दिया है सामान होता है। यदि आप इस बिंदु तक ट्यूटोरियल में सब कुछ का पालन नहीं करते हैं तो भी यह महत्वपूर्ण नहीं है। बिंदु है, आप शानदार गेम बनाने के लिए इस कोड को रीसायकल कर सकते हैं!
एक ग्राफिक्स कर रहा है
ठीक है, अब हमारे पास खींचने के लिए एक खाली स्क्रीन है, हम सभी को इस पर आकर्षित करने की आवश्यकता है। सौभाग्य से, यह सरल हिस्सा है। तुम सब करने की जरूरत है हमारे में ड्रा विधि को ओवरराइड करने के लिए है GameView कक्षा और फिर कुछ सुंदर चित्र जोड़ें:
@ ओवरराइड सार्वजनिक शून्य ड्रा (कैनवस कैनवास) {सुपर.ड्राइव (कैनवास); if (कैनवस! = null) {कैनवस। विदड्रॉल (Color.WHITE); पेंट पेंट = नया पेंट (); पेंट.सेटकोलर (Color.rgb (250, 0, 0)); कैनवास। निकासी (100, 100, 200, 200, पेंट); }}
इसे चलाएं और अब आपके पास एक अन्यथा सफेद स्क्रीन के बाईं ओर एक सुंदर लाल वर्ग होना चाहिए। यह निश्चित रूप से एक सुधार है।
आप सैद्धांतिक रूप से अपने पूरे खेल को इस विधि के अंदर चिपकाकर (और ओवरराइडिंग) बना सकते हैं onTouchEvent इनपुट संभालना) लेकिन वह चीजों के बारे में बहुत अच्छा तरीका नहीं होगा। हमारे लूप के अंदर नए पेंट रखने से चीजें काफी कम हो जाएंगी और भले ही हम कहीं और डाल दें, बहुत अधिक कोड जोड़ दें खींचना विधि बदसूरत और मुश्किल का पालन करना होगा।
इसके बजाय, यह खेल की वस्तुओं को अपनी कक्षाओं के साथ संभालने के लिए बहुत अधिक समझ में आता है। हम एक के साथ शुरू करने जा रहे हैं जो एक चरित्र दिखाता है और इस वर्ग को बुलाया जाएगा CharacterSprite। आगे बढ़ो और वह बनाओ।
यह वर्ग कैनवास पर एक चित्रण बनाने जा रहा है और ऐसा दिखेगा
सार्वजनिक वर्ग के चरित्र {निजी बिटमैप छवि; सार्वजनिक चरित्र-चित्र (बिटमैप बीएमपी) {छवि = बीएमपी; } सार्वजनिक शून्य ड्रा (कैनवस कैनवास) {कैनवस.ब्रिटमैप (छवि, 100, 100, नल); }}
अब इसका उपयोग करने के लिए, आपको पहले बिटमैप लोड करने की आवश्यकता होगी और फिर कक्षा को कॉल करना होगा GameView। एक संदर्भ जोड़ें निजी चरित्र चित्रण और फिर में surfaceCreated विधि, लाइन जोड़ें:
characterSprite = नई CharacterSprite (BitmapFactory.decodeResource (getResources (), R.drawable.avdgreen));
जैसा कि आप देख सकते हैं, हम जिस बिटमैप को लोड कर रहे हैं उसे संसाधनों में संग्रहीत किया जाता है और इसे एवाग्रीन कहा जाता है (यह पिछले गेम से था)। अब आपको केवल उस बिटमैप को नए वर्ग में पास करना है खींचना इसके साथ विधि:
characterSprite.draw (कैनवास);
अब रन पर क्लिक करें और आपको अपनी स्क्रीन पर अपना ग्राफिक दिखाई देना चाहिए! यह BeeBoo है। मैं उसे अपनी स्कूल की पाठ्यपुस्तकों में शामिल करता था।
क्या होगा अगर हम इस छोटे आदमी को स्थानांतरित करना चाहते हैं? सिंपल: हम सिर्फ उसके पदों के लिए x और y वैरिएबल बनाते हैं और फिर इन मानों को एक में बदलते हैं अद्यतन करें तरीका।
इसलिए अपने संदर्भ जोड़ें CharacterSprite और फिर अपने बिटमैप को ड्रा करें एक्स, वाई। यहां अपडेट विधि बनाएं और अभी हम केवल प्रयास करने जा रहे हैं:
y ++;
हर बार जब गेम लूप चलता है, तो हम स्क्रीन के नीचे वर्ण को स्थानांतरित करेंगे। याद है, y निर्देशांक ऊपर से मापा जाता है 0 स्क्रीन के ऊपर है। बेशक हमें कॉल करने की आवश्यकता है अद्यतन करें में विधि CharacterSprite वहाँ से अद्यतन करें में विधि GameView.
फिर से प्ले प्रेस करें और अब आप देखेंगे कि आपकी छवि धीरे-धीरे स्क्रीन के नीचे आती है। हम अभी तक कोई गेम पुरस्कार नहीं जीत रहे हैं लेकिन यह एक शुरुआत है!
ठीक है, बातें बनाने के लिए थोड़ा अधिक दिलचस्प है, मैं यहाँ कुछ 'उछाल वाली गेंद' कोड छोड़ने जा रहा हूँ। यह उन पुराने विंडोज स्क्रीनसेवर की तरह हमारे ग्राफिक को किनारों से स्क्रीन के चारों ओर उछाल देगा। तुम्हें पता है, अजीब सम्मोहक हैं।
सार्वजनिक शून्य अद्यतन () {x + = xVelocity; y + = yVelocity; अगर ((x & gt; स्क्रीनविद - image.getWidth ()) || (x & lt; 0)) {xVelocity = xVelocity * -1; } अगर ((y & gt; स्क्रीनहाइट - इमेज.गेटहाईट ()) || (y & lt; 0)) {yVelocity = yVelocity * -1; }}
आपको इन चरों को परिभाषित करने की आवश्यकता होगी:
निजी int xVelocity = 10; निजी int yVelocity = 5; निजी int स्क्रीनविद = Resources.getSystem ()। getDisplayMetrics ()। widthPixels; निजी int स्क्रीनहाइट = Resources.getSystem ()। getDisplayMetrics ()। heightPixels;
अनुकूलन
वहाँ है बहुत सारे खिलाड़ी इनपुट से निपटने, छवियों को स्केल करने से लेकर स्क्रीन पर चारों ओर घूमने वाले बहुत सारे वर्णों को प्रबंधित करने के लिए, इसमें और अधिक बदलाव करने के लिए। अभी, चरित्र उछल रहा है, लेकिन अगर आप बहुत करीब से देखते हैं, तो थोड़ा हकलाना है। यह भयानक नहीं है, लेकिन यह तथ्य कि आप इसे नग्न आंखों से देख सकते हैं, यह चेतावनी का संकेत है। गति भी भौतिक डिवाइस की तुलना में एमुलेटर पर बहुत भिन्न होती है। अब सोचिए कि आपके पास क्या होता है टन स्क्रीन पर एक बार चल रहा है!
इस समस्या के कुछ समाधान हैं। जो मैं शुरू करना चाहता हूं, वह एक निजी पूर्णांक बनाना है MainThread और कॉल कि targetFPS। इसका मूल्य 60 होगा।मैं कोशिश कर रहा हूं और अपने खेल को इस गति से चलाऊंगा और इस बीच, मैं यह सुनिश्चित करने के लिए जांच करूंगा। उसके लिए मुझे एक प्राइवेट डबल भी चाहिए averageFPS.
मैं भी अद्यतन करने जा रहा हूँ रन यह मापने के लिए कि प्रत्येक गेम लूप को कितना समय लग रहा है और फिर किस विधि को लेना है ठहराव अगर यह टारगेटपीएस से आगे है तो अस्थायी रूप से वह गेम लूप। फिर हम गणना करने जा रहे हैं कि यह कितने समय के लिए है अभी व लिया और फिर प्रिंट करें ताकि हम इसे लॉग में देख सकें।
@ ओवरराइड सार्वजनिक शून्य रन () {लॉन्ग स्टार्टटाइम; लंबे समय तक; लंबे समय तक प्रतीक्षा करने वाला; लंबा कुल समय = 0; int फ्रेमवर्क = 0; long targetTime = 1000 / targetFPS; जबकि (चल रहा है) {startTime = System.nanoTime (); कैनवास = अशक्त; {कैनवास = this.surfaceHolder.lockCanvas () आज़माएं; सिंक्रोनाइज़ (सरफेसहॉर्डर) {this.gameView.update (); this.gameView.draw (कैनवास); }} कैच (अपवाद e) {} अंत में {if (कैनवास! = null) {try {सरफेसहोल्डर.unlockCanvasAndPost (कैनवास); } पकड़ (अपवाद ई) {e.printStackTrace (); }}} timeMillis = (System.nanoTime () - startTime) / 1000000; WaitTime = targetTime - timeMillis; {{this.sleep (WaitTime) कोशिश करें; } पकड़ (अपवाद ई) {} कुल समय + = System.nanoTime () - startTime; frameCount ++; if (फ्रेमकाउंट == targetFPS) {averageFPS = 1000 / ((टोटल / फ्रेमकाउंट) / 1000000); फ्रेमकाउंट = 0; कुल समय = 0; Println (averageFPS); }}}
अब हमारा खेल इसे 60 तक FPS लॉक करने का प्रयास कर रहा है और आपको यह पता लगाना चाहिए कि यह आमतौर पर आधुनिक डिवाइस पर काफी स्थिर 58-62 FPS को मापता है। एमुलेटर पर हालांकि आपको एक अलग परिणाम मिल सकता है।
60 से 30 बदलने की कोशिश करें और देखें कि क्या होता है। खेल धीमा और यह चाहिए अब अपने logcat में 30 पढ़ें।
विचार बंद करना
प्रदर्शन को अनुकूलित करने के लिए हम कुछ अन्य चीजें भी कर सकते हैं। यहाँ इस विषय पर एक बढ़िया ब्लॉग पोस्ट है। लूप के अंदर पेंट या बिटमैप के नए उदाहरण बनाने से कभी भी परहेज करने की कोशिश करें और सभी शुरुआती करें बाहर खेल शुरू होने से पहले।
यदि आप अगला हिट एंड्रॉइड गेम बनाने की योजना बना रहे हैं तो हैं निश्चित रूप से इन दिनों इसके बारे में जाने के लिए आसान और अधिक कुशल तरीके। लेकिन कैनवास पर आकर्षित करने में सक्षम होने के लिए निश्चित रूप से अभी भी उपयोग के मामले परिदृश्य हैं और यह आपके प्रदर्शनों की सूची में जोड़ने के लिए एक अत्यधिक उपयोगी कौशल है। मुझे आशा है कि इस मार्गदर्शिका ने कुछ हद तक मदद की है और आपके आगामी कोडिंग उपक्रमों में आपको शुभकामनाएं दी हैं!
आगामी – जावा के लिए एक शुरुआती गाइड
