सामग्री

• उभे करणे उभारणे
• आपला गेम दृश्य तयार करत आहे
• थ्रेड तयार करीत आहे
• गेम लूप तयार करत आहे
• ग्राफिक्स करत आहे
• ऑप्टिमायझेशन
• विचार बंद

अँड्रॉइडसाठी गेम तयार करण्याचे बरेच मार्ग आहेत आणि जावासह अँड्रॉइड स्टुडिओमध्ये सुरवातीपासून करण्याचा एक महत्वाचा मार्ग आहे. आपण आपला गेम कसा पहावा आणि कसा वागावा यावर आपल्याला जास्तीत जास्त नियंत्रण मिळते आणि ही प्रक्रिया आपल्याला इतर परिस्थितींमध्ये देखील वापरू शकतील अशी कौशल्ये शिकवते - आपण एखाद्या अ‍ॅपसाठी स्प्लॅश स्क्रीन तयार करत असाल किंवा आपल्याला फक्त इच्छित असल्यास काही अ‍ॅनिमेशन जोडा. हे लक्षात घेऊन हे ट्यूटोरियल आपल्याला Android स्टुडिओ आणि जावा वापरून एक साधा 2 डी गेम कसा तयार करायचा हे दर्शवित आहे. आपण अनुसरणे इच्छित असल्यास आपण गीथब येथे सर्व कोड आणि संसाधने शोधू शकता.

उभे करणे उभारणे

आपला गेम तयार करण्यासाठी आम्हाला काही विशिष्ट संकल्पनांबरोबर सामोरे जाण्याची आवश्यकता आहे: गेम लूप्स, थ्रेड्स आणि कॅनव्हेस. सुरूवातीस, Android स्टुडिओ प्रारंभ करा. आपल्याकडे हे स्थापित केलेले नसल्यास, प्रतिष्ठापन प्रक्रियेच्या पुढे जाणार्‍या Android स्टुडिओची आमची संपूर्ण ओळख पहा. आता एक नवीन प्रकल्प प्रारंभ करा आणि आपण ‘रिक्त गतिविधी’ टेम्पलेट निवडले असल्याचे सुनिश्चित करा. हा एक खेळ आहे, म्हणून अर्थात आपल्याला प्रकरणांमध्ये क्लिष्ट करणारे एफएबी बटण यासारख्या घटकांची आवश्यकता नाही.

आपण करू इच्छित असलेली पहिली गोष्ट म्हणजे ती बदलणे AppCompatActivity करण्यासाठी क्रियाकलाप. याचा अर्थ आम्ही अ‍ॅक्शन बार वैशिष्ट्ये वापरणार नाही.

त्याचप्रमाणे आम्हालाही आपला गेम पूर्ण स्क्रीन बनवायचा आहे. सेटकंटेंट व्ह्यू () वर कॉल करण्यापूर्वी ऑन कोड्रीट () वर खालील कोड जोडा:

getWindow (). सेटफ्लाग (विंडो मॅनेज. लेआउटपाराम.एफएलएजी_फुलसक्रिन, विंडो मॅनेज. लेआउटपाराम.फ्लाग_फुलसक्रेन); this.requestWindowFeature (विंडो. FEATURE_NO_TITLE);

लक्षात ठेवा की आपण काही कोड लिहिला आणि तो लाल रंगात अधोरेखित झाला तर याचा अर्थ असा असू शकतो की आपल्याला वर्ग आयात करण्याची आवश्यकता आहे. दुसर्‍या शब्दांत, आपल्याला Android स्टुडिओला सांगण्याची आवश्यकता आहे की आपण विशिष्ट विधाने वापरू इच्छित आहात आणि ती उपलब्ध करुन देऊ इच्छित आहात. आपण अधोरेखित केलेल्या शब्दावर कुठेही क्लिक केले असल्यास आणि नंतर Alt + Enter दाबा तर ते आपोआपच होईल!

आपला गेम दृश्य तयार करत आहे

