分享一个android真正实用的游戏框架

前面有些同学已发过几个游戏框架，我把android SDK中游戏示例代码的框架也剥出来共享给大家，自称为真正实用的游戏框架。已拿其开发过一款游戏，感觉还可以。
其主要“实用”之处在于：
1.框架整体很小，上手快，做大游戏的公司没多少，做小游戏的个人开发者铺天盖地，相比动则上升到引擎级的庞然大物，小型的框架更加实用，更加考虑大多数开发者的利益。
2.小不等于不完善，之所以剥SDK的游戏示例代码的框架出来，就是学习后发现它对于系统事件的处理比较完善，另外我个人还修正了它对于来电处理等异常事件不完美之处，使其更加完善。

多的话不说，代码全贴在这吧，做过游戏开发的同学一看就知道好不好用。欢迎大家采用，如对此框架还有修改建议，请QQ联系:76359570，无事还请勿扰。


R.layout.main 布局文件

1. 
   
3.     xmlns:android="http://schemas.android.com/apk/res/android"
   
4.     android:orientation="vertical"
   
5.     android:layout_width="match_parent"
   
6.     android:layout_height="match_parent">
   
7.    
8.         android:id="@+id/gameview"
   
9.         android:layout_width="match_parent"
   
10.         android:layout_height="match_parent" />
    
11.    
12.         android:layout_width="match_parent"
    
13.         android:layout_height="match_parent">
    
14.         
15.             android:id="@+id/textview"
    
16.             android:layout_width="wrap_content"
    
17.             android:layout_height="wrap_content"
    
18.             android:layout_centerInParent="true"
    
19.             android:gravity="center_horizontal"
    
20.             android:textColor="#88ffffff"
    
21.             android:textSize="24sp" />
    
22.    
    

复制代码

Activity类

1. package com.mstanford.gameframework;
   
2. 
   
3. import com.mstanford.gameframe.R;
   
4. import android.app.Activity;
   
5. import android.os.Bundle;
   
6. import android.util.Log;
   
7. import android.view.Menu;
   
8. import android.view.MenuItem;
   
9. import android.widget.TextView;
   
10. 
    
11. public class GameActivity extends Activity {
    
12. 
    
13. private GameSurfaceView gameSurfaceView;
    
14. 
    
15. private GameThread gameThread;
    
16. 
    
17. @Override
    
18. public void onCreate(Bundle savedInstanceState) {
    
19.   super.onCreate(savedInstanceState);
    
20.   setContentView(R.layout.main);
    
21. 
    
22.   gameSurfaceView = (GameSurfaceView) this.findViewById(R.id.gameview);
    
23.   gameThread = gameSurfaceView.getThread();
    
24.   gameSurfaceView.setTextView((TextView) findViewById(R.id.textview));
    
25. 
    
26.   if (savedInstanceState == null) {
    
27.    // 游戏第一次启动时,初始化游戏状态
    
28.    gameThread.doStart();
    
29.    Log.w(this.getClass().getName(), "SIS is null");
    
30.   }
    
31.   else {
    
32.    // 从其他应用界面切回游戏时,如果Activity重新创建,则恢复上次切出游戏时的各项数据
    
33.    gameThread.restoreState(savedInstanceState);
    
34.    Log.w(this.getClass().getName(), "SIS is nonnull");
    
35.   }
    
36. }
    
37. 
    
38. /**
    
39.   * 当Activity被切换到后台时调用,存储Activity重新创建时需要恢复的游戏数据
    
40.   */
    
41. @Override
    
42. protected void onSaveInstanceState(Bundle outState) {
    
43.   super.onSaveInstanceState(outState);
    
44.   gameThread.saveState(outState);
    
45.   Log.w(this.getClass().getName(), "SIS called");
    
46. }
    
47. 
    
48. /**
    
49.   * 当Activity被切换到后台时调用,在这里对游戏做"暂停"的处理
    
50.   */
    
51. @Override
    
52. protected void onPause() {
    
53.   super.onPause();
    
54.   // 暂停游戏
    
55.   gameSurfaceView.getThread().pause();
    
56. }
    
57. 
    
58. /**
    
59.   * 当Activity切换到前台时调用
    
60.   */
    
61. @Override
    
62. protected void onResume() {
    
63.   super.onResume();
    
64.   // 游戏结束暂停状态,游戏正常进行
    
65.   gameSurfaceView.getThread().unpause();
    
66. }
    
67. 
    
68. /**
    
69.   * 创建游戏菜单
    
70.   */
    
71. @Override
    
72. public boolean onCreateOptionsMenu(Menu menu) {
    
73.   // TODO Auto-generated method stub
    
74.   return super.onCreateOptionsMenu(menu);
    
75. }
    
76. 
    
77. /**
    
78.   * 定义游戏菜单的点击事件处理
    
79.   */
    
80. @Override
    
81. public boolean onOptionsItemSelected(MenuItem item) {
    
82.   // TODO Auto-generated method stub
    
83.   return super.onOptionsItemSelected(item);
    
84. }
    
85. 
    
86. @Override
    
87. protected void onDestroy() {
    
88.   super.onDestroy();
    
89.   Log.v(this.getClass().getName(), "onDestroy");
    
90.   
    
91.   //停止游戏
    
92.   gameThread.setRunning(false);
    
93.   boolean retry = true;
    
94.   while (retry) {
    
95.    try {
    
96.     //阻塞Activity的主线程直到游戏线程执行完
    
97.     gameThread.join();
    
98.     retry = false;
    
99.    } catch (InterruptedException e) {
    
100.    }
     
101.   }
     
102. }
     
103. }

