« previous next »
Pages: [1]   Go Down

Author Topic: Re: Ellastic Collisions  (Read 428 times)

0 Members and 1 Guest are viewing this topic.

Offline codeguy

  • Forum Regular
  • Posts: 174
    • View Profile
Re: Ellastic Collisions
« on: March 28, 2019, 07:45:51 pm »
here's a blast from the past, containing my implementation of Elastic/Inelastic collisions. You may need to slow this appreciably on newer systems as it is FAST. Your creations are generally pretty darn cool, so here's one of my hits:
from: https://www.tapatalk.com/groups/qbasic/collider-worms-t30559.html

Code: QB64: [Select]
  1. '* this also makes a cool little screensaver
  2. '* this is a program i wrote just messing around, however, it follows all the physical laws concerning
  3. '* mass and elastic collisions. in order to show z-plane travel, i made the balls smaller according to a
  4. '* linear scale -- that is, that the farther the spheres are back in the z-plane (low z-numbers), the
  5. '* smaller the spere appears. to get a more accurate visual of this, use same-sized spheres, rather than
  6. '* randomly sized ones. also, in order to increase the likelihood of collisions, use a smaller z-plane distance
  7. '* or make it 2-d (either by setting the flag for 2d to true or eliminating the code referring to z-plane)
  8. '* v2 now features COR -- coefficient of restitution, which in a nutshell describes how "sticky" or "repulsive"
  9. '* an object is to collision. Low COR's essentially stick together (think steel ball colliding into soft butter), while
  10. '* high COR's bounce like steel balls off an equally hard steel floor. The COR must be a number from 0 to 1.
  11. '* same as before, works well for n=256 balls, but once past 1000, gets pretty syrupy. I just added the COR
  12. '* code today. So there you have it. Anyone who wants to add point light sources and do Phong shading can
  13. '* make this program REALLY shine, especially if they can make it run decently for n=16 ball system.
  14.  
  15. TYPE BallRec
  22. Radius AS DOUBLE
  23. Mass AS DOUBLE
  24. colr AS INTEGER
  27. const MaxScreenX=640
  28. const MinScreenX=0
  29. const MinScreenY=0
  30. const MaxScreenY=480
  31. const MinScreenZ=0
  32. const MaxScreenZ=100
  33. const Minvx=0
  34. const Maxvx=16
  35. const Minvy=0
  36. const Maxvy=16
  37. const Minvz=0
  38.  
  39. const Maxvz=16
  40. const aspectR=1
  41. schermo = _NEWIMAGE(Maxscreenx, Maxscreeny, 256)
  43. VIEW (Minscreenx, Minscreeny)-(Maxscreenx - 1, Maxscreeny - 1), 0
  44. NBalls% = 255
  45. DIM b(NBalls%) AS BallRec
  46. FOR i& = 0 TO NBalls%
  47. 'radius = RND * 16
  48. b(i&).px = Minscreenx + RND * (Maxscreenx - radius)
  49. b(i&).py = Minscreeny + RND * (Maxscreeny - radius)
  50. b(i&).pz = Minscreenz + RND * (Maxscreenz - radius)
  51. b(i&).vx = Minvx + RND * (Maxvx - Minvx) * (-1 ^ i& MOD 2)
  52. b(i&).vy = Minvy + RND * (Maxvy - Minvy) * (-1 ^ i& MOD 2)
  53. b(i&).vz = Minvz + RND * (Maxvz - Minvz) * (-1 ^ i& MOD 2)
  54. b(i&).Radius = 16 'INT(RND * 16) + 1
  55. b(i&).Mass = RND * 2 + 1
  56. b(i&).colr = INT(RND * 255) + 1
  57. b(i&).COR = INT(RND * 1)
  59. just2d% = -1
  61. FOR i& = 0 TO NBalls%
  62. FOR j& = 0 TO NBalls% - 1
  63. IF i& <> j& THEN
  64. IF b(i&).px + b(i&).vx - (b(j&).px + b(j&).vx) > b(i&).Radius + b(j&).Radius THEN
  66. IF b(i&).py + b(i&).vy - (b(j&).py + b(j&).vy) > b(i&).Radius + b(j&).Radius THEN
  68. IF (b(i&).pz + b(i&).vz - (b(j&).pz + b(j&).vz) <= b(i&).Radius + b(j&).Radius) AND (NOT just2d%) THEN
  69. ELSEIF NOT just2d% AND (b(i&).pz + b(i&).vz - (b(j&).pz + b(j&).vz) <= b(i&).Radius + b(j&).Radius) THEN
  71. CASE IS < 1 / 2
  72. CalcVelocities b(), i&, j&
  74. CalcVelocitiesCOR b(), i&, j&
  82. CIRCLE (b(i&).px, b(i&).py), (b(i&).Radius * b(i&).pz / Maxscreenz), b(i).colr, 0, 6.28, Aspectr
  83. IF b(i&).px + b(i&).vx < Minscreenx THEN
  84. b(i&).vx = -b(i&).vx
  85. ELSEIF b(i&).px + b(i&).vx > Maxscreenx THEN
  86. b(i&).vx = -b(i&).vx
  88. b(i&).px = b(i&).px + b(i&).vx
  90.  
  91. IF b(i&).py + b(i&).vy < Minscreeny THEN
  92. b(i&).vy = -b(i&).vy
  93. ELSEIF b(i&).py + b(i&).vy > Maxscreeny THEN
  94. b(i&).vy = -b(i&).vy
  96. b(i&).py = b(i&).py + b(i&).vy
  98.  
  99. IF b(i&).pz + b(i&).vz < Minscreenz THEN
  100. b(i&).vz = -b(i&).vz
  101. ELSEIF b(i&).pz + b(i&).vz > Maxscreenz THEN
  102. b(i&).vz = -b(i&).vz
  104. b(i&).pz = b(i&).pz + b(i&).vz
  106. CIRCLE (b(i&).px, b(i&).py), (b(i&).Radius * b(i&).pz / Maxscreenz), b(i&).colr, 0, 6.28, Aspectr
  107. PAINT (b(i&).px, b(i&).py), _RGB32(16 * b(i&).colr, 8 * b(i&).colr, b(i&).colr)
  109. k$ = INKEY$
  110. IF k$ > "" THEN
  115. SUB CalcVelocities (b() AS BallRec, i&, j&)
  116. temp1 = b(i&).vx
  117. temp2 = b(j&).vx
  118. totalMass = (b(i&).Mass + b(j&).Mass)
  119. b(i&).vx = (temp1 * (b(i&).Mass - b(j&).Mass) + (2 * b(j&).Mass * temp2)) / totalMass
  120. b(j&).vx = (temp2 * (b(j&).Mass - b(i&).Mass) + (2 * b(i&).Mass * temp1)) / totalMass
  121. temp1 = b(i&).vy
  122. temp2 = b(j&).vy
  123. b(i&).vy = (temp1 * (b(i&).Mass - b(j&).Mass) + (2 * b(j&).Mass * temp2)) / totalMass
  124. b(j&).vy = (temp2 * (b(j&).Mass - b(i&).Mass) + (2 * b(i&).Mass * temp1)) / totalMass
  125. temp1 = b(i&).vz
  126. temp2 = b(j&).vz
  127. b(i&).vz = (temp1 * (b(i&).Mass - b(j&).Mass) + (2 * b(j&).Mass * temp2)) / totalMass
  128. b(j&).vz = (temp2 * (b(j&).Mass - b(i&).Mass) + (2 * b(i&).Mass * temp1)) / totalMass
  130.  
  131. '* Normalize COR's of 2 objects to 1, otherwise Conservation of Momentum is violated -- adding energy to the closed system.
  132. '* According to the great physicists out there, roughly half of all collisions in a system are inelastic to some extent.
  133.  
  134. SUB CalcVelocitiesCOR (b() AS BallRec, i&, j&) ' * varying levels of elasticity from 0 (perfectly inelastic) to 1 (perfectly elastic)
  135. vx1 = b(i&).Mass * b(i&).vx + b(j&).Mass * b(j&).vx + b(j&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(i&).vx - b(j&).vx)
  136. vx2 = b(i&).Mass * b(i&).vx + b(j&).Mass * b(j&).vx + b(i&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(j&).vx - b(i&).vx)
  137. b(i&).vx = vx1
  138. b(j&).vx = vx2
  139. vy1 = b(i&).Mass * b(i&).vy + b(j&).Mass * b(j&).vy + b(j&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(i&).vy - b(j&).vy)
  140. vy2 = b(i&).Mass * b(i&).vy + b(j&).Mass * b(j&).vy + b(i&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(j&).vy - b(i&).vy)
  141. b(i&).vy = vy1
  142. b(j&).vy = vy2
  143. vz1 = b(i&).Mass * b(i&).vz + b(j&).Mass * b(j&).vz + b(j&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(i&).vz - b(j&).vz)
  144. vz2 = b(i&).Mass * b(i&).vz + b(j&).Mass * b(j&).vz + b(i&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(j&).vz - b(i&).vz)
  145. b(i&).vz = vz1
  146. b(j&).vz = vz2
  148.  