आपण बटण, प्रतिमा आणि लेबले यासारख्या दृश्यांचा लेआउट परिभाषित करण्यासाठी XML स्क्रिप्ट वापरणार्‍या अॅप्समध्ये वापरू शकता. हीच ओळ आहे सेट कॉन्टेन्ट व्ह्यू आमच्यासाठी करत आहे.

परंतु पुन्हा हा एक गेम आहे याचा अर्थ ब्राउझर विंडोज किंवा स्क्रोलिंग रीसायकलर दृश्ये असणे आवश्यक नाही. त्याऐवजी आम्हाला त्याऐवजी कॅनव्हास दाखवायचा आहे. अँड्रॉइड स्टुडिओमध्ये कॅनव्हास अगदी कलेप्रमाणेच आहे: हे आपण काढू शकू असे माध्यम आहे.

म्हणून वाचण्यासाठी ती ओळ बदला:

सेट कॉन्टेन्ट व्ह्यू (नवीन गेमव्ही (या))

आपल्याला आढळेल की हे पुन्हा एकदा रेखांकित केले आहे. परंतु आता आपण Alt + Enter दाबल्यास आपल्याकडे वर्ग आयात करण्याचा पर्याय नाही. त्याऐवजी, आपल्याकडे पर्याय आहे तयार करा वर्ग. दुसर्‍या शब्दांत, आम्ही आपला स्वतःचा वर्ग बनवणार आहोत जे कॅनव्हासवर काय जात आहे ते परिभाषित करेल. हे केवळ तयार दृश्ये दर्शविण्याऐवजी आपल्याला स्क्रीनवर आकर्षित करण्यास अनुमती देईल.

तर डावीकडील आपल्या उतरंडातील पॅकेजच्या नावावर उजवे क्लिक करा आणि निवडा नवीन> वर्ग. आपला वर्ग तयार करण्यासाठी आपल्यास आता एक विंडो सादर केले जाईल आणि आपण त्यास कॉल करणार आहात गेम व्ह्यू. सुपरक्लास अंतर्गत, लिहा: android.view.SurfaceView ज्याचा अर्थ असा आहे की वर्गास पद्धती - त्याच्या क्षमता - सर्फेस व्ह्यू वरून वारसा मिळतील.

इंटरफेस (बॉक्स) बॉक्समध्ये, आपण लिहाल android.view.SurfaceHolder.Callback. कोणत्याही वर्गाप्रमाणेच आपल्याला आता आपले कन्स्ट्रक्टर तयार करण्याची आवश्यकता आहे. हा कोड वापरा:

खाजगी मेनथ्रेड धागा; सार्वजनिक गेमव्यू (संदर्भ संदर्भ) {सुपर (संदर्भ); getHolder (). addCallback (हे); }

प्रत्येक वेळी जेव्हा आमच्या वर्गास नवीन ऑब्जेक्ट (या प्रकरणात आमची पृष्ठभाग) बनविण्यास सांगितले जाते तेव्हा ते कन्स्ट्रक्टर चालवेल आणि नवीन पृष्ठभाग तयार करेल. ‘सुपर’ ही ओळ सुपरक्लास कॉल करते आणि आमच्या बाबतीत ते म्हणजे सरफेस व्ह्यू.

कॉलबॅक जोडून, ​​आम्ही कार्यक्रमांमध्ये व्यत्यय आणण्यास सक्षम आहोत.

आता काही पद्धती अधिलिखित करा:

@ ओव्हरराइड पब्लिक शून्य पृष्ठभाग बदलले (सरफेसहोल्डर धारक, इंट फॉरमॅट, इंट रुंदी, इंट उंची)

हे मूलतः आम्हाला सुपरक्लास (सर्फेस व्ह्यू) मधील पद्धती अधिलिखित करण्याची परवानगी देते. आपल्याकडे आता आपल्या कोडमध्ये अधिक लाल अधोरेखित होऊ नये. छान.

