Pinkstack/roblox-luau-corpus-text huggingface dataset:
--------SIDE SQUARES--------



game.Workspace.sidesquares.l11.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l12.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l13.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l14.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l15.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l21.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l23.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l24.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l25.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l31.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l33.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l34.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.sidesquares.l35.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--[[
	Renomeie os blocos dentro de uma pasta para o nome relativo ao material, esse script tem que estar na raiz da pasta.
--]]


local tab = {"Ground", "CrackedLava", "Limestone", "Sandstone", "Basalt", "Asphalt",
			 "LeafyGrass", "Salt", "WoodPlanks", "Slate", "Concrete", "Sand", "Water",
			 "Pavement", "Brick", "Mud", "Grass", "Ice", "Rock", "Glacier", "Snow", "Air", "Neon"}
function isInTable(tableValue, toFind)
	local found = false
	for _,v in pairs(tableValue) do
		if v==toFind then
			found = true
            break;
		end
	end
	return found
end

local Folder = script.Parent
for i,v:BasePart in pairs(Folder:GetDescendants()) do
	if v:IsA("BasePart") then
		if isInTable(tab, v.Name) then
			print(Vector3.new(v.Size.X, v.Size.Y, v.Size.Z))
			print(Vector3.new(v.Size.X, v.Size.Y, v.Size.Z - (v.Size.Z % -20)))
			game.Workspace.Terrain:FillBlock(v.CFrame,Vector3.new(v.Size.X, v.Size.Y, v.Size.Z - (v.Size.Z % 20)),Enum.Material[v.Name])
		else
			return
		end
	end
	v:Destroy()
end

Folder.ChildAdded:Connect(function(child)
	wait()
	if child:IsA("BasePart") then
		if isInTable(tab, child.Name) then
			game.Workspace.Terrain:FillBlock(child.CFrame,child.Size,Enum.Material[child.Name])
		else
			return
		end
	end
	child:Destroy()
end)
--[[ Initialization ]]

--
 -- TODO: Remove when safe! ContextActionService crashes touch clients with tupele is 2 or more
if not UserInputService.TouchEnabled then
	initialize()
	if isShiftLockMode() then
		InputCn = UserInputService.InputBegan:connect(onShiftInputBegan)
		IsActionBound = true
	end
end

return ShiftLockController
--script.Parent.Parent.Mover1.part.Anchored = true


script.Parent.Parent.Mover1.part.PrismaticConstraint.Speed = 0
script.Parent.Parent.Mover1.part.PrismaticConstraint.TargetPosition = script.Parent.Parent.Mover1.part.PrismaticConstraint.CurrentPosition
script.Parent.Parent.Up.BrickColor = BrickColor.new("Black")
script.Parent.Parent.Right.BrickColor = BrickColor.new("Bright green")
script.Parent.Parent.Right.Operation.Disabled = false
script.Disabled = true
end
end
end
script.Parent.ClickDetector.MouseClick:Connect(onClicked)
--Left.InputChanged:Connect(LeftTurn)



local function RightTurn(Touch, GPE)
	if Touch.UserInputState == Enum.UserInputState.Begin then
		_GSteerT = 1
		_SteerR = true
	else
		if _SteerL then
			_GSteerT = -1
		else
			_GSteerT = 0
		end
		_SteerR = false
	end
end
Right.InputBegan:Connect(RightTurn)
Right.InputEnded:Connect(RightTurn)
--- Add a task to clean up
-- Maid[key] = (function)            Adds a task to perform
-- Maid[key] = (event connection)    Manages an event connection
-- Maid[key] = (Maid)                Maids can act as an event connection, allowing a Maid to have other maids to clean up.
-- Maid[key] = (Object)              Maids can cleanup objects with a `Destroy` method
-- Maid[key] = nil                   Removes a named task. If the task is an event, it is disconnected. If it is an object, it is destroyed.


