Roblox/luau_corpus huggingface dataset:
------------------------------------------------------------------------

local PlayerState = {} do
	local mouseBehavior
	local mouseIconEnabled
	local cameraType
	local cameraFocus
	local cameraCFrame
	local cameraFieldOfView
	local screenGuis = {}
	local coreGuis = {
		Backpack = true,
		Chat = true,
		Health = true,
		PlayerList = true,
	}
	local setCores = {
		BadgesNotificationsActive = true,
		PointsNotificationsActive = true,
	}

	-- Save state and set up for freecam
	function PlayerState.Push()
		for name in pairs(coreGuis) do
			coreGuis[name] = StarterGui:GetCoreGuiEnabled(Enum.CoreGuiType[name])
			StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType[name], false)
		end
		for name in pairs(setCores) do
			setCores[name] = StarterGui:GetCore(name)
			StarterGui:SetCore(name, false)
		end
		local playergui = LocalPlayer:FindFirstChildOfClass("PlayerGui")
		if playergui then
			for _, gui in pairs(playergui:GetChildren()) do
				if gui:IsA("ScreenGui") and gui.Enabled then
					screenGuis[#screenGuis + 1] = gui
					gui.Enabled = false
				end
			end
		end

		cameraFieldOfView = Camera.FieldOfView
		Camera.FieldOfView = 70

		cameraType = Camera.CameraType
		Camera.CameraType = Enum.CameraType.Custom

		cameraCFrame = Camera.CFrame
		cameraFocus = Camera.Focus

		mouseIconEnabled = UserInputService.MouseIconEnabled
		UserInputService.MouseIconEnabled = false

		mouseBehavior = UserInputService.MouseBehavior
		UserInputService.MouseBehavior = Enum.MouseBehavior.Default
	end

	-- Restore state
	function PlayerState.Pop()
		for name, isEnabled in pairs(coreGuis) do
			StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType[name], isEnabled)
		end
		for name, isEnabled in pairs(setCores) do
			StarterGui:SetCore(name, isEnabled)
		end
		for _, gui in pairs(screenGuis) do
			if gui.Parent then
				gui.Enabled = true
			end
		end

		Camera.FieldOfView = cameraFieldOfView
		cameraFieldOfView = nil

		Camera.CameraType = cameraType
		cameraType = nil

		Camera.CFrame = cameraCFrame
		cameraCFrame = nil

		Camera.Focus = cameraFocus
		cameraFocus = nil

		UserInputService.MouseIconEnabled = mouseIconEnabled
		mouseIconEnabled = nil

		UserInputService.MouseBehavior = mouseBehavior
		mouseBehavior = nil
	end
end

local function StartFreecam()
	local cameraCFrame = Camera.CFrame
	cameraRot = Vector2.new(cameraCFrame:toEulerAnglesYXZ())
	cameraPos = cameraCFrame.p
	cameraFov = Camera.FieldOfView

	velSpring:Reset(Vector3.new())
	panSpring:Reset(Vector2.new())
	fovSpring:Reset(0)

	PlayerState.Push()
	RunService:BindToRenderStep("Freecam", Enum.RenderPriority.Camera.Value, StepFreecam)
	Input.StartCapture()
end

local function StopFreecam()
	Input.StopCapture()
	RunService:UnbindFromRenderStep("Freecam")
	PlayerState.Pop()
end
--[[ Constants ]]--
local ZERO_VECTOR3 = Vector3.new(0,0,0)
--- Sets the text in the command bar text box, and captures focus
function Window:SetEntryText(text)
	Entry.TextBox.Text = text

	if self:IsVisible() then
		Entry.TextBox:CaptureFocus()
		Entry.TextBox.CursorPosition = #text + 1
	end
end
-- Interaction GUIs prompting user input
local InteractionButton = InteractionGui:WaitForChild("InteractionButton")
-- A state object which follows another state object using tweens.
export type Tween<T> = StateObject<T> & Dependent & {
	-- kind: "Tween" (add this when Luau supports singleton types)
}
--// Vars

local plr = game.Players.LocalPlayer
	local char = plr.Character
	local hum = char.Humanoid

