下面是Maze迷宫的坐标计算
01.// maze level data
02.private static int[] mMazeData;

这个一维数组存放所有的tile的类型
01.// maze tile size and dimension
02.private final static int TILE_SIZE = 16;
03.private final static int MAZE_COLS = 20;
04.private final static int MAZE_ROWS = 26;

01.// tile types
02.public final static int PATH_TILE = 0;
03.public final static int VOID_TILE = 1;//death area
04.public final static int EXIT_TILE = 2;//the target
而这个坐标的读取是通过从文件读取的，当然也可以通过写几个数组的形式，但是以文件的形式的话就不需要修改代码就可以实现软件的修改是一种比在代码中写几个大的数组要好的形式。

01./**
02. * Load specified maze level.
03. *
04. * @param activity
05. * Activity controlled the maze, we use this load the level data
06. * @param newLevel
07. * Maze level to be loaded.
08. */
09. void load(Activity activity, int newLevel) {
10. // maze data is stored in the assets folder as level1.txt, level2.txt
11. // etc....
12. String mLevel = "level" + newLevel + ".txt";
13.
14. InputStream is = null;
15.
16. try {
17. // construct our maze data array.
18. mMazeData = new int[MAZE_ROWS * MAZE_COLS];
19. // attempt to load maze data.
20. is = activity.getAssets().open(mLevel);
21.
22. // we need to loop through the input stream and load each tile for
23. // the current maze.
24. for (int i = 0; i < mMazeData.length; i++) {
25. // data is stored in unicode so we need to convert it.
26. mMazeData[i] = Character.getNumericValue(is.read());
27.
28. // skip the "," and white space in our human readable file.
29. is.read();
30. is.read();
31. }
32. } catch (Exception e) {
33. Log.i("Maze", "load exception: " + e);
34. } finally {
35. closeStream(is);
36. }
37. }
mMazeData数组存放了每个tile是什么类型的，MAZE_ROWS一共有多少行，MAZE_COLS一共多少列，TILE_SIZE每个tile的宽度，这样就可以在界面上画出来整个界面的布局

01./**
02. * Draw the maze.
03. *
04. * @param canvas
05. * Canvas object to draw too.
06. * @param paint
07. * Paint object used to draw with.
08. */
09. public void draw(Canvas canvas, Paint paint) {
10. // loop through our maze and draw each tile individually.
11. for (int i = 0; i 0)
22. mLocation = mCellRow * MAZE_COLS;
23.
24. // add the column location.
25. mLocation += mCellCol;
26.
27. return mMazeData[mLocation];
28. }
/**
* Determine which cell the marble currently occupies.
*
* @param x
* Current x co-ordinate of marble on the screen.
* @param y
* Current y co-ordinate of marble on the screen.
* @return The actual cell occupied by the marble.
*/
public int getCellType(int x, int y) {
// convert the x,y co-ordinate into row and col values.
int mCellCol = x / TILE_SIZE;
int mCellRow = y / TILE_SIZE;

// location is the row,col coordinate converted so we know where in the
// maze array to look.
int mLocation = 0;

// if we are beyond the 1st row need to multiple by the number of
// columns.
if (mCellRow > 0)
mLocation = mCellRow * MAZE_COLS;

// add the column location.
mLocation += mCellCol;

return mMazeData[mLocation];
}下面是Marble小球的坐标计算

01.// marble attributes
02.// x,y are private because we need boundary checking on any new values to
03.// make sure they are valid.
04.private int mX = 0;
05.private int mY = 0;
06.private int mRadius = 8;
07.private int mColor = Color.WHITE;
08.private int mLives = 5;

在AmazedView中的onDraw()调用gameTick()的时候会更新小球Marble的坐标：

01./**
02. * Called from gameTick(), update marble x,y based on latest values obtained
03. * from the Accelerometer sensor. AccelX and accelY are values received from
04. * the accelerometer, higher values represent the device tilted at a more
05. * acute angle.
06. */
07. public void updateMarble() {
08. // we CAN give ourselves a buffer to stop the marble from rolling even
09. // though we think the device is "flat".
10. if (mAccelX > mSensorBuffer || mAccelX mSensorBuffer || mAccelY 0) {
19. // user still has some lives remaining, restart the level.
20. mMarble.death();
21. mMarble.init();
22. mWarning = true;
23. } else {
24. // user has no more lives left, end of game.
25. mEndTime = System.currentTimeMillis();
26. mTotalTime += mEndTime - mStartTime;
27. switchGameState(GAME_OVER);
28. }
29.
30. } else if (mMaze.getCellType(mMarble.getX(), mMarble.getY()) == mMaze.EXIT_TILE) {
31. // user has reached the exit tiles, prepare the next level.
32. mEndTime = System.currentTimeMillis();
33. mTotalTime += mEndTime - mStartTime;
34. initLevel();
35. }
36. }

在Marble中更新小球坐标：

01./**
02. * Attempt to update the marble with a new x value, boundary checking
03. * enabled to make sure the new co-ordinate is valid.
04. *
05. * @param newX
06. * Incremental value to add onto current x co-ordinate.
07. */
08. public void updateX(float newX) {
09. mX += newX;
10.
11. // boundary checking, don't want the marble rolling off-screen.
12. if (mX + mRadius >= mView.getWidth())
13. mX = mView.getWidth() - mRadius;
14. else if (mX - mRadius < 0)
15. mX = mRadius;
16. }

if-else中是对左右边界的处理，同样的是对上下边界的处理。