another variation that clears the screen between frames and uses fixed-size balls:
Code: QB64: [Select]
  1. '* this also makes a cool little screensaver
  2. '* this is a program i wrote just messing around, however, it follows all the physical laws concerning
  3. '* mass and elastic collisions. in order to show z-plane travel, i made the balls smaller according to a
  4. '* linear scale -- that is, that the farther the spheres are back in the z-plane (low z-numbers), the
  5. '* smaller the spere appears. to get a more accurate visual of this, use same-sized spheres, rather than
  6. '* randomly sized ones. also, in order to increase the likelihood of collisions, use a smaller z-plane distance
  7. '* or make it 2-d (either by setting the flag for 2d to true or eliminating the code referring to z-plane)
  8. '* v2 now features COR -- coefficient of restitution, which in a nutshell describes how "sticky" or "repulsive"
  9. '* an object is to collision. Low COR's essentially stick together (think steel ball colliding into soft butter), while
  10. '* high COR's bounce like steel balls off an equally hard steel floor. The COR must be a number from 0 to 1.
  11. '* same as before, works well for n=256 balls, but once past 1000, gets pretty syrupy. I just added the COR
  12. '* code today. So there you have it. Anyone who wants to add point light sources and do Phong shading can
  13. '* make this program REALLY shine, especially if they can make it run decently for n=16 ball system.
  14.  
  15. TYPE BallRec
  16.     px AS DOUBLE
  17.     py AS DOUBLE
  18.     pz AS DOUBLE
  19.     vx AS DOUBLE
  20.     vy AS DOUBLE
  21.     vz AS DOUBLE
  22.     Radius AS DOUBLE
  23.     Mass AS DOUBLE
  24.     colr AS INTEGER
  25.     COR AS DOUBLE
  27. CONST MaxScreenX = 640
  28. CONST MinScreenX = 0
  29. CONST MinScreenY = 0
  30. CONST MaxScreenY = 480
  31. CONST MinScreenZ = 0
  32. CONST MaxScreenZ = 100
  33. CONST Minvx = 0
  34. CONST Maxvx = 16
  35. CONST Minvy = 0
  36. CONST Maxvy = 16
  37. CONST Minvz = 0
  38.  
  39. CONST Maxvz = 16
  40. CONST aspectR = 1
  41. schermo = _NEWIMAGE(MaxScreenX, MaxScreenY, 256)
  43. VIEW (MinScreenX, MinScreenY)-(MaxScreenX - 1, MaxScreenY - 1), 0
  44. NBalls% = 511
  45. DIM b(NBalls%) AS BallRec
  46. FOR i& = 0 TO NBalls%
  47.     'radius = RND * 16
  48.     b(i&).px = MinScreenX + RND * (MaxScreenX - radius)
  49.     b(i&).py = MinScreenY + RND * (MaxScreenY - radius)
  50.     b(i&).pz = MinScreenZ + RND * (MaxScreenZ - radius)
  51.     b(i&).vx = Minvx + RND * (Maxvx - Minvx) * (-1 ^ i& MOD 2)
  52.     b(i&).vy = Minvy + RND * (Maxvy - Minvy) * (-1 ^ i& MOD 2)
  53.     b(i&).vz = Minvz + RND * (Maxvz - Minvz) * (-1 ^ i& MOD 2)
  54.     b(i&).Radius = INT(RND * 8) + 1
  55.     b(i&).Mass = RND * 2 + 1
  56.     b(i&).colr = INT(RND * 255) + 1
  57.     b(i&).COR = INT(RND * 1)
  59. just2d% = -1
  61.     CLS
  62.     FOR i& = 0 TO NBalls%
  63.         FOR j& = 0 TO NBalls% - 1
  64.             IF i& <> j& THEN
  65.                 IF b(i&).px + b(i&).vx - (b(j&).px + b(j&).vx) > b(i&).Radius + b(j&).Radius THEN
  66.                 ELSE
  67.                     IF b(i&).py + b(i&).vy - (b(j&).py + b(j&).vy) > b(i&).Radius + b(j&).Radius THEN
  68.                     ELSE
  69.                         IF (b(i&).pz + b(i&).vz - (b(j&).pz + b(j&).vz) <= b(i&).Radius + b(j&).Radius) AND (NOT just2d%) THEN
  70.                         ELSEIF NOT just2d% AND (b(i&).pz + b(i&).vz - (b(j&).pz + b(j&).vz) <= b(i&).Radius + b(j&).Radius) THEN
  71.                             SELECT CASE RND
  72.                                 CASE IS < 1 / 2
  73.                                     CalcVelocities b(), i&, j&
  74.                                 CASE ELSE
  75.                                     CalcVelocitiesCOR b(), i&, j&
  76.                             END SELECT
  77.                             EXIT FOR
  78.                         END IF
  79.                     END IF
  80.                 END IF
  81.             END IF
  82.         NEXT
  83.         CIRCLE (b(i&).px, b(i&).py), (b(i&).Radius * b(i&).pz / MaxScreenZ), b(i).colr, 0, 6.28, aspectR
  84.         IF b(i&).px + b(i&).vx < MinScreenX THEN
  85.             b(i&).vx = -b(i&).vx
  86.         ELSEIF b(i&).px + b(i&).vx > MaxScreenX THEN
  87.             b(i&).vx = -b(i&).vx
  88.         ELSE
  89.             b(i&).px = b(i&).px + b(i&).vx
  90.         END IF
  91.  
  92.         IF b(i&).py + b(i&).vy < MinScreenY THEN
  93.             b(i&).vy = -b(i&).vy
  94.         ELSEIF b(i&).py + b(i&).vy > MaxScreenY THEN
  95.             b(i&).vy = -b(i&).vy
  96.         ELSE
  97.             b(i&).py = b(i&).py + b(i&).vy
  98.         END IF
  99.  
  100.         IF b(i&).pz + b(i&).vz < MinScreenZ THEN
  101.             b(i&).vz = -b(i&).vz
  102.         ELSEIF b(i&).pz + b(i&).vz > MaxScreenZ THEN
  103.             b(i&).vz = -b(i&).vz
  104.         ELSE
  105.             b(i&).pz = b(i&).pz + b(i&).vz
  106.         END IF
  107.         CIRCLE (b(i&).px, b(i&).py), (b(i&).Radius * b(i&).pz / MaxScreenZ), b(i&).colr, 0, 6.28, aspectR
  108.         PAINT (b(i&).px, b(i&).py), _RGB32(16 * b(i&).colr, 8 * b(i&).colr, b(i&).colr)
  109.     NEXT
  110.     k$ = INKEY$
  111.     IF k$ > "" THEN
  112.         EXIT DO
  113.     END IF
  114.     _DISPLAY
  117. SUB CalcVelocities (b() AS BallRec, i&, j&)
  118.     temp1 = b(i&).vx
  119.     temp2 = b(j&).vx
  120.     totalMass = (b(i&).Mass + b(j&).Mass)
  121.     b(i&).vx = (temp1 * (b(i&).Mass - b(j&).Mass) + (2 * b(j&).Mass * temp2)) / totalMass
  122.     b(j&).vx = (temp2 * (b(j&).Mass - b(i&).Mass) + (2 * b(i&).Mass * temp1)) / totalMass
  123.     temp1 = b(i&).vy
  124.     temp2 = b(j&).vy
  125.     b(i&).vy = (temp1 * (b(i&).Mass - b(j&).Mass) + (2 * b(j&).Mass * temp2)) / totalMass
  126.     b(j&).vy = (temp2 * (b(j&).Mass - b(i&).Mass) + (2 * b(i&).Mass * temp1)) / totalMass
  127.     temp1 = b(i&).vz
  128.     temp2 = b(j&).vz
  129.     b(i&).vz = (temp1 * (b(i&).Mass - b(j&).Mass) + (2 * b(j&).Mass * temp2)) / totalMass
  130.     b(j&).vz = (temp2 * (b(j&).Mass - b(i&).Mass) + (2 * b(i&).Mass * temp1)) / totalMass
  132.  
  133. '* Normalize COR's of 2 objects to 1, otherwise Conservation of Momentum is violated -- adding energy to the closed system.
  134. '* According to the great physicists out there, roughly half of all collisions in a system are inelastic to some extent.
  135.  
  136. SUB CalcVelocitiesCOR (b() AS BallRec, i&, j&) ' * varying levels of elasticity from 0 (perfectly inelastic) to 1 (perfectly elastic)
  137.     vx1 = b(i&).Mass * b(i&).vx + b(j&).Mass * b(j&).vx + b(j&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(i&).vx - b(j&).vx)
  138.     vx2 = b(i&).Mass * b(i&).vx + b(j&).Mass * b(j&).vx + b(i&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(j&).vx - b(i&).vx)
  139.     b(i&).vx = vx1
  140.     b(j&).vx = vx2
  141.     vy1 = b(i&).Mass * b(i&).vy + b(j&).Mass * b(j&).vy + b(j&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(i&).vy - b(j&).vy)
  142.     vy2 = b(i&).Mass * b(i&).vy + b(j&).Mass * b(j&).vy + b(i&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(j&).vy - b(i&).vy)
  143.     b(i&).vy = vy1
  144.     b(j&).vy = vy2
  145.     vz1 = b(i&).Mass * b(i&).vz + b(j&).Mass * b(j&).vz + b(j&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(i&).vz - b(j&).vz)
  146.     vz2 = b(i&).Mass * b(i&).vz + b(j&).Mass * b(j&).vz + b(i&).Mass * ((b(i&).COR + b(j&).COR) / 2) * (b(j&).vz - b(i&).vz)
  147.     b(i&).vz = vz1
  148.     b(j&).vz = vz2
  150.  

