Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android游戲 >> Android游戲開發 >> Android游戲開發的入門實例

Android游戲開發的入門實例

編輯：Android游戲開發

       在Android系統上開發游戲是Android開發學習者所向往的，有成就感也有樂趣，還能取得經濟上的報酬。那怎樣開發Android游戲呢？下面介紹一個簡單的入門實例。

       一、創建新工程　　

       首先，我們在Eclipse中新建一個名為Movement的工程，並且選擇合適的Android SDK，在這裡，我們選用的API是比較低的1.5版本，這樣可以讓其適應性更強。接下來，我們新建兩個類，一個是UpdateThread類，一個是SurfaceView類，它們在項目中分別是負責處理線程和畫面的兩個類，在接下來會有詳細介紹，如下圖，分別建立這兩個類，注意選擇正確它們繼承的父類：
 

Android游戲開發的入門實例

Android游戲開發的入門實例

       在建立完成後，系統的項目結構看上去應該象如下的樣子：

Android游戲開發的入門實例

       二、編寫Movment.java啟動程序

       任何一個Android應用都必須有一個主啟動程序來啟動，我們這裡把這個啟動程序命名為Movment,代碼很簡單如下：

Java代碼
  1. public class Movement extends Activity  {   
  2.  @Override  
  3.  public void onCreate(Bundle savedInstanceState) {   
  4.   
  5.      super.onCreate(savedInstanceState);   
  6.      setContentView(new MovementView(this));   
  7.  }   

　　注意的是，我們這個啟動程序不象其他程序一樣，在啟動的時候，在setContentView中傳入界面布局文件，而是直接將MovementView的實例傳遞進來，也就是說，直接啟動了MovementView這個類，在這個類中，我們將繪畫我們的小球。

       三、什麼是SurfaceView

       在Android中，SurfaceView是一個重要的繪圖容器，它可以可以直接從內存或者DMA等硬件接口取得圖像數據。通常情況程序的View和用戶響應都是在同一個線程中處理的，這也是為什麼處理長時間事件(例如訪問網絡)需要放到另外的線程中去(防止阻塞當前UI線程的操作和繪制)。但是在其他線程中卻不能修改UI元素，例如用後台線程更新自定義View(調用View的在自定義View中的onDraw函數)是不允許的。

       如果需要在另外的線程繪制界面、需要迅速的更新界面或則渲染UI界面需要較長的時間，這種情況就要使用SurfaceView了。SurfaceView中包含一個Surface對象，而Surface是可以在後台線程中繪制的。

       在本文中，我們將使用它，直接通過代碼創建一個小球，並且隨著UpdateThread線程的更新，不斷改變小球的位置，下面我們開始學習MovementView的編寫，先看下如何運用SurfaceView。

       首先導入SurfaceView及繪圖的相關庫文件，如下所示：

Java代碼
  1. package example.movement;   
  2.   
  3. import android.content.Context;   
  4. import android.graphics.Canvas;   
  5. import android.graphics.Color;   
  6. import android.graphics.Paint;   
  7. import android.graphics.Rect;   
  8. import android.view.SurfaceHolder;   
  9. import android.view.SurfaceView;  

　　接著，我們要繼承SurfaceView並且實現SurfaceHolder.Callback接口，這是一個SurfaceHolder的內部接口，可以實現該接口獲得界面改變的信息，代碼如下，並且我們聲明了一些成員變量：

Java代碼
  1. public class MovementView extends SurfaceView implements SurfaceHolder.Callback {   
  2.     private int xPos;   
  3.     private int yPos;   
  4.   
  5.     private int xVel;   
  6.     private int yVel;   
  7.   
  8.     private int width;   
  9.     private int height;   
  10.   
  11.     private int circleRadius;   
  12.     private Paint circlePaint;   
  13.   
  14.     UpdateThread updateThread;   
  15. }   

        而在MovementView的構造函數中，我們設置了小球的大小和在X,Y方向上的初始坐標，如下：  

Java代碼    
  1. 　　public MovementView(Context context) {      
  2.     super(context);      
  3.     getHolder().addCallback(this);      
  4.      
  5.     circleRadius = 10;      
  6.     circlePaint = new Paint();      
  7.     circlePaint.setColor(Color.BLUE);      
  8.      
  9.     xVel = 2;      
  10.     yVel = 2;      
  11. }      
  12.      

       接著我們來看下ondraw方法的編寫，在這裡，我們將繪畫小球，並且每次都把畫布Canvas的背景色設置為白色，以重新覆蓋之前一幀，代碼如下：

Java代碼
  1. protected void onDraw(Canvas canvas) {   
  2.   
  3.         canvas.drawColor(Color.WHITE);   
  4.   
  5.         canvas.drawCircle(xPos, yPos, circleRadius, circlePaint);   
  6. }   

       我們再來看下updatePhysics這個方法如何編寫。這個方法的作用有兩個：一是處理小球的運動，二是更新小球的實時位置，因為小球在屏幕中不斷地運動，因此當小球到達比如屏幕繪畫區域的頂端後，要被彈回，因此代碼如下：

Java代碼
  1. public void updatePhysics() {   
  2.   
  3. //更新當前的x,y坐標   
  4.         xPos += xVel;   
  5.         yPos += yVel;   
  6.   
  7.         if (yPos - circleRadius < 0 || yPos + circleRadius > height) {   
  8.   
  9.                
  10.             if (yPos - circleRadius < 0) {   
  11.   
  12.                 //如果小球到達畫布區域的上頂端，則彈回   
  13.   
  14.                 yPos = circleRadius;   
  15.             }else{   
  16.   
  17.                 //如果小球到達了畫布的下端邊界，則彈回   
  18.   
  19.                 yPos = height - circleRadius;   
  20.             }   
  21.   
  22.             // 將Y坐標設置為相反方向   
  23.             yVel *= -1;   
  24.         }   
  25.         if (xPos - circleRadius < 0 || xPos + circleRadius > width) {   
  26.   
  27.                
  28.             if (xPos - circleRadius < 0) {   
  29.   
  30.                 // 如果小球到達左邊緣   
  31.   
  32.                 xPos = circleRadius;   
  33.             } else {   
  34.   
  35.                 // 如果小球到達右邊緣   
  36.   
  37.                 xPos = width - circleRadius;   
  38.             }   
  39.   
  40.             // 重新設置x軸坐標   
  41.             xVel *= -1;   
  42.         }   
  43.     }   
  44.   

       最後我們看下surfaceCreated這個方法的代碼，在這個方法中，主要是取得了可用的SurfaceView的區域的高度和寬度，然後設置了小球的起始坐標(將其設置在屏幕的正中央位置)，並且啟動了UpdateThread線程，代碼如下：

Java代碼
  1. public void surfaceCreated(SurfaceHolder holder) {   
  2.   
  3.         Rect surfaceFrame = holder.getSurfaceFrame();   
  4.         width = surfaceFrame.width();   
  5.         height = surfaceFrame.height();   
  6.   
  7.         xPos = width / 2;   
  8.         yPos = circleRadius;   
  9.   
  10.         updateThread = new UpdateThread(this);   
  11.         updateThread.setRunning(true);   
  12.         updateThread.start();   
  13.     }   

       此外，我們要補上surfaceChanged這個方法，這個方法意思是界面尺寸改變時才調用，在我們這個應用中並沒用到，所以我們保留為空的方法實現：

Java代碼
  1. public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)   
  2.     {   
  3.   
  4.     }   

       而surfaceDestroyed方法中，主要實現的是界面被銷毀時才調用，這裡我們停止了當前的線程所處理的任務，這裡使用了線程的join方法：

