एक गेम डेवलपमेंट फ्रेमवर्क लिखना - मैकेनिक फ्रेमवर्क

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

हमें क्या चाहिए:

• स्थापित किया गया ग्रहण और Android एसडीके
• जावा या किसी अन्य सी-भाषा की तरह ज्ञान का निर्णय। सर्वश्रेष्ठ उदाहरण - C #
• धैर्य

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


नई Android एप्लिकेशन विंडो दिखाई देती है। कोई भी नाम दर्ज करें (उदाहरण के लिए, मैकेनिक), अपना नाम पैकेज करें, एप्लिकेशन और लक्ष्य संस्करण के लिए Android के न्यूनतम संभव संस्करण का चयन करें, अगला क्लिक करें।


अगला क्लिक करें।


आइकन का चयन करें (यदि आपको एंड्रॉइड आइकन पसंद नहीं है, तो क्लिपआर्ट पर क्लिक करें - चुनें और कुछ चुनें, या अपना खुद का आइकन डालें)।


अगला क्लिक करें।


गतिविधि के लिए एक नाम चुनें, उदाहरण के लिए, MyGame, समाप्त पर क्लिक करें।

.Xml दृश्य संपादन विंडो खुल जाएगी, इसे बंद करें।
AndroidManifest.xml खोलें और इसे अपनी आवश्यकताओं के अनुसार कस्टमाइज़ करें।



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

android:installLocation="preferExternal" 

डिबगिंग के लिए एप्लिकेशन को सुलभ बनाने के लिए, एप्लिकेशन फ़ील्ड में लिखें

 android:debuggable="true" 

एप्लिकेशन में पोर्ट्रेट या लैंडस्केप मोड (इस मामले में लैंडस्केप मोड) में, जिस गतिविधि क्षेत्र में हम लिखते हैं, उसे ठीक करने के लिए

 android:screenOrientation="landscape" 

कीबोर्ड क्रियाओं को संसाधित करने के लिए एमुलेटर पर आवेदन के लिए, हम उसी क्षेत्र में लिखते हैं

 android:configChanges="keyboard|keyboardHidden|orientation" 

जब आप Google Play से एप्लिकेशन डाउनलोड करते हैं, तो आप नोटिस करते हैं कि अनुप्रयोगों को मेमोरी कार्ड / इंटरनेट और अन्य चीजों तक पहुंच की आवश्यकता होती है, और इसलिए, मेमोरी कार्ड पर नियंत्रण पाने और निष्क्रिय होने पर स्क्रीन लॉक को रोकने के लिए, हम लिखते हैं

  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> <uses-permission android:name="android.permission.WAKE_LOCK"/> 

प्रकट कुछ इस तरह दिखाई देगा

 <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.frame" android:versionCode="1" android:versionName="1.0" android:installLocation="preferExternal"> <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="18" /> <application android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" android:debuggable="true" > <activity android:name="com.frame.MyGame" android:screenOrientation="landscape" android:configChanges="keyboard|keyboardHidden|orientation" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> <uses-permission android:name="android.permission.WAKE_LOCK"/> </manifest> 

प्रकट को बंद करें

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

प्रविष्टि

Com.mechanic.input नामक एक नया पैकेज बनाएँ
हम इस पैकेज में इनपुट इंटरफ़ेस बनाते हैं, और इसे इस रूप में लाते हैं

 public interface Input { public static class MechanicKeyEvent { public static final int KEY_DOWN = 0, KEY_UP = 1; public int Type; public int KeyCode; public char KeyChar; } public static class MechanicTouchEvent { public static final int TOUCH_DOWN = 0, TOUCH_UP = 1, TOUCH_DRAGGED = 2; public int Type; public int X, Y; public int Pointer; } public boolean IsKeyPressed(int KeyCode); public boolean IsKeyPressed(char KeyChar); public boolean IsTouchDown(int pointer); public int GetTouchX(int pointer); public int GetTouchY(int pointer); public float GetAccelX(); public float GetAccelY(); public float GetAccelZ(); public List<MechanicTouchEvent> GetTouchEvents(); public List<MechanicKeyEvent> GetKeyEvents(); } 

GetKeyDown - बूलियन मान, कुंजी कोड को स्वीकार करता है और यदि बटन दबाया जाता है तो यह सही है
GetTouchDown - एक बूलियन मान, अगर स्क्रीन को दबाया जाता है, तो यह सही है और यह फ़ंक्शन स्क्रीन को दबाने वाली उंगली की संख्या को लेता है। एंड्रॉइड के पुराने संस्करण मल्टीटच का समर्थन नहीं करते हैं।
GetTouchX - दबाए गए कुंजी का एक्स-समन्वय लौटाता है
GetTouchY - दबाए गए कुंजी का Y- समन्वय लौटाता है
दोनों अंतिम कार्य उंगली संख्या स्वीकार करते हैं
GetAccelX, GetAccelY, GetAccelZ - एक्सेलेरोमीटर के किसी भी समन्वय पर वापसी त्वरण। जब हम फोन को पोर्ट्रेट मोड में लंबवत रखते हैं, तो Y अक्ष के साथ त्वरण 9.6 m / s2 होगा, साथ X और Z अक्ष 0 m / s2।

बाहर की जाँच करें
प्रथम श्रेणी प्रमुख घटना की जानकारी संग्रहीत करता है। टाइप हमेशा या तो KEY_DOWN या KEY_UP होगा। KeyCode और KeyChar क्रमशः एक संख्यात्मक और चरित्र प्रकार में कुंजी मूल्य संग्रहीत करते हैं।
दूसरी कक्षा में, X और Y स्क्रीन को दबाने वाली उंगली के निर्देशांक हैं, पॉइंटर उंगली की संख्या है। TOUCH_DRAGGED का अर्थ है अपनी उंगली हिलाना।

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

