J2ME游戏中的碰撞检测

我们在游戏开发中总会遇到这样那样的碰撞 , 并且会很频繁的去处理这些行为 . 这也是游戏开发的一种基本的算法 .2D 的相对 3D 的要简单的多了，最简单的就是矩形碰撞 \ 圆形碰撞 , 像素碰撞。矩形碰撞用的最多

我就简单总结一点我的认识，对于矩形碰撞 .

   我们就把游戏中的角色统称为一个一个的 Actor, 并且把每个   Actor 框成一个与角色大小相等的矩形框，那么在游戏中每次的循环检查就是围绕每个 Actor 的矩形框之间是否发生了交错。为了简单起见，我们就拿一个主角与一个 Actor 来分析，其它的可以类似。

        一个主角与一个 Actor 的碰撞其实就成了两个矩形的检测，是否发生了交集。

第一种方法：

我们可以通过检测一个矩形的 4 个顶点是否在另外一个矩形的内部来完成。代码如下：

我们简单的设定一个 Actor 类：

public   class   Actor {

     int   x , y , w , h ;

     public   int   getX() {

        return   x ;

     }

     public   int   getY() {

        return   y ;

     }  

     public   int   getActorWidth() {      

        return   w ;

     }

     public   int   getActorHeight() {     

        return   h ;

     }  

}

 

检测的处理为：

        public boolean isCollidingWith (int px ,int py){

               if(px > getX() && px < getX() + getActorWidth()

               &&   px > getY() && px < getY() + getActorHeight())

                      return true;

               return false;

        }

      

        public boolean isCollidingWith(Actor another) {

               if(isCollidingWith(another.getX(),another.getY())

               ||isCollidingWith(another.getX()+ another.getActorWidth(),another.getY())

               ||isCollidingWith(another.getX(),another.getY()+another.getActorHeight())

               ||isCollidingWith(another.getX()+ another.getActorWidth(),another.getY()+another.getActorHeight())

               )

               return true;

               return false;

        }

以上处理运行应该是没有什么问题的，但是没有考虑不到运行速度，而游戏中需要大量的碰撞检测工作，所以要求碰撞检测要尽量的快。

 

第二种方法：

我们从相反的角度考虑，以前是想什么时候相交，现在我们处理什么时候不会相交，可以处理 4 条边，

 

               a         b   

左边 a 矩形的右边界在 b 矩形的左边界以外，同理， a 的上边界需要在 b 的下边界以外，四边都判断，则可以知道 a 是否与 b 相交，代码：

     /**

      *   ax   a 矩形左上角 x 坐标

      *   ay -- a 矩形左上角 y 坐标

      *   aw   --   a 矩形宽度

      *   ah   --   a 矩形高度

      *

      *   bx   -- b 矩形左上角 x 坐标

      *   by   -- b 矩形左上角 y 坐标

      *   bw --   b 矩形宽度

      *   bh   --   b 矩形高度

      *        *

      */

     public   boolean   isColliding( int   ax, int   ay, int   aw, int   ah,

                             int   bx,  int   by,  int   bw,  int   bh){

        if (ay > by + bh || by > ay + ah

            || ax > bx + bw || bx > ax + aw)

        return   false ;

        return   true ;

     }

此方法比第一种简单且运行快。

 

 

 

第三种方法：

这种方法其实可以说是第二种的一个变异，我们可以保存两个矩形的左上和右下两个坐标的坐标值，然后对两个坐标的一个对比就可以得出两个矩形是否相交。这应该比第二种更优越一点。

/*

  * rect1[0]:  矩形 1 左上角 x 坐标

  * rect1[1]:  矩形 1 左上角 y 坐标

  * rect1[2]:  矩形 1 右下角 x 坐标

  * rect1[3]:  矩形 1 右上角 y 坐标

  *

  * rect2[0]:  矩形 2 左上角 x 坐标

  * rect2[1]:  矩形 2 左上角 y 坐标

  * rect2[2]:  矩形 2 右下角 x 坐标

  * rect2[3]:  矩形 2 右上角 y 坐标

  */

     static   boolean   IsRectCrossing ( int   rect1[],  int   rect2[])

     {

     if   (rect1[0] > rect2[2])  return   false ;

     if   (rect1[2] < rect2[0])  return   false ;

     if   (rect1[1] > rect2[3])  return   false ;

     if   (rect1[3] < rect2[1])  return   false ;

     return   true ;

     }

这种速度应该很快的了，推荐使用这种。

 

第四种方法：（类似于圆形与圆形）

现在介绍一种测试两个对象边界是否重叠。可以通过比较两个对象间的距离和两个对象半径的和的大小，很快实现这种检测。如果它们之间的距离小于半径的和，就说明产生了碰撞。

为了计算半径，就可以简单的取高度或者宽度的一半作为半径的值。

代码如下：

        public static boolean isColliding ( int ax,int ay,int aw, int ah,

                                                                       int bx, int by, int bw, int bh){

             

               int r1 = (Math.max(aw, ah)/2 + 1);

               int r2 = (Math.max(bw, bh)/2 + 1);            

               int rSquard = r1 * r1;

               int anrSquard = r2* r2;

               int disX = ax - bx;

               int disY = ay - by;

             

               if((disX * disX) + (disY * disY) < (rSquard + anrSquard))

               return true;

               else

               return false;

        }

这种方法类似于圆形碰撞检测。处理两个圆的碰撞处理就可以用这种。

 

以上只是总结了几种简单的方法，当然其实在游戏中熟练的运用才是最好的，在 J2ME 中差不多以上几种算够了，它不需要太精密的算法，当然可能有些需要比以上更复杂，例如如果一个对象速度足够快的，