2D Collision Detection XNA C#

Question

I've read all around the net, watched videos, tried things and in the end I can't make a decent platform collision detection.

I've followed this tutorial.

It didn't work out at 100%. My object stops above ground and can't hit the ground. Anyway, I think the guy got fed up with me asking questions. And his way seems too complicated. In short it's about constant calculations how far are you from a wall/ground and how much steps can you make("step" is also defined), how much DID you make, etc. Too complicated if you ask me. So let's forget about that.

I began anew on my own. Here's what I got:

private void ApplyCollision()
    {
        if (PlayerIsOnPlatform())
        {
            this.Position -= new Vector2(0, 5);  // Holds Player on platform. 
        }
    }

private bool PlayerIsOnPlatform()
    {
        int playerBottom = this.Bounds.Bottom;
        int platformTop = Platform.CurrentPlatform.Bounds.Top;
        bool playerIntersectsPlatform = 
            this.Bounds.Intersects(Platform.CurrentPlatform.Bounds);

        if ((playerBottom >= platformTop) && (playerIntersectsPlatform))
        {
            return true;
        }
        return false;
    }

And gravity and friction:

private void Friction()
    {
        Movement -= Movement * new Vector2(.1f, .1f);
    }

private void Gravity()
    {
        Movement += Vector2.UnitY * .5f;   
    }

Like this, the player bounces a bit and stays about a pixel above ground. And the gravity is always trying to pin the object down even when I somehow manage to land on the platform.

=======

EDIT:

The player stops at the platform top correctly. But now I have another problem:

private void ApplyCollision()
    {
        // Object is above
        if (playerBottom > platformTop && playerBottom < platformBottom && playerIntersectsPlatform)
        {
            this.Position = new Vector2(currentPlayerPosX, platformTop - playerHeight);
        }
        // Object below
        else if (playerTop < platformBottom && playerTop > platformTop && playerIntersectsPlatform)
        {
            this.Position = new Vector2(currentPlayerPosX, platformBottom);
        }
        // Object to the left !! Conflicts with Vertical detection
        if (playerLeft < platformLeft && playerRight > platformLeft && playerIntersectsPlatform &&
            this.Bounds.Center.X <= platformLeft) // Not perfect
        {
            this.Position = new Vector2(platformLeft - playerWidth, currentPlayerPosY);
        }
        // Object to the right !! Conflicts with Vertical detection
        else if (playerRight > platformRight && playerLeft < platformRight && playerIntersectsPlatform)
        {
            this.Position = new Vector2(platformRight, currentPlayerPosY);
        }
    }

This methods works. It's shorter, better and doesn't need my initial boolean methods I had for top, bottom, sides check. But the Left and Right checks still need work. When the player is near the Platform border, he gets pushed/teleported off the edge. The Left check actually allows half of the Player to go off the edge without falling instantly - thanks to this.Bounds.Center.X <= platformLeft. Not perfect. Here's a picture to illustrate the problem:

I know why this is happening. It's due to the conditions in the if statements. I guess this calls for collision depth calculation. I find Jon's implementation kinda confusing. And I wonder if that's the only solution. I tried adding another condition. Pseudocode for left check: if 1/4 of Player.Width <= platformLeft >THEN> this.Position = new Vector2(platformLeft - playerWidth, currentPlayerPosY); But due to the friction and speed I have, it doesn't work.

Answer 1

I figured I'd come in and explain to you how I used to do my Rectangle collisions in XNA/Monogame. Firstly, I declare an enum that will serve as a way to indicate what axis we are going to be working with. This is important, as our calculations will be done one axis at a time.

public enum Direction
{
    Horizontal,
    Vertical
}

You will also need a function that can determine if two Rectangles are intersecting, and if they are, you are going to want to know how deep this intersection is. The depth will be important when we get to collision response.

The below functions, will do these calculations for you.

// A helper function for the next two
public static bool Intersects(Rectangle player, Rectangle block, Direction direction, out Vector2 depth)
{
    if (direction == Direction.Vertical)
        depth =  new Vector2(0, GetVerticalIntersectionDepth(player, block));
    else 
        depth = new Vector2(GetHorizontalIntersectionDepth(player, block), 0);

    return depth.Y != 0 || depth.X != 0;
}