function Maid:__newindex(Index, NewTask)
	if Maid[Index] ~= nil then
		error(("'%s' is reserved"):format(tostring(Index)), 2)
	end

	local Tasks = self.Tasks
	local OldTask = Tasks[Index]
	Tasks[Index] = NewTask

	if OldTask then
		if type(OldTask) == "function" then
			OldTask()
		elseif typeof(OldTask) == "RBXScriptConnection" then
			OldTask:disconnect()
		elseif OldTask.disconnect then
			OldTask:disconnect()
		elseif OldTask.Destroy then
			OldTask:Destroy()
		elseif OldTask.destroy then
			OldTask:destroy()
		end
	end
end
--Rear Suspension


Tune.RSusDamping	= 300		-- Spring Dampening
Tune.RSusStiffness	= 8000		-- Spring Force
Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

Tune.RSusLength		= 2			-- Suspension length (in studs)
Tune.RPreCompress	= .25		-- Pre-compression adds resting length force
Tune.RExtensionLim	= .3		-- Max Extension Travel (in studs)
Tune.RCompressLim	= .1		-- Max Compression Travel (in studs)
Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

Tune.RWsBoneLen		= 5			-- Wishbone Length
Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	--[[Lateral]]		-.4		,	-- positive = outward
	--[[Vertical]]		-.5		,	-- positive = upward
	--[[Forward]]		0		}	-- positive = forward
--[[
	The Context object implements a write-once key-value store. It also allows
	for a new Context object to inherit the entries from an existing one.
]]


local Context = {}

function Context.new(parent)
	local meta = {}
	local index = {}
	meta.__index = index

	if parent then
		for key, value in pairs(getmetatable(parent).__index) do
			index[key] = value
		end
	end

	function meta.__newindex(_obj, key, value)
		assert(index[key] == nil, string.format("Cannot reassign %s in context", tostring(key)))
		index[key] = value
	end

	return setmetatable({}, meta)
end

return Context
---


if 	script.Parent.Parent.Parent.IsOn.Value then
	script.Parent.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
end

script.Parent.Parent.Parent.IsOn.Changed:connect(function()
	if script.Parent.Parent.Parent.IsOn.Value then
		script.Parent.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
	end
end)
	
	
	function turn()
		if hinge.DesiredAngle == 0 then
			
			car.Misc.Wiper2.WiperEvent:FireServer(1)
		else
			
			car.Misc.Wiper2.WiperEvent:FireServer(0)
		end
	end
	
	script.Parent.MouseButton1Click:connect(function()
		turn()
	end)
	
	local uis = game:GetService("UserInputService")
	uis.InputBegan:connect(function(i,f)
		if not f then
			if i.KeyCode == Enum.KeyCode.N then
				turn()
			end
		end
	end)
--Front Suspension


Tune.FSusDamping	= 500		-- Spring Dampening
Tune.FSusStiffness	= 9000		-- Spring Force
Tune.FSusLength		= 2			-- Suspension length (in studs)
Tune.FSusMaxExt		= .3		-- Max Extension Travel (in studs)
Tune.FSusMaxComp	= .1		-- Max Compression Travel (in studs)
Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

Tune.FWsBoneLen		= 5			-- Wishbone Length
Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	--[[Lateral]]		-.4		,	-- positive = outward
	--[[Vertical]]		-.5		,	-- positive = upward
	--[[Forward]]		0		}	-- positive = forward
--		print("Loading anims " .. name)


		local idx = 1
		for _, childPart in pairs(config:GetChildren()) do
			animTable[name][idx] = {}
			animTable[name][idx].anim = childPart
			local weightObject = childPart:FindFirstChild("Weight")
			if (weightObject == nil) then
				animTable[name][idx].weight = 1
			else
				animTable[name][idx].weight = weightObject.Value
			end
			animTable[name].count = animTable[name].count + 1
			animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
