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

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

Offline BlitzBot

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

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


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


Comments : none...

 

SimplePortal 2.3.6 © 2008-2014, SimplePortal