ये इंटरफेस हैं

 public interface Accelerometer extends SensorEventListener { public float GetAccelX(); public float GetAccelY(); public float GetAccelZ(); } 

 public interface Keyboard extends OnKeyListener { public boolean IsKeyPressed(int keyCode); public List<KeyEvent> GetKeyEvents(); } 

 public interface Touch extends OnTouchListener { public boolean IsTouchDown(int pointer); public int GetTouchX(int pointer); public int GetTouchY(int pointer); public List<TouchEvent> GetTouchEvents(); } 

यह अनुमान लगाना आसान है कि इनपुट केवल अन्य कक्षाओं के तरीकों को पुनर्निर्देशित करता है, और वे ईमानदारी से काम करते हैं और परिणाम निकालते हैं।

फ़ाइलें

यह फाइलों के साथ काम करने का समय है। हमारा इंटरफ़ेस FileIO कहलाएगा, क्योंकि फ़ाइल वर्ग पहले से मौजूद है।
एक नया पैकेज com.mechanic.fileio और उसमें एक नया इंटरफ़ेस बनाएँ

 public interface FileIO { public InputStream ReadAsset(String name) throws IOException; public InputStream ReadFile(String name) throws IOException; public OutputStream WriteFile(String name) throws IOException; } 

आमतौर पर हम प्रोजेक्ट एसेट फ़ोल्डर में सभी चित्रों, ध्वनियों और अन्य फाइलों को स्टोर करते हैं। पहला कार्य संपत्ति से निर्दिष्ट नाम के साथ एक फ़ाइल खोलता है, एसेट्समैनेजर के साथ अनावश्यक परेशानी से बचने के लिए। उदाहरण के लिए, रिकॉर्ड को बचाने के लिए अंतिम 2 कार्यों की आवश्यकता होती है। जब हम डेटा सहेजते हैं, तो हम डिवाइस के स्टोरेज में जानकारी के साथ एक टेक्स्ट फाइल लिखते हैं और फिर उसे पढ़ते हैं। बस मामले में, "file.txt" की तुलना में अधिक मूल फ़ाइल नाम के साथ आने की कोशिश करें, उदाहरण के लिए, ".mechanicsave" - ​​यह भी संभव है।

आवाज़

पैकेज com.mechanic.audio और नया ऑडियो इंटरफ़ेस बनाएँ

 public interface Audio { public Music NewMusic(String name); public Sound NewSound(String name); } 

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

 public interface Sound { public void Play(float volume); public void Close(); } 

 public interface Music extends OnCompletionListener { public void Close(); public boolean IsLooping(); public boolean IsPlaying(); public boolean IsStopped(); public void Play(); public void SetLooping(boolean loop); public void SetVolume(float volume); public void Stop(); } 

ग्राफिक्स

पैकेज com.mechanic.graphics बनाएँ
ग्राफिक्स इंटरफेस मुख्य रूप से ग्राफिक्स के लिए जिम्मेदार है।
यहाँ उसकी परिभाषा है

 public interface Graphics { public static enum ImageFormat { ARGB_8888, ARGB_4444, RGB_565 } public Image NewImage(String fileName); public void Clear(int color); public void DrawPixel(int x, int y, int color); public void DrawLine(int x, int y, int x2, int y2, int color); public void DrawRect(int x, int y, int width, int height, int color); public void DrawImage(Image image, int x, int y, int srcX, int srcY, int srcWidth, int srcHeight); public void DrawImage(Image image, int x, int y); public int GetWidth(); public int GetHeight(); } 

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

तस्वीरों के लिए एक और इंटरफ़ेस है -

 public interface Image { public int GetWidth(); public int GetHeight(); public ImageFormat GetFormat(); public void Dispose(); } 

सब कुछ पर्याप्त है

केंद्रीकृत खेल प्रबंधन

पैकेज com.mechanic.game बनाएँ
एक महत्वपूर्ण महत्वपूर्ण इंटरफ़ेस है जो पूरे एप्लिकेशन के संचालन का समर्थन करेगा - गेम

 public interface Game { public Input GetInput(); public FileIO GetFileIO(); public Graphics GetGraphics(); public Audio GetAudio(); public void SetScreen(Screen screen); public Screen GetCurrentScreen(); public Screen GetStartScreen(); } 

हम सिर्फ वहां के इंटरफेस को बदलते हैं - पिछले अध्यायों के विषय।
लेकिन स्क्रीन क्या है?

मुझे विचलित कर दो। लगभग हर खेल में कई "राज्य" होते हैं - मुख्य मेनू, सेटिंग्स मेनू, हाईस्कोर स्क्रीन, सभी स्तर, आदि। आदि कोई आश्चर्य नहीं कि कम से कम 5 राज्यों के लिए समर्थन हमें कोड के रसातल में डुबो सकता है। स्क्रीन अमूर्त वर्ग हमें बचाता है

 public abstract class Screen { protected final Game game; public Screen(Game game) { this.game = game; } public abstract void Update(float deltaTime); public abstract void Present(float deltaTime); public abstract void Pause(); public abstract void Resume(); public abstract void Dispose(); } 

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