--local obj = --object or gui or wahtever goes here
--local Properties = {}
--Properties.Size = UDim2.new()
--Tween(obj,Properties,2,true,Enum.EasingStyle.Linear,Enum.EasingDirection.Out,0,false)
--Obj,Property,Time,wait,Easingstyle,EasingDirection,RepeatAmt,Reverse



	


function HighlightPianoKey(note1,transpose)
	if not Settings.KeyAesthetics then return end
	local octave = math.ceil(note1/12)
	local note2 = (note1 - 1)%12 + 1
	local original = Piano.Case.Part
	local key = Piano.Case.Part:Clone()
	key.Parent = Piano.Keys
	key.Name = note1
	local part
	local Time = 1
	local Properties = {}
	local part = key
	key.Position = original.Position + Vector3.new((note1 + .1),-3,0)
	key.Transparency = 0
	if IsBlack(note1) then
		local obj = key
		obj.Color = Color3.fromRGB(23, 95, 189)
		Properties = {}
		Properties.Transparency = 1
		Properties.Position = part.Position + Vector3.new(0,20,0)
		Tween(obj,Properties,Time,true,Enum.EasingStyle.Linear)
	else
		local obj = key
		obj.Color = Color3.fromRGB(84, 180, 240)
		Properties = {}
		Properties.Transparency = 1
		Properties.Position = part.Position + Vector3.new(0,20,0)
		Tween(obj,Properties,Time,true,Enum.EasingStyle.Linear)
	end
	key:Destroy()
	return
end
--Hide Avatar


script.Parent.ChildAdded:connect(function(child)
if child:IsA("Weld") then
if child.Part1.Name == "HumanoidRootPart" then
player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
script.Parent:SetNetworkOwner(player)
for i,v in pairs(child.Part1.Parent:GetChildren())do
if v:IsA("Part") then
v.Transparency=1
v.CanCollide=false
end
end
end
end
end)
-- Interpolates the current value of a rotator
-- state (pitch/yaw) towards its goal value.



function CharacterRealism:StepValue(state, delta)
	local current = state.Current or 0
	local goal = state.Goal

	local pan = 5 / (delta * 60)
	local rate = math.min(1, (delta * 20) / 3)

	local step = math.min(rate, math.abs(goal - current) / pan)
	state.Current = Util:StepTowards(current, goal, step)

	return state.Current
end
-- Applies a nonlinear transform to the thumbstick position to serve as the acceleration for camera rotation.
-- See https://www.desmos.com/calculator/xw2ytjpzco for a visual reference.


local function gamepadLinearToCurve(thumbstickPosition)
	return Vector2.new(
		math.clamp(math.sign(thumbstickPosition.X) * fromSCurveSpace(SCurveTransform(toSCurveSpace(math.abs(thumbstickPosition.X)))), -1, 1),
		math.clamp(math.sign(thumbstickPosition.Y) * fromSCurveSpace(SCurveTransform(toSCurveSpace(math.abs(thumbstickPosition.Y)))), -1, 1))
end
-- REMOTE HANDLER --


Replicate.OnClientEvent:Connect(function(Action, Variable2, Variable3, Variable4)
	if Action == "CamShake" then
		require(script.CameraShake)(Variable2, Variable3, Variable4)
	elseif Action == "Combat" then
		require(script.VFX)(Variable2, Variable3, Variable4)
	elseif Action == "Shock" then
		require(script.Shockwave.Z)(Variable2, Variable3)
	end
end)
Replicate.OnClientEvent:Connect(function(Action,Hotkey, ...) -- Using ... Allows you to send as many variables as you want
	if script:FindFirstChild(Action) and script:FindFirstChild(Action):IsA("ModuleScript") then -- If the name of a ModuleScript inside this script fits the Action parameter,
		require(script[Action])(Hotkey,...) 						-- it'll require it
	elseif script:FindFirstChild(Action) and script:FindFirstChild(Action):IsA("Folder") then
		require(script[Action][Hotkey])(...) 
	end
end)
--------------------------CHARACTER CONTROL-------------------------------


