Hub

 Library = (:())()
 Window = Library.(, )
 Tab = Window:()
 Section = Tab:()
Section:()
Section:()
 Tab = Window:()
 Section = Tab:()
Section:(, , ()
(:())()
    ()
)
Section:(, , ()
()
 players = .Players:()
 i = , #players 
	players[i].Character.Head:()
	()
    
()
)
Section:(, , ()
(:())() 
    ()
)
Section:(, , (state)
 verlet = {}
verlet.step_time =  / 
verlet.gravity = .(, -, )

 char = .Players.LocalPlayer.Character
 torso = char:()
 parts = {}
 render = :().RenderStepped

()

 point = {}
 link = {}
 rope = {}

  (A,B,C)
     (C.y-A.y) * (B.x-A.x) > (B.y-A.y) * (C.x-A.x)


  (A,B,C,D)
     (A,C,D) ~= (B,C,D)  (A,B,C) ~= (A,B,D)


  (v)
	 .(v.x, v.z)


 point:()
	  self.fixed 
		 derivative = (self.position - self.last_position) * 
		self.last_position = self.position
		self.position = self.position + derivative + (self.velocity * verlet.step_time ^ )
		
	


 link:()
	 i = ,  
		 distance = self.point1.position - self.point2.position
		 magnitude = distance.magnitude
		 differance = (self.length - magnitude) / magnitude
		 translation = ((self.point1.fixed  self.point2.fixed)    ) * distance * differance
		  self.point1.fixed 
			self.point1.position = self.point1.position + translation
		
		  self.point2.fixed 
			self.point2.position = self.point2.position - translation
		
	


 verlet.(class, a, b, c)
	 class ==  
		 new = {}
		(new, {__index = point})
		new.class = class
		new.position = a  .()
		new.last_position = new.position
		new.velocity = verlet.gravity
		new.fixed = 
		 new
	 class ==  
		 new = {}
		(new, {__index = link})
		new.class = class
		new.point1 = a
		new.point2 = b
		new.length = c  (a.position - b.position).magnitude
		 new
	 class ==  
		 new = {}
		(new, {__index = link})
		new.class = class
		new.start_point = a
		new.finish_point = b
		new.points = {}
		new.links = {}
		 inc = (b - a) / 
		 i = ,  
			.(new.points, verlet.(, a + (i * inc)))
		
		 i = , #new.points 
			.(new.links, verlet.(, new.points[i - ], new.points[i]))
		
		 new
	


 tris = {}
 triParts = {}

  (hue)
 section = hue %  * 
 secondary =  * .pi * (section % )
 section <  
   .(,  - .(secondary),  - .(secondary))
 section <  
   .( - .(secondary), ,  - .(secondary))

   .( - .(secondary),  - .(secondary), )



  (part)
	part.Anchored = 
	part.FormFactor = 
	part.CanCollide = 
	part.TopSurface = 
	part.BottomSurface = 
	part.LeftSurface = 
	part.RightSurface = 
	part.FrontSurface = 
	part.BackSurface = 
	part.Material = 
	 m = .(, part)
	m.MeshType = 
	m.Scale = .(, , )
	 part


  (at, top, back)
	 right = top:(back)
	 .(at.x, at.y, at.z, right.x, top.x, back.x,  right.y, top.y, back.y, right.z, top.z, back.z)


  (parent, a, b, c)
	 this = {}
	 mPart1 = .(triParts, )  (.())
	 mPart2 = .(triParts, )  (.())
	 this:(a, b, c)
		 ab, bc, ca = b-a, c-b, a-c
		 abm, bcm, cam = ab.magnitude, bc.magnitude, ca.magnitude
		 edg1 = .( + ca:(ab)/(abm*abm))
		 edg2 = .( + ab:(bc)/(bcm*bcm))
		 edg3 = .( + bc:(ca)/(cam*cam))
		 edg1 < edg2 
			 edg1 >= edg3 		
				a, b, c = c, a, b
				ab, bc, ca = ca, ab, bc
				abm = cam
			
		
			 edg2 < edg3 
				a, b, c = b, c, a
				ab, bc, ca = bc, ca, ab
				abm = bcm
			
				a, b, c = c, a, b
				ab, bc, ca = ca, ab, bc
				abm = cam
			
		
	 
		 len1 = -ca:(ab)/abm
		 len2 = abm - len1
		 width = (ca + ab.unit*len1).magnitude
	 
		 maincf = (a, ab:(bc).unit, -ab.unit)
	 
		 len1 >  
			mPart1.Parent = parent
			mPart1.Size = .(, width, len1)
			mPart1.CFrame = maincf*.(.pi,,.pi/)*.(,width/,len1/)
		
			mPart1.Parent = 
		
		
		 len2 >  
			mPart2.Parent = parent
			mPart2.Size = .(, width, len2)
			mPart2.CFrame = maincf*.(.pi,.pi,-.pi/)*.(,width/,-len1 - len2/)
		
			mPart2.Parent = 
			
	
	 this:(prop, value)
		mPart1[prop] = value
		mPart2[prop] = value
	
	this:(a, b, c)
	 this:()
		mPart1:()
		mPart2:()
	
	this.p1 = mPart1
	this.p2 = mPart2
	this.p1.BrickColor = BrickColor.((.(, , this.p1.CFrame.Y *  + ())))
	this.p2.BrickColor = BrickColor.((.(, , this.p2.CFrame.Y *  + ())))
	 this


 verlet.(object, id)
	 object.class ==  
		 part = parts[id]
		part.BrickColor = BrickColor.(, , )
		part.Transparency = 
		part.formFactor = 
		part.Anchored = 
		part.CanCollide = 
		part.TopSurface = 
		part.BottomSurface = 
		part.Size = .(, , )
		part.Material = 
		part.CFrame = .(object.position)
		part.Parent = torso
		 part
	 object.class ==  
		 part = parts[id]
		 dist = (object.point1.position - object.point2.position).magnitude
		part.Size = .(, , dist)
		part.CFrame = .(object.point1.position, object.point2.position) * .(, , dist * -)
		part.Parent = torso
		 part
	


 verlet.()
	 _, v  (:()) 
		 v.Name ==  
			v:()
		
	


 points = {}
 links = {}

 x = ,  
	points[x] = {}
	 y = ,  
		points[x][y] = verlet.(, torso.Position + .(x *  - ,  - y * ,  + y * ))
		points[x][y].fixed = y == 
	


 x = ,  
	 y = ,  
		links[#links + ] = verlet.(, points[x][y], points[x - ][y],  + y * )
	


 x = ,  
	 y = ,  
		links[#links + ] = verlet.(, points[x][y], points[x][y - ],  + y * )
	


render:(()
	 x = ,  
		 y = ,  
			 y ==  
				points[x][y].position = (torso.CFrame * .(x *  - , , )).p
			
				points[x][y]:()
			
		
	
	 i = , #links 
		links[i]:()
	
	 i = , #tris 
		triParts[#triParts + ] = tris[i].p1
		triParts[#triParts + ] = tris[i].p2
	
	tris = {}
	 x = ,  
		 y = ,  
			tris[#tris + ] = (torso, points[x - ][y - ].position, points[x - ][y].position, points[x][y - ].position)
			tris[#tris + ] = (torso, points[x][y].position, points[x - ][y].position, points[x][y - ].position)
		
	
)
        ()
    
        ()
    
)