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

最新推荐文章于 2024-04-30 19:41:08 发布
最新推荐文章于 2024-04-30 19:41:08 发布
阅读量98 收藏
点赞数
文章标签： 移动开发
原文链接：http://www.cnblogs.com/yc-755909659/p/4186193.html
版权
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;
    }
}
View Code
 
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;
    }
}
View Code

 

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;
    }
}
View Code

 

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

 

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();
            }
        }
    }
}
View Code

 

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

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

转载于:https://www.cnblogs.com/yc-755909659/p/4186193.html

ajhtdi1157
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
判断两个矩形是否相交的4个方法
weixin_30256901的博客
02-21 3021
http://blog.csdn.net/cxf7394373/article/details/7535105 最近在用opencv寫一個文本定位的程序，獲取到字符輪廓之後需要進行合並，涉及到判斷矩形是否相交的問題，記得去年去三星通信研究院面試同樣問到了這個問題，如何判斷兩條線段是否相交，如何判斷兩個矩形是否相交。以前寫過一篇如何判斷線段相交的問題，上網查了一些方法，在這裡做一下後一...
零基础如何学习编程心得笔记(1).pdf
11-16
零基础如何学习编程心得笔记(1).pdf
Android开发教程+笔记十-基础UI编程4.pdf
11-17
Android开发教程+笔记十-基础UI编程4.pdf
《从零开始学架构》读书笔记
12-27
《从零开始学架构》读书笔记，以思维导图的方式进行归纳总结知识要点。
Android游戏开发之碰撞检测（矩形碰撞、圆形碰撞、像素碰撞）
01-05
本文为大家分享了Android游戏开发之碰撞检测，供大家参考，具体内容如下 矩形碰撞 原理: 两个矩形位置 的四种情况 不是这四中情况 则碰撞 圆形碰撞 原理: 利用两个圆心之间的距离进行判定.当两个圆心的距离小于半径之和则碰撞. 像素碰撞 原理:不适用 遍历所有像素 检测 太多了 多矩形碰撞 原理:设置多个矩形碰撞检测区域 检测碰撞矩形数组 与另一碰撞矩形数组之间的位置关系. 矩形碰撞 代码: public class MySurfaceView extends SurfaceView implements Callback, Runnable { private SurfaceHol
游戏编程开发学习整理笔记分享.zip
12-10
游戏编程模式 QFramework Unity框架 Unity 3D高级编程 游戏感等等
android 矩形碰撞
michellebaby的专栏
06-26 962
矩形碰撞就是利用两个矩形之间的位置关系来进行判断，如果一个矩形的像素在另外一个矩形之中，或者之上都可以认为这两个矩形发生了碰撞。其实两个矩形不发生碰撞的情况就只有四种，其他情况就是发生碰撞了 创建实例：RectCollion, 游戏框架为SurfaceView 项目效果图：     MySurfaceView.java package com.rectCollsio
2个矩形碰撞检测
zhang1chao5的专栏
02-11 2098
if (x1 >= x2 && x1 >= x2 + w2)  {   return false;  //当矩形1 位于矩形2 的右侧 ;  }  else if (x1  {  return false;  //当矩形1 位于矩形2 的上方 ;  }  else if (y1 >= y2 && y1 >= y2 + h2)  {  return false;  //当矩
多矩形碰撞
weixin_33851604的博客
10-07 150
转自http://bbs.lanou3g.com/forum.php?mod=viewthread&tid=4854&extra=page%3D1我们可以在每加飞机的机身上加两个矩形,当然这两个矩形是不可见的,把与每个飞机所绑定的矩形放到不同的数组里面,数组的元素类型是矩形,然后再遍利两个数组,看一个数组里面的矩形是否和另外一个数组里面的矩形发生了碰撞,原理就...
判断两个矩形是否交叉(包括包含的情况)
kevin_org
02-15 9834
转自：https://www.cnblogs.com/avril/archive/2012/11/13/2767577.html 问题：给定两个矩形A和B，矩形A的左上角坐标为（Xa1,Ya1），右下角坐标为（Xa2,Ya2），矩形B的左上角坐标为（Xb1,Yb1），右下角坐标为（Xb2,Yb2）。 （a）设计一个算法，确定两个矩形是否相交（即有重叠区域） （b）如果两个矩形相交，设计一个算法，求...
Android游戏中最简单的碰撞检测
abcnull 的博客
05-23 1703
Android游戏中最简单的碰撞检测   由于本人在本科毕业时候做的毕设是一个小游戏，其中就有碰撞检测的实现，如下代码，先自己写一个可以得到碰撞点的方法getCollidePoint(Sprite s)返回的是Point类，之后只要这个碰撞点是存在的，则表示两个游戏的精灵发生了碰撞。逻辑比较简单，用得到了sdk的graphics包下的setIntersect()方法看是否相交。 //得...
测试笔记(从零开始).pdf
12-16
测试笔记(从零开始).pdf
【读书笔记《Android游戏编程之从零开始》】10.游戏开发基础（View 游戏框架）...
12-04 109
对于玩家来说，游戏是动态的；对于游戏开发人员来说，游戏是静态的，只是不停地播放不通的画面，让玩家看到了动态的效果。进入Android之前，首先要熟悉三个重要的类：View（视图）、Canvas（画布）、Paint（画笔）。通过画笔，可以在画布上画出各种精彩的图形、图片等等，然后通过视图可以将画布上的内容展现在手机屏幕上。其次要熟悉“刷屏”的概念。绘制在画布中的图像不管是图片还是图形，都是...
安卓学习笔记（1）-2048游戏遇到的问题与解决方案
kabuto_hui的博客
09-15 3744
前言​ 前段时间对java的基础学习之后，开始着手于安卓的学习。感谢极客学院的视频教程中关于2048游戏开发的完整教程。我在此项目的基础上对界面进行了优化，添加了颜色，新游戏按钮，增加了当前成绩和最好成绩模块等。现将这个项目中的一些知识点和遇到问题进行总结，欢迎各位进行交流~~~。下面就是我初步完成之后的游戏界面。​ 关于程序运行逻辑​ 首先建立了一个Ca
【读书笔记《Android游戏编程之从零开始》】19.游戏开发基础（游戏音乐与音效）
今天的成功，是昨天换来的
01-04 655
在一款游戏中，除了华丽的界面 UI 直接吸引玩家外，另外重要的就是游戏的背景音乐与音效；合适的背景音乐以及精彩的音效搭配会令整个游戏上升一个档次。 在 Android 中。常用于播放游戏背景音乐的类是 MediaPlayer， 而用于游戏音效的则是 SoundPool 类。   1. MediaPlayer MediaPlayer 实例化不是 new 出来的，而是通过调用静态方法得到的，这
用数学方法解决工程问题系列（二） 两个矩形（多边形）的碰撞检测
日西月东的专栏
03-18 1723
关于碰撞检测，喜欢深入探究的同学可以去书店买书看，网上当然也有很多资源可以参考，这里只贴出代码，供C#开发的同学参照。以下代码中，AABBvsAABB()是给不倾斜的矩形判断碰撞时调用的，OBBvsOBB则是给任意角度矩形判断碰撞时使用。public class OBBCollisionDetect { /// <summary> /// AABB 碰撞检测
Android游戏开发基础part7--碰撞检测
mmdev
06-25 196
Android游戏开发基础--碰撞检测 在游戏当中碰撞无时不在，比如在射击游戏当中碰撞更是家常便饭，游戏主角在跟敌机发生碰撞，游戏主角跟敌机子弹发生碰撞，或者反过来敌机跟游戏主角发生碰撞，敌机更主角子弹发生碰撞等等。 一般我们都会有碰撞检测，发生碰撞时应该发生什么状况是我们需要设计的，比如主角的血量减少，或者敌机发生爆炸等等。只有通过碰撞的检测，我们才能进而触发相应的事件。 《Andr...
特效
缥缈的云 专栏
04-10 1124
新建工程，名为testEffect 修改HelloWorldScene.h #ifndef __HELLOWORLD_SCENE_H__ #define __HELLOWORLD_SCENE_H__ #include "cocos2d.h" class HelloWorld : public cocos2d::CCLayer { publ
透明的Activity:主题样式：
最新发布
qq_63053996的博客
04-30 142
主题，透明activity
android开发教程及笔记-完整版.pdf
07-25
《Android开发教程及笔记-完整版.pdf》是一本关于Android开发的教程和笔记的完整版电子书。这本电子书主要介绍了Android开发所需的各种知识和技术，对于想要学习Android开发的人来说是一本非常有价值的资料。 这本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值