【贪吃蛇—Java程序员写Android游戏】系列 1.Android SDK Sample-Snake详解

Snake也是一个经典游戏了，Nokia蓝屏机的王牌游戏之一。Android SDK 1.5就有了它的身影。我们这里就来详细解析一下Android SDK Sample中的Snake工程。本工程基于SDK 2.3.3版本中的工程，路径为：%Android_SDK_HOME% /samples/android-10/Snake

一、Eclipse工程

通过File-New Project-Android-Android Project，选择“Create project from existing sample”创建自己的应用SnakeAndroid，如下图：

运行效果如下图：

二、工程结构和类图

其实Snake的工程蛮简单的，源文件就三个：Snake.java SnakeView.java TileView.java。Snake类是这个游戏的入口点，TitleView类进行游戏的绘画，SnakeView类则是对游戏控制操作的处理。Coordinate，RefreshHandler是2个辅助类，也是SnakeView类中的内部类。其中，Coordinate是一个点的坐标（x，y），RefreshHandler将RefreshHandler对象绑定某个线程并给它发送消息。如下图：

任何游戏都需要有个引擎来推动游戏的运行，最简化的游戏引擎就是：在一个线程中While循环，检测用户操作，对用户的操作作出反应，更新游戏的界面，直到用户退出游戏。

在Snake这个游戏中，辅助类RefreshHandler继承自Handler，用来把RefreshHandler与当前线程进行绑定，从而可以直接给线程发送消息并处理消息。注意一点：Handle对消息的处理都是异步。RefreshHandler在Handler的基础上增加sleep()接口，用来每隔一个时间段后给当前线程发送一个消息。handleMessage()方法在接受消息后，根据当前的游戏状态重绘界面，运行机制如下：

这比较类似定时器的概念，在特定的时刻发送消息，根据消息处理相应的事件。update()与sleep()间接的相互调用就构成了一个循环。这里要注意：mRedrawHandle绑定的是Avtivity所在的线程，也就是程序的主线程；另外由于sleep()是个异步函数，所以update()与sleep()之间的相互调用才没有构成死循环。

最后分析下游戏数据的保存机制，如下：

这里考虑了Activity的生命周期：如果用户在游戏期间离开游戏界面，游戏暂停；或者由于内存比较紧张，Android关闭游戏释放内存，那么当用户返回游戏界面的时候恢复到上次离开时的界面。

三、源码解析

详细解析下源代码，由于代码量不大，以注释的方式列出如下：

1、Snake.java

View Code

1 /**
2 * Title: Snake
3 * Copyright: (C) 2007 The Android Open Source Project. Licensed under the Apache License, Version 2.0 (the “License”)
4 * @author Gavin 标注
5 */
6
7 package com.deaboway.snake;
8
9 import android.app.Activity;
10 import android.os.Bundle;
11 import android.widget.TextView;
12
13 /**
14 * Snake: a simple game that everyone can enjoy.
15 *
16 * This is an implementation of the classic Game “Snake”, in which you control a
17 * serpent roaming around the garden looking for apples. Be careful, though,
18 * because when you catch one, not only will you become longer, but you\’ll move
19 * faster. Running into yourself or the walls will end the game.
20 *
21 */
22 // 贪吃蛇：经典游戏，在一个花园中找苹果吃，吃了苹果会变长，速度变快。碰到自己和墙就挂掉。
23 public class Snake extends Activity {
24
25 private SnakeView mSnakeView;
26
27 private static String ICICLE_KEY = “snake-view“;
28
29 /**
30 * Called when Activity is first created. Turns off the title bar, sets up
31 * the content views, and fires up the SnakeView.
32 *
33 */
34 // 在 activity 第一次创建时被调用
35 @Override
36 public void onCreate(Bundle savedInstanceState) {
37
38 super.onCreate(savedInstanceState);
39 setContentView(R.layout.snake_layout);
40
41 mSnakeView = (SnakeView) findViewById(R.id.snake);
42 mSnakeView.setTextView((TextView) findViewById(R.id.text));
43
44 // 检查存贮状态以确定是重新开始还是恢复状态
45 if (savedInstanceState == null) {
46 // 存储状态为空，说明刚启动可以切换到准备状态
47 mSnakeView.setMode(SnakeView.READY);
48 } else {
49 // 已经保存过，那么就去恢复原有状态
50 Bundle map = savedInstanceState.getBundle(ICICLE_KEY);
51 if (map != null) {
52 // 恢复状态
53 mSnakeView.restoreState(map);
54 } else {
55 // 设置状态为暂停
56 mSnakeView.setMode(SnakeView.PAUSE);
57 }
58 }
59 }
60
61 // 暂停事件被触发时
62 @Override
63 protected void onPause() {
64 super.onPause();
65 // Pause the game along with the activity
66 mSnakeView.setMode(SnakeView.PAUSE);
67 }
68
69 // 状态保存
70 @Override
71 public void onSaveInstanceState(Bundle outState) {
72 // 存储游戏状态到View里
73 outState.putBundle(ICICLE_KEY, mSnakeView.saveState());
74 }
75
76 }

