If I know a given action will result in a collision, should I allow the action to occur anyway?

Question

I've finished programming my game engine, and now that I've been testing it, I've been noticing some graphics problems.

The big one is that when a player tries to push against a wall, their character will "jiggle" against it as it constantly tries to enter the wall's space and the collision detection constantly pushes it back outside.

What is the proper way to handle such a situation?

My first instinct was, if moving in a certain direction causes a collision, disable movement in that direction until the entity's position has changed. I.e., once an object falls onto a platform, disable gravity until the object is no longer above a platform.

Is there a better way to resolve repeated collision detections between the same two objects in the same overlapping space?

Answer 1

About character collisions with a wall, for instance (I'll use some arbitrary values as example): if you are 10 units (e.g. pixels) away from a wall, and a single step would normally move you 20 units in that direction, the correct behavior is for your character to move 10 units and stop there. If you cancelled the action instead, you'd remain 10 units away from the wall which is not what you'd want.

One way to do this is to move the character by the full amount, then detect the collision and its depth i.e. how much the bounding boxes of the character and the wall are overlapping, and move the character back by that same amount. If you do this correctly you shouldn't be getting any "jiggle" behavior from your character, he'll just press against the wall and stop there. If he's jiggle'ing then you're probably moving him back too much (you're probably moving him back to position he was before the collision, instead of clamping it against the wall boundary).

That being said, I usually see gravity being treated as a special case. In most implementations I've seen, the character stores an onFloor flag and gravity is only applied when that flag is false.

Edit: I guess you could expand this last concept and create additional flags such as touchingRightWall or touchingLeftWall, but only when the boundaries of the character and the wall match exactly. In that case you could perhaps bypass movement altogether. But if the boundaries are not matching precisely, you should let the movement take place and let the collision detection system resolve any intersections.

Answer 2

This problem usually occurs when the code clamps positions before detecting a collision. I.e:

MoveCharacter();
ClampPosition();
CheckCollision();
DrawFrame();

instead of

MoveCharacer();
CheckCollision();
ClampPosition();
DrawFrame();

The reason it "jiggles" is because the check happens after the character has been clamped to a "safe" location, but because the character is in a non-colliding location at the time of the check the engine allows for the character to continue to move, then the character is drawn and then the next frame the check fails, Clamp is called, causing the character to "snap" back to the safe location.

Answer 3

I've had the same problem recently and fixed it like this:

move the object, checking for a collision, if collision is found, place object outside of colliding object. draw the object.

The player could keep running into the wall without any jiggling because before he is drawn, he will be placed at the side of the object.

Answer 4

Using vector / plane mathematics you can calculate exact point of collision with wall that will happen in next frame. This assumes that your character has velocity which you can use to calculate movement vector that will happen during next frame. After finding point of collision you can calculte sliding vector that will move your character along wall, this vector actually can collide with another wall.

So back to your question, you should calculate the exact position of collision where your character should be located and what actually should happend then. If this is a wall and its FPS game, then let character slide along it.