flash as3实现不规则碰撞程序类

时间：2022-06-28 22:12:49 编辑：袖梨来源：一聚教程网

Flwordlink_affiliate">ash自带有规则碰撞的函数，当两个元件发生碰撞时，可以使用hitTestObject 或 hitTestPoint 进行检测。

但是这两个函数有个缺陷，就是只能检测规则的碰撞，对于碰撞检测要求不高，或者元件本身就是方方正正的话，直接调用这个自带的API是可以实现的，非常方便。

如下图：实际元件内容本身没有接触，但元件间已经接触了。

如果需要对不规则的元件进行像素级检测，可以使用位图像素碰撞BitmapData.hitTest（）这个是高精度像素碰撞不过效率要差一点点。网上也有好多类似的例子、代码，感觉都不够好用，主要是不能直接拿来就用，还要做些修改，比较麻烦。

现在提供一个网上找的类，原版是老外写的，运行的时候报错，后来经过修改后，已经可以正常使用了

代码如下

复制代码

package code
{
    //像素级精确碰撞算法优化
    //代码：Aone
    import flash.display.BitmapData;
    import flash.display.BlendMode;
    import flash.display.DisplayObject;
    import flash.geom.ColorTransform;
    import flash.geom.Matrix;
    import flash.geom.Point;
    import flash.geom.Rectangle;
    public class HitTest
    {
        public static var tileSize:int = 20;
        public static function complexHitTestObject(target1:DisplayObject, target2:DisplayObject):Boolean
        {
            //横向缩小到tileSize尺寸需要的倍数，也就是期望检测的时候缩小到的尺寸。
            var scaleX:Number = (target1.width < target2.width ? target1.width : target2.width) / tileSize
            //纵向缩小到tileSize尺寸需要的倍
            var scaleY:Number = (target1.height < target2.height ? target1.height : target2.height) / tileSize
            //
            //如果倍数小于1则按原始倍率也就是原始尺寸
            scaleX = scaleX < 1 ? 1 : scaleX
            scaleY = scaleY < 1 ? 1 : scaleY
            //draw用point
            var pt:Point=new Point()
            //做2次draw时使用的颜色
            var ct:ColorTransform=new ColorTransform()
            ct.color=0xFF00000F
            //原始尺寸下的重叠矩形
            var oldHitRectangle:Rectangle=intersectionRectangle(target1, target2)
            //用于存放缩放的重叠矩形
            var hitRectangle:Rectangle= new Rectangle()
            return complexIntersectionRectangle(target1, target2 , scaleX , scaleY , pt , ct , oldHitRectangle,hitRectangle,tileSize,tileSize).width != 0;
        }
        public static function intersectionRectangle(target1:DisplayObject, target2:DisplayObject):Rectangle
        {
            // If either of the items don't have a reference to stage, then they are not in a display list
            // or if a simple hitTestObject is false, they cannot be intersecting.
            if (!target1.root || !target2.root || !target1.hitTestObject(target2))
                return new Rectangle();
            // Get the bounds of each DisplayObject.
            var bounds1:Rectangle = target1.getBounds(target1.root);
            var bounds2:Rectangle= target2.getBounds(target2.root);
            return bounds1.intersection(bounds2);
//          // Determine test area boundaries.
//          var intersection:Rectangle = new Rectangle();
//          intersection.x = Math.max(bounds1.x, bounds2.x);
//          intersection.y = Math.max(bounds1.y, bounds2.y);
//          intersection.width = Math.min((bounds1.x + bounds1.width) - intersection.x, (bounds2.x + bounds2.width) - intersection.x);
//          intersection.height = Math.min((bounds1.y + bounds1.height) - intersection.y, (bounds2.y + bounds2.height) - intersection.y);
//          return intersection;
        }
        private static function complexIntersectionRectangle(target1:DisplayObject, target2:DisplayObject, scaleX:Number , scaleY:Number , pt:Point , ct:ColorTransform ,oldhitRectangle:Rectangle,hitRectangle:Rectangle,nowW:int,nowH:int):Rectangle
        {
            if (!target1.hitTestObject(target2))
                return new Rectangle();
            //根据纵横的缩小倍数来计算缩小的重叠矩形尺寸
            hitRectangle.x = oldhitRectangle.x
            hitRectangle.y = oldhitRectangle.y
            hitRectangle.width = oldhitRectangle.width / scaleX
            hitRectangle.height = oldhitRectangle.height / scaleY
            //建立一个用来draw的临时BitmapData对象，尺寸为期望宽nowW,期望高nowH
            var bitmapData:BitmapData=new BitmapData(nowW,nowH, true, 0);
            //绘制对象1其缩放比例和位移量由getDrawMatrix（）函数计算，并且把不透明处绘制为ct的颜色
            bitmapData.draw(target1, getDrawMatrix(target1, hitRectangle , scaleX , scaleY ),ct);
            //当纵横缩小比例不为1的时候把任何有色像素重新替换成ct的颜色0xFF00000F，原因为缩小的对象在进行纯色绘制的时候会有半透明像素产生，如果不加以重新替换会影响后面对象2的滤镜效果。
            if(scaleX!=1&&scaleY!=1)
                bitmapData.threshold(bitmapData,bitmapData.rect,pt,">",0,0xFF00000F)
            //绘制对象2其缩放比例和位移量由getDrawMatrix（）函数计算，并且把不透明处绘制为ct的颜色，并且模式为叠加。如此一来两个对象重叠的部分颜色值必定大于0xFF00000F。
            bitmapData.draw(target2, getDrawMatrix(target2, hitRectangle , scaleX , scaleY ),ct, BlendMode.ADD);
            //把所有颜色值大于0xFF00000F的部分（也就是重叠部分）重新替换为不透明红色方便后面getColorBoundsRect()方法计算尺寸。这里替换的原因是getColorBoundsRect()不支持范围取色而只支持单色计算。
            //对象1缩放后可以重新替换掉透明色，但是对象2则无法使用同一方法，但是对象2由于也是经过缩放绘制也会有半透明像素，那么重叠部分虽然全部大于0xFF00000F，但未必是统一的。
            var hits:int=bitmapData.threshold(bitmapData,bitmapData.rect,pt,">",0xFF00000F,0xFFFF0000)
            //判断红色区域尺寸
            var intersection:Rectangle=bitmapData.getColorBoundsRect(0xFFFFFFFF, 0xFFFF0000);
            bitmapData.dispose();
            //如果红色区域宽度不为0，即bitmapData中含有红色像素。此时说明对象1和对象2在此次判定中有重叠有碰撞
            //如果纵横缩放比例有任意一个不是原始尺寸
            //并且红色像素的数量比较少，对象1和对象2的碰撞面积比较小的话
            if (intersection.width != 0 && (scaleX > 1 || scaleY > 1) && hits <= (scaleX+scaleY) * 1.5)
            {
                //由于bitmapData的宽高坐标都是以整数表示，那么经过缩放后取整的区域势必回又可能在取整的时候把真正可能产生碰撞的区域忽略。
                //所以要进行下一次检测时候适当的把检测区域扩大xadd和yadd就是这个扩大的系数
                var xadd:int = 0.5;
                var yadd:int = 0.5;
                //下次检测时候bitmapData的期望大小
                //如果此次判定发现碰撞区域和bitmapData尺寸相同，那么在计算下次需要判断区域时候会和此次的区域相同，那么判断结果可能会和此次结果相同。这样则会引起堆栈上溢的情况，为了避免该情况发生，将缩小判断的尺寸扩大一倍进行再次检测。
                var nextW:int = (intersection.width != nowW) ? tileSize : nowW * 2;
                var nextH:int = (intersection.height != nowH) ? tileSize : nowH * 2;
                //根据检测出来的缩的碰撞区域来计算未缩小的碰撞区域大小以方便下一次计算的时候缩小检测范围。
                oldhitRectangle.x += (intersection.x - xadd) * scaleX;
                oldhitRectangle.y += (intersection.y - yadd) * scaleY;
                oldhitRectangle.width = (intersection.width + xadd*2) * scaleX;
                oldhitRectangle.height = (intersection.height + yadd*2) * scaleY;
                //根据检测期望缩小到的尺寸重新计算缩小倍率
                scaleX = (oldhitRectangle.width / nextW)
                scaleY = (oldhitRectangle.height / nextH)
                //如果倍率小于2则直接按原始尺寸
                scaleX = scaleX < 2 ? 1 : scaleX
                scaleY = scaleY < 2 ? 1 : scaleY
                //进行下一次判定
                intersection = complexIntersectionRectangle(target1,target2, scaleX , scaleY ,pt,ct,oldhitRectangle,hitRectangle,nextW,nextH)
            }
            return intersection;
        }
        protected static function getDrawMatrix(target:DisplayObject, hitRectangle:Rectangle , scaleX:Number , scaleY:Number ):Matrix
        {
            var localToGlobal:Point;
            var matrix:Matrix;
            var rootConcatenatedMatrix:Matrix=target.root.transform.concatenatedMatrix;
            localToGlobal=target.localToGlobal(new Point());
            matrix=target.transform.concatenatedMatrix;
            matrix.tx=(localToGlobal.x - hitRectangle.x) / scaleX;
            matrix.ty=(localToGlobal.y - hitRectangle.y) / scaleY;
            matrix.a=matrix.a / rootConcatenatedMatrix.a / scaleX ;
            matrix.d=matrix.d / rootConcatenatedMatrix.d / scaleY;
            return matrix;
        }
    }
}

使用方法也很简单：

代码如下	复制代码
HitTest.complexHitTestObject(元件1,元件2);

推荐专题

最新下载

热门教程

flash as3实现不规则碰撞程序类

相关文章

热门栏目

php教程

asp.net教程

手机开发

css教程

网页制作

办公数码

jsp教程