यह डेल्टा के बारे में थोड़ी बात करने लायक है, 2 कार्यों में पारित किया गया।
अधिक परिष्कृत गेम डेवलपर्स समस्या को जानते हैं जब खेल की गति (उदाहरण के लिए, खिलाड़ी की चाल) सीधे डिवाइस की गति पर निर्भर करती है, अर्थात। अगर हम हर चक्र में चर x को 1 से बढ़ाते हैं, तो ऐसा कभी नहीं होगा कि गेम नेटबुक पर और विशाल रैम वाले कंप्यूटर पर समान रूप से काम करता है।

इस प्रकार, ट्रू संस्करण:

  @Override public void Update(float deltaTime) { x += 150 * deltaTime; } 

ट्रू संस्करण नहीं:

  @Override public void Update(float deltaTime) { x += 150; } 

एक प्राथमिक त्रुटि है - बहुत बार, 1.0f * एक्सट्रीमटाइम से बढ़ते एक्स, यह हमेशा संभव नहीं दिखता है कि 0 से 1 तक एक गैर-पूर्णांक में एक पूर्णांक जोड़ने से कोई परिणाम नहीं मिलता है, x को फ्लोट होना चाहिए

हम स्क्रीन कैसे बदलेंगे? गेम इंटरफ़ेस पर वापस जाएं
सेटस्क्रीन फ़ंक्शन हर चीज के लिए जिम्मेदार है। वर्तमान और प्रारंभ स्क्रीन प्राप्त करने के लिए कार्य भी हैं।

यह इस पूरे संग्रह को लागू करने का समय है!

टाइप करके शुरू करें

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

इसका अर्थ यह है कि हम कचरा संग्रहकर्ता को आवेदन में हस्तक्षेप करने की अनुमति नहीं देते हैं और आवश्यक संसाधनों को बर्बाद नहीं करते हैं

 public class Pool<T> { public interface PoolFactory<T> { public T Create(); } private final List<T> Objects; private final PoolFactory<T> Factory; private final int MaxSize; public Pool(PoolFactory<T> Factory, int MaxSize) { this.Factory = Factory; this.MaxSize = MaxSize; Objects = new ArrayList<T>(MaxSize); } public T NewObject() { T obj = null; if (Objects.size() == 0) obj = Factory.Create(); else obj = Objects.remove(Objects.size() - 1); return obj; } public void Free(T object) { if (Objects.size() < MaxSize) Objects.add(object); } } 

मान लें कि हमारे पास एक पूल पूल ऑब्जेक्ट है। हम इसे कैसे उपयोग करते हैं

  PoolFactory<MechanicTouchEvent> factory = new PoolFactory<MechanicTouchEvent>() { @Override public MechanicTouchEvent Create() { return new MechanicTouchEvent(); } }; TouchEventPool = new Pool<MechanicTouchEvent>(factory, 100); 

पूल की घोषणा

 TouchEventPool.Free(event); 

एक पूल में एक घटना को सहेजना

 event = TouchEventPool.NewObject(); 

पूल से घटना प्राप्त करें। यदि सूची खाली है, तो यह डरावना नहीं है, क्योंकि घटना का उपयोग करने के बाद, हम इसे अगले कॉल तक पूल में वापस रख देते हैं।
बहुत अच्छी बात है!

MechanicAccelerometer

 package com.mechanic.input; import android.content.Context; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorManager; public class MechanicAccelerometer implements Accelerometer { float accelX, accelY, accelZ; public MechanicAccelerometer(Context context) { SensorManager manager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE); if(manager.getSensorList(Sensor.TYPE_ACCELEROMETER).size() > 0) { Sensor accelerometer = manager.getSensorList(Sensor.TYPE_ACCELEROMETER).get(0); manager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_GAME); } } @Override public void onAccuracyChanged(Sensor sensor, int accuracy) { } @Override public void onSensorChanged(SensorEvent event) { accelX = event.values[0]; accelY = event.values[1]; accelZ = event.values[2]; } @Override public float GetAccelX() { return accelX; } @Override public float GetAccelY() { return accelY; } @Override public float GetAccelZ() { return accelZ; } } 

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

