November 25, 2020, 06:10:13 AM

Author Topic: [bb] Verlet Physics (incomplete) by Nate the Great [ 1+ years ago ]  (Read 617 times)

Offline BlitzBot

  • Jr. Member
  • **
  • Posts: 1
Title : Verlet Physics (incomplete)
Author : Nate the Great
Posted : 1+ years ago

Description : This is a very helpful physics engine which I have spent a few weeks on.  I plan to use it to add little physics effects to my games so I don't have to use a hugely complex physics system.  I also like to have an idea of how every aspect of my game works.

I will give a lot of credit to stevie g and pongo for advising me on how to do certain things while making it.  :)
The demonstraintion below uses the arrow keys to simulate an air hockey table.

P.S.  It has many bugs but I will leave those for you to sort out if you really need it in a game :)   also you don't have to give me credit but mentioning my name in the credits or emailing me if you use it in a game would be nice.


Code :
Code: BlitzBasic
  1. Graphics3D 640,480,0,2
  2. SeedRnd(MilliSecs())
  3.  
  4.  
  5.  
  6.  
  7. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  8. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  9. ;;;;;;Temporary camera stuff;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  10. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  11. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  12.  
  13. piv = CreatePivot()
  14. cam = CreateCamera(piv)
  15. ;CameraRange cam,.01,50
  16. CameraZoom cam,2
  17. MoveEntity cam,0,3,-30
  18. lit = CreateLight()
  19. TurnEntity lit,90,0,0
  20.  
  21. TurnEntity piv,20,0,0
  22.  
  23. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  24. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  25. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  26. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  27.  
  28.  
  29.  
  30.  
  31. Global VerletType = 1                                   ;Collision Types
  32. Global RBodyType = 2
  33. Global RigidBodyNum = 0
  34. Global groundtype = 3
  35.  
  36. ;Collisions VerletType,RBodyType,2,2    ;Sets Collision Types
  37. ;Collisions VerletType,VerletType,1,2
  38. Collisions verletType,GroundType,2,2
  39.  
  40. Type Verlet                                                             ;Verlet type Contains:
  41.         Field Active                                            ;Determines if the verlet is an active verlet or a verlet used for orientation
  42.         Field Mass#                                                     ;Gives the verlet a mass
  43.         Field x#,y#,z#                                          ;Gives the verlet an x,y,z cooridnate
  44.         Field vx#,vy#,vz#                                       ;Gives the verlet a velocity in 3d
  45.         Field ox#,oy#,oz#                                       ;Stores the old x,y,z coordinates to figure out the velocity of the verlet
  46.         Field piv,ent                                           ;Gives the verlet a pivot point and names the verlet's entity
  47.         Field Col,ID,piv2,radius#                       ;Col tells if the verlet has collided yet and ID tells what entity and verlet group the verlet belongs to
  48. End Type       
  49.  
  50. Type Constraint                                                 ;Constraints constrain the verlets to certain distances from eachother
  51.         Field v1.verlet                                         ;First verlet in constraint
  52.         Field v2.verlet                                         ;Second verlet in constraint
  53.         Field length#                                           ;Length of the constraint
  54. End Type
  55.  
  56. Type Rigidbody                                                                          ;Rigidbody is used as a reference for all of the verlets that belong to a mesh
  57.         Field Ent                                                                               ;Ent is the entity that is acting as the rigid body
  58.         Field ID                                                                                ;ID is the ID that all of the verlets in this mesh are attatched to
  59.         Field x#,y#,z#                                                                  ;X,Y,Z coordinates of the mesh
  60.         Field Yaw#,pitch#,Roll#                                                 ;Yaw,Pitch,Roll coordinates of the mesh
  61.         Field lf.verlet,lb.verlet,rf.verlet,rb.verlet   ;The verlets that are inactive and are used to orient the mesh
  62.         Field lfd.verlet,lbd.verlet,rfd.verlet,rbd.verlet;The verlets that are inactive and are used to orient the mesh
  63.         Field c.verlet,idl                                                              ;The central Verlet
  64.         Field Verl.verlet[50],verlnum
  65. End Type
  66.  
  67.  
  68.  
  69.  
  70.  
  71. SetBuffer BackBuffer()
  72.  
  73. ground = CreatePlane()
  74. EntityColor ground,32,32,64
  75. EntityAlpha ground,.9
  76. EntityType ground,GroundType
  77.  
  78.  
  79.  
  80. rwall = CreateCube()
  81. ScaleEntity rwall,.1,.8,10
  82. MoveEntity rwall,5,.1,0
  83.  
  84. EntityType rwall,GroundType
  85.  
  86. lwall = CreateCube()
  87. ScaleEntity lwall,.1,.8,10
  88. MoveEntity lwall,-5,.1,0
  89.  
  90. EntityType lwall,GroundType
  91.  
  92. bwall = CreateCube()
  93. ScaleEntity bwall,5,.8,.1
  94. MoveEntity bwall,0,.1,-10
  95.  
  96. EntityType bwall,GroundType
  97.  
  98. fwall = CreateCube()
  99. ScaleEntity fwall,5,.8,.1
  100. MoveEntity fwall,0,.1,10
  101.  
  102. EntityType fwall,GroundType
  103.  
  104.  
  105. obstacle = CreateCylinder(10)
  106. MoveEntity obstacle,0,0,5
  107.  
  108. EntityType obstacle,GroundType
  109.  
  110.  
  111. puck = CreateCylinder(8)
  112. MoveEntity puck,0,.8,0
  113. ScaleEntity puck,.3,.1,.3
  114.  
  115. applyphysics(puck,10,False,.2)
  116.  
  117.  
  118.  
  119. pl1 = CreateCylinder(10)
  120. MoveEntity pl1,0,.8,-4
  121. ScaleEntity pl1,.5,.2,.5
  122. EntityColor pl1,255,0,0
  123.  
  124. applyphysics(pl1,10,False,.2)
  125.  
  126. CreateMirror()
  127.  
  128.  
  129.  
  130.  
  131.  
  132. timer = MilliSecs()
  133.  
  134. cnter = 0
  135. While Not KeyDown(1)
  136. Cls
  137.  
  138.  
  139. If KeyDown(205) Then PApplyForce(pl1,.015,0,0)
  140. If KeyDown(203) Then PApplyForce(pl1,-.015,0,0)
  141. If KeyDown(200) Then PApplyForce(pl1,0,0,.015)
  142. If KeyDown(208) Then PApplyForce(pl1,0,0,-.015)
  143.  
  144.  
  145.  
  146. UpdateVerlets()
  147.  
  148. UpdateConstraints()
  149.  
  150. DrawVerlets()
  151.  
  152. UpdateWorld()
  153. detectcollisions()
  154.  
  155. drawverlets()
  156.  
  157. positionPhysicsEntity()
  158.  
  159. RenderWorld()
  160.  
  161. cnt = 0
  162. For v.verlet = Each verlet
  163.         cnt = cnt + 1
  164. Next
  165.  
  166. Text 1,1,cnt
  167.  
  168. cnter = cnter + 1
  169. Text 1,20,"FPS: "+1000/((MilliSecs()-timer)/cnter)
  170.  
  171. Flip
  172. Wend
  173. End
  174.  
  175.  
  176.  
  177.  
  178. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  179. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  180. ;;;;;;Creates a verlet bounding box & creates verlets;;;;;
  181. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  182. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  183.  
  184.  
  185. Function ApplyPhysics(ent,mass#,stationary,verlsize# = .3)
  186.  
  187. rigidbodynum = rigidbodynum + 1
  188.  
  189.  
  190. ;Creates the Rigidbody that all of the verlets are linked to
  191.  
  192. r.rigidbody = New rigidbody
  193. rid = rigidbodynum
  194. rent = ent
  195. rx# = EntityX(rent)
  196. ry# = EntityY(rent)
  197. rz# = EntityZ(rent)
  198. ryaw# = EntityYaw(rent)
  199. rpitch# = EntityPitch(rent)
  200. r
  201. oll# = EntityRoll(rent)
  202. EntityType rent,RBodyType
  203. ridl = stationary
  204.  
  205. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212. ;Loops through all surfaces and verticies
  213. For k = 1 To CountSurfaces(ent)
  214.         surf = GetSurface(ent,k)
  215.         For index = 0 To CountVertices(surf)-1
  216.                 TFormPoint VertexX(surf,index), VertexY(surf, index),VertexZ(surf, index), ent, 0
  217.                 CreateVerlet(TFormedX(),TFormedY(),TFormedZ(),mass#,ent,rID,True,verlsize#)   ;Creates a verlet for every vertice  Later it deletes duplicate verlets for the sake of stability.
  218.         Next
  219. Next
  220.  
  221. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  222.  
  223.  
  224. ;Creates the bounding box verlets that don't react with anything but are used to orient the mesh
  225.  
  226. rlf.verlet = CreateVerlet(rx# - .5 , ry# - .5, rz# + .5, 1 , ent , rID , False)
  227.  
  228. rlb.verlet = CreateVerlet(rx# - .5 , ry# - .5, rz# - .5, 1 , ent , rID , False)
  229.  
  230. r
  231. f.verlet = CreateVerlet(rx# + .5 , ry# - .5, rz# + .5, 1 , ent , rID , False)
  232.  
  233. r
  234. b.verlet = CreateVerlet(rx# + .5 , ry# - .5, rz# - .5, 1 , ent , rID , False)
  235.  
  236. rlfd.verlet = CreateVerlet(rx# - .5 , ry# + .5, rz# + .5, 1 , ent , rID , False)
  237.  
  238. rlbd.verlet = CreateVerlet(rx# - .5 , ry# + .5, rz# - .5, 1 , ent , rID , False)
  239.  
  240. r
  241. fd.verlet = CreateVerlet(rx# + .5 , ry# + .5, rz# + .5, 1 , ent , rID , False)
  242.  
  243. r
  244. bd.verlet = CreateVerlet(rx# + .5 , ry# + .5, rz# - .5, 1 , ent , rID , False)
  245.  
  246. rc.verlet = CreateVerlet(rx# , ry# , rz#, 1 , ent , rID , False)
  247.  
  248.  
  249. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  250.  
  251.  
  252.  
  253. ;Deletes Duplicate verlets so that the meshes are more stable
  254.  
  255. For v.verlet = Each verlet
  256.         For vv.verlet = Each verlet
  257.                 If vvID = vID Then
  258.                         If vvpiv <> vpiv Then
  259.                                 If vx# = vvx# And vy# = vvy# And vz# = vvz# And vvmass <> 0 And vmass <> 0 Then
  260.                                         FreeEntity vvpiv
  261.                                         Delete vv.verlet
  262.                                 EndIf
  263.                         EndIf
  264.                 EndIf
  265.         Next
  266. Next
  267.  
  268. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  269.  
  270.  
  271.  
  272.  
  273. cnt = 0
  274. For v.verlet = Each verlet
  275.         If Vent = ent And VActive = True Then
  276.                 RVerl.verlet[cnt] = v.verlet
  277.                 cnt = cnt + 1
  278.         EndIf
  279. Next
  280.  
  281. rVerlnum = cnt - 1
  282.  
  283.  
  284. ;This code makes constraints which it links every inside verlet to all eight of the outside verlets but no others
  285.  
  286. For v.verlet = Each verlet
  287.         If vID = rigidbodynum Then
  288.                 If ridl = False Then
  289.                         If vactive = True Then
  290.                                 Createconstraint(v.verlet,r
  291. f.verlet)              ;Creates constraint
  292.                                 Createconstraint(v.verlet,r
  293. b.verlet)
  294.                                 Createconstraint(v.verlet,rlf.verlet)
  295.                                 Createconstraint(v.verlet,rlb.verlet)
  296.                                 Createconstraint(v.verlet,r
  297. fd.verlet)              ;Creates constraint
  298.                                 Createconstraint(v.verlet,r
  299. bd.verlet)
  300.                                 Createconstraint(v.verlet,rlfd.verlet)
  301.                                 Createconstraint(v.verlet,rlbd.verlet)
  302.                                 Createconstraint(v.verlet,rc.verlet)
  303.                                
  304.                         EndIf
  305.                 EndIf
  306.         EndIf
  307. Next
  308. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  309.  
  310.  
  311.  
  312.  
  313. createconstraint(r
  314. f.verlet,rc.verlet)
  315. createconstraint(r
  316. b.verlet,rc.verlet)
  317. createconstraint(rlf.verlet,rc.verlet)
  318. createconstraint(rlb.verlet,rc.verlet)
  319. createconstraint(r
  320. fd.verlet,rc.verlet)
  321. createconstraint(r
  322. bd.verlet,rc.verlet)
  323. createconstraint(rlfd.verlet,rc.verlet)
  324. createconstraint(rlbd.verlet,rc.verlet)
  325.  
  326. createconstraint(r
  327. f.verlet,r
  328. b.verlet)
  329. createconstraint(r
  330. f.verlet,rlf.verlet)
  331. createconstraint(r
  332. f.verlet,rlb.verlet)
  333.  
  334. createconstraint(r
  335. b.verlet,rlb.verlet)
  336. createconstraint(r
  337. b.verlet,rlf.verlet)
  338.  
  339. createconstraint(rlf.verlet,rlb.verlet)
  340.  
  341.  
  342. createconstraint(r
  343. fd.verlet,r
  344. bd.verlet)
  345. createconstraint(r
  346. fd.verlet,rlfd.verlet)
  347. createconstraint(r
  348. fd.verlet,rlbd.verlet)
  349.  
  350. createconstraint(r
  351. bd.verlet,rlbd.verlet)
  352. createconstraint(r
  353. bd.verlet,rlfd.verlet)
  354.  
  355. createconstraint(rlfd.verlet,rlbd.verlet)
  356.  
  357.  
  358. createconstraint(r
  359. f.verlet,r
  360. fd.verlet)
  361. createconstraint(rlf.verlet,rlfd.verlet)
  362. createconstraint(r
  363. b.verlet,r
  364. bd.verlet)
  365. createconstraint(rlb.verlet,rlbd.verlet)
  366.  
  367. ;Deletes duplicate Or reversed constraints  This speeds up the constraint loops very much
  368.  
  369. For c.constraint = Each constraint
  370.         For cc.constraint = Each constraint
  371.                 If cv1piv = ccv1piv And cv2piv = cv1piv Then
  372.                         Delete cc.constraint
  373.                 EndIf
  374.         Next
  375. Next
  376.  
  377.  
  378. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  379.  
  380.  
  381.  
  382.  
  383.  
  384. End Function
  385.  
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  400. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  401. ;;;;;;Creates a verlet at the given x,y,z coordinate;;;;;;
  402. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  403. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  404.  
  405.  
  406. Function createverlet.verlet(x#,y#,z#,mass#,ent,ID,Active,radius# = .1)
  407.  
  408.         v.Verlet = New Verlet
  409.         vx# = x#
  410.         vy# = y#
  411.         vz# = z#
  412.         vox# = vx#
  413.         voy# = vy#
  414.         voz# = vz#
  415.         vvx# = 0
  416.         vvy# = 0
  417.         vvz# = 0
  418.         vent = ent
  419.         vID = ID
  420.         vactive = Active
  421.         vmass# = mass#
  422.         v
  423. adius# = radius#
  424.        
  425.         vpiv = CreatePivot()
  426.         vpiv2 = CreatePivot()
  427.         ScaleEntity vpiv,.2,.2,.2
  428.         PositionEntity vpiv,vx#,vy#,vz#
  429.        
  430.         If active = True Then
  431.                 EntityType vpiv,VerletType
  432.                 EntityRadius vpiv,radius#
  433.         EndIf
  434.        
  435.         Return v
  436. End Function
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  455. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  456. ;;;;;;Constrains two verlets together;;;;;;;;;;;;;;;;;;;;;
  457. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  458. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  459.  
  460.  
  461. Function CreateConstraint(v1.verlet,v2.verlet)
  462.  
  463.         c.constraint = New constraint
  464.         cv1.verlet = v1.verlet
  465.         cv2.verlet = v2.verlet
  466.         clength# = Sqr((cv1x#-cv2x#)^2 + (cv1y#-cv2y#)^2 + (cv1z#-cv2z#)^2)
  467.  
  468. End Function
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480.  
  481.  
  482.  
  483.  
  484.  
  485.  
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492.  
  493. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  494. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  495. ;;;;;;goes through every verlet and updates it;;;;;;;;;;;;
  496. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  497. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  498.  
  499. Function Updateverlets()
  500.  
  501. For v.verlet = Each verlet
  502.        
  503.         If vcol = True Then
  504.                 vcol = False
  505.                 fric# = .95
  506.         Else
  507.                 fric# = 1
  508.         EndIf
  509.        
  510.         vvx# = (vx# - vox#)*fric#
  511.         vvy# = (vy# - voy#)*fric#
  512.         vvz# = (vz# - voz#)*fric#
  513.        
  514.         vox# = vx#
  515.         voy# = vy#
  516.         voz# = vz#
  517.        
  518.         vx# = vx# + vvx#
  519.         vy# = vy# + vvy# - .004
  520.         vz# = vz# + vvz#
  521.        
  522.        
  523.         For vv.verlet = Each verlet
  524.                         If v <> vv And vid <> vvid; if not the same verlet or group
  525.                                 dx# = vx# - vvx#
  526.                                 dy# = vy# - vvy#
  527.                                 dz# = vz# - vvz#
  528.                                 dist# = Sqr ( dx#*dx# + dy#*dy# + dz#*dz# )            
  529.                                 totalr# = v
  530. adius# + vv
  531. adius#
  532.                                 If dist# < totalr# Then
  533.                                
  534.                                        
  535.                                         Diffx# = ( dist# - totalr# ) * ( dx# / dist# )
  536.                                         Diffy# = ( dist# - totalr# ) * ( dy# / dist# )
  537.                                         Diffz# = ( dist# - totalr# ) * ( dz# / dist# )
  538.  
  539.                                         vx# = vx# - Diffx# ;* .5
  540.                                         vy# = vy# - Diffy# ;* .5
  541.                                         vz# = vz# - Diffz# ;* .5
  542.  
  543.                                         vvx# = vvx# + Diffx# ;* .5
  544.                                         vvy# = vvy# + Diffy# ;* .5
  545.                                         vvz# = vvz# + Diffz# ;* .5
  546.                                 EndIf                          
  547.                         EndIf
  548.                 Next
  549.  
  550. ;       If vy# < 0 Then
  551. ;               vy# = 0
  552. ;               vcol = True
  553. ;       EndIf
  554.        
  555. Next
  556.  
  557. End Function
  558.  
  559.  
  560.  
  561.  
  562.  
  563.  
  564.  
  565.  
  566.  
  567.  
  568.  
  569.  
  570.  
  571.  
  572.  
  573.  
  574.  
  575.  
  576.  
  577.  
  578.  
  579.  
  580. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  581. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  582. ;;;;;;goes through every constraint and updates it;;;;;;;;
  583. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  584. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  585.  
  586. Function UpdateConstraints()
  587.  
  588. For i = 1 To 3
  589.  
  590.         For c.constraint = Each constraint
  591.                 mx# = ( cv1x# - cv2x# )
  592.                 my# = ( cv1y# - cv2y# )
  593.                 mz# = ( cv1z# - cv2z# )
  594.                
  595.                 dist# = Sqr( (mx)^2 + (my)^2 + (mz)^2 )
  596.                
  597.                 mx# = mx# / 2
  598.                 my# = my# / 2
  599.                 mz# = mz# / 2
  600.                
  601.                 If dist# <> 0  Then
  602.                         dif# = (dist# - clength#) / dist# * .7
  603.                 EndIf
  604.                
  605.         ;       If cv1col = False Or i > 5 Then
  606.                         cv1x# = cv1x# - dif# * mx#
  607.                         cv1y# = cv1y# - dif# * my#
  608.                         cv1z# = cv1z# - dif# * mz#
  609.         ;       EndIf
  610.         ;       If cv2col = False Or i > 5 Then
  611.                         cv2x# = cv2x# + dif# * mx#
  612.                         cv2y# = cv2y# + dif# * my#
  613.                         cv2z# = cv2z# + dif# * mz#
  614.         ;       EndIf
  615.         Next
  616.  
  617. Next
  618.  
  619. End Function
  620.  
  621.  
  622.  
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.  
  638.  
  639. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  640. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  641. ;;;;;;positions all verlets;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  642. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  643. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  644.  
  645. Function Drawverlets()
  646.  
  647. For v.verlet = Each verlet
  648.        
  649.         PositionEntity vpiv,vx#,vy#,vz#
  650.        
  651. Next
  652.  
  653. End Function
  654.  
  655.  
  656.  
  657.  
  658.  
  659.  
  660.  
  661.  
  662.  
  663.  
  664.  
  665.  
  666.  
  667.  
  668.  
  669.  
  670.  
  671.  
  672. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  673. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  674. ;;;;;;positions all meshes;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  675. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  676. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  677.  
  678. Function PositionPhysicsEntity()
  679.  
  680. For r.rigidbody = Each rigidbody
  681.         PositionEntity rent,EntityX(rcpiv),EntityY(rcpiv),EntityZ(rcpiv)
  682.        
  683.         ;align mesh to verlet cage
  684.         x# = EntityX( r
  685. fpiv ) - EntityX( rlfpiv ) + EntityX( r
  686. bpiv ) - EntityX( rlbpiv )
  687.         y# = EntityY( r
  688. fpiv ) - EntityY( rlfpiv ) + EntityY( r
  689. bpiv ) - EntityY( rlbpiv )
  690.         z# = EntityZ( r
  691. fpiv ) - EntityZ( rlfpiv ) + EntityZ( r
  692. bpiv ) - EntityZ( rlbpiv )
  693.         AlignToVector rent, x#,y#,z#,1  
  694.         x# = EntityX( r
  695. fpiv ) - EntityX( r
  696. bpiv ) + EntityX( rlfpiv ) - EntityX( rlbpiv )
  697.         y# = EntityY( r
  698. fpiv ) - EntityY( r
  699. bpiv ) + EntityY( rlfpiv ) - EntityY( rlbpiv )
  700.         z# = EntityZ( r
  701. fpiv ) - EntityZ( r
  702. bpiv ) + EntityZ( rlfpiv ) - EntityZ( rlbpiv )
  703.         AlignToVector rent, x#,y#,z#, 3
  704. Next
  705.  
  706. End Function
  707.  
  708.  
  709.  
  710.  
  711.  
  712.  
  713.  
  714.  
  715.  
  716.  
  717.  
  718.  
  719.  
  720.  
  721.  
  722.  
  723.  
  724.  
  725.  
  726.  
  727.  
  728. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  729. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  730. ;;;;;;tests all verlets for collisions;;;;;;;;;;;;;;;;;;;;
  731. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  732. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  733.  
  734. Function Detectcollisions()
  735.  
  736. For v.verlet = Each verlet
  737.         If EntityX(vpiv) <> vx# Then
  738.                 If EntityCollided(vpiv,3) Then
  739.                         vcol = True
  740.                 EndIf
  741.                 vx# = EntityX(vpiv)
  742.         EndIf
  743.         If EntityY(vpiv) <> vy# Then
  744.                 If EntityCollided(vpiv,3) Then
  745.                         vcol = True
  746.                 EndIf
  747.                 vy# = EntityY(vpiv)
  748.         EndIf
  749.         If EntityZ(vpiv) <> vz# Then
  750.                 If EntityCollided(vpiv,3) Then
  751.                         vcol = True
  752.                 EndIf
  753.                 vz# = EntityZ(vpiv)
  754.         EndIf
  755. Next
  756.  
  757. End Function
  758.  
  759.  
  760.  
  761.  
  762.  
  763.  
  764. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  765. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  766. ;;;;;;applies a force to given object;;;;;;;;;;;;;;;;;;;;;
  767. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  768. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  769.  
  770.  
  771. Function PApplyForce(ent,x#,y#,z#)
  772.  
  773. For r.rigidbody = Each rigidbody
  774.         If rent = ent Then
  775.                 For i = 0 To rVerlnum
  776.                         rverl[i]ox# = rverl[i]ox# - x#
  777.                         rverl[i]oy# = rverl[i]oy# - y#
  778.                         rverl[i]oz# = rverl[i]oz# - z#
  779.                 Next
  780.         EndIf
  781. Next
  782.  
  783. End Function
  784.  
  785.  
  786.  
  787. Function PMoveEntity(ent,x#,y#,z#)
  788.  
  789. For r.rigidbody = Each rigidbody
  790.         If rent = ent Then
  791.                 For i = 0 To rverlnum
  792.                         rverl[cnt]ox# = rverl[cnt]ox# + x#
  793.                         rverl[cnt]oy# = rverl[cnt]oy# + y#
  794.                         rverl[cnt]oz# = rverl[cnt]oz# + z#
  795.                         rverl[cnt]x# = rverl[cnt]x# + x#
  796.                         rverl[cnt]y# = rverl[cnt]y# + y#
  797.                         rverl[cnt]z# = rverl[cnt]z# + z#
  798.                 Next
  799.         EndIf
  800. Next
  801.  
  802. End Function
  803.  
  804.  
  805.  
  806. Function PPositionEntity(ent,x#,y#,z#)
  807.  
  808. For r.rigidbody = Each rigidbody
  809.         If rent = ent Then
  810.                 For i = 0 To rverlnum
  811.                         rverl[cnt]ox# = x#
  812.                         rverl[cnt]oy# = y#
  813.                         rverl[cnt]oz# = z#
  814.                         rverl[cnt]x# = x#
  815.                         rverl[cnt]y# = y#
  816.                         rverl[cnt]z# = z#
  817.                 Next
  818.         EndIf
  819. Next
  820.  
  821. End Function


Comments :


Ked(Posted 1+ years ago)

 Puki would be proud of your "incomplete" tag at the top.


Nate the Great(Posted 1+ years ago)

 Yes it is incomplete but I probably will not post any more updates because I am currently turning it into a full fledged game.   ;)   I am not sure about the name but it will probably be called Destructo Car (Kindof similare to indestructo tank on addicting games)


KillerX(Posted 1+ years ago)

 Pretty cool.


Nate the Great(Posted 1+ years ago)

 Thanks KillerX


mtnhome3d(Posted 1+ years ago)

 lol i see how this worksthis is fun NTG. good job


Nate the Great(Posted 1+ years ago)

 Thanks Mtnhome3d glad you see how it works... that could be helpful


 

SimplePortal 2.3.6 © 2008-2014, SimplePortal