anti fling by Zenith

 Players = :()
 RunService = :()
 TweenService = :()
 CollectionService = :()

 player = Players.LocalPlayer
  player   
 player:()   
player:(, )

 playerGui = player:()

 CFG = {
	Speed = ,
	Angular = ,
	SoftSustain = ,
	Rewind = ,
	ShieldRadius = ,
	PartLin = ,
	PartAng = ,
	FreezeTime = ,
	LinkRadius = ,
	SweepEvery = ,
	ParkDistance = ,
	HopMin = ,
	HopCount = ,
	Huge = ,
	SpawnGrace = ,
}

  (char)  char  char:() 
  (char)  char  char:() 
  (char)
	 h = (char)
	 h ~=   h.Health > 


 selfUntil = 

  ()
	 gui = .()
	gui.Name = 
	gui.ResetOnSpawn = 
	gui.IgnoreGuiInset = 
	gui.DisplayOrder = 
	gui.Parent = playerGui

	 label = .()
	label.AnchorPoint = .(, )
	label.Position = .(, , , )
	label.Size = .(, )
	label.BackgroundTransparency = 
	label.Text = 
	label.TextColor3 = .(, , )
	label.TextStrokeColor3 = .(, , )
	label.TextStrokeTransparency = 
	label.TextSize = 
	label.Font = .Font.GothamBold
	label.TextTransparency = 
	label.TextStrokeTransparency = 
	label.Parent = gui

	.(()
		 fade = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)
		TweenService:(label, fade, { TextTransparency = , TextStrokeTransparency =  }):()
		.()
		TweenService:(label, fade, { TextTransparency = , TextStrokeTransparency =  }):()
		.()
		gui:()
	)


 tracked = {}

  (v)
	 m = v.Magnitude
	 m == m  m < CFG.Huge


  (char)
	 e = tracked[char]
	  e   
	 _, c  e.conns  c:() 
	tracked[char] = 


  (plr, char)
	 plr == player  tracked[char]   
	 e = {
		plr = plr, parts = {}, conns = {}, slot = plr.UserId % ,
		parkUntil = , parked = , parkPos = , realCF = ,
		hotSince = , hotLast = , hops = {}, hopPos = , hopT = ,
	}
	tracked[char] = e
	  (d)
		 d:()  e.parts[d] =  
	
	 _, d  char:()  (d) 
	e.conns[] = char.DescendantAdded:(add)
	e.conns[] = char.DescendantRemoving:((d) e.parts[d] =  )
	e.conns[] = char.AncestryChanged:((_, parent)
		  parent  (char) 
	)


  (plr)
	 plr == player   
	plr.CharacterAdded:((char) (plr, char) )
	 plr.Character  (plr, plr.Character) 


 _, plr  Players:()  (plr) 
