You can't just cancel out the last movement of the player when he collides - that is why your player is freezing/getting stuck.

What you need to do in the event of a collision is move the colliding object out of the shape by the shortest distance possible.

For a circle, this means move the colliding object out along the direction of the circle's radius projected towards the collision point.

For a rectangle, this means move the object out by either x or y amount, up/down, whichever distance is shortest.

There's several ways you can do collision, but the simplest I can think of is a mathematical representation of point vs circle and point vs rectangle shape.

In rough pseudo-code (I'm assuming point is a vector (porbably sf::Vector2f) and circle has properties like center (Vector2f) and radius (float))

CollidePointVsCircle( point, circle )
{
  float dist = distance(point, circle.center);
  if ( dist < circle.radius )
  { // point is inside circle, i.e. colliding
    vector2f direction = normalize(point - circle.center); // figure out the shortest direction 'out' of the circle
    float amountToMove = radius - dist;  // the minimum distance to get out of the circle
    point = point + directoin * amountToMove;  // move the point along the direction by the smallest necessary amount
  }
}
 

For a rectangle, you need to figure out if the point is inside the rectangle, and then which side its closest to, then move it out along that amount.

Rough pseudo code:

CollidePointVsRectangle(point, rect)
{
  float distToLeft = point.x - rect.left;
  float distToRight = (rect.left + rect.width) - point.x;
  float distToTop = point.y - rect.top;
  float distToBottom = (rect.top + rect.height) - point.y
  if ( distToLeft > 0 && distToRight > 0 && distToTop > 0 && distToBottom > 0 )
  { // point is inside rectangle
    // determine which distance of the above is smallest - done by a lengthy if/else combination
    // then move the point along the direction depending on which side the point was closest - 
    // if distToLeft is smallest, move point.x by amount (-distToLeft)
    // if distToRight is smallest, move point.x by amount (distToRight)
    // if distToTop is smallest, move point.y by amount (-distToTop)
    // if distToBottom is smallest, move point.y by amount (distToBottom)
  }
}
 

When I say move the point, you can actually compose your player of multiple points, and collide each point with whatever is nearby (you'll have to figure out a way to make sure you don't do collision with all objects)

This is very simple point-circle and point-rectangle collision. If your player is small enough relative to the objects he's colliding with (i.e. there's no wall with a size smaller than the player's size), this will work relatively well.

Alternatively, there's some more complicated, but also more versatile collision methods described here: http://www.metanetsoftware.com/technique/tutorialA.html - as I mentioned on another similar post, they provide source, which should be fairly easy to adapt to your purpose - i did so for the 2d platformer I'm making right now.

Or you could use a library like Box2D - though since I've never used it, i don't know if it has everything you need.

Hi, thanks for the info, but I find it is poorly explained. As I have many walls in my room, how would I check for collision on all of them. INCLUDING AN L SHAPE

___

| |

| |____

|_______|

????

... INCLUDING AN L SHAPE

As fastcall said - you can decompose an L shape piece into four square pieces.

Alternatively, you can decompose it into two rectangles, like so:

 _
| | __
|_||__|

In general, any polygonal shape consisting of only right angles can be decomposed into a number of rectangles.

With circle, you can also approximate more complex shapes.

Hope this clarifies the L shaped collision. If there's any other specific part of my previous post you don't find clear, let me know. :)

How would I go about checking all my walls at the same time??

Though if the L shape is the shape of the inside of the room (and not the wall), you'll want a rectangle for each wall.

Thank you beernuts! Most helpfull of all.

And Servant of the lord, I appreciate your effort, but the room isn't actually L shaped. There is a counter with an L shape inside the room

I would suggest moving your player in the x-direction 1st, then checking for collision. If it collided, move it back to where it was (by just adding the -velocity). Then move the player in the y-direction and check for collisions. If it collided, move it back to where it was. This would keep the player always just off the wall.

This is a simple method of doing it, but its effective. it will handle those cases where the player is moving up and right, and he hits a wall to his right. You will keep moving him right, then placing him back on the x-axis, then move him up, and he won't hit anything bove him, and the y-position will change.

interesting, separation of the axis. This would work for rectangle collision, but it won't give accurate results for collision vs a circle. Here's one case, where the y-axis will fail, but the x-axis won't, and you'll end up in the wrong spot (the red arrows are the axis separation, the green is the minimum distance displacement)

Worst case I can think of actually ends up where both your x and y axis tests will fail (both will collide with circle) and you'll end up being stuck on the circle.