MechanicTouch

 package com.mechanic.input; import java.util.ArrayList; import java.util.List; import com.mechanic.input.Input.MechanicTouchEvent; import com.mechanic.input.Pool.PoolFactory; import android.os.Build.VERSION; import android.view.MotionEvent; import android.view.View; public class MechanicTouch implements Touch { boolean EnableMultiTouch; final int MaxTouchers = 20; boolean[] IsTouched = new boolean[MaxTouchers]; int[] TouchX = new int[MaxTouchers]; int[] TouchY = new int[MaxTouchers]; Pool<MechanicTouchEvent> TouchEventPool; List<MechanicTouchEvent> TouchEvents = new ArrayList<MechanicTouchEvent>(); List<MechanicTouchEvent> TouchEventsBuffer = new ArrayList<MechanicTouchEvent>(); float ScaleX; float ScaleY; public MechanicTouch(View view, float scaleX, float scaleY) { if(Integer.parseInt(VERSION.SDK) < 5) EnableMultiTouch = false; else EnableMultiTouch = true; PoolFactory<MechanicTouchEvent> factory = new PoolFactory<MechanicTouchEvent>() { @Override public MechanicTouchEvent Create() { return new MechanicTouchEvent(); } }; TouchEventPool = new Pool<MechanicTouchEvent>(factory, 100); view.setOnTouchListener(this); this.ScaleX = scaleX; this.ScaleY = scaleY; } @Override public boolean onTouch(View v, MotionEvent event) { synchronized (this) { int action = event.getAction() & MotionEvent.ACTION_MASK; @SuppressWarnings("deprecation") int pointerIndex = (event.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >> MotionEvent.ACTION_POINTER_ID_SHIFT; int pointerId = event.getPointerId(pointerIndex); MechanicTouchEvent TouchEvent; switch (action) { case MotionEvent.ACTION_DOWN: case MotionEvent.ACTION_POINTER_DOWN: TouchEvent = TouchEventPool.NewObject(); TouchEvent.Type = MechanicTouchEvent.TOUCH_DOWN; TouchEvent.Pointer = pointerId; TouchEvent.X = TouchX[pointerId] = (int)(event.getX(pointerIndex) * ScaleX); TouchEvent.Y = TouchY[pointerId] = (int)(event.getY(pointerIndex) * ScaleY); IsTouched[pointerId] = true; TouchEventsBuffer.add(TouchEvent); break; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_POINTER_UP: case MotionEvent.ACTION_CANCEL: TouchEvent = TouchEventPool.NewObject(); TouchEvent.Type = MechanicTouchEvent.TOUCH_UP; TouchEvent.Pointer = pointerId; TouchEvent.X = TouchX[pointerId] = (int)(event.getX(pointerIndex) * ScaleX); TouchEvent.Y = TouchY[pointerId] = (int)(event.getY(pointerIndex) * ScaleY); IsTouched[pointerId] = false; TouchEventsBuffer.add(TouchEvent); break; case MotionEvent.ACTION_MOVE: int pointerCount = event.getPointerCount(); for (int i = 0; i < pointerCount; i++) { pointerIndex = i; pointerId = event.getPointerId(pointerIndex); TouchEvent = TouchEventPool.NewObject(); TouchEvent.Type = MechanicTouchEvent.TOUCH_DRAGGED; TouchEvent.Pointer = pointerId; TouchEvent.X = TouchX[pointerId] = (int)(event.getX(pointerIndex) * ScaleX); TouchEvent.Y = TouchY[pointerId] = (int)(event.getY(pointerIndex) * ScaleY); TouchEventsBuffer.add(TouchEvent); } break; } return true; } } @Override public boolean IsTouchDown(int pointer) { synchronized(this) { if(pointer < 0 || pointer >= MaxTouchers) return false; else return IsTouched[pointer]; } } @Override public int GetTouchX(int pointer) { synchronized(this) { if (pointer < 0 || pointer >= MaxTouchers) return 0; else return TouchX[pointer]; } } @Override public int GetTouchY(int pointer) { synchronized(this) { if (pointer < 0 || pointer >= 20) return 0; else return TouchY[pointer]; } } @Override public List<MechanicTouchEvent> GetTouchEvents() { synchronized (this) { for (int i = 0; i < TouchEvents.size(); i++) TouchEventPool.Free(TouchEvents.get(i)); TouchEvents.clear(); TouchEvents.addAll(TouchEventsBuffer); TouchEventsBuffer.clear(); return TouchEvents; } } } 

टच के अलावा, हम OnTouchListener को भी लागू करते हैं
यह निर्धारित करने के लिए EnableMultiTouch की आवश्यकता है कि क्या डिवाइस कई फिंगर प्रेस का समर्थन करता है। यदि VERSION.SDK 5 से कम है (किसी कारण से यह चर स्ट्रिंग के रूप में प्रस्तुत किया गया है), तो यह समर्थन नहीं करता है।
मैक्सटचर्स - उंगलियों की अधिकतम संख्या। उनमें से 20 हैं, शायद कम या ज्यादा।
ऑनटच फ़ंक्शन में, हमें उंगली नंबर और एक्शन (दबाने, उठाने, हिलाने) मिलते हैं, जिसे हम ईवेंट में रिकॉर्ड करते हैं और ईवेंट को सूची में जोड़ते हैं।
GetTouchEvents में हम घटनाओं की एक सूची वापस करते हैं, जो हम उसके बाद स्पष्ट करते हैं। घटनाओं की सूची वापस करने के लिए एक और सूची जिम्मेदार है।
आप पूछ सकते हैं कि ScaleX और ScaleY किसके लिए जिम्मेदार हैं? यह बाद में ग्राफिक्स अनुभाग में चर्चा की जाएगी।

MechanicKeyboard

 package com.mechanic.input; import java.util.ArrayList; import java.util.List; import android.view.KeyEvent; import android.view.View; import com.mechanic.input.Input.MechanicKeyEvent; import com.mechanic.input.Pool.PoolFactory; import com.mechanic.input.Pool; public class MechanicKeyboard implements Keyboard { boolean[] PressedKeys = new boolean[128]; Pool<MechanicKeyEvent> KeyEventPool; List<MechanicKeyEvent> KeyEventsBuffer = new ArrayList<MechanicKeyEvent>(); List<MechanicKeyEvent> KeyEvents = new ArrayList<MechanicKeyEvent>(); public MechanicKeyboard(View view) { PoolFactory<MechanicKeyEvent> pool = new PoolFactory<MechanicKeyEvent>() { @Override public MechanicKeyEvent Create() { return new MechanicKeyEvent(); } }; KeyEventPool = new Pool<MechanicKeyEvent>(pool,100); view.setOnKeyListener(this); view.setFocusableInTouchMode(true); view.requestFocus(); } public boolean IsKeyPressed(int KeyCode) { if(KeyCode < 0 || KeyCode > 127) return false; return PressedKeys[KeyCode]; } public List<MechanicKeyEvent> GetKeyEvents() { synchronized(this) { for(int i = 0; i < KeyEvents.size(); i++) KeyEventPool.Free(KeyEvents.get(i)); KeyEvents.clear(); KeyEvents.addAll(KeyEventsBuffer); KeyEventsBuffer.clear(); return KeyEvents; } } @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if(event.getAction() == KeyEvent.ACTION_MULTIPLE) return false; synchronized(this) { MechanicKeyEvent key = KeyEventPool.NewObject(); key.KeyCode = keyCode; key.KeyChar = (char)event.getUnicodeChar(); if(event.getAction() == KeyEvent.ACTION_DOWN) { key.Type = MechanicKeyEvent.KEY_DOWN; if(keyCode > 0 && keyCode < 128) PressedKeys[keyCode] = true; } if(event.getAction() == KeyEvent.ACTION_UP) { key.Type = MechanicKeyEvent.KEY_UP; if(keyCode > 0 && keyCode < 128) PressedKeys[keyCode] = false; } KeyEventsBuffer.add(key); } return false; } } 

