Simple Pool Game in QBasic

[justsomeguy]

Hello

I wrote a simple pool game in QB using my physics engine. The game has no real rules just hit the balls in to the pockets. The instructions on how to play are visible when you start.

Since pool is inherently a 3D game, and my physics engine is 2D only. I do have not real good way to simulate full 'English' on the cue ball, so it only has left and right spin as of now. To help atone for that, I have provided the <TAB> key to help you predict your shots.

While doing these exercises I'm slowly improving the engine and making it more robust. This for example I learned how to "see into the future." Slowly progress is being made on commenting it, and making it easier for other to use in their projects. One day maybe even actual documentation.

I apologize for putting it into a zip file. Its the only good way to keep the directory structure with the assets. All assets are CC0 public domain. Also, for some reason the 13 ball is solid. ¯\_(ツ)_/¯

I would love to hear your feedback good or bad, and any suggestions to help make it more accessible and easier to use in your projects.

If you just want to look over the code. (Note: it will need the provided assets to run.)

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. '$dynamic
3. '**********************************************************************************************
4. '   FzxNGN written by justsomeguy
5. '   Physics code ported from RandyGaul's Impulse Engine
6. '   https://github.com/RandyGaul/ImpulseEngine
7. '   http://RandyGaul.net
8. '**********************************************************************************************
9. '/*
10. '    Copyright (c) 2013 Randy Gaul http://RandyGaul.net
11.  
12. '    This software is provided 'as-is', without any express or implied
13. '    warranty. In no event will the authors be held liable for any damages
14. '    arising from the use of this software.
15.  
16. '    Permission is granted to anyone to use this software for any purpose,
17. '    including commercial applications, and to alter it and redistribute it
18. '    freely, subject to the following restrictions:
19. '      1. The origin of this software must not be misrepresented; you must not
20. '         claim that you wrote the original software. If you use this software
21. '         in a product, an acknowledgment in the product documentation would be
22. '         appreciated but is not required.
23. '      2. Altered source versions must be plainly marked as such, and must not be
24. '         misrepresented as being the original software.
25. '      3. This notice may not be removed or altered from any source distribution.
26. '
27. '    Port to QB64 by justsomeguy
28. '*/
29. '
30.  
31. '**********************************************************************************************
32. '   Setup Types and Variables
33. '**********************************************************************************************
34. TYPE tVECTOR2d
35.     x AS _FLOAT
36.     y AS _FLOAT
37. END TYPE
38.  
39. TYPE tLINE2d ' Not used
40.     a AS tVECTOR2d
41.     b AS tVECTOR2d
42. END TYPE
43.  
44. TYPE tFACE2d ' Not used
45.     f0 AS tVECTOR2d
46.     f1 AS tVECTOR2d
47. END TYPE
48.  
49. TYPE tTRIANGLE ' Not used
50.     a AS tVECTOR2d
51.     b AS tVECTOR2d
52.     c AS tVECTOR2d
53. END TYPE
54.  
55. TYPE tMATRIX2d
56.     m00 AS _FLOAT
57.     m01 AS _FLOAT
58.     m10 AS _FLOAT
59.     m11 AS _FLOAT
60. END TYPE
61.  
62. TYPE tSHAPE
63.     ty AS INTEGER ' cSHAPE_CIRCLE = 1, cSHAPE_POLYGON = 2
64.     radius AS _FLOAT ' Only necessary for circle shapes
65.     u AS tMATRIX2d ' Only necessary for polygons
66.     texture AS LONG
67.     flipTexture AS INTEGER 'flag for flipping texture depending on direction
68.     scaleTextureX AS _FLOAT
69.     scaleTextureY AS _FLOAT
70.     offsetTextureX AS _FLOAT
71.     offsetTextureY AS _FLOAT
72. END TYPE
73.  
74. TYPE tPOLY 'list of vertices for all objects in simulation
75.     vert AS tVECTOR2d
76.     norm AS tVECTOR2d
77. END TYPE
78.  
79. TYPE tPOLYATTRIB 'keep track of polys in monlithic list of vertices
80.     start AS INTEGER ' starting vertex of the polygon
81.     count AS INTEGER ' number of vertices in polygon
82. END TYPE
83.  
84. TYPE tBODY
85.     objectName AS STRING * 64
86.     objectHash AS _INTEGER64
87.     position AS tVECTOR2d
88.     velocity AS tVECTOR2d
89.     force AS tVECTOR2d
90.     angularVelocity AS _FLOAT
91.     torque AS _FLOAT
92.     orient AS _FLOAT
93.     mass AS _FLOAT
94.     invMass AS _FLOAT
95.     inertia AS _FLOAT
96.     invInertia AS _FLOAT
97.     staticFriction AS _FLOAT
98.     dynamicFriction AS _FLOAT
99.     restitution AS _FLOAT
100.     shape AS tSHAPE
101.     pa AS tPOLYATTRIB
102.     c AS LONG ' color
103.     enable AS INTEGER 'Hide a body ;)
104.     collisionMask AS _UNSIGNED INTEGER
105. END TYPE
106.  
107. TYPE tMANIFOLD
108.     A AS INTEGER
109.     B AS INTEGER
110.     penetration AS _FLOAT
111.     normal AS tVECTOR2d
112.     contactCount AS INTEGER
113.     e AS _FLOAT
114.     df AS _FLOAT
115.     sf AS _FLOAT
116.     cv AS _FLOAT 'contact velocity
117. END TYPE
118.  
119. TYPE tHIT
120.     A AS INTEGER
121.     B AS INTEGER
122.     position AS tVECTOR2d
123.     cv AS _FLOAT
124. END TYPE
125.  
126. TYPE tJOINT
127.     jointName AS STRING * 64
128.     jointHash AS _INTEGER64
129.     M AS tMATRIX2d
130.     localAnchor1 AS tVECTOR2d
131.     localAnchor2 AS tVECTOR2d
132.     r1 AS tVECTOR2d
133.     r2 AS tVECTOR2d
134.     bias AS tVECTOR2d
135.     P AS tVECTOR2d
136.     body1 AS INTEGER
137.     body2 AS INTEGER
138.     biasFactor AS _FLOAT
139.     softness AS _FLOAT
140. END TYPE
141.  
142. TYPE tCAMERA
143.     position AS tVECTOR2d
144.     zoom AS _FLOAT
145. END TYPE
146.  
147. TYPE tWORLD
148.     plusLimit AS tVECTOR2d
149.     minusLimit AS tVECTOR2d
150.     gravity AS tVECTOR2d
151.     spawn AS tVECTOR2d
152.     terrainPosition AS tVECTOR2d
153. END TYPE
154.  
155. TYPE tVEHICLE
156.     vehicleName AS STRING * 64
157.     vehicleHash AS _INTEGER64
158.     body AS INTEGER
159.     wheelOne AS INTEGER
160.     wheelTwo AS INTEGER
161.     axleJointOne AS INTEGER
162.     axleJointTwo AS INTEGER
163.     auxBodyOne AS INTEGER
164.     auxJointOne AS INTEGER
165.     wheelOneOffset AS tVECTOR2d
166.     wheelTwoOffset AS tVECTOR2d
167.     auxOneOffset AS tVECTOR2d
168.     torque AS _FLOAT
169. END TYPE
170.  
171. TYPE tOBJECTMANAGER
172.     objectCount AS INTEGER
173.     jointCount AS INTEGER
174. END TYPE
175.  
176. TYPE tINPUTDEVICE
177.     x AS INTEGER
178.     y AS INTEGER
179.     b1 AS INTEGER
180.     lb1 AS INTEGER
181.     b2 AS INTEGER
182.     lb2 AS INTEGER
183.     b3 AS INTEGER
184.     lb3 AS INTEGER
185.     w AS INTEGER
186.     wCount AS INTEGER
187.     keyHit AS LONG
188.     lastKeyHit AS LONG
189. END TYPE
190.  
191. CONST cSHAPE_CIRCLE = 1
192. CONST cSHAPE_POLYGON = 2
193. CONST cPRECISION = 100
194. CONST cMAXNUMOFTRIANGLES = 100
195. CONST cMAXNUMBEROFOBJECTS = 1000 ' Max number of objects at one time
196. CONST cMAXNUMBEROFPOLYGONS = 10000 ' Max number of total vertices included in all objects
197. CONST cMAXNUMBEROFJOINTS = 100
198. CONST cMAXNUMBEROFHITS = 10000
199. CONST cPI = 3.14159
200. CONST cEPSILON = 0.0001
201. CONST cEPSILON_SQ = cEPSILON * cEPSILON
202. CONST cBIAS_RELATIVE = 0.95
203. CONST cBIAS_ABSOLUTE = 0.01
204. CONST cDT = 1.0 / 120.0
205. CONST cITERATIONS = 100
206. CONST cPENETRATION_ALLOWANCE = 0.05
207. CONST cPENETRATION_CORRECTION = 0.4 ' misspelled in original code
208. CONST cGLOBAL_FRICTION = .992
209. CONST cPARAMETER_POSITION = 1
210. CONST cPARAMETER_VELOCITY = 2
211. CONST cPARAMETER_FORCE = 3
212. CONST cPARAMETER_ANGULARVELOCITY = 4
213. CONST cPARAMETER_TORQUE = 5
214. CONST cPARAMETER_ORIENT = 6
215. CONST cPARAMETER_STATICFRICTION = 7
216. CONST cPARAMETER_DYNAMICFRICTION = 8
217. CONST cPARAMETER_RESTITUTION = 9
218. CONST cPARAMETER_COLOR = 10
219. CONST cPARAMETER_ENABLE = 11
220. CONST cPARAMETER_STATIC = 12
221. CONST cPARAMETER_TEXTURE = 13
222. CONST cPARAMETER_FLIPTEXTURE = 14
223. CONST cPARAMETER_COLLISIONMASK = 15
224. CONST cRENDER_JOINTS = 0
225. CONST cRENDER_COLLISIONS = 0
226. CONST cPLAYER_FORCE = 600000
227.  
228. DIM SHARED sRESTING AS _FLOAT
229. DIM SHARED sNUMBEROFBODIES AS INTEGER: sNUMBEROFBODIES = 10 ' 0 is included
230. DIM SHARED sNUMBEROFJOINTS AS INTEGER: sNUMBEROFJOINTS = 3 ' if zero then no joints at all
231. DIM SHARED sNUMBEROFVEHICLES AS INTEGER: sNUMBEROFVEHICLES = 1
232. DIM SHARED sTIMER AS LONG: sTIMER = TIMER
233.  
234. DIM poly(cMAXNUMBEROFPOLYGONS) AS tPOLY
235. DIM body(sNUMBEROFBODIES) AS tBODY
236. DIM joints(cMAXNUMBEROFJOINTS) AS tJOINT
237. DIM hits(cMAXNUMBEROFHITS) AS tHIT
238. DIM veh(sNUMBEROFVEHICLES) AS tVEHICLE
239. DIM camera AS tCAMERA
240. DIM inputDevice AS tINPUTDEVICE
241.  
242.  
243. DIM texture(100) AS LONG
244.  
245. TYPE tPOOL
246.     status AS INTEGER
247.     rackposition AS tVECTOR2d
248.     objId AS _INTEGER64
249. END TYPE
250. TYPE tGENPOOL
251.     instructions AS INTEGER
252.     instructionImage AS LONG
253.     mode AS INTEGER
254.     english AS tVECTOR2d
255. END TYPE
256. TYPE tSENSORS
257.     objId AS _INTEGER64
258. END TYPE
259.  
260.  
261. DIM timerOne AS INTEGER
262. DIM SHARED fps AS INTEGER
263. DIM SHARED fpsLast AS INTEGER
264. DIM SHARED world AS tWORLD
265. DIM SHARED objectManager AS tOBJECTMANAGER
266. DIM SHARED pool(17) AS tPOOL
267. DIM SHARED genPool AS tGENPOOL
268. DIM SHARED poolSensors(10) AS tSENSORS
269.  
270.  
271. '**********************************************************************************************
272. _TITLE "FzxNGN POOL"
273. SCREEN _NEWIMAGE(1024, 768, 32)
274. timerOne = _FREETIMER
275. ON TIMER(timerOne, 1) renderFps
276. TIMER(timerOne) ON
277. camera.zoom = .25
278. 'RANDOMIZE TIMER
279. CALL buildSimpleScene(poly(), body(), joints(), texture(), veh())
280. '**********************************************************************************************
281. _PRINTMODE _KEEPBACKGROUND
282. DO: fps = fps + 1
283.     CLS , _RGB32(67, 39, 0)
284.     LOCATE 1, 55: PRINT "FPS:"; (fpsLast)
285.  
286.     CALL renderBodies(poly(), body(), joints(), hits(), camera)
287.     CALL animateScene(poly(), body(), joints(), hits(), texture(), camera, veh(), inputDevice)
288.     CALL impulseStep(poly(), body(), joints(), hits(), cDT, cITERATIONS)
289.  
290.     _DISPLAY
291.     _LIMIT 120
292. LOOP UNTIL _KEYHIT = 27
293. SYSTEM
294. '**********************************************************************************************
295. '   End of Main loop
296. '**********************************************************************************************
297.  
298.  
299. '**********************************************************************************************
300. '   Scene Creation and Handling Ahead
301. '**********************************************************************************************
302. SUB animateScene (poly() AS tPOLY, body() AS tBODY, joints() AS tJOINT, hits() AS tHIT, textureMap() AS LONG, camera AS tCAMERA, veh() AS tVEHICLE, iDevice AS tINPUTDEVICE)
303.     ' Cache some widely used ID's
304.     DIM cueBall AS _INTEGER64: cueBall = objectManagerID(body(), "cSCENE_BALL16")
305.     DIM cue AS _INTEGER64: cue = objectManagerID(body(), "cSCENE_CUE")
306.  
307.     DIM AS INTEGER index, ballCount
308.     DIM AS _FLOAT cueAngle, cueDistance, cueDrawingDistance
309.     DIM AS tVECTOR2d cueNormal, cuePos, cueBall2Camera, cuePower, mousePosVector
310.     DIM guideLine AS tLINE2d
311.     DIM AS LONG ghostImg
312.  
313.     ' Ignore this
314.     veh(0).vehicleName = "Nothing" 'this is just to clear the warnings
315.  
316.     ' Mouse and keyboard handling, mainly mouse, keyboard is too slow for indirect
317.     CALL handleInputDevice(iDevice)
318.     ' Change cueball to camera coordinate system.
319.     CALL worldToCamera(body(), camera, cueBall, cueBall2Camera)
320.     CALL vectorSet(mousePosVector, iDevice.x, iDevice.y)
321.  
322.     ' Some Maths
323.     cueNormal.x = cueBall2Camera.x - iDevice.x ' x-Component of Distance
324.     cueNormal.y = cueBall2Camera.y - iDevice.y ' y-Component of Distance
325.     cueAngle = _ATAN2(-cueNormal.y, -cueNormal.x) ' Use mouse to control the cue angle
326.     cueDistance = vectorDistance(mousePosVector, cueBall2Camera)
327.     cueDrawingDistance = (cueDistance * .25) + 450 ' Use this to guage power
328.     cuePos.x = COS(cueAngle) * cueDrawingDistance + body(cueBall).position.x ' Use these to calculate cue position
329.     cuePos.y = SIN(cueAngle) * cueDrawingDistance + body(cueBall).position.y
330.     cuePower.x = cueNormal.x * cPLAYER_FORCE
331.     cuePower.y = cueNormal.y * cPLAYER_FORCE
332.  
333.     guideLine.a.x = COS(cueAngle + _PI) * (25 * camera.zoom) + cueBall2Camera.x
334.     guideLine.a.y = SIN(cueAngle + _PI) * (25 * camera.zoom) + cueBall2Camera.y
335.     guideLine.b.x = COS(cueAngle + _PI) * (1000 * camera.zoom) + cueBall2Camera.x
336.     guideLine.b.y = SIN(cueAngle + _PI) * (1000 * camera.zoom) + cueBall2Camera.y
337.  
338.     ' Aim the Stick
339.     IF bodyAtRest(body(cueBall)) THEN ' AIM
340.         CALL setBody(body(), cPARAMETER_ENABLE, cue, 1, 0)
341.         CALL setBody(body(), cPARAMETER_ORIENT, cue, cueAngle, 0)
342.         CALL setBody(body(), cPARAMETER_POSITION, cue, cuePos.x, cuePos.y)
343.         LINE (guideLine.a.x, guideLine.a.y)-(guideLine.b.x, guideLine.b.y)
344.         camera.position = body(cueBall).position
345.     ELSE
346.         CALL setBody(body(), cPARAMETER_ENABLE, cue, 0, 0)
347.     END IF
348.  
349.     ' Camera Zoom
350.     camera.zoom = camera.zoom + (iDevice.wCount * .01): iDevice.wCount = 0
351.     IF camera.zoom < .125 THEN camera.zoom = .125
352.  
353.     ' Hit the ball
354.     ' Verify cue ball is not moving - I really need to check that all balls are not moving.
355.     IF bodyAtRest(body(cueBall)) THEN
356.         IF iDevice.lb1 = -1 AND iDevice.b1 = 0 THEN ' only fire once
357.             'Apply hitting Force and English
358.             CALL setBody(body(), cPARAMETER_FORCE, cueBall, cuePower.x, cuePower.y)
359.             CALL setBody(body(), cPARAMETER_ANGULARVELOCITY, cueBall, genPool.english.x, 0)
360.             ' Reset English
361.             genPool.english.x = 0
362.             genPool.english.y = 0
363.         END IF
364.     END IF
365.  
366.     IF _KEYDOWN(19200) THEN ' Left English
367.         genPool.english.x = genPool.english.x + 1
368.         IF genPool.english.x > 200 THEN genPool.english.x = 200
369.     END IF
370.  
371.     IF _KEYDOWN(19712) THEN ' Right English
372.         genPool.english.x = genPool.english.x - 1
373.         IF genPool.english.x < -200 THEN genPool.english.x = -200
374.     END IF
375.  
376.     ' Instruction GUI
377.     IF _KEYDOWN(ASC("I")) OR _KEYDOWN(ASC("i")) THEN ' Show instructions
378.         genPool.instructionImage = _COPYIMAGE(textureMap(22))
379.         genPool.instructions = 1
380.         sTIMER = TIMER
381.     END IF
382.     IF TIMER - sTIMER > 20 THEN genPool.instructions = 0 ' instruction timeout 20 sec
383.     IF genPool.instructions THEN
384.         genPool.instructionImage = _COPYIMAGE(textureMap(22))
385.         IF TIMER - sTIMER > 15 THEN 'After 15 seconds fade it out
386.             _SETALPHA INT((20 - (TIMER - sTIMER)) * 50), _RGB(255, 255, 255), genPool.instructionImage
387.         END IF
388.         _PUTIMAGE (0, 0), genPool.instructionImage, 0 ' INSTRUCTIONS
389.         _FREEIMAGE genPool.instructionImage
390.     END IF
391.  
392.     IF _KEYDOWN(ASC("R")) OR _KEYDOWN(ASC("r")) THEN ' ReRack balls
393.         ' Put all balls back in their rack positions
394.         CALL reRackBalls(body())
395.     END IF
396.  
397.     IF _KEYDOWN(32) THEN ' Spacebar  - For break
398.         ' Verify cue ball is not moving - I really need to check that all balls are not moving.
399.         IF bodyAtRest(body(cueBall)) THEN
400.             CALL setBody(body(), cPARAMETER_ANGULARVELOCITY, cueBall, genPool.english.x, 0)
401.             CALL setBody(body(), cPARAMETER_FORCE, cueBall, cuePower.x * 2, cuePower.y * 2)
402.             genPool.english.x = 0
403.             genPool.english.y = 0
404.         END IF
405.     END IF
406.  
407.     ' Check your shot feature
408.     IF _KEYDOWN(9) AND bodyAtRest(body(cueBall)) THEN 'TAB - LOOK ahead
409.         DIM ghostBody(UBOUND(body)) AS tBODY ' Create a new list of bodies
410.         CALL copyBodies(body(), ghostBody()) ' Copy all the bodies to the new list
411.         ' Apply Forces to the Cue Ball in the Bodies
412.         CALL setBody(ghostBody(), cPARAMETER_FORCE, cueBall, cuePower.x, cuePower.y)
413.         CALL setBody(ghostBody(), cPARAMETER_ANGULARVELOCITY, cueBall, genPool.english.x, 0)
414.         ' Create a Ghost Image Overlay
415.         ghostImg = _NEWIMAGE(_WIDTH(0), _HEIGHT(0), 32)
416.         _DEST ghostImg
417.         _SETALPHA 127, 0 TO 255, ghostImg
418.         ' Hide the table since we only car abou the balls
419.         CALL setBodyEx(ghostBody(), cPARAMETER_ENABLE, "cSCENE_TABLE", 0, 0)
420.         ' Run Simulation for about 2 secs
421.         FOR index = 0 TO 240 ' number of frames for look ahead .. 240 / 120 fps = 2 sec
422.             CALL impulseStep(poly(), ghostBody(), joints(), hits(), cDT, cITERATIONS)
423.             CALL handlePocketSensors(ghostBody(), hits(), cueBall)
424.             CALL renderBodies(poly(), ghostBody(), joints(), hits(), camera)
425.         NEXT
426.         ' Return Screen to normal
427.         _DEST 0
428.         ' Display overlay
429.         _PUTIMAGE (0, 0), ghostImg, 0
430.         _DISPLAY
431.         ' Free up overlay
432.         _FREEIMAGE ghostImg
433.     END IF
434.  
435.     ballCount = 0
436.     FOR index = 1 TO 16 'Make balls roll across ball return
437.         ' check if balls are off the table and then give it "gravity"
438.         IF body(pool(index).objId).position.y > 750 THEN
439.             CALL setBody(body(), cPARAMETER_FORCE, pool(index).objId, 200000, 100000)
440.             ballCount = ballCount + 1
441.         END IF
442.         ' rerack table if all the balls are in the ball return
443.         IF ballCount > 14 AND bodyAtRest(body(cueBall)) THEN CALL reRackBalls(body())
444.     NEXT
445.  
446.     ' Show english Indicator - Only Left and Right are supported
447.     _PUTIMAGE (0, _HEIGHT(0) - 140), textureMap(16), 0,
448.     CIRCLE (70 - genPool.english.x / 4, _HEIGHT(0) - 70), 10, _RGB(72, 111, 183)
449.  
450.  
451.     CALL handlePocketSensors(body(), hits(), cueBall)
452.     CALL cleanUpInputDevice(iDevice)
453. END SUB
454.  
455. SUB handlePocketSensors (body() AS tBODY, hits() AS tHIT, cueBallId AS _INTEGER64)
456.     DIM AS LONG index, ballId
457.     FOR index = 0 TO 5 ' check if ball has been pocketed
458.         ballId = isBodyTouching(hits(), poolSensors(index).objId)
459.         IF ballId > 0 THEN
460.             IF ballId = cueBallId THEN
461.                 body(ballId).position = pool(16).rackposition ' Move to break position
462.             ELSE
463.                 body(ballId).position = pool(17).rackposition ' Move to ball return
464.             END IF
465.             CALL bodyStop(body(ballId))
466.         END IF
467.     NEXT
468. END SUB
469.  
470. SUB reRackBalls (body() AS tBODY)
471.     DIM AS INTEGER index
472.     FOR index = 1 TO 16
473.         body(pool(index).objId).position = pool(index).rackposition
474.         CALL bodyStop(body(pool(index).objId))
475.     NEXT
476. END SUB
477.  
478. SUB handleInputDevice (iDevice AS tINPUTDEVICE)
479.     ' iDevice.keyHit = _KEYHIT ' --- THIS IS TOO SLOW
480.     DO WHILE _MOUSEINPUT
481.         iDevice.x = _MOUSEX
482.         iDevice.y = _MOUSEY
483.         iDevice.b1 = _MOUSEBUTTON(1)
484.         iDevice.b2 = _MOUSEBUTTON(2)
485.         iDevice.b3 = _MOUSEBUTTON(3)
486.         iDevice.w = _MOUSEWHEEL
487.         iDevice.wCount = iDevice.wCount + iDevice.w
488.     LOOP
489. END SUB
490.  
491. SUB cleanUpInputDevice (iDevice AS tINPUTDEVICE)
492.     iDevice.lb1 = iDevice.b1
493.     iDevice.lb2 = iDevice.b2
494.     iDevice.lb3 = iDevice.b3
495.     iDevice.lastKeyHit = iDevice.keyHit
496. END SUB
497.  
498. FUNCTION bodyAtRest (body AS tBODY)
499.     bodyAtRest = (body.velocity.x < 1 AND body.velocity.x > -1 AND body.velocity.y < 1 AND body.velocity.y > -1)
500. END FUNCTION
501.  
502. SUB copyBodies (body() AS tBODY, newBody() AS tBODY)
503.     DIM AS LONG index
504.     FOR index = 0 TO UBOUND(body)
505.         newBody(index) = body(index)
506.     NEXT
507. END SUB
508.  
509. SUB buildSimpleScene (p() AS tPOLY, body() AS tBODY, j() AS tJOINT, textureMap() AS LONG, v() AS tVEHICLE)
510.     DIM AS INTEGER trans, index, ballSize
511.     DIM AS LONG iD
512.     DIM b AS STRING
513.     DIM AS _FLOAT bumperRestitution, bumperSF, bumperDF
514.  
515.     trans = 0 ' Adjust <0-255> to see the hidden rail bodies
516.     ballSize = 36
517.     bumperRestitution = .5
518.     bumperSF = .01 '.5
519.     bumperDF = .01 '.3
520.     j(0).jointName = "Nothing" ' this is just to clear the warning and does nothing
521.     v(0).vehicleName = "Nothing" ' Clear Warning
522.     CALL loadBitmap(textureMap())
523.  
524.     '********************************************************
525.     '   Setup World
526.     '********************************************************
527.  
528.     CALL vectorSet(world.minusLimit, -6500, -2000)
529.     CALL vectorSet(world.plusLimit, 70000, 10000)
530.     CALL vectorSet(world.spawn, -5000, -800)
531.     CALL vectorSet(world.gravity, 0.0, 0.0)
532.     CALL vectorSet(world.terrainPosition, -7000.0, 1000.0)
533.     DIM o AS tVECTOR2d: CALL vectorMultiplyScalarND(o, world.gravity, cDT): sRESTING = vectorLengthSq(o) + cEPSILON
534.  
535.     '********************************************************
536.     '   Build Table
537.     '********************************************************
538.  
539.  
540.     iD = createBoxBodiesEx(p(), body(), "cSCENE_TABLE", 1000, 600)
541.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_TABLE", 0, 0)
542.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_TABLE", 0, 0)
543.     CALL setBodyEx(body(), cPARAMETER_COLLISIONMASK, "cSCENE_TABLE", 0, 0)
544.     CALL setBodyEx(body(), cPARAMETER_TEXTURE, "cSCENE_TABLE", textureMap(19), 0)
545.  
546.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BALLRETURN", 600, 100)
547.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BALLRETURN", 0, 0)
548.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BALLRETURN", 0, 800)
549.     CALL setBodyEx(body(), cPARAMETER_COLLISIONMASK, "cSCENE_BALLRETURN", 0, 0)
550.     CALL setBodyEx(body(), cPARAMETER_TEXTURE, "cSCENE_BALLRETURN", textureMap(21), 0)
551.  
552.  
553.     '********************************************************
554.     '   Build Bumpers
555.     '********************************************************
556.  
557.     ' These are hidden using transparent colors
558.  
559.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BUMPER1", 370, 100)
560.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BUMPER1", 0, 0)
561.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BUMPER1", -445, -565)
562.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BUMPER1", _RGBA32(0, 0, 255, trans), 0) ' blue
563.     CALL setBodyEx(body(), cPARAMETER_RESTITUTION, "cSCENE_BUMPER1", bumperRestitution, 0)
564.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BUMPER1", bumperSF, 0)
565.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BUMPER1", bumperDF, 0)
566.  
567.  
568.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BUMPER2", 370, 100)
569.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BUMPER2", 0, 0)
570.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BUMPER2", -445, 565)
571.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BUMPER2", _RGBA32(255, 0, 0, trans), 0) ' red
572.     CALL setBodyEx(body(), cPARAMETER_RESTITUTION, "cSCENE_BUMPER2", bumperRestitution, 0)
573.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BUMPER2", bumperSF, 0)
574.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BUMPER2", bumperDF, 0)
575.  
576.  
577.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BUMPER3", 370, 100)
578.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BUMPER3", 0, 0)
579.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BUMPER3", 425, -565)
580.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BUMPER3", _RGBA32(0, 255, 0, trans), 0) ' green
581.     CALL setBodyEx(body(), cPARAMETER_RESTITUTION, "cSCENE_BUMPER3", bumperRestitution, 0)
582.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BUMPER3", bumperSF, 0)
583.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BUMPER3", bumperDF, 0)
584.  
585.  
586.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BUMPER4", 370, 100)
587.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BUMPER4", 0, 0)
588.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BUMPER4", 425, 565)
589.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BUMPER4", _RGBA32(255, 255, 0, trans), 0) ' red and green
590.     CALL setBodyEx(body(), cPARAMETER_RESTITUTION, "cSCENE_BUMPER4", bumperRestitution, 0)
591.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BUMPER4", bumperSF, 0)
592.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BUMPER4", bumperDF, 0)
593.  
594.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BUMPER5", 100, 390)
595.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BUMPER5", 0, 0)
596.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BUMPER5", -970, 0)
597.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BUMPER5", _RGBA32(255, 0, 255, trans), 0) 'red and blue
598.     CALL setBodyEx(body(), cPARAMETER_RESTITUTION, "cSCENE_BUMPER5", bumperRestitution, 0)
599.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BUMPER5", bumperSF, 0)
600.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BUMPER5", bumperDF, 0)
601.  
602.  
603.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BUMPER6", 100, 390)
604.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BUMPER6", 0, 0)
605.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BUMPER6", 970, 0)
606.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BUMPER6", _RGBA32(0, 255, 255, trans), 0) ' green and blue
607.     CALL setBodyEx(body(), cPARAMETER_RESTITUTION, "cSCENE_BUMPER6", bumperRestitution, 0)
608.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BUMPER6", bumperSF, 0)
609.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BUMPER6", bumperDF, 0)
610.  
611.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BORDER1", 50, 600)
612.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BORDER1", 0, 0)
613.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BORDER1", 970, 0)
614.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BORDER1", _RGBA32(255, 255, 255, trans), 0)
615.  
616.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BORDER2", 50, 600)
617.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BORDER2", 0, 0)
618.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BORDER2", -970, 0)
619.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BORDER2", _RGBA32(255, 255, 255, trans), 0)
620.  
621.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BORDER3", 1000, 50)
622.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BORDER3", 0, 0)
623.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BORDER3", 0, -560)
624.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BORDER3", _RGBA32(255, 255, 255, trans), 0)
625.  
626.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BORDER4", 1000, 50)
627.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BORDER4", 0, 0)
628.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BORDER4", 0, 560)
629.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BORDER4", _RGBA32(255, 255, 255, trans), 0)
630.  
631.  
632.     '********************************************************
633.     '   Build Ball Return hidden surfaces
634.     '********************************************************
635.     ' These are hidden using transparent colors
636.  
637.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BALLRETURNBOTTOM", 600, 10)
638.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BALLRETURNBOTTOM", 0, 0)
639.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BALLRETURNBOTTOM", 0, 850)
640.     CALL setBodyEx(body(), cPARAMETER_ORIENT, "cSCENE_BALLRETURNBOTTOM", 0.01, 0)
641.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BALLRETURNBOTTOM", _RGBA32(255, 255, 255, trans), 0)
642.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BALLRETURNBOTTOM", 10, 0)
643.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BALLRETURNBOTTOM", 10, 0)
644.  
645.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BALLRETURNTOP", 600, 10)
646.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BALLRETURNTOP", 0, 0)
647.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BALLRETURNTOP", 0, 750)
648.     CALL setBodyEx(body(), cPARAMETER_ORIENT, "cSCENE_BALLRETURNTOP", 0.01, 0)
649.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BALLRETURNTOP", _RGBA32(255, 255, 255, trans), 0)
650.     CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, "cSCENE_BALLRETURNTOP", 10, 0)
651.     CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, "cSCENE_BALLRETURNTOP", 10, 0)
652.  
653.  
654.  
655.  
656.     iD = createBoxBodiesEx(p(), body(), "cSCENE_BALLRETURNEND", 10, 40)
657.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_BALLRETURNEND", 0, 0)
658.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_BALLRETURNEND", 550, 800)
659.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_BALLRETURNEND", _RGBA32(255, 255, 255, trans), 0)
660.  
661.  
662.     '********************************************************
663.     '   Pocket sensors
664.     '********************************************************
665.  
666.     iD = createCircleBodyEx(body(), "cSCENE_SENSOR1", 50)
667.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_SENSOR1", 0, 0)
668.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_SENSOR1", -5, 525)
669.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_SENSOR1", _RGBA32(255, 255, 255, trans), 0)
670.     poolSensors(0).objId = objectManagerID(body(), "cSCENE_SENSOR1")
671.  
672.     iD = createCircleBodyEx(body(), "cSCENE_SENSOR2", 50)
673.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_SENSOR2", 0, 0)
674.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_SENSOR2", -5, -525)
675.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_SENSOR2", _RGBA32(255, 255, 255, trans), 0)
676.     poolSensors(1).objId = objectManagerID(body(), "cSCENE_SENSOR2")
677.  
678.     iD = createCircleBodyEx(body(), "cSCENE_SENSOR3", 50)
679.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_SENSOR3", 0, 0)
680.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_SENSOR3", -900, -490)
681.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_SENSOR3", _RGBA32(255, 255, 255, trans), 0)
682.     poolSensors(2).objId = objectManagerID(body(), "cSCENE_SENSOR3")
683.  
684.     iD = createCircleBodyEx(body(), "cSCENE_SENSOR4", 50)
685.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_SENSOR4", 0, 0)
686.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_SENSOR4", 900, -490)
687.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_SENSOR4", _RGBA32(255, 255, 255, trans), 0)
688.     poolSensors(3).objId = objectManagerID(body(), "cSCENE_SENSOR4")
689.  
690.     iD = createCircleBodyEx(body(), "cSCENE_SENSOR5", 50)
691.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_SENSOR5", 0, 0)
692.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_SENSOR5", -900, 490)
693.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_SENSOR5", _RGBA32(255, 255, 255, trans), 0)
694.     poolSensors(4).objId = objectManagerID(body(), "cSCENE_SENSOR5")
695.  
696.     iD = createCircleBodyEx(body(), "cSCENE_SENSOR6", 50)
697.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_SENSOR6", 0, 0)
698.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_SENSOR6", 900, 490)
699.     CALL setBodyEx(body(), cPARAMETER_COLOR, "cSCENE_SENSOR6", _RGBA32(255, 255, 255, trans), 0)
700.     poolSensors(5).objId = objectManagerID(body(), "cSCENE_SENSOR6")
701.  
702.     '********************************************************
703.     '   Place Balls
704.     '********************************************************
705.     DIM AS _FLOAT rX, rY
706.  
707.     FOR index = 1 TO 17
708.         READ rX, rY
709.         CALL vectorSet(pool(index).rackposition, rX, rY)
710.     NEXT
711.  
712.     FOR index = 1 TO 16
713.         b = "cSCENE_BALL" + LTRIM$(STR$(index))
714.         iD = createCircleBodyEx(body(), b, ballSize)
715.         CALL setBodyEx(body(), cPARAMETER_TEXTURE, b, textureMap(index), 0)
716.         CALL setBodyEx(body(), cPARAMETER_RESTITUTION, b, 1.00, 0)
717.         CALL setBodyEx(body(), cPARAMETER_STATICFRICTION, b, .50, 0) '.5
718.         CALL setBodyEx(body(), cPARAMETER_DYNAMICFRICTION, b, .30, 0) '.3
719.         CALL setBodyEx(body(), cPARAMETER_POSITION, b, pool(index).rackposition.x, pool(index).rackposition.y)
720.         pool(index).objId = iD
721.         pool(index).status = 0
722.     NEXT
723.  
724.     '********************************************************
725.     '   Cue Stick
726.     '********************************************************
727.  
728.     DIM tv AS tVECTOR2d
729.     CALL vectorSet(tv, 500, 0)
730.  
731.     iD = createBoxBodiesEx(p(), body(), "cSCENE_CUE", 400, 10)
732.     CALL setBodyEx(body(), cPARAMETER_STATIC, "cSCENE_CUE", 0, 0)
733.     CALL setBodyEx(body(), cPARAMETER_POSITION, "cSCENE_CUE", 0, 0)
734.     CALL setBodyEx(body(), cPARAMETER_COLLISIONMASK, "cSCENE_CUE", 0, 0)
735.     CALL setBodyEx(body(), cPARAMETER_TEXTURE, "cSCENE_CUE", textureMap(18), 0)
736.  
737.     DATA -475,0
738.     DATA -548,38
739.     DATA -494,-19
740.     DATA -530,-19
741.     DATA -548,-38
742.     DATA -512,38
743.     DATA -548,75
744.     DATA -512,0
745.     DATA -530,-57
746.     DATA -548,0
747.     DATA -494,19
748.     DATA -548,-75
749.     DATA -530,57
750.     DATA -512,-38
751.     DATA -530,19
752.     DATA 525,0
753.     DATA -500,800
754.  
755.     textureMap(22) = _NEWIMAGE(_WIDTH(0) / 2, _HEIGHT(0) / 2, 32) 'GUI
756.     _DEST textureMap(22)
757.     _PRINTMODE _KEEPBACKGROUND
758.     LOCATE 1, 1
759.     PRINT "QB Pool: No rules."
760.     PRINT "Instructions:"
761.     PRINT "- 'I' or 'i' to show these instructions."
762.     PRINT "- Use Mouse to Aim."
763.     PRINT "- Mouse also controls power."
764.     PRINT "- Mousewheel to adjust zoom."
765.     PRINT "- LEFT and RIGHT arrow keys for English."
766.     PRINT "- 'R' or 'r' to rerack balls."
767.     PRINT "- <SPACE> to hit harder. Example for a break."
768.     PRINT "- <TAB> to test your shot. ;)"
769.     PRINT "- <ESC> to quit."
770.     genPool.instructions = 1
771.     _DEST 0
772.  
773. END SUB
774.  
775. SUB bodyStop (body AS tBODY)
776.     CALL vectorSet(body.velocity, 0, 0)
777.     body.angularVelocity = 0
778. END SUB
779.  
780. SUB bodyOffset (body() AS tBODY, p() AS tPOLY, index AS LONG, vec AS tVECTOR2d)
781.     DIM i AS INTEGER
782.     FOR i = 0 TO body(index).pa.count
783.         CALL vectorAddVector(p(body(index).pa.start + i).vert, vec)
784.     NEXT
785. END SUB
786.  
787.  
788. FUNCTION objectContainsString (body() AS tBODY, start AS INTEGER, s AS STRING)
789.     objectContainsString = -1
790.     DIM AS INTEGER j
791.     FOR j = start TO objectManager.objectCount
792.         IF INSTR(body(j).objectName, s) THEN
793.             objectContainsString = j
794.             EXIT FUNCTION
795.         END IF
796.     NEXT
797. END FUNCTION
798. '**********************************************************************************************
799. '   Collision Helper Tools
800. '**********************************************************************************************
801.  
802. FUNCTION isBodyTouchingBody (hits() AS tHIT, A AS INTEGER, B AS INTEGER)
803.     DIM hitcount AS INTEGER: hitcount = 1
804.     isBodyTouchingBody = 0
805.     DO WHILE hits(hitcount).A <> hits(hitcount).B
806.         IF hits(hitcount).A = A AND hits(hitcount).B = B THEN
807.             isBodyTouchingBody = hitcount
808.             EXIT FUNCTION
809.         END IF
810.         hitcount = hitcount + 1: IF hitcount > UBOUND(hits) THEN REDIM _PRESERVE hits(hitcount * 1.5) AS tHIT
811.     LOOP
812. END FUNCTION
813.  
814. FUNCTION isBodyTouchingStatic (body() AS tBODY, hits() AS tHIT, A AS INTEGER)
815.     DIM hitcount AS INTEGER: hitcount = 1
816.     isBodyTouchingStatic = 0
817.     DO WHILE hits(hitcount).A <> hits(hitcount).B
818.         IF hits(hitcount).A = A THEN
819.             IF body(hits(hitcount).B).mass = 0 THEN
820.                 isBodyTouchingStatic = hitcount
821.                 EXIT FUNCTION
822.             END IF
823.         ELSE
824.             IF hits(hitcount).B = A THEN
825.                 IF body(hits(hitcount).A).mass = 0 THEN
826.                     isBodyTouchingStatic = hitcount
827.                     EXIT FUNCTION
828.                 END IF
829.             END IF
830.         END IF
831.         hitcount = hitcount + 1: IF hitcount > UBOUND(hits) THEN REDIM _PRESERVE hits(hitcount * 1.5) AS tHIT
832.     LOOP
833. END FUNCTION
834.  
835. FUNCTION isBodyTouching (hits() AS tHIT, A AS INTEGER)
836.     DIM hitcount AS INTEGER: hitcount = 1
837.     isBodyTouching = 0
838.     DO WHILE hits(hitcount).A <> hits(hitcount).B
839.         IF hits(hitcount).A = A THEN
840.             isBodyTouching = hits(hitcount).B
841.             EXIT FUNCTION
842.         END IF
843.         IF hits(hitcount).B = A THEN
844.             isBodyTouching = hits(hitcount).A
845.             EXIT FUNCTION
846.         END IF
847.  
848.         hitcount = hitcount + 1: IF hitcount > UBOUND(hits) THEN REDIM _PRESERVE hits(hitcount * 1.5) AS tHIT
849.     LOOP
850. END FUNCTION
851.  
852. FUNCTION highestCollisionVelocity (hits() AS tHIT, A AS INTEGER) ' this function is a bit dubious and may not do as you think
853.     DIM hitcount AS INTEGER: hitcount = 1
854.     DIM hiCv AS _FLOAT: hiCv = 0
855.     highestCollisionVelocity = 0
856.     DO WHILE hits(hitcount).A <> hits(hitcount).B
857.         IF hits(hitcount).A = A AND ABS(hits(hitcount).cv) > hiCv AND hits(hitcount).cv < 0 THEN
858.             hiCv = ABS(hits(hitcount).cv)
859.         END IF
860.         hitcount = hitcount + 1: IF hitcount > UBOUND(hits) THEN REDIM _PRESERVE hits(hitcount * 1.5) AS tHIT
861.     LOOP
862.     highestCollisionVelocity = hiCv
863. END FUNCTION
864.  
865. '**********************************************************************************************
866. '   Physics and Collision Stuff Ahead
867. '**********************************************************************************************
868.  
869. SUB impulseIntegrateForces (b AS tBODY, dt AS _FLOAT)
870.     IF b.invMass = 0.0 THEN EXIT SUB
871.     DIM dts AS _FLOAT
872.     dts = dt * .5
873.     CALL vectorAddVectorScalar(b.velocity, b.force, b.invMass * dts)
874.     CALL vectorAddVectorScalar(b.velocity, world.gravity, dts)
875.     b.angularVelocity = b.angularVelocity + (b.torque * b.invInertia * dts)
876. END SUB
877.  
878. SUB impulseIntegrateVelocity (body AS tBODY, dt AS _FLOAT)
879.     IF body.invMass = 0.0 THEN EXIT SUB
880.     body.velocity.x = body.velocity.x * (1 - dt)
881.     body.velocity.y = body.velocity.y * (1 - dt)
882.     body.angularVelocity = body.angularVelocity * (1 - dt)
883.     CALL vectorAddVectorScalar(body.position, body.velocity, dt)
884.     body.orient = body.orient + (body.angularVelocity * dt)
885.     CALL matrixSetRadians(body.shape.u, body.orient)
886.     CALL impulseIntegrateForces(body, dt)
887. END SUB
888.  
889. SUB impulseStep (p() AS tPOLY, body() AS tBODY, j() AS tJOINT, hits() AS tHIT, dt AS _FLOAT, iterations AS INTEGER)
890.     DIM A AS tBODY
891.     DIM B AS tBODY
892.     DIM c(cMAXNUMBEROFOBJECTS) AS tVECTOR2d
893.     DIM m AS tMANIFOLD
894.     DIM manifolds(sNUMBEROFBODIES * sNUMBEROFBODIES) AS tMANIFOLD
895.     DIM collisions(sNUMBEROFBODIES * sNUMBEROFBODIES, cMAXNUMBEROFOBJECTS) AS tVECTOR2d
896.     DIM manifoldCount AS INTEGER: manifoldCount = 0
897.     '    // Generate new collision info
898.     DIM i, j, k AS LONG
899.     DIM hitCount AS LONG: hitCount = 0
900.     DIM dHit AS tHIT 'empty
901.     ' // erase hitlist
902.     DO
903.         hits(hitCount) = dHit
904.         hitCount = hitCount + 1
905.     LOOP UNTIL hitCount > UBOUND(hits)
906.     hitCount = 0
907.  
908.     FOR i = 0 TO objectManager.objectCount ' number of bodies
909.         A = body(i)
910.         IF A.enable THEN
911.             FOR j = i + 1 TO objectManager.objectCount
912.                 B = body(j)
913.                 IF (A.collisionMask AND B.collisionMask) THEN
914.                     IF A.invMass = 0.0 AND B.invMass = 0.0 THEN _CONTINUE
915.                     'Mainfold solve - handle collisions
916.                     IF AABBOverlapVector(A.position, 2000, 2000, B.position, 2000, 2000) THEN
917.                         IF A.shape.ty = cSHAPE_CIRCLE AND B.shape.ty = cSHAPE_CIRCLE THEN
918.                             CALL collisionCCHandle(m, c(), A, B)
919.                         ELSE
920.                             IF A.shape.ty = cSHAPE_POLYGON AND B.shape.ty = cSHAPE_POLYGON THEN
921.                                 CALL collisionPPHandle(p(), body(), m, c(), i, j)
922.                             ELSE
923.                                 IF A.shape.ty = cSHAPE_CIRCLE AND B.shape.ty = cSHAPE_POLYGON THEN
924.                                     CALL collisionCPHandle(p(), body(), m, c(), i, j)
925.                                 ELSE
926.                                     IF B.shape.ty = cSHAPE_CIRCLE AND A.shape.ty = cSHAPE_POLYGON THEN
927.                                         CALL collisionPCHandle(p(), body(), m, c(), i, j)
928.                                     END IF
929.                                 END IF
930.                             END IF
931.                         END IF
932.  
933.                         IF m.contactCount > 0 THEN
934.                             m.A = i 'identify the index of objects
935.                             m.B = j
936.                             manifolds(manifoldCount) = m
937.                             FOR k = 0 TO m.contactCount
938.                                 hits(hitCount).A = i
939.                                 hits(hitCount).B = j
940.                                 hits(hitCount).position = c(k)
941.                                 collisions(manifoldCount, k) = c(k)
942.                                 hitCount = hitCount + 1
943.                                 IF hitCount > UBOUND(hits) THEN REDIM _PRESERVE hits(hitCount * 1.5) AS tHIT
944.                             NEXT
945.                             manifoldCount = manifoldCount + 1
946.                             IF manifoldCount > UBOUND(manifolds) THEN REDIM _PRESERVE manifolds(manifoldCount * 1.5) AS tMANIFOLD
947.                         END IF
948.                     END IF
949.                 END IF
950.             NEXT
951.         END IF
952.     NEXT
953.  
954.     '   // Integrate forces
955.     FOR i = 0 TO objectManager.objectCount
956.         IF body(i).enable THEN CALL impulseIntegrateForces(body(i), dt)
957.     NEXT
958.     '   // Initialize collision
959.     FOR i = 0 TO manifoldCount - 1
960.         ' this is the stupidest thing ever since QB will not let you split arrays
961.         FOR k = 0 TO manifolds(i).contactCount - 1
962.             c(k) = collisions(i, k)
963.         NEXT
964.         CALL manifoldInit(manifolds(i), body(), c())
965.     NEXT
966.     ' joint pre Steps
967.  
968.     FOR i = 1 TO sNUMBEROFJOINTS
969.         CALL jointPrestep(j(i), body(), dt)
970.     NEXT
971.  
972.     '// Solve collisions
973.     FOR j = 0 TO iterations - 1
974.         FOR i = 0 TO manifoldCount - 1
975.             FOR k = 0 TO manifolds(i).contactCount - 1
976.                 c(k) = collisions(i, k)
977.             NEXT
978.             CALL manifoldApplyImpulse(manifolds(i), body(), c())
979.             'store the hit speed for later
980.             FOR k = 0 TO hitCount - 1
981.                 IF manifolds(i).A = hits(k).A AND manifolds(i).B = hits(k).B THEN
982.                     hits(k).cv = manifolds(i).cv
983.                 END IF
984.             NEXT
985.         NEXT
986.         FOR i = 1 TO sNUMBEROFJOINTS
987.             CALL jointApplyImpulse(j(i), body())
988.         NEXT
989.     NEXT
990.  
991.     '// Integrate velocities
992.     FOR i = 0 TO objectManager.objectCount
993.         IF body(i).enable THEN CALL impulseIntegrateVelocity(body(i), dt)
994.     NEXT
995.     '// Correct positions
996.     FOR i = 0 TO manifoldCount - 1
997.         CALL manifoldPositionalCorrection(manifolds(i), body())
998.     NEXT
999.     '// Clear all forces
1000.     FOR i = 0 TO objectManager.objectCount
1001.         CALL vectorSet(body(i).force, 0, 0)
1002.         body(i).torque = 0
1003.     NEXT
1004. END SUB
1005.  
1006. SUB bodyApplyImpulse (body AS tBODY, impulse AS tVECTOR2d, contactVector AS tVECTOR2d)
1007.     CALL vectorAddVectorScalar(body.velocity, impulse, body.invMass)
1008.     body.angularVelocity = body.angularVelocity + body.invInertia * vectorCross(contactVector, impulse)
1009. END SUB
1010.  
1011. SUB bodySetStatic (body AS tBODY)
1012.     body.inertia = 0.0
1013.     body.invInertia = 0.0
1014.     body.mass = 0.0
1015.     body.invMass = 0.0
1016. END SUB
1017.  
1018. SUB manifoldInit (m AS tMANIFOLD, body() AS tBODY, contacts() AS tVECTOR2d)
1019.     DIM ra AS tVECTOR2d
1020.     DIM rb AS tVECTOR2d
1021.     DIM rv AS tVECTOR2d
1022.     DIM tv1 AS tVECTOR2d 'temporary Vectors
1023.     DIM tv2 AS tVECTOR2d
1024.     m.e = scalarMin(body(m.A).restitution, body(m.B).restitution)
1025.     m.sf = SQR(body(m.A).staticFriction * body(m.A).staticFriction)
1026.     m.df = SQR(body(m.A).dynamicFriction * body(m.A).dynamicFriction)
1027.     DIM i AS INTEGER
1028.     FOR i = 0 TO m.contactCount - 1
1029.         CALL vectorSubVectorND(contacts(i), body(m.A).position, ra)
1030.         CALL vectorSubVectorND(contacts(i), body(m.B).position, rb)
1031.  
1032.         CALL vectorCrossScalar(tv1, rb, body(m.B).angularVelocity)
1033.         CALL vectorCrossScalar(tv2, ra, body(m.A).angularVelocity)
1034.         CALL vectorAddVector(tv1, body(m.B).velocity)
1035.         CALL vectorSubVectorND(tv2, body(m.A).velocity, tv2)
1036.         CALL vectorSubVectorND(rv, tv1, tv2)
1037.  
1038.         IF vectorLengthSq(rv) < sRESTING THEN
1039.             m.e = 0.0
1040.         END IF
1041.     NEXT
1042. END SUB
1043.  
1044. SUB manifoldApplyImpulse (m AS tMANIFOLD, body() AS tBODY, contacts() AS tVECTOR2d)
1045.     DIM ra AS tVECTOR2d
1046.     DIM rb AS tVECTOR2d
1047.     DIM rv AS tVECTOR2d
1048.     DIM tv1 AS tVECTOR2d 'temporary Vectors
1049.     DIM tv2 AS tVECTOR2d
1050.     DIM contactVel AS _FLOAT
1051.  
1052.     DIM raCrossN AS _FLOAT
1053.     DIM rbCrossN AS _FLOAT
1054.     DIM invMassSum AS _FLOAT
1055.     DIM i AS INTEGER
1056.     DIM j AS _FLOAT
1057.     DIM impulse AS tVECTOR2d
1058.  
1059.     DIM t AS tVECTOR2d
1060.     DIM jt AS _FLOAT
1061.     DIM tangentImpulse AS tVECTOR2d
1062.  
1063.     IF impulseEqual(body(m.A).invMass + body(m.B).invMass, 0.0) THEN
1064.         CALL manifoldInfiniteMassCorrection(body(m.A), body(m.B))
1065.         EXIT SUB
1066.     END IF
1067.  
1068.     FOR i = 0 TO m.contactCount - 1
1069.         '// Calculate radii from COM to contact
1070.         '// Vec2 ra = contacts[i] - A->position;
1071.         '// Vec2 rb = contacts[i] - B->position;
1072.         CALL vectorSubVectorND(ra, contacts(i), body(m.A).position)
1073.         CALL vectorSubVectorND(rb, contacts(i), body(m.B).position)
1074.  
1075.         '// Relative velocity
1076.         '// Vec2 rv = B->velocity + Cross( B->angularVelocity, rb ) - A->velocity - Cross( A->angularVelocity, ra );
1077.         CALL vectorCrossScalar(tv1, rb, body(m.B).angularVelocity)
1078.         CALL vectorCrossScalar(tv2, ra, body(m.A).angularVelocity)
1079.         CALL vectorAddVectorND(rv, tv1, body(m.B).velocity)
1080.         CALL vectorSubVector(rv, body(m.A).velocity)
1081.         CALL vectorSubVector(rv, tv2)
1082.  
1083.         '// Relative velocity along the normal
1084.         '// real contactVel = Dot( rv, normal );
1085.         contactVel = vectorDot(rv, m.normal)
1086.  
1087.         '// Do not resolve if velocities are separating
1088.         IF contactVel > 0 THEN EXIT SUB
1089.         m.cv = contactVel
1090.         '// real raCrossN = Cross( ra, normal );
1091.         '// real rbCrossN = Cross( rb, normal );
1092.         '// real invMassSum = A->im + B->im + Sqr( raCrossN ) * A->iI + Sqr( rbCrossN ) * B->iI;
1093.         raCrossN = vectorCross(ra, m.normal)
1094.         rbCrossN = vectorCross(rb, m.normal)
1095.         invMassSum = body(m.A).invMass + body(m.B).invMass + (raCrossN * raCrossN) * body(m.A).invInertia + (rbCrossN * rbCrossN) * body(m.B).invInertia
1096.  
1097.         '// Calculate impulse scalar
1098.         j = -(1.0 + m.e) * contactVel
1099.         j = j / invMassSum
1100.         j = j / m.contactCount
1101.  
1102.         '// Apply impulse
1103.         CALL vectorMultiplyScalarND(impulse, m.normal, j)
1104.         CALL vectorNegND(tv1, impulse)
1105.         CALL bodyApplyImpulse(body(m.A), tv1, ra)
1106.         CALL bodyApplyImpulse(body(m.B), impulse, rb)
1107.  
1108.         '// Friction impulse
1109.         '// rv = B->velocity + Cross( B->angularVelocity, rb ) - A->velocity - Cross( A->angularVelocity, ra );
1110.         CALL vectorCrossScalar(tv1, rb, body(m.B).angularVelocity)
1111.         CALL vectorCrossScalar(tv2, ra, body(m.A).angularVelocity)
1112.         CALL vectorAddVectorND(rv, tv1, body(m.B).velocity)
1113.         CALL vectorSubVector(rv, body(m.A).velocity)
1114.         CALL vectorSubVector(rv, tv2)
1115.  
1116.         '// Vec2 t = rv - (normal * Dot( rv, normal ));
1117.         '// t.Normalize( );
1118.         CALL vectorMultiplyScalarND(t, m.normal, vectorDot(rv, m.normal))
1119.         CALL vectorSubVectorND(t, rv, t)
1120.         CALL vectorNormalize(t)
1121.  
1122.         '// j tangent magnitude
1123.         jt = -vectorDot(rv, t)
1124.         jt = jt / invMassSum
1125.         jt = jt / m.contactCount
1126.  
1127.         '// Don't apply tiny friction impulses
1128.         IF impulseEqual(jt, 0.0) THEN EXIT SUB
1129.  
1130.         '// Coulumb's law
1131.         IF ABS(jt) < j * m.sf THEN
1132.             CALL vectorMultiplyScalarND(tangentImpulse, t, jt)
1133.         ELSE
1134.             CALL vectorMultiplyScalarND(tangentImpulse, t, -j * m.df)
1135.         END IF
1136.  
1137.         '// Apply friction impulse
1138.         '// A->ApplyImpulse( -tangentImpulse, ra );
1139.         '// B->ApplyImpulse( tangentImpulse, rb );
1140.         CALL vectorNegND(tv1, tangentImpulse)
1141.         CALL bodyApplyImpulse(body(m.A), tv1, ra)
1142.         CALL bodyApplyImpulse(body(m.B), tangentImpulse, rb)
1143.     NEXT i
1144. END SUB
1145.  
1146. SUB manifoldPositionalCorrection (m AS tMANIFOLD, body() AS tBODY)
1147.     DIM correction AS _FLOAT
1148.     correction = scalarMax(m.penetration - cPENETRATION_ALLOWANCE, 0.0) / (body(m.A).invMass + body(m.B).invMass) * cPENETRATION_CORRECTION
1149.     CALL vectorAddVectorScalar(body(m.A).position, m.normal, -body(m.A).invMass * correction)
1150.     CALL vectorAddVectorScalar(body(m.B).position, m.normal, body(m.B).invMass * correction)
1151. END SUB
1152.  
1153. SUB manifoldInfiniteMassCorrection (A AS tBODY, B AS tBODY)
1154.     CALL vectorSet(A.velocity, 0, 0)
1155.     CALL vectorSet(B.velocity, 0, 0)
1156. END SUB
1157.  
1158. '**********************************************************************************************
1159. '   Collision Stuff Ahead
1160. '**********************************************************************************************
1161.  
1162. SUB collisionCCHandle (m AS tMANIFOLD, contacts() AS tVECTOR2d, A AS tBODY, B AS tBODY)
1163.     DIM normal AS tVECTOR2d
1164.     DIM dist_sqr AS _FLOAT
1165.     DIM radius AS _FLOAT
1166.  
1167.     CALL vectorSubVectorND(normal, B.position, A.position) ' Subtract two vectors position A and position B
1168.     dist_sqr = vectorLengthSq(normal) ' Calculate the distance between the balls or circles
1169.     radius = A.shape.radius + B.shape.radius ' Add both circle A and circle B radius
1170.  
1171.     IF (dist_sqr >= radius * radius) THEN
1172.         m.contactCount = 0
1173.     ELSE
1174.         DIM distance AS _FLOAT
1175.         distance = SQR(dist_sqr)
1176.         m.contactCount = 1
1177.  
1178.         IF distance = 0 THEN
1179.             m.penetration = A.shape.radius
1180.             CALL vectorSet(m.normal, 1.0, 0.0)
1181.             CALL vectorSetVector(contacts(0), A.position)
1182.         ELSE
1183.             m.penetration = radius - distance
1184.             CALL vectorDivideScalarND(m.normal, normal, distance)
1185.  
1186.             CALL vectorMultiplyScalarND(contacts(0), m.normal, A.shape.radius)
1187.             CALL vectorAddVector(contacts(0), A.position)
1188.         END IF
1189.     END IF
1190. END SUB
1191.  
1192. SUB collisionPCHandle (p() AS tPOLY, body() AS tBODY, m AS tMANIFOLD, contacts() AS tVECTOR2d, A AS INTEGER, B AS INTEGER)
1193.     CALL collisionCPHandle(p(), body(), m, contacts(), B, A)
1194.     IF m.contactCount > 0 THEN
1195.         CALL vectorNeg(m.normal)
1196.     END IF
1197. END SUB
1198.  
1199. SUB collisionCPHandle (p() AS tPOLY, body() AS tBODY, m AS tMANIFOLD, contacts() AS tVECTOR2d, A AS INTEGER, B AS INTEGER)
1200.     'A is the Circle
1201.     'B is the POLY
1202.     m.contactCount = 0
1203.     DIM center AS tVECTOR2d
1204.     DIM tm AS tMATRIX2d
1205.     DIM tv AS tVECTOR2d
1206.     DIM ARadius AS _FLOAT: ARadius = body(A).shape.radius
1207.  
1208.     CALL vectorSubVectorND(center, body(A).position, body(B).position)
1209.     CALL matrixTranspose(body(B).shape.u, tm)
1210.     CALL matrixMultiplyVector(tm, center, center)
1211.  
1212.     DIM separation AS _FLOAT: separation = -9999999
1213.     DIM faceNormal AS INTEGER: faceNormal = 0
1214.     DIM i AS INTEGER
1215.     DIM s AS _FLOAT
1216.     FOR i = 0 TO body(B).pa.count
1217.         CALL vectorSubVectorND(tv, center, p(body(B).pa.start + i).vert)
1218.         s = vectorDot(p(body(B).pa.start + i).norm, tv)
1219.         IF s > ARadius THEN EXIT SUB
1220.         IF s > separation THEN
1221.             separation = s
1222.             faceNormal = i
1223.         END IF
1224.     NEXT
1225.     DIM v1 AS tVECTOR2d
1226.     v1 = p(body(B).pa.start + faceNormal).vert
1227.     DIM i2 AS INTEGER
1228.     i2 = body(B).pa.start + arrayNextIndex(faceNormal, body(B).pa.count)
1229.     DIM v2 AS tVECTOR2d
1230.     v2 = p(i2).vert
1231.  
1232.     IF separation < cEPSILON THEN
1233.         m.contactCount = 1
1234.         CALL matrixMultiplyVector(body(B).shape.u, p(body(B).pa.start + faceNormal).norm, m.normal)
1235.         CALL vectorNeg(m.normal)
1236.         CALL vectorMultiplyScalarND(contacts(0), m.normal, ARadius)
1237.         CALL vectorAddVector(contacts(0), body(A).position)
1238.         m.penetration = ARadius
1239.         EXIT SUB
1240.     END IF
1241.  
1242.     DIM dot1 AS _FLOAT
1243.     DIM dot2 AS _FLOAT
1244.  
1245.     DIM tv1 AS tVECTOR2d
1246.     DIM tv2 AS tVECTOR2d
1247.     DIM n AS tVECTOR2d
1248.     CALL vectorSubVectorND(tv1, center, v1)
1249.     CALL vectorSubVectorND(tv2, v2, v1)
1250.     dot1 = vectorDot(tv1, tv2)
1251.     CALL vectorSubVectorND(tv1, center, v2)
1252.     CALL vectorSubVectorND(tv2, v1, v2)
1253.     dot2 = vectorDot(tv1, tv2)
1254.     m.penetration = ARadius - separation
1255.     IF dot1 <= 0.0 THEN
1256.         IF vectorSqDist(center, v1) > ARadius * ARadius THEN EXIT SUB
1257.         m.contactCount = 1
1258.         CALL vectorSubVectorND(n, v1, center)
1259.         CALL matrixMultiplyVector(body(B).shape.u, n, n)
1260.         CALL vectorNormalize(n)
1261.         m.normal = n
1262.         CALL matrixMultiplyVector(body(B).shape.u, v1, v1)
1263.         CALL vectorAddVectorND(v1, v1, body(B).position)
1264.         contacts(0) = v1
1265.     ELSE
1266.         IF dot2 <= 0.0 THEN
1267.             IF vectorSqDist(center, v2) > ARadius * ARadius THEN EXIT SUB
1268.             m.contactCount = 1
1269.             CALL vectorSubVectorND(n, v2, center)
1270.             CALL matrixMultiplyVector(body(B).shape.u, v2, v2)
1271.             CALL vectorAddVectorND(v2, v2, body(B).position)
1272.             contacts(0) = v2
1273.             CALL matrixMultiplyVector(body(B).shape.u, n, n)
1274.             CALL vectorNormalize(n)
1275.             m.normal = n
1276.         ELSE
1277.             n = p(body(B).pa.start + faceNormal).norm
1278.             CALL vectorSubVectorND(tv1, center, v1)
1279.             IF vectorDot(tv1, n) > ARadius THEN EXIT SUB
1280.             m.contactCount = 1
1281.             CALL matrixMultiplyVector(body(B).shape.u, n, n)
1282.             CALL vectorNeg(n)
1283.             m.normal = n
1284.             CALL vectorMultiplyScalarND(contacts(0), m.normal, ARadius)
1285.             CALL vectorAddVector(contacts(0), body(A).position)
1286.         END IF
1287.     END IF
1288. END SUB
1289.  
1290. FUNCTION collisionPPClip (n AS tVECTOR2d, c AS _FLOAT, face() AS tVECTOR2d)
1291.     DIM sp AS INTEGER: sp = 0
1292.     DIM o(cMAXNUMBEROFPOLYGONS) AS tVECTOR2d
1293.  
1294.     o(0) = face(0)
1295.     o(1) = face(1)
1296.  
1297.     DIM d1 AS _FLOAT: d1 = vectorDot(n, face(0)) - c
1298.     DIM d2 AS _FLOAT: d2 = vectorDot(n, face(1)) - c
1299.  
1300.     IF d1 <= 0.0 THEN
1301.         o(sp) = face(0)
1302.         sp = sp + 1
1303.     END IF
1304.  
1305.     IF d2 <= 0.0 THEN
1306.         o(sp) = face(1)
1307.         sp = sp + 1
1308.     END IF
1309.  
1310.     IF d1 * d2 < 0.0 THEN
1311.         DIM alpha AS _FLOAT: alpha = d1 / (d1 - d2)
1312.         DIM tempv AS tVECTOR2d
1313.         'out[sp] = face[0] + alpha * (face[1] - face[0]);
1314.         CALL vectorSubVectorND(tempv, face(1), face(0))
1315.         CALL vectorMultiplyScalar(tempv, alpha)
1316.         CALL vectorAddVectorND(o(sp), tempv, face(0))
1317.         sp = sp + 1
1318.     END IF
1319.     face(0) = o(0)
1320.     face(1) = o(1)
1321.     collisionPPClip = sp
1322. END FUNCTION
1323.  
1324. SUB collisionPPFindIncidentFace (p() AS tPOLY, b() AS tBODY, v() AS tVECTOR2d, RefPoly AS INTEGER, IncPoly AS INTEGER, referenceIndex AS INTEGER)
1325.     DIM referenceNormal AS tVECTOR2d
1326.     DIM uRef AS tMATRIX2d: uRef = b(RefPoly).shape.u
1327.     DIM uInc AS tMATRIX2d: uInc = b(IncPoly).shape.u
1328.     DIM uTemp AS tMATRIX2d
1329.     DIM i AS INTEGER
1330.     referenceNormal = p(b(RefPoly).pa.start + referenceIndex).norm
1331.  
1332.     '        // Calculate normal in incident's frame of reference
1333.     '        // referenceNormal = RefPoly->u * referenceNormal; // To world space
1334.     CALL matrixMultiplyVector(uRef, referenceNormal, referenceNormal)
1335.     '        // referenceNormal = IncPoly->u.Transpose( ) * referenceNormal; // To incident's model space
1336.     CALL matrixTranspose(uInc, uTemp)
1337.     CALL matrixMultiplyVector(uTemp, referenceNormal, referenceNormal)
1338.  
1339.     DIM incidentFace AS INTEGER: incidentFace = 0
1340.     DIM minDot AS _FLOAT: minDot = 9999999
1341.     DIM dot AS _FLOAT
1342.     FOR i = 0 TO b(IncPoly).pa.count
1343.         dot = vectorDot(referenceNormal, p(b(IncPoly).pa.start + i).norm)
1344.         IF (dot < minDot) THEN
1345.             minDot = dot
1346.             incidentFace = i
1347.         END IF
1348.     NEXT
1349.  
1350.     '// Assign face vertices for incidentFace
1351.     '// v[0] = IncPoly->u * IncPoly->m_vertices[incidentFace] + IncPoly->body->position;
1352.     CALL matrixMultiplyVector(uInc, p(b(IncPoly).pa.start + incidentFace).vert, v(0))
1353.     CALL vectorAddVector(v(0), b(IncPoly).position)
1354.  
1355.     '// incidentFace = incidentFace + 1 >= (int32)IncPoly->m_vertexCount ? 0 : incidentFace + 1;
1356.     incidentFace = arrayNextIndex(incidentFace, b(IncPoly).pa.count)
1357.  
1358.     '// v[1] = IncPoly->u * IncPoly->m_vertices[incidentFace] +  IncPoly->body->position;
1359.     CALL matrixMultiplyVector(uInc, p(b(IncPoly).pa.start + incidentFace).vert, v(1))
1360.     CALL vectorAddVector(v(1), b(IncPoly).position)
1361. END SUB
1362.  
1363. SUB collisionPPHandle (p() AS tPOLY, body() AS tBODY, m AS tMANIFOLD, contacts() AS tVECTOR2d, A AS INTEGER, B AS INTEGER)
1364.     m.contactCount = 0
1365.  
1366.     DIM faceA(100) AS INTEGER
1367.  
1368.     DIM penetrationA AS _FLOAT
1369.     penetrationA = collisionPPFindAxisLeastPenetration(p(), body(), faceA(), A, B)
1370.     IF penetrationA >= 0.0 THEN EXIT SUB
1371.  
1372.     DIM faceB(100) AS INTEGER
1373.  
1374.     DIM penetrationB AS _FLOAT
1375.     penetrationB = collisionPPFindAxisLeastPenetration(p(), body(), faceB(), B, A)
1376.     IF penetrationB >= 0.0 THEN EXIT SUB
1377.  
1378.  
1379.     DIM referenceIndex AS INTEGER
1380.     DIM flip AS INTEGER
1381.  
1382.     DIM RefPoly AS INTEGER
1383.     DIM IncPoly AS INTEGER
1384.  
1385.     IF impulseGT(penetrationA, penetrationB) THEN
1386.         RefPoly = A
1387.         IncPoly = B
1388.         referenceIndex = faceA(0)
1389.         flip = 0
1390.     ELSE
1391.         RefPoly = B
1392.         IncPoly = A
1393.         referenceIndex = faceB(0)
1394.         flip = 1
1395.     END IF
1396.  
1397.     DIM incidentFace(2) AS tVECTOR2d
1398.  
1399.     CALL collisionPPFindIncidentFace(p(), body(), incidentFace(), RefPoly, IncPoly, referenceIndex)
1400.     DIM v1 AS tVECTOR2d
1401.     DIM v2 AS tVECTOR2d
1402.     DIM v1t AS tVECTOR2d
1403.     DIM v2t AS tVECTOR2d
1404.  
1405.     v1 = p(body(RefPoly).pa.start + referenceIndex).vert
1406.     referenceIndex = arrayNextIndex(referenceIndex, body(RefPoly).pa.count)
1407.     v2 = p(body(RefPoly).pa.start + referenceIndex).vert
1408.     '// Transform vertices to world space
1409.     '// v1 = RefPoly->u * v1 + RefPoly->body->position;
1410.     '// v2 = RefPoly->u * v2 + RefPoly->body->position;
1411.     CALL matrixMultiplyVector(body(RefPoly).shape.u, v1, v1t)
1412.     CALL vectorAddVectorND(v1, v1t, body(RefPoly).position)
1413.     CALL matrixMultiplyVector(body(RefPoly).shape.u, v2, v2t)
1414.     CALL vectorAddVectorND(v2, v2t, body(RefPoly).position)
1415.  
1416.     '// Calculate reference face side normal in world space
1417.     '// Vec2 sidePlaneNormal = (v2 - v1);
1418.     '// sidePlaneNormal.Normalize( );
1419.     DIM sidePlaneNormal AS tVECTOR2d
1420.     CALL vectorSubVectorND(sidePlaneNormal, v2, v1)
1421.     CALL vectorNormalize(sidePlaneNormal)
1422.  
1423.     '// Orthogonalize
1424.     '// Vec2 refFaceNormal( sidePlaneNormal.y, -sidePlaneNormal.x );
1425.     DIM refFaceNormal AS tVECTOR2d
1426.     CALL vectorSet(refFaceNormal, sidePlaneNormal.y, -sidePlaneNormal.x)
1427.  
1428.     '// ax + by = c
1429.     '// c is distance from origin
1430.     '// real refC = Dot( refFaceNormal, v1 );
1431.     '// real negSide = -Dot( sidePlaneNormal, v1 );
1432.     '// real posSide = Dot( sidePlaneNormal, v2 );
1433.     DIM refC AS _FLOAT: refC = vectorDot(refFaceNormal, v1)
1434.     DIM negSide AS _FLOAT: negSide = -vectorDot(sidePlaneNormal, v1)
1435.     DIM posSide AS _FLOAT: posSide = vectorDot(sidePlaneNormal, v2)
1436.  
1437.  
1438.     '// Clip incident face to reference face side planes
1439.     '// if(Clip( -sidePlaneNormal, negSide, incidentFace ) < 2)
1440.     DIM negSidePlaneNormal AS tVECTOR2d
1441.     CALL vectorNegND(negSidePlaneNormal, sidePlaneNormal)
1442.  
1443.     IF collisionPPClip(negSidePlaneNormal, negSide, incidentFace()) < 2 THEN EXIT SUB
1444.     IF collisionPPClip(sidePlaneNormal, posSide, incidentFace()) < 2 THEN EXIT SUB
1445.  
1446.     CALL vectorSet(m.normal, refFaceNormal.x, refFaceNormal.y)
1447.     IF flip THEN CALL vectorNeg(m.normal)
1448.  
1449.     '// Keep points behind reference face
1450.     DIM cp AS INTEGER: cp = 0 '// clipped points behind reference face
1451.     DIM separation AS _FLOAT
1452.     separation = vectorDot(refFaceNormal, incidentFace(0)) - refC
1453.     IF separation <= 0.0 THEN
1454.         contacts(cp) = incidentFace(0)
1455.         m.penetration = -separation
1456.         cp = cp + 1
1457.     ELSE
1458.         m.penetration = 0
1459.     END IF
1460.  
1461.     separation = vectorDot(refFaceNormal, incidentFace(1)) - refC
1462.     IF separation <= 0.0 THEN
1463.         contacts(cp) = incidentFace(1)
1464.         m.penetration = m.penetration + -separation
1465.         cp = cp + 1
1466.         m.penetration = m.penetration / cp
1467.     END IF
1468.     m.contactCount = cp
1469. END SUB
1470.  
1471. FUNCTION collisionPPFindAxisLeastPenetration (p() AS tPOLY, body() AS tBODY, faceIndex() AS INTEGER, A AS INTEGER, B AS INTEGER)
1472.     DIM bestDistance AS _FLOAT: bestDistance = -9999999
1473.     DIM bestIndex AS INTEGER: bestIndex = 0
1474.  
1475.     DIM n AS tVECTOR2d
1476.     DIM nw AS tVECTOR2d
1477.     DIM buT AS tMATRIX2d
1478.     DIM s AS tVECTOR2d
1479.     DIM nn AS tVECTOR2d
1480.     DIM v AS tVECTOR2d
1481.     DIM tv AS tVECTOR2d
1482.     DIM d AS _FLOAT
1483.     DIM i, k AS INTEGER
1484.  
1485.     FOR i = 0 TO body(A).pa.count
1486.         k = body(A).pa.start + i
1487.  
1488.         '// Retrieve a face normal from A
1489.         '// Vec2 n = A->m_normals[i];
1490.         '// Vec2 nw = A->u * n;
1491.         n = p(k).norm
1492.         CALL matrixMultiplyVector(body(A).shape.u, n, nw)
1493.  
1494.  
1495.         '// Transform face normal into B's model space
1496.         '// Mat2 buT = B->u.Transpose( );
1497.         '// n = buT * nw;
1498.         CALL matrixTranspose(body(B).shape.u, buT)
1499.         CALL matrixMultiplyVector(buT, nw, n)
1500.  
1501.         '// Retrieve support point from B along -n
1502.         '// Vec2 s = B->GetSupport( -n );
1503.         CALL vectorNegND(nn, n)
1504.         CALL vectorGetSupport(p(), body(), B, nn, s)
1505.  
1506.         '// Retrieve vertex on face from A, transform into
1507.         '// B's model space
1508.         '// Vec2 v = A->m_vertices[i];
1509.         '// v = A->u * v + A->body->position;
1510.         '// v -= B->body->position;
1511.         '// v = buT * v;
1512.  
1513.         v = p(k).vert
1514.         CALL matrixMultiplyVector(body(A).shape.u, v, tv)
1515.         CALL vectorAddVectorND(v, tv, body(A).position)
1516.  
1517.         CALL vectorSubVector(v, body(B).position)
1518.         CALL matrixMultiplyVector(buT, v, tv)
1519.  
1520.         CALL vectorSubVector(s, tv)
1521.         d = vectorDot(n, s)
1522.  
1523.         IF d > bestDistance THEN
1524.             bestDistance = d
1525.             bestIndex = i
1526.         END IF
1527.  
1528.     NEXT i
1529.  
1530.     faceIndex(0) = bestIndex
1531.  
1532.     collisionPPFindAxisLeastPenetration = bestDistance
1533. END FUNCTION
1534.  
1535. '**********************************************************************************************
1536. '   Shape Creation Ahead
1537. '**********************************************************************************************
1538.  
1539. SUB shapeCreate (sh AS tSHAPE, ty AS INTEGER, radius AS _FLOAT)
1540.     DIM u AS tMATRIX2d
1541.     CALL matrixSetScalar(u, 1, 0, 0, 1)
1542.     sh.ty = ty
1543.     sh.radius = radius
1544.     sh.u = u
1545.     sh.scaleTextureX = 1.0
1546.     sh.scaleTextureY = 1.0
1547. END SUB
1548.  
1549. '**********************************************************************************************
1550. '   Scene Creation Tools ahead
1551. '**********************************************************************************************
1552.  
1553. SUB setBody (body() AS tBODY, Parameter AS INTEGER, Index AS INTEGER, arg1 AS _FLOAT, arg2 AS _FLOAT)
1554.     SELECT CASE Parameter
1555.         CASE cPARAMETER_POSITION:
1556.             CALL vectorSet(body(Index).position, arg1, arg2)
1557.         CASE cPARAMETER_VELOCITY:
1558.             CALL vectorSet(body(Index).velocity, arg1, arg2)
1559.         CASE cPARAMETER_FORCE:
1560.             CALL vectorSet(body(Index).force, arg1, arg2)
1561.         CASE cPARAMETER_ANGULARVELOCITY:
1562.             body(Index).angularVelocity = arg1
1563.         CASE cPARAMETER_TORQUE:
1564.             body(Index).torque = arg1
1565.         CASE cPARAMETER_ORIENT:
1566.             body(Index).orient = arg1
1567.             CALL matrixSetRadians(body(Index).shape.u, body(Index).orient)
1568.         CASE cPARAMETER_STATICFRICTION:
1569.             body(Index).staticFriction = arg1
1570.         CASE cPARAMETER_DYNAMICFRICTION:
1571.             body(Index).dynamicFriction = arg1
1572.         CASE cPARAMETER_RESTITUTION:
1573.             body(Index).restitution = arg1
1574.         CASE cPARAMETER_COLOR:
1575.             body(Index).c = arg1
1576.         CASE cPARAMETER_ENABLE:
1577.             body(Index).enable = arg1
1578.         CASE cPARAMETER_STATIC:
1579.             CALL bodySetStatic(body(Index))
1580.         CASE cPARAMETER_TEXTURE:
1581.             body(Index).shape.texture = arg1
1582.         CASE cPARAMETER_FLIPTEXTURE: 'does the texture flip directions when moving left or right
1583.             body(Index).shape.flipTexture = arg1
1584.         CASE cPARAMETER_COLLISIONMASK:
1585.             body(Index).collisionMask = arg1
1586.     END SELECT
1587. END SUB
1588.  
1589. SUB setBodyEx (body() AS tBODY, Parameter AS INTEGER, objName AS STRING, arg1 AS _FLOAT, arg2 AS _FLOAT)
1590.     DIM index AS INTEGER
1591.     index = objectManagerID(body(), objName)
1592.  
1593.     IF index > -1 THEN
1594.         CALL setBody(body(), Parameter, index, arg1, arg2)
1595.     END IF
1596. END SUB
1597.  
1598.  
1599. FUNCTION createCircleBody (body() AS tBODY, index AS INTEGER, radius AS _FLOAT)
1600.     DIM shape AS tSHAPE
1601.     CALL shapeCreate(shape, cSHAPE_CIRCLE, radius)
1602.     CALL bodyCreate(body(), index, shape)
1603.     'no vertices have to created for circles
1604.     CALL circleInitialize(body(), index)
1605.     ' Even though circles do not have vertices, they still must be included in the vertices list
1606.     IF index = 0 THEN
1607.         body(index).pa.start = 0
1608.     ELSE
1609.         body(index).pa.start = body(index - 1).pa.start + body(index - 1).pa.count + 1
1610.     END IF
1611.     body(index).pa.count = 1
1612.     body(index).c = _RGB32(255, 255, 255)
1613.     createCircleBody = index
1614. END FUNCTION
1615.  
1616. FUNCTION createCircleBodyEx (body() AS tBODY, objName AS STRING, radius AS _FLOAT)
1617.     DIM shape AS tSHAPE
1618.     DIM index AS INTEGER
1619.     CALL shapeCreate(shape, cSHAPE_CIRCLE, radius)
1620.     CALL bodyCreateEx(body(), objName, shape, index)
1621.     'no vertices have to created for circles
1622.     CALL circleInitialize(body(), index)
1623.     ' Even though circles do not have vertices, they still must be included in the vertices list
1624.     IF index = 0 THEN
1625.         body(index).pa.start = 0
1626.     ELSE
1627.         body(index).pa.start = body(index - 1).pa.start + body(index - 1).pa.count + 1
1628.     END IF
1629.     body(index).pa.count = 1
1630.     body(index).c = _RGB32(255, 255, 255)
1631.     createCircleBodyEx = index
1632. END FUNCTION
1633.  
1634.  
1635. FUNCTION createBoxBodies (p() AS tPOLY, body() AS tBODY, index AS INTEGER, xs AS _FLOAT, ys AS _FLOAT)
1636.     DIM shape AS tSHAPE
1637.     CALL shapeCreate(shape, cSHAPE_POLYGON, 0)
1638.     CALL bodyCreate(body(), index, shape)
1639.     CALL boxCreate(p(), body(), index, xs, ys)
1640.     CALL polygonInitialize(body(), p(), index)
1641.     body(index).c = _RGB32(255, 255, 255)
1642.     createBoxBodies = index
1643. END FUNCTION
1644.  
1645. FUNCTION createBoxBodiesEx (p() AS tPOLY, body() AS tBODY, objName AS STRING, xs AS _FLOAT, ys AS _FLOAT)
1646.     DIM shape AS tSHAPE
1647.     DIM index AS INTEGER
1648.     CALL shapeCreate(shape, cSHAPE_POLYGON, 0)
1649.     CALL bodyCreateEx(body(), objName, shape, index)
1650.     CALL boxCreate(p(), body(), index, xs, ys)
1651.     CALL polygonInitialize(body(), p(), index)
1652.     body(index).c = _RGB32(255, 255, 255)
1653.     createBoxBodiesEx = index
1654. END FUNCTION
1655.  
1656. SUB createTrapBody (p() AS tPOLY, body() AS tBODY, index AS INTEGER, xs AS _FLOAT, ys AS _FLOAT, yoff1 AS _FLOAT, yoff2 AS _FLOAT)
1657.     DIM shape AS tSHAPE
1658.     CALL shapeCreate(shape, cSHAPE_POLYGON, 0)
1659.     CALL bodyCreate(body(), index, shape)
1660.     CALL trapCreate(p(), body(), index, xs, ys, yoff1, yoff2)
1661.     CALL polygonInitialize(body(), p(), index)
1662.     body(index).c = _RGB32(255, 255, 255)
1663. END SUB
1664.  
1665. SUB createTrapBodyEx (p() AS tPOLY, body() AS tBODY, objName AS STRING, xs AS _FLOAT, ys AS _FLOAT, yoff1 AS _FLOAT, yoff2 AS _FLOAT)
1666.     DIM shape AS tSHAPE
1667.     DIM index AS INTEGER
1668.     CALL shapeCreate(shape, cSHAPE_POLYGON, 0)
1669.     CALL bodyCreateEx(body(), objName, shape, index)
1670.     CALL trapCreate(p(), body(), index, xs, ys, yoff1, yoff2)
1671.     CALL polygonInitialize(body(), p(), index)
1672.     body(index).c = _RGB32(255, 255, 255)
1673. END SUB
1674.  
1675.  
1676. FUNCTION objectManagerAdd (body() AS tBODY)
1677.     objectManagerAdd = objectManager.objectCount
1678.     objectManager.objectCount = objectManager.objectCount + 1
1679.     IF objectManager.objectCount > sNUMBEROFBODIES THEN
1680.         sNUMBEROFBODIES = sNUMBEROFBODIES * 1.5
1681.         REDIM _PRESERVE body(sNUMBEROFBODIES) AS tBODY
1682.     END IF
1683. END FUNCTION
1684.  
1685. FUNCTION objectManagerID (body() AS tBODY, objName AS STRING)
1686.     DIM i AS INTEGER
1687.     DIM uID AS _INTEGER64
1688.     uID = computeHash(RTRIM$(LTRIM$(objName)))
1689.     objectManagerID = -1
1690.  
1691.     FOR i = 0 TO objectManager.objectCount
1692.         IF body(i).objectHash = uID THEN
1693.             objectManagerID = i
1694.             EXIT FUNCTION
1695.         END IF
1696.     NEXT
1697. END FUNCTION
1698.  
1699. SUB bodyCreateEx (body() AS tBODY, objName AS STRING, shape AS tSHAPE, index AS INTEGER)
1700.     index = objectManagerAdd(body())
1701.     body(index).objectName = objName
1702.     body(index).objectHash = computeHash(objName)
1703.     CALL bodyCreate(body(), index, shape)
1704. END SUB
1705.  
1706.  
1707. SUB bodyCreate (body() AS tBODY, index AS INTEGER, shape AS tSHAPE)
1708.     CALL vectorSet(body(index).position, 0, 0)
1709.     CALL vectorSet(body(index).velocity, 0, 0)
1710.     body(index).angularVelocity = 0.0
1711.     body(index).torque = 0.0
1712.     body(index).orient = 0.0
1713.  
1714.     CALL vectorSet(body(index).force, 0, 0)
1715.     body(index).staticFriction = 0.5
1716.     body(index).dynamicFriction = 0.3
1717.     body(index).restitution = 0.2
1718.     body(index).shape = shape
1719.     body(index).collisionMask = 255
1720.     body(index).enable = 1
1721. END SUB
1722.  
1723. SUB boxCreate (p() AS tPOLY, body() AS tBODY, index AS INTEGER, sizex AS _FLOAT, sizey AS _FLOAT)
1724.     DIM vertlength AS INTEGER: vertlength = 3
1725.     DIM verts(vertlength) AS tVECTOR2d
1726.  
1727.     CALL vectorSet(verts(0), -sizex, -sizey)
1728.     CALL vectorSet(verts(1), sizex, -sizey)
1729.     CALL vectorSet(verts(2), sizex, sizey)
1730.     CALL vectorSet(verts(3), -sizex, sizey)
1731.  
1732.     CALL vertexSet(p(), body(), index, verts(), vertlength)
1733. END SUB
1734.  
1735. SUB trapCreate (p() AS tPOLY, body() AS tBODY, index AS INTEGER, sizex AS _FLOAT, sizey AS _FLOAT, yOff1 AS _FLOAT, yOff2 AS _FLOAT)
1736.     DIM vertlength AS INTEGER: vertlength = 3
1737.     DIM verts(vertlength) AS tVECTOR2d
1738.  
1739.     CALL vectorSet(verts(0), -sizex, -sizey - yOff2)
1740.     CALL vectorSet(verts(1), sizex, -sizey - yOff1)
1741.     CALL vectorSet(verts(2), sizex, sizey)
1742.     CALL vectorSet(verts(3), -sizex, sizey)
1743.  
1744.     CALL vertexSet(p(), body(), index, verts(), vertlength)
1745. END SUB
1746.  
1747. SUB createTerrianBody (p() AS tPOLY, body() AS tBODY, index AS INTEGER, slices AS INTEGER, sliceWidth AS _FLOAT, nominalHeight AS _FLOAT)
1748.     DIM shape AS tSHAPE
1749.     DIM elevation(slices) AS _FLOAT
1750.  
1751.     DIM AS INTEGER i, j
1752.     FOR j = 0 TO slices
1753.         elevation(j) = RND * 500
1754.     NEXT
1755.  
1756.     CALL shapeCreate(shape, cSHAPE_POLYGON, 0)
1757.  
1758.     FOR i = 0 TO slices - 1
1759.         CALL bodyCreate(body(), index + i, shape)
1760.         CALL terrainCreate(p(), body(), index + i, elevation(i), elevation(i + 1), sliceWidth, nominalHeight)
1761.         CALL polygonInitialize(body(), p(), index + i)
1762.         body(index + i).c = _RGB32(255, 255, 255)
1763.         CALL bodySetStatic(body(index + i))
1764.     NEXT i
1765.  
1766. END SUB
1767.  
1768. SUB createTerrianBodyEx (p() AS tPOLY, body() AS tBODY, objName AS STRING, elevation() AS _FLOAT, slices AS INTEGER, sliceWidth AS _FLOAT, nominalHeight AS _FLOAT)
1769.     DIM shape AS tSHAPE
1770.  
1771.     DIM AS INTEGER i, index
1772.  
1773.     CALL shapeCreate(shape, cSHAPE_POLYGON, 0)
1774.  
1775.     FOR i = 0 TO slices - 1
1776.         CALL bodyCreateEx(body(), objName + "_" + LTRIM$(STR$(i)), shape, index)
1777.         CALL terrainCreate(p(), body(), index, elevation(i), elevation(i + 1), sliceWidth, nominalHeight)
1778.         CALL polygonInitialize(body(), p(), index)
1779.         body(index).c = _RGB32(255, 255, 255)
1780.         CALL bodySetStatic(body(index))
1781.     NEXT i
1782.  
1783.     DIM AS _FLOAT p1, p2
1784.     DIM start AS _INTEGER64
1785.  
1786.     FOR i = 0 TO slices - 1
1787.         start = objectManagerID(body(), objName + "_" + LTRIM$(STR$(i)))
1788.         p1 = (sliceWidth / 2) - p(body(start).pa.start).vert.x
1789.         p2 = nominalHeight - p(body(start).pa.start + 1).vert.y
1790.         CALL setBody(body(), cPARAMETER_POSITION, start, world.terrainPosition.x + p1 + (sliceWidth * i), world.terrainPosition.y + p2)
1791.     NEXT
1792. END SUB
1793.  
1794.  
1795. SUB terrainCreate (p() AS tPOLY, body() AS tBODY, index AS INTEGER, ele1 AS _FLOAT, ele2 AS _FLOAT, sliceWidth AS _FLOAT, nominalHeight AS _FLOAT)
1796.     DIM AS INTEGER vertLength
1797.     vertLength = 3 ' numOfslices + 1
1798.     DIM verts(vertLength) AS tVECTOR2d
1799.  
1800.     CALL vectorSet(verts(0), 0, nominalHeight)
1801.     CALL vectorSet(verts(1), (0) * sliceWidth, -nominalHeight - ele1)
1802.     CALL vectorSet(verts(2), (1) * sliceWidth, -nominalHeight - ele2)
1803.     CALL vectorSet(verts(3), (1) * sliceWidth, nominalHeight)
1804.     CALL vertexSet(p(), body(), index, verts(), vertLength)
1805. END SUB
1806.  
1807.  
1808.  
1809. SUB vShapeCreate (p() AS tPOLY, body() AS tBODY, index AS INTEGER, sizex AS _FLOAT, sizey AS _FLOAT)
1810.     DIM vertlength AS INTEGER: vertlength = 7
1811.     DIM verts(vertlength) AS tVECTOR2d
1812.  
1813.     CALL vectorSet(verts(0), -sizex, -sizey)
1814.     CALL vectorSet(verts(1), sizex, -sizey)
1815.     CALL vectorSet(verts(2), sizex, sizey)
1816.     CALL vectorSet(verts(3), -sizex, sizey)
1817.     CALL vectorSet(verts(4), -sizex, sizey / 2)
1818.     CALL vectorSet(verts(5), sizex / 2, sizey / 2)
1819.     CALL vectorSet(verts(6), sizex / 2, -sizey / 2)
1820.     CALL vectorSet(verts(7), -sizex, sizey / 2)
1821.  
1822.     CALL vertexSet(p(), body(), index, verts(), vertlength)
1823. END SUB
1824.  
1825. SUB vertexSet (p() AS tPOLY, body() AS tBODY, index AS INTEGER, verts() AS tVECTOR2d, vertLength AS INTEGER)
1826.     DIM rightMost AS INTEGER: rightMost = 0
1827.     DIM highestXCoord AS _FLOAT: highestXCoord = verts(0).x
1828.     DIM i AS INTEGER
1829.     DIM x AS _FLOAT
1830.     FOR i = 1 TO vertLength
1831.         x = verts(i).x
1832.         IF x > highestXCoord THEN
1833.             highestXCoord = x
1834.             rightMost = i
1835.         ELSE
1836.             IF x = highestXCoord THEN
1837.                 IF verts(i).y < verts(rightMost).y THEN
1838.                     rightMost = i
1839.                 END IF
1840.             END IF
1841.         END IF
1842.     NEXT
1843.     DIM hull(cMAXNUMBEROFPOLYGONS) AS INTEGER
1844.     DIM outCount AS INTEGER: outCount = 0
1845.     DIM indexHull AS INTEGER: indexHull = rightMost
1846.     DIM nextHullIndex AS INTEGER
1847.     DIM e1 AS tVECTOR2d
1848.     DIM e2 AS tVECTOR2d
1849.     DIM c AS _FLOAT
1850.     DO
1851.         hull(outCount) = indexHull
1852.         nextHullIndex = 0
1853.         FOR i = 1 TO vertLength
1854.             IF nextHullIndex = indexHull THEN
1855.                 nextHullIndex = i
1856.                 _CONTINUE
1857.             END IF
1858.             CALL vectorSubVectorND(e1, verts(nextHullIndex), verts(hull(outCount)))
1859.             CALL vectorSubVectorND(e2, verts(i), verts(hull(outCount)))
1860.             c = vectorCross(e1, e2)
1861.             IF c < 0.0 THEN nextHullIndex = i
1862.             IF c = 0.0 AND (vectorLengthSq(e2) > vectorLengthSq(e1)) THEN
1863.                 nextHullIndex = i
1864.             END IF
1865.         NEXT
1866.         outCount = outCount + 1
1867.         indexHull = nextHullIndex
1868.         IF nextHullIndex = rightMost THEN
1869.             body(index).pa.count = outCount - 1
1870.             EXIT DO
1871.         END IF
1872.     LOOP
1873.  
1874.     IF index = 0 THEN
1875.         body(index).pa.start = 0
1876.     ELSE
1877.         body(index).pa.start = body(index - 1).pa.start + body(index - 1).pa.count + 1
1878.     END IF
1879.  
1880.     FOR i = 0 TO vertLength
1881.         p(body(index).pa.start + i).vert = verts(hull(i))
1882.     NEXT
1883.  
1884.     DIM face AS tVECTOR2d
1885.     FOR i = 0 TO vertLength
1886.         CALL vectorSubVectorND(face, p(body(index).pa.start + arrayNextIndex(i, body(index).pa.count)).vert, p(body(index).pa.start + i).vert)
1887.         CALL vectorSet(p(body(index).pa.start + i).norm, face.y, -face.x)
1888.         CALL vectorNormalize(p(body(index).pa.start + i).norm)
1889.     NEXT
1890. END SUB
1891.  
1892. FUNCTION arrayNextIndex (i AS INTEGER, count AS INTEGER)
1893.     arrayNextIndex = ((i + 1) MOD (count + 1))
1894. END FUNCTION
1895.  
1896. '**********************************************************************************************
1897. '   Rendering Stuff Ahead
1898. '**********************************************************************************************
1899.  
1900. SUB renderFps
1901.     fpsLast = fps
1902.     fps = 0
1903. END SUB
1904.  
1905. FUNCTION AABBOverlap (Ax AS _FLOAT, Ay AS _FLOAT, Aw AS _FLOAT, Ah AS _FLOAT, Bx AS _FLOAT, By AS _FLOAT, Bw AS _FLOAT, Bh AS _FLOAT)
1906.     AABBOverlap = Ax < Bx + Bw AND Ax + Aw > Bx AND Ay < By + Bh AND Ay + Ah > By
1907. END FUNCTION
1908.  
1909. FUNCTION AABBOverlapVector (A AS tVECTOR2d, Aw AS _FLOAT, Ah AS _FLOAT, B AS tVECTOR2d, Bw AS _FLOAT, Bh AS _FLOAT)
1910.     AABBOverlapVector = AABBOverlap(A.x, A.y, Aw, Ah, B.x, B.y, Bw, Bh)
1911. END FUNCTION
1912.  
1913.  
1914. SUB renderBodies (p() AS tPOLY, body() AS tBODY, j() AS tJOINT, hits() AS tHIT, camera AS tCAMERA)
1915.     DIM i AS INTEGER
1916.     DIM hitcount AS INTEGER
1917.     DIM camoffset AS tVECTOR2d
1918.     DIM AS _FLOAT cx, cy, cwx, cwy, ox, oy, owx, owy, ccw, cch
1919.     ccw = _WIDTH / 2
1920.     cch = _HEIGHT / 2
1921.     FOR i = 0 TO objectManager.objectCount
1922.         IF body(i).enable THEN
1923.             'AABB to cut down on rendering objects out of camera view
1924.             cx = camera.position.x - ccw
1925.             cy = camera.position.y - cch
1926.             cwx = _WIDTH
1927.             cwy = _HEIGHT
1928.             ox = body(i).position.x - 2000
1929.             oy = body(i).position.y - 2000
1930.             owx = 4000
1931.             owy = 4000
1932.             IF AABBOverlap(cx, cy, cwx, cwy, ox, oy, owx, owy) THEN
1933.                 IF body(i).shape.ty = cSHAPE_CIRCLE THEN
1934.                     IF body(i).shape.texture = 0 THEN
1935.                         CALL renderWireframeCircle(body(), i, camera)
1936.                     ELSE
1937.                         CALL renderTexturedCircle(body(), i, camera)
1938.                     END IF
1939.                 ELSE IF body(i).shape.ty = cSHAPE_POLYGON THEN
1940.                         IF body(i).shape.texture = 0 THEN
1941.                             CALL renderWireframePoly(p(), body(), i, camera)
1942.                         ELSE
1943.                             CALL renderTexturedBox(p(), body(), i, camera)
1944.                         END IF
1945.                     END IF
1946.                 END IF
1947.             END IF
1948.         END IF
1949.     NEXT
1950.     IF cRENDER_JOINTS THEN
1951.         FOR i = 1 TO sNUMBEROFJOINTS
1952.             CALL renderJoints(j(i), body(), camera)
1953.         NEXT
1954.     END IF
1955.     IF cRENDER_COLLISIONS THEN
1956.         hitcount = 0
1957.         DO WHILE hits(hitcount).A <> hits(hitcount).B
1958.             CALL vectorSubVectorND(camoffset, hits(hitcount).position, camera.position)
1959.             CIRCLE (camoffset.x, camoffset.y), 5, _RGB(255, 6, 11)
1960.             hitcount = hitcount + 1
1961.         LOOP
1962.     END IF
1963.  
1964. END SUB
1965.  
1966. SUB renderJoints (j AS tJOINT, b() AS tBODY, camera AS tCAMERA)
1967.     DIM b1 AS tBODY: b1 = b(j.body1)
1968.     DIM b2 AS tBODY: b2 = b(j.body2)
1969.     DIM R1 AS tMATRIX2d: R1 = b1.shape.u
1970.     DIM R2 AS tMATRIX2d: R2 = b2.shape.u
1971.  
1972.     DIM x1 AS tVECTOR2d: x1 = b1.position
1973.     DIM p1 AS tVECTOR2d: CALL matrixMultiplyVector(R1, j.localAnchor1, p1)
1974.  
1975.     CALL vectorAddVectorND(p1, p1, x1)
1976.  
1977.     DIM x2 AS tVECTOR2d: x2 = b2.position
1978.     DIM p2 AS tVECTOR2d: CALL matrixMultiplyVector(R2, j.localAnchor2, p2)
1979.  
1980.     CALL vectorAddVectorND(p2, p2, x2)
1981.  
1982.     CALL vectorSubVector(p1, camera.position)
1983.     CALL vectorSubVector(x2, camera.position)
1984.  
1985.     LINE (p1.x, p1.y)-(x2.x, x2.y), _RGB(255, 255, 127) 'yellow
1986. END SUB
1987.  
1988. SUB renderWireframePoly (p() AS tPOLY, b() AS tBODY, index AS INTEGER, camera AS tCAMERA)
1989.     DIM a AS tVECTOR2d ' dummy vertices
1990.     DIM b AS tVECTOR2d
1991.     DIM tv AS tVECTOR2d
1992.     CALL vectorSet(tv, _WIDTH / 2, _HEIGHT / 2)
1993.  
1994.     DIM i, element, element_next AS INTEGER
1995.     FOR i = 0 TO b(index).pa.count
1996.         element = b(index).pa.start + i
1997.         element_next = b(index).pa.start + arrayNextIndex(i, b(index).pa.count)
1998.         a = p(element).vert
1999.         b = p(element_next).vert
2000.         CALL worldToCamera(b(), camera, index, a)
2001.         CALL worldToCamera(b(), camera, index, b)
2002.         LINE (a.x, a.y)-(b.x, b.y), b(index).c
2003.     NEXT
2004. END SUB
2005.  
2006. SUB renderTexturedBox (p() AS tPOLY, b() AS tBODY, index AS INTEGER, camera AS tCAMERA)
2007.     DIM vert(3) AS tVECTOR2d
2008.  
2009.     DIM AS INTEGER W, H
2010.     DIM bm AS LONG ' Texture map
2011.     bm = b(index).shape.texture
2012.     W = _WIDTH(bm): H = _HEIGHT(bm)
2013.  
2014.     DIM i AS INTEGER
2015.     FOR i = 0 TO 3
2016.         vert(i) = p(b(index).pa.start + i).vert
2017.         vert(i).x = vert(i).x + b(index).shape.offsetTextureX
2018.         vert(i).y = vert(i).y + b(index).shape.offsetTextureY
2019.         vert(i).x = vert(i).x * b(index).shape.scaleTextureX
2020.         vert(i).y = vert(i).y * b(index).shape.scaleTextureY
2021.         CALL worldToCamera(b(), camera, index, vert(i))
2022.     NEXT
2023.     IF b(index).velocity.x > 1 OR b(index).shape.flipTexture = 0 THEN
2024.         _MAPTRIANGLE (0, 0)-(W - 1, 0)-(W - 1, H - 1), bm TO(vert(3).x, vert(3).y)-(vert(0).x, vert(0).y)-(vert(1).x, vert(1).y)
2025.         _MAPTRIANGLE (0, 0)-(0, H - 1)-(W - 1, H - 1), bm TO(vert(3).x, vert(3).y)-(vert(2).x, vert(2).y)-(vert(1).x, vert(1).y)
2026.     ELSE
2027.         _MAPTRIANGLE (0, 0)-(W - 1, 0)-(W - 1, H - 1), bm TO(vert(0).x, vert(0).y)-(vert(3).x, vert(3).y)-(vert(2).x, vert(2).y)
2028.         _MAPTRIANGLE (0, 0)-(0, H - 1)-(W - 1, H - 1), bm TO(vert(0).x, vert(0).y)-(vert(1).x, vert(1).y)-(vert(2).x, vert(2).y)
2029.     END IF
2030.  
2031. END SUB
2032.  
2033. SUB renderWireframeCircle (b() AS tBODY, index AS INTEGER, camera AS tCAMERA)
2034.     DIM tv AS tVECTOR2d: tv = b(index).position
2035.     tv.x = tv.x * camera.zoom
2036.     tv.y = tv.y * camera.zoom
2037.     CALL worldToCameraNR(b(), camera, index, tv)
2038.     CIRCLE (tv.x, tv.y), b(index).shape.radius * camera.zoom, b(index).c
2039.     LINE (tv.x, tv.y)-(tv.x + COS(b(index).orient) * (b(index).shape.radius * camera.zoom), tv.y + SIN(b(index).orient) * (b(index).shape.radius) * camera.zoom), b(index).c
2040. END SUB
2041.  
2042. SUB renderTexturedCircle (b() AS tBODY, index AS INTEGER, camera AS tCAMERA)
2043.     DIM vert(3) AS tVECTOR2d
2044.     DIM W, H AS INTEGER
2045.     DIM bm AS LONG
2046.     'DIM tv AS tVECTOR2d
2047.     ' CALL vectorSet(tv, _WIDTH / 2 * (1 / camera.zoom), _HEIGHT / 2 * (1 / camera.zoom))
2048.  
2049.     bm = b(index).shape.texture
2050.     W = _WIDTH(bm): H = _HEIGHT(bm)
2051.     CALL vectorSet(vert(0), -b(index).shape.radius, -b(index).shape.radius)
2052.     CALL vectorSet(vert(1), -b(index).shape.radius, b(index).shape.radius)
2053.     CALL vectorSet(vert(2), b(index).shape.radius, b(index).shape.radius)
2054.     CALL vectorSet(vert(3), b(index).shape.radius, -b(index).shape.radius)
2055.     DIM i AS INTEGER
2056.     FOR i = 0 TO 3
2057.         CALL worldToCamera(b(), camera, index, vert(i))
2058.     NEXT
2059.     _MAPTRIANGLE (0, 0)-(0, H - 1)-(W - 1, H - 1), bm TO(vert(0).x, vert(0).y)-(vert(1).x, vert(1).y)-(vert(2).x, vert(2).y)
2060.     _MAPTRIANGLE (0, 0)-(W - 1, 0)-(W - 1, H - 1), bm TO(vert(0).x, vert(0).y)-(vert(3).x, vert(3).y)-(vert(2).x, vert(2).y)
2061.  
2062. END SUB
2063.  
2064. SUB worldToCamera (body() AS tBODY, camera AS tCAMERA, index AS INTEGER, vert AS tVECTOR2d)
2065.     DIM tv AS tVECTOR2d
2066.     CALL vectorSet(tv, _WIDTH / 2 * (1 / camera.zoom), _HEIGHT / 2 * (1 / camera.zoom)) ' Camera Center
2067.     CALL matrixMultiplyVector(body(index).shape.u, vert, vert) ' Rotate body
2068.     CALL vectorAddVector(vert, body(index).position) ' Add Position
2069.     CALL vectorSubVector(vert, camera.position) 'Sub Camera Position
2070.     CALL vectorAddVector(vert, tv) ' Add to camera Center
2071.     CALL vectorMultiplyScalar(vert, camera.zoom) 'Zoom everything
2072. END SUB
2073.  
2074. SUB worldToCameraNR (body() AS tBODY, camera AS tCAMERA, index AS INTEGER, vert AS tVECTOR2d)
2075.     DIM tv AS tVECTOR2d
2076.     CALL vectorSet(tv, _WIDTH / 2 * (1 / camera.zoom), _HEIGHT / 2 * (1 / camera.zoom)) ' Camera Center
2077.     CALL vectorSetVector(vert, body(index).position) ' Add Position
2078.     CALL vectorSubVector(vert, camera.position) 'Sub Camera Position
2079.     CALL vectorAddVector(vert, tv) ' Add to camera Center
2080.     CALL vectorMultiplyScalar(vert, camera.zoom) 'Zoom everything
2081. END SUB
2082.  
2083.  
2084. SUB polygonSetOrient (b AS tBODY, radians AS _FLOAT)
2085.     CALL matrixSetRadians(b.shape.u, radians)
2086. END SUB
2087.  
2088. '**********************************************************************************************
2089. '   Object initialization Ahead
2090. '**********************************************************************************************
2091.  
2092. SUB circleInitialize (b() AS tBODY, index AS INTEGER)
2093.     CALL circleComputeMass(b(), index, .10)
2094. END SUB
2095.  
2096. SUB circleComputeMass (b() AS tBODY, index AS INTEGER, density AS _FLOAT)
2097.     b(index).mass = cPI * b(index).shape.radius * b(index).shape.radius * density
2098.     IF b(index).mass <> 0 THEN
2099.         b(index).invMass = 1.0 / b(index).mass
2100.     ELSE
2101.         b(index).invMass = 0.0
2102.     END IF
2103.  
2104.     b(index).inertia = b(index).mass * b(index).shape.radius * b(index).shape.radius
2105.  
2106.     IF b(index).inertia <> 0 THEN
2107.         b(index).invInertia = 1.0 / b(index).inertia
2108.     ELSE
2109.         b(index).invInertia = 0.0
2110.     END IF
2111. END SUB
2112.  
2113. SUB polygonInitialize (body() AS tBODY, p() AS tPOLY, index AS INTEGER)
2114.     CALL polygonComputeMass(body(), p(), index, .10)
2115. END SUB
2116.  
2117. SUB polygonComputeMass (b() AS tBODY, p() AS tPOLY, index AS INTEGER, density AS _FLOAT)
2118.     DIM c AS tVECTOR2d ' centroid
2119.     DIM p1 AS tVECTOR2d
2120.     DIM p2 AS tVECTOR2d
2121.     DIM area AS _FLOAT
2122.     DIM I AS _FLOAT
2123.     DIM k_inv3 AS _FLOAT
2124.     DIM D AS _FLOAT
2125.     DIM triangleArea AS _FLOAT
2126.     DIM weight AS _FLOAT
2127.     DIM intx2 AS _FLOAT
2128.     DIM inty2 AS _FLOAT
2129.     DIM ii AS INTEGER
2130.  
2131.     k_inv3 = 1.0 / 3.0
2132.  
2133.     FOR ii = 0 TO b(index).pa.count
2134.         p1 = p(b(index).pa.start + ii).vert
2135.         p2 = p(b(index).pa.start + arrayNextIndex(ii, b(index).pa.count)).vert
2136.         D = vectorCross(p1, p2)
2137.         triangleArea = .5 * D
2138.         area = area + triangleArea
2139.         weight = triangleArea * k_inv3
2140.         CALL vectorAddVectorScalar(c, p1, weight)
2141.         CALL vectorAddVectorScalar(c, p2, weight)
2142.         intx2 = p1.x * p1.x + p2.x * p1.x + p2.x * p2.x
2143.         inty2 = p1.y * p1.y + p2.y * p1.y + p2.y * p2.y
2144.         I = I + (0.25 * k_inv3 * D) * (intx2 + inty2)
2145.     NEXT ii
2146.  
2147.     CALL vectorMultiplyScalar(c, 1.0 / area)
2148.  
2149.     FOR ii = 0 TO b(index).pa.count
2150.         CALL vectorSubVector(p(b(index).pa.start + ii).vert, c)
2151.     NEXT
2152.  
2153.     b(index).mass = density * area
2154.     IF b(index).mass <> 0.0 THEN
2155.         b(index).invMass = 1.0 / b(index).mass
2156.     ELSE
2157.         b(index).invMass = 0.0
2158.     END IF
2159.  
2160.     b(index).inertia = I * density
2161.     IF b(index).inertia <> 0 THEN
2162.         b(index).invInertia = 1.0 / b(index).inertia
2163.     ELSE
2164.         b(index).invInertia = 0.0
2165.     END IF
2166. END SUB
2167. '**********************************************************************************************
2168. '   Joint Stuff Ahead
2169. '**********************************************************************************************
2170. SUB jointSet (j AS tJOINT, body() AS tBODY, b1 AS INTEGER, b2 AS INTEGER, x AS _FLOAT, y AS _FLOAT)
2171.     DIM anchor AS tVECTOR2d
2172.     CALL vectorSet(anchor, x, y)
2173.     DIM Rot1 AS tMATRIX2d: Rot1 = body(b1).shape.u
2174.     DIM Rot2 AS tMATRIX2d: Rot2 = body(b2).shape.u
2175.     DIM Rot1T AS tMATRIX2d: CALL matrixTranspose(Rot1, Rot1T)
2176.     DIM Rot2T AS tMATRIX2d: CALL matrixTranspose(Rot2, Rot2T)
2177.     DIM tv AS tVECTOR2d
2178.  
2179.     j.body1 = b1
2180.     j.body2 = b2
2181.  
2182.     CALL vectorSubVectorND(tv, anchor, body(b1).position)
2183.     CALL matrixMultiplyVector(Rot1T, tv, j.localAnchor1)
2184.  
2185.     CALL vectorSubVectorND(tv, anchor, body(b2).position)
2186.     CALL matrixMultiplyVector(Rot2T, tv, j.localAnchor2)
2187.  
2188.     CALL vectorSet(j.P, 0, 0)
2189.  
2190.     j.softness = 0.001
2191.     j.biasFactor = 100
2192.  
2193. END SUB
2194.  
2195. SUB jointPrestep (j AS tJOINT, body() AS tBODY, inv_dt AS _FLOAT)
2196.     DIM Rot1 AS tMATRIX2d: Rot1 = body(j.body1).shape.u
2197.     DIM Rot2 AS tMATRIX2d: Rot2 = body(j.body2).shape.u
2198.     DIM b1invMass AS _FLOAT
2199.     DIM b2invMass AS _FLOAT
2200.  
2201.     DIM b1invInertia AS _FLOAT
2202.     DIM b2invInertia AS _FLOAT
2203.  
2204.     CALL matrixMultiplyVector(Rot1, j.localAnchor1, j.r1)
2205.     CALL matrixMultiplyVector(Rot2, j.localAnchor2, j.r2)
2206.  
2207.     b1invMass = body(j.body1).invMass
2208.     b2invMass = body(j.body2).invMass
2209.  
2210.     b1invInertia = body(j.body1).invInertia
2211.     b2invInertia = body(j.body2).invInertia
2212.  
2213.     DIM K1 AS tMATRIX2d
2214.     Call matrixSetScalar(K1, b1invMass + b2invMass, 0,_
2215.                                                 0, b1invMass + b2invMass)
2216.     DIM K2 AS tMATRIX2d
2217.     Call matrixSetScalar(K2, b1invInertia * j.r1.y * j.r1.y, -b1invInertia * j.r1.x * j.r1.y,_
2218.                             -b1invInertia * j.r1.x * j.r1.y,  b1invInertia * j.r1.x * j.r1.x)
2219.  
2220.     DIM K3 AS tMATRIX2d
2221.     Call matrixSetScalar(K3,  b2invInertia * j.r2.y * j.r2.y, - b2invInertia * j.r2.x * j.r2.y,_
2222.                              -b2invInertia * j.r2.x * j.r2.y,   b2invInertia * j.r2.x * j.r2.x)
2223.  
2224.     DIM K AS tMATRIX2d
2225.     CALL matrixAddMatrix(K1, K2, K)
2226.     CALL matrixAddMatrix(K3, K, K)
2227.     K.m00 = K.m00 + j.softness
2228.     K.m11 = K.m11 + j.softness
2229.     CALL matrixInvert(K, j.M)
2230.  
2231.     DIM p1 AS tVECTOR2d: CALL vectorAddVectorND(p1, body(j.body1).position, j.r1)
2232.     DIM p2 AS tVECTOR2d: CALL vectorAddVectorND(p2, body(j.body2).position, j.r2)
2233.     DIM dp AS tVECTOR2d: CALL vectorSubVectorND(dp, p2, p1)
2234.  
2235.     CALL vectorMultiplyScalarND(j.bias, dp, -j.biasFactor * inv_dt)
2236.     'Call vectorSet(j.bias, 0, 0)
2237.     CALL vectorSet(j.P, 0, 0)
2238. END SUB
2239.  
2240. SUB jointApplyImpulse (j AS tJOINT, body() AS tBODY)
2241.     DIM dv AS tVECTOR2d
2242.     DIM impulse AS tVECTOR2d
2243.     DIM cross1 AS tVECTOR2d
2244.     DIM cross2 AS tVECTOR2d
2245.     DIM tv AS tVECTOR2d
2246.  
2247.  
2248.     'Vec2 dv = body2->velocity + Cross(body2->angularVelocity, r2) - body1->velocity - Cross(body1->angularVelocity, r1);
2249.     CALL vectorCrossScalar(cross2, j.r2, body(j.body2).angularVelocity)
2250.     CALL vectorCrossScalar(cross1, j.r1, body(j.body1).angularVelocity)
2251.     CALL vectorAddVectorND(dv, body(j.body2).velocity, cross2)
2252.     CALL vectorSubVectorND(dv, dv, body(j.body1).velocity)
2253.     CALL vectorSubVectorND(dv, dv, cross1)
2254.  
2255.     ' impulse = M * (bias - dv - softness * P);
2256.     CALL vectorMultiplyScalarND(tv, j.P, j.softness)
2257.     CALL vectorSubVectorND(impulse, j.bias, dv)
2258.     CALL vectorSubVectorND(impulse, impulse, tv)
2259.     CALL matrixMultiplyVector(j.M, impulse, impulse)
2260.  
2261.     ' body1->velocity -= body1->invMass * impulse;
2262.  
2263.     CALL vectorMultiplyScalarND(tv, impulse, body(j.body1).invMass)
2264.     CALL vectorSubVectorND(body(j.body1).velocity, body(j.body1).velocity, tv)
2265.  
2266.     ' body1->angularVelocity -= body1->invI * Cross(r1, impulse);
2267.     DIM crossScalar AS _FLOAT
2268.     crossScalar = vectorCross(j.r1, impulse)
2269.     body(j.body1).angularVelocity = body(j.body1).angularVelocity - body(j.body1).invInertia * crossScalar
2270.  
2271.     CALL vectorMultiplyScalarND(tv, impulse, body(j.body2).invMass)
2272.     CALL vectorAddVectorND(body(j.body2).velocity, body(j.body2).velocity, tv)
2273.  
2274.     crossScalar = vectorCross(j.r2, impulse)
2275.     body(j.body2).angularVelocity = body(j.body2).angularVelocity + body(j.body2).invInertia * crossScalar
2276.  
2277.     CALL vectorAddVectorND(j.P, j.P, impulse)
2278.  
2279. END SUB
2280.  
2281. '**********************************************************************************************
2282. '   Vector Math Ahead
2283. '**********************************************************************************************
2284.  
2285. SUB vectorSet (v AS tVECTOR2d, x AS _FLOAT, y AS _FLOAT)
2286.     v.x = x
2287.     v.y = y
2288. END SUB
2289.  
2290. SUB vectorSetVector (o AS tVECTOR2d, v AS tVECTOR2d)
2291.     o.x = v.x
2292.     o.y = v.y
2293. END SUB
2294.  
2295. SUB vectorNeg (v AS tVECTOR2d)
2296.     v.x = -v.x
2297.     v.y = -v.y
2298. END SUB
2299.  
2300. SUB vectorNegND (o AS tVECTOR2d, v AS tVECTOR2d)
2301.     o.x = -v.x
2302.     o.y = -v.y
2303. END SUB
2304.  
2305. SUB vectorMultiplyScalar (v AS tVECTOR2d, s AS _FLOAT)
2306.     v.x = v.x * s
2307.     v.y = v.y * s
2308. END SUB
2309.  
2310. SUB vectorMultiplyScalarND (o AS tVECTOR2d, v AS tVECTOR2d, s AS _FLOAT)
2311.     o.x = v.x * s
2312.     o.y = v.y * s
2313. END SUB
2314.  
2315. SUB vectorDivideScalar (v AS tVECTOR2d, s AS _FLOAT)
2316.     v.x = v.x / s
2317.     v.y = v.y / s
2318. END SUB
2319.  
2320. SUB vectorDivideScalarND (o AS tVECTOR2d, v AS tVECTOR2d, s AS _FLOAT)
2321.     o.x = v.x / s
2322.     o.y = v.y / s
2323. END SUB
2324.  
2325. SUB vectorAddScalar (v AS tVECTOR2d, s AS _FLOAT)
2326.     v.x = v.x + s
2327.     v.y = v.y + s
2328. END SUB
2329.  
2330. SUB vectorAddScalarND (o AS tVECTOR2d, v AS tVECTOR2d, s AS _FLOAT)
2331.     o.x = v.x + s
2332.     o.y = v.y + s
2333. END SUB
2334.  
2335. SUB vectorMultiplyVector (v AS tVECTOR2d, m AS tVECTOR2d)
2336.     v.x = v.x * m.x
2337.     v.y = v.y * m.y
2338. END SUB
2339.  
2340. SUB vectorMultiplyVectorND (o AS tVECTOR2d, v AS tVECTOR2d, m AS tVECTOR2d)
2341.     o.x = v.x * m.x
2342.     o.y = v.y * m.y
2343. END SUB
2344.  
2345. SUB vectorDivideVector (v AS tVECTOR2d, m AS tVECTOR2d)
2346.     v.x = v.x / m.x
2347.     v.y = v.y / m.y
2348. END SUB
2349.  
2350. SUB vectorAddVector (v AS tVECTOR2d, m AS tVECTOR2d)
2351.     v.x = v.x + m.x
2352.     v.y = v.y + m.y
2353. END SUB
2354.  
2355. SUB vectorAddVectorND (o AS tVECTOR2d, v AS tVECTOR2d, m AS tVECTOR2d)
2356.     o.x = v.x + m.x
2357.     o.y = v.y + m.y
2358. END SUB
2359.  
2360. SUB vectorAddVectorScalar (v AS tVECTOR2d, m AS tVECTOR2d, s AS _FLOAT)
2361.     v.x = v.x + m.x * s
2362.     v.y = v.y + m.y * s
2363. END SUB
2364.  
2365. SUB vectorAddVectorScalarND (o AS tVECTOR2d, v AS tVECTOR2d, m AS tVECTOR2d, s AS _FLOAT)
2366.     o.x = v.x + m.x * s
2367.     o.y = v.y + m.y * s
2368. END SUB
2369.  
2370. SUB vectorSubVector (v AS tVECTOR2d, m AS tVECTOR2d)
2371.     v.x = v.x - m.x
2372.     v.y = v.y - m.y
2373. END SUB
2374.  
2375. SUB vectorSubVectorND (o AS tVECTOR2d, v AS tVECTOR2d, m AS tVECTOR2d)
2376.     o.x = v.x - m.x
2377.     o.y = v.y - m.y
2378. END SUB
2379.  
2380. FUNCTION vectorLengthSq (v AS tVECTOR2d)
2381.     vectorLengthSq = v.x * v.x + v.y * v.y
2382. END FUNCTION
2383.  
2384. FUNCTION vectorLength (v AS tVECTOR2d)
2385.     vectorLength = SQR(vectorLengthSq(v))
2386. END FUNCTION
2387.  
2388. SUB vectorRotate (v AS tVECTOR2d, radians AS _FLOAT)
2389.     DIM c, s, xp, yp AS _FLOAT
2390.     c = COS(radians)
2391.     s = SIN(radians)
2392.     xp = v.x * c - v.y * s
2393.     yp = v.x * s + v.y * c
2394.     v.x = xp
2395.     v.y = yp
2396. END SUB
2397.  
2398. SUB vectorNormalize (v AS tVECTOR2d)
2399.     DIM lenSQ, invLen AS _FLOAT
2400.     lenSQ = vectorLengthSq(v)
2401.     IF lenSQ > cEPSILON_SQ THEN
2402.         invLen = 1.0 / SQR(lenSQ)
2403.         v.x = v.x * invLen
2404.         v.y = v.y * invLen
2405.     END IF
2406. END SUB
2407.  
2408. SUB vectorMin (a AS tVECTOR2d, b AS tVECTOR2d, o AS tVECTOR2d)
2409.     o.x = scalarMin(a.x, b.x)
2410.     o.y = scalarMin(a.y, b.y)
2411. END SUB
2412.  
2413. SUB vectorMax (a AS tVECTOR2d, b AS tVECTOR2d, o AS tVECTOR2d)
2414.     o.x = scalarMax(a.x, b.x)
2415.     o.y = scalarMax(a.y, b.y)
2416. END SUB
2417.  
2418. FUNCTION vectorDot (a AS tVECTOR2d, b AS tVECTOR2d)
2419.     vectorDot = a.x * b.x + a.y * b.y
2420. END FUNCTION
2421.  
2422. FUNCTION vectorSqDist (a AS tVECTOR2d, b AS tVECTOR2d)
2423.     DIM dx, dy AS _FLOAT
2424.     dx = b.x - a.x
2425.     dy = b.y - a.y
2426.     vectorSqDist = dx * dx + dy * dy
2427. END FUNCTION
2428.  
2429. FUNCTION vectorDistance (a AS tVECTOR2d, b AS tVECTOR2d)
2430.     vectorDistance = SQR(vectorSqDist(a, b))
2431. END FUNCTION
2432.  
2433. FUNCTION vectorCross (a AS tVECTOR2d, b AS tVECTOR2d)
2434.     vectorCross = a.x * b.y - a.y * b.x
2435. END FUNCTION
2436.  
2437. SUB vectorCrossScalar (o AS tVECTOR2d, v AS tVECTOR2d, a AS _FLOAT)
2438.     o.x = v.y * -a
2439.     o.y = v.x * a
2440. END SUB
2441.  
2442. FUNCTION vectorArea (a AS tVECTOR2d, b AS tVECTOR2d, c AS tVECTOR2d)
2443.     vectorArea = (((b.x - a.x) * (c.y - a.y)) - ((c.x - a.x) * (b.y - a.y)))
2444. END FUNCTION
2445.  
2446. FUNCTION vectorLeft (a AS tVECTOR2d, b AS tVECTOR2d, c AS tVECTOR2d)
2447.     vectorLeft = vectorArea(a, b, c) > 0
2448. END FUNCTION
2449.  
2450. FUNCTION vectorLeftOn (a AS tVECTOR2d, b AS tVECTOR2d, c AS tVECTOR2d)
2451.     vectorLeftOn = vectorArea(a, b, c) >= 0
2452. END FUNCTION
2453.  
2454. FUNCTION vectorRight (a AS tVECTOR2d, b AS tVECTOR2d, c AS tVECTOR2d)
2455.     vectorRight = vectorArea(a, b, c) < 0
2456. END FUNCTION
2457.  
2458. FUNCTION vectorRightOn (a AS tVECTOR2d, b AS tVECTOR2d, c AS tVECTOR2d)
2459.     vectorRightOn = vectorArea(a, b, c) <= 0
2460. END FUNCTION
2461.  
2462. FUNCTION vectorCollinear (a AS tVECTOR2d, b AS tVECTOR2d, c AS tVECTOR2d, thresholdAngle AS _FLOAT)
2463.     IF (thresholdAngle = 0) THEN
2464.         vectorCollinear = (vectorArea(a, b, c) = 0)
2465.     ELSE
2466.         DIM ab AS tVECTOR2d
2467.         DIM bc AS tVECTOR2d
2468.         DIM dot AS _FLOAT
2469.         DIM magA AS _FLOAT
2470.         DIM magB AS _FLOAT
2471.         DIM angle AS _FLOAT
2472.  
2473.         ab.x = b.x - a.x
2474.         ab.y = b.y - a.y
2475.         bc.x = c.x - b.x
2476.         bc.y = c.y - b.y
2477.  
2478.         dot = ab.x * bc.x + ab.y * bc.y
2479.         magA = SQR(ab.x * ab.x + ab.y * ab.y)
2480.         magB = SQR(bc.x * bc.x + bc.y * bc.y)
2481.         angle = _ACOS(dot / (magA * magB))
2482.         vectorCollinear = angle < thresholdAngle
2483.     END IF
2484. END FUNCTION
2485.  
2486. SUB vectorGetSupport (p() AS tPOLY, body() AS tBODY, index AS INTEGER, dir AS tVECTOR2d, bestVertex AS tVECTOR2d)
2487.     DIM bestProjection AS _FLOAT
2488.     DIM v AS tVECTOR2d
2489.     DIM projection AS _FLOAT
2490.     DIM i AS INTEGER
2491.     bestVertex.x = -9999999
2492.     bestVertex.y = -9999999
2493.     bestProjection = -9999999
2494.  
2495.     FOR i = 0 TO body(index).pa.count
2496.         v = p(i + body(index).pa.start).vert
2497.         projection = vectorDot(v, dir)
2498.         IF projection > bestProjection THEN
2499.             bestVertex = v
2500.             bestProjection = projection
2501.         END IF
2502.     NEXT
2503. END SUB
2504.  
2505. '**********************************************************************************************
2506. '   Matrix Stuff Ahead
2507. '**********************************************************************************************
2508.  
2509. SUB matrixSetRadians (m AS tMATRIX2d, radians AS _FLOAT)
2510.     DIM c AS _FLOAT
2511.     DIM s AS _FLOAT
2512.     c = COS(radians)
2513.     s = SIN(radians)
2514.     m.m00 = c
2515.     m.m01 = -s
2516.     m.m10 = s
2517.     m.m11 = c
2518. END SUB
2519.  
2520. SUB matrixSetScalar (m AS tMATRIX2d, a AS _FLOAT, b AS _FLOAT, c AS _FLOAT, d AS _FLOAT)
2521.     m.m00 = a
2522.     m.m01 = b
2523.     m.m10 = c
2524.     m.m11 = d
2525. END SUB
2526.  
2527. SUB matrixAbs (m AS tMATRIX2d, o AS tMATRIX2d)
2528.     o.m00 = ABS(m.m00)
2529.     o.m01 = ABS(m.m01)
2530.     o.m10 = ABS(m.m10)
2531.     o.m11 = ABS(m.m11)
2532. END SUB
2533.  
2534. SUB matrixGetAxisX (m AS tMATRIX2d, o AS tVECTOR2d)
2535.     o.x = m.m00
2536.     o.y = m.m10
2537. END SUB
2538.  
2539. SUB matrixGetAxisY (m AS tMATRIX2d, o AS tVECTOR2d)
2540.     o.x = m.m01
2541.     o.y = m.m11
2542. END SUB
2543.  
2544. SUB matrixTransposeI (m AS tMATRIX2d)
2545.     SWAP m.m01, m.m10
2546. END SUB
2547.  
2548. SUB matrixTranspose (m AS tMATRIX2d, o AS tMATRIX2d)
2549.     DIM tm AS tMATRIX2d
2550.     tm.m00 = m.m00
2551.     tm.m01 = m.m10
2552.     tm.m10 = m.m01
2553.     tm.m11 = m.m11
2554.     o = tm
2555. END SUB
2556.  
2557. SUB matrixInvert (m AS tMATRIX2d, o AS tMATRIX2d)
2558.     DIM a, b, c, d, det AS _FLOAT
2559.     DIM tm AS tMATRIX2d
2560.  
2561.     a = m.m00: b = m.m01: c = m.m10: d = m.m11
2562.     det = a * d - b * c
2563.     IF det = 0 THEN EXIT SUB
2564.  
2565.     det = 1 / det
2566.     tm.m00 = det * d: tm.m01 = -det * b
2567.     tm.m10 = -det * c: tm.m11 = det * a
2568.     o = tm
2569. END SUB
2570.  
2571. SUB matrixMultiplyVector (m AS tMATRIX2d, v AS tVECTOR2d, o AS tVECTOR2d)
2572.     DIM t AS tVECTOR2d
2573.     t.x = m.m00 * v.x + m.m01 * v.y
2574.     t.y = m.m10 * v.x + m.m11 * v.y
2575.     o = t
2576. END SUB
2577.  
2578. SUB matrixAddMatrix (m AS tMATRIX2d, x AS tMATRIX2d, o AS tMATRIX2d)
2579.     o.m00 = m.m00 + x.m00
2580.     o.m01 = m.m01 + x.m01
2581.     o.m10 = m.m10 + x.m10
2582.     o.m11 = m.m11 + x.m11
2583. END SUB
2584.  
2585. SUB matrixMultiplyMatrix (m AS tMATRIX2d, x AS tMATRIX2d, o AS tMATRIX2d)
2586.     o.m00 = m.m00 * x.m00 + m.m01 * x.m10
2587.     o.m01 = m.m00 * x.m01 + m.m01 * x.m11
2588.     o.m10 = m.m10 * x.m00 + m.m11 * x.m10
2589.     o.m11 = m.m10 * x.m01 + m.m11 * x.m11
2590. END SUB
2591.  
2592. '**********************************************************************************************
2593. '   Mostly Unused Stuff Ahead
2594. '**********************************************************************************************
2595.  
2596. SUB polygonMakeCCW (obj AS tTRIANGLE)
2597.     IF vectorLeft(obj.a, obj.b, obj.c) = 0 THEN
2598.         SWAP obj.a, obj.c
2599.     END IF
2600. END SUB
2601.  
2602. FUNCTION polygonIsReflex (t AS tTRIANGLE)
2603.     polygonIsReflex = vectorRight(t.a, t.b, t.c)
2604. END FUNCTION
2605.  
2606. FUNCTION scalarMin (a AS _FLOAT, b AS _FLOAT)
2607.     IF a < b THEN
2608.         scalarMin = a
2609.     ELSE
2610.         scalarMin = b
2611.     END IF
2612. END FUNCTION
2613.  
2614. FUNCTION scalarMax (a AS _FLOAT, b AS _FLOAT)
2615.     IF a > b THEN
2616.         scalarMax = a
2617.     ELSE
2618.         scalarMax = b
2619.     END IF
2620. END FUNCTION
2621.  
2622. SUB lineIntersection (l1 AS tLINE2d, l2 AS tLINE2d, o AS tVECTOR2d)
2623.     DIM a1, b1, c1, a2, b2, c2, det AS _FLOAT
2624.     o.x = 0
2625.     o.y = 0
2626.     a1 = l1.b.y - l1.a.y
2627.     b1 = l1.a.x - l1.b.x
2628.     c1 = a1 * l1.a.x + b1 * l1.a.y
2629.     a2 = l2.b.y - l2.a.y
2630.     b2 = l2.a.x - l2.b.x
2631.     c2 = a2 * l2.a.x + b2 * l2.a.y
2632.     det = a1 * b2 - a2 * b1
2633.  
2634.     IF INT(det * cPRECISION) <> 0 THEN
2635.         o.x = (b2 * c1 - b1 * c2) / det
2636.         o.y = (a1 * c2 - a2 * c1) / det
2637.     END IF
2638. END SUB
2639.  
2640. FUNCTION lineSegmentsIntersect (l1 AS tLINE2d, l2 AS tLINE2d)
2641.     DIM dx, dy, da, db, s, t AS _FLOAT
2642.     dx = l1.b.x - l1.a.x
2643.     dy = l1.b.y - l1.a.y
2644.     da = l2.b.x - l2.a.x
2645.     db = l2.b.y - l2.a.y
2646.     IF da * dy - db * dx = 0 THEN
2647.         lineSegmentsIntersect = 0
2648.     ELSE
2649.         s = (dx * (l2.a.y - l1.a.y) + dy * (l1.a.x - l2.a.x)) / (da * dy - db * dx)
2650.         t = (da * (l1.a.y - l2.a.y) + db * (l2.a.x - l1.a.x)) / (db * dx - da * dy)
2651.         lineSegmentsIntersect = (s >= 0 AND s <= 1 AND t >= 0 AND t <= 1)
2652.     END IF
2653. END FUNCTION
2654.  
2655. '**********************************************************************************************
2656. '   Impulse Specific Math Ahead
2657. '**********************************************************************************************
2658.  
2659. FUNCTION impulseEqual (a AS _FLOAT, b AS _FLOAT)
2660.     impulseEqual = ABS(a - b) <= cEPSILON
2661. END FUNCTION
2662.  
2663. FUNCTION impulseClamp (min AS _FLOAT, max AS _FLOAT, a AS _FLOAT)
2664.     IF a < min THEN
2665.         impulseClamp = min
2666.     ELSE IF a > max THEN
2667.             impulseClamp = max
2668.         ELSE
2669.             impulseClamp = a
2670.         END IF
2671.     END IF
2672. END FUNCTION
2673.  
2674. FUNCTION impulseRound (a AS _FLOAT)
2675.     impulseRound = INT(a + 0.5)
2676. END FUNCTION
2677.  
2678. FUNCTION impulseRandom_float (min AS _FLOAT, max AS _FLOAT)
2679.     impulseRandom_float = ((max - min) * RND + min)
2680. END FUNCTION
2681.  
2682. FUNCTION impulseRandomInteger (min AS INTEGER, max AS INTEGER)
2683.     impulseRandomInteger = INT((max - min) * RND + min)
2684. END FUNCTION
2685.  
2686. FUNCTION impulseGT (a AS _FLOAT, b AS _FLOAT)
2687.     impulseGT = (a >= b * cBIAS_RELATIVE + a * cBIAS_ABSOLUTE)
2688. END FUNCTION
2689.  
2690. '**********************************************************************************************
2691. '   Troubleshooting Tools
2692. '**********************************************************************************************
2693.  
2694. SUB printMatrix (u AS tMATRIX2d, n AS INTEGER)
2695.     PRINT "---------------------------"
2696.     PRINT n; " u:"; u.m00; "|"; u.m10
2697.     PRINT "       "; u.m10; "|"; u.m11
2698.     DO
2699.     LOOP UNTIL _KEYHIT = 27
2700. END SUB
2701.  
2702. '**********************************************************************************************
2703. '   String Hash
2704. '**********************************************************************************************
2705.  
2706. FUNCTION computeHash&& (s AS STRING)
2707.     DIM p, i AS INTEGER: p = 31
2708.     DIM m AS _INTEGER64: m = 1E9 + 9
2709.     DIM AS _INTEGER64 hash_value, p_pow
2710.     p_pow = 1
2711.     FOR i = 1 TO LEN(s)
2712.         hash_value = (hash_value + (ASC(MID$(s, i)) - 97 + 1) * p_pow)
2713.         p_pow = (p_pow * p) MOD m
2714.     NEXT
2715.     computeHash = hash_value
2716. END FUNCTION
2717. '**********************************************************************************************
2718. '   Load Bitmap
2719. '**********************************************************************************************
2720. SUB loadBitmap (textureMap() AS LONG)
2721.     DIM AS INTEGER index
2722.     DIM AS STRING fl
2723.     FOR index = 1 TO 16
2724.         fl = _CWD$ + "\Assets\ball_" + LTRIM$(STR$(index)) + ".png"
2725.         textureMap(index) = _LOADIMAGE(fl)
2726.         IF textureMap(index) > -2 THEN
2727.             PRINT "Unable to load image "; fl; " with return of "; textureMap(index)
2728.             END
2729.         END IF
2730.     NEXT
2731.     textureMap(index + 1) = _LOADIMAGE(_CWD$ + "\Assets\cue.png")
2732.     textureMap(index + 2) = _LOADIMAGE(_CWD$ + "\Assets\table.png")
2733.     textureMap(index + 3) = _LOADIMAGE(_CWD$ + "\Assets\triangle.png")
2734.     textureMap(index + 4) = _LOADIMAGE(_CWD$ + "\Assets\ballreturn.png")
2735. END SUB
2736.  

