How can I determine the direction of the balls after collision in billiards game?

Question

I'm making a billiard game and I have two questions:

How do I find the velocity of two balls when they collide with each other and how do I apply it to both balls?

I already know the angles that they're gonna move, I just need to find the velocity that they'll move in those directions.

My game is in 3D, and I'm using Unity. I don't want to use Unity's built-in physics to compute the result in this case, I'd like to know how to compute it myself.

Answer 1

What you are attempting is non trivial and using the internal Physics system is going to be a ton less problematic.

That said, if you really want to eek it out by hand then you need to first detect intersections between the relevant balls, then you need to resolve these out, then you need to update the velocities.

1. To detect intersections between the balls

This is simply a sphere / sphere intersection test. Iterate through all pairs and check the distance. Distance = (sphere1.transform.position - sphere2.transform.position).Length()

If Length < sphere1.radius + sphere2.radius then you have an intersection and you should resolve them

2. Resolution of intersection

You first calculate the normal of collision. This is simply

NormalOfCollision = sphere1.transform.position - sphere2.transform.position;
NormalOfCollision.Normalise();

You calculated the sphere distance in (1) so the resolutionDistance is totalRadius - sphereDistance. You then apply this to the bodies.

sphere1.transform.position += NormalOfCollision * resolutionDistance
sphere2.transform.position -= NormalOfCollision * resolutionDistance

If you are going to have spheres of different masses colliding then you should scale the impulse so that the smaller mass is moved more than the larger mass. I.e.

sphere1Impulse = sphere2Mass / (Sphere1Mass + Sphere2Mass);
sphere2Impulse = sphere1Mass / (sphere1Mass + Sphere2Mass);
sphere1.transform.position += NormalOfCollision * resolutionDistance * sphere1Impulse 
sphere2.transform.position -= NormalOfCollision * resolutionDistance * sphere2Impulse 

3. Calculation of velocity after impact

You need to use the conservation of linear momentumm law. The wikipedia page gives a worked example.

NB

1. The above is pseudo code, I've not run it, so I may have some of the +ve / -ve signs around the wrong way - butit's the right direction
2. This just handles the linear effects NOT angular (so won't simulate spin shots etc)
3. If you have larger time steps, or multiple balls interpenertating you should resolve until you have no more contacts (ObjectA may push ObjectB into ObjectC so you need to resolveagain)
4. There is no optimisation in this (islanding / broadphase collision etc)
5. There is no restitution in this with different objects being more bouncy than others
6. Using PhysX is going to be a ton easier than doing everything yourself

Answer 2

This question is more about an approach rather than the actual physics.

In this case all your balls should have or contain a component describing the relevant information that you require.

i.e.:

public class Balls
{
    public Vector3 Vector {get; private set;}
    public float Speed {get; private set;}
}

And when the balls meet you can then use this information to do whatever physics you need to perform. For example, depending on your implementation, you may choose to make each ball calculate its own trajectory after colliding with the other, in the OnCollisionEnter function.