检测碰撞工具类(两个类各有特点 可以结合使用)

 

package 
{
	import flash.display.BitmapData;
	import flash.display.BlendMode;
	import flash.display.DisplayObject;
	import flash.display.Sprite;
	import flash.geom.ColorTransform;
	import flash.geom.Matrix;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	
	public class HitTest
	{
		//========复杂（精确）碰撞测试
		public static function complexHitTestObject( target1:DisplayObject, target2:DisplayObject,  accurracy:Number = 1 ):Boolean
		{
			return complexIntersectionRectangle(target1,target2,accurracy).width != 0;
		}
		//========返回两目标对象重叠的区域矩形
		public static function intersectionRectangle( target1:DisplayObject, target2:DisplayObject ):Rectangle
		{
			//如果目标对象不存在，或者简单碰撞测试为否，那么就不可能重叠
			if (! target1.root || ! target2.root || ! target1.hitTestObject(target2))
			{
				return new Rectangle;
			}
			//获取目标的边界信息Bounds
			var bounds1:Rectangle = target1.getBounds(target1.root);
			var bounds2:Rectangle = target2.getBounds(target2.root);
			// 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;
		}
		//========返回复杂重叠的区域矩形
		public static function complexIntersectionRectangle( target1:DisplayObject, target2:DisplayObject, accurracy:Number = 1 ):Rectangle
		{
			if (accurracy <= 0)
			{
				throw new Error("ArgumentError: Error #5001: Invalid value for accurracy",5001);
			}
			//如果简单碰撞为否，那么他们没有重叠
			if (! target1.hitTestObject(target2))
			{
				return new Rectangle;
			}

			var hitRectangle:Rectangle = intersectionRectangle(target1,target2);

			if (hitRectangle.width * accurracy < 1 || hitRectangle.height * accurracy < 1)
			{
				return new Rectangle;
			}

			var bitmapData:BitmapData = new BitmapData(hitRectangle.width * accurracy,hitRectangle.height * accurracy,false,0x000000);

			//绘制第一个目标
			bitmapData.draw( target1, HitTest.getDrawMatrix( target1, hitRectangle, accurracy ), new ColorTransform( 1, 1, 1, 1, 255, -255, -255, 255 ) );
			//绘制第二个目标
			bitmapData.draw( target2, HitTest.getDrawMatrix( target2, hitRectangle, accurracy ), new ColorTransform( 1, 1, 1, 1, 255, 255, 255, 255 ), BlendMode.DIFFERENCE );


			//确定位图图像中完全包含指定颜色的所有像素的矩形区域,以找到重叠区域
			var intersection:Rectangle = bitmapData.getColorBoundsRect(0xFFFFFFFF,0xFF00FFFF);

			bitmapData.dispose();
			//释放bitmapData对象的内存，返回width,height为-1;
			if (accurracy != 1)
			{
				intersection.x /=  accurracy;
				intersection.y /=  accurracy;
				intersection.width /=  accurracy;
				intersection.height /=  accurracy;
			}
			intersection.x +=  hitRectangle.x;
			intersection.y +=  hitRectangle.y;
			
			return intersection;
		}

		protected static function getDrawMatrix( target:DisplayObject, hitRectangle:Rectangle, accurracy:Number ):Matrix
		{//返回一个转换矩阵
			//accurracy精确度
			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;
			matrix.ty = localToGlobal.y - hitRectangle.y;

			matrix.a = matrix.a / rootConcatenatedMatrix.a;
			matrix.d = matrix.d / rootConcatenatedMatrix.d;
			if (accurracy != 1)
			{
				matrix.scale( accurracy, accurracy );
			}
			return matrix;
		}

	}

}

package 
{
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.display.BitmapData;
	import flash.display.Bitmap;
	import flash.events.MouseEvent;
	import flash.geom.*;
	import flash.filters.GlowFilter;

	public class HitTest extends MovieClip
	{
		public function HitTest()
		{
			
		}
		
		public function hitTestShape(mc1:Sprite,mc2:Sprite):Boolean
		{
			var rect1:Rectangle = mc1.getBounds(this);//这里要用rect的宽度才合适了
			//trace(this);
			var bmd1:BitmapData = new BitmapData(rect1.width,rect1.height,true,0);//返回的矩阵也是变化的
			var matrix1:Matrix = mc1.transform.matrix;
			matrix1.tx = mc1.x - rect1.x;
			matrix1.ty = mc1.y - rect1.y;
			bmd1.draw(mc1);
			var bit1:Bitmap = new Bitmap(bmd1);
			var rect2:Rectangle = mc2.getBounds(this);
			var bmd2:BitmapData = new BitmapData(rect2.width,rect2.height,true,0);
			var matrix2:Matrix = mc2.transform.matrix;
			matrix2.tx = mc2.x - rect2.x;
			matrix2.ty = mc2.y - rect2.y;
			bmd2.draw(mc2,matrix2);
			var bit2:Bitmap = new Bitmap(bmd2);
			if (bmd1.hitTest(new Point(rect1.x,rect1.y),10,bmd2,new Point(rect2.x,rect2.y),10))//可以改变透明度达到不同的检测效果
			{
				trace("碰撞了");
				mc2.filters = [new GlowFilter  ];
				return true;
			}
			else
			{
				mc2.filters = [];
			}
			return false;
		}

	}
}