आपण नुकताच एक नवीन वर्ग तयार केला आहे आणि प्रत्येक वेळी आम्ही त्याचा संदर्भ घेतो, तो आपल्या गेमवर रंगविण्यासाठी कॅनव्हास तयार करेल. वर्ग तयार करा ऑब्जेक्ट्स आणि आम्हाला आणखी एक आवश्यक आहे.

थ्रेड तयार करीत आहे

आमचा नवीन वर्ग बोलावणार आहे मेनथ्रेड. आणि त्याचे कार्य एक धागा तयार करणे असेल. एक धागा मूलत: कोडच्या समांतर काटासारखा असतो जो की बाजूने एकाच वेळी चालू शकतो मुख्य आपल्या कोडचा एक भाग आपल्याकडे बर्‍याच धागे एकाच वेळी चालू शकतात, ज्यायोगे कठोर क्रमांचे पालन करण्याऐवजी एकाच वेळी गोष्टी घडू शकतात. हे खेळासाठी महत्वाचे आहे, कारण आपल्याकडून हे सुनिश्चित करणे आवश्यक आहे की बरेच काही चालू असतानाही ते सहजतेने चालू आहे.

आपण पूर्वी केले त्याप्रमाणे आपला नवीन वर्ग तयार करा आणि यावेळी त्याचा विस्तार होणार आहे धागा. कन्स्ट्रक्टरमध्ये आम्ही फक्त कॉल करणार आहोत सुपर (). लक्षात ठेवा, हा एक सुपर क्लास आहे, जो थ्रेड आहे आणि जो आपल्यासाठी सर्व भार उचलू शकतो. हे फक्त कॉल करणारे डिश धुण्यासाठी प्रोग्राम तयार करण्यासारखे आहे वॉशिंगमॅचिन ().

जेव्हा हा वर्ग म्हणतात, तेव्हा तो एक वेगळा धागा तयार करणार आहे जो मुख्य गोष्टीच्या ऑफशूट म्हणून चालतो. आणि ते आहे येथे की आम्हाला आमचा गेम व्ह्यू पहायचा आहे. म्हणजेच आम्हाला गेम व्ह्यू वर्गाचा संदर्भ देणे देखील आवश्यक आहे आणि आम्ही कॅनव्हास असलेले सरफेसहोल्डर देखील वापरत आहोत. तर जर कॅनव्हास पृष्ठभाग असेल तर सरफेसहोल्डर हे पिंड आहे. आणि गेम व्ह्यू हे सर्व एकत्र ठेवते.

पूर्ण गोष्ट यासारखी दिसली पाहिजे:

पब्लिक क्लास मेनथ्रेडने धागा वाढविला - खासगी सरफेसहोल्डर पृष्ठभाग होल्डर; खाजगी गेमव्ह्यू गेम व्ह्यू; पब्लिक मेनथ्रेड (सरफेस होल्डर पृष्ठभाग होल्डर, गेम व्ह्यू गेमव्यू) {सुपर (); this.surfaceHolder = पृष्ठवाहक; this.gameView = गेम व्ह्यू; }}

श्वेट. आमच्याकडे आता गेम व्ह्यू आणि थ्रेड आहे!

गेम लूप तयार करत आहे

आमच्याकडे आता आपला खेळ बनविण्यासाठी आवश्यक असलेले कच्चे माल आहे, परंतु काहीही घडत नाही. येथेच गेम लूप येतो. मुळात हा कोडचा एक लूप आहे जो गोल फिरतो आणि स्क्रीन ड्रॉईंग करण्यापूर्वी इनपुट व व्हेरिएबल्सची तपासणी करतो. हे शक्य तितक्या सुसंगत करणे हे आमचे उद्दीष्ट आहे, जेणेकरून फ्रेमरेटमध्ये कोणतेही हकला किंवा हिचकी नाहीत, जे मी थोड्या वेळाने शोधून काढू.

