Android पर एक सरल 2D गेम बनाएं

सभी को शुभ दिन!

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

समस्या कथन:

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

इस तरह के खेल का एक उदाहरण एंड्रॉइड मार्केट में देखा जा सकता है। हालांकि मैंने दृढ़ता से लहराया, हम केवल एक समान विचार करेंगे।

यहाँ क्या खेल की तरह दिखेगा:

विकास शुरू

एक प्रोजेक्ट बनाएं। लॉन्च ग्रहण - फ़ाइल - एंड्रॉइड प्रोजेक्ट - रक्षा - मुख्य.जावा।

हमारी Main.java फ़ाइल खोलें और नीचे दिए गए कोड को सभी कोड बदलें:

Main.java

public class Main extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //  ,       setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); //  ,     getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN); //    requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(new GameView(this)); } } 

नीचे दिया गया कोड हमारे मुख्य कार्य को बताता है कि आपको विषय की * .xml फ़ाइल नहीं, बल्कि हमारे पास जो क्लास है, उसे चलाने की आवश्यकता है।

 setContentView(new GameView(this)); 

अगला, आपको एक गेम बनाने की आवश्यकता है GameView.java जो हमारे लिए मुख्य वर्ग के रूप में काम करेगा, जिस पर सभी ऑब्जेक्ट तैयार किए जाएंगे। इसके अलावा इस वर्ग में हमारी स्ट्रीम होगी, जिसमें प्रोसेसर में गेम लोड को कम करने के लिए स्ट्रीम में ऑब्जेक्ट्स की ड्राइंग को प्रोसेस किया जाएगा। जब मंच पर कुछ नहीं होता है तो यह वर्ग कैसा दिखेगा:

