I've developed two different collision routines.

The first is far better at conservation of momentum, while the second yields more precise resultant vectors. But the magnitude of such results are not at all accurate as the first's.

This first code:

VB Code:
  1. If Points(Y).Size < 1 Then Points(Y).Size = 1

  2.                 pd = (Points(X).Size / Points(Y).Size) / 2

  3.             

  4.                 P1mx = (Points(X).Move.X)

  5.                 P1my = (Points(X).Move.Y)

  6.                 If Points(X).Size < 1 Then Points(X).Size = 1

  7.                 If Points(X).Size > Points(Y).Size Then

  8.                     pd = (Points(X).Size / Points(Y).Size)

  9.                     Points(X).Move.X = (Points(Y).Move.X / pd) * Fric

  10.                     Points(X).Move.Y = (Points(Y).Move.Y / pd) * Fric

  11.                     Points(Y).Move.X = (P1mx * pd) * Fric

  12.                     Points(Y).Move.Y = (P1my * pd) * Fric '

  13.  
  14.                 Else

  15.                     pd = (Points(Y).Size / (Points(X).Size))

  16.                     Points(X).Move.X = (Points(Y).Move.X * pd) * Fric

  17.                     Points(X).Move.Y = (Points(Y).Move.Y * pd) * Fric

  18.                     Points(Y).Move.X = (P1mx / pd) * Fric

  19.                     Points(Y).Move.Y = (P1my / pd) * Fric

  20.                 End If

The second.
VB Code:
  1. pxmx = Points(X).Move.X

  2.                     pxmy = Points(X).Move.Y

  3.                     pymx = Points(Y).Move.X

  4.                     pymy = Points(Y).Move.Y

  5.                     

  6.                     If Points(X).Size > Points(Y).Size Then

  7.                         Points(X).Move.X = (((xRadii + yRadii) * xd) / dist * Fric)

  8.                         Points(X).Move.Y = (((xRadii + yRadii) * yd) / dist * Fric)

  9.                         Points(Y).Move.X = -(((xRadii + yRadii) * xd) / dist * Fric)

  10.                         Points(Y).Move.Y = -(((xRadii + yRadii) * yd) / dist * Fric)

  11.                     Else

  12.                         Points(X).Move.X = (((xRadii + yRadii) * xd) / dist * Fric)

  13.                         Points(X).Move.Y = (((xRadii + yRadii) * yd) / dist * Fric)

  14.                         Points(Y).Move.X = -(((xRadii + yRadii) * xd) / dist * Fric)

  15.                         Points(Y).Move.X = -(((xRadii + yRadii) * yd) / dist * Fric)

  16.                     End If

Points is defined as:
VB Code:
  1. Private Points() As pPoint

  2.  
  3. 'pPoint is:

  4.  
  5. Private Type pPoint

  6. Loc As sPoint

  7. Move As sPoint

  8. Size As Long

  9. Color As rgbCol

  10. LastColl As Long

  11. End Type

  12.  
  13. 'which uses:

  14.  
  15. Private Type sPoint

  16. X As Single

  17. Y As Single

  18. End Type

  19.  
  20. Private Type rgbCol

  21. r As Long

  22. g As Long

  23. b As Long

  24. End Type

When colliding:
VB Code:
  1. If dist > 1 Then

  2.                     Points(X).Loc.X = Points(Y).Loc.X + ((xRadii + yRadii) * xd) / dist

  3.                     Points(X).Loc.Y = Points(Y).Loc.Y + ((xRadii + yRadii) * yd) / dist

  4.                     Points(Y).Loc.X = Points(X).Loc.X - ((xRadii + yRadii) * xd) / dist

  5.                     Points(Y).Loc.Y = Points(X).Loc.Y - ((xRadii + yRadii) * yd) / dist

  6. End If

Sets each particle's location out of the other particle.