bad universal car crash avoidance bot

 UserInputService = :()
 VirtualInputManager = :()
 RunService = :()
 Players = :()
 PathfindingService = :()
 thisScript = 

 spamEnabled = 
 spamThread
 player = Players.LocalPlayer

 heldKeys = {}
 lastSteerDir = 
 hysteresisTimer = 
 hysteresisCooldown =  
 steerSmoothing =  
 stuckTimer = 
 stuckStage =  
 lastPos = 
 waypoints = {}
 currentWaypoint = 
 asphaltBias =  
 maxSpeed =  
 minSpeed =  


  (key, intensity)
	  heldKeys[key]  heldKeys[key] < intensity 
		VirtualInputManager:(, .KeyCode[key], , )
		heldKeys[key] = intensity
	


  (key)
	 heldKeys[key] 
		VirtualInputManager:(, .KeyCode[key], , )
		heldKeys[key] = 
	


  ()
	 key, _  (heldKeys) 
		(key)
	



  ()
	 character = player.Character
	  character    
	 root = character:()
	  root    
	 root:()  root:()



  ()
	 params = RaycastParams.()
	params.FilterType = .RaycastFilterType.Exclude
	 ignoreList = {}

	 vehicle = ()
	 vehicle 
		 _, obj  (vehicle:()) 
			.(ignoreList, obj)
		
		.(ignoreList, vehicle)
	

	 player.Character 
		.(ignoreList, player.Character)
	

	params.FilterDescendantsInstances = ignoreList
	params.IgnoreWater = 
	 params



  (startPos, endPos)
	 path = PathfindingService:({
		AgentRadius = , 
		AgentHeight = ,
		AgentCanJump = ,
		Costs = {
			Water = , 
			Grass = ,
			Sand = ,
			Asphalt = ,
			Concrete =  
		}
	})
	path:(startPos, endPos)
	 path.Status == .PathStatus.Success 
		 path:()
	
		
		path:(startPos, endPos + .(, , ))
		 path.Status == .PathStatus.Success  path:()  
	



  (currentPos)
	 maxDist = 
	 minDist = 
	 attempts = 
	 maxAttempts = 

	 attempts < maxAttempts 
		 angle = .() *  * .pi
		 distance = .(minDist, maxDist)
		 newPos = currentPos + .(.(angle) * distance, , .(angle) * distance)

		
		 raycastParams = ()
		 result = :(newPos + .(, , ), .(, -, ), raycastParams)
		 result  (result.Material == .Material.Asphalt  result.Material == .Material.Concrete) 
			
			 isClear = 
			 angle = , ,  
				 rad = .(angle)
				 dir = .(.(rad), , .(rad))
				 checkResult = :(newPos, dir * , raycastParams)
				 checkResult  checkResult.Distance <  
					isClear = 
					
				
			
			 isClear 
				 result.Position
			
		
		attempts += 
	
	 



  ()
	 vehicle = ()
	  vehicle   
	 currentPos = vehicle.Position

	  currentWaypoint  (currentPos - currentWaypoint).Magnitude <  
		 newWaypoint = (currentPos)
		 newWaypoint 
			currentWaypoint = newWaypoint
			waypoints = (currentPos, currentWaypoint)  {}
		
			
			waypoints = {}
		
	



  ()
	 character = player.Character
	  character   ,  
	 root = character:()
	  root   ,  

	 vehicle = ()
	 velocity = vehicle  vehicle.AssemblyLinearVelocity.Magnitude  
	 origin = root.Position
	 forward = root.CFrame.LookVector
	 right = root.CFrame.RightVector
	 upOffsets = {, , , } 

	 maxDist = .(velocity * , , )
	 rayDirs = {}

	
	 angleStep = velocity >     
	 angle = -, , angleStep 
		 rad = .(angle)
		 _, up  (upOffsets) 
			 dir = .(.(, , ), rad) * forward
			 finalDir = (dir + .(, up / maxDist, )).Unit
			.(rayDirs, {dir = finalDir, angle = rad})
		
	

	 params = ()
	 avoidanceVector = .(, , )
	 totalWeight = 

	 futureOffset = forward * velocity * 
	 predictedOrigin = origin + futureOffset

	
	 surfaceWeight = 
	 groundResult = :(predictedOrigin + .(, , ), .(, -, ), params)
	 groundResult 
		 groundResult.Material == .Material.Asphalt  groundResult.Material == .Material.Concrete 
			surfaceWeight = asphaltBias
		 groundResult.Material == .Material.Grass 
			surfaceWeight = 
			maxSpeed = 
		 groundResult.Material == .Material.Sand 
			surfaceWeight = 
			maxSpeed = 
		
	

	 _, ray  (rayDirs) 
		 result = :(predictedOrigin, ray.dir * maxDist, params)
		 result 
			 distanceFactor = (maxDist - result.Distance) / maxDist
			 weight = distanceFactor ^  * surfaceWeight 

			 .(.(ray.angle)) <  
				weight = weight *  
			

			avoidanceVector = avoidanceVector - ray.dir * weight
			totalWeight = totalWeight + weight
		
	

	
	 waypoints  #waypoints >  
		 nextPoint = waypoints[].Position
		 toWaypoint = (nextPoint - origin).Unit
		 distanceToWaypoint = (nextPoint - origin).Magnitude
		 waypointWeight = .( / distanceToWaypoint, , )
		avoidanceVector = avoidanceVector + toWaypoint * waypointWeight
		totalWeight = totalWeight + waypointWeight
	

	 totalWeight >  
		avoidanceVector = avoidanceVector / totalWeight
	

	avoidanceVector = .(avoidanceVector.X, , avoidanceVector.Z)
	 mag = avoidanceVector.Magnitude

	 mag <  
		lastSteerDir = 
		 , 
	

	 steerDot = avoidanceVector.Unit:(right)
	 steerDir = steerDot >     
	 steerPower = .(mag * , , )

	
	 proposedDir = steerDir ==   right  -right
	 secondaryDist = maxDist * 
	 secondaryResult = :(origin, proposedDir * secondaryDist, params)
	 secondaryResult  secondaryResult.Distance < secondaryDist *  
		steerPower = steerPower * 
		 secondaryResult.Distance < secondaryDist *  
			steerDir = steerDir ==     
		
	

	
	 lastSteerDir  lastSteerDir ~= steerDir 
		 () - hysteresisTimer < hysteresisCooldown 
			steerDir = lastSteerDir
			steerPower = steerPower * 
		
			lastSteerDir = steerDir
			hysteresisTimer = ()
		
	

	
	 lastSteerDir == steerDir 
		steerPower = steerPower * ( - steerSmoothing) + (heldKeys[steerDir]  ) * steerSmoothing
	

	lastSteerDir = steerDir
	 steerDir, steerPower



  ()
	 spamEnabled 
		()
		 steerDir, steerIntensity = ()

		
		 throttle = maxSpeed
		 steerDir  steerIntensity >  
			throttle = .(maxSpeed * ( - steerIntensity), minSpeed, maxSpeed)
		

		(, throttle)

		
		 steerDir 
			(steerDir, steerIntensity)
			 oppositeDir = steerDir ==     
			(oppositeDir)
		
			()
			()
		

		
		 vehicle = ()
		 vehicle 
			 currentPos = vehicle.Position
			 lastPos  (currentPos - lastPos).Magnitude <  
				stuckTimer += 
			
				stuckTimer = 
				stuckStage = 
			
			lastPos = currentPos

			 stuckTimer >  
				 stuckStage ==  
					
					(, )
					.()
					()
					stuckStage = 
				 stuckStage ==  
					
					(, )
					(.() >     , )
					.()
					()
					()
					()
					stuckStage = 
				
					
					waypoints = {}
					currentWaypoint = 
					stuckTimer = 
					stuckStage = 
				
			
		

		
		  =  - steerIntensity * 
		.(.(, , ))
	

	()



 connection
connection = UserInputService.InputBegan:((input, gameProcessed)
	 gameProcessed   
	 input.KeyCode == .KeyCode.Z 
		spamEnabled =  spamEnabled
		 spamEnabled 
			spamThread = .(steerVehicle)
		
	 input.KeyCode == .KeyCode.X 
		spamEnabled = 
		 connection  connection:() 
		()
		thisScript:()
	
)