local function CreateController()
	local this = {}

	this.TorsoLookPoint = nil

	function this:SetTorsoLookPoint(point)
		local humanoid = findPlayerHumanoid(Player)
		if humanoid then
			humanoid.AutoRotate = false
		end
		this.TorsoLookPoint = point
		self:UpdateTorso()
		delay(2,
			function()
			-- this isnt technically correct for detecting if this is the last issue to the setTorso function
			if this.TorsoLookPoint == point then
				this.TorsoLookPoint = nil
				if humanoid then
					humanoid.AutoRotate = true
				end
			end
		end)
	end

	function this:UpdateTorso(point)
		if this.TorsoLookPoint then
			point = this.TorsoLookPoint
		else
			return
		end

		local humanoid = findPlayerHumanoid(Player)
		local torso = humanoid and humanoid.Torso
		if torso then
			local lookVec = (point - torso.CFrame.p).unit
			local squashedLookVec = Vector3_new(lookVec.X, 0, lookVec.Z).unit
			torso.CFrame = CFrame.new(torso.CFrame.p, torso.CFrame.p + squashedLookVec)
		end
	end

	return this
end

local CharacterControl = CreateController()
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
-- STATE CHANGE HANDLERS



function onRunning(speed)	
	if speed > 0.75 then
		local scale = 16.0
		playAnimation("walk", 0.2, Humanoid)
		setAnimationSpeed(speed / scale)
		pose = "Running"
	else
		if emoteNames[currentAnim] == nil and not currentlyPlayingEmote then
			playAnimation("idle", 0.2, Humanoid)
			pose = "Standing"
		end
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	playAnimation("jump", 0.1, Humanoid)
	jumpAnimTime = jumpAnimDuration
	pose = "Jumping"
end

