Ping Compensation OP

 Players = :()
 RunService = :()
 Workspace = :()
 lp = Players.LocalPlayer

 cfg = {
	active = ,
	visual = ,
	compFactor = ,
	jitterW = ,
	maxCompMs = ,
	maxOfs = ,
	smooth = ,
	blendUp = ,
	blendDn = ,
	dirUp = ,
	dirDn = ,
	velMin = ,
	velAlpha = ,
	tpDist = ,
	rttA = ,
	jitA = ,
	yDamp = ,
	spdClamp = ,
	boundsCheck = ,
	maxOfsRate = ,
	pingFadeLo = ,
	pingFadeHi = ,
	minDt =  / ,
	maxDt =  / ,
	owThresh = ,
	accelAlpha = ,
	accelScale = ,
	staleRate = ,
	staleFade = ,
	groundUp = ,
	groundDown = ,
	adaptSmoothMin = ,
	adaptSmoothMax = ,
	adaptJitScale = ,
}

 net = { rtt = , jit =  }
 ents = {}
 conns = {}
 running = 
 rcP = RaycastParams.()
rcP.FilterType = .RaycastFilterType.Exclude
 filterTable = {}

  (rate, dt)
	  - .(-rate * dt)


  (rtt)
	 hi = .(cfg.pingFadeHi, net.jit * )
	 rtt <= cfg.pingFadeLo    
	 rtt >= hi    
	 (rtt - cfg.pingFadeLo) / (hi - cfg.pingFadeLo)


  ()
	 raw = net.rtt *  * cfg.compFactor + net.jit * cfg.jitterW
	 v = .(raw * (net.rtt), cfg.maxCompMs / )
	 v ~= v  v <     
	 v


  ()
	 r = lp:() * 
	 r ~= r  r <   r =  
	net.rtt = net.rtt ==   r  net.rtt + cfg.rttA * (r - net.rtt)
	net.jit = net.jit + cfg.jitA * (.(r - net.rtt) - net.jit)


  ()
	 {
		engPos = ,
		readCF = .identity,
		lastPP = ,
		vel = .zero,
		sVel = .zero,
		dir = .zero,
		dcon = ,
		bld = ,
		ofs = .zero,
		pred = .identity,
		char = ,
		root = ,
		hum = ,
		alive = ,
		ok = ,
		accel = .zero,
		prevVel = ,
		airborne = ,
		stale = ,
		conf = ,
	}


  (e)
	e.vel = .zero
	e.sVel = .zero
	e.dir = .zero
	e.dcon = 
	e.bld = 
	e.ofs = .zero
	e.ok = 
	e.engPos = 
	e.lastPP = 
	e.accel = .zero
	e.prevVel = 
	e.airborne = 
	e.stale = 
	e.conf = 


  (e)
	 (e.hum  e.hum.WalkSpeed)  


  (origin, target)
	  cfg.boundsCheck   target 
	 disp = target - origin
	 dist = disp.Magnitude
	 dist <    target 
	 wh = Workspace:(origin, disp, rcP)
	 wh   origin + disp.Unit * .(wh.Distance - , ) 
	 gh = Workspace:(target + .(, cfg.groundUp, ), .(, -(cfg.groundUp + cfg.groundDown), ), rcP)
	  gh   origin 
	 target

  (e, dt)
	 root = e.root
	 cf = root.CFrame
	 p = cf.Position
	 rv = root.AssemblyLinearVelocity
	 rvm = rv.Magnitude
	 rvm ~= rvm  rvm >   rv = .zero 

	e.readCF = cf

	 freshData = 
	 engP
	 cfg.visual  e.lastPP  e.engPos 
		 (p - e.lastPP).Magnitude > cfg.owThresh 
			engP = p
			freshData = 
		
			engP = e.engPos + rv * dt
		
	
		engP = p
		freshData = 
	

	 e.engPos  (engP - e.engPos).Magnitude > cfg.tpDist 
		(e)
		engP = p
		freshData = 
	

	e.engPos = engP

	 va = (cfg.velAlpha, dt)
	e.sVel = e.sVel:(rv, va)

	 ws = (e)
	 maxSpd = ws * cfg.spdClamp
	 hRaw = .(e.sVel.X, , e.sVel.Z)
	 hMag = hRaw.Magnitude

	 hMag > maxSpd 
		 s = maxSpd / hMag
		e.vel = .(e.sVel.X * s, e.sVel.Y, e.sVel.Z * s)
	
		e.vel = e.sVel
	

	 e.prevVel 
		 rawAccel = (e.vel - e.prevVel) / dt
		 ram = rawAccel.Magnitude
		 ram ~= ram  ram >   rawAccel = .zero 
		e.accel = e.accel:(rawAccel, (cfg.accelAlpha, dt))
	
	e.prevVel = e.vel

	e.airborne = e.hum  e.hum.FloorMaterial == .Material.Air

	 hv = .(e.vel.X, , e.vel.Z)
	 hspd = hv.Magnitude

	 hspd > cfg.velMin 
		 nv = hv.Unit
		 e.dir.Magnitude <  
			e.dir = nv
			e.dcon = 
		
			 dot = .(nv:(e.dir), , )
			e.dcon = e.dcon + cfg.dirUp * dt * (dot - e.dcon)
			 nd = e.dir:(nv, .( * dt, , ))
			e.dir = nd.Magnitude >   nd.Unit  nv
		
		e.bld = .(e.bld + cfg.blendUp * dt, )
	
		e.dcon = .(e.dcon - cfg.dirDn * dt, )
		e.bld = .(e.bld - cfg.blendDn * dt, )
		 e.bld <   e.dir = .zero 
	

	 freshData 
		e.stale = 
	
		e.stale = e.stale + dt * cfg.staleRate
	
	 staleMul = .( - e.stale * cfg.staleFade, )

	 sc = e.bld * e.dcon * staleMul
	 ct = ()
	 adaptSmooth = .(cfg.smooth - net.jit * cfg.adaptJitScale, cfg.adaptSmoothMin, cfg.adaptSmoothMax)
	 tgt
	 sc >  
		 t = ct * sc
		 pv
		 e.airborne 
			 grav = Workspace.Gravity
			pv = e.vel * t + .(, -grav *  * t * t, ) + .(e.accel.X, , e.accel.Z) * (cfg.accelScale *  * t * t)
		
			 dampedVel = .(e.vel.X, e.vel.Y * cfg.yDamp, e.vel.Z)
			pv = dampedVel * t + .(e.accel.X, , e.accel.Z) * (cfg.accelScale *  * t * t)
		
		tgt = pv
		 m = tgt.Magnitude
		 dynMax = .(cfg.maxOfs, ws * ct * cfg.spdClamp)
		 m > dynMax  tgt = tgt * (dynMax / m) 
	
		tgt = .zero
	

	 a = (adaptSmooth, dt)
	 desired = e.ofs:(tgt, a)
	 delta = desired - e.ofs
	 deltaMag = delta.Magnitude
	 maxDelta = maxSpd * dt * cfg.maxOfsRate
	 deltaMag > maxDelta  deltaMag >  
		desired = e.ofs + delta * (maxDelta / deltaMag)
	

	e.ofs = desired
	 ofsMag = e.ofs.Magnitude
	 ofsMag ~= ofsMag 
		e.ofs = .zero
		ofsMag = 
	 ofsMag <  
		e.ofs = .zero
		ofsMag = 
	

	 ofsMag >   sc >  
		e.conf = .(e.conf +  * dt, )
	
		e.conf = .(e.conf -  * dt, )
	

	 predPos = (engP, engP + e.ofs)
	e.pred = (cf - p) + predPos
	e.ok = 

 M = {}

 M.()
	 running   
	running = 

	conns.leave = Players.PlayerRemoving:((pl)
		ents[pl] = 
	)

	conns.hb = RunService.Heartbeat:((rawDt)
		  cfg.active   
		 dt = .(rawDt, cfg.minDt, cfg.maxDt)
		()

				 pls = Players:()
		.(filterTable)
		 fi = 
		 i = , #pls 
			 ch = pls[i].Character
			 ch  fi = fi + ; filterTable[fi] = ch 
		
		rcP.FilterDescendantsInstances = filterTable

		 i = , #pls 
			 pl = pls[i]
			 pl ~= lp 
				 ch = pl.Character
				 ch 
					 root = ch:()
					 hum = ch:()
					 root  hum  hum.Health >  
						 e = ents[pl]
						  e  e = (); ents[pl] = e 
						 e.char ~= ch 
							(e)
							e.char = ch
						
						e.root = root
						e.hum = hum
						e.alive = 
						(e, dt)
						 cfg.visual  root.Parent 
							root.CFrame = e.pred
							e.lastPP = e.pred.Position
						
							e.lastPP = 
						
					
						 e = ents[pl]
						 e  e.alive 
							e.alive = 
							 cfg.visual  e.ok  e.root  e.root.Parent  e.engPos 
								e.root.CFrame = (e.readCF - e.readCF.Position) + e.engPos
							
						
					
				
					 e = ents[pl]
					 e  e.alive =  
				
			
		
	)


 M.()
	running = 
	 k, c  (conns)  c:(); conns[k] =  
	 _, e  (ents) 
		 cfg.visual  e.ok  e.root  e.root.Parent  e.engPos 
			e.root.CFrame = (e.readCF - e.readCF.Position) + e.engPos
		
	
	.(ents)
	.(filterTable)
	rcP.FilterDescendantsInstances = filterTable


 M.(pl)
	 e = ents[pl]
	 e  e.ok  e.pred.Position  


 M.(pl)
	 e = ents[pl]
	 e  e.ok  e.pred  


 M.(pl, name)
	 e = ents[pl]
	  e   e.ok   e.char   e.engPos    
	 pt = e.char:(name)
	  pt    
	 e.pred.Position + (pt.Position - e.readCF.Position)


 M.(pl)
	 M.(pl, )


 M.(pl, projSpd)
	 e = ents[pl]
	  e   e.ok    
	  projSpd  projSpd <=    e.pred.Position 
	 mc = lp.Character
	 mr = mc  mc:()
	  mr   e.pred.Position 
	 d = (e.pred.Position - mr.Position).Magnitude
	 t = d / projSpd + net.rtt * 
	 e.pred.Position + e.vel * t + e.accel * (cfg.accelScale *  * t * t)


 M.(fov, rng, los)
	 cam = Workspace.CurrentCamera
	  cam    
	fov = fov  
	rng = rng  
	 o = cam.CFrame.Position
	 l = cam.CFrame.LookVector
	 best, bs = , .huge
	 pl, e  (ents) 
		 e.ok  e.alive 
			 dv = e.pred.Position - o
			 dm = dv.Magnitude
			 dm >   dm < rng 
				 ang = .(.(.(l:(dv / dm), -, )))
				 ang < fov 
					 los 
						 hit = Workspace:(o, dv, rcP)
						 hit   
					
					 sc = ang + dm * 
					 sc < bs  best, bs = pl, sc 
				
			
		
	
	 best


 M.(pl)
	 e = ents[pl]
	 e  e.vel  


 M.(pl, t)
	 e = ents[pl]
	 e ~=   e.vel.Magnitude > (t  cfg.velMin)


 M.(pl)
	 e = ents[pl]
	 e  e.ofs  


 M.(pl)
	 e = ents[pl]
	 e  e.conf  


 M.()
	 {
		rtt = net.rtt,
		rttMs = net.rtt * ,
		jitter = net.jit,
		jitterMs = net.jit * ,
		compMs = () * ,
		oneWayMs = net.rtt * ,
	}


 M.()
	 r = {}
	 pl, e  (ents) 
		 e.ok  e.alive 
			r[pl] = {
				position = e.pred.Position,
				cframe = e.pred,
				velocity = e.vel,
				offset = e.ofs,
				acceleration = e.accel,
				confidence = e.conf,
				airborne = e.airborne,
			}
		
	
	 r


 M.(on)
	  on  cfg.visual 
		 _, e  (ents) 
			 e.ok  e.root  e.root.Parent  e.engPos 
				e.root.CFrame = (e.readCF - e.readCF.Position) + e.engPos
			
			e.ofs = .zero
			e.lastPP = 
			e.stale = 
			e.conf = 
		
	
	cfg.visual = on


 M.(on)
	cfg.active = on
	  on  M.() 


 M.()
	 cfg


M.()
 M