« Last Edit: March 28, 2019, 07:57:51 pm by codeguy »
Logged

Offline codeguy

  • Forum Regular
  • Posts: 174
    • View Profile
Re: Ellastic Collisions
« Reply #1 on: March 28, 2019, 08:04:55 pm »
Also of interest as this demo contains an implementation of my NSpace Collision Detection System as a SUB:
Code: QB64: [Select]
  1. _TITLE "NSpace Sub And Demo Code"
  2. '*NSpaceRoutine.bas
  3. TYPE RGBRec
  4.     red AS _UNSIGNED _BYTE
  5.     green AS _UNSIGNED _BYTE
  6.     blue AS _UNSIGNED _BYTE
  8.  
  9. TYPE Coord
  10.     x AS INTEGER
  11.     y AS INTEGER
  12.     z AS INTEGER
  14.  
  15. TYPE PointRec
  16.     x AS SINGLE
  17.     y AS SINGLE
  18.     z AS SINGLE
  19.     radius AS SINGLE
  20.     colorsRGB AS RGBRec
  21.     inc AS Coord
  22.     precalcRGB AS LONG
  23.     precalcdiameter AS LONG
  25.  
  26. TYPE Segment
  27.     xseg AS _UNSIGNED _BYTE
  28.     yseg AS _UNSIGNED _BYTE
  29.     zseg AS _UNSIGNED _BYTE
  30.     xsegsize AS _UNSIGNED _BYTE
  31.     ysegsize AS _UNSIGNED _BYTE
  32.     zsegsize AS _UNSIGNED _BYTE
  34.  
  35. TYPE ScreenRec
  36.     begins AS Coord
  37.     ends AS Coord
  39.  
  40. xscreen& = _SCREENIMAGE
  41. SCREEN xscreen&
  43. DIM GScrn AS ScreenRec
  44. GScrn.begins.x = 1
  45. GScrn.begins.y = 1
  46. GScrn.begins.z = 1
  47. GScrn.ends.x = _WIDTH(xscreen&)
  48. GScrn.ends.y = _HEIGHT(xscreen&)
  49. GScrn.ends.z = 1024
  50.  
  51. DIM a(16383 * 1.5) AS PointRec
  52. DIM SegmentMetrics AS Segment
  53. SegmentMetrics.xseg = 16
  54. SegmentMetrics.xsegsize = (GScrn.ends.x - GScrn.begins.x + 1) / SegmentMetrics.xseg
  55. SegmentMetrics.yseg = 16
  56. SegmentMetrics.ysegsize = (GScrn.ends.y - GScrn.begins.y + 1) / SegmentMetrics.yseg
  57. SegmentMetrics.zseg = 16
  58. SegmentMetrics.zsegsize = (GScrn.ends.z - GScrn.begins.z + 1) / SegmentMetrics.zseg
  59. REDIM NspaceObjects(SegmentMetrics.xseg, SegmentMetrics.yseg, SegmentMetrics.zseg, SizeOf(a()) / 4)
  60. REDIM counts%(SegmentMetrics.xseg, SegmentMetrics.yseg, SegmentMetrics.zseg)
  61. FOR i = LBOUND(a) TO UBOUND(a)
  62.     a(i).radius = (RND * 2) OR 1
  63.     a(i).precalcdiameter = a(i).radius * 2
  64.     a(i).x = a(i).radius + RND * (GScrn.ends.x - a(i).radius)
  65.     a(i).y = a(i).radius + RND * (GScrn.ends.y - a(i).radius)
  66.     a(i).z = a(i).radius + RND * (GScrn.ends.z - a(i).radius)
  67.     a(i).inc.x = (6 * (1 - RND * 2)) OR 1
  68.     a(i).inc.y = (6 * (1 - RND * 2)) OR 1
  69.     a(i).inc.z = (6 * (1 - RND * 2)) OR 1
  70.     a(i).colorsRGB.red = INT(RND * 256)
  71.     a(i).colorsRGB.green = INT(RND * 256)
  72.     a(i).colorsRGB.blue = INT(RND * 256)
  73.     a(i).precalcRGB = _RGB(a(i).colorsRGB.red, a(i).colorsRGB.green, a(i).colorsRGB.blue)
  75. frames& = 0
  76. lastframe& = 0
  77. Start! = TIMER(.001)
  78. xstart! = Start!
  79.  
  83.  
  85.     CLS
  86.     FOR i = LBOUND(a) TO UBOUND(a)
  87.         IF a(i).x - a(i).radius + a(i).inc.x < GScrn.begins.x THEN
  88.             a(i).inc.x = -a(i).inc.x
  89.         ELSEIF a(i).x + a(i).radius + a(i).inc.x > GScrn.ends.x THEN
  90.             a(i).inc.x = -a(i).inc.x
  91.         END IF
  92.         a(i).x = a(i).x + a(i).inc.x
  93.  
  94.         IF a(i).y - a(i).radius + a(i).inc.y < GScrn.begins.y THEN
  95.             a(i).inc.y = -a(i).inc.y
  96.         ELSEIF a(i).y + a(i).radius + a(i).inc.y > GScrn.ends.y THEN
  97.             a(i).inc.y = -a(i).inc.y
  98.         END IF
  99.         a(i).y = a(i).y + a(i).inc.y
  100.  
  101.         IF a(i).z - a(i).radius + a(i).inc.z < GScrn.begins.z THEN
  102.             a(i).inc.z = -a(i).inc.z
  103.         ELSEIF a(i).z + a(i).radius + a(i).inc.z > GScrn.ends.z THEN
  104.             a(i).inc.z = -a(i).inc.z
  105.         END IF
  106.         a(i).z = a(i).z + a(i).inc.z
  107.         PSET (a(i).x, a(i).y), a(i).precalcRGB
  108.     NEXT
  109.  
  110.     NSpace a(), GScrn, SegmentMetrics, NspaceObjects(), counts%()
  111.     FOR XLoop = 0 TO SegmentMetrics.xseg
  112.         FOR YLoop = 0 TO SegmentMetrics.yseg
  113.             FOR ZLoop = 0 TO SegmentMetrics.zseg
  114.                 FOR d% = 0 TO counts%(XLoop, YLoop, ZLoop) - 2
  115.                     m& = NspaceObjects(XLoop, YLoop, ZLoop, d%)
  116.                     FOR e% = d% + 1 TO counts%(XLoop, YLoop, ZLoop) - 1
  117.                         n& = NspaceObjects(XLoop, YLoop, ZLoop, e%)
  118.                         IF Collision%(a(m&), a(n&)) THEN
  119.                             a(n&).inc.x = -a(m&).inc.x
  120.                             a(n&).inc.y = -a(m&).inc.y
  121.                             a(n&).inc.z = -a(m&).inc.z
  122.                         END IF
  123.                     NEXT
  124.                 NEXT
  125.             NEXT
  126.         NEXT
  127.     NEXT
  128.  
  129.     REDIM counts%(SegmentMetrics.xseg, SegmentMetrics.yseg, SegmentMetrics.zseg)
  130.  
  131.     IF ABS(TIMER(.001) - Start!) < 2 THEN
  132.         frames& = frames& + 1
  133.     ELSE
  134.         Start! = TIMER(.001)
  135.         PRINT (frames& - lastframe&) / 2
  136.         lastframe& = frames&
  137.     END IF
  138.     _DISPLAY
  139.     d$ = INKEY$
  140. LOOP UNTIL d$ > ""
  141. finish! = TIMER(.001)
  144. PRINT frames& / (finish! - xstart!)
  145.  
  146. SUB NSpace (a() AS PointRec, Scrn AS ScreenRec, SegmentsXYZ AS Segment, NspaceObjects(), Counts%())
  147.     DIM xbox, ybox, zbox AS _UNSIGNED _BYTE
  148.     DIM oxseg, oyseg, ozseg AS _UNSIGNED _BYTE
  149.     FOR m& = LBOUND(A) TO UBOUND(A)
  150.         oxseg = a(m&).x \ SegmentsXYZ.xsegsize
  151.         oyseg = a(m&).y \ SegmentsXYZ.ysegsize
  152.         ozseg = a(m&).z \ SegmentsXYZ.zsegsize
  153.         IF Counts%(oxseg, oyseg, ozseg) > UBOUND(NspaceObjects, 4) THEN
  154.             REDIM _PRESERVE NspaceObjects(SegmentsXYZ.xseg, SegmentsXYZ.yseg, SegmentsXYZ.zseg, Counts%(oxseg, oyseg, ozseg))
  155.             '* PRINT Counts%(oxseg, oyseg, ozseg)
  156.         END IF
  157.         dx% = Counts%(oxseg, oyseg, ozseg)
  158.         NspaceObjects(oxseg, oyseg, ozseg, dx%) = m&
  159.         Counts%(oxseg, oyseg, ozseg) = dx% + 1
  160.         IF a(m&).radius THEN
  161.             FOR u = -a(m&).radius TO a(m&).radius STEP a(m&).precalcdiameter
  162.                 xbox = (a(m&).x + u) \ SegmentsXYZ.xsegsize
  163.                 IF xbox >= 0 THEN
  164.                     IF xbox <= SegmentsXYZ.xseg THEN
  165.                         ybox = (a(m&).y + u) \ SegmentsXYZ.ysegsize
  166.                         IF ybox >= 0 THEN
  167.                             IF ybox <= SegmentsXYZ.yseg THEN
  168.                                 zbox = (a(m&).z + u) \ SegmentsXYZ.zsegsize
  169.                                 IF zbox >= 0 THEN
  170.                                     IF zbox <= SegmentsXYZ.zseg THEN
  171.                                         IF xbox <> oxseg OR ybox <> oyseg OR zbox <> ozseg THEN
  172.                                             dx% = Counts%(xbox, ybox, zbox)
  173.                                             NspaceObjects(xbox, ybox, zbox, dx%) = m&
  174.                                             Counts%(xbox, ybox, zbox) = dx% + 1
  175.                                         END IF
  176.                                     END IF
  177.                                 END IF
  178.                             END IF
  179.                         END IF
  180.                     END IF
  181.                 END IF
  182.             NEXT
  183.         END IF
  184.     NEXT
  186.  
  187. FUNCTION SizeOf% (a() AS PointRec)
  188.     SizeOf% = UBOUND(a) - LBOUND(a) + 1
  190.  
  191. FUNCTION Collision% (a AS PointRec, b AS PointRec)
  192.     Collision% = 0
  193.     IF ABS(b.x - a.x) > a.radius + b.radius THEN
  194.         EXIT SUB
  195.     ELSE
  196.         IF ABS(b.y - a.y) > a.radius + b.radius THEN
  197.             EXIT SUB
  198.         ELSE
  199.             IF ABS(b.z - a.z) > a.radius + b.radius THEN
  200.                 EXIT SUB
  201.             ELSE
  202.                 Collision% = -1
  203.             END IF
  204.         END IF
  205.     END IF
  207.  