आत्तासाठी, आम्ही अजूनही मध्ये आहोत मेनथ्रेड वर्ग आणि आम्ही सुपरक्लासमधून एक पद्धत अधिलिखित करणार आहोत. हे एक आहे चालवा.

आणि हे असे काहीतरी होते:

@ ओव्हरराइड पब्लिक रिक्त रन () {असताना (चालू आहे) {कॅनव्हास = शून्य; {कॅनव्हास = या.सुरफेस होल्डर.लॉककॅनव्हास () वापरून पहा; समक्रमित (पृष्ठभाग होल्डर) {this.gameView.update (); this.gameView.draw (कॅनव्हास); }} कॅच (अपवाद ई)}} शेवटी {if (कॅनव्हास! = शून्य) {सतहहोल्डर.अनलॉककॅनवासअँडपोस्ट (कॅनव्हास) प्रयत्न करा; } कॅच (अपवाद ई). ई.प्रिंटस्टॅकट्रेस (); }}}}

आपल्याला बर्‍यापैकी अधोरेखित दिसेल, म्हणून आम्हाला आणखी काही व्हेरिएबल्स आणि संदर्भ जोडण्याची आवश्यकता आहे. शीर्षस्थानी परत जा आणि जोडा:

खाजगी सरफेस होल्डर पृष्ठभाग होल्डर; खाजगी गेमव्ह्यू गेम व्ह्यू; खाजगी बुलियन चालू; सार्वजनिक स्थिर कॅनव्हास कॅनव्हास;

कॅनव्हास आयात करणे लक्षात ठेवा. कॅनव्हास ही एक गोष्ट आहे जी आम्ही प्रत्यक्षात काढत आहोत. ‘लॉक कॅनव्हास’ साठी, हे महत्त्वाचे आहे कारण हेच कॅनव्हास आपल्याला त्यास आकर्षित करण्यास अनुमती देते. ते महत्वाचे आहे कारण अन्यथा, आपल्याकडे एकाच वेळी त्यावर अनेक धागे काढण्याचा प्रयत्न होऊ शकेल. फक्त हे जाणून घ्या की कॅनव्हास संपादित करण्यासाठी प्रथम आपण हे करणे आवश्यक आहे लॉक कॅनव्हास.

अद्यतन ही एक पद्धत आहे जी आम्ही तयार करणार आहोत आणि येथून पुढे मजा होईल.

द प्रयत्न आणि झेल दरम्यान, जावाच्या फक्त आवश्यकता आहेत ज्या दर्शवितात की आम्ही कॅनव्हास तयार नसल्यास उद्भवू शकू अशा अपवाद (त्रुटी) हाताळण्यास आणि तयार करण्यास तयार आहोत.

शेवटी, आम्हाला आवश्यक असल्यास आपला धागा सुरू करण्यास सक्षम होऊ इच्छित आहोत. हे करण्यासाठी, आम्हाला येथे आणखी एक पद्धत आवश्यक आहे जी आपल्याला गोष्टी गतिमान करण्यास परवानगी देते. हेच आहे चालू आहे व्हेरिएबल हे आहे (लक्षात ठेवा बुलियन हा एक प्रकार आहे जो केवळ खरा किंवा खोटा असतो). ही पद्धत जोडा मेनथ्रेड वर्ग:

सार्वजनिक शून्य सेट रनिंग (बुलियन isRunning) {कार्यरत = isRunning; }

परंतु याक्षणी, एक गोष्ट अद्याप ठळकपणे दर्शविली पाहिजे आणि ती आहे अद्यतनित करा. कारण आम्ही अद्याप अद्यतन पद्धत तयार केलेली नाही. मध्ये परत पॉप गेम व्ह्यू आणि आता पद्धत जोडा.

सार्वजनिक शून्य अद्यतन () {}

आम्हाला देखील आवश्यक आहे प्रारंभ करा धागा! आम्ही आमच्यामध्ये हे करणार आहोत पृष्ठभाग तयार पद्धत:

@ ओव्हरराइड सार्वजनिक शून्य पृष्ठभाग तयार (सर्फेस होल्डर धारक) {थ्रेड.सेटरनिंग (सत्य); थ्रेड.स्टार्ट (); }

जेव्हा पृष्ठभाग नष्ट होतो तेव्हा आपल्याला धागा देखील थांबविणे आवश्यक आहे. जसे आपण अंदाज केला असेल, आम्ही हे हाताळतो पृष्ठभागस्ट्रॉईड पद्धत. परंतु प्रत्यक्षात धागा थांबायला एकाधिक प्रयत्नांचा प्रयत्न करता येत असल्याने आम्ही हा लूपमध्ये वापरणार आहोत प्रयत्न आणि झेल पुन्हा. आवडले:

@ ओव्हरराइड पब्लिक रिकाम्या पृष्ठभागडस्ट्रॉइड (सरफेसहोल्डर धारक) {बुलियन रीट्री = ट्रू; (पुन्हा प्रयत्न करा) थ्रेड.सेट रनिंग (खोटे) करताना; थ्रेड.जॉइन (); } कॅच (इंटरप्टेक्सप्शन ई). ई.प्रिंटस्टॅकट्रेस (); } पुन्हा प्रयत्न करा = खोटे; }}

आणि शेवटी, कन्स्ट्रक्टरकडे जा आणि आपल्या धाग्याचा नवीन देखावा तयार करण्याचे सुनिश्चित करा, अन्यथा आपल्याला भयानक शून्य पॉईंटर अपवाद मिळेल! आणि मग आम्ही गेमव्यू फोकस करण्यायोग्य बनवणार आहोत म्हणजेच ते इव्हेंट हाताळू शकेल.

थ्रेड = नवीन मेनथ्रेड (गेटहोल्डर (), हे); सेटफोकसेबल (सत्य);

आता आपण हे करू शकता शेवटी प्रत्यक्षात या गोष्टीची चाचणी घ्या! ते ठीक आहे, रन वर क्लिक करा आणि ते पाहिजे प्रत्यक्षात कोणत्याही त्रुटीशिवाय चालवा. उडाण्याची तयारी करा!

हे आहे… ती आहे… रिक्त स्क्रीन! तो सर्व कोड. रिक्त पडद्यासाठी. पण, ही एक रिक्त स्क्रीन आहे संधी. इव्हेंट्स हाताळण्यासाठी आपल्याकडे पृष्ठभाग वर आला आहे आणि गेम लूपसह चालू आहे. आता जे काही शिल्लक आहे ते सामग्री बनविणे बाकी आहे. आपण या टप्प्यापर्यंत ट्यूटोरियल मधील प्रत्येक गोष्टीचे अनुसरण केले नाही तरीही काही फरक पडत नाही. मुद्दा असा आहे की, आपण भव्य खेळ बनविणे प्रारंभ करण्यासाठी या कोडची केवळ रीसायकल करू शकता!

ग्राफिक्स करत आहे

ठीक आहे, आता आपल्याकडे रेखांकित करण्यासाठी एक रिक्त स्क्रीन आहे, आपल्याला त्यास काढणे आवश्यक आहे. सुदैवाने, हा सोपा भाग आहे. आपल्याला फक्त आपल्या मधील अनिर्णित पध्दती अधिलिखित करण्याची आवश्यकता आहे गेम व्ह्यू वर्ग आणि नंतर काही सुंदर चित्रे जोडा:

@ ओव्हरराइड पब्लिक शून्य ड्रॉ (कॅनव्हास कॅनव्हास) {सुपर.ड्राऊ (कॅनव्हास); if (कॅनव्हास! = शून्य) {कॅनव्हास.ड्रॉर कलर (कलर. डब्ल्यूएचआयटीई); पेंट पेंट = नवीन पेंट (); पेंट.सेट कलर (कलर.आरजीबी (250, 0, 0)); कॅनव्हास.ड्रॅब्रॅक्ट (100, 100, 200, 200, पेंट); }}

