Collisions Dump

        private void HandleCollisions()
        {
            // find neighboring tiles.
            int leftTile = Owner.GetArray(Bounds.Left);
            int rightTile = Owner.GetArray(Bounds.Right);
            int topTile = Owner.GetArray(Bounds.Top);
            int bottomTile = Owner.GetArray(Bounds.Bottom);

            // Reset flag to search for ground collision.
            OnGround = false;

            // For each potentially colliding tile,
            for (int y = topTile; y <= bottomTile; ++y)
            {
                for (int x = leftTile; x <= rightTile; ++x)
                {
                    TileCollision collision = Owner.GetCollision(x, y);

                    if (collision == TileCollision.Block || collision == TileCollision.Platform)
                    {
                        Rectangle tile = Owner.GetBounds(x, y);

                        if (previousBounds.Bottom <= tile.Top && Momentum.Y >= 0 && Bounds.Bottom > tile.Top
                            && Bounds.Left < tile.Right && Bounds.Right > tile.Left)
                        {
                            Land(tile.Top - boundingBox.Height / 2f);
                        }
                        else if (collision == TileCollision.Block)
                        {
                            if (Bounds.Bottom > tile.Top)
                            {
                                if (previousBounds.Right <= tile.Left)
                                    Position = new Vector2(tile.Left - boundingBox.Width / 2, Position.Y);
                                if (previousBounds.Left >= tile.Right)
                                    Position = new Vector2(tile.Right + boundingBox.Width / 2, Position.Y);
                            }
                            if (previousBounds.Top >= tile.Bottom && Momentum.Y <= 0
                                && (Bounds.Right > tile.Left && Bounds.Left < tile.Right))
                            {
                                Position = new Vector2(Position.X, tile.Bottom + boundingBox.Height / 2);
                                Momentum.Y = 0.0f;
                                JumpTime = 0;
                            }
                        }
                    }
                }
            }
        }

        public void Land(float Y)
        {
            OnGround = true;
            Momentum.Y = 0.0f;
            Position = new Vector2(Position.X, Y);
            JumpTime = 5;
        }


        private void HandleCollisions(Vector2 momentum)
        {
            int x = Owner.GetArray(Position.X);
            int y = Owner.GetArray(Position.Y);

            TileCollision collision = Owner.GetCollision(x, y);

            if (collision == TileCollision.Block)
            {
                Rectangle tile = Owner.GetBounds(x, y);
                Rectangle column = tile, row = tile;

                #region cluster
                TileCollision leftCollision = Owner.GetCollision(x - 1, y);
                TileCollision rightCollision = Owner.GetCollision(x + 1, y);
                TileCollision topCollision = Owner.GetCollision(x, y - 1);
                TileCollision botCollision = Owner.GetCollision(x, y + 1);

                if (leftCollision == TileCollision.Block)
                {
                    row.Offset(-Tile.Size / 2, 0);
                    row.Inflate(Tile.Size / 2, 0);
                }
                if (rightCollision == TileCollision.Block)
                {
                    row.Offset(Tile.Size / 2, 0);
                    row.Inflate(Tile.Size / 2, 0);
                }
                if (topCollision == TileCollision.Block)
                {
                    column.Offset(0, -Tile.Size / 2);
                    column.Inflate(0, Tile.Size / 2);
                }
                if (botCollision == TileCollision.Block)
                {
                    column.Offset(0, Tile.Size / 2);
                    column.Inflate(0, Tile.Size / 2);
                }
                #endregion

                Vector2 verticalCross, horizontalCross;

                //vertical
                if (momentum.X < 0)
                    verticalCross.X = column.Right;
                else
                    verticalCross.X = column.Left;
                verticalCross.Y = LastPos.Y + ((-(LastPos.X - verticalCross.X) / momentum.X) * momentum.Y);

                //horizontal
                if (momentum.Y < 0)
                    horizontalCross.Y = row.Bottom;
                else
                    horizontalCross.Y = row.Top;
                horizontalCross.X = LastPos.X + ((-(LastPos.Y - horizontalCross.Y) / momentum.Y) * momentum.X);

                if ((column.Top <= verticalCross.Y && verticalCross.Y <= column.Bottom) &&
                    ((verticalCross.Y < row.Top || row.Bottom < verticalCross.Y) ||
                    (verticalCross.X == row.Left || row.Right == verticalCross.X)))
                    Bounce(new Vector2(verticalCross.X, float.NaN));

                else if (row.Left <= horizontalCross.X && horizontalCross.X <= row.Right &&
                    ((horizontalCross.X < column.Left || column.Right < horizontalCross.X) ||
                    (horizontalCross.Y == column.Top || column.Bottom == horizontalCross.Y)))
                    Bounce(new Vector2(float.NaN, horizontalCross.Y));
            }
        }

        public void Bounce(Vector2 pos)
        {
            if (!float.IsNaN(pos.X))
            {
                Position = new Vector2(pos.X, Position.Y);
                Momentum = new Vector2(Momentum.X * -0.5f, Momentum.Y);
            }
            if (!float.IsNaN(pos.Y))
            {
                Position = new Vector2(Position.X, pos.Y);
                Momentum = new Vector2(Momentum.X, Momentum.Y * -0.5f);
            }
        }