local cam = game.Workspace.CurrentCamera

local seat = script:WaitForChild("VehicleSeat").Value
	local BAV = seat.BodyAngularVelocity
	local BV = seat.BodyVelocity

local Storage = seat.Parent.Parent.TankEvents
	
	local idleSound = seat.idleSound
	Storage.Sound:FireServer(idleSound, true)
	local runSound = seat.runSound

local Settings = require(seat.Parent.Parent.Settings)

local Equipped = true

local car = seat.Parent

local rs = game:GetService("RunService")
	rst = rs.RenderStepped
local uis = game:GetService("UserInputService")
	local ib = uis.InputBegan
	local ie = uis.InputEnded
	local jr = uis.JumpRequest

local ForwardKeyDown
local BackwardKeyDown
local RightTurnKeyDown
local LeftTurnKeyDown

local speed = 0
local maxSpeed = 18
-- ROBLOX deviation: omitted isPrimitive import
local jasmineUtils = require(CurrentModule.jasmineUtils)
local equals = jasmineUtils.equals
-- dayLength defines how long, in minutes, a day in your game is. Feel free to alter it.
local dayLength = 7

local cycleTime = dayLength*60
local minutesInADay = 24*60

local lighting = game:GetService("Lighting")

local startTime = tick() - (lighting:getMinutesAfterMidnight() / minutesInADay)*cycleTime
local endTime = startTime + cycleTime

local timeRatio = minutesInADay / cycleTime

if dayLength == 0 then
	dayLength = 1
end

repeat
	local currentTime = tick()
	
	if currentTime > endTime then
		startTime = endTime
		endTime = startTime + cycleTime
	end
	
	lighting:setMinutesAfterMidnight((currentTime - startTime)*timeRatio)
	wait(1/15)
until false
-- The maximum distance the can can shoot, this value should never go above 1000
local Range = 200
--// Bullet Physics
	BulletPhysics = Vector3.new(0,45,0); -- Drop fixation: Lower number = more drop
	BulletSpeed = 2000; -- Bullet Speed
	
	ExploPhysics = Vector3.new(0,20,0); -- Drop for explosive rounds
	ExploSpeed = 600; -- Speed for explosive rounds
-- Functional Services
uis = game:GetService("UserInputService")
rs = game:GetService("RunService")
tween = game:GetService("TweenService")
--Made by Haustier and Luckymaxer
local humanoid = script.Parent.Humanoid
local head = script.Parent.Head
local walkDistance = 20 --radius
local detectionDistance = 20

function walkBackAndForth()
	while wait() do
		local targetPos = head.CFrame * CFrame.new(0, 0, -walkDistance)
		targetPos = Vector3.new(targetPos.X, targetPos.Y, targetPos.Z)
		humanoid:MoveTo(targetPos)
		local counter = 0
		repeat
			wait()
			counter = counter + 1
			if counter >= 100 then
				break
			end
		until (head.Position - targetPos).magnitude <= 2
		walkDistance = -walkDistance
	end
end

walkBackAndForth()
--// SS3 controls for AC6 by Itzt, originally for 2014 Infiniti QX80. i don't know how to tune ac lol
 
wait(0.1)
local player = game.Players.LocalPlayer
local HUB = script.Parent.HUB
local HUB2 = script.Parent.HUB2
local limitButton = HUB.Name
local FE = game.Workspace.FilteringEnabled
local lightOn = false
local Camera = game.Workspace.CurrentCamera
local cam = script.Parent.nxtcam.Value
local carSeat = script.Parent.CarSeat.Value
local mouse = game.Players.LocalPlayer:GetMouse()
local windows = false
local handler = carSeat:WaitForChild('Filter')
local winfob = HUB.Parent.Music
local pal = false
local palpal = HUB.Parent.Palette
local red = 0
local green = 0
local blue = 1
local debounce = false

local scr = false


local st = false
--[[function GAReporter:sendPageView(...)
	assert(self.trackingId ~= "UA-00000000-00", "YOU HAVE NOT YET SET YOUR GOOGLE ANALYTICS TRACKING ID")
	-- look this up : https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters
end]]