[bplus]

Really nice!

Lots of handy subs and functions in there too!

You solved the problem of having enough room to stroke the cue all around the room, just move the table LOL!

Oh mouse wheel zooms, more nice!

[OldMoses]

Amazing work, if that's considered simple then I should just stop working on mine now. I'm particularly intrigued by the vast library of vector functions. A lot of stuff there that I hadn't thought of doing.

[justsomeguy]

if that's considered simple then I should just stop working on mine now

@OldMoses I apologize about calling it simple. I meant that it was, by far, not a complete implementation of a pool game. You should not quit on your project, in fact you are more than welcome to use anything you can make use of, if it will help you.

[OldMoses]

No need to apologize, that is a wonderfully executed program. In my own program, I didn't intend to go beyond the simple physics of the thing, but yours has a very realistic look to it. For mine, the closest I get to realism is to make use of a particular exploit of Steve's circle fill routine that made it easy to do striped and solid balls, but I never thought about getting them to rotate. They just sort of sled around. ;)

Now that I think of it Bplus' Rotozoom3 would probably handle ball rotations, but my first task is to tame the little buggers not to plow through each other and teleport around the table.

[justsomeguy]

Now that I think of it Bplus' Rotozoom3 would probably handle ball rotations

I used Rotozoom for the texture rotations.