हे चालवा आणि अन्यथा पांढर्‍या पडद्याच्या डाव्या बाजूस आता आपल्याकडे एक सुंदर लाल चौरस असावा. ही नक्कीच एक सुधारणा आहे.

आपण या संपूर्ण या गेममध्ये चिकटून (आणि अधिलिखित करून) संपूर्ण गेम तात्त्विकरित्या तयार करू शकता onTouchEvent इनपुट हाताळण्यासाठी) परंतु गोष्टींकडे जाण्याचा हा भयंकर चांगला मार्ग नाही. आमच्या पळवाटात नवीन पेंट ठेवणे यामुळे गोष्टी बर्‍यापैकी कमी होईल आणि आम्ही हे दुसर्‍या ठिकाणी ठेवले तरीही बरेच कोड जोडले काढा पद्धत कुरूप आणि अनुसरण करणे कठीण होईल.

त्याऐवजी, गेम ऑब्जेक्ट्सना त्यांच्या स्वत: च्या वर्गासह हाताळण्यास बरेच अर्थ प्राप्त होते. आम्ही एखादे पात्र दर्शविणार्‍या एकासह प्रारंभ करणार आहोत आणि हा वर्ग कॉल केला जाईल कॅरेक्टरस्प्रिट. पुढे जा आणि बनव.

हा वर्ग कॅनव्हास वर एक स्प्राइट काढणार आहे आणि तसा दिसेल

सार्वजनिक वर्ग कॅरेक्टरस्प्रिट {खासगी बिटमॅप प्रतिमा; सार्वजनिक कॅरेक्टरस्प्रिट (बिटमैप बीएमपी) {प्रतिमा = बीएमपी; } सार्वजनिक शून्य ड्रॉ (कॅनव्हास कॅनव्हास) {कॅनव्हास.ड्रॉ बिटमैप (प्रतिमा, 100, 100, शून्य); }}

आता हे वापरण्यासाठी, आपल्याला प्रथम बिटमॅप लोड करणे आवश्यक आहे आणि त्यानंतर वर्गास कॉल करणे आवश्यक आहे गेम व्ह्यू. चा संदर्भ जोडा खाजगी कॅरेक्टरस्प्रिट कॅरेक्टरस्प्रिट आणि नंतर मध्ये पृष्ठभाग तयार पद्धत, ओळ जोडा:

कॅरेक्टरस्प्रिट = नवीन कॅरेक्टरस्प्रिट (बिटमैपफैक्टरी.डेकॉडरेसोर्स (गेटआरसोर्सस (), आर.ड्राव्हेबल.एवडीग्रीन));

आपण पहातच आहात की, आम्ही लोड करीत असलेला बिटमॅप संसाधनात संचयित केलेला आहे आणि त्याला एव्हीडग्रीन म्हणतात (हा मागील गेमचा होता). आपल्याला फक्त त्या बिटमॅपला नवीन वर्गात पास करण्याची आवश्यकता आहे काढा यासह पद्धतः

कॅरेव्हासप्रिट.ड्राऊ (कॅनव्हास);

आता रन वर क्लिक करा आणि आपण आपल्या स्क्रीनवर आपला ग्राफिक दिसला पाहिजे! हे बीबू आहे. मी त्याला माझ्या शाळेच्या पाठ्यपुस्तकांमध्ये काढायचो.

जर आम्हाला या लहान मुलाला हलवायचे असेल तर काय करावे? सोपाः आम्ही त्याच्या पोझिशन्ससाठी x आणि y व्हेरिएबल्स बनवू आणि नंतर ही व्हॅल्यूज an मधे बदलू अद्यतनित करा पद्धत.

आपल्या संदर्भात संदर्भ जोडा कॅरेक्टरस्प्रिट आणि मग आपला बिटमैप येथे काढा x, y. येथे अद्यतन पद्धत तयार करा आणि आत्ता आम्ही फक्त प्रयत्न करणार आहोतः

y ++;

