/// <summary>
        ///     Generates an OctTree used to improve collision processing.
        /// </summary>
        /// <returns>Newly generated OctTree.</returns>
        private static ArrayList[,] GenerateOctTree()
        {
            // Work out a full-size bounding box that encloses all polygons.
            float minX = 0, minY = 0, maxX = 0, maxY = 0;
            foreach (CollisionPolygon prePolygon in _polygonList)
            {
                if (prePolygon.Transformation.X < minX) minX = prePolygon.Transformation.X;
                if (prePolygon.Transformation.Y < minY) minY = prePolygon.Transformation.Y;
                if (prePolygon.Transformation.X + prePolygon.BoundingWidth > maxX) maxX = prePolygon.Transformation.X + prePolygon.BoundingWidth;
                if (prePolygon.Transformation.Y + prePolygon.BoundingHeight > maxY) maxY = prePolygon.Transformation.Y + prePolygon.BoundingHeight;
            }

            int octTreeCellWidth = 128;
            int octTreeCellHeight = 128;
            int octTreeXCells = (int)Math.Ceiling((maxX - minX) / (float)octTreeCellWidth);
            int octTreeYCells = (int)Math.Ceiling((maxY - minY) / (float)octTreeCellHeight);

            if (_octTree == null || octTreeXCells != _octTreeXCells || octTreeYCells != _octTreeYCells)
            {
                // Generate an Oct-Tree.
                _octTreeXCells = octTreeXCells;
                _octTreeYCells = octTreeYCells;
                _octTree = new ArrayList[octTreeXCells, octTreeYCells];
                for (int x = 0; x < octTreeXCells; x++)
                    for (int y = 0; y < octTreeYCells; y++)
                        _octTree[x, y] = new ArrayList();

                // Generate collision rectangles.
                _octTreeCollisionRectangles = new CollisionRectangle[octTreeXCells, octTreeYCells];
                for (int x = 0; x < octTreeXCells; x++)
                    for (int y = 0; y < octTreeYCells; y++)
                        _octTreeCollisionRectangles[x, y] = new CollisionRectangle(new Transformation(minX + (x * octTreeCellWidth), minY + (y * octTreeCellHeight), 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f), octTreeCellWidth, octTreeCellHeight);

                // Place entities into Oct-Tree cells.
                for (int x = 0; x < octTreeXCells; x++)
                    for (int y = 0; y < octTreeYCells; y++)
                    {
                        foreach (CollisionPolygon prePolygon in _polygonList)
                        {
                            if (_octTreeCollisionRectangles[x, y].HitTest(prePolygon) == true)
                                _octTree[x, y].Add(prePolygon);
                        }
                    }
            }
            else
            {
                // Have any polygons moved? If so we need to update the cells they are in.
                foreach (CollisionPolygon polygon in _polygonList)
                {
                    if ((!((polygon.PreviousTransformationValid == false ||
                        ((polygon.Transformation.X - polygon.PreviousTransformation.X == 0) &&
                        (polygon.Transformation.Y - polygon.PreviousTransformation.Y == 0))) && polygon.FrameCount > 0)))// || polygon.BoundingChanged == true)
                    {
                        _octTreeRemovals.Add(polygon);
                        _octTreeAdditions.Add(polygon);
                    }
                }
            }

            // Remove superflous ones.
            if (_octTreeRemovals.Count != 0)
            {
                foreach (CollisionPolygon polygon in _octTreeRemovals)
                {
                    for (int x = 0; x < octTreeXCells; x++)
                        for (int y = 0; y < octTreeYCells; y++)
                            _octTree[x, y].Remove(polygon);
                }
                _octTreeRemovals.Clear();
            }

            // Add aditional ones.
            if (_octTreeAdditions.Count != 0)
            {
                foreach (CollisionPolygon polygon in _octTreeAdditions)
                {
                    for (int x = 0; x < octTreeXCells; x++)
                        for (int y = 0; y < octTreeYCells; y++)
                        {
                            if (_octTreeCollisionRectangles[x, y].HitTest(polygon) == true)
                            {
                                _octTree[x, y].Add(polygon);
                            }
                        }
                }
                _octTreeAdditions.Clear();
            }

            return _octTree;
        }
        /// <summary>
        ///     Attempts to respond to a collision by moving this rectangle out
        ///     of the given rectangle.
        /// </summary>
        /// <param name="rectangle">Rectangle that this rectangle is currently penetrating.</param>
        public void RespondToRectangleCollision(CollisionRectangle rectangle)
        {
            // Truncate the positions of the entitys as decimal places tend
            // to f**k up collision response.

            _transformation.X = (float)Math.Truncate(_transformation.X);
            _transformation.Y = (float)Math.Truncate(_transformation.Y);
            rectangle._transformation.X = (float)Math.Truncate(rectangle._transformation.X);
            rectangle._transformation.Y = (float)Math.Truncate(rectangle._transformation.Y);

            // Really crude form of SAT collision response.
            // Probably a good idea to clean this up a bit, possibly implement
            // vector projection as well, to remove the if blocks.

            float rectangleWidth = rectangle._width * Math.Abs(rectangle._transformation.ScaleX), rectangleHeight = rectangle._height * Math.Abs(rectangle._transformation.ScaleY);
            float rectangleCenterX = rectangle._transformation.X + (rectangleWidth / 2.0f), rectangleCenterY = rectangle._transformation.Y + (rectangleHeight / 2.0f);
            float thisWidth = _width * Math.Abs(_transformation.ScaleX), thisHeight = _height * Math.Abs(_transformation.ScaleY);
            float thisCenterX = _transformation.X + (thisWidth / 2.0f), thisCenterY = _transformation.Y + (thisHeight / 2.0f);
            float rectangleVertexX = 0, rectangleVertexY = 0;
            float thisVertexX = 0, thisVertexY = 0;

            if (thisCenterX > rectangleCenterX)
                if (thisCenterY > rectangleCenterY)
                {
                    // Were in the bottom-right corner of the rectangle.
                    rectangleVertexX = rectangle._transformation.X + rectangleWidth;
                    rectangleVertexY = rectangle._transformation.Y + rectangleHeight;
                    thisVertexX = _transformation.X;
                    thisVertexY = _transformation.Y;
                }
                else
                {
                    // Were in the top-right corner of the rectangle.
                    rectangleVertexX = rectangle._transformation.X + rectangleWidth;
                    rectangleVertexY = rectangle._transformation.Y;
                    thisVertexX = _transformation.X;
                    thisVertexY = _transformation.Y + thisHeight;
                }
            else
                if (thisCenterY > rectangleCenterY)
                {
                    // Were in the bottom-left corner of the rectangle.
                    rectangleVertexX = rectangle._transformation.X;
                    rectangleVertexY = rectangle._transformation.Y + rectangleHeight;
                    thisVertexX = _transformation.X + thisWidth;
                    thisVertexY = _transformation.Y;
                }
                else
                {
                    // Were in the top-left corner of the rectangle.
                    rectangleVertexX = rectangle._transformation.X;
                    rectangleVertexY = rectangle._transformation.Y;
                    thisVertexX = _transformation.X + thisWidth;
                    thisVertexY = _transformation.Y + thisHeight;
                }

            float xDifference = thisVertexX - rectangleVertexX;
            float yDifference = thisVertexY - rectangleVertexY;
            if (Math.Abs(xDifference) > Math.Abs(yDifference))
                _transformation.Y -= yDifference;
            else
                _transformation.X -= xDifference;
        }
        /// <summary>
        ///     Checks for and returns the polygon at the given point.
        /// </summary>
        /// <param name="x">Position on the x-axis.</param>
        /// <param name="y">Position on the y-axis.</param>
        /// <returns>Null if no polygon at given point, else true.</returns>
        public static CollisionPolygon PolygonAtPoint(int x, int y)
        {
            CollisionPolygon aPolygon = new CollisionRectangle(new Transformation(x, y, 0, 0, 0, 0, 1, 1, 1), 1, 1);

            foreach (CollisionPolygon polygon in _polygonList)
                if (aPolygon != polygon && polygon.HitTest(aPolygon) == true && polygon.Solid == true)
                    return polygon;

            return null;
        }
 public void EntityHitTestB(ScriptThread thread)
 {
     EntityNode entitya = ((NativeObject)thread.GetObjectParameter(0)).Object as EntityNode;
     if (entitya == null)
     {
         DebugLogger.WriteLog((thread.Process.Url != null && thread.Process.Url != "" ? thread.Process.Url : "A script") + " called EntityHitTest with an invalid object.", LogAlertLevel.Error);
         return;
     }
     CollisionRectangle rect = new CollisionRectangle(new Transformation(thread.GetIntegerParameter(1), thread.GetIntegerParameter(2), 0, 0, 0, 0, 1, 1, 1), thread.GetIntegerParameter(3), thread.GetIntegerParameter(4));
     rect.Layers = entitya.CollisionPolygon.Layers;
     thread.SetReturnValue(entitya.CollisionPolygon.HitTest(rect));
 }