« previous next »
Pages: [1]   Go Down

Author Topic: rerotating math problem  (Read 4120 times)

0 Members and 1 Guest are viewing this topic.

This topic contains a post which is marked as Best Answer. Press here if you would like to see it.

Offline MasterGy

  • Seasoned Forum Regular
  • Posts: 327
  • people lie, math never lies
    • View Profile
rerotating math problem
« on: June 26, 2020, 12:20:28 pm »
Hi !
I have a math problem with Philipines2 that I haven’t been able to solve from the beginning. I slipped over it because it wasn’t important so far, but it would be nice if it worked now. Perception of objects. Smallest unit is the rectangle. I enter this into the system by latitude, height, length, body center coordinates, and rotation angles.
When I perceive, I rotate my own coordinates negatively relative to the body, and from there I can determine with smaller or larger relations whether I am in the given rectangle or not.
DE!
This only works correctly if I only use 1 rotation. However, if I use rotation in all 3 coordinate planes, it does not sense well.
I’m slowly smashing my head into the wall because I can’t figure it out.
I tried to decipher it to the smallest element and ran into a problem.
My question:
What should I vary in the formula to get the original values ​​back when I rotate it ???
Thank you for your effort!

Code: QB64: [Select]
  1. origox = 0
  2. origoy = 0
  3. origoz = 0
  4. x = 10
  5. y = 10
  6. z = 10
  7. rotatingx = 20 * 3.141592 / 180
  8. rotatingy = 45 * 3.141592 / 180
  9. rotatingz = 20 * 3.141592 / 180
  10.  
  11. 'ROTATING
  12. px = x - origox
  13. py = y - origoy
  14. pz = z - origoz
  15. PRINT "original coordinates:"; px, py, pz
  16. rotx = rotatingx
  17. roty = rotatingy
  18. rotz = rotatingz
  19.  
  20. px2 = (px * COS(rotz)) - (py * SIN(rotz))
  21. py2 = (px * SIN(rotz)) + (py * COS(rotz))
  22. px3 = (px2 * COS(roty)) - (pz * SIN(roty))
  23. pz2 = (px2 * SIN(roty)) + (pz * COS(roty))
  24. py3 = (py2 * COS(rotx)) - (pz2 * SIN(rotx))
  25. pz3 = (py2 * SIN(rotx)) + (pz2 * COS(rotx))
  26. px3 = px3 + origox
  27. py3 = py3 + origoy
  28. pz3 = pz3 + origoz
  29.  
  30.  
  31. PRINT "rotated coordinates:"; px3, py3, pz3
  32. 'ROTATING INVERSE
  33. rotx = -rotatingx: roty = -rotatingy: rotz = -rotatingz
  34.  
  35. px = px3 - origox
  36. py = py3 - origoy
  37. pz = pz3 - origoz
  38.  
  39. px2 = (px * COS(rotz)) - (py * SIN(rotz))
  40. py2 = (px * SIN(rotz)) + (py * COS(rotz))
  41. px3 = (px2 * COS(roty)) - (pz * SIN(roty))
  42. pz2 = (px2 * SIN(roty)) + (pz * COS(roty))
  43. py3 = (py2 * COS(rotx)) - (pz2 * SIN(rotx))
  44. pz3 = (py2 * SIN(rotx)) + (pz2 * COS(rotx))
  45. px3 = px3 + origox
  46. py3 = py3 + origoy
  47. pz3 = pz3 + origoz
  48.  
  49. PRINT "re-rotated coordinates:"; px3, py3, pz3
  50.  
  51. PRINT "why don't i get the original coordinates back?"
  52.  
  53.  
« Last Edit: June 26, 2020, 12:38:57 pm by MasterGy »
Logged

Offline Qwerkey

  • Forum Resident
  • Posts: 755
    • View Profile
Re: rerotating math problem
« Reply #1 on: June 26, 2020, 12:42:10 pm »
@MasterGy In my pi-in-the-sky program (https://www.qb64.org/forum/index.php?topic=1969.0), the image of pi is rotated in all three coordinate angles.  The maths used to do this is in lines 757 - 795 of the program.  I hope that this may be if some use to you.
Logged

Offline MasterGy

  • Seasoned Forum Regular
  • Posts: 327
  • people lie, math never lies
    • View Profile
Re: rerotating math problem
« Reply #2 on: June 26, 2020, 01:34:01 pm »
Thank you for sharing, I find the solution interesting, I will study it tomorrow. What you put into the program is the pinnacle of _MAPTRIANGLE usability! Congratulations!
Logged

Offline bplus

  • Global Moderator
  • Forum Resident
  • Posts: 8053
  • b = b + ...
    • View Profile
Re: rerotating math problem
« Reply #3 on: June 26, 2020, 02:28:08 pm »
See Qwerkey, " is the pinnacle of _MAPTRIANGLE usability!", not just me thinks highly of Pi-in-the-sky. :)

From no less than MasterGy! :)
« Last Edit: June 26, 2020, 02:31:21 pm by bplus »
Logged
Marked as best answer by MasterGy on June 29, 2020, 02:57:44 am

Offline Unseen Machine

  • Forum Regular
  • Posts: 158
  • Make the game not the engine!
    • View Profile
Re: rerotating math problem
« Reply #4 on: June 26, 2020, 02:36:35 pm »
I think im on the right track with this suggestion, check out GDK's rectangle collision detection, it'll tell you if your inside a rectangle of any given rotation.