复制代码

SurfaceView类

1. package com.mstanford.gameframework;
   
2. 
   
3. import android.content.Context;
   
4. import android.os.Handler;
   
5. import android.os.Message;
   
6. import android.util.AttributeSet;
   
7. import android.util.Log;
   
8. import android.view.KeyEvent;
   
9. import android.view.SurfaceHolder;
   
10. import android.view.SurfaceView;
    
11. import android.view.SurfaceHolder.Callback;
    
12. import android.widget.TextView;
    
13. 
    
14. public class GameSurfaceView extends SurfaceView implements Callback {
    
15. 
    
16. private GameThread gameThread;
    
17. 
    
18. private TextView textview;
    
19. 
    
20. public GameSurfaceView(Context context, AttributeSet attrs) {
    
21.   super(context, attrs);
    
22.   SurfaceHolder holder = getHolder();
    
23.   holder.addCallback(this);
    
24. 
    
25.   gameThread = new GameThread(holder, context, new Handler() {
    
26.    @Override
    
27.    public void handleMessage(Message m) {
    
28.     textview.setText(m.getData().getString("text"));
    
29.    }
    
30.   });
    
31. 
    
32.   // 设置可获得焦点,确保能捕获到KeyEvent
    
33.   setFocusable(true);
    
34. }
    
35. 
    
36. /**
    
37.   * 获取一个Activity传来的View协助SurfaceView显示游戏视图,View的具体类型可以根据游戏需要来定
    
38.   */
    
39. public void setTextView(TextView view) {
    
40.   this.textview = view;
    
41. }
    
42. 
    
43. public GameThread getThread() {
    
44.   return gameThread;
    
45. }
    
46. 
    
47. @Override
    
48. public boolean onKeyDown(int keyCode, KeyEvent event) {
    
49.   return gameThread.doKeyDown(keyCode, event);
    
50. }
    
51. 
    
52. @Override
    
53. public boolean onKeyUp(int keyCode, KeyEvent event) {
    
54.   return gameThread.doKeyUp(keyCode, event);
    
55. }
    
56. 
    
57. /**
    
58.   * 当SurfaceView得到或失去焦点时调用,使游戏暂停/恢复运行,
    
59.   */
    
60. @Override
    
61. public void onWindowFocusChanged(boolean hasWindowFocus) {
    
62.   if (!hasWindowFocus) {
    
63.    gameThread.pause();
    
64.   }
    
65.   else {
    
66.    gameThread.unpause();
    
67.   }
    
68. }
    
69. 
    
70. @Override
    
71. public void surfaceChanged(SurfaceHolder holder, int format, int width,
    
72.    int height) {
    
73.   Log.v(this.getClass().getName(), "surfaceChanged()");
    
74.   gameThread.setSurfaceSize(width, height);
    
75. 
    
76.   gameThread.setRunning(true);
    
77. 
    
78.   if (gameThread.isAlive()) {
    
79.    Log.v(this.getClass().getName(), "unpause gameThread");
    
80.    gameThread.unpause();
    
81.   }
    
82.   else {
    
83.    Log.v(this.getClass().getName(), "start gameThread");
    
84.    gameThread.start();
    
85.   }
    
86. 
    
87. }
    
88. 
    
89. @Override
    
90. public void surfaceCreated(SurfaceHolder holder) {
    
91.   Log.v(this.getClass().getName(), "surfaceCreated()");
    
92.   }
    
93. 
    
94. /**
    
95.   * 为防止surface还会被创建(比如来电)导致gameThread再次启动出现错误,且Activity的onPause方法中已做暂停处理,
    
96.   * 这边不对gameThread做处理
    
97.   * @param holder
    
98.   */
    
99. @Override
    
100. public void surfaceDestroyed(SurfaceHolder holder) {
     
101.   Log.v(this.getClass().getName(), "surfaceDestroyed");
     
102. }

复制代码

游戏线程类

1. package com.mstanford.gameframework;
   
2. 
   
3. import android.content.Context;
   
4. import android.graphics.Canvas;
   
5. import android.os.Bundle;
   
6. import android.os.Handler;
   
7. import android.util.Log;
   
8. import android.view.KeyEvent;
   
9. import android.view.SurfaceHolder;
   
10. 
    
11. public class GameThread extends Thread {
    
12. 
    
13. // 游戏状态值:ready
    
14. public final static int GS_READY = 0;
    
15. 
    
16. //游戏线程每执行一次需要睡眠的时间
    
17. private final static int DELAY_TIME = 100;
    
18. 
    
19. //上下文,方便获取到应用的各项资源,如图片、音乐、字符串等
    
20. private Context context;
    
21. 
    
22. //与Activity其他View交互用的handler
    
23. private Handler handler;
    
24. 
    
25. //由SurfaceView提供的SurfaceHolder
    
26. private SurfaceHolder surfaceHolder;
    
27. 
    
28. //游戏线程运行开关
    
29. private boolean running = false;
    
30. 
    
31. //游戏状态
    
32. private int gameState;
    
33. 
    
34. //当前surface/canvas的高度,在surfaceChanged方法中被设置
    
35.     private int mCanvasHeight = 1;
    
36. 
    
37.   //当前surface/canvas的宽度,在surfaceChanged方法中被设置
    
38.     private int mCanvasWidth = 1;
    
39.     
    
40.     /**
    
41.      * 游戏是否暂停
    
42.      */
    
43.     private boolean isPaused = false;
    
44. 
    
45. public GameThread(SurfaceHolder holder, Context context, Handler handler) {
    
46.   this.surfaceHolder = holder;
    
47.   this.context = context;
    
48.   this.handler = handler;
    
49. }
    
50. 
    
51. /**
    
52.   * 设置游戏状态
    
53.   * @param mode 游戏状态
    
54.   */
    
55. public void setState(int mode) {
    
56.   synchronized (surfaceHolder) {
    
57.    setState(mode, null);
    
58.   }
    
59. }
    
60. 
    
61. /**
    
62.   * 设置游戏状态
    
63.   * @param mode 游戏状态
    
64.   * @param message 设置游戏状态时的附加文字信息
    
65.   */
    
66. public void setState(int mode, CharSequence message) {
    
67.   synchronized (surfaceHolder) {
    
68.    // TODO
    
69.   }
    
70. }
    
71. 
    
72. /**
    
73.   * 暂停游戏
    
74.   */
    
75. public void pause() {
    
76.   synchronized (surfaceHolder) {
    
77.    isPaused = true;
    
78.   }
    
79. }
    
80. 
    
81. /**
    
82.   * 恢复运行游戏
    
83.   */
    
84. public void unpause() {
    
85.   //如果游戏中有时间,别忘记应将其在这里调整到正常
    
86.   synchronized (surfaceHolder) {
    
87.    isPaused = false;
    
88.   }
    
89. }
    
90. 
    
91. /**
    
92.   * 当Activity因销毁而被重新创建时,在这里恢复游戏上次运行的数据
    
93.   * @param saveState Activity传来的保存游戏数据的容器
    
94.   */
    
95. public void restoreState(Bundle saveState) {
    
96.   //TODO
    
97. }
    
98. 
    
99. /**
    
100.   * 在Activity切到后台时保存游戏的数据
     
101.   * @param outState 保存游戏数据的容器
     
102.   */
     
103. public void saveState(Bundle outState)
     
104. {
     
105.   //TODO
     
106. }
     
107. 
     
108. /**
     
109.   * 设置游戏线程运行开关
     
110.   * @param b 开/关
     
111.   */
     
112. public void setRunning(boolean b) {
     
113.   running = b;
     
114. }
     
115. 
     
116. /**
     
117.   * 处理按下按键的事件
     
118.   * @param keyCode 按键事件动作值
     
119.   * @param msg 按键事件对象
     
120.   * @return 是否处理完
     
121.   */
     
122. public boolean doKeyDown(int keyCode, KeyEvent msg) {
     
123.   synchronized (surfaceHolder) {
     
124.    // TODO
     
125.    return false;
     
126.   }
     
127. }
     
128. 
     
129. /**
     
130.   * 处理弹起按键的事件
     
131.   * @param keyCode 按键事件动作值
     
132.   * @param msg 按键事件对象
     
133.   * @return 是否处理完
     
134.   */
     
135. public boolean doKeyUp(int keyCode, KeyEvent msg) {
     
136.   synchronized (surfaceHolder) {
     
137.    // TODO
     
138.   }
     
139.   return false;
     
140. }
     
141. 
     
142. /**
     
143.   * 设置surface/canvas的宽度和高度
     
144.   * @param width 由SurfaceHolder传来的宽度
     
145.   * @param height 由SurfaceHolder传来的高度
     
146.   */
     
147. public void setSurfaceSize(int width, int height) {
     
148.   // synchronized to make sure these all change atomically
     
149.   synchronized (surfaceHolder) {
     
150.    mCanvasWidth = width;
     
151.    mCanvasHeight = height;
     
152.    //不要忘记每次画布的宽度和高度改变时, 在这里对图片等资源做缩放等相关适配屏幕的处理
     
153.    //TODO
     
154.   }
     
155. }
     
156. 
     
157. public void run() {
     
158.   while (running) {
     
159.    if (!isPaused) {
     
160.     Canvas c = null;
     
161.     try {
     
162.      c = surfaceHolder.lockCanvas(null);
     
163.      synchronized (surfaceHolder) {
     
164.       doDraw(c);
     
165.      }
     
166.      logic();
     
167.     } finally {
     
168.      if (c != null) {
     
169.       surfaceHolder.unlockCanvasAndPost(c);
     
170.      }
     
171.     }
     
172.     try {
     
173.      Thread.sleep(DELAY_TIME);
     
174.     } catch (InterruptedException e) {
     
175.      e.printStackTrace();
     
176.     }
     
177.    }
     
178.   }
     
179. }
     
180. 
     
181. /**
     
182.   * 游戏逻辑处理
     
183.   */
     
184. public void logic()
     
185. {
     
186.   Log.v(this.getClass().getName(), "logic");
     
187.   //TODO
     
188. }
     
189. 
     
190. /**
     
191.   * 游戏绘画
     
192.   */
     
193. private void doDraw(Canvas canvas) {
     
194.   Log.v(this.getClass().getName(), "doDraw");
     
195.   //TODO
     
196. }
     
197. 
     
198. /**
     
199.   * 初始化游戏开始时的参数
     
200.   */
     
201. private void doStart() {
     
202.   //TODO
     
203. }
     
204. }

复制代码

  GameFramework (1).rar (52.27 KB, 下载次数: 73)