« Last Edit: March 28, 2019, 08:06:57 pm by codeguy »
Logged

Offline bplus

  • Global Moderator
  • Forum Resident
  • Posts: 8053
  • b = b + ...
    • View Profile
Re: Ellastic Collisions
« Reply #2 on: March 28, 2019, 08:07:15 pm »
When calculating velocities the trick is NOT to use the New Velocity Value for the 2nd Velocity calculation.

Best to save both old values in variables and use them to calculate the new values.

I fixed your code thus:
Code: QB64: [Select]
  1. _TITLE "Elastic Collisions"   'mod B+ 2019-03-28
  2. ' https://en.wikipedia.org/wiki/Elastic_collision
  3.  
  4. SCREEN _NEWIMAGE(400, 400, 32)
  5.  
  6. TYPE newBlock
  7.     xPos AS SINGLE
  9.  
  10.     vel AS SINGLE
  11.     mass AS INTEGER
  13.  
  14. DIM SHARED Block1 AS newBlock
  15. DIM SHARED Block2 AS newBlock
  16.  
  17. Example
  18.  
  19. 'only need 1 function but know which velocity is which my Mass and Velocity or the other Block's Mass and Velocity
  20. FUNCTION MyVelocity (myM, myV, otherM, otherV)
  21.     sum = myM + otherM
  22.     MyVelocity = myV * (myM - otherM) / sum + otherV * 2 * otherM / sum
  24.  
  25. SUB Example
  26.     ' Elastic collision of unequal masses
  27.     Block1.xPos = 4
  28.     Block1.width = 32
  29.     Block1.vel = 1
  30.     Block1.mass = 1
  31.  
  32.     Block2.xPos = _WIDTH - 20
  33.     Block2.width = 32
  34.     Block2.vel = -1
  35.     Block2.mass = 1
  36.  
  37.     DO
  38.         _LIMIT 60
  39.  
  40.         LINE (0, 0)-(_WIDTH - 1, _HEIGHT - 1), _RGB(127, 127, 127), BF
  41.         LINE (Block1.xPos, _HEIGHT - 20)-(Block1.xPos + Block1.width, _HEIGHT - 4), _RGB(0, 0, 0), BF
  42.         LINE (Block2.xPos, _HEIGHT - 20)-(Block2.xPos + Block2.width, _HEIGHT - 4), _RGB(0, 0, 255), BF
  43.         _DISPLAY
  44.  
  45.         Block1.xPos = Block1.xPos + Block1.vel
  46.         Block2.xPos = Block2.xPos + Block2.vel
  47.  
  48.         IF Block1.xPos + Block1.width >= Block2.xPos THEN
  49.             b1v = Block1.vel: b2v = Block2.vel '<<<<   these get changed so save old values in separate variables
  50.             Block1.vel = MyVelocity(Block1.mass, b1v, Block2.mass, b2v)
  51.             Block2.vel = MyVelocity(Block2.mass, b2v, Block1.mass, b1v)
  52.         END IF
  53.     LOOP UNTIL Done
  55.  
  56.  

