Physics-bodies bouncing of each other at high velocities

Question

I'm developing a physics-engine in Python (I know, it's mostly for "learning") and have it come along quite well. I've been following a lot of online documentation on the matter, and this series of articles was especially helpful: How to Create a Custom Physics Engine.

I've got materials working, that act as a class that holds restitution and density of a body. What happens next is that bodies that have a low density and a high restitution (e.g. 0.3, 0.8 respectively), they bounce off each other with such high velocity it doesn't take long for them to shoot off into the "void".

I have a test scene set up with 4 walls that encloses the bodies (ball). When they go at such high velocity, a collision is never registered as the next physics simulation happens after they already passed the "walls".

What I'm really interested in is why they get such high velocity when bouncing off each other, while I don't believe they should. In my example recording, I have a small ball (red) which is controller by the player (me). It has a density of 0.3 and a restitution of 0.8, with a volume of 100 (r * r or 10 * 10), its mass is 30 KGs (100 * 0.3). Another larger ball (green) is not controller by the player, but can be bounced by hitting it with the red ball. It has the same material, therefor has the same density and restitution. However, its mass is higher, because of the higher radius (30). The actual mass of the green ball is 270 (900 * 0.8).

In the recording it's noticeable the balls bounce off of each other in an unnatural way. Shouldn't the small ball get inflicted a higher impulse than the big ball? I tried to work around this by swapping the mass values used when calculating the impulse. So the small ball's impulse is calculated using the mass of the big ball, and vice-versa. You'd think this is due to the bigger ball having a higher mass, but to me they bounce off of each other rather quickly?

Is this normal behaviour for the density and restitution I have on both of these balls? I will share code if needed, but as this text is already getting a bit long, I won't waste space if not needed. My code is almost exactly following what is covered in the articles, only "converted" into Python code.

Code on calculating impulse

# Relative velocity
rv = b.velocity - a.velocity

# Velocity along the normal direction
vel_along_normal = rv.dot(contact_normal)

# EPSILON (use lowest restitution value)
e = min(a.restitution, b.restitution)

# Calculate j, which will be used to get the impulse
j = -(1 + e) * vel_along_normal
j /= a_inv_mass + b_inv_mass

impulse = contact_normal * j

# Using ratio to have lighter bodies bounce with a higher impulse than heavier bodies
mass_sum = a_mass + b_mass
ratio = (b_mass / mass_sum)
a.rigid_body.velocity -= (impulse * ratio) * dt

ratio = (a_mass / mass_sum)
b.rigid_body.velocity += (impulse * ratio) * dt

Answer 1

It seems that there is a sign problem with velocity difference after collision. Rather than slowing red ball down it speeds it up.

Answer 2

The whole function does not look right to me, and as it does not seam to work as expected there is something wrong. Rather than try and workout what is wrong (too many unknowns in your code, dt, a_inv_mass, b_inv_mass, contact_normal) the following snippet will do the collision math for you

// A and B are balls at time of collision
mA = A.mass
mB = B.mass
mm = mA + mB

// vector between balls
x = A.x - B.x
y = A.y - B.y  

// restitution
e1 = A.restitution
e2 = B.restitution

// distance sqr between balls
d = x * x + y * y;

// v velocities
uAB = (A.v.x * x + A.v.y * y) / d  // normal component force A into B
u2  = (A.v.y * x - A.v.x * y) / d  // tangent component force A

uBA = (B.v.x * x + B.v.y * y) / d  // normal component force B into A
u4  = (B.v.y * x - B.v.x * y) / d  // tangent component force B

// Force from B into A along normal, scaled for mass ratio and restitution
uA = ((mA - mB) / mm * uAB + (2 * mB) / mm * uBA) * e1

// Force from A into B along normal, scaled for mass ratio and restitution
uB = ((mB - mA) / mm * uBA + (2 * mA) / mm * uAB) * e2

// new velocities 
A.v.x = x * uA - y * u2
A.v.y = y * uA + x * u2

B.v.x = x * uB - y * u4
B.v.y = y * uB + x * u4

Note that dt is ignored (assuming dt to be delta time)

Note both objects must have some mass. This will not work if one or both have 0 mass.