Java代碼
  1. public void surfaceDestroyed(SurfaceHolder holder) {   
  2.   
  3.         boolean retry = true;   
  4.   
  5.         updateThread.setRunning(false);   
  6.         while (retry) {   
  7.             try {   
  8.                 updateThread.join();   
  9.                 retry = false;   
  10.             } catch (InterruptedException e) {   
  11.   
  12.             }   
  13.         }   
  14.     }   

       歸納下，完整的MovementView代碼如下：

Java代碼
  1. 　　package example.movement;   
  2.   
  3. import android.content.Context;   
  4. import android.graphics.Canvas;   
  5. import android.graphics.Color;   
  6. import android.graphics.Paint;   
  7. import android.graphics.Rect;   
  8. import android.view.SurfaceHolder;   
  9. import android.view.SurfaceView;   
  10.   
  11. public class MovementView extends SurfaceView implements SurfaceHolder.Callback {   
  12.   
  13.     private int xPos;   
  14.     private int yPos;   
  15.   
  16.     private int xVel;   
  17.     private int yVel;   
  18.   
  19.     private int width;   
  20.     private int height;   
  21.   
  22.     private int circleRadius;   
  23.     private Paint circlePaint;   
  24.   
  25.     UpdateThread updateThread;   
  26.   
  27.     public MovementView(Context context) {   
  28.   
  29.         super(context);   
  30.         getHolder().addCallback(this);   
  31.   
  32.         circleRadius = 10;   
  33.         circlePaint = new Paint();   
  34.         circlePaint.setColor(Color.BLUE);   
  35.   
  36.         xVel = 2;   
  37.         yVel = 2;   
  38.     }   
  39.     @Override  
  40.     protected void onDraw(Canvas canvas) {   
  41.   
  42.         canvas.drawColor(Color.WHITE);   
  43.         canvas.drawCircle(xPos, yPos, circleRadius, circlePaint);   
  44.     }   
  45.   
  46.     public void updatePhysics() {   
  47.         xPos += xVel;   
  48.         yPos += yVel;   
  49.   
  50.         if (yPos - circleRadius < 0 || yPos + circleRadius > height) {   
  51.             if (yPos - circleRadius < 0) {   
  52.                 yPos = circleRadius;   
  53.             }else{   
  54.                 yPos = height - circleRadius;   
  55.             }   
  56.             yVel *= -1;   
  57.         }   
  58.         if (xPos - circleRadius < 0 || xPos + circleRadius > width) {   
  59.             if (xPos - circleRadius < 0) {   
  60.                 xPos = circleRadius;   
  61.             } else {   
  62.                 xPos = width - circleRadius;   
  63.             }   
  64.             xVel *= -1;   
  65.         }   
  66.     }   
  67.   
  68.     public void surfaceCreated(SurfaceHolder holder) {   
  69.   
  70.         Rect surfaceFrame = holder.getSurfaceFrame();   
  71.         width = surfaceFrame.width();   
  72.         height = surfaceFrame.height();   
  73.   
  74.         xPos = width / 2;   
  75.         yPos = circleRadius;   
  76.   
  77.         updateThread = new UpdateThread(this);   
  78.         updateThread.setRunning(true);   
  79.         updateThread.start();   
  80.     }   
  81.   
  82.     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {   
  83.     }   
  84.   
  85.     public void surfaceDestroyed(SurfaceHolder holder) {   
  86.   
  87.         boolean retry = true;   
  88.   
  89.         updateThread.setRunning(false);   
  90.         while (retry) {   
  91.             try {   
  92.                 updateThread.join();   
  93.                 retry = false;   
  94.             } catch (InterruptedException e) {   
  95.             }   
  96.         }   
  97.     }   
  98. }   

       四、UpdateThread線程程序

       下面，我們開始著手編寫UpdateThread線程程序。這個程序主要是啟動一個線程去不斷更新當前小球的位置。先看聲明及構造函數部分：