GameView.java

 import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Random; import towe.def.GameView.GameThread; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.Color; import android.view.MotionEvent; import android.view.SurfaceHolder; import android.view.SurfaceView; public class GameView extends SurfaceView { /**  GameLoopThread*/ private GameThread mThread; public int shotX; public int shotY; /**   */ private boolean running = false; //-------------Start of GameThread--------------------------------------------------\\ public class GameThread extends Thread { /** */ private GameView view; /** */ public GameThread(GameView view) { this.view = view; } /**  */ public void setRunning(boolean run) { running = run; } /** ,    */ public void run() { while (running) { Canvas canvas = null; try { //  Canvas- canvas = view.getHolder().lockCanvas(); synchronized (view.getHolder()) { //   onDraw(canvas); } } catch (Exception e) { } finally { if (canvas != null) { view.getHolder().unlockCanvasAndPost(canvas); } } } } } //-------------End of GameThread--------------------------------------------------\\ public GameView(Context context) { super(context); mThread = new GameThread(this); /*       */ getHolder().addCallback(new SurfaceHolder.Callback() { /***    */ public void surfaceDestroyed(SurfaceHolder holder) { boolean retry = true; mThread.setRunning(false); while (retry) { try { //    mThread.join(); retry = false; } catch (InterruptedException e) { } } } /**    */ public void surfaceCreated(SurfaceHolder holder) { mThread.setRunning(true); mThread.start(); } /**    */ public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { } }); } /**     */ protected void onDraw(Canvas canvas) { canvas.drawColor(Color.WHITE); } } 

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

स्प्रिट निर्माण

स्प्राइट 2 डी गेम में छोटी तस्वीरें हैं जो चारों ओर घूमती हैं। यह पुरुष, गोला-बारूद या बादल भी हो सकते हैं। इस गेम में हमारे पास तीन अलग-अलग प्रकार के स्प्राइट होंगे: निंजा भूत और खोल ।

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

अब इन छवियों को रेस / ड्रा करने योग्य फ़ोल्डर में अपलोड करें ताकि ग्रहण इन छवियों को देख सकें और उन्हें अपने प्रोजेक्ट में पेस्ट कर सकें।

निम्न चित्र को यह समझने में मदद करनी चाहिए कि खिलाड़ी स्क्रीन पर कैसे स्थित होगा।

एक उबाऊ तस्वीर ... चलो इसे बहुत ही खिलाड़ी बनाते हैं।

हमें स्क्रीन पर स्प्राइट लगाने की आवश्यकता है, यह कैसे करना है? हम खिलाड़ी Player.java बनाते हैं और उसमें निम्नलिखित लिखते हैं:

Player.java

 import android.graphics.Bitmap; import android.graphics.Canvas; public class Player { /**  */ GameView gameView; // Bitmap bmp; //     int x; int y; // public Player(GameView gameView, Bitmap bmp) { this.gameView = gameView; this.bmp = bmp; //  this.x = 0; //    this.y = gameView.getHeight() / 2; //   } //   public void onDraw(Canvas c) { c.drawBitmap(bmp, x, y, null); } } 

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

एक और क्लास फ़ाइल बनाएं और इसे Bullet.java कहें, यह क्लास उड़ान, उड़ान की गति और बुलेट के अन्य मापदंडों के निर्देशांक का निर्धारण करेगी। और इसलिए, हमने फ़ाइल बनाई, और उसमें निम्नलिखित लिखें:

Bullet.java

 import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Rect; public class Bullet { /***/ private Bitmap bmp; /***/ public int x; public int y; /**  =15*/ private int mSpeed=25; public double angle; /***/ public int width; /***/ public int height; public GameView gameView; /***/ public Bullet(GameView gameView, Bitmap bmp) { this.gameView=gameView; this.bmp=bmp; this.x = 0; //   this.y = 120; //   this.width = 27; //  this.height = 40; //  //          angle = Math.atan((double)(y - gameView.shotY) / (x - gameView.shotX)); } /** ,  */ private void update() { x += mSpeed * Math.cos(angle); //     mSpeed     angle y += mSpeed * Math.sin(angle); //    -//- } /**  */ public void onDraw(Canvas canvas) { update(); //          canvas.drawBitmap(bmp, x, y, null); } } 

टिप्पणियों से यह स्पष्ट होना चाहिए कि गोली केवल एक कार्रवाई करती है - इसे खिलाड़ी द्वारा बताई गई दिशा में उड़ना चाहिए।

मंच पर स्प्राइट्स ड्रा करें

हमारे द्वारा बनाए गए इन दो वर्गों को खींचने के लिए, हमें GameView.java वर्ग में कोड को संपादित करने की आवश्यकता है, कई तरीकों को जोड़ें जो हमारे चित्रों को हमें वापस कर देंगे। मैं सभी कोड नहीं लिखूंगा, मुझे केवल उन तरीकों का कोड देना होगा जिनकी मुझे आवश्यकता है।

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

GameView टोपी

 private List<Bullet> ball = new ArrayList<Bullet>(); private Player player; Bitmap players; 

इसके बाद, हमें अपनी कक्षाओं में चित्रों को असाइन करने, गेम व्यू कंस्ट्रक्टर खोजने और बहुत अंत में दो लाइनें डालने की आवश्यकता है:

GameView.java - गेम व्यू कंस्ट्रक्टर

 players= BitmapFactory.decodeResource(getResources(), R.drawable.player2); player= new Player(this, guns); 

और onDraw (कैनवस c) विधि में; इन स्प्राइट्स को दिखाई दें। हम सूची में उत्पन्न हमारी वस्तुओं के पूरे संग्रह से गुजरते हैं।

GameView, जावा

  /**     */ protected void onDraw(Canvas canvas) { canvas.drawColor(Color.WHITE); Iterator<Bullet> j = ball.iterator(); while(j.hasNext()) { Bullet b = j.next(); if(bx >= 1000 || bx <= 1000) { b.onDraw(canvas); } else { j.remove(); } } canvas.drawBitmap(guns, 5, 120, null); } 

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

GameView.java

  public Bullet createSprite(int resouce) { Bitmap bmp = BitmapFactory.decodeResource(getResources(), resouce); return new Bullet(this, bmp); } 

अच्छी तरह से और अंत में हम एक और विधि बनाते हैं - ऑनटच (); जो वास्तव में स्क्रीन पर सभी स्पर्शों को पकड़ लेगा और बुलेट को उस बिंदु पर निर्देशित करेगा जहां स्क्रीन पर क्लिक किया गया था।

GameView.java

 public boolean onTouchEvent(MotionEvent e) { shotX = (int) e.getX(); shotY = (int) e.getY(); if(e.getAction() == MotionEvent.ACTION_DOWN) ball.add(createSprite(R.drawable.bullet)); return true; } 

यदि आप यह सुनिश्चित करना चाहते हैं कि क्लिक एक बार संसाधित न हो, अर्थात 1 प्रेस - 1 गोली, और 1 प्रेस - और जब तक आप इसे छोड़ देंगे, तब तक आपको गोली मार दी जाएगी, अगर आपको (e.getAction () == MotionEvent.ACTION_DOWN) {}
और केवल बॉल छोड़ें ।dd (createSprite (R.drawable.bullet)); ।

यही है, हमारे खेल को चलाने और शूट करने का प्रयास करें। यह इस तरह से आना चाहिए:

दुश्मनों

आदेश में कि हम खेलने के लिए ऊब नहीं होंगे, आपको दुश्मन बनाने की जरूरत है। ऐसा करने के लिए, हमें एक और वर्ग बनाना होगा, जिसे Enemy.java कहा जाएगा और जो हमारे दुश्मन को हमारे बेस पर प्रदर्शित और निर्देशित करने में सक्षम होगा। कक्षा काफी सरल है, इसलिए नीचे दिया गया कोड देखें:

Enemy.java

 import java.util.Random; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Rect; public class Enemy { /**   */ public int x; public int y; /***/ public int speed; /**   */ public int width; public int height; public GameView gameView; public Bitmap bmp; /** */ public Enemy(GameView gameView, Bitmap bmp){ this.gameView = gameView; this.bmp = bmp; Random rnd = new Random(); this.x = 900; this.y = rnd.nextInt(300); this.speed = rnd.nextInt(10); this.width = 9; this.height = 8; } public void update(){ x -= speed; } public void onDraw(Canvas c){ update(); c.drawBitmap(bmp, x, y, null); } } 

और इसलिए इस वर्ग में क्या होता है? मैं आपको बताता हूं: हमने अपने दुश्मन, ऊंचाई की चौड़ाई और निर्देशांक के लिए महत्वपूर्ण चर घोषित किए हैं। उन्हें मंच पर रखने के लिए, मैंने रैंडम () वर्ग का उपयोग किया ताकि जब वे मंच पर दिखाई दें, तो वे एक बिंदु पर और अलग-अलग बिंदुओं पर और अलग-अलग निर्देशांक में सब कुछ पर दिखाई दें। हमारी गति भी यादृच्छिक है ताकि प्रत्येक दुश्मन एक अलग गति से चले, हमारी गति 0 से शुरू होती है और 10, 10 पर समाप्त होती है - अधिकतम गति जो दुश्मन तक पहुंच सकती है। वे दाएं से बाएं ओर बढ़ेंगे, ताकि वे तुरंत मंच पर दिखाई न दें, मैंने उन्हें स्क्रीन की दृश्यता के लिए 900 पिक्सेल पर फेंक दिया। इसलिए जब वे पहुंचते हैं तो हमले के लिए पूरी तरह से तैयार करना संभव होगा।

इसके बाद, हमें शत्रु को मंच पर प्रदर्शित करने की आवश्यकता है, इसके लिए GameView.java निम्न कार्य करें:

हम दुश्मनों की एक सूची बनाते हैं ताकि वे कभी खत्म न हों और एक बिटमैप बनाएं जिसमें एक स्प्राइट होगा:

GameView टोपी

 private List<Enemy> enemy = new ArrayList<Enemy>(); Bitmap enemies; 

अगला, स्क्रीन पर दिखाई देने वाले दुश्मनों की गति निर्धारित करने के लिए एक नया धागा बनाएं:

GameView टोपी

 private Thread thred = new Thread(this); 

और हम रनवेबल क्लास को लागू करते हैं, इस तरह से GameView क्लास का इनिशियलाइज़ेशन देखना चाहिए:

 public class GameView extends SurfaceView implements Runnable 

अब आपके ग्रहण के लिए आपको रन () विधि बनाने की आवश्यकता है, इसे बनाएं, यह इस तरह दिखेगा:

GameView वर्ग के बहुत नीचे

 public void run() { while(true) { Random rnd = new Random(); try { Thread.sleep(rnd.nextInt(2000)); enemy.add(new Enemy(this, enemies)); } catch (InterruptedException e) { e.printStackTrace(); } } } 

यहां हम एक स्ट्रीम बनाते हैं जो 0 से 2000 मिलीसेकंड या हर 0, 1 या 2 सेकंड में स्प्राइट बनाएगा।

अब निर्माणकर्ता में हम अंत में दृश्य पर प्रदर्शित करने के लिए कक्षा के साथ अपने स्प्राइट को इनिशियलाइज़ करते हैं:

गेमव्यू कंस्ट्रक्टर

 enemies = BitmapFactory.decodeResource(getResources(), R.drawable.target); enemy.add(new Enemy(this, enemies)); 

और हां, हमें इन तरीकों को onDraw () में घोषित करने की आवश्यकता है; इसका मतलब है कि हम इसमें निम्नलिखित लिखते हैं:

GameView में OnDraw () विधि

 Iterator<Enemy> i = enemy.iterator(); while(i.hasNext()) { Enemy e = i.next(); if(ex >= 1000 || ex <= 1000) { e.onDraw(canvas); } else { i.remove(); } } 

फिर से, हम एक इट्रेटर और चेक का उपयोग करके दुश्मनों के संग्रह के माध्यम से जाते हैं - अगर दुश्मन 1000 पिक्सेल की सीमा से परे चला गया - हम इसे हटा देते हैं, क्योंकि यदि हम मेमोरी को नहीं हटाते हैं, तो यह लोड करना बंद कर देगा और फोन फ्रीज हो जाएगा, लेकिन हम ऐसी समस्याओं से बचते नहीं हैं। पूरा खेल चलने के लिए तैयार है।

हम अपना खेल शुरू करते हैं और हम क्या देखेंगे? और यहाँ है:


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

टकराव का पता लगाना

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

इस फ़ंक्शन के साथ, मैंने अपने आप को पूरी तरह से डुबो दिया, यहां तक ​​कि किसी तरह यह भी निकला कि मैं बाहर निकल गया और सड़क पर टहलने चला गया)) सबसे कठिन तरीका है, हालांकि यह पूरी तरह से हानिरहित दिखता है ...

ठीक है, चलो इस विधि को बनाते हैं और बहुत सी बातें नहीं करते हैं ... कहीं GameView वर्ग के अंत में हम TestCollision () विधि बनाते हैं और निम्नलिखित कोड लिखते हैं:

GameView.java वर्ग के बहुत नीचे

 /*  */ private void testCollision() { Iterator<Bullet> b = ball.iterator(); while(b.hasNext()) { Bullet balls = b.next(); Iterator<Enemy> i = enemy.iterator(); while(i.hasNext()) { Enemy enemies = i.next(); if ((Math.abs(balls.x - enemies.x) <= (balls.width + enemies.width) / 2f) && (Math.abs(balls.y - enemies.y) <= (balls.height + enemies.height) / 2f)) { i.remove(); b.remove(); } } } } 

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

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

Ifa के अंदर, दो आयतों की तुलना की जाती है। मॉड्यूल से होता है (X समन्वयित बुलेट पर गोली माइनस में दुश्मन का निर्देशांक X निर्देशांक पर गोली की चौड़ाई से कम या बराबर होता है, दुश्मन की चौड़ाई / 2 (आयत के केंद्र को खोजने के लिए दो से विभाजित)) और (मॉड्यूल Y समन्वय माइनस से बुलेट है) Y निर्देशांक में दुश्मन बुलेट की चौड़ाई से कम या बराबर है, दुश्मन की चौड़ाई / 2 (आयत के केंद्र को खोजने के लिए दो से विभाजित करें));

और सब कुछ के अंत में, अगर गोली दुश्मन तक पहुंच गई, तो हम उसे दृश्य से मिलते हैं।

खैर, इस फ़ंक्शन को काम करने के लिए, हम इसे रन () विधि में लिखते हैं जो गेम ऑनथ्रेड क्लास में है, हमारे ऑनड्राइव () ड्राइंग विधि के नीचे।

एप्लिकेशन लॉन्च करने के बाद हमें क्या मिलता है: