【读书笔记《Android游戏编程之从零开始》】18.游戏开发基础（碰撞检测）

1.矩形碰撞

所谓矩形碰撞，就是利用两个矩形之间的位置关系来进行判断，如果矩形的像素在另外一个矩形之中，或者之上都可以认为这两个矩形发生了碰撞。

如果单纯的去考虑哪些情况会判定两个矩形发生碰撞，倒不如反思考虑两个矩形之间不发生碰撞的几种情况。其实两个矩形不发生碰撞的情况就上下左右这四种。

下面通过实例项目来完成对应的四种判定。

先看实例效果图：

新建项目，游戏框架为 SurfaceView 游戏框架，修改 MySurfaceView 类如下：

package com.example.ex4_15;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;

/**
 *
 * @author David
 *
 */
public class MySurfaceView extends SurfaceView implements Callback, Runnable {
    // 用于控制SurfaceView 的大小、格式等，并且主要用于监听SurfaceView 的状态
    private SurfaceHolder sfh;
    // 声明一个画笔
    private Paint paint;
    // 声明一个画布
    private Canvas canvas;
    // 声明一个线程
    private Thread th;
    // 线程消亡的标识符
    private boolean flag;
    // 声明屏幕的宽高
    private int screenW, screenH;

    // 定义两个矩形的宽高坐标
    private int x1 = 10, y1 = 110, w1 = 40, h1 = 40;
    private int x2 = 100, y2 = 110, w2 = 40, h2 = 40;
    // 便于观察是否发生了碰撞设置一个标识位
    private boolean isCollsion;

    /**
     * SurfaceView 初始化函数
     *
     * @param context
     */
    public MySurfaceView(Context context) {
        super(context);
        // 实例SurfaceView
        sfh = this.getHolder();
        // 为SurfaceView添加状态监听
        sfh.addCallback(this);
        // 实例一个画笔
        paint = new Paint();
        // 设置字体大小
        paint.setTextSize(20);
        // 设置画笔的颜色
        paint.setColor(Color.WHITE);
        // 设置画布无锯齿
        paint.setAntiAlias(true);
        // 设置焦点
        setFocusable(true);
    }

    /**
     * SurfaceView 视图状态发生改变时，响应此函数
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {

    }

    /**
     * SurfaceView 视图创建，响应此函数
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        screenW = this.getWidth();// 屏幕的宽
        screenH = this.getHeight();// 屏幕的高
        flag = true;
        // 实例线程
        th = new Thread(this);
        // 启动线程
        th.start();
    }

    /**
     * SurfaceView 视图消亡时，响应此函数
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        flag = false;
    }

    /**
     * 游戏绘图
     */
    private void myDraw() {
        try {
            // 获取SurfaceView 的Canvas 对象，
            canvas = sfh.lockCanvas();
            if (canvas != null) {
                // 刷新画布，背景为黑色
                canvas.drawColor(Color.BLACK);
                if (isCollsion) {
                    // 设置画笔为红色
                    paint.setColor(Color.RED);
                    // 设置画笔文本字体大小
                    paint.setTextSize(20);
                    // 绘制文本
                    canvas.drawText("矩形碰撞了！", 10, 30, paint);
                } else {
                    // 设置画笔为白色
                    paint.setColor(Color.WHITE);
                }
                // 绘制两个矩形
                canvas.drawRect(x1, y1, x1 + w1, y1 + h1, paint);
                canvas.drawRect(x2, y2, x2 + w2, y2 + h2, paint);
            }
        } catch (Exception e) {

        } finally {
            if (canvas != null) {
                // 解锁画布和提交
                sfh.unlockCanvasAndPost(canvas);
            }
        }
    }

    /**
     * 触屏事件监听
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // 让矩形1随着触屏位置移动
        x1 = (int) event.getX() - w1 / 2;
        y1 = (int) event.getY() - h1 / 2;
        if (isCollsionWithRect(x1, y1, w1, h1, x2, y2, w2, h2)) {
            isCollsion = true;
        } else {
            isCollsion = false;
        }
        return true;
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        return super.onKeyDown(keyCode, event);
    }

    /**
     * 游戏逻辑
     */
    private void logic() {
    }

    @Override
    public void run() {
        while (flag) {
            long start = System.currentTimeMillis();
            myDraw();
            logic();
            long end = System.currentTimeMillis();
            try {
                if (end - start < 50) {
                    Thread.sleep(50 - (end - start));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 碰撞情况判断
     * @param x1 第一个矩形的X坐标
     * @param y1 第一个矩形的Y坐标
     * @param w1 第一个矩形的宽
     * @param h1 第一个矩形的高
     * @param x2 第二个矩形的X坐标
     * @param y2 第二个矩形的Y坐标
     * @param w2 第二个矩形的宽
     * @param h2 第二个矩形的高
     * @return
     */
    public boolean isCollsionWithRect(int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2) {
        //当矩形1位于矩形2的左侧
        if (x1 >= x2 && x1 >= x2 + w2) {
            return false;
        }
        //当矩形1位于矩形2的右侧
        else if (x1 <= x2 && x1 + w1 <= x2) {
            return false;
        }
        //当矩形1位于矩形2的上方
        else if (y1 >= y2 && y1 >= y2 + h2) {
            return false;
        }
        //当矩形1位于矩形2的下方
        else if (y1 <= y2 && y1 + h1 <= y2) {
            return false;
        }
        //所有不会发生碰撞都不满足，肯定就是碰撞了
        return true;
    }
}

PS:在两个矩形之间进行碰撞检测时，不仅仅要判定两者X、Y坐标之间的位置关系，还要考虑到两个矩形的宽度和高度。

2.圆形碰撞

圆形之间的碰撞，主要是利用两圆心的圆心距离进行判定的；当两圆心的圆心距小于两圆半径之和时，判定发生了碰撞。还是用一个实例进行说明，效果图如下：

新建项目，游戏框架为 SurfaceView 游戏框架，修改 MySurfaceView 类如下，其中主要就是圆形碰撞函数方法isCollisionWithCircle：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;

/**
 *
 * @author David
 *
 */
public class MySurfaceView extends SurfaceView implements Callback, Runnable {
    // 用于控制SurfaceView 的大小、格式等，并且主要用于监听SurfaceView 的状态
    private SurfaceHolder sfh;
    // 声明一个画笔
    private Paint paint;
    // 声明一个画布
    private Canvas canvas;
    // 声明一个线程
    private Thread th;
    // 线程消亡的标识符
    private boolean flag;
    // 声明屏幕的宽高
    private int screenW, screenH;

    // 定义两个圆形的半径与坐标
    private int r1 = 20, r2 = 20;
    private int x1 = 50, y1 = 100, x2 = 150, y2 = 100;
    // 便于观察是否发生了碰撞设置一个标识位
    private boolean isCollsion;

    /**
     * SurfaceView 初始化函数
     *
     * @param context
     */
    public MySurfaceView(Context context) {
        super(context);
        // 实例SurfaceView
        sfh = this.getHolder();
        // 为SurfaceView添加状态监听
        sfh.addCallback(this);
        // 实例一个画笔
        paint = new Paint();
        // 设置字体大小
        paint.setTextSize(20);
        // 设置画笔的颜色
        paint.setColor(Color.WHITE);
        // 设置画布无锯齿
        paint.setAntiAlias(true);
        // 设置焦点
        setFocusable(true);
    }

    /**
     * SurfaceView 视图状态发生改变时，响应此函数
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {

    }

    /**
     * SurfaceView 视图创建，响应此函数
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        screenW = this.getWidth();// 屏幕的宽
        screenH = this.getHeight();// 屏幕的高
        flag = true;
        // 实例线程
        th = new Thread(this);
        // 启动线程
        th.start();
    }

    /**
     * SurfaceView 视图消亡时，响应此函数
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        flag = false;
    }

    /**
     * 游戏绘图
     */
    private void myDraw() {
        try {
            // 获取SurfaceView 的Canvas 对象，
            canvas = sfh.lockCanvas();
            if (canvas != null) {
                // 刷新画布，背景为黑色
                canvas.drawColor(Color.BLACK);
                if (isCollsion) {
                    // 设置画笔为红色
                    paint.setColor(Color.RED);
                    // 设置画笔文本字体大小
                    paint.setTextSize(20);
                    // 绘制文本
                    canvas.drawText("唉呀，碰撞了！", 10, 30, paint);
                } else {
                    // 设置画笔为白色
                    paint.setColor(Color.WHITE);
                }
                // 绘制两个圆形
                canvas.drawCircle(x1, y1, r1, paint);
                canvas.drawCircle(x2, y2, r2, paint);
            }
        } catch (Exception e) {

        } finally {
            if (canvas != null) {
                // 解锁画布和提交
                sfh.unlockCanvasAndPost(canvas);
            }
        }
    }

    /**
     * 触屏事件监听
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // 让矩形1随着触屏位置移动
        x1 = (int) event.getX();
        y1 = (int) event.getY();
        if (isCollisionWithCircle(x1, y1, x2, y2, r1, r2)) {
            isCollsion = true;
        } else {
            isCollsion = false;
        }
        return true;
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        return super.onKeyDown(keyCode, event);
    }

    /**
     * 游戏逻辑
     */
    private void logic() {
    }

    @Override
    public void run() {
        while (flag) {
            long start = System.currentTimeMillis();
            myDraw();
            logic();
            long end = System.currentTimeMillis();
            try {
                if (end - start < 50) {
                    Thread.sleep(50 - (end - start));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
    }
    /**
     * 圆形碰撞
     * @param x1    圆形1的圆心X坐标
     * @param y1    圆形2的圆心X坐标
     * @param x2    圆形1的圆心Y坐标
     * @param y2    圆形2的圆心Y坐标
     * @param r1    圆形1的半径
     * @param r2    圆形2的半径
     * @return
     */
    private boolean isCollisionWithCircle(int x1, int y1, int x2, int y2, int r1, int r2) {
        //Math.sqrt:开平方
        //Math.pow(double x, double y): X的Y次方
        if (Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2)) <= r1 + r2) {
            //如果两圆的圆心距小于或等于两圆半径则认为发生碰撞
            return true;
        }
        return false;
    }
}

3.像素碰撞

对于碰撞检测已经介绍了矩形与圆形两种方式，其实使用这两种检测方式不是很精确。比如两张大小相同的带透明度的矩形png图，如果利用矩形来进行碰撞，肯定不能以图的大小进行碰撞检测，因为可能只是透明像素位置发生碰撞，而非透明像素并没有发生碰撞，在屏幕上直观看来，也并没有发生碰撞。

而像素碰撞是怎样模拟碰撞的呢？首先遍历算出一张位图所有的像素点坐标，然后与另外一张位图上的所有点坐标进行对比，一旦有一个像素点的坐标相同，就立刻取出这两个坐标相同的像素点，通过位运算取出这两个像素点的最高位（透明度）进行对比，如果两个像素点都是非透明像素则判定这两张位图发生碰撞。

但正因为像素碰撞的这种高精确性判定，从而也会造成代码效率明显降低！假设两张100×100 大小的位图利用像素级检测碰撞，仅是遍历两张位图的像素点就要循环 100×100×2 = 20000 句逻辑代码；况且还要筛选出来的相同坐标的像素点进行遍历对比其透明值！这中效率可想而知！
像素级的碰撞检测是不推荐使用的。一般游戏开发中，取代像素级碰撞检测的方法是利用“多矩形”、“多圆形”的检测方式来实现的。

4.多矩形碰撞
所谓多矩形碰撞，顾名思义就是设置多个矩形碰撞区域。还是用一个实例进行说明，矩形部分为非透明部分，其他为透明部分，效果图如下：

新建项目，游戏框架为 SurfaceView 游戏框架，修改 MySurfaceView 类如下

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.Rect;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;

/**
 *
 * @author David
 *
 */
public class MySurfaceView extends SurfaceView implements Callback, Runnable {
    // 用于控制SurfaceView 的大小、格式等，并且主要用于监听SurfaceView 的状态
    private SurfaceHolder sfh;
    // 声明一个画笔
    private Paint paint;
    // 声明一个画布
    private Canvas canvas;
    // 声明一个线程
    private Thread th;
    // 线程消亡的标识符
    private boolean flag;
    // 声明屏幕的宽高
    private int screenW, screenH;

    // 定义两个矩形图形的宽高坐标
    private int rectX1 = 10, rectY1 = 10, rectW1 = 40, rectH1 = 40;
    private int rectX2 = 100, rectY2 = 110, rectW2 = 40, rectH2 = 40;
    // 便于观察是否发生了碰撞设置一个标识位
    private boolean isCollsion;
    // 定义第一个矩形的矩形碰撞数组
    private Rect clipRect1 = new Rect(0, 0, 15, 15);
    private Rect clipRect2 = new Rect(rectW1 - 15, rectH1 - 15, rectW1, rectH1);
    private Rect[] arrayRect1 = new Rect[] { clipRect1, clipRect2 };
    // 定义第二个矩形的矩形碰撞数组
    private Rect clipRect3 = new Rect(0, 0, 15, 15);
    private Rect clipRect4 = new Rect(rectW2 - 15, rectH2 - 15, rectW2, rectH2);
    private Rect[] arrayRect2 = new Rect[] { clipRect3, clipRect4 };

    /**
     * SurfaceView 初始化函数
     *
     * @param context
     */
    public MySurfaceView(Context context) {
        super(context);
        // 实例SurfaceView
        sfh = this.getHolder();
        // 为SurfaceView添加状态监听
        sfh.addCallback(this);
        // 实例一个画笔
        paint = new Paint();
        // 设置字体大小
        paint.setTextSize(20);
        // 设置画笔的颜色
        paint.setColor(Color.WHITE);
        // 设置画布无锯齿
        paint.setAntiAlias(true);
        // 设置焦点
        setFocusable(true);
    }

    /**
     * SurfaceView 视图状态发生改变时，响应此函数
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {

    }

    /**
     * SurfaceView 视图创建，响应此函数
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        screenW = this.getWidth();// 屏幕的宽
        screenH = this.getHeight();// 屏幕的高
        flag = true;
        // 实例线程
        th = new Thread(this);
        // 启动线程
        th.start();
    }

    /**
     * SurfaceView 视图消亡时，响应此函数
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        flag = false;
    }

    /**
     * 游戏绘图
     */
    private void myDraw() {
        try {
            // 获取SurfaceView 的Canvas 对象，
            canvas = sfh.lockCanvas();
            if (canvas != null) {
                // 刷新画布，背景为黑色
                canvas.drawColor(Color.BLACK);
                paint.setColor(Color.WHITE);
                paint.setStyle(Style.FILL);
                if (isCollsion) {
                    paint.setTextSize(20);
                    canvas.drawText("哎呀呀，合体了！", 0, 30, paint);
                }
                // 绘制两个矩形
                canvas.drawRect(rectX1, rectY1, rectX1 + rectW1, rectY1
                        + rectH1, paint);
                canvas.drawRect(rectX2, rectY2, rectX2 + rectW2, rectY2
                        + rectH2, paint);
                // ---绘制碰撞区域使用非填充，并设置画笔颜色白色
                paint.setStyle(Style.STROKE);
                paint.setColor(Color.RED);
                // 绘制第一个矩形的所有矩形碰撞区域
                for (int i = 0; i < arrayRect1.length; i++) {
                    canvas.drawRect(arrayRect1[i].left + this.rectX1,
                            arrayRect1[i].top + this.rectY1,
                            arrayRect1[i].right + this.rectX1,
                            arrayRect1[i].bottom + this.rectY1, paint);
                }
                // 绘制第二个矩形的所有矩形碰撞区域
                for (int i = 0; i < arrayRect2.length; i++) {
                    canvas.drawRect(arrayRect2[i].left + this.rectX2,
                            arrayRect2[i].top + this.rectY2,
                            arrayRect2[i].right + this.rectX2,
                            arrayRect2[i].bottom + rectY2, paint);
                }
            }
        } catch (Exception e) {

        } finally {
            if (canvas != null) {
                // 解锁画布和提交
                sfh.unlockCanvasAndPost(canvas);
            }
        }
    }

    /**
     * 触屏事件监听
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // 让矩形1随着触屏位置移动
        rectX1 = (int) event.getX() - rectW1 / 2;
        rectY1 = (int) event.getY() - rectH1 / 2;
        if (isCollsionWithRect(arrayRect1, arrayRect2)) {
            isCollsion = true;
        } else {
            isCollsion = false;
        }
        return true;
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        return super.onKeyDown(keyCode, event);
    }

    /**
     * 游戏逻辑
     */
    private void logic() {
    }

    @Override
    public void run() {
        while (flag) {
            long start = System.currentTimeMillis();
            myDraw();
            logic();
            long end = System.currentTimeMillis();
            try {
                if (end - start < 50) {
                    Thread.sleep(50 - (end - start));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    // Rect 类中的四个属性 top bottom left right
    // 分别表示这个矩形的 上 下 左 右
    public boolean isCollsionWithRect(Rect[] rectArray, Rect[] rect2Array) {
        Rect rect = null;
        Rect rect2 = null;
        for (int i = 0; i < rectArray.length; i++) {
            // 依次取出第一个矩形数组的每个矩形实例
            rect = rectArray[i];
            // 获取到第一个矩形数组中每个矩形元素的属性值
            int x1 = rect.left + this.rectX1;
            int y1 = rect.top + this.rectY1;
            int w1 = rect.right - rect.left;
            int h1 = rect.bottom - rect.top;
            for (int j = 0; j < rect2Array.length; j++) {
                // 依次取出第二个矩形数组的每个矩形实例
                rect2 = rect2Array[j];
                // 获取到第二个矩形数组中每个矩形元素的属性值
                int x2 = rect2.left + this.rectX2;
                int y2 = rect2.top + this.rectY2;
                int w2 = rect2.right - rect2.left;
                int h2 = rect2.bottom - rect2.top;
                // 进行循环遍历两个矩形碰撞数组所有元素之间的位置关系
                if (x1 >= x2 && x1 >= x2 + w2) {
                } else if (x1 <= x2 && x1 + w1 <= x2) {
                } else if (y1 >= y2 && y1 >= y2 + h2) {
                } else if (y1 <= y2 && y1 + h1 <= y2) {
                } else {
                    // 只要有一个碰撞矩形数组与另一碰撞矩形数组发生碰撞则认为碰撞
                    return true;
                }
            }
        }
        return false;
    }
}

由于多圆形的碰撞检测类似于多矩形碰撞，不再赘述。

5.Region 碰撞检测

在之前的笔记“游戏开发基础（剪切区域）”中介绍过 Region 这个类，其实此类还有一个比较常用的方法就是用于判断一个点是否在矩形区域内，其方法是使用 Region 类中的 contains(int x,int y) 函数。

下面用一个实例进行说明,效果为当用户触屏的坐标点在碰撞矩形内时，显示指定的位图：

新建项目，游戏框架为 SurfaceView 游戏框架，修改 MySurfaceView 类如下

import android.content.Context;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Region;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;

/**
 *
 * @author David
 *
 */
public class MySurfaceView extends SurfaceView implements Callback, Runnable {
    // 用于控制SurfaceView 的大小、格式等，并且主要用于监听SurfaceView 的状态
    private SurfaceHolder sfh;
    // 声明一个画笔
    private Paint paint;
    // 声明一个画布
    private Canvas canvas;
    // 声明一个线程
    private Thread th;
    // 线程消亡的标识符
    private boolean flag;
    // 声明屏幕的宽高
    private int screenW, screenH;

    // 定义碰撞矩形
    private Rect rect = new Rect(0, 0, 50, 50);
    // 定义Region类实例
    private Region r = new Region(rect);
    // 表示是否发生碰撞的标识位
    private boolean isInclude;

    /**
     * SurfaceView 初始化函数
     *
     * @param context
     */
    public MySurfaceView(Context context) {
        super(context);
        // 实例SurfaceView
        sfh = this.getHolder();
        // 为SurfaceView添加状态监听
        sfh.addCallback(this);
        // 实例一个画笔
        paint = new Paint();
        // 设置字体大小
        paint.setTextSize(20);
        // 设置画笔的颜色
        paint.setColor(Color.WHITE);
        // 设置画布无锯齿
        paint.setAntiAlias(true);
        // 设置焦点
        setFocusable(true);
    }

    /**
     * SurfaceView 视图状态发生改变时，响应此函数
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {

    }

    /**
     * SurfaceView 视图创建，响应此函数
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        screenW = this.getWidth();// 屏幕的宽
        screenH = this.getHeight();// 屏幕的高
        flag = true;
        // 实例线程
        th = new Thread(this);
        // 启动线程
        th.start();
    }

    /**
     * SurfaceView 视图消亡时，响应此函数
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        flag = false;
    }

    /**
     * 游戏绘图
     */
    private void myDraw() {
        try {
            // 获取SurfaceView 的Canvas 对象，
            canvas = sfh.lockCanvas();
            if (canvas != null) {
                // 刷新画布，背景为黑色
                canvas.drawColor(Color.BLACK);
                // 标识位为真时，绘制icon图
                if (isInclude) {
                    canvas.drawBitmap(BitmapFactory.decodeResource(
                            this.getResources(), R.drawable.ic_launcher), 100,
                            50, paint);
                }
                // 绘制矩形区域（便于观察）
                canvas.drawRect(rect, paint);
            }
        } catch (Exception e) {

        } finally {
            if (canvas != null) {
                // 解锁画布和提交
                sfh.unlockCanvasAndPost(canvas);
            }
        }
    }

    /**
     * 触屏事件监听
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // 判定用户触屏的坐标点是否在碰撞矩形内
        if (r.contains((int) event.getX(), (int) event.getY())) {
            isInclude = true;
        } else {
            isInclude = false;
        }
        return true;
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        return super.onKeyDown(keyCode, event);
    }

    /**
     * 游戏逻辑
     */
    private void logic() {
    }

    @Override
    public void run() {
        while (flag) {
            long start = System.currentTimeMillis();
            myDraw();
            logic();
            long end = System.currentTimeMillis();
            try {
                if (end - start < 50) {
                    Thread.sleep(50 - (end - start));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

本文地址：http://www.cnblogs.com/yc-755909659/p/4186193.html

PS：本文由Y灬叶超原创，如有转载请注明出处，谢谢！

时间： 2024-10-27 06:17:57

【读书笔记《Android游戏编程之从零开始》】18.游戏开发基础（碰撞检测）的相关文章

【读书笔记-《Android游戏编程之从零开始》】3.Android 游戏开发常用的系统控件（Button、Layout、ImageButton）

3.1 Button Button这控件不用多说,就是一个按钮,主要是点击后进行相应事件的响应. 给组件添加ID属性:定义格式为 android:id="@+id/name",这里的name是自定义的,不是索引变量."@+"表示新声明,"@"表示引用,例如:"@+id/tv" 表示新声明一个id,是id名为tv的组件:"@id/tv" 表示引用id名为tv的组件. 给按钮添加点击事件响应  想知道按钮是否被

【读书笔记-《Android游戏编程之从零开始》】1.Android 平台简介与环境搭建

简单的记录下笔记,具体可百度! Android SDK (Software Development Kit)- Android 软件开发工具包,用于辅助Android 操作系统软件开发,是开发Android 软件.文档.范例.工具的一个集合.Android NDK (Native Development Kit) - 类似 Android SDK,可用C/C++语言编写Android程序. developer.android.com - 可查阅到 Android SDK. 开发指南.API说明等

【读书笔记-《Android游戏编程之从零开始》】8.Android 游戏开发常用的系统控件（系统控件常见问题）

Android 中常用的计量单位Android有时候需要一些计量单位,比如在布局Layout文件中可能需要指定具体单位等.常用的计量单位有:px.dip(dp).sp,以及一些不常用的pt.in.mm.下面详细介绍下这些计量单位之间的区别和联系.in:英寸(长度单位):mm:毫米(长度单位):pt:磅/点,1/72英寸(一个标准的长度单位):sp:全名 scaled pixels-best for text size,放大像素,与刻度无关,可以根据用户的字体大小就行缩放,主要用来处理字体的大小:

【读书笔记-《Android游戏编程之从零开始》】5.Android 游戏开发常用的系统控件（ProgressBar、Seekbar）

3.7 ProgressBar ProgressBar类官方文档地址:http://developer.android.com/reference/android/widget/ProgressBar.html 在Android应用开发中,ProgressBar(运行进度条)是比较常用到的组件,例如下载进度.安装程序进度.加载资源进度显示等.在Android中提供了两种样式来分别表示在不同状态下显示的进度条,下面来实现这两种样式.默认进度条是圆形,通过style属性来指定系统进度条的大小:sty

【读书笔记-《Android游戏编程之从零开始》】4.Android 游戏开发常用的系统控件（EditText、CheckBox、Radiobutton）

3.4 EditText EditText类官方文档地址:http://developer.android.com/reference/android/widget/EditText.html EditText继承TextView,所以EditText具有TextView的属性特点,下面主要介绍一些EditText的特有的输入法的属性特点android:layout_gravity="center_vertical":设置控件显示的位置:默认top,这里居中显示,还有bottomand

【读书笔记-《Android游戏编程之从零开始》】6.Android 游戏开发常用的系统控件（TabHost、ListView）

3.9 TabSpec与TabHost TabHost类官方文档地址:http://developer.android.com/reference/android/widget/TabHost.html Android 实现tab视图有2种方法,一种是在布局页面中定义<tabhost>标签,另一种就是继承tabactivity.但是我比较喜欢第二种方式,应为如果页面比较复杂的话你的XML文件会写得比较庞大,用第二种方式XML页面相对要简洁得多. <?xml version="1

Android游戏编程之从零开始pdf

下载地址:网盘下载 <Android游戏编程之从零开始>主要系统地讲解了Android游戏开发,从最基础部分开始,让零基础的Android初学者也能快速学习和掌握Android游戏开发.<Android游戏编程之从零开始>一共8章,内容包括Android平台介绍与环境搭建.Hello,Android!项目剖析.游戏开发中常用的系统组件.游戏开发基础.游戏开发实战.游戏开发提高篇.Box2d物理引擎.物理游戏实战.随书光盘包括全书65个项目源代码.<Android游戏编程之从零

Windows游戏编程之从零开始d

I'm back~~恩,几个月不见,大家还好吗? 这段时间真的好多童鞋在博客里留言说或者发邮件说浅墨你回来继续更新博客吧. woxiangnifrr童鞋说每天都在来浅墨的博客逛一下看有没有更新,"每天都来就像看女神那般不依不舍",弄得我再不更新都不好意思了,哈哈~怎么说呢,前段时间忙毕设,回国,暑假,间隔年旅行休整,然后是适应新的生活,各种事情,也真正没有心境来更新博客了,最近正好心境安定下来,就继续开始写博.额,关于思想汇报改天我专门写一篇文章和大家交流交流,现在先打住说正事吧~ 首

读书笔记-----Java并发编程实战（一）线程安全性

线程安全类:在线程安全类中封装了必要的同步机制,客户端无须进一步采取同步措施 示例:一个无状态的Servlet 1 @ThreadSafe 2 public class StatelessFactorizer implements Servlet{ 3 public void service(ServletRequest req,ServletResponse resp){ 4 BigInteger i = extractFromRequest(req); 5 BigInteger[] fact

游戏新手村：从零开始做游戏

写在前面的话 年前看到张亮<从零开始做运营>在百度阅读上发布,于是便萌生了自己也撰写1篇作品的想法.首先是为了记录自己的想法.记录和观点,其次也算是对自己过去几年做游戏的一点总结,最后也想过把瘾:"看,这是哥写的书". 为什么要写这本书 最近这10多年是中国游戏产业蓬勃发展的10多年.一波又一波的游戏公司先后上市,一个又一个的千万富翁陆续诞生,一批又一批的有志年轻人和应届毕业生前仆后继的进入到了游戏行业,去从事游戏策划以及游戏运营等工作. 互联网的精神是开放和分享,但是游戏