Function 无法随机检测事件

Question

I have these functions:

void apply_gravity(double delta){
    velocity.y+=9.8*100*delta;
}

void move_body(double delta){
    location.x+=velocity.x*delta;
    location.y+=velocity.y*delta;
}

void processPhysics(double delta){
    apply_gravity(delta);
    move_body(delta);
    if(location.y>=SCREENY){
        velocity.y=-coefficient_of_restitution*velocity.y;
    }
}

delta is the time elapsed between two calls to the function. velocity contains two parts, x and y which represent the increment per second to the location's x and y. coefficient of restitution represents how much of the original velocity the body retains after collision.

Basically, here is what I want this code to do:
Accelerate downwards by 9.8*100px per second. When the body goes below a limit (SCREENY px), it should bounce back, just like if it is hitting a floor. The collision should be perfectly elastic, and for now, SCREENY does not vary at all.

The code perfectly works for most of the times. BUT, sometimes, instead of "bouncing", the body just passes through the "floor". Basically, it seems that velocity.y does NOT negate even when the body crosses SCREENY. The comparision (location.y>=SCREENY) just fails at random times. Sometimes it works, sometimes it doesn't.

That should not happen.

What is going wrong here?

Answer 1

Your object is still allowed to pass through the floor, only updating the velocity. However, in the next frame, the object may still be in the floor, and have its velocity negated a second time (and third, and fourth). I imagine it would look like it gets stuck and vibrates a bit of a distance within the wall. If the object is within the wall, you should instead calculate where it should be if it had bounced, and update the position AND velocity accordingly. Not just the velocity.

A possible solution could look like:

void apply_gravity(double delta){
    velocity.y += 9.8 * 100 * delta;
}

void move_body(double delta){
    location.x += velocity.x * delta;
    location.y += velocity.y * delta;
}

void processPhysics(double delta){
    apply_gravity(delta);
    move_body(delta);
    if(location.y > SCREENY) // change to > from >= (eliminates edge case)
    {
        location.y = SCREENY - coefficient_of_restitution * (location.y - SCREENY); // update position as well, accounting for loss of velocity due to bounce
        velocity.y = -coefficient_of_restitution * velocity.y;
    }
}

The above solution will yield an error if the object is moving greater than one screen length in a single physics tic, so be careful about high speeds. You'll need a slightly more complicated algorithm to handle those situations.