pol ball physics

[ScottB]

I want to do a pool game.

This is a must for speed. I writing physics formulas but having trouble.

I know reflection is perpendicular to the ball I hit and of ball one is incident angle between balls.
so this was easy but it seems wrong when the mouse ball hits straight on and also which perpendicular normal is right. can some please help with only two balls on the table. rewrite what i'm missing or corrent me thanks.

[stevmjon]

the reflection is not always perpendicular to the ball you hit. the difference is what you are applying this to (ray tracing reflection works differently from what your doing for example). it all depends on the direction vector the 'hit ball' is travelling in, then when the balls collide, you need to create another vector between the ball centers (from hit ball to static ball), then make a reflectance between these 2 vectors (maybe dot product the vectors as unit vectors) to figure out correct angle to move static ball.

the balls may hit square on or you may glance the ball. vectors will give an accurate value every time at any angle.

dot product is handy as 'unit vectors' because that determines how straight the reflectance angle should be. the closer to 1 the more square the hit angle, the closer to 0 the more of a glancing angle between balls. then you can determine the speed & reflectance angle from this to move the static ball.

the reflect vector in the demo is just one possibility. i just averaged the direction vector & ball to ball vector. it will need tweaking.

hope this helps you, stevmjon.

[kevin]

  I remember doing something like like this back in the day, not that I can find it today.. :(  but none the less the general idea of that code was to find the point of impact on the objects.  Compute the normal and reflect it. 

  Saved some time and got GPT to spit out some functions.. 

PlayBASIC Code: [Select]

   SetFPS 30

   // Ball properties
   BallRadius# = 20

    Ball1X# = 200
    Ball1Y# = 300

   // Moving Ball
   Ball1DX# = 100    // Movement vector X
   Ball1DY# = 100    // Movement vector Y

   // Stationary Ball
   Ball2X# = 500
   Ball2Y# = 300

   // Main Loop
   Do
       Cls
       
       Ball1X#=mousex()
       Ball1Y#=mousey()
    
       // Draw stationary ball
       Ink RGB(0, 255, 0)
       Circle Ball2X#, Ball2Y#, BallRadius#, 1
    
        // Draw moving ball
        Ink RGB(255, 0, 0)
       Circle Ball1X#, Ball1Y#, BallRadius#, 1
    
   // project the movement     
      dx#=    Ball1DX#     
      dy#=    Ball1DY#     
      x2#=  Ball1X# + dx#
      y2#=  Ball1Y# + dy#
        
    // Draw movement vector
       Ink RGB(255, 255, 0)
       Line Ball1X#, Ball1Y#, x2#,y2#
   
   //  Get the impact otin fo a potentional collision
      Hit,NewX#,NewY#=FirstImpactPoint(Ball1X#, Ball1Y#, DX#, DY#, Ball2X#, Ball2Y#, BallRadius#, BallRadius#)

       if Hit
            // Draw the impact point
             circle NewX#,NewY#, BallRadius#,false
             
             //  compute the impact point of 
            Angle#=getangle2d( Ball2X#, Ball2Y#, NewX#,NewY#)   
            ImpactX#=ball2x#+cos(angle#)* BallRadius#
            ImpactY#=ball2y#+sin(angle#)* BallRadius#

            // reflect it
            reflectx#,reflecty#=ComputeReflection(ImpactX#, ImpactY#, Ball2X#, Ball2Y#, DX#, DY#)

               
            linec ImpactX#,ImpactY#,reflectx#,reflecty#,$ff000
      endif
    
    Sync
   Loop




Function ComputeReflection(ImpactX#, ImpactY#, CircleX#, CircleY#, IncidentX#, IncidentY#)

    // Calculate Normal Vector
    NormalX# = ImpactX# - CircleX#
    NormalY# = ImpactY# - CircleY#
    
    // Normalize the Normal Vector
    NormalLength# = GetDistance2d(0,0,NormalX#,NormalY)
   
      If NormalLength# = 0 
        exitfunction IncidentX#, IncidentY# // Avoid division by zero
    EndIf
    NormalX# = NormalX# / NormalLength#
    NormalY# = NormalY# / NormalLength#
    
    // Dot Product of Incident Vector and Normal Vector
    DotProduct# = IncidentX# * NormalX# + IncidentY# * NormalY#
    
    // Reflection Vector Calculation
    ReflectionX# = IncidentX# - 2 * DotProduct# * NormalX#
    ReflectionY# = IncidentY# - 2 * DotProduct# * NormalY#
    
EndFunction ReflectionX#, ReflectionY#




// Function: FirstImpactPoint
// Calculates when and where a moving ball first impacts a stationary circle.
// Parameters:
//   BallX, BallY: Starting position of the moving ball
//   DX, DY: Movement vector of the ball
//   CircleX, CircleY: Position of the stationary circle
//   BallRadius, CircleRadius: Radii of the moving and stationary balls
// Returns:
//   ImpactX, ImpactY: Coordinates of the first impact point
//   ImpactDetected: Boolean (True if impact detected, False otherwise)

Function FirstImpactPoint(BallX#, BallY#, DX#, DY#, CircleX#, CircleY#, BallRadius#, CircleRadius#)
    // Relative position of ball to circle
    Local RelX# = BallX# - CircleX#
    Local RelY# = BallY# - CircleY#
    
    // Quadratic coefficients
    A# = DX# * DX# + DY# * DY#
    B# = 2 * (RelX# * DX# + RelY# * DY#)
    C# = (RelX# * RelX# + RelY# * RelY#) - ((BallRadius# + CircleRadius#) ^ 2)
    
    // Calculate the discriminant
    Discriminant# = B# * B# - (4 * A# * C#)
    
    // No collision if discriminant is negative
    If Discriminant# < 0
        exitfunction False, 0, 0
    EndIf
    
    // Calculate the two possible intersection times
    SqrtDisc# = Sqrt(Discriminant#)
    T1# = (-B# - SqrtDisc#) / (2 * A#)
    T2# = (-B# + SqrtDisc#) / (2 * A#)
    
    // Check valid collision time (0 = T = 1)
    If (T1# >= 0 And T1# <= 1)
        T# = T1#
    ElseIf (T2# >= 0 And T2# <= 1)
        T# = T2#
    Else
        exitfunction False, 0, 0
    EndIf
    
    // Calculate impact point
    ImpactX# = BallX# + DX# * T#
    ImpactY# = BallY# + DY# * T#
    
EndFunction True, ImpactX#, ImpactY#

 Keywords: Pool Balls, Collision, Reflect, Vector