android 项目实训——（三）

最新推荐文章于 2023-12-12 22:57:20 发布

sunda112

最新推荐文章于 2023-12-12 22:57:20 发布

阅读量1.1k

点赞数

分类专栏： android学习篇

android学习篇专栏收录该内容

13 篇文章 0 订阅

订阅专栏

 
     // 更新
 
    public void update() {
 
        // 如果是处于运行状态
 
        if (mMode == RUNNING) {
 
 
 
            long now = System.currentTimeMillis();
 
 
 
            // 如果当前时间距离最后一次移动的时间超过了延迟时间
 
            if (now - mLastMoveTime > mMoveDelay) {
 
                //
 
                clearTiles();
 
                updateWalls();
 
                updateSnake();
 
                updateApples();
 
                mLastMoveTime = now;
 
            }
 
            //会话进程睡一个延迟时间单位
 
            mRedrawHandler.sleep(mMoveDelay);
 
        }
 
 
 
    }
 
 
 
    // 更新墙
 
    private void updateWalls() {
 
        Log.i(tag, "updateWalls");
 
        for (int x = 0; x < mXTileCount; x++) {
 
            // 给上边线的每个贴片位置设置一个绿色索引标识
 
            setTile(GREEN_STAR, x, 0);
 
            // 给下边线的每个贴片位置设置一个绿色索引标识
 
            setTile(GREEN_STAR, x, mYTileCount - 1);
 
        }
 
        for (int y = 1; y < mYTileCount - 1; y++) {
 
            // 给左边线的每个贴片位置设置一个绿色索引标识
 
            setTile(GREEN_STAR, 0, y);
 
            // 给右边线的每个贴片位置设置一个绿色索引标识
 
            setTile(GREEN_STAR, mXTileCount - 1, y);
 
        }
 
    }
 
 
 
    // 更新苹果
 
    private void updateApples() {
 
        Log.i(tag, "updateApples");
 
 
 
        for (Coordinate c : mAppleList) {
 
            setTile(YELLOW_STAR, c.x, c.y);
 
        }
 
    }
 
 
 
    // 更新蛇
 
    private void updateSnake() {
 
        // 生长标志
 
        boolean growSnake = false;
 
 
 
        // 得到蛇头坐标
 
        Coordinate head = mSnakeTrail.get(0);
 
        // 初始化一个新的蛇头坐标
 
        Coordinate newHead = new Coordinate(1, 1);
 
 
 
        // 当前方向改成新的方向
 
        mDirection = mNextDirection;
 
 
 
        // 根据方向确定蛇头新坐标
 
        switch (mDirection) {
 
        // 如果方向向东（右），那么X加1
 
        case EAST: {
 
            newHead = new Coordinate(head.x + 1, head.y);
 
            break;
 
        }
 
            // 如果方向向西（左），那么X减1
 
        case WEST: {
 
            newHead = new Coordinate(head.x - 1, head.y);
 
            break;
 
        }
 
            // 如果方向向北（上），那么Y减1
 
        case NORTH: {
 
            newHead = new Coordinate(head.x, head.y - 1);
 
            break;
 
        }
 
            // 如果方向向南（下），那么Y加1
 
        case SOUTH: {
 
            newHead = new Coordinate(head.x, head.y + 1);
 
            break;
 
        }
 
        }
 
 
 
        // 冲突检测 新蛇头是否四面墙重叠，那么游戏结束
 
        if ((newHead.x < 1) || (newHead.y < 1) || (newHead.x > mXTileCount - 2)
 
                || (newHead.y > mYTileCount - 2)) {
 
            // 设置游戏状态为Lose
 
            setMode(LOSE);
 
            // 返回
 
            return;
 
 
 
        }
 
 
 
        // 冲突检测 新蛇头是否和自身坐标重叠，重叠的话游戏也结束
 
        int snakelength = mSnakeTrail.size();
 
 
 
        for (int snakeindex = 0; snakeindex < snakelength; snakeindex++) {
 
            Coordinate c = mSnakeTrail.get(snakeindex);
 
            if (c.equals(newHead)) {
 
                // 设置游戏状态为Lose
 
                setMode(LOSE);
 
                // 返回
 
                return;
 
            }
 
        }
 
 
 
        // 看新蛇头和苹果们是否重叠
 
        int applecount = mAppleList.size();
 
        for (int appleindex = 0; appleindex < applecount; appleindex++) {
 
            Coordinate c = mAppleList.get(appleindex);
 
            if (c.equals(newHead)) {
 
                // 如果重叠，苹果坐标从苹果列表中移除
 
                mAppleList.remove(c);
 
                // 再立刻增加一个新苹果
 
                addRandomApple();
 
                // 得分加一
 
                mScore++;
 
                // 延迟是以前的90%
 
                mMoveDelay *= 0.9;
 
                // 蛇增长标志改为真
 
                growSnake = true;
 
            }
 
        }
 
 
 
        // 在蛇头的位置增加一个新坐标
 
        mSnakeTrail.add(0, newHead);
 
        // 如果没有增长
 
        if (!growSnake) {
 
            // 如果蛇头没增长则删去最后一个坐标，也就相当于蛇向前走了一步^_^
 
            mSnakeTrail.remove(mSnakeTrail.size() - 1);
 
        }
 
 
 
        int index = 0;
 
        // 重新设置一下颜色，蛇头式黄色的，蛇身是红色的
 
        for (Coordinate c : mSnakeTrail) {
 
            if (index == 0) {
 
                setTile(YELLOW_STAR, c.x, c.y);
 
            } else {
 
                setTile(RED_STAR, c.x, c.y);
 
            }
 
            index++;
 
        }
 
 
 
    }
 
 
 
    // 定义坐标内部类
 
    private class Coordinate {
 
 
 
        public int x;
 
        public int y;
 
 
 
        // 构造函数
 
        public Coordinate(int newX, int newY) {
 
            x = newX;
 
            y = newY;
 
        }
 
 
 
        // 重写equals
 
        public boolean equals(Coordinate other) {
 
            if (x == other.x && y == other.y) {
 
                return true;
 
            }
 
            return false;
 
        }
 
 
 
        // 重写toString
 
        @Override
 
        public String toString() {
 
            return "Coordinate: [" + x + "," + y + "]";
 
        }
 
    }
 
 
 
    // 添加苹果
 
    private void addRandomApple() {
 
        // 新的坐标
 
        Coordinate newCoord = null;
 
        //
 
        boolean flag = true;
 
        // 为真的话在循环体内一直循环
 
        while (flag) {
 
            // 为苹果再找一个坐标,先随机一个X值
 
            int newX = 1 + RNG.nextInt(mXTileCount - 2);
 
            // 再随机一个Y值
 
            int newY = 1 + RNG.nextInt(mYTileCount - 2);
 
            // 新坐标
 
            newCoord = new Coordinate(newX, newY);
 
 
 
            // 下面确保新苹果不在蛇身下，先假设没发生冲突
 
            boolean collision = false;
 
 
 
            int snakelength = mSnakeTrail.size();
 
            // 和蛇占据的所有坐标比较
 
            for (int index = 0; index < snakelength; index++) {
 
                // 只要和蛇占据的任何一个坐标相同，即认为发生冲突了
 
                if (mSnakeTrail.get(index).equals(newCoord)) {
 
                    collision = true;
 
                }
 
            }
 
            // 如果有冲突就继续循环，如果没冲突flag的值就是false,那么自然会退出循环，新坐标也就诞生了
 
            flag = collision;
 
        }
 
 
 
        if (newCoord == null) {
 
            Log.e(tag, "Somehow ended up with a null newCoord!");
 
        }
 
        // 生成一个新苹果放在苹果列表中（两个苹果可能会重合吧）
 
        mAppleList.add(newCoord);
 
    }
 
 
 
    // 初始化游戏
 
    private void initNewGame() {
 
 
 
        Log.e(tag, "initNewGame!");
 
 
 
        // 清空ArrayList列表
 
        mSnakeTrail.clear();
 
        mAppleList.clear();
 
 
 
        // 创建蛇身
 
        mSnakeTrail.add(new Coordinate(7, 7));
 
        mSnakeTrail.add(new Coordinate(6, 7));
 
        mSnakeTrail.add(new Coordinate(5, 7));
 
        mSnakeTrail.add(new Coordinate(4, 7));
 
        mSnakeTrail.add(new Coordinate(3, 7));
 
        mSnakeTrail.add(new Coordinate(2, 7));
 
 
 
        // 新的方向 ：北方
 
        mNextDirection = NORTH;
 
 
 
        // 开始都时候有2个苹果
 
        addRandomApple();
 
        addRandomApple();
 
 
 
        // 设置移动延迟
 
        mMoveDelay = 600;
 
        // 得分0
 
        mScore = 0;
 
    }
 
 
 
    // 保存状态
 
    public Bundle saveState() {
 
 
 
        Bundle bundle = new Bundle();
 
 
 
        bundle.putIntArray("mAppleList", coordArrayListToArray(mAppleList));
 
        bundle.putIntArray("mSnakeTrail", coordArrayListToArray(mSnakeTrail));
 
 
 
        bundle.putInt("mDirection", Integer.valueOf(mDirection));
 
        bundle.putInt("mNextDirection", Integer.valueOf(mNextDirection));
 
 
 
        bundle.putLong("mMoveDelay", Long.valueOf(mMoveDelay));
 
        bundle.putLong("mScore", Long.valueOf(mScore));
 
 
 
        return bundle;
 
    }
 
 
 
    // 恢复状态
 
    public void restoreState(Bundle icicle) {
 
 
 
        setMode(PAUSE);
 
 
 
        mAppleList = coordArrayToArrayList(icicle.getIntArray("mAppleList"));
 
        mDirection = icicle.getInt("mDirection");
 
        mNextDirection = icicle.getInt("mNextDirection");
 
        mMoveDelay = icicle.getLong("mMoveDelay");
 
        mScore = icicle.getLong("mScore");
 
        mSnakeTrail = coordArrayToArrayList(icicle.getIntArray("mSnakeTrail"));
 
    }
 
 
 
    // 整数数组转坐标数组
 
    private ArrayList coordArrayToArrayList(int[] rawArray) {
 
        ArrayList coordArrayList = new ArrayList();
 
 
 
        int coordCount = rawArray.length;
 
        for (int index = 0; index < coordCount; index += 2) {
 
            Coordinate c = new Coordinate(rawArray[index], rawArray[index + 1]);
 
            coordArrayList.add(c);
 
        }
 
        return coordArrayList;
 
    }
 
 
 
    // 坐标数组转整数数组
 
    private int[] coordArrayListToArray(ArrayList cvec) {
 
        int count = cvec.size();
 
        int[] rawArray = new int[count * 2];
 
        for (int index = 0; index < count; index++) {
 
            Coordinate c = cvec.get(index);
 
            rawArray[2 * index] = c.x;
 
            rawArray[2 * index + 1] = c.y;
 
        }
 
        return rawArray;
 
    }
 
 
 
}

6、MainActivity

 
package android.basic.lesson48;
 
 
 
import android.app.Activity;
 
import android.os.Bundle;
 
import android.widget.TextView;
 
 
 
public class MainActivity extends Activity {
 
 
 
    private SnakeView mSnakeView;
 
 
 
    private static String ICICLE_KEY = "snake-view";
 
 
 
    /** Called when the activity is first created. */
 
    @Override
 
    public void onCreate(Bundle savedInstanceState) {
 
 
 
        super.onCreate(savedInstanceState);
 
        setContentView(R.layout.main);
 
 
 
        mSnakeView = (SnakeView) findViewById(R.id.snake);
 
        TextView tv = (TextView) findViewById(R.id.text);
 
 
 
        mSnakeView.setStatusTextView(tv);
 
 
 
        //检查存贮状态以确定是重新开始还是恢复状态
 
        if (savedInstanceState == null) {
 
            //存储状态为空，说明刚启动可以切换到准备状态
 
            mSnakeView.setMode(SnakeView.READY);
 
        } else {
 
            //已经保存过，那么就去恢复原有状态
 
            Bundle bundle = savedInstanceState.getBundle(ICICLE_KEY);
 
            if (bundle != null) {
 
                //恢复状态
 
                mSnakeView.restoreState(bundle);
 
            } else {
 
                //设置状态为暂停
 
                mSnakeView.setMode(SnakeView.PAUSE);
 
            }
 
        }
 
    }
 
 
 
    //暂停事件被触发时
 
    @Override
 
    protected void onPause() {
 
        super.onPause();
 
        // Pause the game along with the activity
 
        mSnakeView.setMode(SnakeView.PAUSE);
 
    }
 
 
 
    //状态保存
 
    @Override
 
    public void onSaveInstanceState(Bundle outState) {
 
        //存储游戏状态到View里
 
        outState.putBundle(ICICLE_KEY, mSnakeView.saveState());
 
    }
 
}