How can I detect a perfect passageway for collision detection?

Question

The problem is when I move diagonal it moves fractions of units and therefore my coordinates might be a fraction of a unit say (40,400) might be actually (40.12,400.40) but another problem is my pink square might be moving really fast. Below is a screenshot where you can see I can make it past a pixel perfect passageway with my pink square but the other passageway with the white square is very difficult if not impossible to make it through (I have by zooming in and moving REALLY slow but sometimes it impossible for the reasons listed above) Suppose in the example above I am holding the up and left arrows how can I make it so the pink square slides across the yellow rectangle and detects it can move upward and begins to move up?

The code I am using right now looks like this

float d45 = (float) (1 / Math.sqrt(2));
moveX = -d45;
moveY = d45;
moveX = moveX * t * speed;
moveY = moveY * t * speed;
        for (Stuff s : collidables) {
            if (overlaps(s, moveX, 0)) {
                collidedX.add(s);
                x += moveX > 0 ? s.x - width - x : s.x + s.width - x;
            }
        }
        if (collidedX.size < 1) {
            x += moveX;
        }
        for (Stuff s : collidables) {
            if (overlaps(s, 0, moveY)) {
                collidedY.add(s);
                y += moveY > 0 ? s.y - height - y : s.y + s.height - y;
            }
        }
        if (collidedY.size < 1) {
            y += moveY;
        }

I check for collision twice once on the Y axis and another on the X axis so that it can still slide to the left even if you are pushing the up and left arrow. The problem is it skips over the 100 unit passage to the left of the picture above. If I create a passage that is 110 units wide it will slide up fine but this isn't really cool because I like how it looks where it slides perfectly. Any ideas?

Answer 1

Collision detection like this can be tricky. However - I do see a way around your problems.

First, you definitely want to round off your "collision" position. In most cases, decimal numbers will cause collision problems when you're working with pixels (which are measured in whole numbers, usually).

Here are two methods I thought up, in image form: (sorry everybody I know this makes my answer hard to edit... if you notice an error with the image please comment - I can correct it, thanks!)

Answer 2

The easiest way to side-step this is:

x = (int)x;
y = (int)y;

or

x = round(x);
y = round(y);

Are either of these acceptable, visually?

Edit:

Diagram of modified SuperDoggy "Method 1" using floats:
Precise overlap amount given by colliders

Since you have so many cases, it may be helpful to make a helper for jiggling the rect:

class CollisionHelper
{
   CollisionHelper(Collider1,Collider2);
   RECT original;
   RECT test;
   void MoveUp();
   void MoveDown();
   void MoveLeft();
   void MoveRight();
   void ResetRect();
   void Test();
   bool wasValid[4];
   ...
}

This would also encapsulate any flags needed to make multiple tests in one frame and any frame-to-frame flags that might be useful. It should make the if/switch more manageable.