हम 128 बूलियन चर की एक सरणी बनाते हैं, जो दबाए गए या दबाए गए 128 कुंजी के बारे में जानकारी रखेगा। हम वस्तुओं और 2 सूचियों का एक पूल भी बनाते हैं। सब कुछ सरल है

MechanicInput

 package com.mechanic.input; import java.util.List; import android.content.Context; import android.view.View; public class MechanicInput implements Input { MechanicKeyboard keyboard; MechanicAccelerometer accel; MechanicTouch touch; public MechanicInput(Context context, View view, float scaleX, float scaleY) { accel = new MechanicAccelerometer(context); keyboard = new MechanicKeyboard(view); touch = new MechanicTouch(view, scaleX, scaleY); } @Override public boolean IsKeyPressed(int keyCode) { return keyboard.IsKeyPressed(keyCode); } @Override public boolean IsKeyPressed(char keyChar) { return keyboard.IsKeyPressed(keyChar); } @Override public boolean IsTouchDown(int pointer) { return touch.IsTouchDown(pointer); } @Override public int GetTouchX(int pointer) { return touch.GetTouchX(pointer); } @Override public int GetTouchY(int pointer) { return touch.GetTouchY(pointer); } @Override public float GetAccelX() { return accel.GetAccelX(); } @Override public float GetAccelY() { return accel.GetAccelY(); } @Override public float GetAccelZ() { return accel.GetAccelZ(); } @Override public List<MechanicTouchEvent> GetTouchEvents() { return touch.GetTouchEvents(); } @Override public List<MechanicKeyEvent> GetKeyEvents() { return keyboard.GetKeyEvents(); } } 

हम "मुखौटा" पैटर्न का एहसास करते हैं।

अब फाइलों के साथ काम करने का समय आ गया है!

फाइलों के साथ काम करें

MechanicFileIO

 package com.mechanic.fileio; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import android.content.res.AssetManager; import android.os.Environment; public class MechanicFileIO implements FileIO { AssetManager assets; String ExternalStoragePath; public MechanicFileIO(AssetManager assets) { this.assets = assets; ExternalStoragePath = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator; } public InputStream ReadAsset(String name) throws IOException { return assets.open(name); } public InputStream ReadFile(String name) throws IOException { return new FileInputStream(ExternalStoragePath + name); } public OutputStream WriteFile(String name) throws IOException { return new FileOutputStream(ExternalStoragePath + name); } } 

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

अब आवाज पैदा करो

ध्वनियों के साथ काम करना

MechanicSound

 package com.mechanic.audio; import android.media.SoundPool; public class MechanicSound implements Sound { int id; SoundPool pool; public MechanicSound(SoundPool pool, int id) { this.pool = pool; this.id = id; } public void Play(float volume) { pool.play(id, volume, volume, 0, 0, 1); } public void Close() { pool.unload(id); } } 

मैकेनिकऑडियो में, हम साउंडपूल का उपयोग छोटे ध्वनि प्रभाव रखने के लिए करते हैं। मैकेनिकसाउंड में, हम ध्वनि प्रभाव संख्या और साउंडपूल ऑब्जेक्ट को स्वयं पास करते हैं, जिससे हम ध्वनि उत्पन्न करते हैं

MechanicMusic

 package com.mechanic.audio; import java.io.IOException; import android.content.res.AssetFileDescriptor; import android.media.MediaPlayer; public class MechanicMusic implements Music { MediaPlayer Player; boolean IsPrepared = false; public MechanicMusic(AssetFileDescriptor descriptor) { Player = new MediaPlayer(); try { Player.setDataSource(descriptor.getFileDescriptor(), descriptor.getStartOffset(), descriptor.getLength()); Player.prepare(); IsPrepared = true; } catch(Exception ex) { throw new RuntimeException("   "); } } public void Close() { if(Player.isPlaying()) Player.stop(); Player.release(); } public boolean IsLooping() { return Player.isLooping(); } public boolean IsPlaying() { return Player.isPlaying(); } public boolean IsStopped() { return !IsPrepared; } public void Play() { if(Player.isPlaying()) return; try { synchronized(this) { if(!IsPrepared) Player.prepare(); Player.start(); } } catch(IllegalStateException ex) { ex.printStackTrace(); } catch(IOException ex) { ex.printStackTrace(); } } public void SetLooping(boolean loop) { Player.setLooping(loop); } public void SetVolume(float volume) { Player.setVolume(volume, volume); } public void Stop() { Player.stop(); synchronized(this) { IsPrepared = false; } } @Override public void onCompletion(MediaPlayer player) { synchronized(this) { IsPrepared = false; } } } 

हमने ध्वनि फ़ाइल को स्ट्रीम पर रखा और इसे बजाया।
IsPrepared इंगित करता है कि ध्वनि कार्य के लिए तैयार है या नहीं।
मैं खुद को इस वर्ग को समझने की सलाह देता हूं।

