November 30, 2020, 02:39:48 AM

### Author Topic: [bb] 2D Ball Collisions by UnderwoodNullium [ 1+ years ago ]  (Read 1556 times)

#### BlitzBot

• Jr. Member
• Posts: 1
##### [bb] 2D Ball Collisions by UnderwoodNullium [ 1+ years ago ]
« on: June 29, 2017, 12:28:43 AM »
Title : 2D Ball Collisions
Author : UnderwoodNullium
Posted : 1+ years ago

Description : A while ago I found some code using vectors for pool ball collisions, I'm not sure who's it was... here's a smaller version...

Code :
Code: BlitzBasic
1. '-------------------------------------------------------------------
2. ' Initialization
3. '-------------------------------------------------------------------
4.
5.
6.
7.
8.
9. ' Initialize
10.
11.
12.         Graphics(1024,768,32)
13.         SeedRnd MilliSecs()
14.         AutoMidHandle(1)
15.         SetBlend(3)
16.
17.
18.
19. ' Types
20.
21.         Type ball
22.                 Field x#
23.                 Field y#
24.                 Field vx#
25.                 Field vy#
26.                 Field friction#
27.                 Field mass#
29.                 Field kind%
30.         End Type
31.
32.         Global balllist:TList = CreateList()
33.
34.
35.
36.
37.         Global GRAVITY# = .098
38.
39.
40.
41.
42.
43.
44.         For Local loop = 0 To 50
45.                 CreateBall(0,Rand(0,1024),Rand(0,768),Rnd(-5,5),Rnd(-5,5),1,0.001,10)
46.         Next
47.
48.
49.
50.
51.
52.         While Not KeyHit(key_escape)
53.         Cls
54.
55.                 UpdateBalls()
56.
57.         Flip
58.         Wend
59.         End
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72. ' Functions
73.
75.
76.                 Local b:ball = New ball
77.                         b.kind     = kind
78.                         b.x        = x
79.                         b.y        = y
80.                         b.vx       = vx
81.                         b.vy       = vy
82.                         b.friction = friction
83.                         b.mass     = mass
86.
87.         End Function
88.
89.
90.
91.         Function UpdateBalls()
92.
93.                 For Local b:ball = EachIn balllist
94.
95.                                 b.vx = (b.vx * b.friction)                                                      ' Update velocities (with gravity and friction)
96.                                 b.vy = ((b.vy + GRAVITY) * b.friction)
97.
98.                                         If b.kind <> 0
99.                                                 b.vx = 0
100.                                                 b.vy = 0
101.                                         EndIf
102.
103.                                 b.x = (b.x + b.vx)                                                              ' Update positions
104.                                 b.y = (b.y + b.vy)
105.
106.                                 If b.x + b.radius < 0
107.                                         b.vx = -(b.vx)
108.                                 EndIf
109.
110.                                 If b.x > GraphicsWidth() - b.radius
111.                                         b.vx = -(b.vx)
112.                                         b.x  = GraphicsWidth() - b.radius
113.                                 EndIf
114.
115.                                 If b.y + b.radius < 0
116.                                         b.vy = -(b.vy)
117.                                 EndIf
118.
119.                                 If b.y > GraphicsHeight() - b.radius
120.                                         b.vy = -(b.vy)
121.                                         b.y  = GraphicsHeight() - b.radius
122.                                 EndIf
123.
124.                                         For Local b2:ball = EachIn balllist
125.
126.                                                 Local collisiondistance# = (b.radius + b2.radius)
127.                                                 Local actualdistance#    = GetDistance(b.x,b.y,b2.x,b2.y)
128.
129.                                                         If actualdistance < collisiondistance
130.
131.                                                                 Local normal#    = ATan2((b2.y - b.y),(b2.x - b.x))
132.                                                                 Local movedist1# = ((collisiondistance - actualdistance) * (b2.mass / Float((b.mass + b2.mass))))
133.                                                                 Local movedist2# = ((collisiondistance - actualdistance) * (b.mass / Float((b.mass + b2.mass))))
134.
135.                                                                 b.x  = (b.x + (movedist1 * Cos(normal + 180)))                  ' position them to 'not touching'
136.                                                                 b.y  = (b.y + (movedist1 * Sin(normal + 180)))
137.                                                                 b2.x = (b2.x + (movedist2 * Cos(normal)))
138.                                                                 b2.y = (b2.y + (movedist2 * Sin(normal)))
139.
140.                                                                 Local nx# = Cos(normal)                                                 ' find components of normalized vector
141.                                                                 Local ny# = Sin(normal)
142.
143.                                                                 Local a1# = ((b.vx * nx) + (b.vy * ny))                         ' find length using dot product
144.                                                                 Local a2# = ((b2.vx * nx) + (b2.vy * ny))
145.
146.                                                                 Local opt# = ((2.0 * (a1 - a2)) / (b.mass + b2.mass))
147.
148.                                                                         b.vx  = (b.vx - (opt * b2.mass * nx))
149.                                                                         b.vy  = (b.vy - (opt * b2.mass * ny))
150.                                                                         b2.vx = (b2.vx + (opt * b.mass * nx))
151.                                                                         b2.vy = (b2.vy + (opt * b.mass * ny))
152.                                                         EndIf
153.
154.                                         Next
155.
156.                         DrawOval(b.x - b.radius / 2,b.y - b.radius / 2,b.radius * 2,b.radius * 2)
157.
158.                 Next
159.
160.         End Function
161.
162.
163.
164.         Function GetDistance:Float(x1#,y1#,x2#,y2#)
165.
166.                 Return(Sqr(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1))))
167.
168.         End Function