« previous next »
Pages: [1]   Go Down

Author Topic: Collisions - Version 9  (Read 4883 times)

0 Members and 1 Guest are viewing this topic.

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Collisions - Version 9
« on: March 05, 2020, 07:53:38 pm »
Hello all,

This thread more-or-less marks a milestone in the performance of the physics engine on which I've been elaborating at https://www.qb64.org/forum/index.php?topic=2207.0. The reason I start a new thread is to erase the old code from institutional memory as the old thread slips away into ancient forum history. (Give it a day or two.) Since its inception, I can now be more clear about what this does, what it doesn't do, and what it may do in the future. The overall plan is for this to become a library for folks to use in any project where the physics needs to be correct. For the sake of having it all in one place, here we go:

Review:
  • This is a two dimensional engine that calculates the motion of arbitrarily*-shaped colliding bodies.
  • Each body, or "shape" as named in the code, is a wire-frame object made of closely-separated points.
  • The mass of a given shape is directly proportional to the area it encloses, however the centroid is calculated as if all mass were concentrated in the wireframe itself. (This is subject to change but still captures the physics we want.)
  • Everything is unified. There are no special objects, boundaries, or miracles. The walls are made of the same stuff as the objects contained in them, and are subject to the same physics. Typically I set the mass of a wall element to an extremely high number so they can't move.
  • * Shapes cannot be truly arbitrary - they must be simply-connected and for now, the centroid must lie within the main body. The rest of this math will be work out soon.
  • I have done absolutely nothing to fine-tune this engine. Everything it does so far is a product of its prototype parts working together. If one were to use this to make one particular game, some time would be spent getting the adjustable parameters correct. With that said, it's still possible to make things fly too fast, send objects through each other, etc - so nobody complain about this! Just be gentle and get a feel for it.

Controls:
This update also includes revamped controls. You can select and move any piece, and you can even fling them with the mouse. It's super addictive - just click+drag and let go to send it flying. Again, this isn't really tuned so just toss gently. Just so you see them in more than once, the controls I have are given in:

Code: QB64: [Select]
  1. CALL cprintstring(-16 * 4, "During Play:")
  2. CALL cprintstring(-16 * 6, "Move mouse to select closest object (by centroid).")
  3. CALL cprintstring(-16 * 7, "Boost velocity with arrow keys or W/S/A/D.        ")
  4. CALL cprintstring(-16 * 8, "Boost angluar velocity with Q/E.                  ")
  5. CALL cprintstring(-16 * 9, "Drag and fling object with Mouse 1.               ")
  6. CALL cprintstring(-16 * 10, "Rotate selected object with Mousewheel.           ")
  7. CALL cprintstring(-16 * 11, "Halt all motion with ESC.                         ")
  8. CALL cprintstring(-16 * 12, "Create new ball with Mouse 2.                     ")
  9. CALL cprintstring(-16 * 13, "Initiate creative mode with SPACE.                ")
  10. CALL cprintstring(-16 * 14, "Restart by pressing R during motion.              ")
  11. CALL cprintstring(-16 * 16, "PRESS ANY KEY TO BEGIN.")

Screenshots:
Before blurting out the code, let me point to the screenshots attached. These all came from running the same code, just with very slightly different options at startup.
  • In screenshot 1 we have what started as a pool game, then I right-clicked a bunch of times to add extra balls. Then I hit space to draw a few oddly-shaped yams, and moved those around (and spun them) to knock the balls around.
  • In screenshot 2 I let the "Wacky Game" option play out a while, then I decided that the "bottleneck", or hourglass thing, whatever - was too narrow so I moved a piece... then added a bunch of balls to see if I could get close to the results @bplus was getting with stacking balls. (No change of settings, just added balls.)
  • In screenshot 3 I demonstrate that shape-within-shape momentum exchange works correctly. Since everything is wireframe, why not let things bounce inside each other? If you'e paying attention, this is hardly new, because that's what the box containing the level is up to!

Levels:
And once again, before I blurt out the full code, here is what setting up one particular level looks like. The way this code might interact with other code, like for whoever is making a game or something, a level might look exactly like this. Here's the pool level:

Code: QB64: [Select]
  1. SUB SetupPoolGame
  2.     ' Set external field
  3.     ForceField.x = 0
  4.     ForceField.y = 0
  5.  
  6.     ' Rectangular border
  7.     wx = 42
  8.     wy = 10
  9.     CALL NewBrickLine(-_WIDTH / 2 + wx, _HEIGHT / 2 - wy, _WIDTH / 2 - wx, _HEIGHT / 2 - wy, wx, wy)
  10.     CALL NewBrickLine(-_WIDTH / 2 + wx, -_HEIGHT / 2 + wy, _WIDTH / 2 - wx, -_HEIGHT / 2 + wy, wx, wy)
  11.     wx = 40
  12.     wy = 10
  13.     CALL NewBrickLine(-_WIDTH / 2 + wy, -_HEIGHT / 2 + 2 * wx, -_WIDTH / 2 + wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  14.     CALL NewBrickLine(_WIDTH / 2 - wy, -_HEIGHT / 2 + 2 * wx, _WIDTH / 2 - wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  15.  
  16.     ' Balls (billiard setup)
  17.     x0 = 160
  18.     y0 = 0
  19.     r = 15
  20.     gg = 2 * r + 4
  21.     xf = COS(30 * 3.14159 / 180)
  22.     yf = SIN(30 * 3.14159 / 180)
  23.     gx = gg * xf
  24.     gy = gg * yf
  25.  
  26.     CALL NewAutoBall(x0 + 0 * gx, y0 + 0 * gy, r, 0, 1, 1, 0)
  27.     CALL NewAutoBall(x0 + 1 * gx, y0 + 1 * gy, r, 0, 1, 1, 0)
  28.     CALL NewAutoBall(x0 + 1 * gx, y0 - 1 * gy, r, 0, 1, 1, 0)
  29.     CALL NewAutoBall(x0 + 2 * gx, y0 + 2 * gy, r, 0, 1, 1, 0)
  30.     CALL NewAutoBall(x0 + 2 * gx, y0 + 0 * gy, r, 0, 1, 1, 0)
  31.     CALL NewAutoBall(x0 + 2 * gx, y0 - 2 * gy, r, 0, 1, 1, 0)
  32.     CALL NewAutoBall(x0 + 3 * gx, y0 + 3 * gy, r, 0, 1, 1, 0)
  33.     CALL NewAutoBall(x0 + 3 * gx, y0 + 1 * gy, r, 0, 1, 1, 0)
  34.     CALL NewAutoBall(x0 + 3 * gx, y0 - 1 * gy, r, 0, 1, 1, 0)
  35.     CALL NewAutoBall(x0 + 3 * gx, y0 - 3 * gy, r, 0, 1, 1, 0)
  36.     CALL NewAutoBall(x0 + 4 * gx, y0 + 4 * gy, r, 0, 1, 1, 0)
  37.     CALL NewAutoBall(x0 + 4 * gx, y0 + 2 * gy, r, 0, 1, 1, 0)
  38.     CALL NewAutoBall(x0 + 4 * gx, y0 - 0 * gy, r, 0, 1, 1, 0)
  39.     CALL NewAutoBall(x0 + 4 * gx, y0 - 2 * gy, r, 0, 1, 1, 0)
  40.     CALL NewAutoBall(x0 + 4 * gx, y0 - 4 * gy, r, 0, 1, 1, 0)
  41.  
  42.     ' Cue ball
  43.     CALL NewAutoBall(-220, 0, r, 0, 1, 1, 0)
  44.     Shape(ShapeCount).Velocity.x = 10 + 2 * RND
  45.     Shape(ShapeCount).Velocity.y = 1 * (RND - .5)
  46.     Shape(ShapeCount).Shade = _RGB(255, 255, 255)
  47.  
  48.     ' Parameters
  49.     CPC = 1.15
  50.     FPC = 8
  51.     RST = 0.75
  52.     VD = 0.995
  53.     SV = 0
  55.  

You see we have no gravity, a bit of geometry for the rack of balls, the cue ball, and then some magic numbers at the end - just throwaway values that would be tuned for a real game. But that's it - any game's specification is in a sub just like the one above.

Full Code:
This code has no dependencies, no includes, doesn't need an experimental version of the compiler (although I have yet to test it on an SDL version). There is so much more work to do, but you can probably take this version as solid. Oh yeah - why version 9? No, versions 1 through 8 did not exist. And I promise, nor will version 10 or beyond. This software, regardless of what date the newest code corresponds to, shall always be version 9. That's INT(9). N-i-n-e.

UPDATED

Code: QB64: [Select]
  1. ' Display
  2. SCREEN _NEWIMAGE(800, 600, 32)
  3. _SCREENMOVE (_DESKTOPWIDTH \ 2 - _WIDTH \ 2) - 3, (_DESKTOPHEIGHT \ 2 - _HEIGHT \ 2) - 29
  4. _TITLE "Collisions - Version 9"
  6.  
  7. ' Meta
  8. start:
  12.  
  13. ' Data structures
  14. TYPE Vector
  15.     x AS DOUBLE
  16.     y AS DOUBLE
  18.  
  19. DIM SHARED vtemp AS Vector
  20.  
  21. ' Object type
  22. TYPE Object
  23.     Centroid AS Vector
  24.     Collisions AS LONG
  25.     CollisionSwitch AS INTEGER
  26.     DeltaO AS DOUBLE
  27.     DeltaV AS Vector
  28.     Diameter AS DOUBLE
  29.     Elements AS INTEGER
  30.     Fixed AS INTEGER
  31.     Mass AS DOUBLE
  32.     MOI AS DOUBLE
  33.     PartialNormal AS Vector
  34.     Omega AS DOUBLE
  35.     Shade AS _UNSIGNED LONG
  36.     Velocity AS Vector
  38.  
  39. ' Object storage
  40. DIM SHARED Shape(300) AS Object
  41. DIM SHARED PointChain(300, 500) AS Vector
  42. DIM SHARED TempChain(300, 500) AS Vector
  43. DIM SHARED ShapeCount AS INTEGER
  44. DIM SHARED SelectedShape AS INTEGER
  45.  
  46. ' Dynamics
  47. DIM SHARED CollisionCount AS INTEGER
  48. DIM SHARED ProximalPairs(300 / 2, 1 TO 2)
  49. DIM SHARED ProximalPairsCount
  50. DIM SHARED CPC, FPC, RST, VD, SV
  51.  
  52. ' Environment
  53. DIM SHARED ForceField AS Vector ' Ex: gravity
  54.  
  55. ' Initialize
  56. ShapeCount = 0
  57. CollisionCount = 0
  58.  
  59. ' Prompt
  61. CALL cprintstring(16 * 17, "WELCOME!                    ")
  62. CALL cprintstring(16 * 16, "Press 1 for Pool prototype  ")
  63. CALL cprintstring(16 * 15, "Press 2 for Wacky game      ")
  64. CALL cprintstring(16 * 14, "Press 3 for Concentric rings")
  65. CALL cprintstring(16 * 13, "Press 4 for Walls only      ")
  66. CALL cprintstring(16 * 12, "Press 5 for Angle pong game ")
  68.  
  71.     kk = _KEYHIT
  72.     SELECT CASE kk
  73.         CASE ASC("1")
  74.             CALL SetupPoolGame
  75.             EXIT DO
  76.         CASE ASC("2")
  77.             CALL SetupWackyGame
  78.             EXIT DO
  79.         CASE ASC("3")
  80.             CALL SetupRings
  81.             EXIT DO
  82.         CASE ASC("4")
  83.             CALL SetupWallsOnly
  84.             EXIT DO
  85.         CASE ASC("5")
  86.             CALL SetupAnglePong
  87.             EXIT DO
  88.         CASE ELSE
  89.             _KEYCLEAR
  90.     END SELECT
  91.     _LIMIT 30
  93.  
  94. CALL Graphics
  95. CALL cprintstring(-16 * 4, "During Play:")
  96. CALL cprintstring(-16 * 6, "Move mouse to select closest object (by centroid).")
  97. CALL cprintstring(-16 * 7, "Boost velocity with arrow keys or W/S/A/D.        ")
  98. CALL cprintstring(-16 * 8, "Boost angluar velocity with Q/E.                  ")
  99. CALL cprintstring(-16 * 9, "Drag and fling object with Mouse 1.               ")
  100. CALL cprintstring(-16 * 10, "Rotate selected object with Mousewheel.           ")
  101. CALL cprintstring(-16 * 11, "Halt all motion with ESC.                         ")
  102. CALL cprintstring(-16 * 12, "Create new ball with Mouse 2.                     ")
  103. CALL cprintstring(-16 * 13, "Initiate creative mode with SPACE.                ")
  104. CALL cprintstring(-16 * 14, "Restart by pressing R during motion.              ")
  105. CALL cprintstring(-16 * 16, "PRESS ANY KEY TO BEGIN.")
  110.  
  111. ' Main loop
  113.     IF (UserInput = -1) THEN GOTO start
  114.     CALL PairDynamics(CPC, FPC, RST)
  115.     CALL FleetDynamics(VD, SV)
  116.     CALL Graphics
  117.     _LIMIT 120
  119.  
  121.  
  122. FUNCTION UserInput
  123.     TheReturn = 0
  124.     ' Keyboard input
  125.     kk = _KEYHIT
  126.     SELECT CASE kk
  127.         CASE 32
  128.             DO: LOOP UNTIL _KEYHIT
  129.             WHILE _MOUSEINPUT: WEND
  130.             _KEYCLEAR
  131.             CALL cprintstring(16 * 17, "Drag Mouse 1 counter-clockwise to draw a new shape.")
  132.             CALL cprintstring(16 * 16, "Make sure centroid is inside body.                 ")
  133.             CALL NewMouseShape(7.5, 150, 15)
  134.             CLS
  135.         CASE 18432, ASC("w"), ASC("W") ' Up arrow
  136.             Shape(SelectedShape).Velocity.y = Shape(SelectedShape).Velocity.y * 1.05 + 1.5
  137.         CASE 20480, ASC("s"), ASC("S") ' Down arrow
  138.             Shape(SelectedShape).Velocity.y = Shape(SelectedShape).Velocity.y * 0.95 - 1.5
  139.         CASE 19200, ASC("a"), ASC("A") ' Left arrow
  140.             Shape(SelectedShape).Velocity.x = Shape(SelectedShape).Velocity.x * 0.95 - 1.5
  141.         CASE 19712, ASC("d"), ASC("D") ' Right arrow
  142.             Shape(SelectedShape).Velocity.x = Shape(SelectedShape).Velocity.x * 1.05 + 1.5
  143.         CASE ASC("e"), ASC("E")
  144.             Shape(SelectedShape).Omega = Omega * 0.5 - .02
  145.         CASE ASC("q"), ASC("Q")
  146.             Shape(SelectedShape).Omega = Omega * 1.5 + .02
  147.         CASE ASC("r"), ASC("R")
  148.             TheReturn = -1
  149.         CASE 27
  150.             FOR k = 1 TO ShapeCount
  151.                 Shape(k).Velocity.x = .000001 * (RND - .5)
  152.                 Shape(k).Velocity.y = .000001 * (RND - .5)
  153.                 Shape(k).Omega = .000001 * (RND - .5)
  154.             NEXT
  155.     END SELECT
  156.     IF (kk) THEN
  157.         _KEYCLEAR
  158.     END IF
  159.  
  160.     ' Mouse input
  161.     mb = 0
  162.     mxold = 999999999
  163.     myold = 999999999
  165.         x = _MOUSEX
  166.         y = _MOUSEY
  167.         IF (x > 0) AND (x < _WIDTH) AND (y > 0) AND (y < _HEIGHT) THEN
  168.             x = x - (_WIDTH / 2)
  169.             y = -y + (_HEIGHT / 2)
  170.             rmin = 999999999
  171.             FOR k = 1 TO ShapeCount
  172.                 dx = x - Shape(k).Centroid.x
  173.                 dy = y - Shape(k).Centroid.y
  174.                 r2 = dx * dx + dy * dy
  175.                 IF (r2 < rmin) THEN
  176.                     rmin = r2
  177.                     SelectedShape = k
  178.                 END IF
  179.             NEXT
  180.             IF (_MOUSEBUTTON(1)) THEN
  181.                 IF (mb = 0) THEN
  182.                     mb = 1
  183.                     vtemp.x = x - Shape(SelectedShape).Centroid.x
  184.                     vtemp.y = y - Shape(SelectedShape).Centroid.y
  185.                     CALL TranslateShape(SelectedShape, vtemp)
  186.                     Shape(SelectedShape).Velocity.x = 0
  187.                     Shape(SelectedShape).Velocity.y = 0
  188.                     Shape(SelectedShape).Omega = 0
  189.                     mxold = x
  190.                     myold = y
  191.                 END IF
  192.             END IF
  193.             IF (_MOUSEBUTTON(2)) THEN
  194.                 IF (mb = 0) THEN
  195.                     mb = 1
  196.                     CALL NewAutoBall(x, y, 15, 0, 1, 1, 0)
  197.                     _DELAY .1
  198.                 END IF
  199.             END IF
  200.             IF (_MOUSEWHEEL > 0) THEN
  201.                 CALL RotShape(SelectedShape, Shape(SelectedShape).Centroid, -.02 * 8 * ATN(1))
  202.             END IF
  203.             IF (_MOUSEWHEEL < 0) THEN
  204.                 CALL RotShape(SelectedShape, Shape(SelectedShape).Centroid, .02 * 8 * ATN(1))
  205.             END IF
  206.         END IF
  207.     LOOP
  208.     IF ((mxold <> 999999999) AND (myold <> 999999999)) THEN
  209.         Shape(SelectedShape).Velocity.x = x - mxold
  210.         Shape(SelectedShape).Velocity.y = y - myold
  211.     END IF
  212.     UserInput = TheReturn
  214.  
  215. SUB PairDynamics (CoarseProximityConstant, FineProximityConstant, Restitution)
  216.  
  217.     DIM GrossJ(300) AS INTEGER
  218.     DIM GrossK(300) AS INTEGER
  219.     DIM NumJK AS INTEGER
  220.  
  221.     ' Proximity detection
  222.     ProximalPairsCount = 0
  223.     Shape1 = 0
  224.     Shape2 = 0
  225.     FOR j = 1 TO ShapeCount
  226.         Shape(j).CollisionSwitch = 0
  227.         Shape(j).DeltaO = 0
  228.         Shape(j).DeltaV.x = 0
  229.         Shape(j).DeltaV.y = 0
  230.         Shape(j).PartialNormal.x = 0
  231.         Shape(j).PartialNormal.y = 0
  232.         FOR k = j + 1 TO ShapeCount
  233.             dx = Shape(j).Centroid.x - Shape(k).Centroid.x
  234.             dy = Shape(j).Centroid.y - Shape(k).Centroid.y
  235.             dr = SQR(dx * dx + dy * dy)
  236.             IF (dr < (CoarseProximityConstant) * (Shape(j).Diameter + Shape(k).Diameter)) THEN
  237.                 ProximalPairsCount = ProximalPairsCount + 1
  238.                 ProximalPairs(ProximalPairsCount, 1) = j
  239.                 ProximalPairs(ProximalPairsCount, 2) = k
  240.                 Shape1 = j
  241.                 Shape2 = k
  242.             END IF
  243.         NEXT
  244.     NEXT
  245.  
  246.     IF (ProximalPairsCount > 0) THEN
  247.         FOR n = 1 TO ProximalPairsCount
  248.             Shape1 = ProximalPairs(n, 1)
  249.             Shape2 = ProximalPairs(n, 2)
  250.  
  251.             ' Collision detection
  252.             rmin = 999999999
  253.             ClosestIndex1 = 0
  254.             ClosestIndex2 = 0
  255.             NumJK = 0
  256.             FOR j = 1 TO Shape(Shape1).Elements
  257.                 FOR k = 1 TO Shape(Shape2).Elements
  258.                     dx = PointChain(Shape1, j).x - PointChain(Shape2, k).x
  259.                     dy = PointChain(Shape1, j).y - PointChain(Shape2, k).y
  260.                     r2 = dx * dx + dy * dy
  261.  
  262.                     IF (r2 <= FineProximityConstant) THEN
  263.  
  264.                         ' Partial normal vector 1
  265.                         nx1 = CalculateNormalY(Shape1, j)
  266.                         ny1 = -CalculateNormalX(Shape1, j)
  267.                         nn = SQR(nx1 * nx1 + ny1 * ny1)
  268.                         nx1 = nx1 / nn
  269.                         ny1 = ny1 / nn
  270.                         Shape(Shape1).PartialNormal.x = Shape(Shape1).PartialNormal.x + nx1
  271.                         Shape(Shape1).PartialNormal.y = Shape(Shape1).PartialNormal.y + ny1
  272.  
  273.                         ' Partial normal vector 2
  274.                         nx2 = CalculateNormalY(Shape2, k)
  275.                         ny2 = -CalculateNormalX(Shape2, k)
  276.                         nn = SQR(nx2 * nx2 + ny2 * ny2)
  277.                         nx2 = nx2 / nn
  278.                         ny2 = ny2 / nn
  279.                         Shape(Shape2).PartialNormal.x = Shape(Shape2).PartialNormal.x + nx2
  280.                         Shape(Shape2).PartialNormal.y = Shape(Shape2).PartialNormal.y + ny2
  281.  
  282.                         NumJK = NumJK + 1
  283.                         GrossJ(NumJK) = j
  284.                         GrossK(NumJK) = k
  285.  
  286.                     END IF
  287.                     IF (r2 < rmin) THEN
  288.                         rmin = r2
  289.                         ClosestIndex1 = j
  290.                         ClosestIndex2 = k
  291.                     END IF
  292.                 NEXT
  293.             NEXT
  294.  
  295.             IF (NumJK > 1) THEN
  296.                 IF ((GrossJ(1) - GrossJ(NumJK)) * (GrossJ(1) - GrossJ(NumJK)) > 50) THEN
  297.                     'ClosestIndex1 = 1
  298.                 ELSE
  299.                     ClosestIndex1 = INT(IntegrateArray(GrossJ(), NumJK) / NumJK)
  300.                 END IF
  301.                 IF ((GrossK(1) - GrossK(NumJK)) * (GrossK(1) - GrossK(NumJK)) > 50) THEN
  302.                     'ClosestIndex2 = 1
  303.                 ELSE
  304.                     ClosestIndex2 = INT(IntegrateArray(GrossK(), NumJK) / NumJK)
  305.                 END IF
  306.             END IF
  307.  
  308.             IF (rmin <= FineProximityConstant) THEN
  309.  
  310.                 CollisionCount = CollisionCount + 1
  311.                 Shape(Shape1).CollisionSwitch = 1
  312.                 Shape(Shape2).CollisionSwitch = 1
  313.  
  314.                 ' Undo previous motion
  315.                 IF (Shape(Shape1).Collisions = 0) THEN
  316.                     CALL RotShape(Shape1, Shape(Shape1).Centroid, -Shape(Shape1).Omega)
  317.                     vtemp.x = -(Shape(Shape1).Velocity.x)
  318.                     vtemp.y = -(Shape(Shape1).Velocity.y)
  319.                     CALL TranslateShape(Shape1, vtemp)
  320.                 END IF
  321.                 IF (Shape(Shape2).Collisions = 0) THEN
  322.                     CALL RotShape(Shape2, Shape(Shape2).Centroid, -Shape(Shape2).Omega)
  323.                     vtemp.x = -(Shape(Shape2).Velocity.x)
  324.                     vtemp.y = -(Shape(Shape2).Velocity.y)
  325.                     CALL TranslateShape(Shape2, vtemp)
  326.                 END IF
  327.  
  328.                 ' Momentum absorption
  329.                 IF (Shape(Shape1).Collisions = 0) THEN
  330.                     Shape(Shape1).Velocity.x = Shape(Shape1).Velocity.x * Restitution
  331.                     Shape(Shape1).Velocity.y = Shape(Shape1).Velocity.y * Restitution
  332.                 END IF
  333.                 IF (Shape(Shape2).Collisions = 0) THEN
  334.                     Shape(Shape2).Velocity.x = Shape(Shape2).Velocity.x * Restitution
  335.                     Shape(Shape2).Velocity.y = Shape(Shape2).Velocity.y * Restitution
  336.                 END IF
  337.  
  338.                 ' Centroid of object 1 (cx1, cy1)
  339.                 cx1 = Shape(Shape1).Centroid.x
  340.                 cy1 = Shape(Shape1).Centroid.y
  341.  
  342.                 ' Centroid of object 2 (cx2, cy2)
  343.                 cx2 = Shape(Shape2).Centroid.x
  344.                 cy2 = Shape(Shape2).Centroid.y
  345.  
  346.                 ' Contact point on object 1 (px1, py1)
  347.                 px1 = PointChain(Shape1, ClosestIndex1).x
  348.                 py1 = PointChain(Shape1, ClosestIndex1).y
  349.  
  350.                 ' Contact point on object 2 (px2, py2)
  351.                 px2 = PointChain(Shape2, ClosestIndex2).x
  352.                 py2 = PointChain(Shape2, ClosestIndex2).y
  353.  
  354.                 ' Contact-centroid differentials 1 (dx1, dy1)
  355.                 dx1 = px1 - cx1
  356.                 dy1 = py1 - cy1
  357.  
  358.                 ' Contact-centroid differentials 2 (dx2, dy2)
  359.                 dx2 = px2 - cx2
  360.                 dy2 = py2 - cy2
  361.  
  362.                 ' Normal vector 1 (nx1, ny1)
  363.                 nn = SQR(Shape(Shape1).PartialNormal.x * Shape(Shape1).PartialNormal.x + Shape(Shape1).PartialNormal.y * Shape(Shape1).PartialNormal.y)
  364.                 nx1 = Shape(Shape1).PartialNormal.x / nn
  365.                 ny1 = Shape(Shape1).PartialNormal.y / nn
  366.  
  367.                 ' Normal vector 2 (nx2, ny2)
  368.                 nn = SQR(Shape(Shape2).PartialNormal.x * Shape(Shape2).PartialNormal.x + Shape(Shape2).PartialNormal.y * Shape(Shape2).PartialNormal.y)
  369.                 nx2 = Shape(Shape2).PartialNormal.x / nn
  370.                 ny2 = Shape(Shape2).PartialNormal.y / nn
  371.  
  372.                 '''
  373.                 'nx1 = CalculateNormalY(Shape1, ClosestIndex1)
  374.                 'ny1 = -CalculateNormalX(Shape1, ClosestIndex1)
  375.                 'nn = SQR(nx1 * nx1 + ny1 * ny1)
  376.                 'nx1 = nx1 / nn
  377.                 'ny1 = ny1 / nn
  378.  
  379.                 'nx2 = CalculateNormalY(Shape2, ClosestIndex2)
  380.                 'ny2 = -CalculateNormalX(Shape2, ClosestIndex2)
  381.                 'nn = SQR(nx2 * nx2 + ny2 * ny2)
  382.                 'nx2 = nx2 / nn
  383.                 'ny2 = ny2 / nn
  384.                 '''
  385.  
  386.                 ' Perpendicular vector 1 (prx1, pry1)
  387.                 prx1 = -dy1
  388.                 pry1 = dx1
  389.                 pp = SQR(prx1 * prx1 + pry1 * pry1)
  390.                 prx1 = prx1 / pp
  391.                 pry1 = pry1 / pp
  392.  
  393.                 ' Perpendicular vector 2 (prx2, pry2)
  394.                 prx2 = -dy2
  395.                 pry2 = dx2
  396.                 pp = SQR(prx2 * prx2 + pry2 * pry2)
  397.                 prx2 = prx2 / pp
  398.                 pry2 = pry2 / pp
  399.  
  400.                 ' Angular velocity vector 1 (w1, r1, vx1, vy1)
  401.                 w1 = Shape(Shape1).Omega
  402.                 r1 = SQR(dx1 * dx1 + dy1 * dy1)
  403.                 vx1 = w1 * r1 * prx1
  404.                 vy1 = w1 * r1 * pry1
  405.  
  406.                 ' Angular velocity vector 2 (w2, r2, vx2, vy2)
  407.                 w2 = Shape(Shape2).Omega
  408.                 r2 = SQR(dx2 * dx2 + dy2 * dy2)
  409.                 vx2 = w2 * r2 * prx2
  410.                 vy2 = w2 * r2 * pry2
  411.  
  412.                 ' Mass terms (m1, m2, mu)
  413.                 m1 = Shape(Shape1).Mass
  414.                 m2 = Shape(Shape2).Mass
  415.                 mu = 1 / (1 / m1 + 1 / m2)
  416.  
  417.                 ' Re-Calculate moment of inertia (i1, i2)
  418.                 vtemp.x = px1
  419.                 vtemp.y = py1
  420.                 CALL CalculateMOI(Shape1, vtemp)
  421.                 vtemp.x = px2
  422.                 vtemp.y = py2
  423.                 CALL CalculateMOI(Shape2, vtemp)
  424.                 i1 = Shape(Shape1).MOI
  425.                 i2 = Shape(Shape2).MOI
  426.  
  427.                 ' Velocity differentials (v1, v2, dvtx, dvty)
  428.                 vcx1 = Shape(Shape1).Velocity.x
  429.                 vcy1 = Shape(Shape1).Velocity.y
  430.                 vcx2 = Shape(Shape2).Velocity.x
  431.                 vcy2 = Shape(Shape2).Velocity.y
  432.                 vtx1 = vcx1 + vx1
  433.                 vty1 = vcy1 + vy1
  434.                 vtx2 = vcx2 + vx2
  435.                 vty2 = vcy2 + vy2
  436.                 v1 = SQR(vtx1 * vtx1 + vty1 * vty1)
  437.                 v2 = SQR(vtx2 * vtx2 + vty2 * vty2)
  438.                 dvtx = vtx2 - vtx1
  439.                 dvty = vty2 - vty1
  440.  
  441.                 ' Geometry (n1dotdvt, n2dotdvt)
  442.                 n1dotdvt = nx1 * dvtx + ny1 * dvty
  443.                 n2dotdvt = nx2 * dvtx + ny2 * dvty
  444.  
  445.                 ' Momentum exchange (qx1, qy1, qx2, qy2)
  446.                 qx1 = nx1 * 2 * mu * n1dotdvt
  447.                 qy1 = ny1 * 2 * mu * n1dotdvt
  448.                 qx2 = nx2 * 2 * mu * n2dotdvt
  449.                 qy2 = ny2 * 2 * mu * n2dotdvt
  450.  
  451.                 ' Momentum exchange unit vector (qhat)
  452.                 qq = SQR(qx1 * qx1 + qy1 * qy1)
  453.                 qhatx1 = qx1 / qq
  454.                 qhaty1 = qy1 / qq
  455.                 qq = SQR(qx2 * qx2 + qy2 * qy2)
  456.                 qhatx2 = qx2 / qq
  457.                 qhaty2 = qy2 / qq
  458.  
  459.                 ' Angular impulse
  460.                 q1dotp1 = qx1 * prx1 + qy1 * pry1
  461.                 q2dotp2 = qx2 * prx2 + qy2 * pry2
  462.  
  463.                 ' Translational impulse
  464.                 q1dotn1 = qhatx1 * nx1 + qhaty1 * ny1
  465.                 q2dotn2 = qhatx2 * nx2 + qhaty2 * ny2
  466.                 n1dotr1hat = (nx1 * dx1 + ny1 * dy1) / r1
  467.                 n2dotr2hat = (nx2 * dx2 + ny2 * dy2) / r2
  468.                 f1 = -q1dotn1 * n1dotr1hat
  469.                 f2 = -q2dotn2 * n2dotr2hat
  470.  
  471.                 ' Special case for shape within shape.
  472.                 np = nx1 * nx2 + ny1 * ny2
  473.                 IF (np > 0) THEN
  474.                     dcx = cx1 - cx2
  475.                     dcy = cy1 - cy2
  476.                     dc = SQR(dcx * dcx + dcy * dcy)
  477.                     IF (dc < (r1 + r2)) THEN
  478.                         IF (m1 > m2) THEN ' This criteria may be bullshit in general but works now.
  479.                             q1dotp1 = -q1dotp1
  480.                             f1 = -f1
  481.                         ELSE
  482.                             q2dotp2 = -q2dotp2
  483.                             f2 = -f2
  484.                         END IF
  485.                     END IF
  486.                 END IF
  487.  
  488.                 ' Angular impulse update
  489.                 Shape(Shape1).DeltaO = Shape(Shape1).DeltaO + r1 * q1dotp1 / i1
  490.                 Shape(Shape2).DeltaO = Shape(Shape2).DeltaO - r2 * q2dotp2 / i2
  491.  
  492.                 ' Linear impulse update
  493.                 dvx1 = f1 * qx1 / m1
  494.                 dvy1 = f1 * qy1 / m1
  495.                 dvx2 = f2 * qx2 / m2
  496.                 dvy2 = f2 * qy2 / m2
  497.                 dvx1s = dvx1 * dvx1
  498.                 dvy1s = dvy1 * dvy1
  499.                 dvx2s = dvx2 * dvx2
  500.                 dvy2s = dvy2 * dvy2
  501.                 IF ((dvx1s > .001) AND (dvx1s < 60)) THEN
  502.                     Shape(Shape1).DeltaV.x = Shape(Shape1).DeltaV.x + dvx1
  503.                 END IF
  504.                 IF ((dvy1s > .001) AND (dvy1s < 60)) THEN
  505.                     Shape(Shape1).DeltaV.y = Shape(Shape1).DeltaV.y + dvy1
  506.                 END IF
  507.                 IF ((dvx2s > .001) AND (dvx2s < 60)) THEN
  508.                     Shape(Shape2).DeltaV.x = Shape(Shape2).DeltaV.x + dvx2
  509.                 END IF
  510.                 IF ((dvy2s > .001) AND (dvy2s < 60)) THEN
  511.                     Shape(Shape2).DeltaV.y = Shape(Shape2).DeltaV.y + dvy2
  512.                 END IF
  513.  
  514.                 ' External torque
  515.                 torque1 = m1 * (dx1 * ForceField.y - dy1 * ForceField.x)
  516.                 torque2 = m2 * (dx2 * ForceField.y - dy2 * ForceField.x)
  517.                 Shape(Shape1).DeltaO = Shape(Shape1).DeltaO - torque1 / i1
  518.                 Shape(Shape2).DeltaO = Shape(Shape2).DeltaO - torque2 / i2
  519.  
  520.                 ' Separate along normal
  521.                 vtemp.x = -nx1 * 1 * ((v1 + 0.01) / m1)
  522.                 vtemp.y = -ny1 * 1 * ((v1 + 0.01) / m1)
  523.                 CALL TranslateShape(Shape1, vtemp)
  524.                 vtemp.x = -nx2 * 1 * ((v2 + 0.01) / m2)
  525.                 vtemp.y = -ny2 * 1 * ((v2 + 0.01) / m2)
  526.                 CALL TranslateShape(Shape2, vtemp)
  527.  
  528.                 ' Dent along normal
  529.                 'PointChain(Shape1, ClosestIndex1).x = PointChain(Shape1, ClosestIndex1).x - v1 * nx1 / 2
  530.                 'PointChain(Shape1, ClosestIndex1).y = PointChain(Shape1, ClosestIndex1).y - v1 * ny1 / 2
  531.                 'PointChain(Shape2, ClosestIndex2).x = PointChain(Shape2, ClosestIndex2).x - v2 * nx2 / 2
  532.                 'PointChain(Shape2, ClosestIndex2).y = PointChain(Shape2, ClosestIndex2).y - v2 * ny2 / 2
  533.  
  534.                 ' Feedback
  535.                 IF (Shape(Shape1).Collisions = 0) AND (Shape(Shape2).Collisions = 0) THEN
  536.                     CALL snd(100 * (v1 + v2) / 2, .5)
  537.                 END IF
  538.  
  539.             END IF
  540.         NEXT
  541.     END IF
  543.  
  544. SUB FleetDynamics (MotionDamping, StoppingVelocity)
  545.  
  546.     FOR ShapeIndex = 1 TO ShapeCount
  547.  
  548.         ' Contact update
  549.         IF (Shape(ShapeIndex).CollisionSwitch = 1) THEN
  550.             Shape(ShapeIndex).Collisions = Shape(ShapeIndex).Collisions + 1
  551.         ELSE
  552.             Shape(ShapeIndex).Collisions = 0
  553.         END IF
  554.  
  555.         IF (Shape(ShapeIndex).Fixed = 0) THEN
  556.  
  557.             ' Angular velocity update
  558.             Shape(ShapeIndex).Omega = Shape(ShapeIndex).Omega + Shape(ShapeIndex).DeltaO
  559.  
  560.             ' Linear velocity update
  561.             Shape(ShapeIndex).Velocity.x = Shape(ShapeIndex).Velocity.x + Shape(ShapeIndex).DeltaV.x
  562.             Shape(ShapeIndex).Velocity.y = Shape(ShapeIndex).Velocity.y + Shape(ShapeIndex).DeltaV.y
  563.  
  564.             IF (Shape(ShapeIndex).Collisions < 2) THEN ' changed from = 0
  565.                 ' Freefall (if airborne)
  566.                 Shape(ShapeIndex).Velocity.x = Shape(ShapeIndex).Velocity.x + ForceField.x
  567.                 Shape(ShapeIndex).Velocity.y = Shape(ShapeIndex).Velocity.y + ForceField.y
  568.             ELSE
  569.                 ' Static friction
  570.                 IF ((Shape(ShapeIndex).Velocity.x * Shape(ShapeIndex).Velocity.x) < StoppingVelocity) THEN
  571.                     Shape(ShapeIndex).Velocity.x = Shape(ShapeIndex).Velocity.x * .05
  572.                 END IF
  573.                 IF ((Shape(ShapeIndex).Velocity.y * Shape(ShapeIndex).Velocity.y) < StoppingVelocity) THEN
  574.                     Shape(ShapeIndex).Velocity.y = Shape(ShapeIndex).Velocity.y * .05
  575.                 END IF
  576.                 IF ((Shape(ShapeIndex).Omega * Shape(ShapeIndex).Omega) < .000015 * StoppingVelocity) THEN
  577.                     Shape(ShapeIndex).Omega = 0
  578.                 END IF
  579.             END IF
  580.  
  581.             ' Rotation update
  582.             CALL RotShape(ShapeIndex, Shape(ShapeIndex).Centroid, Shape(ShapeIndex).Omega)
  583.  
  584.             ' Position update
  585.             CALL TranslateShape(ShapeIndex, Shape(ShapeIndex).Velocity)
  586.  
  587.             ' Motion Damping
  588.             Shape(ShapeIndex).Velocity.x = Shape(ShapeIndex).Velocity.x * MotionDamping
  589.             Shape(ShapeIndex).Velocity.y = Shape(ShapeIndex).Velocity.y * MotionDamping
  590.             Shape(ShapeIndex).Omega = Shape(ShapeIndex).Omega * MotionDamping
  591.  
  592.         ELSE
  593.  
  594.             ' Lock all motion
  595.             Shape(ShapeIndex).Velocity.x = 0
  596.             Shape(ShapeIndex).Velocity.y = 0
  597.             Shape(ShapeIndex).Omega = 0
  598.  
  599.         END IF
  600.     NEXT
  601.  
  603.  
  604. SUB Graphics
  605.     LINE (0, 0)-(_WIDTH, _HEIGHT), _RGBA(0, 0, 0, 200), BF
  606.     FOR ShapeIndex = 1 TO ShapeCount
  607.         FOR i = 1 TO Shape(ShapeIndex).Elements - 1
  608.             CALL cpset(PointChain(ShapeIndex, i).x, PointChain(ShapeIndex, i).y, Shape(ShapeIndex).Shade)
  609.             CALL cline(PointChain(ShapeIndex, i).x, PointChain(ShapeIndex, i).y, PointChain(ShapeIndex, i + 1).x, PointChain(ShapeIndex, i + 1).y, Shape(ShapeIndex).Shade)
  610.             IF (ShapeIndex = SelectedShape) THEN
  611.                 CALL ccircle(PointChain(ShapeIndex, i).x, PointChain(ShapeIndex, i).y, 1, Shape(ShapeIndex).Shade)
  612.             END IF
  613.         NEXT
  614.         CALL cpset(PointChain(ShapeIndex, Shape(ShapeIndex).Elements).x, PointChain(ShapeIndex, Shape(ShapeIndex).Elements).y, Shape(ShapeIndex).Shade)
  615.         CALL cline(PointChain(ShapeIndex, 1).x, PointChain(ShapeIndex, 1).y, PointChain(ShapeIndex, Shape(ShapeIndex).Elements).x, PointChain(ShapeIndex, Shape(ShapeIndex).Elements).y, Shape(ShapeIndex).Shade)
  616.         CALL cline(Shape(ShapeIndex).Centroid.x, Shape(ShapeIndex).Centroid.y, PointChain(ShapeIndex, 1).x, PointChain(ShapeIndex, 1).y, Shape(ShapeIndex).Shade)
  617.         IF (ShapeIndex = SelectedShape) THEN
  618.             CALL ccircle(Shape(ShapeIndex).Centroid.x, Shape(ShapeIndex).Centroid.y, 3, Shape(ShapeIndex).Shade)
  619.             CALL cpaint(Shape(ShapeIndex).Centroid.x, Shape(ShapeIndex).Centroid.y, Shape(ShapeIndex).Shade, Shape(ShapeIndex).Shade)
  620.         END IF
  621.     NEXT
  622.     _DISPLAY
  624.  
  625. FUNCTION IntegrateArray (arr() AS INTEGER, lim AS INTEGER)
  626.     t = 0
  627.     FOR j = 1 TO lim
  628.         t = t + arr(j)
  629.     NEXT
  630.     IntegrateArray = t
  632.  
  633. FUNCTION CalculateNormalX (k AS INTEGER, i AS INTEGER)
  634.     DIM l AS Vector
  635.     DIM r AS Vector
  636.     li = i - 1
  637.     ri = i + 1
  638.     IF (i = 1) THEN li = Shape(k).Elements
  639.     IF (i = Shape(k).Elements) THEN ri = 1
  640.     l.x = PointChain(k, li).x
  641.     r.x = PointChain(k, ri).x
  642.     dx = r.x - l.x
  643.     CalculateNormalX = dx
  645.  
  646. FUNCTION CalculateNormalY (k AS INTEGER, i AS INTEGER)
  647.     DIM l AS Vector
  648.     DIM r AS Vector
  649.     li = i - 1
  650.     ri = i + 1
  651.     IF (i = 1) THEN li = Shape(k).Elements
  652.     IF (i = Shape(k).Elements) THEN ri = 1
  653.     l.y = PointChain(k, li).y
  654.     r.y = PointChain(k, ri).y
  655.     dy = r.y - l.y
  656.     CalculateNormalY = dy
  658.  
  659. SUB CalculateCentroid (k AS INTEGER)
  660.     xx = 0
  661.     yy = 0
  662.     FOR i = 1 TO Shape(k).Elements
  663.         xx = xx + PointChain(k, i).x
  664.         yy = yy + PointChain(k, i).y
  665.     NEXT
  666.     Shape(k).Centroid.x = xx / Shape(k).Elements
  667.     Shape(k).Centroid.y = yy / Shape(k).Elements
  669.  
  670. SUB CalculateDiameter (k AS INTEGER)
  671.     r2max = -1
  672.     FOR i = 1 TO Shape(k).Elements
  673.         xx = Shape(k).Centroid.x - PointChain(k, i).x
  674.         yy = Shape(k).Centroid.y - PointChain(k, i).y
  675.         r2 = xx * xx + yy * yy
  676.         IF (r2 > r2max) THEN
  677.             r2max = r2
  678.         END IF
  679.     NEXT
  680.     Shape(k).Diameter = SQR(r2max)
  682.  
  683. SUB CalculateMass (k AS INTEGER, factor AS DOUBLE)
  684.     aa = 0
  685.     FOR i = 2 TO Shape(k).Elements
  686.         x = PointChain(k, i).x - Shape(k).Centroid.x
  687.         y = PointChain(k, i).y - Shape(k).Centroid.y
  688.         dx = (PointChain(k, i).x - PointChain(k, i - 1).x)
  689.         dy = (PointChain(k, i).y - PointChain(k, i - 1).y)
  690.         da = .5 * (x * dy - y * dx)
  691.         aa = aa + da
  692.     NEXT
  693.     Shape(k).Mass = factor * SQR(aa * aa)
  695.  
  696. SUB CalculateMOI (k AS INTEGER, ctrvec AS Vector)
  697.     xx = 0
  698.     yy = 0
  699.     FOR i = 1 TO Shape(k).Elements
  700.         a = ctrvec.x - PointChain(k, i).x
  701.         b = ctrvec.y - PointChain(k, i).y
  702.         xx = xx + a * a
  703.         yy = yy + b * b
  704.     NEXT
  705.     Shape(k).MOI = SQR((xx + yy) * (xx + yy)) * (Shape(k).Mass / Shape(k).Elements)
  707.  
  708. SUB TranslateShape (k AS INTEGER, c AS Vector)
  709.     FOR i = 1 TO Shape(k).Elements
  710.         PointChain(k, i).x = PointChain(k, i).x + c.x
  711.         PointChain(k, i).y = PointChain(k, i).y + c.y
  712.     NEXT
  713.     Shape(k).Centroid.x = Shape(k).Centroid.x + c.x
  714.     Shape(k).Centroid.y = Shape(k).Centroid.y + c.y
  716.  
  717. SUB RotShape (k AS INTEGER, c AS Vector, da AS DOUBLE)
  718.     FOR i = 1 TO Shape(k).Elements
  719.         xx = PointChain(k, i).x - c.x
  720.         yy = PointChain(k, i).y - c.y
  721.         PointChain(k, i).x = c.x + xx * COS(da) - yy * SIN(da)
  722.         PointChain(k, i).y = c.y + yy * COS(da) + xx * SIN(da)
  723.     NEXT
  725.  
  726. SUB NewAutoBall (x1, y1, r1, r2, pa, pb, fx)
  727.     ShapeCount = ShapeCount + 1
  728.     Shape(ShapeCount).Fixed = fx
  729.     Shape(ShapeCount).Collisions = 0
  730.     i = 0
  731.     FOR j = 0 TO (8 * ATN(1)) STEP .02 * 8 * ATN(1)
  732.         i = i + 1
  733.         r = r1 + r2 * COS(pa * j) ^ pb
  734.         PointChain(ShapeCount, i).x = x1 + r * COS(j)
  735.         PointChain(ShapeCount, i).y = y1 + r * SIN(j)
  736.     NEXT
  737.     Shape(ShapeCount).Elements = i
  738.     CALL CalculateCentroid(ShapeCount)
  739.     IF (fx = 0) THEN
  740.         CALL CalculateMass(ShapeCount, 1)
  741.     ELSE
  742.         CALL CalculateMass(ShapeCount, 999999)
  743.     END IF
  744.     CALL CalculateMOI(ShapeCount, Shape(ShapeCount).Centroid)
  745.     CALL CalculateDiameter(ShapeCount)
  746.     Shape(ShapeCount).Velocity.x = 0
  747.     Shape(ShapeCount).Velocity.y = 0
  748.     Shape(ShapeCount).Omega = 0
  749.     IF (fx = 0) THEN
  750.         Shape(ShapeCount).Shade = _RGB(100 + INT(RND * 155), 100 + INT(RND * 155), 100 + INT(RND * 155))
  751.     ELSE
  752.         Shape(ShapeCount).Shade = _RGB(100, 100, 100)
  753.     END IF
  754.     SelectedShape = ShapeCount
  756.  
  757. SUB NewAutoBrick (x1, y1, wx, wy, ang)
  758.     ShapeCount = ShapeCount + 1
  759.     Shape(ShapeCount).Fixed = 1
  760.     Shape(ShapeCount).Collisions = 0
  761.     i = 0
  762.     FOR j = -wy / 2 TO wy / 2 STEP 5
  763.         i = i + 1
  764.         PointChain(ShapeCount, i).x = x1 + wx / 2
  765.         PointChain(ShapeCount, i).y = y1 + j
  766.     NEXT
  767.     FOR j = wx / 2 TO -wx / 2 STEP -5
  768.         i = i + 1
  769.         PointChain(ShapeCount, i).x = x1 + j
  770.         PointChain(ShapeCount, i).y = y1 + wy / 2
  771.     NEXT
  772.     FOR j = wy / 2 TO -wy / 2 STEP -5
  773.         i = i + 1
  774.         PointChain(ShapeCount, i).x = x1 - wx / 2
  775.         PointChain(ShapeCount, i).y = y1 + j
  776.     NEXT
  777.     FOR j = -wx / 2 TO wx / 2 STEP 5
  778.         i = i + 1
  779.         PointChain(ShapeCount, i).x = x1 + j
  780.         PointChain(ShapeCount, i).y = y1 - wy / 2
  781.     NEXT
  782.     Shape(ShapeCount).Elements = i
  783.     CALL CalculateCentroid(ShapeCount)
  784.     CALL CalculateMass(ShapeCount, 99999)
  785.     CALL CalculateMOI(ShapeCount, Shape(ShapeCount).Centroid)
  786.     CALL CalculateDiameter(ShapeCount)
  787.     Shape(ShapeCount).Velocity.x = 0
  788.     Shape(ShapeCount).Velocity.y = 0
  789.     Shape(ShapeCount).Omega = 0
  790.     Shape(ShapeCount).Shade = _RGB(100, 100, 100)
  791.     SelectedShape = ShapeCount
  792.     CALL RotShape(ShapeCount, Shape(ShapeCount).Centroid, ang)
  794.  
  795. SUB NewBrickLine (xi, yi, xf, yf, wx, wy)
  796.     d1 = SQR((xf - xi) ^ 2 + (yf - yi) ^ 2)
  797.     d2 = SQR(wx ^ 2 + wy ^ 2)
  798.     ang = ATN((yf - yi) / (xf - xi))
  799.     f = 1.2 * d2 / d1
  800.     FOR t = 0 TO 1 + f STEP f
  801.         CALL NewAutoBrick(xi * (1 - t) + xf * t, yi * (1 - t) + yf * t, wx, wy, ang)
  802.     NEXT
  804.  
  805. SUB NewMouseShape (rawresolution AS DOUBLE, targetpoints AS INTEGER, smoothiterations AS INTEGER)
  806.     ShapeCount = ShapeCount + 1
  807.     Shape(ShapeCount).Fixed = 0
  808.     Shape(ShapeCount).Collisions = 0
  809.     numpoints = 0
  810.     xold = 999 ^ 999
  811.     yold = 999 ^ 999
  812.     DO
  813.         DO WHILE _MOUSEINPUT
  814.             x = _MOUSEX
  815.             y = _MOUSEY
  816.             IF (x > 0) AND (x < _WIDTH) AND (y > 0) AND (y < _HEIGHT) THEN
  817.                 IF _MOUSEBUTTON(1) THEN
  818.                     x = x - (_WIDTH / 2)
  819.                     y = -y + (_HEIGHT / 2)
  820.                     delta = SQR((x - xold) ^ 2 + (y - yold) ^ 2)
  821.                     IF (delta > rawresolution) AND (numpoints < targetpoints - 1) THEN
  822.                         numpoints = numpoints + 1
  823.                         PointChain(ShapeCount, numpoints).x = x
  824.                         PointChain(ShapeCount, numpoints).y = y
  825.                         CALL cpset(x, y, _RGB(0, 255, 255))
  826.                         xold = x
  827.                         yold = y
  828.                     END IF
  829.                 END IF
  830.             END IF
  831.         LOOP
  832.         _DISPLAY
  833.     LOOP UNTIL NOT _MOUSEBUTTON(1) AND (numpoints > 1)
  834.  
  835.     DO WHILE (numpoints < targetpoints)
  836.         rad2max = -1
  837.         kmax = -1
  838.         FOR k = 1 TO numpoints - 1
  839.             xfac = PointChain(ShapeCount, k).x - PointChain(ShapeCount, k + 1).x
  840.             yfac = PointChain(ShapeCount, k).y - PointChain(ShapeCount, k + 1).y
  841.             rad2 = xfac ^ 2 + yfac ^ 2
  842.             IF rad2 > rad2max THEN
  843.                 kmax = k
  844.                 rad2max = rad2
  845.             END IF
  846.         NEXT
  847.         edgecase = 0
  848.         xfac = PointChain(ShapeCount, numpoints).x - PointChain(ShapeCount, 1).x
  849.         yfac = PointChain(ShapeCount, numpoints).y - PointChain(ShapeCount, 1).y
  850.         rad2 = xfac ^ 2 + yfac ^ 2
  851.         IF (rad2 > rad2max) THEN
  852.             kmax = numpoints
  853.             rad2max = rad2
  854.             edgecase = 1
  855.         END IF
  856.         numpoints = numpoints + 1
  857.         IF (edgecase = 0) THEN
  858.             FOR j = numpoints TO kmax + 1 STEP -1
  859.                 PointChain(ShapeCount, j + 1).x = PointChain(ShapeCount, j).x
  860.                 PointChain(ShapeCount, j + 1).y = PointChain(ShapeCount, j).y
  861.             NEXT
  862.             PointChain(ShapeCount, kmax + 1).x = (1 / 2) * (PointChain(ShapeCount, kmax).x + PointChain(ShapeCount, kmax + 2).x)
  863.             PointChain(ShapeCount, kmax + 1).y = (1 / 2) * (PointChain(ShapeCount, kmax).y + PointChain(ShapeCount, kmax + 2).y)
  864.         ELSE
  865.             PointChain(ShapeCount, numpoints).x = (1 / 2) * (PointChain(ShapeCount, 1).x + PointChain(ShapeCount, numpoints - 1).x)
  866.             PointChain(ShapeCount, numpoints).y = (1 / 2) * (PointChain(ShapeCount, 1).y + PointChain(ShapeCount, numpoints - 1).y)
  867.         END IF
  868.     LOOP
  869.  
  870.     FOR j = 1 TO smoothiterations
  871.         FOR k = 2 TO numpoints - 1
  872.             TempChain(ShapeCount, k).x = (1 / 2) * (PointChain(ShapeCount, k - 1).x + PointChain(ShapeCount, k + 1).x)
  873.             TempChain(ShapeCount, k).y = (1 / 2) * (PointChain(ShapeCount, k - 1).y + PointChain(ShapeCount, k + 1).y)
  874.         NEXT
  875.         FOR k = 2 TO numpoints - 1
  876.             PointChain(ShapeCount, k).x = TempChain(ShapeCount, k).x
  877.             PointChain(ShapeCount, k).y = TempChain(ShapeCount, k).y
  878.         NEXT
  879.         TempChain(ShapeCount, 1).x = (1 / 2) * (PointChain(ShapeCount, numpoints).x + PointChain(ShapeCount, 2).x)
  880.         TempChain(ShapeCount, 1).y = (1 / 2) * (PointChain(ShapeCount, numpoints).y + PointChain(ShapeCount, 2).y)
  881.         PointChain(ShapeCount, 1).x = TempChain(ShapeCount, 1).x
  882.         PointChain(ShapeCount, 1).y = TempChain(ShapeCount, 1).y
  883.         TempChain(ShapeCount, numpoints).x = (1 / 2) * (PointChain(ShapeCount, 1).x + PointChain(ShapeCount, numpoints - 1).x)
  884.         TempChain(ShapeCount, numpoints).y = (1 / 2) * (PointChain(ShapeCount, 1).y + PointChain(ShapeCount, numpoints - 1).y)
  885.         PointChain(ShapeCount, numpoints).x = TempChain(ShapeCount, numpoints).x
  886.         PointChain(ShapeCount, numpoints).y = TempChain(ShapeCount, numpoints).y
  887.     NEXT
  888.  
  889.     Shape(ShapeCount).Elements = numpoints
  890.     CALL CalculateCentroid(ShapeCount)
  891.     CALL CalculateMass(ShapeCount, 1)
  892.     CALL CalculateMOI(ShapeCount, Shape(ShapeCount).Centroid)
  893.     CALL CalculateDiameter(ShapeCount)
  894.     Shape(ShapeCount).Velocity.x = 0
  895.     Shape(ShapeCount).Velocity.y = 0
  896.     Shape(ShapeCount).Omega = 0
  897.     Shape(ShapeCount).Shade = _RGB(100 + INT(RND * 155), 100 + INT(RND * 155), 100 + INT(RND * 155))
  898.     SelectedShape = ShapeCount
  900.  
  901. SUB cline (x1, y1, x2, y2, col AS _UNSIGNED LONG)
  902.     LINE (_WIDTH / 2 + x1, -y1 + _HEIGHT / 2)-(_WIDTH / 2 + x2, -y2 + _HEIGHT / 2), col
  904.  
  905. SUB ccircle (x1, y1, rad, col AS _UNSIGNED LONG)
  906.     CIRCLE (_WIDTH / 2 + x1, -y1 + _HEIGHT / 2), rad, col
  908.  
  909. SUB cpset (x1, y1, col AS _UNSIGNED LONG)
  910.     PSET (_WIDTH / 2 + x1, -y1 + _HEIGHT / 2), col
  912.  
  913. SUB cpaint (x1, y1, col1 AS _UNSIGNED LONG, col2 AS _UNSIGNED LONG)
  914.     PAINT (_WIDTH / 2 + x1, -y1 + _HEIGHT / 2), col1, col2
  916.  
  917. SUB cprintstring (y, a AS STRING)
  918.     _PRINTSTRING (_WIDTH / 2 - (LEN(a) * 8) / 2, -y + _HEIGHT / 2), a
  920.  
  921. SUB snd (frq, dur)
  922.     IF ((frq >= 37) AND (frq <= 2000)) THEN
  923.         SOUND frq, dur
  924.     END IF
  926.  
  927. SUB SetupPoolGame
  928.     ' Set external field
  929.     ForceField.x = 0
  930.     ForceField.y = 0
  931.  
  932.     ' Rectangular border
  933.     wx = 42
  934.     wy = 10
  935.     CALL NewBrickLine(-_WIDTH / 2 + wx, _HEIGHT / 2 - wy, _WIDTH / 2 - wx, _HEIGHT / 2 - wy, wx, wy)
  936.     CALL NewBrickLine(-_WIDTH / 2 + wx, -_HEIGHT / 2 + wy, _WIDTH / 2 - wx, -_HEIGHT / 2 + wy, wx, wy)
  937.     wx = 40
  938.     wy = 10
  939.     CALL NewBrickLine(-_WIDTH / 2 + wy, -_HEIGHT / 2 + 2 * wx, -_WIDTH / 2 + wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  940.     CALL NewBrickLine(_WIDTH / 2 - wy, -_HEIGHT / 2 + 2 * wx, _WIDTH / 2 - wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  941.  
  942.     ' Balls (billiard setup)
  943.     x0 = 160
  944.     y0 = 0
  945.     r = 15
  946.     gg = 2 * r + 4
  947.     xf = COS(30 * 3.14159 / 180)
  948.     yf = SIN(30 * 3.14159 / 180)
  949.     gx = gg * xf
  950.     gy = gg * yf
  951.  
  952.     CALL NewAutoBall(x0 + 0 * gx, y0 + 0 * gy, r, 0, 1, 1, 0)
  953.     CALL NewAutoBall(x0 + 1 * gx, y0 + 1 * gy, r, 0, 1, 1, 0)
  954.     CALL NewAutoBall(x0 + 1 * gx, y0 - 1 * gy, r, 0, 1, 1, 0)
  955.     CALL NewAutoBall(x0 + 2 * gx, y0 + 2 * gy, r, 0, 1, 1, 0)
  956.     CALL NewAutoBall(x0 + 2 * gx, y0 + 0 * gy, r, 0, 1, 1, 0)
  957.     CALL NewAutoBall(x0 + 2 * gx, y0 - 2 * gy, r, 0, 1, 1, 0)
  958.     CALL NewAutoBall(x0 + 3 * gx, y0 + 3 * gy, r, 0, 1, 1, 0)
  959.     CALL NewAutoBall(x0 + 3 * gx, y0 + 1 * gy, r, 0, 1, 1, 0)
  960.     CALL NewAutoBall(x0 + 3 * gx, y0 - 1 * gy, r, 0, 1, 1, 0)
  961.     CALL NewAutoBall(x0 + 3 * gx, y0 - 3 * gy, r, 0, 1, 1, 0)
  962.     CALL NewAutoBall(x0 + 4 * gx, y0 + 4 * gy, r, 0, 1, 1, 0)
  963.     CALL NewAutoBall(x0 + 4 * gx, y0 + 2 * gy, r, 0, 1, 1, 0)
  964.     CALL NewAutoBall(x0 + 4 * gx, y0 - 0 * gy, r, 0, 1, 1, 0)
  965.     CALL NewAutoBall(x0 + 4 * gx, y0 - 2 * gy, r, 0, 1, 1, 0)
  966.     CALL NewAutoBall(x0 + 4 * gx, y0 - 4 * gy, r, 0, 1, 1, 0)
  967.  
  968.     ' Cue ball
  969.     CALL NewAutoBall(-220, 0, r, 0, 1, 1, 0)
  970.     Shape(ShapeCount).Velocity.x = 10 + 2 * RND
  971.     Shape(ShapeCount).Velocity.y = 1 * (RND - .5)
  972.     Shape(ShapeCount).Shade = _RGB(255, 255, 255)
  973.  
  974.     ' Parameters
  975.     CPC = 1.15
  976.     FPC = 8
  977.     RST = 0.75
  978.     VD = 0.995
  979.     SV = 0
  981.  
  982. SUB SetupWackyGame
  983.     ' Set external field
  984.     ForceField.x = 0
  985.     ForceField.y = -.08
  986.  
  987.     ' Rectangular border
  988.     wx = 42
  989.     wy = 10
  990.     CALL NewBrickLine(-_WIDTH / 2 + wx, _HEIGHT / 2 - wy, _WIDTH / 2 - wx, _HEIGHT / 2 - wy, wx, wy)
  991.     CALL NewBrickLine(-_WIDTH / 2 + wx, -_HEIGHT / 2 + wy, _WIDTH / 2 - wx, -_HEIGHT / 2 + wy, wx, wy)
  992.     wx = 40
  993.     wy = 10
  994.     CALL NewBrickLine(-_WIDTH / 2 + wy, -_HEIGHT / 2 + 2 * wx, -_WIDTH / 2 + wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  995.     CALL NewBrickLine(_WIDTH / 2 - wy, -_HEIGHT / 2 + 2 * wx, _WIDTH / 2 - wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  996.  
  997.     ' Wacky balls
  998.     x0 = -70
  999.     y0 = 120
  1000.     r1 = 15
  1001.     r2 = 2.5
  1002.     gg = 2.5 * (r1 + r2) + 3.5
  1003.     xf = COS(30 * 3.14159 / 180)
  1004.     yf = SIN(30 * 3.14159 / 180)
  1005.     gx = gg * xf
  1006.     gy = gg * yf
  1007.     CALL NewAutoBall(x0 + 0 * gx, y0 + 0 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1008.     CALL NewAutoBall(x0 + 1 * gx, y0 + 1 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1009.     CALL NewAutoBall(x0 + 1 * gx, y0 - 1 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1010.     CALL NewAutoBall(x0 + 2 * gx, y0 + 2 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1011.     CALL NewAutoBall(x0 + 2 * gx, y0 + 0 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1012.     CALL NewAutoBall(x0 + 2 * gx, y0 - 2 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1013.     CALL NewAutoBall(x0 + 3 * gx, y0 + 3 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1014.     CALL NewAutoBall(x0 + 3 * gx, y0 + 1 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1015.     CALL NewAutoBall(x0 + 3 * gx, y0 - 1 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1016.     CALL NewAutoBall(x0 + 3 * gx, y0 - 3 * gy, r1, r2, INT(RND * 3) + 1, INT(RND * 1) + 2, 0)
  1017.  
  1018.     ' Slanted bricks
  1019.     wx = 60
  1020.     wy = 10
  1021.     ww = SQR(wx * wx + wy * wy) * .85
  1022.     CALL NewBrickLine(ww, 0, 100 + ww, 100, wx, wy)
  1023.     CALL NewBrickLine(-ww, 0, -100 - ww, 100, wx, wy)
  1024.  
  1025.     ' Fidget spinner
  1026.     CALL NewAutoBall(-220, 0, 20, 15, 1.5, 2, 0)
  1027.     Shape(ShapeCount).Shade = _RGB(255, 255, 255)
  1028.  
  1029.     ' Parameters
  1030.     CPC = 1.15
  1031.     FPC = 8
  1032.     RST = 0.70
  1033.     VD = 0.995
  1034.     SV = 0.025
  1036.  
  1037. SUB SetupRings
  1038.     ' Set external field
  1039.     ForceField.x = 0
  1040.     ForceField.y = 0
  1041.  
  1042.     ' Rectangular border
  1043.     wx = 42
  1044.     wy = 10
  1045.     CALL NewBrickLine(-_WIDTH / 2 + wx, _HEIGHT / 2 - wy, _WIDTH / 2 - wx, _HEIGHT / 2 - wy, wx, wy)
  1046.     CALL NewBrickLine(-_WIDTH / 2 + wx, -_HEIGHT / 2 + wy, _WIDTH / 2 - wx, -_HEIGHT / 2 + wy, wx, wy)
  1047.     wx = 40
  1048.     wy = 10
  1049.     CALL NewBrickLine(-_WIDTH / 2 + wy, -_HEIGHT / 2 + 2 * wx, -_WIDTH / 2 + wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  1050.     CALL NewBrickLine(_WIDTH / 2 - wy, -_HEIGHT / 2 + 2 * wx, _WIDTH / 2 - wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  1051.  
  1052.     FOR r = 25 TO 175 STEP 25
  1053.         CALL NewAutoBall(0, 0, r, 0, 1, 1, 0)
  1054.     NEXT
  1055.  
  1056.     ' Parameters
  1057.     CPC = 1.15
  1058.     FPC = 8
  1059.     RST = 0.75
  1060.     VD = 0.995
  1061.     SV = 0.025
  1063.  
  1064. SUB SetupWallsOnly
  1065.     ' Set external field
  1066.     ForceField.x = 0
  1067.     ForceField.y = 0 - .08
  1068.  
  1069.     ' Fidget spinner
  1070.     CALL NewAutoBall(-220, 0, 20, 15, 1.5, 2, 0)
  1071.     Shape(ShapeCount).Shade = _RGB(255, 255, 255)
  1072.  
  1073.     ' Rectangular border
  1074.     wx = 42
  1075.     wy = 10
  1076.     CALL NewBrickLine(-_WIDTH / 2 + wx, _HEIGHT / 2 - wy, _WIDTH / 2 - wx, _HEIGHT / 2 - wy, wx, wy)
  1077.     CALL NewBrickLine(-_WIDTH / 2 + wx, -_HEIGHT / 2 + wy, _WIDTH / 2 - wx, -_HEIGHT / 2 + wy, wx, wy)
  1078.     wx = 40
  1079.     wy = 10
  1080.     CALL NewBrickLine(-_WIDTH / 2 + wy, -_HEIGHT / 2 + 2 * wx, -_WIDTH / 2 + wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  1081.     CALL NewBrickLine(_WIDTH / 2 - wy, -_HEIGHT / 2 + 2 * wx, _WIDTH / 2 - wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  1082.  
  1083.     ' Parameters
  1084.     CPC = 1.15
  1085.     FPC = 8
  1086.     RST = 0.75
  1087.     VD = 0.995
  1088.     SV = 0.025
  1090.  
  1091. SUB SetupAnglePong
  1092.     ' Set external field
  1093.     ForceField.x = 0
  1094.     ForceField.y = 0
  1095.  
  1096.     ' Rectangular border
  1097.     wx = 42
  1098.     wy = 10
  1099.     CALL NewBrickLine(-_WIDTH / 2 + wx, _HEIGHT / 2 - wy, _WIDTH / 2 - wx, _HEIGHT / 2 - wy, wx, wy)
  1100.     CALL NewBrickLine(-_WIDTH / 2 + wx, -_HEIGHT / 2 + wy, _WIDTH / 2 - wx, -_HEIGHT / 2 + wy, wx, wy)
  1101.     wx = 40
  1102.     wy = 10
  1103.     CALL NewBrickLine(-_WIDTH / 2 + wy, -_HEIGHT / 2 + 2 * wx, -_WIDTH / 2 + wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  1104.     CALL NewBrickLine(_WIDTH / 2 - wy, -_HEIGHT / 2 + 2 * wx, _WIDTH / 2 - wy, _HEIGHT / 2 - 2 * wx, wx, wy)
  1105.  
  1106.     ' Pong ball
  1107.     CALL NewAutoBall(0, 200, 20, 0, 1, 1, 0)
  1108.     Shape(ShapeCount).Velocity.x = -1
  1109.     Shape(ShapeCount).Velocity.y = -3
  1110.     Shape(ShapeCount).Shade = _RGB(255, 255, 255)
  1111.  
  1112.     ' Pong Paddle
  1113.     CALL NewAutoBrick(-100, 10, 100, -10, .1)
  1114.     vtemp.x = 0
  1115.     vtemp.y = -200
  1116.     CALL TranslateShape(ShapeCount, vtemp)
  1117.     Shape(ShapeCount).Shade = _RGB(200, 200, 200)
  1118.  
  1119.     ' Parameters
  1120.     CPC = 1.15
  1121.     FPC = 8
  1122.     RST = 1 '0.75
  1123.     VD = 1 '0.995
  1124.     SV = 0.025
crazypool.png
* crazypool.png (Filesize: 20.85 KB, Dimensions: 800x600, Views: 202)
manyballs.png
* manyballs.png (Filesize: 26.92 KB, Dimensions: 800x600, Views: 211)
ringsinrings.png
* ringsinrings.png (Filesize: 10.69 KB, Dimensions: 800x600, Views: 202)
« Last Edit: March 10, 2020, 07:33:54 am by STxAxTIC »
Logged
You're not done when it works, you're done when it's right.

Offline Ashish

  • Forum Resident
  • Posts: 630
  • Never Give Up!
    • View Profile
Re: Collisions - Version 9
« Reply #1 on: March 06, 2020, 12:40:28 am »
Nicee... Amazing, I like how it do collision detection for my custom non-regular shapes... But sometime shape overlap each other & do weird things.
Logged
if (Me.success) {Me.improve()} else {Me.tryAgain()}


My Projects - https://github.com/AshishKingdom?tab=repositories
OpenGL tutorials - https://ashishkingdom.github.io/OpenGL-Tutorials

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Collisions - Version 9
« Reply #2 on: March 06, 2020, 06:08:52 am »
Quote from: Ashish on March 06, 2020, 12:40:28 am
Nicee... Amazing, I like how it do collision detection for my custom non-regular shapes... But sometime shape overlap each other & do weird things.

Theres always one isnt there? I dont blame you for not catching my warning:
Quote
I have done absolutely nothing to fine-tune this engine. Everything it does so far is a product of its prototype parts working together. If one were to use this to make one particular game, some time would be spent getting the adjustable parameters correct. With that said, it's still possible to make things fly too fast, send objects through each other, etc - so nobody complain about this! Just be gentle and get a feel for it.
« Last Edit: March 06, 2020, 06:11:55 am by STxAxTIC »
Logged
You're not done when it works, you're done when it's right.

Offline Ashish

  • Forum Resident
  • Posts: 630
  • Never Give Up!
    • View Profile
Re: Collisions - Version 9
« Reply #3 on: March 06, 2020, 06:54:08 am »
Oh! I was too lazy to read whole post.
Logged
if (Me.success) {Me.improve()} else {Me.tryAgain()}


My Projects - https://github.com/AshishKingdom?tab=repositories
OpenGL tutorials - https://ashishkingdom.github.io/OpenGL-Tutorials

Offline _vince

  • Seasoned Forum Regular
  • Posts: 422
    • View Profile
Re: Collisions - Version 9
« Reply #4 on: March 06, 2020, 10:37:40 pm »
nice mouse controls and centroids feels at home
Logged

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Collisions - Version 9
« Reply #5 on: March 06, 2020, 10:43:45 pm »
Thanks _vince!

I admitted that the mass and centroid calculations are a slight bit fake, but I can make that perfect later. Tee hee hee. Anyway, the reason I checked this thread was to show off a video I just took. Same engine posted above except I added gravity to option 4. Check out this "catapult" demo:

https://www.youtube.com/watch?v=deW8EqbvWvc
Logged
You're not done when it works, you're done when it's right.

Offline bplus

  • Global Moderator
  • Forum Resident
  • Posts: 8053
  • b = b + ...
    • View Profile
Re: Collisions - Version 9
« Reply #6 on: March 06, 2020, 10:48:11 pm »
Cool! Catapult
Logged

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Collisions - Version 9
« Reply #7 on: March 08, 2020, 03:27:57 pm »
Hello guys,

So I decided to experiment by re-adding some deleted code to this engine that "dents inward" each piece when it collides. While this will be turned off in most cases for obvious reasons, I had to grab a video of it. In this link you can see some odd trinkets grinding away at each other as they tumble down. Then I grab the "fidget spinner", grind and end off, and you can watch it squeeze through the funnel as a sharp corner shaves down the rest.

https://youtu.be/H5zuL7YcBh8
« Last Edit: March 08, 2020, 03:29:19 pm by STxAxTIC »
Logged
You're not done when it works, you're done when it's right.

Offline STxAxTIC

  • Library Staff
  • Forum Resident
  • Posts: 1091
  • he lives
    • View Profile
Re: Collisions - Version 9
« Reply #8 on: March 10, 2020, 07:16:57 am »
Good morning,

As a hat tip to what's going on at Angle Pong (https://www.qb64.org/forum/index.php?topic=2309.0), and also as a reality check of my own works, I bring you the angle pong update below. (I quietly updated a few things in the engine, including the way hand-drawn shapes are smoothed. There should be no more sharp edges on those, and it plays a bit nicer now.)

Anyway... You can move the paddle by dragging with mouse 1. Rotate it with mouse wheel. I'll caution you that if the paddle is moving while a collision takes place, the ball will go FLYING and it becomes more like breakout. This is because I didn't hard-code the paddle as such - its just an infinitely heavy rectangle-shaped ball. (The player is a strange god in this universe that can move heavy objects.) So treat it gently and you have angle pong:

... actually - Just see top post and run option 5.
« Last Edit: March 10, 2020, 07:30:11 am by STxAxTIC »
Logged
You're not done when it works, you're done when it's right.
Pages: [1]   Go Up
« previous next »