[bplus]

Well for the record bplus Rotozoom3 gives you 2 independent scales for x and y not always needed.

@justsomeguy And I liked the .zip package, everything I need is right there for me to Run and compile as soon as extracted, thanks for that!

I am having a hard time pocketing any ball, I am wondering if you could project the path of cue and first ball hit with tracer lines when aiming the cue ball. I've seen this in an on-line Pool app. Next best thing would be to project cue to kiss point (if cue would roll that far). This might be asking too much but you did ask for feedback.

[justsomeguy]

@bplus Hold down the TAB key and see what happens.

[johnno56]

This game is pretty cool... Well done!

Can I assume that the table cloth colour can be changed? Say... to blue... lol (just for you bplus... lol)

[bplus]

@bplus Hold down the TAB key and see what happens.

Fabulous! 3 in a row! I needed that to see what is off with my aiming.

I tried the tab but missed the part about holding it down. Thanks this gets better and better!

[bplus]

This game is pretty cool... Well done!

Can I assume that the table cloth colour can be changed? Say... to blue... lol (just for you bplus... lol)

I have something that could change the color of an image but I bet that green has many shades. Colour ha! so many letters ;-))

[justsomeguy]

Can I assume that the table cloth colour can be changed? Say... to blue... lol (just for you bplus... lol)