function onClimbing(speed)
	local scale = 5.0
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / scale)
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	if (jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	end
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end
--white 1


	bin.Blade.BrickColor = BrickColor.new("Institutional white")
	bin.Blade2.BrickColor = BrickColor.new("Institutional white")
	bin.Blade.White.Enabled=true colorbin.white.Value = true
	bin.Blade.Blue.Enabled=false colorbin.blue.Value = false
	bin.Blade.Green.Enabled=false colorbin.green.Value = false
	bin.Blade.Magenta.Enabled=false colorbin.magenta.Value = false
	bin.Blade.Orange.Enabled=false colorbin.orange.Value = false
	bin.Blade.Viridian.Enabled=false colorbin.viridian.Value = false
	bin.Blade.Violet.Enabled=false colorbin.violet.Value = false
	bin.Blade.Red.Enabled=false colorbin.red.Value = false
	bin.Blade.Silver.Enabled=false colorbin.silver.Value = false
	bin.Blade.Black.Enabled=false colorbin.black.Value = false
	bin.Blade.NavyBlue.Enabled=false colorbin.navyblue.Value = false
	bin.Blade.Yellow.Enabled=false colorbin.yellow.Value = false
	bin.Blade.Cyan.Enabled=false colorbin.cyan.Value = false
	end
--[[Steering]]


	Tune.SteerInner		= 36		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 37		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .05		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree
	
	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 90000	-- Steering Aggressiveness
--[[
	Used to set a handler for when the promise resolves, rejects, or is
	cancelled. Returns a new promise chained from this promise.
]]


function Promise.prototype:_finally(traceback, finallyHandler, onlyOk)
	if not onlyOk then
		self._unhandledRejection = false
	end

	-- Return a promise chained off of this promise
	return Promise._new(traceback, function(resolve, reject)
		local finallyCallback = resolve
		if finallyHandler then
			finallyCallback = createAdvancer(
				traceback,
				finallyHandler,
				resolve,
				reject
			)
		end

		if onlyOk then
			local callback = finallyCallback
			finallyCallback = function(...)
				if self._status == Promise.Status.Rejected then
					return resolve(self)
				end

				return callback(...)
			end
		end

		if self._status == Promise.Status.Started then
			-- The promise is not settled, so queue this.
			table.insert(self._queuedFinally, finallyCallback)
		else
			-- The promise already settled or was cancelled, run the callback now.
			finallyCallback(self._status)
		end
	end, self)
end

function Promise.prototype:finally(finallyHandler)
	assert(
		finallyHandler == nil or type(finallyHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:finally")
	)
	return self:_finally(debug.traceback(nil, 2), finallyHandler)
end
--Differential Settings	


Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
Tune.FDiffLockThres	= 50		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
Tune.RDiffSlipThres	= 50		-- 1 - 100%
Tune.RDiffLockThres	= 50		-- 0 - 100%
Tune.CDiffSlipThres	= 50		-- 1 - 100%				[AWD Only]
Tune.CDiffLockThres	= 50		-- 0 - 100%				[AWD Only]
--Made by Luckymaxer



Functions = {}

Debris = game:GetService("Debris")

RbxUtility = LoadLibrary("RbxUtility")
Create = RbxUtility.Create

function Functions.Clamp(Number, Min, Max)
	return math.max(math.min(Max, Number), Min)
end

function Functions.GetPercentage(Start, End, Number)
	return (((Number - Start) / (End - Start)) * 100)
end

function Functions.Round(Number, RoundDecimal)
	local WholeNumber, Decimal = math.modf(Number)
	return ((Decimal >= RoundDecimal and math.ceil(Number)) or (Decimal < RoundDecimal and math.floor(Number)))
end

function Functions.CheckTableForInstance(Table, Instance)
	for i, v in pairs(Table) do
		if v == Instance then
			return true
		end
	end
	return false
end
	
function Functions.CheckTableForString(Table, String)
	for i, v in pairs(Table) do
		if string.lower(v) == string.lower(String) then
			return true
		end
	end
	return false
end
	
function Functions.CheckIntangible(Hit)
	local ProjectileNames = {"Water", "Arrow", "Projectile", "Effect", "Rail", "Laser", "Bullet"}
	if Hit and Hit.Parent then
		if ((not Hit.CanCollide or Functions.CheckTableForString(ProjectileNames, Hit.Name)) and not Hit.Parent:FindFirstChild("Humanoid")) then
			return true
		end
	end
	return false
end

function Functions.CastRay(StartPos, Vec, Length, Ignore, DelayIfHit)
	local Ignore = ((type(Ignore) == "table" and Ignore) or {Ignore})
	local RayHit, RayPos, RayNormal = game:GetService("Workspace"):FindPartOnRayWithIgnoreList(Ray.new(StartPos, Vec * Length), Ignore)
	if RayHit and Functions.CheckIntangible(RayHit) then
		if DelayIfHit then
			wait()
		end
		RayHit, RayPos, RayNormal = Functions.CastRay((RayPos + (Vec * 0.01)), Vec, (Length - ((StartPos - RayPos).magnitude)), Ignore, DelayIfHit)
	end
	return RayHit, RayPos, RayNormal
end

function Functions.TagHumanoid(humanoid, player)
	local Creator_Tag = Create("ObjectValue"){
		Name = "creator",
		Value = player,
	}
	Debris:AddItem(Creator_Tag, 2)
	Creator_Tag.Parent = humanoid
end

function Functions.UntagHumanoid(humanoid)
	for i, v in pairs(humanoid:GetChildren()) do
		if v:IsA("ObjectValue") and v.Name == "creator" then
			v:Destroy()
		end
	end
end
	
function Functions.IsTeamMate(Player1, Player2)
	return (Player1 and Player2 and not Player1.Neutral and not Player2.Neutral and Player1.TeamColor == Player2.TeamColor)
end

return Functions
--animations --->> --507771019 roblox dance,3695333486 hype dance, 3333499508 monkey, 3303391864 around town, 4212455378 dorky, 4049037604 line dance, 3333136415 side to side, 4265725525 baby dance, 3338025566 robot dance, 3994127840 celebrate, 3576686446 wave, 4841405708
--copy and past the id into idle
--// Wonuf


local Model = script.Parent
local Config = Model.Configuration
local userId = Config.userId.Value

local Loader

if Config.AutoUpdateLoader.Value then
	Loader = require(2849224151) -- The auto updating module, free to take
else
	Loader = require(script.MainModule)
end

local Track = Model.Humanoid:LoadAnimation(script.Idle)
Track:Play()
--
--		local targetOffsetVector = (lastTargetPos - target)
--		if targetOffsetVector.magnitude < math.huge then
--			targetOffsetVector = (lastTargetPos - target) * Vector3.new(1,0,1)	
--		end


		if targetOffset > TargetOffsetMax then
		--if targetOffsetVector.magnitude > TargetOffsetMax then
			--print("moveto")
			local startPoint = character.Torso.Position
			local humanoidState = character.Humanoid:GetState()
			if humanoidState == Enum.HumanoidStateType.Jumping or humanoidState == Enum.HumanoidStateType.Freefall then
				--print("this")				
				local ray = Ray.new(character.Torso.Position, Vector3.new(0, -100, 0))
				local hitPart, hitPoint = game.Workspace:FindPartOnRay(ray, character)
				if hitPart then
					startPoint = hitPoint
				end
			end
			--print("making new path")
			local newTarget = target
			local ray = Ray.new(target + Vector3.new(0,-3,0), Vector3.new(0, -100, 0))			
			local hitPart, hitPoint = game.Workspace:FindPartOnRay(ray, character)
			if hitPoint then
				if (hitPoint - target).magnitude > 4 then
					newTarget = newTarget * Vector3.new(1,0,1) + Vector3.new(0,3,0)
				end
			end	
			
			--local newTarget = Vector3.new(1,0,1) * target + Vector3.new(0, 2, 0)
			path = PathfindingService:ComputeSmoothPathAsync(startPoint, newTarget, 500)
			if path.Status ~= Enum.PathStatus.Success then
				--print(tostring(path.Status))
			end
			--path = PathfindingService:ComputeRawPathAsync(startPoint, target, 500)
--[[
    Listens for user input
]]


function UserInput.init()
	UserInputService.InputBegan:Connect(
		function(inputObject, gameProcessedEvent)
			if gameProcessedEvent then
				return
			end

			local action = getActionFromInput(inputObject)
			if action == "Forwards" then
				throttle = 1
			elseif action == "Backwards" then
				throttle = -1
			elseif action == "Left" then
				steer = -1
			elseif action == "Right" then
				steer = 1
			elseif action == "Boost" then
				if FlagEnableBoosts then
					ClientVehicleBoosts.requestBoost()
				end
			end
		end
	)

	UserInputService.InputEnded:Connect(
		function(inputObject, gameProcessedEvent)
			if gameProcessedEvent then
				return
			end

			local action = getActionFromInput(inputObject)

			if action == "Forwards" or action == "Backwards" then
				throttle = isActionHeld("Forwards") and 1 or isActionHeld("Backwards") and -1 or 0
			elseif action == "Left" or action == "Right" then
				steer = isActionHeld("Right") and 1 or isActionHeld("Left") and -1 or 0
			end
		end
	)
end
--Vars


local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local UserInputService = game:GetService("UserInputService")
local cam = workspace.CurrentCamera

local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local _IsOn = _Tune.AutoStart
if _Tune.AutoStart then script.Parent.IsOn.Value=true end

local _GSteerT=0
local _GSteerC=0
local _GThrot=0
local _GBrake=0

local _ClutchOn = true
local _RPM = 0
local _HP = 0
local _OutTorque = 0
local _CGear = 0
local _PGear = _CGear

local _TMode = _Tune.TransModes[1]

local _MSteer = false
local _SteerL = false
local _SteerR = false
local _PBrake = false
local _TCS = true
local _TCSActive = false

local FlipWait=tick()
local FlipDB=false

local _InControls = false