Currently set so both blocks bounce away at equal pace.

Oh also better to use SINGLE or DOUBLE for Velocities and probably X positions as well.
« Last Edit: March 28, 2019, 08:33:04 pm by bplus »
Logged

Offline TempodiBasic

  • Forum Resident
  • Posts: 1792
    • View Profile
Re: Ellastic Collisions
« Reply #3 on: March 28, 2019, 08:46:54 pm »
Hey guys
you're wonderful!
While I attempt to understand the problem  you write
and now that I'm going to write my answer I find the question solved!
1. in TYPE the velocity is an INTEGER while the formula gives back a SINGLE
2. velocity2 must get the right initial value of block1.vel to get the right answer
3. you must reset to false the state of collision of the two blocks

here your code modded for output to screen and with values for masses and velocities taken from the example of wikipage that you have posted
Code: QB64: [Select]
  1. _TITLE "Elastic Collisions"
  2. ' https://en.wikipedia.org/wiki/Elastic_collision
  3.  
  4. SCREEN _NEWIMAGE(400, 400, 32)
  5.  
  6. TYPE newBlock
  7.     xPos AS INTEGER
  9.  
  10.     vel AS SINGLE ' AS INTEGER
  11.     mass AS SINGLE ' AS INTEGER
  13.  
  14. DIM SHARED Block1 AS newBlock
  15. DIM SHARED Block2 AS newBlock
  16.  
  17. Example
  18.  
  19. FUNCTION Velocity1 (m1, m2, u1, u2)
  20.     sum = m1 + m2: a = m1 - m2: b = 2 * m2
  21.     Velocity1 = ((a / sum) * u1 + (b / sum) * u2)
  23.  
  24. FUNCTION Velocity2 (m1, m2, u1, u2)
  25.     sum = m1 + m2: a = 2 * m1: b = m2 - m1
  26.     Velocity2 = ((a / sum) * u1 + (b / sum) * u2)
  28.  
  29. SUB Example
  30.     ' Elastic collision of unequal masses
  31.     Block1.xPos = 4
  32.     Block1.width = 32
  33.     Block1.vel = 4 ' 1
  34.     Block1.mass = 3 '2
  35.  
  36.     Block2.xPos = _WIDTH - 20
  37.     Block2.width = 32
  38.     Block2.vel = -6 '-1
  39.     Block2.mass = 5 ' 1
  40.     COLOR _RGB(188, 55, 50), _RGB(10, 127, 127) ' to see the text
  41.     DO
  42.         _LIMIT 60
  43.  
  44.         LINE (0, 0)-(_WIDTH - 1, _HEIGHT - 1), _RGB(127, 127, 127), BF
  45.         LINE (Block1.xPos, _HEIGHT - 20)-(Block1.xPos + Block1.width, _HEIGHT - 4), _RGB(0, 0, 0), BF
  46.         LINE (Block2.xPos, _HEIGHT - 20)-(Block2.xPos + Block2.width, _HEIGHT - 4), _RGB(0, 0, 255), BF
  47.         '        _DISPLAY
  48.  
  49.         Block1.xPos = Block1.xPos + Block1.vel
  50.         Block2.xPos = Block2.xPos + Block2.vel
  51.  
  52.  
  53.         IF Block1.xPos + Block1.width >= Block2.xPos THEN
  54.             oldb1vel = Block1.vel ' to hold old original value of velocity of mass1
  55.             Block1.vel = Velocity1(Block1.mass, Block2.mass, Block1.vel, Block2.vel)
  56.             Block2.vel = Velocity2(Block1.mass, Block2.mass, oldb1vel, Block2.vel)
  57.             Block1.xPos = Block2.xPos - (Block1.width + 1) ' reset collision data
  58.             PRINT Block1.vel, Block2.vel: _DISPLAY: SLEEP 2  'output debug
  59.         END IF
  60.         LOCATE 2, 1: PRINT Block1.vel, Block2.vel: ' output debug
  61.         _DISPLAY
  62.         _DELAY .1 ' to show slowly
  63.     LOOP UNTIL Done OR _KEYHIT = (32)  ' to have a long goal... when is Done created in this code?
  65.  
Thanks to read
Logged
Programming isn't difficult, only it's  consuming time and coffee
Pages: [1]   Go Up
« previous next »