Java代碼
  1. package licksquid.movement;   
  2.   
  3. import android.graphics.Canvas;   
  4. import android.view.SurfaceHolder;   
  5.   
  6. public class UpdateThread extends Thread {   
  7.     private long time;   
  8.     private final int fps = 20;   
  9.     private boolean toRun = false;   
  10.     private MovementView movementView;   
  11.     private SurfaceHolder surfaceHolder;   
  12.   
  13. }   
  14. public UpdateThread(MovementView rMovementView) {   
  15.         movementView = rMovementView;   
  16.         surfaceHolder = movementView.getHolder();   
  17.     }   
  18. 　public void setRunning(boolean run) {   
  19.         toRun = run;   
  20.     }   

        注意這裡的setRunning方法中設置了線程是否應該停止的標記，下面來看重要的方法run:

Java代碼
  1. public void run() {   
  2.   
  3.         Canvas c;   
  4.         while (toRun) {   
  5.   
  6.             long cTime = System.currentTimeMillis();   
  7.   
  8.             if ((cTime - time) <= (1000 / fps)) {   
  9.   
  10.                 c = null;   
  11.                 try {   
  12.                     c = surfaceHolder.lockCanvas(null);   
  13.   
  14.                     movementView.updatePhysics();   
  15.                     movementView.onDraw(c);   
  16.                 } finally {   
  17.                     if (c != null) {   
  18.                         surfaceHolder.unlockCanvasAndPost(c);   
  19.                     }   
  20.                 }   
  21.             }   
  22.             time = cTime;   
  23.         }   
  24.     }  

       在run方法中，主要實現了如下幾個任務：首先檢查是否有允許啟動該線程(在開始運行後，由於在MovementView中，啟動UpdateThread的時候，已經設置了其值為true,即updateThread.setRunning(true))，接下來檢查是否在指定的時間內(這裡設置的是每秒20幀)，如果是的話，則調用surfaceHolder的lockCanvas方法，鎖定當前的畫布繪畫區域，並且調用movementView的updatePhysics方法及onDraw方法去畫小球並判斷小球的運動，最後記得要在finally中調用unlockCanvasAndPost方法。

       五、啟動並運行程序

       最後啟動並運行程序，可以看到如下的效果，可以看到小球在做各個方向的彈跳運動。

       到此就完成了這個Android游戲開發的入門實例，其實編寫Android游戲就是這麼簡單。

  1. 上一頁:
    2. No
Android游戲開發
Android游戲攻略Android游戲資訊關於Android游戲Android游戲開發
相關文章
熱門文章
Android游戲引擎libgdx使用教程6：演員與演出 Android游戲開發24：Android觸屏方向導航 Android游戲開發教程之一：地圖編輯器 Android游戲開發14：SurfaceView中使用Tween Animation漸變動畫 Android游戲開發16：觸摸屏手勢識別編程 實現手勢操作切換圖片的實例 Android游戲開發教程之十八：屏幕分辨率匯總
Android游戲開發教程之七：主角與地圖的滾動

       
Android游戲開發教程之五：View與SurfaceView的區別

       
Android游戲開發教程：手把手教你寫跳躍類游戲（三）

　　在本次教程中，我們將完成Food這個類的設計。這是
Android游戲引擎libgdx使用教程6：演員與演出

    &nb
閱讀排行版
Copyright © Android教程網 All Rights Reserved