package 
{
	import flash.display.*;
	import flash.geom.*;
	public class HitTest
	{
		//按照像素级别来检测碰撞
		private static function _hitTest(shape1:DisplayObject,shape2:DisplayObject):Boolean
		{
			//取得shape1和shape2的坐标
			var p1x:Number = shape1.getRect(shape1).x;
			var p1y:Number = shape1.getRect(shape1).y;
			var p2x:Number = shape2.getRect(shape2).x;
			var p2y:Number = shape2.getRect(shape2).y;
			//取得shape1和shape2的大小
			var p1w:Number = shape1.width;
			var p1h:Number = shape1.height;
			var p2w:Number = shape2.width;
			var p2h:Number = shape2.height;
			//当长宽小于1时取1
			p1w < 1 ? 1:p1w;
			p1h < 1 ? 1:p1h;
			p2w < 1 ? 1:p2w;
			p2h < 1 ? 1:p2h;
			//根据shape1和shape2的大小新建两个透明的BitmapData对象
			//Matrix(a,b,c,d,tx,ty);
			//tx:Number (default = 0) — 沿 x 轴向右平移（移动）的像素数。    
			//ty:Number (default = 0) — 沿 y 轴向下平移（移动）的像素数。 
			var BmpData1:BitmapData = new BitmapData(p1w,p1h,true,0x00000000);
			var BmpData2:BitmapData = new BitmapData(p2w,p2h,true,0x00000000);
			BmpData1.draw(shape1,new Matrix(1,0,0,1, -  p1x, -  p1y));
			BmpData2.draw(shape2,new Matrix(1,0,0,1, -  p2x, -  p2y));
			//取得shape1和shape2相对于舞台的坐标;
			//localToGlobal(point:Point):Point 将 point 对象从显示对象的（本地）坐标转换为舞台（全局）坐标。
			var gp1:Point = shape1.localToGlobal(new Point(p1x,p1y));
			var gp2:Point = shape2.localToGlobal(new Point(p2x,p2y));
			//使用BitmapData类的hitTest方法进行碰撞检测(可以根据情况设置透明度0X05)
			var re:Boolean = BmpData1.hitTest(gp1,0x05,BmpData2,gp2,0x05);
			//dispose():void 释放用来存储 BitmapData 对象的内存。
			BmpData1.dispose();
			BmpData2.dispose();
			return re;
		}
		//按照矩形区域检测碰撞
		public static function hitTestRect(shape1:DisplayObject,shape2:DisplayObject):Boolean
		{
			if (shape1.hitTestObject(shape2))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		//按照点和形状来检测碰撞
		public static function hiTestPoint(point:Point,shape:DisplayObject):Boolean
		{
			if (shape.hitTestPoint(point.x,point.y,true))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		//按形状检测
		public static function hitTestShape(shape1:DisplayObject,shape2:DisplayObject):Boolean
		{
			var hit:Boolean = false;

			if (shape1.hitTestObject(shape2))
			{
				//先用hitTestObject检测是否碰撞如果被检测的物体大小小于20那么用hitTestObject来检测直接返回true否则用像素级别检测
				if (shape2.width < 20 && shape2.height < 20)
				{
					hit = true;
				}
				else
				{
					if (HitTest._hitTest(shape1,shape2))
					{
						hit = true;
					}
				}
			}
			return hit;
		}

	}
}
/*先注意是BitmapData对象的方法hitTest()，精确到像素碰撞，
常用于判断比较大的不规则的对象碰撞，它有5个参数(前3个参数必须，后2个参数可选)依次如下(括号中是参数的类型)：
firstPoint(Point)：BitmapData对象的左上点的位置坐标
firstAlpha(uint)：BitmapData对象中视为不透明的最高alpha通道值
secondObject(Object)：碰撞的区域，可以是BitmapData对象、RectAngle对象、Point对象等。
secondBitmapDataPoint(Point)：只有当secondObject参数为BitmapData对象时，才能使用该参数，表示第二个BitmapData对象的坐上点位置坐标
secondAlpha(uint)：只有当secondObject参数为BitmapData对象，才能使用该参数，表示第二个BitmapData对象中视为不透明的最高alpha通道值

该碰撞没有hitTestObject()效率高，所以当对象很小时，比如宽高小于20像素，即使他不规则，采用hitTestObject()更好
*/