Code: QB64: [Select]
  1. '\\ Unseen Game Deveopment Kit (GDK) - Version 1.8 - DEVELOPMENT VERSION - NOT FINISHED!!!
  2. '// Updated 30/7/2019
  3. '// Created By John Onyon a.k.a Unseen Machine
  4. '// Optimistation by CodeGuy and DarthWho
  5. '// ScanKeys% function by Cypherium
  6. '// Image rotation function by Galleon
  7. '// Rotated Rectangle Collision Detection By Richard Notley
  8.  
  9. '##########################################################################################################################
  10. '// Typdef's
  11. '##########################################################################################################################
  12.  
  13. SUB GDK_Types
  14.  
  15.  TYPE Sprite
  16.   File AS LONG
  18.   Height AS INTEGER
  19.   Alpha AS _UNSIGNED LONG
  20.   IsVisible AS _BYTE
  21.   XFrameCount AS _BYTE
  22.   YFrameCount AS _BYTE
  23.   TotalFrameCount AS INTEGER
  24.   RotationX AS SINGLE
  25.   RotationY AS SINGLE
  26.   Scale AS SINGLE
  27.   BitMask AS _MEM '// For pixel perfect collisions
  29.  
  30.  TYPE Vector
  31.   X AS SINGLE
  32.   Y AS SINGLE
  33.   Speed AS SINGLE
  34.   Rotation AS DOUBLE
  35.   Accel AS SINGLE
  36.   Decel AS SINGLE
  38.  
  39.  TYPE BoundingCircle
  40.   X AS INTEGER
  41.   Y AS INTEGER
  42.   Radius AS INTEGER
  44.  
  45.  TYPE MouseState
  46.   X AS INTEGER
  47.   Y AS INTEGER
  48.   LB AS _BYTE
  49.   RB AS _BYTE
  50.   MB AS _BYTE
  51.   MW AS _BYTE
  53.  
  54.  TYPE KeyBoardState
  55.   Left AS LONG
  56.   Right AS LONG
  57.   Down AS LONG
  58.   Up AS LONG
  59.   CTRL AS LONG
  60.   SHIFT AS LONG
  61.   ALT AS LONG
  62.   SPACE AS LONG
  63.   ENTER AS LONG
  64.   ESC AS LONG
  65.   Num1 AS LONG
  66.   Num2 AS LONG
  67.   Num3 AS LONG
  68.   Num4 AS LONG
  69.   Num5 AS LONG
  70.   Num6 AS LONG
  71.   Num7 AS LONG
  72.   Num8 AS LONG
  73.   Num9 AS LONG
  74.   Num0 AS LONG
  75.   PLUS AS LONG
  76.   MINUS AS LONG
  77.   BACKSPACE AS LONG
  79.   A AS LONG
  80.   B AS LONG
  81.   C AS LONG
  82.   D AS LONG
  83.   E AS LONG
  84.   F AS LONG
  85.   G AS LONG
  86.   H AS LONG
  87.   I AS LONG
  88.   J AS LONG
  89.   K AS LONG
  90.   L AS LONG
  91.   M AS LONG
  92.   N AS LONG
  93.   O AS LONG
  94.   P AS LONG
  95.   Q AS LONG
  96.   R AS LONG
  97.   S AS LONG
  98.   T AS LONG
  99.   U AS LONG
  100.   V AS LONG
  101.   W AS LONG
  102.   X AS LONG
  103.   Y AS LONG
  104.   Z AS LONG
  106.  
  107.  
  108.  TYPE ANIMATION
  109.   Frame AS INTEGER
  110.   StartFrame AS INTEGER
  111.   ResetFrame AS INTEGER
  113.   Time AS DOUBLE
  114.   Dir AS _BYTE
  116.  
  117.  TYPE Emitter
  118.   X AS INTEGER
  119.   Y AS INTEGER
  120.   SpawnRate AS INTEGER
  121.   SpawnAngleMin AS SINGLE
  122.   SpawnAngleMax AS SINGLE
  123.   SpawnMaxVelocity AS SINGLE
  124.   SpawnMinVelocity AS SINGLE
  125.   MaxLifeTime AS DOUBLE
  126.   MinLifeTime AS DOUBLE
  127.   AccelMax AS SINGLE
  128.   DecelMax AS SINGLE
  129.   AccelMin AS SINGLE
  130.   DecelMIn AS SINGLE
  131.   Gravity AS SINGLE
  133.  
  134.  TYPE Particle
  135.   InitialCLR AS _UNSIGNED LONG
  136.   CurrentCLR AS _UNSIGNED LONG
  137.   ClrChange AS _UNSIGNED LONG
  138.   ClrChangeMode AS INTEGER
  139.   Vector AS Vector
  140.   BirthTime AS DOUBLE
  141.   LifeTime AS DOUBLE
  142.   Exists AS _BYTE
  143.   Accel AS SINGLE
  144.   Decel AS SINGLE
  145.   Gravity AS SINGLE
  147.  
  148.  TYPE Tileset
  149.   Sheet AS Sprite
  150.   THeight AS INTEGER
  151.   TWidth AS INTEGER
  153.  
  154.  TYPE XY
  155.   X AS INTEGER
  156.   Y AS INTEGER
  158.  
  159.  TYPE Rectangle
  160.   XY AS XY
  161.   WH AS XY
  162.   Rotation AS SINGLE
  163.   RotationPoint AS XY
  164.   C1 AS XY
  165.   C2 AS XY
  166.   C3 AS XY
  167.   C4 AS XY
  169.  
  170.  TYPE GameObject
  171.   Sprite AS Sprite
  172.   Vector AS Vector
  173.   Rect AS Rectangle
  175.  
  176.  TYPE Tile
  177.   RECT AS Rectangle
  178.   Tile AS INTEGER
  180.  
  181.  TYPE Path
  182.   Vector AS Vector
  183.   LastVector AS Vector
  184.   TargetVector AS Vector
  185.   NumPoints AS INTEGER
  186.   CurrentPoint AS INTEGER
  187.   HitTargetX AS INTEGER
  188.   HitTargetY AS INTEGER
  189.   Repeat AS INTEGER
  190.   Relative AS INTEGER
  191.   Reverse AS INTEGER
  192.   IsReversing AS INTEGER
  194.  
  195.  TYPE PathPoint
  196.   X AS INTEGER
  197.   Y AS INTEGER
  198.   Speed AS INTEGER
  200.  
  201.  
  203.  
  204. '##########################################################################################################################
  205. '// Collision detection
  206. '##########################################################################################################################
  207.  
  208. SUB GDK_Rectangle_New (RectRef AS Rectangle, x%, y%, Width%, Height%)
  209.  RectRef.XY.X = x%
  210.  RectRef.XY.Y = y%
  211.  RectRef.WH.X = Width%
  212.  RectRef.WH.Y = Height%
  214.  
  215. SUB GDK_Rectangle_Autosize (Sprite AS Sprite, Vector AS Vector, Rect AS Rectangle)
  216.  Rect.XY.X = Vector.X - (Sprite.RotationX * Sprite.Scale)
  217.  Rect.XY.Y = Vector.Y - (Sprite.RotationY * Sprite.Scale)
  218.  Rect.WH.X = (Sprite.Width / Sprite.XFrameCount) * Sprite.Scale
  219.  Rect.WH.Y = (Sprite.Height / Sprite.YFrameCount) * Sprite.Scale
  220.  Rect.Rotation = Vector.Rotation
  221.  Rect.RotationPoint.X = Sprite.RotationX * Sprite.Scale
  222.  Rect.RotationPoint.Y = Sprite.RotationY * Sprite.Scale
  223.  DIM pX(3) AS SINGLE, pY(3) AS SINGLE, W AS LONG, H AS LONG, I AS LONG, X AS LONG, Y AS LONG, X2 AS LONG, Y2 AS LONG, PointX AS LONG, PointY AS LONG
  224.  X = Vector.X
  225.  Y = Vector.Y
  226.  W = (Sprite.Width / Sprite.XFrameCount)
  227.  H = (Sprite.Height / Sprite.YFrameCount)
  228.  PointX = Sprite.RotationX
  229.  PointY = Sprite.RotationY
  230.  pX(0) = -PointX
  231.  pY(0) = -PointY
  232.  pX(1) = -PointX
  233.  pY(1) = -PointY + H - 1
  234.  pX(2) = -PointX + W - 1
  235.  pY(2) = -PointY + H - 1
  236.  pX(3) = -PointX + W - 1
  237.  pY(3) = -PointY 'Set dest screen points
  238.  SINr = SIN(Vector.Rotation)
  239.  COSr = COS(Vector.Rotation) 'Precalculate SIN & COS of angle
  240.  FOR I = 0 TO 3
  241.   pX(I) = pX(I) * Sprite.Scale
  242.   pY(I) = pY(I) * Sprite.Scale 'Scale
  243.   X2 = pX(I) * COSr + SINr * pY(I)
  244.   pY(I) = pY(I) * COSr - pX(I) * SINr
  245.   pX(I) = X2 'Rotate Dest Points
  246.   pX(I) = pX(I) + X
  247.   pY(I) = pY(I) + Y 'Translate Dest Points
  249.    CASE 0
  250.     Rect.C1.X = pX(I)
  251.     Rect.C1.Y = pY(I)
  252.    CASE 1
  253.     Rect.C2.X = pX(I)
  254.     Rect.C2.Y = pY(I)
  255.    CASE 2
  256.     Rect.C3.X = pX(I)
  257.     Rect.C3.Y = pY(I)
  258.    CASE 3
  259.     Rect.C4.X = pX(I)
  260.     Rect.C4.Y = pY(I)
  264.  
  265.  
  266. FUNCTION GDK_Rectangle_Intersect (Rect1 AS Rectangle, Rect2 AS Rectangle)
  267.  'IF Rect1.Rotation = 0 AND Rect2.Rotation = 0 THEN '// No rotation do standard collision check'''
  268.  '
  269.  '    IF Rect1.XY.X <= Rect2.XY.X + Rect2.WH.X THEN
  270.  '      IF Rect1.XY.X + Rect1.WH.X >= Rect2.XY.X THEN
  271.  '        IF Rect1.XY.Y <= Rect2.XY.Y + Rect2.WH.Y THEN
  272.  '          IF Rect1.XY.Y + Rect1.WH.Y >= Rect2.XY.Y THEN
  273.  '            GDK_Rectangle_Intersect = -1
  274.  '            EXIT FUNCTION
  275.  '          END IF
  276.  '        END IF
  277.  '      END IF
  278.  '    END IF'
  279.  
  280.  '  ELSE '// Rotated rectangles
  281.  
  282.  '// Adapted from code created by Richard Notley
  283.  '// http://www.[abandoned, outdated and now likely malicious qb64 dot net website - don’t go there]/forum/index.php?topic=12564.0
  284.  REDIM sngCorners1!(3, 1), sngCorners2!(3, 1), sngCorners2A!(3, 1), sngCentre!(1, 1)
  285.  
  286.  '// Put rect data into arrays
  287.  sngCorners1!(0, 0) = Rect1.C1.X
  288.  sngCorners1!(0, 1) = Rect1.C1.Y
  289.  sngCorners1!(1, 0) = Rect1.C2.X
  290.  sngCorners1!(1, 1) = Rect1.C2.Y
  291.  sngCorners1!(2, 0) = Rect1.C3.X
  292.  sngCorners1!(2, 1) = Rect1.C3.Y
  293.  sngCorners1!(3, 0) = Rect1.C4.X
  294.  sngCorners1!(3, 1) = Rect1.C4.Y
  295.  
  296.  sngCorners2!(0, 0) = Rect2.C1.X
  297.  sngCorners2!(0, 1) = Rect2.C1.Y
  298.  sngCorners2!(1, 0) = Rect2.C2.X
  299.  sngCorners2!(1, 1) = Rect2.C2.Y
  300.  sngCorners2!(2, 0) = Rect2.C3.X
  301.  sngCorners2!(2, 1) = Rect2.C3.Y
  302.  sngCorners2!(3, 0) = Rect2.C4.X
  303.  sngCorners2!(3, 1) = Rect2.C4.Y
  304.  
  305.  'Extra copy of sngCorners2! used for second poke-through condition check
  306.  FOR bytN%% = 0 TO 3
  307.   FOR bytM%% = 0 TO 1
  308.    sngCorners2A!(bytN%%, bytM%%) = sngCorners2!(bytN%%, bytM%%)
  309.   NEXT bytM%%
  310.  NEXT bytN%%
  311.  
  312.  'Find Centres of Rectangles
  313.  sngCentre!(0, 0) = (sngCorners1!(0, 0) + sngCorners1!(1, 0) + sngCorners1!(2, 0) + sngCorners1!(3, 0)) / 4
  314.  sngCentre!(0, 1) = (sngCorners1!(0, 1) + sngCorners1!(1, 1) + sngCorners1!(2, 1) + sngCorners1!(3, 1)) / 4
  315.  sngCentre!(1, 0) = (sngCorners2!(0, 0) + sngCorners2!(1, 0) + sngCorners2!(2, 0) + sngCorners2!(3, 0)) / 4
  316.  sngCentre!(1, 1) = (sngCorners2!(0, 1) + sngCorners2!(1, 1) + sngCorners2!(2, 1) + sngCorners2!(3, 1)) / 4
  317.  
  318.  'Find lengths of rectangle diagonals
  319.  sngDiag1! = (SQR((sngCorners1!(2, 0) - sngCorners1!(0, 0)) * (sngCorners1!(2, 0) - sngCorners1!(0, 0)) + (sngCorners1!(2, 1) - sngCorners1!(0, 1)) * (sngCorners1!(2, 1) - sngCorners1!(0, 1)))) / 2
  320.  sngDiag2! = (SQR((sngCorners2!(2, 0) - sngCorners2!(0, 0)) * (sngCorners2!(2, 0) - sngCorners2!(0, 0)) + (sngCorners2!(2, 1) - sngCorners2!(0, 1)) * (sngCorners2!(2, 1) - sngCorners2!(0, 1)))) / 2
  321.  sngSepn! = SQR((sngCentre!(1, 0) - sngCentre!(0, 0)) * (sngCentre!(1, 0) - sngCentre!(0, 0)) + (sngCentre!(1, 1) - sngCentre!(0, 1)) * (sngCentre!(1, 1) - sngCentre!(0, 1)))
  322.  
  323.  IF sngSepn! <= sngDiag1! + sngDiag2! THEN
  324.   'Only need to do collision check if rectangles are closer than sum of half-diagonals
  325.  
  326.   'Check for intersect of diagonals
  327.   IF HF_CrossOver%%(sngCorners1!(0, 1), sngCorners1!(0, 0), sngCorners1!(2, 1), sngCorners1!(2, 0), sngCorners2!(0, 1), sngCorners2!(0, 0), sngCorners2!(2, 1), sngCorners2!(2, 0)) = -1 THEN
  328.    GDK_Rectangle_Intersect = -1
  330.   ELSEIF HF_CrossOver%%(sngCorners1!(0, 1), sngCorners1!(0, 0), sngCorners1!(2, 1), sngCorners1!(2, 0), sngCorners2!(1, 1), sngCorners2!(1, 0), sngCorners2!(3, 1), sngCorners2!(3, 0)) = -1 THEN
  331.    GDK_Rectangle_Intersect = -1
  333.   ELSEIF HF_CrossOver%%(sngCorners1!(1, 1), sngCorners1!(1, 0), sngCorners1!(3, 1), sngCorners1!(3, 0), sngCorners2!(0, 1), sngCorners2!(0, 0), sngCorners2!(2, 1), sngCorners2!(2, 0)) = -1 THEN
  334.    GDK_Rectangle_Intersect = -1
  336.   ELSEIF HF_CrossOver%%(sngCorners1!(1, 1), sngCorners1!(1, 0), sngCorners1!(3, 1), sngCorners1!(3, 0), sngCorners2!(1, 1), sngCorners2!(1, 0), sngCorners2!(3, 1), sngCorners2!(3, 0)) = -1 THEN
  337.    GDK_Rectangle_Intersect = -1
  339.   ELSE
  340.    'Check for poke-throughs
  341.  
  342.    'adjust sngCorners2! relative to sngArr1! centre
  343.  
  344.    FOR bytN%% = 0 TO 3
  345.     FOR bytM%% = 0 TO 1
  346.      sngCorners2!(bytN%%, bytM%%) = sngCorners2!(bytN%%, bytM%%) - sngCentre!(0, bytM%%)
  347.     NEXT bytM%%
  348.    NEXT bytN%%
  349.  
  350.    'rotate to sngArr1!
  351.  
  352.    'find Angle of sngCorners1!
  353.    sngAngRot! = HF_Angle!(sngCorners1!(3, 1) - sngCorners1!(0, 1), sngCorners1!(3, 0) - sngCorners1!(0, 0))
  354.  
  355.    FOR bytN%% = 0 TO 3
  356.     sngR! = SQR(sngCorners2!(bytN%%, 0) * sngCorners2!(bytN%%, 0) + sngCorners2!(bytN%%, 1) * sngCorners2!(bytN%%, 1)): sngPhi! = HF_Angle!(sngCorners2!(bytN%%, 1), sngCorners2!(bytN%%, 0))
  357.     sngCorners2!(bytN%%, 1) = sngR! * COS(sngPhi! - sngAngRot!)
  358.     sngCorners2!(bytN%%, 0) = sngR! * SIN(sngPhi! - sngAngRot!)
  359.    NEXT bytN%%
  360.  
  361.    'Find height and width of sngCorners1!
  362.    sngRWidth! = SQR((sngCorners1!(0, 0) - sngCorners1!(1, 0)) * (sngCorners1!(0, 0) - sngCorners1!(1, 0)) + (sngCorners1!(0, 1) - sngCorners1!(1, 1)) * (sngCorners1!(0, 1) - sngCorners1!(1, 1)))
  363.    sngRHeight! = SQR((sngCorners1!(0, 0) - sngCorners1!(3, 0)) * (sngCorners1!(0, 0) - sngCorners1!(3, 0)) + (sngCorners1!(0, 1) - sngCorners1!(3, 1)) * (sngCorners1!(0, 1) - sngCorners1!(3, 1)))
  364.  
  365.    FOR bytN%% = 0 TO 3
  366.     IF sngCorners2!(bytN%%, 1) <= sngRHeight! / 2 THEN
  367.      IF sngCorners2!(bytN%%, 1) >= -sngRHeight! / 2 THEN
  368.       IF sngCorners2!(bytN%%, 0) <= sngRWidth! / 2 THEN
  369.        IF sngCorners2!(bytN%%, 0) >= -sngRWidth! / 2 THEN
  370.         GDK_Rectangle_Intersect = -1
  371.         EXIT FUNCTION
  372.        END IF
  373.       END IF
  374.      END IF
  375.     END IF
  376.    NEXT
  377.  
  378.    'adjust sngCorners1! relative to sngArr2! centre
  379.  
  380.    FOR bytN%% = 0 TO 3
  381.     FOR bytM%% = 0 TO 1
  382.      sngCorners1!(bytN%%, bytM%%) = sngCorners1!(bytN%%, bytM%%) - sngCentre!(1, bytM%%)
  383.     NEXT bytM%%
  384.    NEXT bytN%%
  385.  
  386.    'rotate to sngArr2!
  387.  
  388.    'find Angle of sngCorners2A!
  389.    sngAngRot! = HF_Angle!(sngCorners2A!(3, 1) - sngCorners2A!(0, 1), sngCorners2A!(3, 0) - sngCorners2A!(0, 0))
  390.  
  391.    FOR bytN%% = 0 TO 3
  392.     sngR! = SQR(sngCorners1!(bytN%%, 0) * sngCorners1!(bytN%%, 0) + sngCorners1!(bytN%%, 1) * sngCorners1!(bytN%%, 1)): sngPhi! = HF_Angle!(sngCorners1!(bytN%%, 1), sngCorners1!(bytN%%, 0))
  393.     sngCorners1!(bytN%%, 1) = sngR! * COS(sngPhi! - sngAngRot!)
  394.     sngCorners1!(bytN%%, 0) = sngR! * SIN(sngPhi! - sngAngRot!)
  395.    NEXT bytN%%
  396.  
  397.    'Find height and width of sngCorners2!
  398.    sngRWidth! = SQR((sngCorners2A!(0, 0) - sngCorners2A!(1, 0)) * (sngCorners2A!(0, 0) - sngCorners2A!(1, 0)) + (sngCorners2A!(0, 1) - sngCorners2A!(1, 1)) * (sngCorners2A!(0, 1) - sngCorners2A!(1, 1)))
  399.    sngRHeight! = SQR((sngCorners2A!(0, 0) - sngCorners2A!(3, 0)) * (sngCorners2A!(0, 0) - sngCorners2A!(3, 0)) + (sngCorners2A!(0, 1) - sngCorners2A!(3, 1)) * (sngCorners2A!(0, 1) - sngCorners2A!(3, 1)))
  400.  
  401.    FOR bytN%% = 0 TO 3
  402.     IF sngCorners1!(bytN%%, 1) <= sngRHeight! / 2 THEN
  403.      IF sngCorners1!(bytN%%, 1) >= -sngRHeight! / 2 THEN
  404.       IF sngCorners1!(bytN%%, 0) <= sngRWidth! / 2 THEN
  405.        IF sngCorners1!(bytN%%, 0) >= -sngRWidth! / 2 THEN
  406.         GDK_Rectangle_Intersect = -1
  407.         EXIT FUNCTION
  408.        END IF
  409.       END IF
  410.      END IF
  411.     END IF
  412.    NEXT
  413.  
  414.   END IF
  416.  '  END IF
  418.  
  419. FUNCTION HF_Angle! (X!, Y!) '// Helper function for collisions
  420.  IF X! = 0 THEN
  421.   IF Y! < 0 THEN
  422.    HF_Angle! = -_PI / 2
  423.   ELSE
  424.    HF_Angle! = _PI / 2
  425.   END IF
  427.   HF_Angle! = ATN(Y! / X!)
  429.  IF X! < 0 THEN
  430.   HF_Angle! = HF_Angle! - _PI
  431.   IF HF_Angle! < -_PI THEN HF_Angle! = HF_Angle! + 2 * _PI
  434.  
  435. FUNCTION HF_CrossOver%% (sngXT1!, sngYT1!, sngXS1!, sngYS1!, sngXT2!, sngYT2!, sngXS2!, sngYS2!) '// Helper function
  436.  sngM1! = (sngYT1! - sngYS1!) / (sngXT1! - sngXS1!)
  437.  sngC1! = ((sngXT1! * sngYS1!) - (sngXS1! * sngYT1!)) / (sngXT1! - sngXS1!)
  438.  sngM2! = (sngYT2! - sngYS2!) / (sngXT2! - sngXS2!)
  439.  sngC2! = ((sngXT2! * sngYS2!) - (sngXS2! * sngYT2!)) / (sngXT2! - sngXS2!)
  440.  sngXCross! = (sngC1! - sngC2!) / (sngM2! - sngM1!) '!!! <- Possible Divide by zero
  441.  sngYCross! = (sngM1! * sngXCross!) + sngC1!
  442.  sngX1H! = sngXT1!: sngY1H! = sngYT1!
  443.  sngX1L! = sngXS1!: sngY1L! = sngYS1!
  444.  sngX2H! = sngXT2!: sngY2H! = sngYT2!
  445.  sngX2L! = sngXS2!: sngY2L! = sngYS2!
  446.  IF sngX1L! > sngX1H! THEN SWAP sngX1L!, sngX1H!
  447.  IF sngY1L! > sngY1H! THEN SWAP sngY1L!, sngY1H!
  448.  IF sngX2L! > sngX2H! THEN SWAP sngX2L!, sngX2H!
  449.  IF sngY2L! > sngY2H! THEN SWAP sngY2L!, sngY2H!
  450.  IF sngXCross! >= sngX1L! THEN
  451.   IF sngXCross! <= sngX1H! THEN
  452.    IF sngYCross! >= sngY1L! THEN
  453.     IF sngYCross! <= sngY1H! THEN
  454.      IF sngXCross! >= sngX2L! THEN
  455.       IF sngXCross! <= sngX2H! THEN
  456.        IF sngYCross! >= sngY2L! THEN
  457.         IF sngYCross! <= sngY2H! THEN
  458.          HF_CrossOver%% = -1
  459.         END IF
  460.        END IF
  461.       END IF
  462.      END IF
  463.     END IF
  464.    END IF
  465.   END IF
  468.  
  469.  
  470.  
  471. FUNCTION GDK_BoundingCircle_Intersect (Circ1 AS BoundingCircle, Circ2 AS BoundingCircle)
  472.  LRAD% = Circ1.Radius + Circ2.Radius
  473.  CDist! = GDK_Distance(Circ1.X, Circ1.Y, Circ2.X, Circ2.Y)
  474.  IF CDist! > LRAD% THEN
  475.   GDK_BoundingCircle_Intersect = 0
  477.   GDK_BoundingCircle_Intersect = -1
  480.  
  481. SUB GDK_BoundingCircle_New (Circ1 AS BoundingCircle, X%, Y%, Radius%)
  482.  Circ1.X = X%
  483.  Circ1.Y = Y%
  484.  Circ1.Radius = Radius%
  486.  
  487.  
  488. '##########################################################################################################################
  489. '//Vector stuff
  490. '##########################################################################################################################
  491.  
  492. SUB GDK_Vector_New (Vector AS Vector, X%, Y%, Speed!, Rotation#)
  493.  Vector.X = X%
  494.  Vector.Y = Y%
  495.  Vector.Speed = Speed!
  496.  Vector.Rotation = Rotation#
  498.  
  499. SUB GDK_Vector_SetPosition (Vector AS Vector, X%, Y%)
  500.  Vector.X = X%
  501.  Vector.Y = Y%
  503.  
  504. SUB GDK_Vector_SetRotation (Vector AS Vector, Rotation#)
  505.  Vector.Rotation = Rotation#
  507.  
  508. SUB GDK_Vector_SetSpeed (Vector AS Vector, Speed!)
  509.  Vector.Speed = Speed!
  511.  
  512. SUB GDK_Vector_SetAccelDecel (Vector AS Vector, Accel!, Decel!)
  513.  Vector.Accel = Accel!
  514.  Vector.Decel = Decel!
  516.  
  517. SUB GDK_Vector_Update (Vector AS Vector)
  518.  IF Vector.Decel > 0 THEN
  519.   IF Vector.Accel > 0 THEN
  520.    Vector.Accel = Vector.Accel - Vector.Decel
  521.   ELSE
  522.    IF Vector.Speed > (Vector.Decel) THEN Vector.Speed = Vector.Speed - Vector.Decel ELSE Vector.Speed = 0
  523.   END IF
  525.  IF Vector.Accel > 0 THEN Vector.Speed = Vector.Speed + Vector.Accel
  526.  GDK_Vector_Move Vector
  528.  
  529. SUB GDK_Vector_Move (Vector AS Vector)
  530.  Vector.X = Vector.X - SIN(Vector.Rotation) * Vector.Speed
  531.  Vector.Y = Vector.Y - COS(Vector.Rotation) * Vector.Speed
  533.  
  534. '##########################################################################################################################
  535. '// Sprite stuff
  536. '##########################################################################################################################
  537.  
  538. SUB GDK_Sprite_New (Sprite AS Sprite, FileSource$, XFrameCount%, YFrameCount%, TotalFrameCount%, Alpha&)
  539.  Sprite.File = _LOADIMAGE(FileSource$, 32)
  540.  Sprite.Width = _WIDTH(Sprite.File)
  541.  Sprite.Height = _HEIGHT(Sprite.File)
  542.  Sprite.XFrameCount = XFrameCount%
  543.  Sprite.YFrameCount = YFrameCount%
  544.  Sprite.TotalFrameCount = TotalFrameCount%
  545.  Sprite.Scale = 1
  546.  Sprite.IsVisible = -1
  547.  Sprite.Alpha = Alpha&
  549.  
  550. SUB GDK_Sprite_SetRotationPoint (Sprite AS Sprite, X!, Y!)
  551.  Sprite.RotationX = X!
  552.  Sprite.RotationY = Y!
  554.  
  555. SUB GDK_Sprite_SetVisibility (Sprite AS Sprite, OnOff AS _BYTE)
  556.  Sprite.IsVisible = OnOff
  558.  
  559. SUB GDK_Sprite_SetAlpha (Sprite AS Sprite, Alpha&)
  560.  Sprite.Alpha = Alpha&
  562.  
  563. SUB GDK_Sprite_DrawXY (Sprite AS Sprite, X%, Y%, Rotation!, AnimationFrame%)
  564.  DIM tempvect AS Vector
  565.  GDK_Vector_New tempvect, X%, Y%, 0, Rotation!
  566.  GDK_Sprite_Draw Sprite, tempvect, AnimationFrame%
  568.  
  569. SUB GDK_Sprite_Hide (Handle AS Sprite)
  570.  Handle.IsVisible = 0
  572.  
  573. SUB GDK_Sprite_Show (Handle AS Sprite)
  574.  Handle.IsVisible = -1
  576.  
  577. SUB GDK_Sprite_Free (Sprite AS Sprite)
  578.  _FREEIMAGE (Sprite.File)
  579.  Sprite.IsVisible = 0
  581.  
  582. SUB GDK_Sprite_Clone (SourceSprite AS Sprite, DestSprite AS Sprite)
  583.  DestSprite = SourceSprite
  585.  
  586. SUB GDK_Sprite_Clone_X (SourceSprite AS Sprite, DestSprite() AS Sprite, FirstClone%, NumberOfClones%)
  587.  FOR CloneCount% = FirstClone% TO FirstClone% + NumberOfClones% - 1
  588.   DestSprite(CloneCount%) = SourceSprite
  591.  
  592. SUB GDK_Sprite_SetRotationAsCenter (Sprite AS Sprite)
  593.  GDK_Sprite_SetRotationPoint Sprite, Sprite.Width / (Sprite.XFrameCount * 2), Sprite.Height / (Sprite.YFrameCount * 2)
  595.  
  596. '// UPDATED VERSION!!
  597. SUB GDK_Sprite_Draw (Sprite AS Sprite, DestVector AS Vector, Frame%)
  598.  IF Frame% = 0 THEN Frame% = 1
  599.  _CLEARCOLOR Sprite.Alpha, Sprite.File
  600.  IF Sprite.IsVisible THEN
  601.   FrameXSize% = Sprite.Width / Sprite.XFrameCount
  602.   FrameYSize% = Sprite.Height / Sprite.YFrameCount
  603.   FrameXStart% = ((INT((Frame% - 1) MOD Sprite.XFrameCount)) * FrameXSize%)
  604.   FrameYStart% = ((INT((Frame% - 1) / Sprite.XFrameCount)) * FrameYSize%)
  605.   TmpImage& = _NEWIMAGE(FrameXSize%, FrameYSize%, 32)
  606.   _PUTIMAGE (0, 0), Sprite.File, TmpImage&, (FrameXStart%, FrameYStart%)-(FrameXStart% + FrameXSize%, FrameYStart% + FrameYSize%)
  607.   Rotate_Scale_AroundPoint DestVector.X, DestVector.Y, TmpImage&, -GDK_RadianToDegree(DestVector.Rotation), Sprite.Scale, Sprite.Scale, Sprite.RotationX, Sprite.RotationY
  608.   _FREEIMAGE TmpImage&
  611.  
  612.  
  613. '##########################################################################################################################
  614. '// SCREEN Stuff!
  615. '##########################################################################################################################
  616.  
  617. SUB GDK_Screen_SetRes (ScreenHandle&, width%, height%)
  618.  ScreenHandle& = _NEWIMAGE(width%, height%, 32)
  619.  SCREEN ScreenHandle&
  621.  
  622.  
  623. '##########################################################################################################################
  624. '// User input subs and functions.
  625. '##########################################################################################################################
  626.  
  627. SUB GDK_Keyboard_GetState (KeyboardRef AS KeyBoardState)
  628.  FOR x% = 1 TO 88 'read each key scancode from array
  629.   IF x% = 1 THEN KeyboardRef.ESC = ScanKey%(x%)
  630.   IF x% = 2 THEN KeyboardRef.Num1 = ScanKey%(x%)
  631.   IF x% = 3 THEN KeyboardRef.Num2 = ScanKey%(x%)
  632.   IF x% = 4 THEN KeyboardRef.Num3 = ScanKey%(x%)
  633.   IF x% = 5 THEN KeyboardRef.Num4 = ScanKey%(x%)
  634.   IF x% = 6 THEN KeyboardRef.Num5 = ScanKey%(x%)
  635.   IF x% = 7 THEN KeyboardRef.Num6 = ScanKey%(x%)
  636.   IF x% = 8 THEN KeyboardRef.Num7 = ScanKey%(x%)
  637.   IF x% = 9 THEN KeyboardRef.Num8 = ScanKey%(x%)
  638.   IF x% = 10 THEN KeyboardRef.Num9 = ScanKey%(x%)
  639.   IF x% = 11 THEN KeyboardRef.Num0 = ScanKey%(x%)
  640.   IF x% = 12 THEN KeyboardRef.MINUS = ScanKey%(x%)
  641.   IF x% = 13 THEN KeyboardRef.PLUS = ScanKey%(x%)
  642.   IF x% = 14 THEN KeyboardRef.BACKSPACE = ScanKey%(x%)
  643.   IF x% = 15 THEN KeyboardRef.TAB = ScanKey%(x%)
  644.   IF x% = 30 THEN KeyboardRef.A = ScanKey%(x%)
  645.   IF x% = 48 THEN KeyboardRef.B = ScanKey%(x%)
  646.   IF x% = 46 THEN KeyboardRef.C = ScanKey%(x%)
  647.   IF x% = 32 THEN KeyboardRef.D = ScanKey%(x%)
  648.   IF x% = 18 THEN KeyboardRef.E = ScanKey%(x%)
  649.   IF x% = 33 THEN KeyboardRef.F = ScanKey%(x%)
  650.   IF x% = 34 THEN KeyboardRef.G = ScanKey%(x%)
  651.   IF x% = 35 THEN KeyboardRef.H = ScanKey%(x%)
  652.   IF x% = 23 THEN KeyboardRef.I = ScanKey%(x%)
  653.   IF x% = 36 THEN KeyboardRef.J = ScanKey%(x%)
  654.   IF x% = 37 THEN KeyboardRef.K = ScanKey%(x%)
  655.   IF x% = 38 THEN KeyboardRef.L = ScanKey%(x%)
  656.   IF x% = 50 THEN KeyboardRef.M = ScanKey%(x%)
  657.   IF x% = 49 THEN KeyboardRef.N = ScanKey%(x%)
  658.   IF x% = 24 THEN KeyboardRef.O = ScanKey%(x%)
  659.   IF x% = 25 THEN KeyboardRef.P = ScanKey%(x%)
  660.   IF x% = 16 THEN KeyboardRef.Q = ScanKey%(x%)
  661.   IF x% = 19 THEN KeyboardRef.R = ScanKey%(x%)
  662.   IF x% = 31 THEN KeyboardRef.S = ScanKey%(x%)
  663.   IF x% = 20 THEN KeyboardRef.T = ScanKey%(x%)
  664.   IF x% = 22 THEN KeyboardRef.U = ScanKey%(x%)
  665.   IF x% = 47 THEN KeyboardRef.V = ScanKey%(x%)
  666.   IF x% = 17 THEN KeyboardRef.W = ScanKey%(x%)
  667.   IF x% = 45 THEN KeyboardRef.X = ScanKey%(x%)
  668.   IF x% = 21 THEN KeyboardRef.Y = ScanKey%(x%)
  669.   IF x% = 44 THEN KeyboardRef.Z = ScanKey%(x%)
  670.   IF x% = 72 THEN KeyboardRef.Up = ScanKey%(x%)
  671.   IF x% = 75 THEN KeyboardRef.Left = ScanKey%(x%)
  672.   IF x% = 77 THEN KeyboardRef.Right = ScanKey%(x%)
  673.   IF x% = 80 THEN KeyboardRef.Down = ScanKey%(x%)
  674.   IF x% = 28 THEN KeyboardRef.ENTER = ScanKey%(x%)
  675.   IF x% = 57 THEN KeyboardRef.SPACE = ScanKey%(x%)
  676.   IF x% = 29 THEN KeyboardRef.CTRL = ScanKey%(x%)
  677.   IF x% = 56 THEN KeyboardRef.ALT = ScanKey%(x%)
  678.   IF x% = 42 THEN KeyboardRef.SHIFT = ScanKey%(x%)
  681.  
  682. FUNCTION ScanKey% (scancode%)
  683.  STATIC Ready%, keyflags%() 'retain values on procedure exit
  684.  IF NOT Ready% THEN REDIM keyflags%(0 TO 127): Ready% = -1 'create array on first use
  685.  i% = INP(&H60) 'read keyboard states
  686.  IF (i% AND 128) THEN keyflags%(i% XOR 128) = 0
  687.  IF (i% AND 128) = 0 THEN keyflags%(i%) = -1
  688.  K$ = INKEY$ 'clears key buffer to prevent beeps
  689.  ScanKey% = keyflags%(scancode%)
  690.  IF scancode% = 0 THEN Ready% = 0 'allows program to reset all values to 0 with a REDIM
  692.  
  693. SUB GDK_Mouse_GetState (MouseRef AS MouseState)
  695.  MouseRef.X = _MOUSEX
  696.  MouseRef.Y = _MOUSEY
  697.  MouseRef.LB = _MOUSEBUTTON(1)
  698.  MouseRef.RB = _MOUSEBUTTON(2)
  699.  MouseRef.MB = _MOUSEBUTTON(3)
  700.  MouseRef.MW = _MOUSEWHEEL
  702. '##########################################################################################################################
  703. '//Particle engine v.03
  704. '##########################################################################################################################
  705.  
  706. SUB GDK_Emitter_New (EmitRef AS Emitter, x%, y%, SpawnRate%, AngleMin!, AngleMax!, VelMin!, VelMax!, MinLifeTime#, MaxLifeTime#)
  707.  EmitRef.X = x%
  708.  EmitRef.Y = y%
  709.  EmitRef.SpawnRate = SpawnRate%
  710.  EmitRef.SpawnAngleMin = AngleMin!
  711.  EmitRef.SpawnAngleMax = AngleMax!
  712.  EmitRef.SpawnMaxVelocity = VelMax!
  713.  EmitRef.SpawnMinVelocity = VelMin!
  714.  EmitRef.MaxLifeTime = MaxLifeTime#
  715.  EmitRef.MinLifeTime = MinLifeTime#
  717.  
  718. SUB GDK_Emitter_SetGravity (EmitRef AS Emitter, Gravity!)
  719.  EmitRef.Gravity = Gravity!
  721.  
  722. SUB GDK_Emitter_SetAccelDecel (EmitRef AS Emitter, AccelMin!, AccelMax!, DecelMin!, DecelMax!)
  723.  EmitRef.AccelMin = AccelMin!
  724.  EmitRef.AccelMax = AccelMax!
  725.  EmitRef.DecelMIn = DecelMin!
  726.  EmitRef.DecelMax! = DecelMax!
  728.  
  729. SUB GDK_Particles_Spawn (EmitRef AS Emitter, PartRef() AS Particle, ParticleMax&, InitialColor&, ColorChange&, ChangeMode%)
  730.  PBTime# = TIMER(.001)
  731.  FOR i& = 0 TO ParticleMax&
  732.   IF NOT PartRef(i&).Exists THEN
  733.    PartRef(i&).Vector.X = EmitRef.X
  734.    PartRef(i&).Vector.Y = EmitRef.Y
  735.    PartRef(i&).Exists = -1
  736.    PartRef(i&).Vector.Rotation = (RND * EmitRef.SpawnAngleMax) + EmitRef.SpawnAngleMin
  737.    PartRef(i&).Vector.Speed = (RND * EmitRef.SpawnMaxVelocity) + EmitRef.SpawnMinVelocity
  738.    PartRef(i&).LifeTime = (RND * EmitRef.MaxLifeTime) + EmitRef.MinLifeTime
  739.    PartRef(i&).InitialCLR = InitialColor&
  740.    PartRef(i&).CurrentCLR = InitialColor&
  741.    PartRef(i&).ClrChange = ColorChange&
  742.    PartRef(i&).BirthTime = PBTime#
  743.    PartRef(i&).ClrChangeMode = ChangeMode%
  744.    IF EmitRef.AccelMax > 0 THEN
  745.     PartRef(i&).Accel = (RND * EmitRef.AccelMax) + EmitRef.AccelMin
  746.    END IF
  747.    IF EmitRef.DecelMax > 0 THEN
  748.     PartRef(i&).Decel = (RND * EmitRef.DecelMax) + EmitRef.DecelMIn
  749.    END IF
  750.    IF SuccessfulSpawns& = EmitRef.SpawnRate THEN EXIT FOR ELSE SuccessfulSpawns& = SuccessfulSpawns& + 1
  751.   END IF
  754.  
  755. SUB GDK_Particles_Update (PartRef() AS Particle, ParticleMax&)
  756.  FOR i& = 0 TO ParticleMax&
  757.   IF PartRef(i&).Exists THEN
  758.    IF TIMER(.001) - PartRef(i&).BirthTime >= PartRef(i&).LifeTime THEN
  759.     PartRef(i&).Exists = 0
  760.    ELSE
  761.     IF PartRef(i&).Vector.Speed > 0 THEN
  762.      IF PartRef(i&).Decel > 0 THEN
  763.       IF PartRef(i&).Accel > 0 THEN
  764.        PartRef(i&).Accel = PartRef(i&).Accel - PartRef(i&).Decel
  765.       ELSE
  766.        PartRef(i&).Vector.Speed = PartRef(i&).Vector.Speed - PartRef(i&).Decel
  767.       END IF
  768.      END IF
  769.      IF PartRef(i&).Accel > 0 THEN PartRef(i&).Vector.Speed = PartRef(i&).Vector.Speed + PartRef(i&).Accel
  770.      IF PartRef(i&).ClrChangeMode = 1 THEN
  771.       PartRef(i&).CurrentCLR = _RGB32(_RED(PartRef(i&).CurrentCLR) - _RED(PartRef(i&).ClrChange), _GREEN(PartRef(i&).CurrentCLR) - _GREEN(PartRef(i&).ClrChange), _BLUE(PartRef(i&).CurrentCLR) - _BLUE(PartRef(i&).ClrChange))
  772.      ELSE
  773.       PartRef(i&).CurrentCLR = _RGB32(_RED(PartRef(i&).CurrentCLR) + _RED(PartRef(i&).ClrChange), _GREEN(PartRef(i&).CurrentCLR) + _GREEN(PartRef(i&).ClrChange), _BLUE(PartRef(i&).CurrentCLR) + _BLUE(PartRef(i&).ClrChange))
  774.      END IF
  775.      GDK_Vector_Move PartRef(i&).Vector
  776.     ELSE
  777.      PartRef(i&).Exists = 0
  778.     END IF
  779.    END IF
  780.   END IF
  783.  
  784. SUB GDK_Particles_Draw (PartRef() AS Particle, ParticleMax&)
  785.  FOR i& = 0 TO ParticleMax&
  786.   IF PartRef(i&).Exists THEN
  787.    PSET (PartRef(i&).Vector.X, PartRef(i&).Vector.Y), PartRef(i&).CurrentCLR
  788.   END IF
  791.  
  792. '##########################################################################################################################
  793. '// MATH FUNCTIONS
  794. '##########################################################################################################################
  795.  
  796. FUNCTION GDK_Distance! (X%, Y%, XX%, YY%)
  797.  xd% = XX% - X%
  798.  yd% = YY% - Y%
  799.  GDK_Distance! = SQR((xd% * xd%) + (yd% * yd%))
  801.  
  802. FUNCTION GDK_RadianToDegree! (Radians!)
  803.  GDK_RadianToDegree! = Radians! * (180 / (4 * ATN(1)))
  805.  
  806. FUNCTION GDK_DegreeToRadian! (Degrees!)
  807.  GDK_DegreeToRadian! = Degrees! * ((4 * ATN(1)) / 180)
  809.  
  810. SUB GDK_MathX
  812.   FUNCTION atan2# (BYVAL y#, BYVAL x#)
  813.   FUNCTION acos# (BYVAL x#)
  814.   FUNCTION asin# (BYVAL x#)
  815.   FUNCTION cosh# (BYVAL x#)
  816.   FUNCTION sinh# (BYVAL x#)
  817.   FUNCTION tanh# (BYVAL x#)
  818.   FUNCTION pow# (BYVAL base#, BYVAL exponent#)
  821.  
  822. '##########################################################################################################################
  823. '// Tile engine
  824. '##########################################################################################################################
  825.  
  826. SUB GDK_TileSet_New (TileRef AS Tileset, File$, XTiles%, YTiles%, Alpha&)
  827.  GDK_Sprite_New TileRef.Sheet, File$, XTiles%, YTiles%, XTiles% * YTiles%, Alpha&
  828.  TileRef.TWidth = (TileRef.Sheet.Width / XTiles%)
  829.  TileRef.THeight = (TileRef.Sheet.Height / YTiles%)
  831.  
  832. SUB GDK_TileMap_Load (Level() AS Tile, XTiles%, YTiles%)
  833.  FOR j% = 0 TO YTiles% - 1
  834.   FOR i% = 0 TO XTiles% - 1
  835.    READ tile%
  836.    Level(i%, j%).Tile = tile%
  837.   NEXT
  840.  
  841. SUB GDK_TileMap_Draw (TileRef AS Tileset, Level() AS Tile, X%, Y%, XCnt%, YCnt%, XMax%, YMax%)
  842.  Tx% = X%
  843.  Ty% = Y%
  844.  sx% = _WIDTH(_DEST)
  845.  sy% = _HEIGHT(_DEST)
  846.  FOR j% = YCnt% TO YMax% - 1
  847.   FOR i% = XCnt% TO XMax% - 1
  848.    IF Tx% < sx% THEN
  849.     IF Level(i%, j%).Tile > 0 THEN
  850.      GDK_Sprite_DrawXY TileRef.Sheet, Tx%, Ty%, 0, Level(i%, j%).Tile
  851.     END IF
  852.     Tx% = Tx% + (TileRef.TWidth * TileRef.Sheet.Scale)
  853.    ELSE
  854.     EXIT FOR
  855.    END IF
  856.   NEXT
  857.   Tx% = X%
  858.   IF Ty% < sy% THEN Ty% = Ty% + (TileRef.THeight * TileRef.Sheet.Scale) ELSE EXIT FOR
  861.  
  862.  
  863. SUB GDK_TileMap_Load_FromFile (GameFile$, Level() AS Tile, YTiles%)
  864.  X& = FREEFILE
  865.  OPEN GameFile$ FOR INPUT AS #X&
  866.  FOR i% = 0 TO YTiles% - 1
  867.   LINE INPUT #X&, DataLine$
  868.   Cnt% = 0
  869.   FOR j% = 0 TO LEN(DataLine$)
  870.    IF INSTR(j%, DataLine$, ",") > 0 THEN
  871.     Level(Cnt%, i%).Tile = VAL(MID$(DataLine$, j%, INSTR(j%, DataLine$, ",") - j%))
  872.     j% = INSTR(j%, DataLine$, ",")
  873.     Cnt% = Cnt% + 1
  874.    ELSE
  875.     Level(Cnt%, i%).Tile = VAL(MID$(DataLine$, j%))
  876.    END IF
  877.   NEXT
  879.  CLOSE #X&
  881.  
  882. SUB GDK_Tileset_SetScale (TileRef AS Tileset, Scale!)
  883.  TileRef.Sheet.Scale = Scale!
  885.  
  886. 'SUB GDK_Tiles_Draw_ISO (TileRef AS Tileset, XYRef() AS XY, Level() AS Tile, X%, Y%, XCnt%, YCnt%, XMax%, YMax%)
  887. '  Tx% = X%
  888. '  Ty% = Y%
  889. '  YCntr% = 0
  890. '  FOR j% = YCnt% TO YMax% - 1
  891. '    FOR i% = XCnt% TO XMax% - 1
  892. '            IF Level(i%, j%).Tile > 0 THEN GDK_Tile_Draw TileRef, Level(i%, j%).Tile, XYRef(), Tx%, Ty%
  893. '            Tx% = Tx% + (TileRef.TWidth / 2)
  894. '            Ty% = Ty% + (TileRef.THeight / 4)
  895. '        NEXT
  896. '        YCntr% = YCntr% + 1
  897. '        Ty% = Y% + YCntr% * (TileRef.THeight / 4)
  898. '        Tx% = X% - (YCntr% * (TileRef.TWidth / 2))
  899. '    NEXT
  900. 'END SUB
  901.  
  902.  
  903. '##########################################################################################################################
  904. '// GameObject Subs and Functions - SUper fast prototyping commands for games
  905. '##########################################################################################################################
  906.  
  907. SUB GDK_GameObject_New (Handle AS GameObject, File$, XframeCount%, YFrameCount%, X%, Y%, Speed!, Rotation!)
  908.  GDK_Sprite_New Handle.Sprite, File$, XframeCount%, YFrameCount%, XframeCount% * YFrameCount%, 1
  909.  GDK_Vector_New Handle.Vector, X%, Y%, Speed!, Rotation!
  910.  GDK_Sprite_SetVisibility Handle.Sprite, -1
  911.  GDK_Sprite_SetAlpha Handle.Sprite, _RGB(255, 0, 255)
  913.  
  914. SUB GDK_GameObject_Draw (GameObject AS GameObject, AnimationFrame%)
  915.  GDK_Sprite_Draw GameObject.Sprite, GameObject.Vector, AnimationFrame%
  917.  
  918. SUB GDK_GameObject_Update (Handle AS GameObject)
  919.  GDK_Vector_Update Handle.Vector
  920.  GDK_Rectangle_Autosize Handle.Sprite, Handle.Vector, Handle.Rect
  922.  
  923. SUB GDK_GameObject_Rotate (Handle AS GameObject, Rot!)
  924.  Handle.Vector.Rotation = Handle.Vector.Rotation + Rot!
  926.  
  927. SUB GDK_GameObject_Hide (Handle AS GameObject)
  928.  Handle.Sprite.IsVisible = 0
  930.  
  931. SUB GDK_GameObject_Show (Handle AS GameObject)
  932.  Handle.Sprite.IsVisible = -1
  934.  
  935. FUNCTION GDK_GameObject_Intersect (Handle AS GameObject, Handle2 AS GameObject)
  936.  IF GDK_Rectangle_Intersect(Handle.Rect, Handle2.Rect) THEN
  937.   GDK_GameObject_Intersect = -1
  939.   GDK_GameObject_Intersect = 0
  942.  
  943. '##########################################################################################################################
  944. '// Animation routines - Taken from GDK_GL
  945. '##########################################################################################################################
  946.  
  947. SUB GDK_ANIMATION_NEW (Anim AS ANIMATION, Frame%, StartFrame%, ResetFrame%, AnimTime#, AnimTimer#)
  948.  Anim.Frame = Frame%
  949.  Anim.StartFrame = StartFrame%
  950.  Anim.ResetFrame = ResetFrame%
  951.  Anim.Time = AnimTime#
  952.  Anim.Timer = AnimTimer#
  953.  IF ResetFrame% < StartFrame% THEN Anim.Dir = -1 ELSE Anim.Dir = 0
  955.  
  956. SUB GDK_ANIMATION_UPDATE (Anim AS ANIMATION)
  957.  IF Anim.Dir = -1 THEN
  958.   IF Anim.Frame > Anim.StartFrame OR Anim.Frame < Anim.ResetFrame THEN
  959.    Anim.Frame = Anim.StartFrame
  960.    Anim.Timer = TIMER(.001)
  961.   ELSE
  962.    IF TIMER(.001) - Anim.Timer >= Anim.Time THEN
  963.     IF Anim.Frame = Anim.ResetFrame THEN
  964.      Anim.Frame = Anim.StartFrame
  965.     ELSE
  966.      Anim.Frame = Anim.Frame - 1
  967.     END IF
  968.     Anim.Timer = TIMER(.001)
  969.    END IF
  970.   END IF
  972.   IF Anim.Frame < Anim.StartFrame OR Anim.Frame > Anim.ResetFrame THEN
  973.    Anim.Frame = Anim.StartFrame
  974.    Anim.Timer = TIMER(.001)
  975.   ELSE
  976.    IF TIMER(.001) - Anim.Timer >= Anim.Time THEN
  977.     IF Anim.Frame = Anim.ResetFrame THEN
  978.      Anim.Frame = Anim.StartFrame
  979.     ELSE
  980.      Anim.Frame = Anim.Frame + 1
  981.     END IF
  982.     Anim.Timer = TIMER(.001)
  983.    END IF
  984.   END IF
  987.  
  988. '##########################################################################################################################
  989. '// Image ROTATION/ZOOM FUNCTION BY GALLEON
  990. '##########################################################################################################################
  991.  
  992. SUB Rotate_Scale_AroundPoint (X AS LONG, Y AS LONG, Image AS LONG, Rotation AS SINGLE, ScaleX AS SINGLE, ScaleY AS SINGLE, PointX AS LONG, PointY AS LONG)
  993.  DEFSNG A-Z
  994.  DIM pX(3) AS SINGLE: DIM pY(3) AS SINGLE
  995.  DIM W AS LONG, H AS LONG, I AS LONG, X2 AS LONG, Y2 AS LONG
  996.  W = _WIDTH(Image): H = _HEIGHT(Image)
  997.  pX(0) = -PointX: pY(0) = -PointY: pX(1) = -PointX: pY(1) = -PointY + H - 1: pX(2) = -PointX + W - 1: pY(2) = -PointY + H - 1: pX(3) = -PointX + W - 1: pY(3) = -PointY 'Set dest screen points
  998.  Radians = -Rotation / 57.29578: SINr = SIN(Radians): COSr = COS(Radians) 'Precalculate SIN & COS of angle
  999.  FOR I = 0 TO 3
  1000.   pX(I) = pX(I) * ScaleX: pY(I) = pY(I) * ScaleY 'Scale
  1001.   X2 = pX(I) * COSr + SINr * pY(I): pY(I) = pY(I) * COSr - pX(I) * SINr: pX(I) = X2 'Rotate Dest Points
  1002.   pX(I) = pX(I) + X: pY(I) = pY(I) + Y 'Translate Dest Points
  1004.  _MAPTRIANGLE (0, 0)-(0, H - 1)-(W - 1, H - 1), Image TO(pX(0), pY(0))-(pX(1), pY(1))-(pX(2), pY(2))
  1005.  _MAPTRIANGLE (0, 0)-(W - 1, 0)-(W - 1, H - 1), Image TO(pX(0), pY(0))-(pX(3), pY(3))-(pX(2), pY(2))
  1007.  
  1008. '##########################################################################################################################
  1009. '// Path based movement v.02
  1010. '##########################################################################################################################
  1011.  
  1012. SUB GDK_Path_New (Path AS Path, PathPoint() AS PathPoint, NumPoints%, Reverse%, Repeat%, Relative%)
  1013.  IF Relative% THEN READ Path.Vector.X, Path.Vector.Y, Path.Vector.Speed
  1014.  FOR i% = 0 TO NumPoints% - 1
  1015.   READ PathPoint(i%).X, PathPoint(i%).Y, PathPoint(i%).Speed
  1017.  IF Relative% THEN
  1018.   Path.TargetVector.X = Path.Vector.X + PathPoint(0).X
  1019.   Path.TargetVector.Y = Path.Vector.Y + PathPoint(0).Y
  1020.   Path.Vector.Rotation = -atan2(Path.Vector.Y - Path.TargetVector.Y, Path.Vector.X - Path.TargetVector.X) + (2 * ATN(1))
  1022.   Path.Vector.X = PathPoint(0).X
  1023.   Path.Vector.Y = PathPoint(0).Y
  1024.   Path.Vector.Speed = PathPoint(0).Speed
  1025.   Path.Vector.Rotation = -atan2(PathPoint(0).Y - PathPoint(1).Y, PathPoint(0).X - PathPoint(1).X) + (2 * ATN(1))
  1026.   Path.TargetVector.X = PathPoint(1).X
  1027.   Path.TargetVector.Y = PathPoint(1).Y
  1029.  Path.LastVector = Path.Vector
  1030.  Path.NumPoints = NumPoints%
  1031.  Path.Reverse = Reverse%
  1032.  Path.Repeat = Repeat%
  1033.  Path.Relative = Relative%
  1035.  
  1036.  
  1037. SUB GDK_Path_Update (Path AS Path, PathPoint() AS PathPoint)
  1038.  IF Path.Relative THEN '// Relative movement
  1039.   IF NOT Path.HitTargetX THEN IF IsWithinRange(Path.TargetVector.X, Path.LastVector.X, Path.Vector.X) THEN Path.HitTargetX = -1
  1040.   IF NOT Path.HitTargetY THEN IF IsWithinRange(Path.TargetVector.Y, Path.LastVector.Y, Path.Vector.Y) THEN Path.HitTargetY = -1
  1041.   IF Path.HitTargetX AND Path.HitTargetY THEN
  1042.    IF Path.CurrentPoint < Path.NumPoints - 1 THEN
  1043.     Path.TargetVector.X = Path.Vector.X + PathPoint(Path.CurrentPoint + 1).X
  1044.     Path.TargetVector.Y = Path.Vector.Y + PathPoint(Path.CurrentPoint + 1).Y
  1045.     Path.Vector.Rotation = -atan2(Path.Vector.Y - Path.TargetVector.Y, Path.Vector.X - Path.TargetVector.X) + (2 * ATN(1))
  1046.     Path.Vector.Speed = PathPoint(Path.CurrentPoint).Speed
  1047.     Path.CurrentPoint = Path.CurrentPoint + 1
  1048.    ELSE '// Last point
  1049.     IF Path.Repeat THEN
  1050.      Path.CurrentPoint = 0
  1051.      Path.TargetVector.X = Path.Vector.X + PathPoint(0).X
  1052.      Path.TargetVector.Y = Path.Vector.Y + PathPoint(0).Y
  1053.      Path.Vector.Rotation = -atan2(Path.Vector.Y - Path.TargetVector.Y, Path.Vector.X - Path.TargetVector.X) + (2 * ATN(1))
  1054.      Path.Vector.Speed = PathPoint(0).Speed
  1055.     ELSE
  1056.      Path.Vector.Speed = 0
  1057.     END IF
  1058.    END IF
  1059.    Path.HitTargetX = 0
  1060.    Path.HitTargetY = 0
  1061.   END IF
  1062.  ELSE '// Co-ordinate based movement
  1063.   IF Path.IsReversing THEN
  1064.    IF Path.CurrentPoint > 0 THEN
  1065.     IF NOT Path.HitTargetX THEN IF IsWithinRange(PathPoint(Path.CurrentPoint - 1).X, Path.LastVector.X, Path.Vector.X) THEN Path.HitTargetX = -1
  1066.     IF NOT Path.HitTargetY THEN IF IsWithinRange(PathPoint(Path.CurrentPoint - 1).Y, Path.LastVector.Y, Path.Vector.Y) THEN Path.HitTargetY = -1
  1067.     IF Path.HitTargetX AND Path.HitTargetY THEN
  1068.      IF Path.CurrentPoint > 1 THEN
  1069.       Path.CurrentPoint = Path.CurrentPoint - 1
  1070.       Path.Vector.Rotation = -atan2(Path.Vector.Y - PathPoint(Path.CurrentPoint - 1).Y, Path.Vector.X - PathPoint(Path.CurrentPoint - 1).X) + (2 * ATN(1))
  1071.      ELSE '// First point
  1072.       Path.CurrentPoint = 0
  1073.       IF Path.Reverse THEN
  1074.        Path.IsReversing = 0
  1075.        Path.Vector.Rotation = -atan2(Path.Vector.Y - PathPoint(Path.CurrentPoint + 1).Y, Path.Vector.X - PathPoint(Path.CurrentPoint + 1).X) + (2 * ATN(1))
  1076.       END IF
  1077.      END IF
  1078.      Path.HitTargetX = 0
  1079.      Path.HitTargetY = 0
  1080.      Path.Vector.Speed = PathPoint(Path.CurrentPoint).Speed
  1081.     END IF
  1082.    END IF
  1083.   ELSE
  1084.    IF Path.CurrentPoint <= Path.NumPoints - 1 THEN
  1085.     IF NOT Path.HitTargetX THEN IF IsWithinRange(PathPoint(Path.CurrentPoint + 1).X, Path.LastVector.X, Path.Vector.X) THEN Path.HitTargetX = -1
  1086.     IF NOT Path.HitTargetY THEN IF IsWithinRange(PathPoint(Path.CurrentPoint + 1).Y, Path.LastVector.Y, Path.Vector.Y) THEN Path.HitTargetY = -1
  1087.     IF Path.HitTargetX AND Path.HitTargetY THEN
  1088.      IF Path.CurrentPoint < Path.NumPoints - 2 THEN
  1089.       Path.CurrentPoint = Path.CurrentPoint + 1
  1090.       Path.Vector.Rotation = -atan2(Path.Vector.Y - PathPoint(Path.CurrentPoint + 1).Y, Path.Vector.X - PathPoint(Path.CurrentPoint + 1).X) + (2 * ATN(1))
  1091.      ELSE '// Last point
  1092.       Path.CurrentPoint = Path.NumPoints - 1
  1093.       IF Path.Reverse THEN
  1094.        Path.IsReversing = -1
  1095.        Path.Vector.Rotation = -atan2(Path.Vector.Y - PathPoint(Path.CurrentPoint - 1).Y, Path.Vector.X - PathPoint(Path.CurrentPoint - 1).X) + (2 * ATN(1))
  1096.       ELSEIF Path.Repeat THEN
  1097.        Path.CurrentPoint = 0
  1098.        IF Path.Repeat THEN
  1099.         FOR i% = 1 TO Path.NumPoints - 1
  1100.          XDif% = PathPoint(i%).X - PathPoint(i% - 1).X
  1101.          YDif% = PathPoint(i%).Y - PathPoint(i% - 1).Y
  1102.          IF i% = 1 THEN
  1103.           PathPoint(0).X = Path.Vector.X
  1104.           PathPoint(0).Y = Path.Vector.Y
  1105.          END IF
  1106.          PathPoint(i%).X = PathPoint(i% - 1).X + XDif%
  1107.          PathPoint(i%).Y = PathPoint(i% - 1).Y + YDif%
  1108.         NEXT
  1109.        END IF
  1110.        Path.Vector.Rotation = -atan2(Path.Vector.Y - PathPoint(Path.CurrentPoint + 1).Y, Path.Vector.X - PathPoint(Path.CurrentPoint + 1).X) + (2 * ATN(1))
  1111.       ELSE '// Stop at end
  1112.        PathPoint(Path.CurrentPoint).Speed = 0
  1113.       END IF
  1114.      END IF
  1115.      Path.Vector.Speed = PathPoint(Path.CurrentPoint).Speed
  1116.      Path.HitTargetX = 0
  1117.      Path.HitTargetY = 0
  1118.     END IF
  1119.    END IF
  1120.   END IF
  1122.  Path.LastVector = Path.Vector
  1123.  GDK_Vector_Update Path.Vector
  1125.  
  1126. '// GDK_Path_Update helper function
  1127. FUNCTION IsWithinRange% (Target%, MinRange%, MaxRange%)
  1128.  IF Target% >= MinRange% AND Target% <= MaxRange% THEN
  1129.   IsWithinRange% = -1
  1130.  ELSEIF Target% <= MinRange% AND Target% >= MaxRange% THEN
  1131.   IsWithinRange% = -1
  1133.   IsWithinRange% = 0
  1136.  
  1137.  
  1138. '##########################################################################################################################
  1139. '// END OF LIBRARY!!!
  1140. '##########################################################################################################################
  1141.  

Unseen
Logged

Offline MasterGy

  • Seasoned Forum Regular
  • Posts: 327
  • people lie, math never lies
    • View Profile
Re: rerotating math problem
« Reply #5 on: June 28, 2020, 04:31:16 pm »
Hi !
I managed to solve the rotation. Thanks for all the help! What helped was a paper by a UNSEEN colleague. Well, that's very no nothing! There are valuable treasures in it that are needed for all this!
The problem there was that it didn’t matter in what order we rotated the shafts and back.
I finally understood, so far I’ve just slipped over it, I didn’t understand the sin-cos rotation, I just used it. I understand pretty much now.
I got to the point where wherever the rectangle can be rotated, it senses properly.
And I redesigned the maze generator to see how many towers as many secondary mazes. Several secondary mazes in one big. each area has a tower from which you can go to another tower.
Key and gate are missing. if you will, you can go it linearly, so in one way. Different areas can be made with different visual characteristics.
If you try it out, have “output EXE to source folder” enabled in your qb64 editor.
In the track_creator folder, the program generates a track. you can decide if it is good or not. if you like, the M button, é went down during the 3d display.
In the game folder, the program is much smaller and only deals with display. If you have saved tracks, everything here will load quickly and start.
It would be really good magazines, ideas, low-polik, companion to a good little duke-nukem clone.



  [ You are not allowed to view this attachment ]  

download:
https://drive.google.com/file/d/1fZXnaLL2FPjQ-GatvRwRw46_9rfusNHk/view?usp=sharing
« Last Edit: June 28, 2020, 04:37:38 pm by MasterGy »
Logged
Pages: [1]   Go Up
« previous next »