public static float GetHorizontalIntersectionDepth(Rectangle rectA, Rectangle rectB)
{
    // Calculate half sizes.
    float halfWidthA = rectA.Width / 2.0f;
    float halfWidthB = rectB.Width / 2.0f;

    // Calculate centers.
    float centerA = rectA.Left + halfWidthA;
    float centerB = rectB.Left + halfWidthB;

    // Calculate current and minimum-non-intersecting distances between centers.
    float distanceX = centerA - centerB;
    float minDistanceX = halfWidthA + halfWidthB;

    // If we are not intersecting at all, return (0, 0).
    if (Math.Abs(distanceX) >= minDistanceX)
        return 0f;

    // Calculate and return intersection depths.
    return distanceX > 0 ? minDistanceX - distanceX : -minDistanceX - distanceX;
}


public static float GetVerticalIntersectionDepth(Rectangle rectA, Rectangle rectB)
{
    // Calculate half sizes.
    float halfHeightA = rectA.Height / 2.0f;
    float halfHeightB = rectB.Height / 2.0f;

    // Calculate centers.
    float centerA = rectA.Top + halfHeightA;
    float centerB = rectB.Top + halfHeightB;

    // Calculate current and minimum-non-intersecting distances between centers.
    float distanceY = centerA - centerB;
    float minDistanceY = halfHeightA + halfHeightB;

    // If we are not intersecting at all, return (0, 0).
    if (Math.Abs(distanceY) >= minDistanceY)
        return 0f;

    // Calculate and return intersection depths.
    return distanceY > 0 ? minDistanceY - distanceY : -minDistanceY - distanceY;
}

Now, in your player class (or whatever class you want to have collisions check done in, you would utilize these above functions, in order to check for collisions, and then handle its response.

The following function will take a direction, and calculate to see if you need to provide a collision response or not.

private void CheckCollisions(Direction direction)
{   
    //Get a list of objects to test against
    //You probably already have a mechanism for this
    List<Tile> tiles = quadtree.GetObjects(this.Rectangle);

    //Loop and check for collisions on these objects
    for (int i = 0; i < tiles.Count; i++)
    {
        if (!tiles[i].Collidable) continue;

        //Calculate intersection depth
        Vector2 depth;
        if (Intersects(this.Rectangle, tiles[i].Rectangle, direction, out depth))
        {
            //If an intersection was found - adjust position
            Position += depth;

            //Adjust velocity based on intersection direction
            if (direction == Direction.Horizontal)
                Velocity.Y = 0;
            else
                Velocity.X = 0;
        }
    }
}

Then finally, in your Update method, you will re-position and check for your collisions one axis at a time.

public void Update(GameTime gametime)
{
    float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;

    //Velocity Calcs
    Velocity = new Vector2(100, 50);

    //Update one axis at a time
    this.Position.Y += Velocity.Y * elapsed;
    CheckCollisions(Direction.Vertical);

    this.Position.X += Velocity.X * elapsed;
    CheckCollisions(Direction.Horizontal);
}

Hopefully this will help you, or someone else, having similar issues like this.

Answer 2

The

if (PlayerIsOnPlatform())
{
    this.Position -= new Vector2(0, 5);  // Holds Player on platform. 
}

is innocorrect. You need to calculate the depth penetration. IE: Calculate how far the player intercepted the other item. XNA has a method for this that returns the rectangle formed when two rectangles intersect. It returns the purple rectangle in this picture:

Rectangle collisionRect = Rectangle.Intersects(player.Rect, platform.Rect);
if(intersection.Height > 0)
{
    player.Rect -= intersection.Height;
}

This will push the player outside the other rectangle. Depending on how you programmed gravity it might create a jittery effect on the player where he falls, gets pushed back up, falls, gets pushed back up, falls, etc. To fix this you need to simulate (everything, particularly gravity) and THEN push back up, then draw.

Edit: If you want to check the bounds yourself. These you will have to think about carefully. I think I got them all right.

if(player.Bottom > platform.Top && player.Bottom < platform.Bottom) // Object is above
    player.Rect.Pos += new Vector2(0, platform.Top - player.Bottom);
else if(player.Top < platform.Bottom && player.Top > platform.Top) // Object below
    player.Rect.Pos += new Vector2(0, platform.Bottom - player.Top);
if(player.Left < platform.Right && player.Left > platform.Left) // Object to the left
    player.Rect.Pos += new Vector2(platform.Right - player.Left, 0);
else if(player.Right > platform.Left && player.Right < platform.Right) // Object to the right
    player.Rect.Pos += new Vector2(platform.Left - player.Right, 0);