2、SnakeView.java

View Code

1 /**
 2 * Title: Snake
 3 * Copyright: (C) 2007 The Android Open Source Project. Licensed under the Apache License, Version 2.0 (the “License”)
 4 * @author Gavin 标注
 5 */
 6
 7 package com.deaboway.snake;
 8
 9 import java.util.ArrayList;
10 import java.util.Random;
11
12 import android.content.Context;
13 import android.content.res.Resources;
14 import android.os.Handler;
15 import android.os.Message;
16 import android.util.AttributeSet;
17 import android.os.Bundle;
18 import android.util.Log;
19 import android.view.KeyEvent;
20 import android.view.View;
21 import android.widget.TextView;
22
23 /**
24 * SnakeView: implementation of a simple game of Snake
25 *
26 *
27 */
28 public class SnakeView extends TileView {
29
30 private static final String TAG = “Deaboway“;
31
32 /**
33 * Current mode of application: READY to run, RUNNING, or you have already
34 * lost. static final ints are used instead of an enum for performance
35 * reasons.
36 */
37 // 游戏状态，默认值是准备状态
38 private int mMode = READY;
39
40 // 游戏的四个状态暂停准备运行和失败
41 public static final int PAUSE = 0;
42 public static final int READY = 1;
43 public static final int RUNNING = 2;
44 public static final int LOSE = 3;
45
46 // 游戏中蛇的前进方向，默认值北方
47 private int mDirection = NORTH;
48 // 下一步的移动方向，默认值北方
49 private int mNextDirection = NORTH;
50
51 // 游戏方向设定北南东西
52 private static final int NORTH = 1;
53 private static final int SOUTH = 2;
54 private static final int EAST = 3;
55 private static final int WEST = 4;
56
57 /**
58 * Labels for the drawables that will be loaded into the TileView class
59 */
60 // 三种游戏元
61 private static final int RED_STAR = 1;
62 private static final int YELLOW_STAR = 2;
63 private static final int GREEN_STAR = 3;
64
65 /**
66 * mScore: used to track the number of apples captured mMoveDelay: number of
67 * milliseconds between snake movements. This will decrease as apples are
68 * captured.
69 */
70 // 游戏得分
71 private long mScore = 0;
72
73 // 移动延迟
74 private long mMoveDelay = 600;
75
76 /**
77 * mLastMove: tracks the absolute time when the snake last moved, and is
78 * used to determine if a move should be made based on mMoveDelay.
79 */
80 // 最后一次移动时的毫秒时刻
81 private long mLastMove;
82
83 /**
84 * mStatusText: text shows to the user in some run states
85 */
86 // 显示游戏状态的文本组件
87 private TextView mStatusText;
88
89 /**
90 * mSnakeTrail: a list of Coordinates that make up the snake\’s body
91 * mAppleList: the secret location of the juicy apples the snake craves.
92 */
93 // 蛇身数组(数组以坐标对象为元素)
94 private ArrayList<Coordinate> mSnakeTrail = new ArrayList<Coordinate>();
95
96 // 苹果数组(数组以坐标对象为元素)
97 private ArrayList<Coordinate> mAppleList = new ArrayList<Coordinate>();
98
99 /**
100 * Everyone needs a little randomness in their life
101 */
102 // 随机数
103 private static final Random RNG = new Random();
104
105 /**
106 * Create a simple handler that we can use to cause animation to happen. We
107 * set ourselves as a target and we can use the sleep() function to cause an
108 * update/invalidate to occur at a later date.
109 */
110 // 创建一个Refresh Handler来产生动画：通过sleep()来实现
111 private RefreshHandler mRedrawHandler = new RefreshHandler();
112
113 // 一个Handler
114 class RefreshHandler extends Handler {
115
116 // 处理消息队列
117 @Override
118 public void handleMessage(Message msg) {
119 // 更新View对象
120 SnakeView.this.update();
121 // 强制重绘
122 SnakeView.this.invalidate();
123 }
124
125 // 延迟发送消息
126 public void sleep(long delayMillis) {
127 this.removeMessages(0);
128 sendMessageDelayed(obtainMessage(0), delayMillis);
129 }
130 };
131
132 /**
133 * Constructs a SnakeView based on inflation from XML
134 *
135 * @param context
136 * @param attrs
137 */
138 // 构造函数
139 public SnakeView(Context context, AttributeSet attrs) {
140 super(context, attrs);
141 // 构造时初始化
142 initSnakeView();
143 }
144
145 public SnakeView(Context context, AttributeSet attrs, int defStyle) {
146 super(context, attrs, defStyle);
147 initSnakeView();
148 }
149
150 // 初始化
151 private void initSnakeView() {
152 // 可选焦点
153 setFocusable(true);
154
155 Resources r = this.getContext().getResources();
156
157 // 设置贴片图片数组
158 resetTiles(4);
159
160 // 把三种图片存到Bitmap对象数组
161 loadTile(RED_STAR, r.getDrawable(R.drawable.redstar));
162 loadTile(YELLOW_STAR, r.getDrawable(R.drawable.yellowstar));
163 loadTile(GREEN_STAR, r.getDrawable(R.drawable.greenstar));
164
165 }
166
167 // 开始新的游戏——初始化
168 private void initNewGame() {
169 // 清空ArrayList列表
170 mSnakeTrail.clear();
171 mAppleList.clear();
172
173 // For now we\’re just going to load up a short default eastbound snake
174 // that\’s just turned north
175 // 创建蛇身
176
177 mSnakeTrail.add(new Coordinate(7, 7));
178 mSnakeTrail.add(new Coordinate(6, 7));
179 mSnakeTrail.add(new Coordinate(5, 7));
180 mSnakeTrail.add(new Coordinate(4, 7));
181 mSnakeTrail.add(new Coordinate(3, 7));
182 mSnakeTrail.add(new Coordinate(2, 7));
183
184 // 新的方向：北方
185 mNextDirection = NORTH;
186
187 // 2个随机位置的苹果
188 addRandomApple();
189 addRandomApple();
190
191 // 移动延迟
192 mMoveDelay = 600;
193 // 初始得分0
194 mScore = 0;
195 }

View Code

1 /**
 2 * Given a ArrayList of coordinates, we need to flatten them into an array
 3 * of ints before we can stuff them into a map for flattening and storage.
 4 *
 5 * @param cvec
 6 * : a ArrayList of Coordinate objects
 7 * @return : a simple array containing the x/y values of the coordinates as
 8 * [x1,y1,x2,y2,x3,y3…]
 9 */
10 // 坐标数组转整数数组，把Coordinate对象的x y放到一个int数组中——用来保存状态
11 private int[] coordArrayListToArray(ArrayList<Coordinate> cvec) {
12 int count = cvec.size();
13 int[] rawArray = new int[count * 2];
14 for (int index = 0; index < count; index++) {
15 Coordinate c = cvec.get(index);
16 rawArray[2 * index] = c.x;
17 rawArray[2 * index + 1] = c.y;
18 }
19 return rawArray;
20 }
21
22 /**
23 * Save game state so that the user does not lose anything if the game
24 * process is killed while we are in the background.
25 *
26 * @return a Bundle with this view\’s state
27 */
28 // 保存状态
29 public Bundle saveState() {
30
31 Bundle map = new Bundle();
32
33 map.putIntArray(“mAppleList“, coordArrayListToArray(mAppleList));
34 map.putInt(“mDirection“, Integer.valueOf(mDirection));
35 map.putInt(“mNextDirection“, Integer.valueOf(mNextDirection));
36 map.putLong(“mMoveDelay“, Long.valueOf(mMoveDelay));
37 map.putLong(“mScore“, Long.valueOf(mScore));
38 map.putIntArray(“mSnakeTrail“, coordArrayListToArray(mSnakeTrail));
39
40 return map;
41 }
42
43 /**
44 * Given a flattened array of ordinate pairs, we reconstitute them into a
45 * ArrayList of Coordinate objects
46 *
47 * @param rawArray
48 * : [x1,y1,x2,y2,…]
49 * @return a ArrayList of Coordinates
50 */
51 // 整数数组转坐标数组，把一个int数组中的x y放到Coordinate对象数组中——用来恢复状态
52 private ArrayList<Coordinate> coordArrayToArrayList(int[] rawArray) {
53 ArrayList<Coordinate> coordArrayList = new ArrayList<Coordinate>();
54
55 int coordCount = rawArray.length;
56 for (int index = 0; index < coordCount; index += 2) {
57 Coordinate c = new Coordinate(rawArray[index], rawArray[index + 1]);
58 coordArrayList.add(c);
59 }
60 return coordArrayList;
61 }
62
63 /**
64 * Restore game state if our process is being relaunched
65 *
66 * @param icicle
67 * a Bundle containing the game state
68 */
69 // 恢复状态
70 public void restoreState(Bundle icicle) {
71
72 setMode(PAUSE);
73
74 mAppleList = coordArrayToArrayList(icicle.getIntArray(“mAppleList“));
75 mDirection = icicle.getInt(“mDirection“);
76 mNextDirection = icicle.getInt(“mNextDirection“);
77 mMoveDelay = icicle.getLong(“mMoveDelay“);
78 mScore = icicle.getLong(“mScore“);
79 mSnakeTrail = coordArrayToArrayList(icicle.getIntArray(“mSnakeTrail“));
80 }
81
82 /*
83 * handles key events in the game. Update the direction our snake is
84 * traveling based on the DPAD. Ignore events that would cause the snake to
85 * immediately turn back on itself.
86 *
87 * (non-Javadoc)
88 *
89 * @see android.view.View#onKeyDown(int, android.os.KeyEvent)
90 */
91 // 监听用户键盘操作，并处理这些操作
92 // 按键事件处理，确保贪吃蛇只能90度转向，而不能180度转向
93 @Override
94 public boolean onKeyDown(int keyCode, KeyEvent msg) {
95
96 // 向上键
97 if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
98 // 准备状态或者失败状态时
99 if (mMode == READY | mMode == LOSE) {
100 /*
101 * At the beginning of the game, or the end of a previous one,
102 * we should start a new game.
103 */
104 // 初始化游戏
105 initNewGame();
106 // 设置游戏状态为运行
107 setMode(RUNNING);
108 // 更新
109 update();
110 // 返回
111 return (true);
112 }
113
114 // 暂停状态时
115 if (mMode == PAUSE) {
116 /*
117 * If the game is merely paused, we should just continue where
118 * we left off.
119 */
120 // 设置成运行状态
121 setMode(RUNNING);
122 update();
123 // 返回
124 return (true);
125 }
126
127 // 如果是运行状态时，如果方向原有方向不是向南，那么方向转向北
128 if (mDirection != SOUTH) {
129 mNextDirection = NORTH;
130 }
131 return (true);
132 }
133
134 // 向下键
135 if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
136 // 原方向不是向上时，方向转向南
137 if (mDirection != NORTH) {
138 mNextDirection = SOUTH;
139 }
140 // 返回
141 return (true);
142 }
143
144 // 向左键
145 if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
146 // 原方向不是向右时，方向转向西
147 if (mDirection != EAST) {
148 mNextDirection = WEST;
149 }
150 // 返回
151 return (true);
152 }
153
154 // 向右键
155 if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
156 // 原方向不是向左时，方向转向东
157 if (mDirection != WEST) {
158 mNextDirection = EAST;
159 }
160 // 返回
161 return (true);
162 }
163
164 // 按其他键时按原有功能返回
165 return super.onKeyDown(keyCode, msg);
166 }