हमें मैकेनिकऑडियो मिला

 package com.mechanic.audio; import java.io.IOException; import android.app.Activity; import android.content.res.AssetFileDescriptor; import android.content.res.AssetManager; import android.media.AudioManager; import android.media.SoundPool; public class MechanicAudio implements Audio { AssetManager assets; SoundPool pool; public MechanicAudio(Activity activity) { activity.setVolumeControlStream(AudioManager.STREAM_MUSIC); this.assets = activity.getAssets(); pool = new SoundPool(20, AudioManager.STREAM_MUSIC, 0); } public Music NewMusic(String name) { try { AssetFileDescriptor descriptor = assets.openFd(name); return new MechanicMusic(descriptor); } catch(IOException ex) { throw new RuntimeException("    " + name); } } public Sound NewSound(String name) { try { AssetFileDescriptor descriptor = assets.openFd(name); int id = pool.load(descriptor, 0); return new MechanicSound(pool, id); } catch(IOException ex) { throw new RuntimeException("    " + name); } } } 

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

हम एक ड्राफ्ट्समैन बनाते हैं

ग्राफिक्स के साथ काम करें

MechanicImage

 package com.mechanic.graphics; import com.mechanic.graphics.Graphics.ImageFormat; import android.graphics.Bitmap; public class MechanicImage implements Image { Bitmap bitmap; ImageFormat format; public MechanicImage(Bitmap bitmap, ImageFormat format) { this.bitmap = bitmap; this.format = format; } @Override public int GetWidth() { return bitmap.getWidth(); } @Override public int GetHeight() { return bitmap.getHeight(); } @Override public ImageFormat GetFormat() { return format; } @Override public void Dispose() { bitmap.recycle(); } } 

यह वर्ग एक छवि धारक है। वह कुछ खास नहीं करता, सुविधा के लिए पेश किया गया।

MechanicGraphics

 package com.mechanic.graphics; import java.io.IOException; import java.io.InputStream; import android.content.res.AssetManager; import android.graphics.Bitmap; import android.graphics.Bitmap.Config; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.Paint.Style; import android.graphics.Rect; public class MechanicGraphics implements Graphics { AssetManager assets; Bitmap buffer; Canvas canvas; Paint paint; Rect srcRect = new Rect(), dstRect = new Rect(); public MechanicGraphics(AssetManager assets, Bitmap buffer) { this.assets = assets; this.buffer = buffer; this.canvas = new Canvas(buffer); this.paint = new Paint(); } @Override public Image NewImage(String fileName) { ImageFormat format; InputStream file = null; Bitmap bitmap = null; try { file = assets.open(fileName); bitmap = BitmapFactory.decodeStream(file); if (bitmap == null) throw new RuntimeException("   '" + fileName + "'"); } catch (IOException e) { throw new RuntimeException("   '" + fileName + "'"); } finally { try { if(file != null) file.close(); } catch(IOException e) { } } if (bitmap.getConfig() == Config.RGB_565) format = ImageFormat.RGB_565; else if (bitmap.getConfig() == Config.ARGB_4444) format = ImageFormat.ARGB_4444; else format = ImageFormat.ARGB_8888; return new MechanicImage(bitmap, format); } @Override public void Clear(int color) { canvas.drawRGB((color & 0xff0000) >> 16, (color & 0xff00) >> 8, (color & 0xff)); } @Override public void DrawPixel(int x, int y, int color) { paint.setColor(color); canvas.drawPoint(x, y, paint); } @Override public void DrawLine(int x, int y, int x2, int y2, int color) { paint.setColor(color); canvas.drawLine(x, y, x2, y2, paint); } @Override public void DrawRect(int x, int y, int width, int height, int color) { paint.setColor(color); paint.setStyle(Style.FILL); canvas.drawRect(x, y, x + width - 1, y + width - 1, paint); } @Override public void DrawImage(Image image, int x, int y, int srcX, int srcY, int srcWidth, int srcHeight) { srcRect.left = srcX; srcRect.top = srcY; srcRect.right = srcX + srcWidth - 1; srcRect.bottom = srcY + srcHeight - 1; dstRect.left = x; dstRect.top = y; dstRect.right = x + srcWidth - 1; dstRect.bottom = y + srcHeight - 1; canvas.drawBitmap(((MechanicImage)image).bitmap, srcRect, dstRect, null); } @Override public void DrawImage(Image image, int x, int y) { canvas.drawBitmap(((MechanicImage)image).bitmap, x, y, null); } @Override public int GetWidth() { return buffer.getWidth(); } @Override public int GetHeight() { return buffer.getHeight(); } } 

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

(interesnoe.info वेब संसाधन से लिया गया चित्र)
मान लीजिए कि हमें चित्र 1.1 का स्थान 32.32 से 48.48 तक, 1.1 की स्थिति में खींचने की आवश्यकता है; तो हम ऐसा करते हैं

 DrawImage(image, 1, 1, 32, 32, 16, 16); 

शेष विधियां आसानी से समझ में आती हैं और ब्याज की नहीं हैं।