Can do! Just insert this in 'SUB animateScene ()'

Code: QB64: [Select]

1.     IF _KEYDOWN(ASC("B")) OR _KEYDOWN(ASC("b")) THEN
2.         _SOURCE textureMap(19)
3.         _DEST textureMap(19)
4.         DIM AS INTEGER x, y, r, g, b
5.         DIM AS LONG c
6.         FOR x = 0 TO _WIDTH
7.             FOR y = 0 TO _HEIGHT
8.                 c = POINT(x, y): r = _RED(c): g = _GREEN(c): b = _BLUE(c)
9.                 IF g > 96 THEN
10.                     PSET (x, y), _RGB32(r, b, g)
11.                 END IF
12.             NEXT
13.         NEXT
14.         _SOURCE 0
15.         _DEST 0
16.     END IF

[bplus]

Well you have to Shared Texture and drop "Map" ending plus if you prefer red...

Code: QB64: [Select]

1.     If _KeyDown(Asc("B")) Or _KeyDown(Asc("b")) Then
2.         _Source texture(19)
3.         _Dest texture(19)
4.         Dim As Integer x, y, r, g, b
5.         Dim As Long c
6.         For x = 0 To _Width
7.             For y = 0 To _Height
8.                 c = Point(x, y): r = _Red(c): g = _Green(c): b = _Blue(c)
9.                 If g > 96 Then
10.                     PSet (x, y), _RGB32(g, r, b)
11.                 End If
12.             Next
13.         Next
14.         _Source 0
15.         _Dest 0
16.     End If
17.  