return GAReporter
-- SETTINGS ----------------------------------
local timeToRespawn = 60
local allowDamage = true
--[[**
	ensures Roblox Color3 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Color3 = primitive("Color3")
-- functions

function onRunning(speed)
	if speed>0 then
		pose = "Running"
	else
		pose = "Standing"
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	pose = "Jumping"
end

function onClimbing()
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end

function moveJump()
	RightShoulder.MaxVelocity = 0.5
	LeftShoulder.MaxVelocity = 0.5
	RightShoulder.DesiredAngle = 3.14
	LeftShoulder.DesiredAngle = -3.14
	RightHip.DesiredAngle = 0
	LeftHip.DesiredAngle = 0
end
-- This is called when settings menu is opened
function BaseCamera:ResetInputStates()
	self.isRightMouseDown = false
	self.isMiddleMouseDown = false
	self:OnMousePanButtonReleased() -- this function doesn't seem to actually need parameters

	if UserInputService.TouchEnabled then
		--[[menu opening was causing serious touch issues
		this should disable all active touch events if
		they're active when menu opens.]]
		for inputObject in pairs(self.fingerTouches) do
			self.fingerTouches[inputObject] = nil
		end
		self.dynamicTouchInput = nil
		self.panBeginLook = nil
		self.startPos = nil
		self.lastPos = nil
		self.userPanningTheCamera = false
		self.startingDiff = nil
		self.pinchBeginZoom = nil
		self.numUnsunkTouches = 0
	end
end

function BaseCamera:GetGamepadPan(name, state, input)
	if input.UserInputType == self.activeGamepad and input.KeyCode == Enum.KeyCode.Thumbstick2 then
--- Creates raycast points using only vector3 values.
-- @param object BasePart or Bone, the part you want the points to be locally offset from
-- @param table of vector3 values that are in local space relative to the basePart or bone
-- @param optional group string parameter that names the group these points belong to
function Hitbox:SetPoints(object: BasePart | Bone, vectorPoints: {[number]: Vector3}, group: string?)
	for _: number, vector: Vector3 in ipairs(vectorPoints) do
		local point: Point = self:_CreatePoint(group, Hitbox.CastModes[object:IsA("Bone") and "Bone" or "Vector3"])

		point.Instances[1] = object
		point.Instances[2] = vector
		table.insert(self.HitboxRaycastPoints, point)
	end
end
--// UI Tween Info
local L_157_ = TweenInfo.new(
	1,
	Enum.EasingStyle.Sine,
	Enum.EasingDirection.Out,
	0,
	false,
	0
)

local L_158_ = {
	TextTransparency = 1
}
-- A symbol that represents the absence of a value.
export type None = PubTypes.Symbol & {
	-- name: "None" (add this when Luau supports singleton types)
}
-- main program

local nextTime = 0
local runService = game:service("RunService");

while Figure.Parent~=nil do
	time = runService.Stepped:wait()
	if time > nextTime then
		move(time)
		nextTime = time + 0.1
	end
end
-- / Animations / --
local SwingAnimation = script:WaitForChild("SwingAnimation")
-- Preload music tracks
AudioPlayerModule.preloadAudio({
	["Main_Background_Theme"] = 1836038596,
})
--[[
	Returns all ScreenGui objects shown that are not a part of this dev module

	Returns:
	An array of ScreenGuis that are Enabled
]]
function GuiController:_getOtherScreenGuis(): { ScreenGui }
	local otherScreenGuis = Cryo.List.filter(self.player.PlayerGui:GetDescendants(), function(instance)
		return instance:IsA("ScreenGui") and not self:_isModuleScreenGui(instance) and instance.Enabled
	end)

	return otherScreenGuis
end
-- Decompiled with the Synapse X Luau decompiler.

local v1 = require(game.ReplicatedStorage:WaitForChild("Resources"));
while not v1.Loaded do
	game:GetService("RunService").Heartbeat:Wait();
end;
v1.Network.Invoked("Get Pet Positions").OnInvoke = function(p1)
	local v2 = {};

		for v3, v4 in ipairs(p1) do
		if not v3 then
			break;
		end;
		local v6 = v1.Debris.Pets:FindFirstChild(v4);
		if v6 then
			v2[v4] = v6.CFrame.p;
		end;	
	end;
	return v2;
end;
-------------------------------------------------------------------------------------

Loader:updateModel(Model, Config.userId.Value)

if Config.AutoUpdateCharacter.Value then
	while wait(Config.AutoUpdateCharacter.Delay.Value) do
		Loader:updateModel(Model, Config.userId.Value)
	end
end
--> SERVICES
local TweenService = game:GetService("TweenService")
--Services
local ServerStorage = game:GetService("ServerStorage")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
--[[
	Provides various properties for cchecking if the user is interfacing with a
	keyboard, gamepad, or touch-enabled device.
]]

local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")

local Cryo = require(script.Parent.Parent.Packages.Cryo)
local Roact = require(script.Parent.Parent.Packages.Roact)
local ConfigurationContext = require(script.Parent.Parent.Libraries.Configuration).ConfigurationContext
local withConfiguration = ConfigurationContext.withConfiguration
local ExternalEventConnection = require(script.Parent.Parent.Components.ExternalEventConnection)

local Context = Roact.createContext({})

local InputContextProvider = Roact.Component:extend("InputContextProvider")

export type State = {
	isAppFocusedByGamepad: boolean,
	isUsingKeyboard: boolean,
	isUsingGamepad: boolean,
	isUsingTouch: boolean,
}

function InputContextProvider:init()
	self.selectedObjectTracker = Roact.createRef()

	local state: State = {
		isAppFocusedByGamepad = false,
		isUsingGamepad = false,
		isUsingKeyboard = false,
		isUsingTouch = false,
	}
	self.state = state

	self.onSelectedObjectChanged = function()
		local selectedObject = GuiService.SelectedObject
		local tracker = self.selectedObjectTracker:getValue()

		self:setState(function()
			if selectedObject and tracker then
				if selectedObject:IsDescendantOf(tracker.Parent) then
					return {
						isAppFocusedByGamepad = true,
					}
				end
			end

			return {
				isAppFocusedByGamepad = false,
			}
		end)
	end

	self.onInputTypeChanged = function(inputType: Enum.UserInputType)
		self:setState(function()
			if inputType.Name:match("^Gamepad%d") then
				return {
					isUsingGamepad = true,
					isUsingKeyboard = false,
					isUsingTouch = false,
				}
			elseif inputType == Enum.UserInputType.Touch then
				return {
					isUsingGamepad = false,
					isUsingKeyboard = false,
					isUsingTouch = true,
				}
			else
				return {
					isUsingGamepad = false,
					isUsingKeyboard = true,
					isUsingTouch = false,
				}
			end
		end)
	end
end

function InputContextProvider:render()
	return Roact.createFragment({
		SelectedObjectTracker = Roact.createElement("Folder", {
			[Roact.Ref] = self.selectedObjectTracker,
		}),

		SelectedObjectChanged = Roact.createElement(ExternalEventConnection, {
			event = GuiService:GetPropertyChangedSignal("SelectedObject"),
			callback = self.onSelectedObjectChanged,
		}),

		LastInputTypeChanged = Roact.createElement(ExternalEventConnection, {
			event = UserInputService.LastInputTypeChanged,
			callback = self.onInputTypeChanged,
		}),

		Provider = Roact.createElement(Context.Provider, {
			value = self.state,
		}, self.props[Roact.Children]),
	})
end

function InputContextProvider:didMount()
	self.onInputTypeChanged(UserInputService:GetLastInputType())
end

function InputContextProvider:didUpdate(prevProps)
	-- This is for stories so that if the various states are changed by a
	-- storybook control the provider rerenders.
	if self.props ~= prevProps then
		self:setState(self.props)
	end
end
-- ROBLOX deviation: omitted Chalk and DiffOptionsColor types
export type Chalk = any
--EDIT BELOW----------------------------------------------------------------------
settings.PianoSoundRange = 100

settings.KeyAesthetics = true

settings.PianoSounds = {
	"233836579", --C/C#
	"233844049", --D/D#
	"233845680", --E/F
	"233852841", --F#/G
	"233854135", --G#/A
	"233856105", --A#/B
}
-- PUBLIC
local Tracker = {}
Tracker.__index = Tracker
local trackers = {}
Tracker.trackers = trackers
Tracker.itemAdded = Signal.new()
Tracker.itemRemoved = Signal.new()
Tracker.bodyPartsToIgnore = {
	-- We ignore these due to their insignificance (e.g. we ignore the lower and
	-- upper torso because the HumanoidRootPart also covers these areas)
	-- This ultimately reduces the burden on the player region checks
	UpperTorso = true,
	LowerTorso = true,
	Torso = true,
	LeftHand = true,
	RightHand = true,
	LeftFoot = true,
	RightFoot = true,
}
--- Takes in raw command information and generates a command out of it.
-- text and executor are required arguments.
-- allowIncompleteData, when true, will ignore errors about arguments missing so we can parse live as the user types.
-- data is for special networked Data about the command gathered on the client. Purely Optional.
-- returns the command if successful, or (false, errorText) if not
function Dispatcher:Evaluate (text, executor, allowIncompleteArguments, data)
	if RunService:IsClient() == true and executor ~= Players.LocalPlayer then
		error("Can't evaluate a command that isn't sent by the local player.")
	end

	local arguments = Util.SplitString(text)
	local commandName = table.remove(arguments, 1)
	local commandObject = self.Registry:GetCommand(commandName)

	if commandObject then
		-- No need to continue splitting when there are no more arguments. We'll just mash any additional arguments into the last one.
		arguments = Util.MashExcessArguments(arguments, #commandObject.Args)

		-- Create the CommandContext and parse it.
		local command = Command.new({
			Dispatcher = self,
			Text = text,
			CommandObject = commandObject,
			Alias = commandName,
			Executor = executor,
			Arguments = arguments,
			Data = data
		})
		local success, errorText = command:Parse(allowIncompleteArguments)

		if success then
			return command
		else
			return false, errorText
		end
	else
		return false, "Invalid command. Use the help command to see all available commands."
	end
end
-- Input callback function compares items at indexes in the sequences.
type IsCommon = (
	number, -- caller can assume: 0 <= aIndex && aIndex < aLength
	number -- caller can assume: 0 <= bIndex && bIndex < bLength
) -> boolean
--[=[
	A class which holds data and methods for ScriptSignals.

	@class ScriptSignal
]=]
local ScriptSignal = {}
ScriptSignal.__index = ScriptSignal
-- first, define some variables to hold references to parts of the physics gun:
local gripPart = script.Parent
local beamPart = gripPart:WaitForChild("Beam")
local tipPart = beamPart:WaitForChild("Tip")
-- Create component
local ScopeHierarchyItemButton = Roact.PureComponent:extend 'ScopeHierarchyItemButton'
--[[
	Enters the view, cloning the element from ReplicatedStorage.
]]
function Spectating.enter()
	activeElements = elements:Clone()

	local spectatingElement = activeElements.SpectatingElement

	spectatingElement:FindFirstChild("Amount").Text = translate("SPECTATING")
	spectatingElement:FindFirstChild("Info").Text = translate("Click to change perspective")

	activeElements.Parent = LocalPlayer.PlayerGui

	startTime()
end
---------------------------------------------------

This = script.Parent
Lift = This.Parent.Parent.Parent
CustomLabel = require(This.Parent.Parent.Parent.CustomLabel)
Characters = require(script.Characters)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Lift:WaitForChild("Floor").Changed:connect(function(floor)
  --custom indicator code--
  ChangeFloor(tostring(floor))
end)

function ChangeFloor(SF)
	if CustomText[tonumber(SF)] then
		SF = CustomText[tonumber(SF)]
	end
	SetDisplay(1,(string.len(SF) == 2 and SF:sub(1,1) or "NIL"))		
	SetDisplay(2,(string.len(SF) == 2 and SF:sub(2,2) or SF))
end


function SetDisplay(ID,CHAR)
	if This.Display:FindFirstChild("Matrix"..ID) and Characters[CHAR] ~= nil then
 		for i,l in pairs(Characters[CHAR]) do 
			for r=1,5 do	
				This.Display["Matrix"..ID]["Row"..i]["D"..r].BrickColor = (l:sub(r,r) == "1" and BrickColor.new(ActiveCol) or BrickColor.new(InactiveCol))
				This.Display["Matrix"..ID]["Row"..i]["D"..r].Material = (l:sub(r,r) == "1" and "Neon" or "SmoothPlastic")
			end
		end
	end
end
-- Local player
local player = Players.LocalPlayer
local leaderstats = player:WaitForChild("CustomLeaderstats")

local displayValues = ReplicatedStorage:WaitForChild("DisplayValues")
local points = leaderstats:WaitForChild("Points")
-- ф-ция обработки нажатия клавиш на клавиатуре
local function onKeyPress(inputObject)
	if inputObject == "s" then -- если нажата клавиша "W"
		car:SetPrimaryPartCFrame(car:GetPrimaryPartCFrame() + car.PrimaryPart.CFrame.LookVector * speed) -- перемещаем машину вперед
	elseif inputObject == "w" then -- если нажата клавиша "S"
		car:SetPrimaryPartCFrame(car:GetPrimaryPartCFrame() - car.PrimaryPart.CFrame.LookVector * speed) -- перемещаем машину назад
	elseif inputObject == "a" then -- если нажата клавиша "A"
		car:SetPrimaryPartCFrame(car:GetPrimaryPartCFrame() * CFrame.Angles(0, -math.rad(10), 0)) -- поворачиваем машину влево
	elseif inputObject == "d" then -- если нажата клавиша "D"
		car:SetPrimaryPartCFrame(car:GetPrimaryPartCFrame() * CFrame.Angles(0, math.rad(10), 0)) -- поворачиваем машину вправо
	elseif inputObject == "e" then -- если нажата клавиша "Пробел"
		car:SetPrimaryPartCFrame(car:GetPrimaryPartCFrame()+Vector3.new(0,1,0)) -- увеличиваем высоту
	elseif inputObject=="q" then
		car:SetPrimaryPartCFrame(car:GetPrimaryPartCFrame()+Vector3.new(0,-1,0))
	end
end
script.Parent.Seat.ChildAdded:Connect(function(child)
	if child:IsA("Weld") then
		local humanoid = child.Part1.Parent:FindFirstChildOfClass("Humanoid") -- получаем объект Humanoid игрока
		if humanoid then -- если объект найден
			game.Players.LocalPlayer:GetMouse().KeyDown:Connect(onKeyPress)
		end
	end
end)
-- Arm the rocket and save the touch connection so we can disconnect it later
Connection = Rocket.Touched:connect(OnTouched)
----- Service Table -----

local ProfileService = {

	ServiceLocked = false, -- Set to true once the server is shutting down

	IssueSignal = Madwork.NewScriptSignal(), -- (error_message, profile_store_name, profile_key) -- Fired when a DataStore API call throws an error
	CorruptionSignal = Madwork.NewScriptSignal(), -- (profile_store_name, profile_key) -- Fired when DataStore key returns a value that has
	-- all or some of it's profile components set to invalid data types. E.g., accidentally setting Profile.Data to a noon table value

	CriticalState = false, -- Set to true while DataStore service is throwing too many errors
	CriticalStateSignal = Madwork.NewScriptSignal(), -- (is_critical_state) -- Fired when CriticalState is set to true
	-- (You may alert players with this, or set up analytics)

	ServiceIssueCount = 0,

	_active_profile_stores = {}, -- {profile_store, ...}

	_auto_save_list = {}, -- {profile, ...} -- loaded profile table which will be circularly auto-saved

	_issue_queue = {}, -- [table] {issue_time, ...}
	_critical_state_start = 0, -- [number] 0 = no critical state / os.clock() = critical state start

	-- Debug:
	_mock_data_store = {},
	_user_mock_data_store = {},

	_use_mock_data_store = false,

}
-- This file was @generated by Tarmac. It is not intended for manual editing.
return {
	ToolboxIcon = "rbxassetid://10216552848",
}
--[[Steering]]
	Tune.SteerInner		= 34		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 35		-- 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			= 100000	-- Steering Aggressiveness