यह खेल और स्क्रीन इंटरफेस के लिए समय है!

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

 package com.mechanic.game; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Rect; import android.view.SurfaceHolder; import android.view.SurfaceView; public class Runner extends SurfaceView implements Runnable { MechanicGame game; Canvas canvas; Bitmap buffer; Thread thread = null; SurfaceHolder holder; volatile boolean running = false; public Runner(Object context, MechanicGame game, Bitmap buffer) { super(game); this.game = game; this.buffer = buffer; this.holder = getHolder(); } public void Resume() { running = true; thread = new Thread(this); thread.start(); } public void run() { Rect dstRect = new Rect(); long startTime = System.nanoTime(); while(running) { if(!holder.getSurface().isValid()) continue; float deltaTime = (System.nanoTime()-startTime) / 1000000000.0f; startTime = System.nanoTime(); game.GetCurrentScreen().Update(deltaTime); game.GetCurrentScreen().Present(deltaTime); canvas = holder.lockCanvas(); canvas.getClipBounds(dstRect); canvas.drawBitmap(buffer, null, dstRect, null); holder.unlockCanvasAndPost(canvas); } } public void Pause() { running = false; while(true) { try { thread.join(); break; } catch (InterruptedException e) { } } } } 

मैकेनिकगेम वर्ग जल्द ही आ रहा है, चिंता न करें।
उपयोगकर्ता इंटरफ़ेस में नहीं ग्राफिक्स खींचने के लिए, हमें एक सरफेसहार्ड ऑब्जेक्ट की आवश्यकता है। इसके मुख्य कार्य हैं LockCanvas और unlockCanvasAndPost। पहला फ़ंक्शन सरफेस को ब्लॉक करता है और एक कैनवस देता है जिस पर कुछ आकर्षित करने के लिए (हमारे मामले में, बिटमैप बफर, जो एक कैनवास के रूप में कार्य करता है)।
रिज्यूमे फ़ंक्शन में, हम इस वर्ग के साथ एक नया सूत्र शुरू करते हैं।
रन फ़ंक्शन में, जब एप्लिकेशन चल रहा होता है, तो अंतिम चक्र से बीता हुआ समय लिया जाता है (System.nanoTime रिटर्न nanoseconds) और एप्लिकेशन की वर्तमान स्क्रीन के अपडेट और प्रेजेंट फ़ंक्शन को कहा जाता है, जिसके बाद एक बफर खींचा जाता है।

यहां मैकेनिकगेम क्लास है

 package com.mechanic.game; import com.mechanic.audio.Audio; import com.mechanic.audio.MechanicAudio; import com.mechanic.fileio.FileIO; import com.mechanic.fileio.MechanicFileIO; import com.mechanic.graphics.Graphics; import com.mechanic.graphics.MechanicGraphics; import com.mechanic.input.Input; import com.mechanic.input.MechanicInput; import android.app.Activity; import android.content.Context; import android.content.res.Configuration; import android.graphics.Bitmap; import android.graphics.Bitmap.Config; import android.os.Bundle; import android.os.PowerManager; import android.os.PowerManager.WakeLock; import android.view.Window; import android.view.WindowManager; public abstract class MechanicGame extends Activity implements Game { Runner runner; Graphics graphics; Audio audio; Input input; FileIO fileIO; Screen screen; WakeLock wakeLock; static final int SCREEN_WIDTH = 80; static final int SCREEN_HEIGHT = 128; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); boolean IsLandscape = (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE); int frameBufferWidth = IsLandscape ? SCREEN_HEIGHT : SCREEN_WIDTH; int frameBufferHeight = IsLandscape ? SCREEN_WIDTH : SCREEN_HEIGHT; Bitmap frameBuffer = Bitmap.createBitmap(frameBufferWidth, frameBufferHeight, Config.RGB_565); float scaleX = (float) frameBufferWidth / getWindowManager().getDefaultDisplay().getWidth(); float scaleY = (float) frameBufferHeight / getWindowManager().getDefaultDisplay().getHeight(); runner = new Runner(null, this, frameBuffer); graphics = new MechanicGraphics(getAssets(), frameBuffer); fileIO = new MechanicFileIO(getAssets()); audio = new MechanicAudio(this); input = new MechanicInput(this, runner, scaleX, scaleY); screen = GetStartScreen(); setContentView(runner); PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE); wakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, "Game"); } @Override public Input GetInput() { return input; } @Override public FileIO GetFileIO() { return fileIO; } @Override public Graphics GetGraphics() { return graphics; } @Override public Audio GetAudio() { return audio; } @Override public void SetScreen(Screen screen) { if (screen == null) throw new IllegalArgumentException("Screen    null"); this.screen.Pause(); this.screen.Dispose(); screen.Resume(); screen.Update(0); this.screen = screen; } @Override public Screen GetCurrentScreen() { return screen; } @Override public Screen GetStartScreen() { return null; } @Override public void onResume() { super.onResume(); wakeLock.acquire(); screen.Resume(); runner.Resume(); } @Override public void onPause() { super.onPause(); wakeLock.release(); runner.Pause(); screen.Pause(); if(isFinishing()) screen.Dispose(); } } 

इस वर्ग में रनर ऑब्जेक्ट्स, हमारे सभी इंटरफेस और कक्षाएं और एक वेकॉक ऑब्जेक्ट (आवश्यक है ताकि गेम चलने पर फोन सो न जाए)

इसमें 2 स्थिरांक भी हैं - SCREEN_WIDTH और SCREEN_HEIGHT, जो बहुत महत्वपूर्ण हैं!
उपकरणों में कई संकल्प होते हैं, और प्रत्येक डिवाइस के लिए छवियों के आकार को समायोजित करने, स्थान की गणना करने, आदि के लिए यह लगभग असंभव और व्यर्थ है। आदिकल्पना कीजिए कि हमारे पास 80x128 पिक्सेल (दो ऊपर वाले स्थिरांक) से मापने वाली एक खिड़की है। हम इस विंडो में छोटी तस्वीरें खींचते हैं। लेकिन अचानक डिवाइस का स्क्रीन आकार इस विंडो के आकार में फिट नहीं होता है। क्या करें?सब कुछ बहुत सरल है - हम अपनी खिड़की की चौड़ाई और लंबाई के अनुपात को डिवाइस की चौड़ाई और लंबाई तक ले जाते हैं और इस अनुपात को देखते हुए सभी चित्रों को खींचते हैं।
नतीजतन, एप्लिकेशन स्वयं डिवाइस की स्क्रीन के नीचे चित्रों को फैलाता है।

