/// <summary>
        /// �ж�ָ����С�����������Ƿ��ཻ
        /// </summary>
        ///
        /// <param name="rectA"></param>
        /// <param name="dataA"></param>
        /// <param name="rectB"></param>
        /// <param name="dataB"></param>
        /// <returns></returns>
        public static bool Intersect(RectBox rectA, int[] dataA, RectBox rectB,
                int[] dataB)
        {
            int top = (int)Loon.Utils.MathUtils.Max(rectA.GetY(), rectB.GetY());
            int bottom = (int)Loon.Utils.MathUtils.Min(rectA.GetBottom(), rectB.GetBottom());
            int left = (int)Loon.Utils.MathUtils.Max(rectA.GetX(), rectB.GetX());
            int right = (int)Loon.Utils.MathUtils.Min(rectA.GetRight(), rectB.GetRight());

            for (int y = top; y < bottom; y++)
            {
                for (int x = left; x < right; x++)
                {

                    int colorA = dataA[(int)((x - rectA.x) + (y - rectA.y)
                            * rectA.width)];
                    int colorB = dataB[(int)((x - rectB.x) + (y - rectB.y)
                            * rectB.width)];
                    if ((int)(((uint)colorA) >> 24) != 0 && (int)(((uint)colorB) >> 24) != 0)
                    {
                        return true;
                    }
                }
            }

            return false;
        }

 public LObjectCamera(RectBox r, object f, int width, int height,
         int horBorderPixel_0, int vertBorderPixel_1, Vector2f maxSpeed_2)
 {
     this.cameraX = 0;
     this.cameraY = 0;
     this.renderWidth = width;
     this.renderHeight = height;
     this.follow = new Bind(f);
     this.horBorderPixel = horBorderPixel_0;
     this.vertBorderPixel = vertBorderPixel_1;
     this.maxSpeed = maxSpeed_2;
     if (follow != null)
     {
         this.cameraX = follow.GetX() - (this.renderWidth / 2);
         this.cameraY = follow.GetY() - (this.renderHeight / 2);
     }
     this.cameraRect = r;
     this.visibleRect = new RectBox(cameraX - horBorderPixel_0, cameraY
             - vertBorderPixel_1, renderWidth + horBorderPixel_0, renderHeight
             + vertBorderPixel_1);
     this.moveRect = new RectBox(cameraX - horBorderPixel_0, cameraY
             - vertBorderPixel_1, renderWidth + horBorderPixel_0, renderHeight
             + vertBorderPixel_1);
     this.UpdateCamera();
 }

        public EmulatorButton(LTexture img, int w, int h, int x, int y,
                bool flag, int sizew, int sizeh)
        {
            this.color = new LColor(LColor.gray.R, LColor.gray.G,
                            LColor.gray.B, 125);
            img.LoadTexture();
            if (flag)
               {
                this.bitmap = img.GetSubTexture(x, y, w, h);
            }
            else
            {
                this.bitmap = img;
            }
            if (bitmap.GetWidth() != sizew || bitmap.GetHeight() != sizeh)
            {

                LTexture tmp = bitmap;
                this.bitmap = bitmap.Scale(sizew, sizeh);

                if (tmp != null)
                {
                    tmp.Dispose();
                    tmp = null;
                }
            }
            this.bounds = new RectBox(0, 0, bitmap.GetWidth(), bitmap.GetHeight());
        }

		public static LNFollow Action(LNNode followedNode, RectBox rect) {
			LNFollow follow = new LNFollow();
			follow._followedNode = followedNode;
			follow._boundarySet = true;
			follow._boundaryFullyCovered = false;
	
			follow.winRect = LSystem.screenRect;
			follow.fullScreenSize = new Vector2f(follow.winRect.width,
					follow.winRect.height);
            follow.halfScreenSize = follow.fullScreenSize.Mul(0.5f);
	
			follow.leftBoundary = -((rect.x + rect.width) - follow.fullScreenSize.x);
			follow.rightBoundary = -rect.x;
			follow.topBoundary = -rect.y;
			follow.bottomBoundary = -((rect.y + rect.height) - follow.fullScreenSize.y);
	
			if (follow.rightBoundary < follow.leftBoundary) {
				follow.rightBoundary = follow.leftBoundary = (follow.leftBoundary + follow.rightBoundary) / 2;
			}
	
			if (follow.topBoundary < follow.bottomBoundary) {
				follow.topBoundary = follow.bottomBoundary = (follow.topBoundary + follow.bottomBoundary) / 2;
			}
			if ((follow.topBoundary == follow.bottomBoundary)
					&& (follow.leftBoundary == follow.rightBoundary)) {
				follow._boundaryFullyCovered = true;
			}
			return follow;
		}

		private bool Intersects(RectBox other) {
			RectBox box = other;
			Circle circle = this;
	
			if (box.Contains(x + radius, y + radius)) {
				return true;
			}
	
			float x1 = box.GetX();
			float y1 = box.GetY();
			float x2 = box.GetX() + box.GetWidth();
			float y2 = box.GetY() + box.GetHeight();
	
			Line[] lines = new Line[4];
			lines[0] = new Line(x1, y1, x2, y1);
			lines[1] = new Line(x2, y1, x2, y2);
			lines[2] = new Line(x2, y2, x1, y2);
			lines[3] = new Line(x1, y2, x1, y1);
	
			float r2 = circle.GetRadius() * circle.GetRadius();
	
			Vector2f pos = new Vector2f(circle.GetCenterX(), circle.GetCenterY());
	
			for (int i = 0; i < 4; i++) {
				float dis = lines[i].DistanceSquared(pos);
				if (dis < r2) {
					return true;
				}
			}
	
			return false;
		}

 /// <summary>
 /// 判断两个圆形是否发生了碰撞
 /// </summary>
 ///
 /// <param name="rect1"></param>
 /// <param name="rect2"></param>
 /// <returns></returns>
 public static bool IsCircToCirc(RectBox rect1, RectBox rect2)
 {
     Point middle1 = GetMiddlePoint(rect1);
     Point middle2 = GetMiddlePoint(rect2);
     float distance = middle1.DistanceTo(middle2);
     float radius1 = rect1.GetWidth() / 2;
     float radius2 = rect2.GetWidth() / 2;
     return (distance - radius2) < radius1;
 }

 public OutEffect(LTexture t, RectBox limit, int code)
 {
     this.texture = t;
     this.type = code;
     this.width = t.Width;
     this.height = t.Height;
     this.multiples = 1;
     this.limit = limit;
     this.visible = true;
 }

		public EmulatorButton(LTextureRegion img, int w, int h, int x, int y,
				bool flag, int sizew, int sizeh) {
			if (flag) {
				this.bitmap = new LTextureRegion(img, x, y, w, h);
			} else {
				this.bitmap = new LTextureRegion(img);
			}
			this.scaleWidth = sizew;
			this.scaleHeight = sizeh;
			this.bounds = new RectBox(0, 0, scaleWidth, scaleHeight);
		}

        public bool CheckCollision(Actor actor)
        {

            obj0 = actor.GetRectBox();

            dx = MathUtils.Abs(obj0.GetCenterX() - x);
            dy = MathUtils.Abs(obj0.GetCenterY() - y);

            dist =  MathUtils.Sqrt(dx * dx + dy * dy);

            return dist <= this.r;
        }

        public static bool Contains(int[] xPoints, int[] yPoints,
                int nPoints,RectBox bounds, int x1, int y1)
        {
            if ((bounds != null && bounds.Inside(x1, y1))
                    || (bounds == null && GetBoundingBox(xPoints, yPoints, nPoints)
                            .Inside(x1, y1)))
            {
                int hits = 0;
                int ySave = 0;
                int i = 0;

                while (i < nPoints && yPoints[i] == y1)
                {
                    i++;
                }
                for (int n = 0; n < nPoints; n++)
                {
                    int j = (i + 1) % nPoints;

                    int dx = xPoints[j] - xPoints[i];
                    int dy = yPoints[j] - yPoints[i];

                    if (dy != 0)
                    {

                        int rx = x1 - xPoints[i];
                        int ry = y1 - yPoints[i];

                        if (yPoints[j] == y1 && xPoints[j] >= x1)
                        {
                            ySave = yPoints[i];
                        }
                        if (yPoints[i] == y1 && xPoints[i] >= x1)
                        {
                            if ((ySave > y1) != (yPoints[j] > y1))
                            {
                                hits--;
                            }
                        }
                        if (ry * dy >= 0
                                && (ry <= dy && ry >= 0 || ry >= dy && ry <= 0)
                                && Round(dx * ry, dy) >= rx)
                        {
                            hits++;
                        }
                    }
                    i = j;
                }
                return (hits % 2) != 0;
            }

            return false;
        }

 public static RectBox GetBounds(float x, float y, float width,
         float height, float rotate, RectBox result)
 {
     int[] rect = GetLimit(x, y, width, height, rotate);
     if (result == null)
     {
         result = new RectBox(rect[0], rect[1], rect[2], rect[3]);
     }
     else
     {
         result.SetBounds(rect[0], rect[1], rect[2], rect[3]);
     }
     return result;
 }

		public SpriteBatchObject(float x, float y, float dw, float dh,
				Animation animation, TileMap map) {
			this.SetLocation(x, y);
			this.tiles = map;
			this.animation = animation;
			this.dstWidth = dw;
			this.dstHeight = dh;
            Loon.Core.Graphics.Opengl.LTexture texture = animation.GetSpriteImage();
			if (dw < 1 && dh < 1) {
                this.rectBox = new RectBox(x, y, texture
                        .GetWidth(), texture.GetHeight());
			} else {
				this.rectBox = new RectBox(x, y, dw, dh);
			}
		}

        public SpriteBatchObject(float x, float y, float dw, float dh,
				Animation animation, TileMap map)
        {
            this.SetLocation(x, y);
            this.tiles = map;
            this.animation = animation;
            this.dstWidth = dw;
            this.dstHeight = dh;
            if (dw < 1 && dh < 1) {
                this.rectBox = new RectBox(x, y, animation.GetSpriteImage()
                        .GetWidth(), animation.GetSpriteImage().GetHeight());
            } else {
                this.rectBox = new RectBox(x, y, dw, dh);
            }
        }

 public static RectBox GetIntersection(RectBox a, RectBox b)
 {
     float a_x = a.GetX();
     float a_r = a.GetRight();
     float a_y = a.GetY();
     float a_t = a.GetBottom();
     float b_x = b.GetX();
     float b_r = b.GetRight();
     float b_y = b.GetY();
     float b_t = b.GetBottom();
     float i_x = MathUtils.Max(a_x, b_x);
     float i_r = MathUtils.Min(a_r, b_r);
     float i_y = MathUtils.Max(a_y, b_y);
     float i_t = MathUtils.Min(a_t, b_t);
     return (i_x < i_r && i_y < i_t) ? new RectBox(i_x, i_y, i_r - i_x, i_t
             - i_y) : null;
 }

 public SplitEffect(LTexture t, RectBox limit_0, int d)
 {
     this.texture = t;
     this.width = texture.GetWidth();
     this.height = texture.GetHeight();
     this.halfWidth = width / 2;
     this.halfHeight = height / 2;
     this.multiples = 2;
     this.direction = d;
     this.limit = limit_0;
     this.timer = new LTimer(10);
     this.visible = true;
     this.v1 = new Vector2f();
     this.v2 = new Vector2f();
     switch (direction)
     {
         case Config.UP:
         case Config.DOWN:
             special = true;
             {
                 v1.Set(0, 0);
                 v2.Set(halfWidth, 0);
                 break;
             }
         case Config.TLEFT:
         case Config.TRIGHT:
             v1.Set(0, 0);
             v2.Set(halfWidth, 0);
             break;
         case Config.LEFT:
         case Config.RIGHT:
             special = true;
             {
                 v1.Set(0, 0);
                 v2.Set(0, halfHeight);
                 break;
             }
         case Config.TUP:
         case Config.TDOWN:
             v1.Set(0, 0);
             v2.Set(0, halfHeight);
             break;
     }
 }

 /// <summary>
 /// 检查矩形与圆形是否发生了碰撞
 /// </summary>
 ///
 /// <param name="rect1"></param>
 /// <param name="rect2"></param>
 /// <returns></returns>
 public static bool IsRectToCirc(RectBox rect1, RectBox rect2)
 {
     float radius = rect2.GetWidth() / 2;
     Point middle = GetMiddlePoint(rect2);
     Point upperLeft = new Point(rect1.GetMinX(), rect1.GetMinY());
     Point upperRight = new Point(rect1.GetMaxX(), rect1.GetMinY());
     Point downLeft = new Point(rect1.GetMinX(), rect1.GetMaxY());
     Point downRight = new Point(rect1.GetMaxX(), rect1.GetMaxY());
     bool collided = true;
     if (!IsPointToLine(upperLeft, upperRight, middle, radius))
     {
         if (!IsPointToLine(upperRight, downRight, middle, radius))
         {
             if (!IsPointToLine(upperLeft, downLeft, middle, radius))
             {
                 if (!IsPointToLine(downLeft, downRight, middle, radius))
                 {
                     collided = false;
                 }
             }
         }
     }
     return collided;
 }

 public void Draw(LTexture texture, Vector2f pos, RectBox src,
         bool flipX, bool flipY)
 {
     Draw(texture, pos.x, pos.y, src.width / 2, src.height / 2, src.width,
             src.height, 1f, 1f, 0, src.x, src.y, src.width, src.height,
             flipX, flipY, false);
 }

 public Actor GetOnlyIntersectingUp(RectBox r,
         CollisionQuery query, Actor actor, BSPCollisionNode start)
 {
     for (; start != null && !start.GetArea().Contains(r); )
     {
         Actor res = this.CheckForOnlyCollision(actor, start, query);
         if (res != null)
         {
             return res;
         }
         start = start.GetParent();
     }
     return null;
 }

        private Actor GetOnlyIntersectingDown(RectBox r,
                CollisionQuery query, Actor actor)
        {
            if (this.bspTree == null)
            {
                return null;
            }
            else
            {
                lock (cacheNodeStack)
                {
                    cacheNodeStack.Clear();
                    CollectionUtils.Add(cacheNodeStack, this.bspTree);
                    int idx = 0;
                    for (; !(cacheNodeStack.Count == 0) && idx < MAX_SIZE; )
                    {
                        BSPCollisionNode node = (BSPCollisionNode)cacheNodeStack
                                .RemoveLast();
                        if (node.GetArea().Contains(r))
                        {
                            Actor res = this.CheckForOnlyCollision(actor, node,
                                    query);
                            if (res != null)
                            {
                                return res;
                            }

                            BSPCollisionNode left = node.GetLeft();
                            BSPCollisionNode right = node.GetRight();
                            if (left != null)
                            {
                                CollectionUtils.Add(cacheNodeStack, left);
                            }
                            if (right != null)
                            {
                                CollectionUtils.Add(cacheNodeStack, right);
                            }
                        }
                    }
                }
                return null;
            }
        }

 private Actor GetOnlyObjectDownTree(Actor ignore, RectBox r,
         CollisionQuery query, BSPCollisionNode startNode)
 {
     if (startNode == null)
     {
         return null;
     }
     else
     {
         lock (cacheNodeStack)
         {
             cacheNodeStack.Clear();
             if (startNode != null)
             {
                 CollectionUtils.Add(cacheNodeStack, startNode);
             }
             while (!(cacheNodeStack.Count == 0))
             {
                 BSPCollisionNode node = (BSPCollisionNode)cacheNodeStack
                         .RemoveLast();
                 if (node.GetArea().Intersects(r))
                 {
                     Actor res = this.CheckForOnlyCollision(ignore, node,
                             query);
                     if (res != null)
                     {
                         return res;
                     }
                     BSPCollisionNode left = node.GetLeft();
                     BSPCollisionNode right = node.GetRight();
                     if (left != null)
                     {
                         CollectionUtils.Add(cacheNodeStack, left);
                     }
                     if (right != null)
                     {
                         CollectionUtils.Add(cacheNodeStack, right);
                     }
                 }
             }
         }
         return null;
     }
 }