प्रत्येक वेळी गेमची पळवाट चालू असताना, आम्ही वर्ण स्क्रीनवर खाली आणू. लक्षात ठेवा, y निर्देशांक वरुन मोजले जातात 0 स्क्रीनचा वरचा भाग आहे. अर्थात आम्हाला कॉल करणे आवश्यक आहे अद्यतनित करा मध्ये पद्धत कॅरेक्टरस्प्रिट पासून अद्यतनित करा मध्ये पद्धत गेम व्ह्यू.

पुन्हा प्ले दाबा आणि आता आपणास दिसेल की आपली प्रतिमा हळूहळू स्क्रीनच्या खाली ट्रेस करते. आम्ही अद्याप कोणताही खेळ पुरस्कार जिंकत नाही आहोत परंतु ही एक सुरुवात आहे!

ठीक आहे, गोष्टी बनवण्यासाठी किंचित अधिक मनोरंजक, मी येथे काही ‘बाउन्सी बॉल’ कोड टाकणार आहे. हे जुने विंडोज स्क्रीनसेव्हर्स प्रमाणेच कडापासून दूर स्क्रीनभोवती आमचे ग्राफिक बाउन्स करेल. तुम्हाला माहिती आहे, विचित्र आश्चर्यकारक संमोहन.

सार्वजनिक शून्य अद्यतन () {x + = x वेग; y + = yVelocity; if ((x & gt; स्क्रीनविड्थ - image.getWidth ()) || (x & lt; 0)) V xVelocity = xVelocity * -1; } if ((y & gt; स्क्रीनहाइट - image.getHeight ()) || (y & lt; 0)) V yVelocity = yVelocity * -1; }}

आपल्याला हे चल देखील परिभाषित करण्याची आवश्यकता असेल:

खाजगी इंट xVelocity = 10; खाजगी इंट yVelocity = 5; खाजगी इंट स्क्रीनविड्थ = रिसोर्सेस.गेटसिस्टम () .डीटीस्प्लेमेट्रिक्स (). रुंदीपिक्सल; खाजगी इंट स्क्रीनहाइट = रिसोर्सेस.गेटसिस्टम () .गेटडिस्प्लेमेट्रिक्स (). उंचीपिक्सल्स;

ऑप्टिमायझेशन

तेथे आहे भरपूर प्लेअर इनपुट हाताळण्यापासून, स्केलिंग इमेजपर्यंत, एकाच वेळी पडद्याभोवती फिरणारी बर्‍याच वर्णांची व्यवस्था करण्यापर्यंत बरेच काही येथे पहा. आत्ता, चारित्र्य उसळत आहे परंतु जर तुम्ही अगदी जवळून पाहिलेत तर थोडासा हालचाल होईल. ते भयानक नाही परंतु आपण ते उघड्या डोळ्याने पाहू शकता ही एक चेतावणी देणारी चिन्हे आहे. भौतिक डिव्हाइसच्या तुलनेत इम्यूलेटरवरही गती बरेच बदलते. आता कल्पना करा की आपल्याकडे काय होते टन एकदा स्क्रीनवर चालू!

या समस्येवर काही निराकरणे आहेत. मला सुरूवात करण्यासाठी काय करायचे आहे ते म्हणजे खाजगी पूर्णांक तयार करणे मेनथ्रेड आणि त्यास कॉल करा लक्ष्य एफपीएस. याची किंमत 60 असेल.मी प्रयत्न करीत आहे आणि माझा खेळ या वेगाने चालविण्यासाठी मिळवित आहे आणि त्यादरम्यान, मी ते असल्याचे असल्याचे सुनिश्चित करत आहे. त्यासाठी मला एक प्रायव्हेट डबलही पाहिजे आहे सरासरी एफपीएस.

मी देखील अद्यतनित करणार आहे चालवा प्रत्येक गेम पळवाट किती वेळ घेत आहे आणि नंतर कसे मोजते याची पद्धत विराम द्या ते लक्ष्य लूपीस पुढे असल्यास तात्पुरते गेम लूप. आम्ही नंतर हे किती काळ मोजणार आहोत आता घेतला आणि मग प्रिंट करा जेणेकरुन आम्ही ते लॉगमध्ये पाहू शकू.