View Code

1 /**
 2 * Sets the TextView that will be used to give information (such as “Game
 3 * Over” to the user.
 4 *
 5 * @param newView
 6 */
 7 // 设置状态显示View
 8 public void setTextView(TextView newView) {
 9 mStatusText = newView;
10 }
11
12 /**
13 * Updates the current mode of the application (RUNNING or PAUSED or the
14 * like) as well as sets the visibility of textview for notification
15 *
16 * @param newMode
17 */
18 // 设置游戏状态
19 public void setMode(int newMode) {
20
21 // 把当前游戏状态存入oldMode
22 int oldMode = mMode;
23 // 把游戏状态设置为新状态
24 mMode = newMode;
25
26 // 如果新状态是运行状态，且原有状态为不运行，那么就开始游戏
27 if (newMode == RUNNING & oldMode != RUNNING) {
28 // 设置mStatusTextView隐藏
29 mStatusText.setVisibility(View.INVISIBLE);
30 // 更新
31 update();
32 return;
33 }
34
35 Resources res = getContext().getResources();
36 CharSequence str = “”;
37
38 // 如果新状态是暂停状态，那么设置文本内容为暂停内容
39 if (newMode == PAUSE) {
40 str = res.getText(R.string.mode_pause);
41 }
42
43 // 如果新状态是准备状态，那么设置文本内容为准备内容
44 if (newMode == READY) {
45 str = res.getText(R.string.mode_ready);
46 }
47
48 // 如果新状态时失败状态，那么设置文本内容为失败内容
49 if (newMode == LOSE) {
50 // 把上轮的得分显示出来
51 str = res.getString(R.string.mode_lose_prefix) + mScore
52 + res.getString(R.string.mode_lose_suffix);
53 }
54
55 // 设置文本
56 mStatusText.setText(str);
57 // 显示该View
58 mStatusText.setVisibility(View.VISIBLE);
59 }
60
61 /**
62 * Selects a random location within the garden that is not currently covered
63 * by the snake. Currently _could_ go into an infinite loop if the snake
64 * currently fills the garden, but we\’ll leave discovery of this prize to a
65 * truly excellent snake-player.
66 *
67 */
68 // 添加苹果
69 private void addRandomApple() {
70 // 新的坐标
71 Coordinate newCoord = null;
72 // 防止新苹果出席在蛇身下
73 boolean found = false;
74 // 没有找到合适的苹果，就在循环体内一直循环，直到找到合适的苹果
75 while (!found) {
76 // 为苹果再找一个坐标,先随机一个X值
77 int newX = 1 + RNG.nextInt(mXTileCount – 2);
78 // 再随机一个Y值
79 int newY = 1 + RNG.nextInt(mYTileCount – 2);
80 // 新坐标
81 newCoord = new Coordinate(newX, newY);
82
83 // Make sure it\’s not already under the snake
84 // 确保新苹果不在蛇身下，先假设没有发生冲突
85 boolean collision = false;
86
87 int snakelength = mSnakeTrail.size();
88 // 和蛇占据的所有坐标比较
89 for (int index = 0; index < snakelength; index++) {
90 // 只要和蛇占据的任何一个坐标相同，即认为发生冲突了
91 if (mSnakeTrail.get(index).equals(newCoord)) {
92 collision = true;
93 }
94 }
95 // if we\’re here and there\’s been no collision, then we have
96 // a good location for an apple. Otherwise, we\’ll circle back
97 // and try again
98 // 如果有冲突就继续循环，如果没冲突flag的值就是false,那么自然会退出循环，新坐标也就诞生了
99 found = !collision;
100 }
101
102 if (newCoord == null) {
103 Log.e(TAG, “Somehow ended up with a null newCoord!“);
104 }
105 // 生成一个新苹果放在苹果列表中（两个苹果有可能会重合——这时候虽然看到的是一个苹果，但是呢，分数就是两个分数。）
106 mAppleList.add(newCoord);
107 }
108
109 /**
110 * Handles the basic update loop, checking to see if we are in the running
111 * state, determining if a move should be made, updating the snake\’s
112 * location.
113 */
114 // 更新各种动作，特别是贪吃蛇的位置，还包括：墙、苹果等的更新
115 public void update() {
116 // 如果是处于运行状态
117 if (mMode == RUNNING) {
118
119 long now = System.currentTimeMillis();
120
121 // 如果当前时间距离最后一次移动的时间超过了延迟时间
122 if (now – mLastMove > mMoveDelay) {
123 //
124 clearTiles();
125 updateWalls();
126 updateSnake();
127 updateApples();
128 mLastMove = now;
129 }
130 // Handler 会话进程sleep一个延迟时间单位
131 mRedrawHandler.sleep(mMoveDelay);
132 }
133
134 }
135
136 /**
137 * Draws some walls.
138 *
139 */
140 // 更新墙
141 private void updateWalls() {
142 for (int x = 0; x < mXTileCount; x++) {
143 // 给上边线的每个贴片位置设置一个绿色索引标识
144 setTile(GREEN_STAR, x, 0);
145 // 给下边线的每个贴片位置设置一个绿色索引标识
146 setTile(GREEN_STAR, x, mYTileCount – 1);
147 }
148 for (int y = 1; y < mYTileCount – 1; y++) {
149 // 给左边线的每个贴片位置设置一个绿色索引标识
150 setTile(GREEN_STAR, 0, y);
151 // 给右边线的每个贴片位置设置一个绿色索引标识
152 setTile(GREEN_STAR, mXTileCount – 1, y);
153 }
154 }
155
156 /**
157 * Draws some apples.
158 *
159 */
160 // 更新苹果
161 private void updateApples() {
162 for (Coordinate c : mAppleList) {
163 setTile(YELLOW_STAR, c.x, c.y);
164 }
165 }

