I am working on a brick breaker type game, so it was necessary for me to know not just that the ball collided with the brick but also which side that it collided on.

What i did, is that i essentially create four more bounding boxes ( logically in the code, not actually as a instance of a Hit_box struct ) that are three pixels deep from their respective sides.

Once i know that the ball collided with the brick, i call this function to determine which side it hit ( LEFT, RIGHT, TOP and BOTTOM being members of an enum, the parameters being members of the ball )

The problem is this: it never returns LEFT or TOP.

I am guessing it has something to do with the "a[x/y]+a[w/h] > [x/y] and a[x/y]+a[w/h] < [x/y]+3" conditions being logically flawed, but i can't see the problem.

Any help would be appreciated!

Just write a rectangle class and give it a contains(int x , int y) method. Then make rectangles for each side and say if (left_rectangle.contains(ballx,bally)) {return LEFT;}

That would help if my ball were a pixel, but that would be a bit difficult to see

The resolution to my problem would be, in the best case scenario, a revision of the conditions for the first and third if statement.

If it helps people visualize better, attached is a hitbox map of one of the bricks. If there is overlap on the red areas, it SHOULD return LEFT. If there is overlap on the brown areas, it SHOULD return TOP. If there is overlap on the cyan areas, it returns RIGHT. If there is overlap on the yellow areas, it returns BOTTOM.

And if it makes it more clear:
(ax,ay) = top left corner of ball.
(ax+aw,ay) = top right corner of ball.
(ax,ay+ah) = bottom left corner of ball.
(ax+aw,ay+ah) = bottom left corner of ball.

if( ax+aw > x and ax+aw < x+3 ) return LEFT;//problems

Your checks are very prone to the bullet through paper problem,
if your ball moves fast enough, and in one frame goes further than x + 3 it will not return, that could be the problem.

So, if in one frame it is 1 pixel away from the bounding box, and has a speed of 4 pixels or higher it will fail. One solution is to include the speed of the ball.

So then write a rectangle overlap function.

typedef struct Rect {int lx,ty,rx,by,w,h;};

int Overlaps(Rect r1 , Rect r2) {
   if ((r1.lx > r2.rx) || (r1.rx < r2.lx) || (r1.ty > r2.by) || (r1.by < r2.ty)) {return 0;}
   return 1;
}

Now make a rectangle for each side of the brick, and check if the ball overlaps it. And pay attention to what Gnamra said about it moving too fast.

No,no. Like i said, this only happens when coming from the left or top. I had thought of that initially, though and tried to increase the width of the bounding box to compensate. That didn't work. So i just set a ball going 1pxl right per frame at the left of the block. It still went through.

Since it returns correctly on RIGHT and BOTTOM, i can only assume that it is a problem with the top and left IF statements.

It could also be that your first collision check is incorrect, because if it is only going 1 px per frame then it should work. Perhaps you could post some more code?

Oh good lord. Thank you SO much.

It turns out i had replaced the initial collision detection with tile system, since all of the bricks are of the same width and height. That let me get rid of the time consuming For loops.

Unfortunately, i forgot to account for the bottom and right of the ball when i made the switch.

Sorry about that, I'm still having trouble wrapping my mind around such a (comparatively) large project.

I recently work on the same type of game. One extra thing to note is that if your bricks are close together (in my game they touch), than the ball can potentially hit more than one brick at a time, you need to check for this.

If the ball collides with the bottom of a brick, than you need to check if it also collided with the side of another adjacent brick...

   _
 _|_|
|_|O

.. as you can see the ball will collide with two bricks here at the same time given the right circumstances.

If you count the time a ball hits this becomes more important. It's really easier than it looks. Here's the code for how I do it:

I checked both vertical and horizontal collisions just in case it hit a second brick at the same time.

For really easy, basic bouncing box collision detection this works well:

if (bottom1 < top2) return(false);
if (top1 > bottom2) return(false);
if (right1 < left2) return(false);
if (left1 > right2) return(false);

You don't check for overlap, but rather you check if they don't overlap. If the bottom of sprite one is less than the top of sprite two, than a collision between the two is impossible and the function can return false.

You do the four tests above and if any one of them fails, no collision. But if they all pass, than you have a collision. You can then add in more code to find just where that happened. In my own function I then have some code to detect for pixel perfect detection which isn't needed in most cases. It's a nice fast way to check for collisions though.

I've made a pong clone numerous times and every time I forget to check the top and bottom of the paddles to react accordingly. Slow learner. Though this helps me understand collision detection a little more.