इस वर्ग में गतिविधि शामिल है और इसमें onCreate, onResume और onPause के तरीके हैं।
ऑनक्रिएट में, एप्लिकेशन पहले फ़ुल-स्क्रीन मोड में चला जाता है (ताकि चार्जिंग और समय शीर्ष पर दिखाई न दे)। फिर यह फोन - परिदृश्य या चित्र (जो पहले से ही लेख की शुरुआत में .xml फ़ाइल में लिखा गया है) के उन्मुखीकरण का पता लगाता है। फिर एक लंबे समय से प्रतीक्षित बफर 80x128 पिक्सल की इस खिड़की के आकार के साथ बनाया जाता है, इस विंडो का आकार डिवाइस के आकार के लिए, जो मैकेनिकइन्पुट कंस्ट्रक्टर को पास किया गया है, पता चला है, यह बदले में मैकेनिकटच से संबंध पारित करता है। और यहाँ - बिंगो! स्क्रीन पर परिणामी स्पर्श बिंदुओं को इस अनुपात से गुणा किया जाता है, इसलिए क्लिक के निर्देशांक डिवाइस के आकार से स्वतंत्र होते हैं।
अगला, हम अपना इंटरफेस बनाते हैं, रनर और वेकॉक को पंजीकृत करते हैं।
सेटस्क्रीन विधि में, हम वर्तमान स्क्रीन को मुक्त करते हैं और दूसरी स्क्रीन लिखते हैं।
ब्याज के अन्य तरीके प्रदान नहीं करते हैं।

क्या वह सब है?

हाँ, सज्जनों, ढांचा तैयार है!
जब हो गया।

और अब मुख्य वर्ग के साथ फ्रेमवर्क को कैसे जोड़ा जाए, उदाहरण के लिए, MyGame के साथ?

"मुख्य" वर्ग कुछ इस तरह दिखता है

 public class MyGame extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_my_game); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.my_game, menu); return true; } } 

हम इसे इस कक्षा में संशोधित करते हैं

 package com.mechanic; import com.mechanic.game.MechanicGame; import com.mechanic.game.Screen; public class MyGame extends MechanicGame { @Override public Screen GetStartScreen() { return new GameScreen(this); } } 

जावा इस वर्ग को गतिविधि से विरासत के रूप में मानता है, क्योंकि मैकेनिकगेम स्वयं गतिविधि से विरासत में मिला है। onCreate पहले से ही पंजीकृत है, और केवल एक चीज जो हमें करने की आवश्यकता है वह है GetStartScreen () को ओवरराइड करना, क्योंकि यह विधि मैकेनिकगेम में अशक्त है, और यह एक त्रुटि फेंकता है।
GameScreen वर्ग को लागू करना याद रखें :)

 package com.mechanic; import com.mechanic.game.Game; import com.mechanic.game.Screen; import com.mechanic.graphics.Graphics; import com.mechanic.graphics.Image; public class GameScreen extends Screen { Graphics g = game.GetGraphics(); Image wikitan; float x = 0.0f; public GameScreen(Game game) { super(game); wikitan = g.NewImage("wikipetan.png"); } @Override public void Update(float deltaTime) { if(game.GetInput().IsTouchDown(0)) x += 1.0f * deltaTime; } @Override public void Present(float deltaTime) { g.Clear(0); g.DrawImage(wikitan, (int)x, 0); } @Override public void Pause() { } @Override public void Resume() { } @Override public void Dispose() { wikitan.Dispose(); } } 

यह एक स्क्रीन कार्यान्वयन का एक सरल उदाहरण है जो विकिपीडिया-टैन छवि डाउनलोड करता है और स्क्रीन पर क्लिक करके इसे स्थानांतरित करता है।

(छवि ru.wikipedia.org वेब संसाधन से ली गई है)

परिणाम


चर x को एक फ्लोट के रूप में दर्शाया गया है, क्योंकि 0 से 1 तक संख्याओं को जोड़ने से कुछ नहीं होता है, गोलाई चल रही है।
विकिप्प-टैन में वृद्धि हुई है, क्योंकि हमारे कैनवास का आकार 80x128 पिक्सल है

प्रश्न और उत्तर:

- मेरी तस्वीर को गलत तरीके से खींचा गया है - 90 डिग्री घुमाया गया!
- यह सब इसलिए है क्योंकि हमने xml फ़ाइल में कमांड केवल लैंडस्केप मोड में काम करने के लिए दी थी। मोड को स्विच करने के लिए, कीबोर्ड के दाईं ओर कुंजी 7 दबाएं
- मैं ईमानदारी से x + = 1.0f * डेल्टा बदल देता हूं, लेकिन चित्र धीरे-धीरे नहीं चलता है या नहीं चलता है। क्या करें?
- एमुलेटर बहुत धीमी चीज है। डिवाइस पर एप्लिकेशन के स्वास्थ्य की जांच करें।

मजा आ गया!

स्रोत:
rghost.ru/49052713
github.com/Izaron/MechanicFramework
साहित्य:
developer.alexanderklimov.ru/android
habrahabr.ru/post/109944
मारियो टेंचर की पुस्तक "एंड्रॉइड के लिए प्रोग्रामिंग गेम्स"