View Code

1 /**
 2 * Figure out which way the snake is going, see if he\’s run into anything
 3 * (the walls, himself, or an apple). If he\’s not going to die, we then add
 4 * to the front and subtract from the rear in order to simulate motion. If
 5 * we want to grow him, we don\’t subtract from the rear.
 6 *
 7 */
 8 // 更新蛇
 9 private void updateSnake() {
10 // 生长标志
11 boolean growSnake = false;
12
13 // 得到蛇头坐标
14 Coordinate head = mSnakeTrail.get(0);
15 // 初始化一个新的蛇头坐标
16 Coordinate newHead = new Coordinate(1, 1);
17
18 // 当前方向改成新的方向
19 mDirection = mNextDirection;
20
21 // 根据方向确定蛇头新坐标
22 switch (mDirection) {
23 // 如果方向向东（右），那么X加1
24 case EAST: {
25 newHead = new Coordinate(head.x + 1, head.y);
26 break;
27 }
28 // 如果方向向西（左），那么X减1
29 case WEST: {
30 newHead = new Coordinate(head.x – 1, head.y);
31 break;
32 }
33 // 如果方向向北（上），那么Y减1
34 case NORTH: {
35 newHead = new Coordinate(head.x, head.y – 1);
36 break;
37 }
38 // 如果方向向南（下），那么Y加1
39 case SOUTH: {
40 newHead = new Coordinate(head.x, head.y + 1);
41 break;
42 }
43 }
44
45 // Collision detection
46 // For now we have a 1-square wall around the entire arena
47 // 冲突检测新蛇头是否四面墙重叠，那么游戏结束
48 if ((newHead.x < 1) || (newHead.y < 1) || (newHead.x > mXTileCount – 2)
49 || (newHead.y > mYTileCount – 2)) {
50 // 设置游戏状态为Lose
51 setMode(LOSE);
52 // 返回
53 return;
54
55 }
56
57 // Look for collisions with itself
58 // 冲突检测新蛇头是否和自身坐标重叠，重叠的话游戏也结束
59 int snakelength = mSnakeTrail.size();
60
61 for (int snakeindex = 0; snakeindex < snakelength; snakeindex++) {
62 Coordinate c = mSnakeTrail.get(snakeindex);
63 if (c.equals(newHead)) {
64 // 设置游戏状态为Lose
65 setMode(LOSE);
66 // 返回
67 return;
68 }
69 }
70
71 // Look for apples
72 // 看新蛇头和苹果们是否重叠
73 int applecount = mAppleList.size();
74 for (int appleindex = 0; appleindex < applecount; appleindex++) {
75 Coordinate c = mAppleList.get(appleindex);
76 if (c.equals(newHead)) {
77 // 如果重叠，苹果坐标从苹果列表中移除
78 mAppleList.remove(c);
79 // 再立刻增加一个新苹果
80 addRandomApple();
81 // 得分加一
82 mScore++;
83 // 延迟是以前的90%
84 mMoveDelay *= 0.9;
85 // 蛇增长标志改为真
86 growSnake = true;
87 }
88 }
89
90 // push a new head onto the ArrayList and pull off the tail
91 // 在蛇头的位置增加一个新坐标
92 mSnakeTrail.add(0, newHead);
93 // except if we want the snake to grow
94 // 如果没有增长
95 if (!growSnake) {
96 // 如果蛇头没增长则删去最后一个坐标，相当于蛇向前走了一步
97 mSnakeTrail.remove(mSnakeTrail.size() – 1);
98 }
99
100 int index = 0;
101 // 重新设置一下颜色，蛇头是黄色的（同苹果一样），蛇身是红色的
102 for (Coordinate c : mSnakeTrail) {
103 if (index == 0) {
104 setTile(YELLOW_STAR, c.x, c.y);
105 } else {
106 setTile(RED_STAR, c.x, c.y);
107 }
108 index++;
109 }
110
111 }
112
113 /**
114 * Simple class containing two integer values and a comparison function.
115 * There\’s probably something I should use instead, but this was quick and
116 * easy to build.
117 *
118 */
119 // 坐标内部类——原作者说这是临时做法
120 private class Coordinate {
121 public int x;
122 public int y;
123
124 // 构造函数
125 public Coordinate(int newX, int newY) {
126 x = newX;
127 y = newY;
128 }
129
130 // 重写equals
131 public boolean equals(Coordinate other) {
132 if (x == other.x && y == other.y) {
133 return true;
134 }
135 return false;
136 }
137
138 // 重写toString
139 @Override
140 public String toString() {
141 return “Coordinate: [“ + x + “,“ + y + “]“;
142 }
143 }
144
145 }

