हम एंड्रॉइड का उपयोग करके एंड्रॉइड के लिए एक गेम लिख रहे हैं। भाग 1

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

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

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

संपत्ति / gfx

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

public class Textures {

private Texture mTexture;
private TextureRegion mLaserGunTextureRegion, mBackgroundTextureRegion;

public Textures(final BaseGameActivity activity, final Engine engine) {
Log.i( "Laser Logic" , "onLoadResources" );
this .mTexture = new Texture(1024, 512,
TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this .mLaserGunTextureRegion = TextureRegionFactory.createFromAsset(
this .mTexture, activity, "gfx/laser_gun.png" , 800, 0);
this .mBackgroundTextureRegion = TextureRegionFactory.createFromAsset(
this .mTexture, activity, "gfx/laser_logic_background.png" , 0, 0);
engine.getTextureManager().loadTexture( this .mTexture);
}

public TextureRegion getBackground(){
return mBackgroundTextureRegion;
}

public TextureRegion getLaserGun(){
return mLaserGunTextureRegion;
}

}

* This source code was highlighted with Source Code Highlighter .

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

चरण 4: हमने बनावट को लोड किया है, अब देखते हैं कि हमें क्या मिला।

public class StageActivity extends BaseGameActivity {

private static final int CAMERA_WIDTH = 800;
private static final int CAMERA_HEIGHT = 480;
private static final int NUMBER_OF_LAYERS = 2;

private Camera mCamera;
private Textures mTextures;

@Override
public void onLoadComplete() {}

@Override
public Engine onLoadEngine() {
this .mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
final EngineOptions options = new EngineOptions( true ,
ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(
getScreenResolutionRatio()), this .mCamera);
return new Engine(options);
}

@Override
public void onLoadResources() {
mTextures = new Textures( this , getEngine());
}

@Override
public Scene onLoadScene() {
Ln.i( "OnLoadScene" );
this .mEngine.registerUpdateHandler( new FPSLogger());

final Scene scene = new Scene(NUMBER_OF_LAYERS);
scene.setBackground( new SpriteBackground( new Sprite(0, 0, mTextures
.getBackground())));
scene.getFirstChild().attachChild( new Sprite(0, 0, mTextures.getLaserGun()));
return scene;
}

private float getScreenResolutionRatio() {
DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
return (( float ) dm.widthPixels) / (( float ) dm.heightPixels);
}

}

* This source code was highlighted with Source Code Highlighter .

यह हमारी मुख्य गतिविधि है, मुझे आशा है कि यह समझाने की आवश्यकता नहीं है कि यह क्या है, जिसे हमें तुरंत बेसगैमाइटिटी से विरासत में प्राप्त करना चाहिए, अन्यथा हम सफल नहीं हुए। उसके बाद, IDE हमें 4 विधियों को ओवरराइड करने की पेशकश करेगा। जिन्हें onLoadEngine-> onLoadResources-> onLoadScene-> onLoadComplete के क्रम में कहा जाता है। आइए श्रृंखला की शुरुआत से शुरू करें यहां हम कैमरा और इंजन को खुद से शुरू करते हैं। मैं getScreenResolutionRatio () पद्धति पर विशेष ध्यान देना चाहता हूं। उसके लिए धन्यवाद, परिणामी तस्वीर पूरी स्क्रीन तक खिंच जाएगी। इस मामले में, अनुपात का सम्मान नहीं किया जाएगा। या हम कैमरे के अनुपात को छोड़ सकते हैं और फिर हमारा गेम कुछ उपकरणों पर पूरी स्क्रीन पर कब्जा नहीं करेगा। बेशक तीसरा विकल्प है - सभी स्क्रीन आकारों के लिए आरंभीकरण लिखने के लिए, लेकिन हम, निश्चित रूप से, अब ऐसा नहीं करेंगे।

इसके बाद, हम अपने बनावट को लोड करते हैं, जिसे हम तब onLoadScene में उपयोग करते हैं। FPSLogger - लॉग में फ्रेम दर का उत्पादन करेगा। और scene.getFirstChild () का अजीब निर्माण हमें हमारे दृश्य की शीर्ष परत का लिंक लौटा देगा। बेशक, हम शीर्ष परत को सीधे दृश्य में शामिल किए बिना कर सकते हैं, लेकिन यह जानना कि आप किस परत को ऑब्जेक्ट जोड़ रहे हैं, अभी भी अधिक सुविधाजनक है।
अब हम देख सकते हैं कि क्या हुआ।


पहले भाग के लिए पर्याप्त है। आप SourceForge पर प्रोजेक्ट कोड पा सकते हैं।
आपका ध्यान देने के लिए धन्यवाद।