Players.PlayerAdded:(watch)
Players.PlayerRemoving:((plr)
	 plr.Character  (plr.Character) 
)

  (e, secs, now)
	e.parkUntil = .(e.parkUntil, now + secs)


  (e, root, now)
	 pos = root.Position
	 pp = e.parkPos
	 pp  (pos - pp).Magnitude <    
	 lv, av = root.AssemblyLinearVelocity, root.AssemblyAngularVelocity
	 lm, am = lv.Magnitude, av.Magnitude
	  (lm < CFG.Huge  am < CFG.Huge  pos.Magnitude < CFG.Huge) 
		e.hopPos = 
		(e, , now)
		
	
	e.realCF = root.CFrame

	 am > CFG.Angular *   lm > CFG.Speed *  
		e.hotSince = e.hotSince  now
		e.hotLast = now
		 now - e.hotSince >=   (e, , now) 
	 e.hotSince  now - e.hotLast >  
		e.hotSince = 
	

	 prev = e.hopPos
	 prev 
		 d = (pos - prev).Magnitude
		 d >= CFG.HopMin  d > lm * .(now - e.hopT, ) *  +  
			 list = e.hops
			list[#list + ] = now
			 #list >   now - list[] >   .(list, ) 
			 #list >= CFG.HopCount 
				.(list)
				(e, , now)
			
		
	
	e.hopPos, e.hopT = pos, now


  (e, char, root, myRoot)
	 spot = myRoot.Position + .(e.slot *  - , CFG.ParkDistance, )
	e.parked, e.parkPos = , spot
	 ok = (() char:(.(spot)) )
	 broken =  ok   (root.Position)
	 part  e.parts 
		 part.Parent 
			 broken  part.CFrame = .(spot) 
			part.AssemblyLinearVelocity = .zero
			part.AssemblyAngularVelocity = .zero
		
	


  (e, char)
	e.parked, e.parkPos, e.hopPos = , , 
	 cf = e.realCF
	 cf  (cf.Position)  (() char:(cf) ) 


 overlap = OverlapParams.()
overlap.FilterType = .RaycastFilterType.Exclude
 looseOff = {}
 looseP, looseT = ({}, { __mode =  }), ({}, { __mode =  })
 seatCache = ({}, { __mode =  })
 shieldN = 

  (part)
	 top = part
	 top.Parent  top.Parent ~=   top = top.Parent 
	 top


  (model)
	 c = seatCache[model]
	 c ==  
		c = 
		 _, d  model:() 
			 d:()  d:()  c =   
		
		seatCache[model] = c
	
	 c


  (part)
	 CollectionService:(part, )    
	 m = part:()
	 m  m:()    
	 top = (part)
	 , top:()  (top)


  (part, k)
	  (part.AssemblyLinearVelocity.Magnitude <= CFG.PartLin * k)
		  (part.AssemblyAngularVelocity.Magnitude <= CFG.PartAng * k)


  (part, now)
	 pos = part.Position
	 prev, pt = looseP[part], looseT[part]
	  prev 
		looseP[part], looseT[part] = pos, now
		 
	
	 dt = now - pt
	 dt <     
	looseP[part], looseT[part] = pos, now
	 dt >     
	  ((pos - prev).Magnitude / dt <= CFG.Speed)


RunService.Stepped:(()
	 now0 = .()
	 myRoot0 = (player.Character)
	 char, e  tracked 
		 char.Parent 
			 root = (char)
			 root 
				(e, root, now0)
				 myRoot0  e.parkUntil > now0 
					 hum = (char)
					 hum  hum.SeatPart  (root.Position) 
						 e.parked  (e, char) 
					
						(e, char, root, myRoot0)
					
				 e.parked 
					(e, char)
				
			
				e.hopPos = 
			
			 part  e.parts 
				 part.Parent  part.CanCollide  part.CanCollide =  
			
		
	

	shieldN += 
	 shieldN %  ~=    
	 now = .()
	 part, due  looseOff 
		  part.Parent 
			looseOff[part] = 
		 now >= due 
			part.CanCollide = 
			looseOff[part] = 
		
	
	 myChar = player.Character
	 myRoot = (myChar)
	  myRoot   
	overlap.FilterDescendantsInstances = { myChar }
	 myHum = (myChar)
	 mySeat = myHum  myHum.SeatPart
	 myAssembly = mySeat  mySeat.AssemblyRootPart
	 _, p  :(myRoot.Position, CFG.ShieldRadius, overlap) 
		 looseOff[p] 
			 (p, )  looseOff[p] = now +  
		  p.Anchored  p.CanCollide  ((p, )  (p, now)) 
			 ok, vehicle = (p)
			 ok  ( vehicle  (p, ))   (myAssembly  p.AssemblyRootPart == myAssembly) 
				looseOff[p] = now + 
				p.CanCollide = 
			
		
	
)

.(()
	  
		.(CFG.SweepEvery)
		 char  tracked 
			 _, d  char:() 
				 d:()  d.CanCollide  d.CanCollide =  
			
		
	
)


 hist, histT = {}, 
 softT, spawnUntil = , 
 frozenRoot, freezeUntil = , 
 lastRoot, lastGround = , 
 lastHum = 

  (hum)
	 v = hum.JumpPower
	 hum.UseJumpPower ==  
		v = .( * .Gravity * (hum.JumpHeight  ))
	
	 (v)  


  (hum)
	(()
		hum:(.HumanoidStateType.FallingDown, )
		hum:(.HumanoidStateType.Ragdoll, )
	)


 VEHICLE_WORDS = { , , , , , , , , , , , , , , ,  }
 lastUnsit = 

  (seat)
	 seat:()    
	 m = seat
	 m  m ~=  
		 CollectionService:(m, )    
		 n = .(m.Name)
		 _, w  VEHICLE_WORDS 
			 .(n, w, , )    
		
		m = m.Parent
	
	 


  (seat)
	 model = seat:()
	 model 
		 plr = Players:(model)
		 plr   plr ~= player 
		 parent = model.Parent
		model = parent  parent:()  
	
	  (seat)  seat.AssemblyLinearVelocity.Magnitude > 


 under = { ref = , t = , cf = , ok = , void = , vy =  }
 underRp = RaycastParams.()
underRp.FilterType = .RaycastFilterType.Exclude
underRp.RespectCanCollide = 

  ()
	under.ref, under.cf, under.ok, under.void, under.vy = , , , , 


  (char, root, hum, vel, now, dt)
	 pos = root.Position
	 vy = vel.Y
	 prevVy = under.vy
	under.vy = vy
	 hum.FloorMaterial ~= .Material.Air 
		 vel.Magnitude <   vy > - 
			under.ref, under.t = pos, now
			under.ok += 
			 under.ok >=   under.cf = root.CFrame 
		
			under.ok = 
		
		under.void = 
		
	
	under.ok = 
	 ref = under.ref
	  ref   
	 t = now - under.t
	 drop = ref.Y - pos.Y
	 g = .Gravity
	 fastDrop = drop >  * g * t * t +  + hum.HipHeight
	 falling = 
	  fastDrop  drop >   vy <= - 
		 acc = prevVy  (vy - prevVy) / .(dt, )  
		falling = acc <= - * g  vy <= -
	
	  (fastDrop  falling) 
		under.void = 
		
	
	under.void += dt
	 under.void <    
	underRp.FilterDescendantsInstances = { char }
	 :(pos, .(, -, ), underRp) 
		under.ref, under.void = , 
		
	
	 ( fastDrop  .StreamingEnabled)   :(pos, .(, , ), underRp) 
		
	
	 target = under.cf  lastGround
	  target   
	under.ref, under.void = , 
	selfUntil = now + 
	root.AssemblyLinearVelocity = .zero
	root.AssemblyAngularVelocity = .zero
	char:(target + .(, , ))
	hist = {}


  (root)
	 root.Anchored   
	root.Anchored = 
	frozenRoot = root
	freezeUntil = .() + CFG.FreezeTime


RunService.Heartbeat:((dt)
	 now = .()
	 frozenRoot  (now >= freezeUntil   frozenRoot.Parent) 
		 frozenRoot.Parent 
			frozenRoot.AssemblyLinearVelocity = .zero
			frozenRoot.AssemblyAngularVelocity = .zero
			frozenRoot.Anchored = 
		
		frozenRoot = 
	

	 char = player.Character
	 root, hum = (char), (char)
	  (root  hum  hum.Health > ) 
		hist, lastGround, lastRoot = {}, , 
		()
		
	
	 frozenRoot   
	 lastRoot ~= root 
		lastRoot = root
		hist, softT = {}, 
		spawnUntil = now + CFG.SpawnGrace
		()
	
	 lastHum ~= hum 
		lastHum = hum
		(hum)
	
	 st = hum:()
	 st == .HumanoidStateType.FallingDown  st == .HumanoidStateType.Ragdoll 
		hum:(.HumanoidStateType.GettingUp)
	

	 seatPart = hum.SeatPart
	 seatPart  now - lastUnsit >   (seatPart) 
		lastUnsit = now
		hum.Sit = 
		hum:(.HumanoidStateType.Jumping)
		 weld = seatPart:()
		 weld  (() weld:() ) 
		seatPart = 
	
	 seated = seatPart ~= 
	 vel = root.AssemblyLinearVelocity
	 angV = root.AssemblyAngularVelocity
	 broken =  ((vel)  (angV)  (root.Position))
	 horiz = .(vel.X, , vel.Z).Magnitude
	 up = .(vel.Y, )
	 down = .(-vel.Y, )
	 jv = (hum)

	 limit = .(CFG.Speed, jv * )
	 soft = .(limit * , hum.WalkSpeed * , jv * )
	 horiz > soft   seated  now > selfUntil 
		softT += dt
	
		softT = 
	

	 angBad = angV.Magnitude > CFG.Angular
	 hard = .(horiz, up) > limit  down > .(limit, )
	 bad =  seated  (broken  (now > spawnUntil  (hard  angBad  softT > CFG.SoftSustain)))

	 bad 
		 target
		 i = #hist, , - 
			 hist[i].t <= now - CFG.Rewind  target = hist[i].cf  
		
		target = target  (hist[]  hist[].cf)  lastGround  under.cf
		root.AssemblyLinearVelocity = .zero
		root.AssemblyAngularVelocity = .zero
		 target 
			selfUntil = now + 
			root.CFrame = target
		
		hist, softT = {}, 
		(root)
	  seated 
		histT += dt
		 histT >=  
			histT = 
			 calm = horiz < soft  up < soft  down < limit *   angV.Magnitude < CFG.Angular * 
			 calm 
				hist[#hist + ] = { t = now, cf = root.CFrame }
				 #hist >   now - hist[].t >   .(hist, ) 
			
		
		 horiz < soft  up < soft  down < limit *   angV.Magnitude < CFG.Angular * 
			 hum.FloorMaterial ~= .Material.Air 
			lastGround = root.CFrame + .(, , )
		
	
		hist = {}
	

	 lastGround  root.Position.Y < .FallenPartsDestroyHeight +  
		selfUntil = now + 
		root.AssemblyLinearVelocity = .zero
		root.AssemblyAngularVelocity = .zero
		char:(lastGround)
	

	  seated  now > selfUntil  now > spawnUntil   broken 
		(char, root, hum, vel, now, dt)
	
		under.ref, under.ok, under.void, under.vy = , , , 
	
)


 FORCE = {
	AlignPosition = , AlignOrientation = , LinearVelocity = , VectorForce = ,
	AngularVelocity = , Torque = , BallSocketConstraint = , RopeConstraint = ,
	SpringConstraint = , RodConstraint = , HingeConstraint = ,
}
 SINGLE = { LinearVelocity = , VectorForce = , AngularVelocity = , Torque =  }
 JOINT = { Weld = , WeldConstraint = , Motor6D = , ManualWeld = , Snap =  }

  (inst)
	 m = inst
	 m  m ~=  
		 m:() 
			 plr = Players:(m)
			 plr   plr 
		
		m = m.Parent
	
	 

  (p, myChar)  p ~=   myChar ~=   p:(myChar) 
  (p)
	  p    
	 o = (p)
	 o ~=   o ~= player


  (d, myChar)
	 cn = d.ClassName
	 FORCE[cn] 
		 a0, a1 = d.Attachment0, d.Attachment1
		 p0 = a0  a0.Parent
		 p1 = a1  a1.Parent
		 SINGLE[cn] 
			 o = (d)
			 (p0, myChar)  o ~=   o ~= player
		
		 ((p0, myChar)  (p1))  ((p1, myChar)  (p0))
	 JOINT[cn] 
		 p0, p1 = d.Part0, d.Part1
		 ((p0, myChar)  (p1))  ((p1, myChar)  (p0))
	
	 


  (model, myChar)
	 _, d  model:() 
		 cn = d.ClassName
		 (FORCE[cn]  JOINT[cn])  (d, myChar) 
			(() d:() )
		
	


 released = {}
  (part, secs)
	 part.Parent  part.CanCollide 
		part.CanCollide = 
		released[part] = .() + secs
	


 fresh = {}
 bootAt = .()
.DescendantAdded:((d)
	 .StreamingEnabled  .() - bootAt <    
	 d:()  d.CanCollide  d.ClassName ~=  
		fresh[#fresh + ] = { p = d, t = .() }
		 #fresh >   .(fresh, ) 
	
)

 rideT, posHist = {}, {}
 sounded = ({}, { __mode =  })
 a1, a2, a3 = , , 

RunService.Heartbeat:((dt)
	 myChar = player.Character
	 myRoot = (myChar)
	 now = .()
	 part, due  released 
		  myRoot  now >= due   part.Parent 
			 part.Parent  part.CanCollide =  
			released[part] = 
		
	
	  (myRoot  (myChar))   

	a1 += dt
	 a1 >=  
		a1 = 
		(myChar, myChar)
		 _, plr  Players:() 
			 char = plr ~= player  plr.Character
			 r = char  (char)
			 r  (r.Position - myRoot.Position).Magnitude < CFG.LinkRadius  (char, myChar) 
		

		  .StreamingEnabled  #fresh >  
			posHist[#posHist + ] = { t = now, p = myRoot.Position }
			 #posHist >   now - posHist[].t >   .(posHist, ) 
			 still = 
			 _, h  posHist 
				 (h.p - myRoot.Position).Magnitude >   still =  
			
			 near = {}
			 i = #fresh, , - 
				 f = fresh[i]
				  f.p.Parent  now - f.t >  
					.(fresh, i)
				 (f.p) ==  
					 pos = f.p.Position
					 (pos - myRoot.Position).Magnitude <   pos.Y > myRoot.Position.Y -  
						near[#near + ] = f.p
					
				
			
			 still  #posHist >=   #near >=  
				 _, p  near  (p, ) 
			
		
	

	a2 += dt
	 a2 >=  
		 step = a2
		a2 = 
		 seen = {}
		 _, plr  Players:() 
			 plr ~= player 
				 r = (plr.Character)
				 r 
					 d = r.Position - myRoot.Position
					 flat = .(d.X, , d.Z).Magnitude
					 flat <   d.Y >   d.Y <  
						seen[plr] = 
						rideT[plr] = (rideT[plr]  ) + step
						 rideT[plr] >  
							 _, part  plr.Character:() 
								 part:()  (part, ) 
							
						
					
				
			
		
		 plr  rideT 
			  seen[plr]  rideT[plr] =  
		
	

	a3 += dt
	 a3 >=  
		a3 = 
		 _, plr  Players:() 
			 char = plr ~= player  plr.Character
			 char 
				 _, d  char:() 
					 d:()  d.Playing  (d.Volume >   d.PlaybackLoudness > ) 
						d.Volume = .(d.Volume, )
						sounded[d] = 
					
				
			
		
	
)

()