# Do two balls of different mass bounce different heights?

There are two balls and the only difference between them is the mass. Both are dropped from the same height on to the floor (static object with infinite mass), would both balls bounce up to the same height, or would the heavier ball bounce higher as it enters the collision with more momentum?

From my own derivation it would appear that the calculation reduces down to a simple vector reflection about the contact normal, but it doesn't feel right. Can anyone verify this?

EDIT:

To be clearer, I am looking for a code sample of how to resolve a ball collision against a plane using a collision impulse. Does the collision impulse rely on the ball's mass when colliding with an object of infinite mass?

• How can a game developer answer this better? It seems like a question for the Physics SE to me. – MichaelHouse Feb 9 '14 at 16:11
• Because I'm not a physicist and would understand it better coming from a games programmer. – Syntac_ Feb 9 '14 at 16:16
• Hm, guess you're both right to some extend. For future, if you don't need working code, I guess you could just ask on physics.stackexchange.com and mention that you'd like an easy/simplified explanation since it's for game simulation or something like that. Most such formulas can be written the easy or the complex (more accurate) way. :) – Mario Feb 9 '14 at 16:17
• The physics SE is not just for physicists. "Physics is a question and answer site for active researchers, academics and students of physics and astronomy". You can ask them to explain things more simply if you don't understand. – MichaelHouse Feb 9 '14 at 16:19
• If you're implementing physics, you're a student of physics. You don't actually have to take a class :). If you're hoping for code samples, why wouldn't you specifically ask for that? – MichaelHouse Feb 9 '14 at 16:29

The answer to your question is: no, as long as the system you're referring to implies no friction, there are no external forces, and the material the two ball are made of can be ignored.

In Classical Mechanics, the linear momentum of a body (any object) is defined as mass times velocity, p = mv, and it is a vector, so that you can consider the linear momentum of an object as the sum of its components along the system axes (x and y, for example).

One of the common reasons linear momentum exists is to deal with collisions between objects, as there's need to give each object involved a magnitude of 'something' to compute the final state of the system, thus the speed and direction of an object after a collision.

Physicists (and matematicians too...) obtained a nice formula to get the velocity of two object O1 and O2 after they collide each other by working out the equation system of the two objects' linear momenta and their kinetic energy, there it is:

Here, v is the velocity vector, m the mass, f and i stand for 'final' and 'initial', thus after and before the collision occurs respectively. The indexes 1 and 2 are used to refer to one of the two objects you are considering for the collision. There's no difference about who is object 1 or 2, as long as you still refer to the same object during the calculations. Also, this formula can be used to compute collision between more than two objects by working on their couples. For example, if three ojects collide each other at the same time, all you need to do (although this is just an approximation) is to apply the formula to object 1 and 2, 1 and 3, and finally to object 2 and 3.

Anyway, if you figure out this formula, you will notice that any final velocity depends on the object masses, but if you consider the two masses the same, velocities are just exchanged betweeen the two objects as final result.

