Ooops
November 28, 2020, 10:49:54 AM

### Author Topic: [bmx] vectors part 4 by Jesse [ 1+ years ago ]  (Read 690 times)

#### BlitzBot

• Jr. Member
• Posts: 1
##### [bmx] vectors part 4 by Jesse [ 1+ years ago ]
« on: June 29, 2017, 12:28:38 AM »
Title : vectors part 4
Author : Jesse
Posted : 1+ years ago

Description : ball to wall collision including corners
based on tutorials by TonyPa:
<a href="http://tonypa.pri.ee/vectors/tut08.html" target="_blank">http://tonypa.pri.ee/vectors/tut08.html[/url]

Code :
Code: BlitzMax
1. '*************************************************************
2. '  author: Jesus Perez
3. ' created: 10/11/2010
4. ' based on tutorial Vectors for Flash by TonyPa
5. ' tutorial located at: http://tonypa.pri.ee/vectors/tut08.html
6. '*************************************************************
7.
8. SuperStrict
9. Type Tpoint
10.         Field x:Float
11.         Field y:Float
12. End Type
13.
14. Type Tvector
15.         Field p0:Tpoint
16.         Field p1:Tpoint
17.         Field vx:Float
18.         Field vy:Float
19.         Field vx1:Float
20.         Field vy1:Float
21.         Field vx2:Float
22.         Field vy2:Float
23.         Field length:Float
24.         Field dx:Float
25.         Field dy:Float
26.         Field rx:Float
27.         Field ry:Float
28.         Field lx:Float
29.         Field ly:Float
30.
31.         Field b:Float
32.         Field f:Float
33.
34.         Method New()
35.                 p0 = New Tpoint
36.                 p1 = New TPoint
37.         End Method
38.
39.
40. End Type
41.
42. Type Tball Extends Tvector
43.         Field r:Float
44.         Field m:Float
45.
46.         Function Create:Tball(x:Float,y:Float,x1:Float,y1:Float,r:Float,m:Float,bo:Float,f:Float)
47.                 Local b:Tball = New Tball
48.                 b.p0.x = x
49.                 b.p0.y = y
50.                 b.r = r
51.                 b.p1.x = x1
52.                 b.p1.y = y1
53.                 b.m = m
54.                 b.b = bo
55.                 b.f = f
56.                 updateVector(b,True)
57.                 Return b
58.
59.         End Function
60.
61. End Type
62.
63. Type TflatWall Extends Tvector
64.
65.         Function Create:TflatWall(x1:Float,y1:Float,x2:Float,y2:Float,b:Float,f:Float)
66.                 Local w:TflatWall = New TflatWall
67.
68.                 w.p0.x = x1
69.                 w.p0.y = y1
70.                 w.p1.x = x2
71.                 w.p1.y = y2
72.                 w.b = b
73.                 w.f = f
74.                 updateVector(w,True)
75.
76.                 Return w
77.         End Function
78.
79. End Type
80.
81.
82.
83. Type Tgame
84.         Field stageW:Float
85.         Field stageH:Float
86.         Field maxV:Float
87.         Field myOb:Tball
88.         Field flatWall:TFlatWall[4]
89.
90.         Field gravity:Float
91.         Field airf:Float
92.         Field lastTime:Float
93.         Field timeFrame:Float
94.         Field time:Float
95.
96.         Function Create:Tgame(w:Float,h:Float,mV:Float,gr:Float)
97.                 Local g:Tgame = New Tgame
98.                 g.stageW = w
99.                 g.stageH = h
100.                 g.maxV = mV ' max velocity
101.                 g.gravity = gr
102.                 g.airf = 1.0 ' value between 0 and 1. the smaller the more friction
103.                 g.myOb = Tball.Create(150,30,150+5,30-5,20,1,1,1)
104.                 g.flatWall[0] = TflatWall.Create(250, 100,  50, 100, 1, 1)
105.                 g.flatwall[1] = TflatWall.Create(250, 150, 250, 100, 1, 1)
106.                 g.flatwall[2] = TflatWall.Create( 50, 150, 250, 150, 1, 1)
107.                 g.flatwall[3] = TflatWall.Create( 50, 100,  50, 150, 1, 1)
108.                 'calculate all parameters For the wall vectors
109.                 g.lastTime = MilliSecs()
110.                 g.timeFrame = 1
111.                 Return g
112.         End Function
113.
114. End Type
115.
116. Graphics 300,180
117. 'Create game Object
118. Global game:Tgame = Tgame.Create(300, 180, 10,0)
119.
120. Repeat
121.         Cls
122.         runme()
123.         Flip()
124. Until KeyDown(key_escape)
125.
126. 'point p0 is its starting point in the coordinates x/y
127. 'Function To draw the points, lines And show text
128. Function drawAll()
129.         For Local w:TflatWall = EachIn game.flatwall
130.                 DrawLine w.p0.x,w.p0.y,w.p1.x,w.p1.y
131.         Next
132.         drawCircle(game.myOb.p0.x,game.myOb.p0.y,game.myOb.r)
133. End Function
134. 'Main Function
135. Function runMe()
136.
137.         'find time passed from last update
138.         Local thisTime:Float = MilliSecs()
139.         game.time = (thisTime-game.lastTime)/20
140.         If game.time
141.                 'start To calculate movement
142.                 Local ob:Tball = game.myOb
143.                 updateObject(ob)
145.                 ob.vx :* game.airf
146.                 ob.vy :* game.airf
147.                 'dont let it go over Max speed
148.                 If (ob.vx>game.maxV)
149.                         ob.vx = game.maxV
150.                 Else If (ob.vx<-game.maxV)
151.                         ob.vx = -game.maxV
152.                 EndIf
153.                 If (ob.vy>game.maxV)
154.                         ob.vy = game.maxV
155.                 Else If (ob.vy<-game.maxV)
156.                         ob.vy = -game.maxV
157.                 EndIf
158.                 'update the vector parameters
159.                 'check the walls For collisions
160.                 For Local w:TflatWall = EachIn game.flatWall
161.                         Local v:Tvector = findIntersection(ob, w)
162.                         updateVector(v, False)
163.                         Local pen:Float = ob.r-v.Length
164.                         'If we have hit the wall
165.                         If (pen>=0)
166.
167.                                 'move Object away from the wall
168.                                 ob.p1.x :+ v.dx*pen
169.                                 ob.p1.y :+ v.dy*pen
170.                                 'change movement, bounce off from the normal of v
171.                                 Local vbounce:Tvector = New tvector
172.                                 vbounce.dx = v.lx
173.                                 vbounce.dy = v.ly
174.                                 vbounce.lx = v.dx
175.                                 vbounce.ly = v.dy
176.                                 vbounce.b = 1
177.                                 vbounce.f = 1
178.                                 Local vb:Tvector = bounce(ob, vbounce)
179.                                 ob.vx = vb.vx
180.                                 ob.vy = vb.vy
181.                         EndIf
182.                 Next
183.                 'reset Object To other side If gone out of stage
184.                 If (ob.p1.x>game.stageW+ob.r)
185.                         ob.p1.x = -ob.r
186.                 ElseIf (ob.p1.x<-ob.r)
187.                         ob.p1.x = game.stageW+ob.r
188.                 EndIf
189.                 If (ob.p1.y>game.stageH+ob.r)
190.                         ob.p1.y = -ob.r
191.                 Else If (ob.p1.y<-ob.r)
192.                         ob.p1.y = game.stageH+ob.r
193.                 EndIf
194.                 'draw it
195.                 'make End point equal To starting point For Next cycle
196.                 ob.p0 = ob.p1
197.                 'save the movement without time
198.                 ob.vx :/ game.timeFrame
199.                 ob.vy :/ game.timeFrame
200.                 game.lastTime = thisTime
201.                 'save time passed
202.                 game.timeFrame = game.time
203.
204.         EndIf
205.         drawAll()
206.
207. End Function
208. 'Function To find all parameters For the vector
209. Function updateVector(v:Tvector, frompoints:Int)
210.
211.         'x And y components
212.         If (frompoints)
213.                 v.vx = v.p1.x-v.p0.x
214.                 v.vy = v.p1.y-v.p0.y
215.         Else
216.                 v.p1.x = v.p0.x+v.vx
217.                 v.p1.y = v.p0.y+v.vy
218.         EndIf
219.         'length of vector
220.         v.Length = Sqr(v.vx*v.vx+v.vy*v.vy)
221.         'normalized unti-sized components
222.         If (v.Length>0)
223.                 v.dx = v.vx/v.Length
224.                 v.dy = v.vy/v.Length
225.         Else
226.                 v.dx = 0
227.                 v.dy = 0
228.         EndIf
229.         'Right hand normal
230.         v.rx = -v.dy
231.         v.ry = v.dx
232.         'Left hand normal
233.         v.lx = v.dy
234.         v.ly = -v.dx
235. End Function
236.
237. Function updateObject:Int(v:Tball)
238.         'we use time, Not frames To move so multiply movement vector with time passed
239.         v.vx :* game.time
240.         v.vy :* game.time
241.         'Print game.time+" "+v.vx+" "+v.vy+" "+game.timeFrame
242.         'add gravity, also based on time
243.         v.vy = v.vy+game.time*game.gravity
244.         'find End point coordinates
245.         v.p1.x = v.p0.x+v.vx
246.         v.p1.y = v.p0.y+v.vy
247.         'length of vector
248.         v.Length = Sqr(v.vx*v.vx+v.vy*v.vy)
249.         If v.length > 0
250.         'normalized unti-sized components
251.                 v.dx = v.vx/v.Length
252.                 v.dy = v.vy/v.Length
253.         Else
254.                 v.dx = 0
255.                 v.dy = 0
256.         EndIf
257.         'Right hand normal
258.         v.rx = -v.vy
259.         v.ry = v.vx
260.         'Left hand normal
261.         v.lx = v.vy
262.         v.ly = -v.vx
263. End Function
264. 'find intersection point of 2 vectors
265. Function findIntersection:Tvector(v1:Tvector, v2:Tvector)
266.         'vector between center of ball And starting point of wall
267.         Local v:Tvector
268.         Local v3:Tvector = New Tvector
269.         v3.vx = v1.p1.x-v2.p0.x
270.         v3.vy = v1.p1.y-v2.p0.y
271.         'check If we have hit starting point
272.         Local dp:Float = v3.vx*v2.dx+v3.vy*v2.dy
273.         If (dp<0)
274.                 'hits starting point
275.                  v = v3
276.         Else
277.                 Local v4:Tvector = New Tvector
278.                 v4.vx = v1.p1.x-v2.p1.x
279.                 v4.vy = v1.p1.y-v2.p1.y
280.                 'check If we have hit side Or endpoint
281.                 Local dp:Float = v4.vx*v2.dx+v4.vy*v2.dy
282.                 If (dp>0)
283.                         'hits ending point
284.                         v = v4
285.                 Else
286.                         'it hits the wall
287.                         'project this vector on the normal of the wall
288.                         v = projectVector(v3, v2.lx, v2.ly)
289.                 EndIf
290.         EndIf
291.         Return v
292. End Function
293. 'find New vector bouncing from v2
294. Function bounce:Tvector(v1:Tvector, v2:Tvector)
295.         'projection of v1 on v2
296.         Local proj1:Tvector = projectVector(v1, v2.dx, v2.dy)
297.         'projection of v1 on v2 normal
298.         Local proj2:Tvector = projectVector(v1, v2.lx, v2.ly)
299.         Local proj:Tvector = New Tvector
300.         'reverse projection on v2 normal
301.         proj2.Length = Sqr(proj2.vx*proj2.vx+proj2.vy*proj2.vy)
302.         proj2.vx = v2.lx*proj2.Length
303.         proj2.vy = v2.ly*proj2.Length
305.         proj.vx = v1.f*v2.f*proj1.vx+v1.b*v2.b*proj2.vx
306.         proj.vy = v1.f*v2.f*proj1.vy+v1.b*v2.b*proj2.vy
307.         Return proj
308. End Function
309. 'project vector v1 on unit-sized vector dx/dy
310. Function projectVector:Tvector(v1:Tvector, dx:Float, dy:Float)
311.         'find dot product
312.         Local dp:Float = v1.vx*dx+v1.vy*dy
313.         Local proj:tvector = New Tvector
314.         'projection components
315.         proj.vx = dp*dx
316.         proj.vy = dp*dy
317.         Return proj
318. End Function
319.
320.
321. Function drawcircle(x:Float,y:Float,r:Float)
322.         For Local a:Float = 0 Until 360
323.                 Local vx:Float = Cos(a)*r
324.                 Local vy:Float = Sin(a)*r
325.                 Plot x+vx,y+vy
326.         Next
327. End Function