b is fine for key though

 

Except it screws up Tab scene.

PS that code is masterfully put together @justsomeguy

[bplus]

We need to fine tune the mouse setting on the cue. It might be OK to quickly narrow down to +- 10 degrees but I am changing the pixels by 1 and getting 10 degrees too much then 10 degrees too short, and moving mouse a pixel is for watch makers and jewelers.

So move mouse for gross angle and power then key in for way more accurate angle and power is my next suggestion.

PS always shoot with spacebar, in case you accidently click mouse.

PPS the left right English works to tune shot but really English is best used to set cue ball for next shot, in that reguard, I sure do miss forward and reverse.

[justsomeguy]

@bplus You are absolutely correct about about the mouse control being too difficult get that precise shot. I end up zooming out to get a little more fine control on the stick, but end up hitting way harder than intend. However, I was playing it on my Microsoft Surface and playing with a touchscreen is awesome, I might give the users a choice on how to aim.

The space bar does shoot, but it is about twice as hard. Per your suggestion this will probably change.

The left and right spin 'English' is simulated by putting angular velocity on the cue ball like you do in real pool. Because the engine is 2D, I'm not sure the best way to simulate angular velocity in a dimension it does not have (top and bottom). I have had a little success with playing with restitution of the cue ball, but it can only approximate top spin and not draw. Over all not a good solution. I will have to ponder this one.

Right now I'm going to see if using InForm would be a good choice for a GUI and, that would give access to real time tweaking of parameters and some options for varying the play style.

I had planned on circling around back to the aiming issue, so expect an up date in the near future.