3、TileView.java

View Code

1 /**
 2 * Title: Snake
 3 * Copyright: (C) 2007 The Android Open Source Project. Licensed under the Apache License, Version 2.0 (the “License”)
 4 * @author Gavin 标注
 5 */
 6
 7 package com.deaboway.snake;
 8
 9 import android.content.Context;
10 import android.content.res.TypedArray;
11 import android.graphics.Bitmap;
12 import android.graphics.Canvas;
13 import android.graphics.Paint;
14 import android.graphics.drawable.Drawable;
15 import android.util.AttributeSet;
16 import android.view.View;
17
18 /**
19 * TileView: a View-variant designed for handling arrays of “icons” or other
20 * drawables.
21 *
22 */
23 // View 变种，用来处理一组贴片—— “icons”或其它可绘制的对象
24 public class TileView extends View {
25
26 /**
27 * Parameters controlling the size of the tiles and their range within view.
28 * Width/Height are in pixels, and Drawables will be scaled to fit to these
29 * dimensions. X/Y Tile Counts are the number of tiles that will be drawn.
30 */
31
32 protected static int mTileSize;
33
34 // X轴的贴片数量
35 protected static int mXTileCount;
36 // Y轴的贴片数量
37 protected static int mYTileCount;
38
39 // X偏移量
40 private static int mXOffset;
41 // Y偏移量
42 private static int mYOffset;
43
44 /**
45 * A hash that maps integer handles specified by the subclasser to the
46 * drawable that will be used for that reference
47 */
48 // 贴片图像的图像数组
49 private Bitmap[] mTileArray;
50
51 /**
52 * A two-dimensional array of integers in which the number represents the
53 * index of the tile that should be drawn at that locations
54 */
55 // 保存每个贴片的索引——二维数组
56 private int[][] mTileGrid;
57
58 // Paint对象（画笔、颜料）
59 private final Paint mPaint = new Paint();
60
61 // 构造函数
62 public TileView(Context context, AttributeSet attrs, int defStyle) {
63 super(context, attrs, defStyle);
64
65 TypedArray a = context.obtainStyledAttributes(attrs,
66 R.styleable.TileView);
67
68 mTileSize = a.getInt(R.styleable.TileView_tileSize, 12);
69
70 a.recycle();
71 }
72
73 public TileView(Context context, AttributeSet attrs) {
74 super(context, attrs);
75
76 TypedArray a = context.obtainStyledAttributes(attrs,
77 R.styleable.TileView);
78
79 mTileSize = a.getInt(R.styleable.TileView_tileSize, 12);
80
81 a.recycle();
82 }
83
84 /**
85 * Rests the internal array of Bitmaps used for drawing tiles, and sets the
86 * maximum index of tiles to be inserted
87 *
88 * @param tilecount
89 */
90 // 设置贴片图片数组
91 public void resetTiles(int tilecount) {
92 mTileArray = new Bitmap[tilecount];
93 }
94
95 // 回调：当该View的尺寸改变时调用，在onDraw()方法调用之前就会被调用，所以用来设置一些变量的初始值
96 // 在视图大小改变的时候调用，比如说手机由垂直旋转为水平
97 @Override
98 protected void onSizeChanged(int w, int h, int oldw, int oldh) {
99
100 // 定义X轴贴片数量
101 mXTileCount = (int) Math.floor(w / mTileSize);
102 mYTileCount = (int) Math.floor(h / mTileSize);
103
104 // X轴偏移量
105 mXOffset = ((w – (mTileSize * mXTileCount)) / 2);
106
107 // Y轴偏移量
108 mYOffset = ((h – (mTileSize * mYTileCount)) / 2);
109
110 // 定义贴片的二维数组
111 mTileGrid = new int[mXTileCount][mYTileCount];
112
113 // 清空所有贴片
114 clearTiles();
115 }
116
117 /**
118 * Function to set the specified Drawable as the tile for a particular
119 * integer key.
120 *
121 * @param key
122 * @param tile
123 */
124 // 给mTileArray这个Bitmap图片数组设置值
125 public void loadTile(int key, Drawable tile) {
126 Bitmap bitmap = Bitmap.createBitmap(mTileSize, mTileSize,
127 Bitmap.Config.ARGB_8888);
128 Canvas canvas = new Canvas(bitmap);
129 tile.setBounds(0, 0, mTileSize, mTileSize);
130 // 把一个drawable转成一个Bitmap
131 tile.draw(canvas);
132 // 在数组里存入该Bitmap
133 mTileArray[key] = bitmap;
134 }
135
136 /**
137 * Resets all tiles to 0 (empty)
138 *
139 */
140 // 清空所有贴片
141 public void clearTiles() {
142 for (int x = 0; x < mXTileCount; x++) {
143 for (int y = 0; y < mYTileCount; y++) {
144 // 全部设置为0
145 setTile(0, x, y);
146 }
147 }
148 }
149
150 /**
151 * Used to indicate that a particular tile (set with loadTile and referenced
152 * by an integer) should be drawn at the given x/y coordinates during the
153 * next invalidate/draw cycle.
154 *
155 * @param tileindex
156 * @param x
157 * @param y
158 */
159 // 给某个贴片位置设置一个状态索引
160 public void setTile(int tileindex, int x, int y) {
161 mTileGrid[x][y] = tileindex;
162 }
163
164 // onDraw 在视图需要重画的时候调用，比如说使用invalidate刷新界面上的某个矩形区域
165 @Override
166 public void onDraw(Canvas canvas) {
167
168 super.onDraw(canvas);
169 for (int x = 0; x < mXTileCount; x += 1) {
170 for (int y = 0; y < mYTileCount; y += 1) {
171 // 当索引大于零，也就是不空时
172 if (mTileGrid[x][y] > 0) {
173 // mTileGrid中不为零时画此贴片
174 canvas.drawBitmap(mTileArray[mTileGrid[x][y]], mXOffset + x
175 * mTileSize, mYOffset + y * mTileSize, mPaint);
176 }
177 }
178 }
179
180 }
181 }

四、工程文件下载

为了方便大家阅读，可以到如下地址下载工程源代码：

http://ishare.iask.sina.com.cn/f/14312223.html

五、小结及下期预告：

本次详细解析了Android SDK 自带 Sample——Snake的结构和功能。下次将会把这个游戏移植到J2ME平台上，并且比较Android和J2ME的区别和相通之处，让从事过J2ME开发的朋友对Android开发有个更加直观的认识。

本文链接：https://www.cnblogs.com/deaboway/archive/2011/03/31/2001173.html

【贪吃蛇—Java程序员写Android游戏】系列 1.Android SDK Sample-Snake详解

【贪吃蛇—Java程序员写Android游戏】系列 1.Android SDK Sample-Snake详解的更多相关文章

随机推荐

热门专题

目录导航