@ ओव्हरराइड पब्लिक रिक्त रन () start लाँग स्टार्टटाइम; लाँग टाइममेलिस; लांब प्रतीक्षा वेळ; लांब एकूण वेळ = 0; इंट फ्रेमकाउंट = 0; लांब टार्गेटटाइम = 1000 / लक्ष्य एफपीएस; (चालू असताना) {प्रारंभटाइम = सिस्टम.nanoTime (); कॅनव्हास = शून्य; {कॅनव्हास = या.सुरफेस होल्डर.लॉककॅनव्हास () वापरून पहा; समक्रमित (पृष्ठभाग होल्डर) {this.gameView.update (); this.gameView.draw (कॅनव्हास); }} कॅच (अपवाद ई)}} शेवटी {if (कॅनव्हास! = शून्य) {सतहहोल्डर.अनलॉककॅनवासअँडपोस्ट (कॅनव्हास) प्रयत्न करा; } कॅच (अपवाद ई). ई.प्रिंटस्टॅकट्रेस (); ;}} टाइममिलिस = (सिस्टम.नानोटाइम () - स्टार्टटाइम) / 1000000; प्रतीक्षा वेळ = टारगेटटाइम - टाइममिलिस; प्रयत्न करा - हे.स्लीप (वेटटाइम); } कॅच (अपवाद ई)}} टोटलटाइम + = सिस्टम.नॅनोटाइम () - स्टार्टटाइम; फ्रेमकाउंट ++; जर (फ्रेमकाउंट == टार्गेट एफपीएस) {सरासरी एफपीएस = 1000 / ((टोटलटाइम / फ्रेमकाउंट) / 1000000); फ्रेमकाउंट = 0; एकूण वेळ = 0; सिस्टम.आउट.प्रिंटलन (सरासरी एफपीएस); }}}

आता आमचा खेळ तो 60 च्या एफपीएसला लॉक करण्याचा प्रयत्न करीत आहे आणि आपण हे शोधले पाहिजे की ते सामान्यत: आधुनिक डिव्हाइसवर बर्‍यापैकी स्थिर 58-62 एफपीएस मोजते. इमुलेटरवर जरी आपणास भिन्न परिणाम मिळू शकेल.

ते 60 ते 30 बदलून पहा आणि काय होते ते पहा. खेळ मंदावते आणि ते पाहिजे आता आपल्या लॉगकॅटमध्ये 30 वाचा.

विचार बंद

कार्यप्रदर्शन देखील अनुकूलित करण्यासाठी आम्ही करु शकत असलेल्या इतर काही गोष्टी आहेत. या विषयावर येथे एक उत्कृष्ट ब्लॉग पोस्ट आहे. लूपच्या आत पेंट किंवा बिटमैप्सची नवीन घटना कधीही तयार करण्यापासून परावृत्त करण्याचा प्रयत्न करा आणि सर्व प्रारंभ करा बाहेर खेळ सुरू होण्यापूर्वी.

आपण पुढील हिट अँड्रॉइड गेम तयार करण्याचा विचार करत असाल तर तेथे आहेत नक्कीच आजकाल याबद्दल अधिक सुलभ आणि कार्यक्षम मार्ग. परंतु कॅनव्हास वर काढण्यात सक्षम होण्यासाठी अजूनही उपयोगात परिस्थिती नक्कीच आहेत आणि आपल्या रिपोर्टमध्ये जोडणे हे एक अत्यंत उपयुक्त कौशल्य आहे. मला आशा आहे की या मार्गदर्शकाने काही प्रमाणात मदत केली असेल आणि आपल्या आगामी कोडिंग कार्यात शुभेच्छा द्या!

पुढे – जावा साठी नवशिक्या मार्गदर्शक