Back to your question. What ball will jump higher? Let's have two schemes, the first is the collision between ball 1 and the pavement, the second one between ball 2 and the same pavement. For each scheme, we'll consider the pavement indexed as '2' in the formulas. Since the pavement has infinite mass, someone would be in trouble multiplying or dividing by infinite. We could apply mathematical calculus to obtain the velocities, OR we can rely on the Law of Conservation of Linear Momentum which says that inside an isolated system (a system where there's no friction) the momenta of every object is conserved entirely.
That means that an object with momentum mv directed downwards (the ball) collides with a fixed non-moving object with infinite mass (the pavement) should still have a momentum of mv regardless of the sign. And since the pavement is not supposed to move, the ball is then moving upwards with the same speed, despite several balls may have different masses.

So, your two balls will bounce to the same height, as equations of motion tell us.

As for the sample code, you can just adapt the above formula so that every object involved performs the first equation only on itself, where the object calling the function has index 1 and the other has index 2 referred to the formula:

    ...
Ball a = new Ball(5);        // Mass is 5
Ball b = new Ball(8);        // Mass is 8
...
if (collision(a,b)) {        // Any collision check algorithm
a.collide(b);            // Call
b.collide(a);            // Call
}
...


Your function may look somehow like this:

    void collide(Object other) {
this.speed = (this.mass-other.mass)/(this.mass+other.mass)*this.speed+(2.0*other.mass/(this.mass+other.mass))*other.speed;
}


This is just a hint about how to write your code; you can think of any possible implementation depending on your needs.

BUT, if you want to better simulate reality, your balls should bounce at different heights as time goes on. Any collision between two objects depends not only on masses and velocities, but also on centers of mass, angular momentum, friction, and the materials the objects are made of. A steel ball and a wood ball will bounce lower than a tennis ball, but that's because of the coefficient of restitution, the energy loss due to the sound of impact and heat generated... But that's physics stuff, as much interesting as boring (well, not for everybody). Usually you would implement a friction system so that a ball will stop sometime in the future when rolling on the floor, but that will influence the motion attitude of the ball too. I suggest further readings if you want to deepen this argument.

It is generally assumed that the mass does not matter and they bounce up to the same height. This is because the coefficient of restitution, which lets you calculate the velocity change after the collision, does not depend on mass. The velocity right after the collision determines the height that the ball will move up to, independent of the mass (just like how mass does not affect free fall duration). So, for games, it's safe to assume that they will end up at the same height.

However, in real life, it can be hard to make the two have the same contact properties and balls with different masses may end up bouncing to slightly different heights. This paper can provide further insight.

They won't necessarily. It doesn't depend on the actual mass. The important part is their elasticity as well as the applied friction.

The mass would come into play, but only if the difference between the balls and the surface are rather small.

So if you assume the ground or wall has infinite mass (i.e. it won't move), then the mass of the balls won't play into this at all (or, realstically, almost no effect).

Of course, everyone knows some piece of metal will drop faster than a feather, but this is mainly due to different shapes (air resistance!). In a vaccum everything accelerates (and falls) with the same speed (9.81 m/s² on Earth).

Given the same impact speed and elasticity/restitution, both would bounce back with the same force and therefore fly up the same height. In the real world this isn't always exactly true, even if you ignore air resistance, since the different weights can modify the actual impact (for example, the heavier ball might squeeze more upon impact).

If you want proofs, just look at the actual free fall:

h(t) = h(0) - 0.5 * g * t2

v(t) = v(0) - g * t

As you can see, the actual height (and with that the acceleration and velocity) depends on the gravity g as well as the time passed t. However, mass doesn't play into this.

For the actual impact, the important rule is the conservation of momentum:

Ekin = m * v

Since no energy is lost (perfect case), this means the ball will bounce back obtaining the same amount of energy. Due to the mass being constant, the velocity will be the same as well (just with changed direction).

For a more realistic simulation, you'll most likely want to add in some friction though. Due to this the ball won't bounce back with 100% energy, but maybe 90% instead (the actual value can be adjusted to simulate different materials).

How much an object bounces doesn't depend on its mass but rather on its material. When you create a physics engine, you usually model "bouncyness" by a factor of speed which is retained when the object collides with the ground. When the object hits the ground, you invert its speed and multiply it with the "bounce-factor" of its material.

A rubber ball with a high bouncyness would have a "bounce-factor" of close to one, like 0.9.

The "bounce-factor" of an NBA-conform basketball is 0.722 (the official definition is that it bounces to 1300mm when dropped from 1800mm).

A bowling ball which just bounces a tiny bit when dropped from a high height would have a very low "bounce-factor" like 0.1.

An object which doesn't bounce at all, like a hacky-sack, would have a bounce-factor of 0.0.

The "correct" bounce-factor for each material should be found out through experimentation. Just tinker with it until it "feels" right.

• What would this look like when applied to the ball's velocity? – Syntac_ Feb 9 '14 at 17:19
• @Syntac Speaking in code, it would look like this: velocity.y = -velocity.y * bounce_factor; – Philipp Feb 9 '14 at 17:25
• This would only work for a horizontal plane, what about a generic plane? – Syntac_ Feb 9 '14 at 17:31
• In that case you could rotate the velocity-vector by the angle-difference between the angle of the velocity-vector and the angle of the surface, perform above operation on the x-component, and rotate the vector back. – Philipp Feb 10 '14 at 0:20