Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- Checks for conditions for enabling/disabling the active controller and updates whether the active controller is enabled/disabled


function ControlModule:UpdateActiveControlModuleEnabled()
	-- helpers for disable/enable
	local disable = function() 
		self.activeController:Enable(false)

		if self.moveFunction then
			self.moveFunction(Players.LocalPlayer, Vector3.new(0,0,0), true)
		end
	end

	local enable = function()
		if self.activeControlModule == ClickToMove then
			-- For ClickToMove, when it is the player's choice, we also enable the full keyboard controls.
			-- When the developer is forcing click to move, the most keyboard controls (WASD) are not available, only jump.
			self.activeController:Enable(
				true,
				Players.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.UserChoice,
				self.touchJumpController
			)
		elseif self.touchControlFrame then
			self.activeController:Enable(true, self.touchControlFrame)
		else
			self.activeController:Enable(true)
		end
	end

	-- there is no active controller
	if not self.activeController then
		return
	end

	-- developer called ControlModule:Disable(), don't turn back on
	if not self.controlsEnabled then
		disable()
		return
	end

	-- GuiService.TouchControlsEnabled == false and the active controller is a touch controller, 
	-- disable controls
	if not GuiService.TouchControlsEnabled and UserInputService.TouchEnabled and 
			(self.activeControlModule == ClickToMove or self.activeControlModule == TouchThumbstick or 
			self.activeControlModule == DynamicThumbstick) then
		disable()
		return
	end

	-- no settings prevent enabling controls
	enable()
end

function ControlModule:Enable(enable: boolean?)
	if enable == nil then 
		enable = true 
	end
	self.controlsEnabled = enable

	if not self.activeController then
		return
	end
	
	self:UpdateActiveControlModuleEnabled()
end
--[=[
	Throttles execution of a functon. Does both leading, and following
	@class ThrottledFunction
]=]



local ThrottledFunction = {}
ThrottledFunction.ClassName = "ThrottledFunction"
ThrottledFunction.__index = ThrottledFunction

function ThrottledFunction.new(timeoutInSeconds, func, config)
	local self = setmetatable({}, ThrottledFunction)

	self._nextCallTimeStamp = 0
	self._timeout = timeoutInSeconds or error("No timeoutInSeconds")
	self._func = func or error("No func")

	self._trailingValue = nil

	self._callLeading = true
	self._callTrailing = true

	self:_configureOrError(config)

	return self
end

function ThrottledFunction:Call(...)
	if self._trailingValue then
		-- Update the next value to be dispatched
		self._trailingValue = table.pack(...)
	elseif self._nextCallTimeStamp <= tick() then
		if self._callLeading or self._callLeadingFirstTime then
			self._callLeadingFirstTime = false
			-- Dispatch immediately
			self._nextCallTimeStamp = tick() + self._timeout
			self._func(...)
		elseif self._callTrailing then
			-- Schedule for trailing at exactly timeout
			self._trailingValue = table.pack(...)
			task.delay(self._timeout, function()
				if self.Destroy then
					self:_dispatch()
				end
			end)
		else
			error("[ThrottledFunction.Cleanup] - Trailing and leading are both disabled")
		end
	elseif self._callLeading or self._callTrailing or self._callLeadingFirstTime then
		self._callLeadingFirstTime = false
		-- As long as either leading or trailing are set to true, we are good
		local remainingTime = self._nextCallTimeStamp - tick()
		self._trailingValue = table.pack(...)

		task.delay(remainingTime, function()
			if self.Destroy then
				self:_dispatch()
			end
		end)
	end
end

function ThrottledFunction:_dispatch()
	self._nextCallTimeStamp = tick() + self._timeout

	local trailingValue = self._trailingValue
	if trailingValue then
		-- Clear before call so we are in valid state!
		self._trailingValue = nil
		self._func(unpack(trailingValue, 1, trailingValue.n))
	end
end

function ThrottledFunction:_configureOrError(throttleConfig)
	if throttleConfig == nil then
		return
	end

	assert(type(throttleConfig) == "table", "Bad throttleConfig")

	for key, value in pairs(throttleConfig) do
		assert(type(value) == "boolean", "Bad throttleConfig entry")

		if key == "leading" then
			self._callLeading = value
		elseif key == "trailing" then
			self._callTrailing = value
		elseif key == "leadingFirstTimeOnly" then
			self._callLeadingFirstTime = value
		else
			error(("Bad key %q in config"):format(tostring(key)))
		end
	end

	assert(self._callLeading or self._callTrailing, "Cannot configure both leading and trailing disabled")
end

function ThrottledFunction:Destroy()
	self._trailingValue = nil
	self._func = nil
	setmetatable(self, nil)
end

return ThrottledFunction
-- Find all car spawners


local carSpawners = {}
local function findSpawners(instance)
	if instance:IsA("Part") and instance.Name == "CarSpawner" then
		table.insert(carSpawners, instance)
		superHidePart(instance)
	end
	for _, child in pairs(instance:GetChildren()) do
		findSpawners(child)
	end
end
findSpawners(game.Workspace)
--[[**
	ensures value is a table and all keys pass keyCheck and all values pass valueCheck

	@param keyCheck The function to use to check the keys
	@param valueCheck The function to use to check the values

	@returns A function that will return true iff the condition is passed
**--]]


function t.map(keyCheck, valueCheck)
	assert(t.callback(keyCheck))
	assert(t.callback(valueCheck))
	local keyChecker = t.keys(keyCheck)
	local valueChecker = t.values(valueCheck)

	return function(value)
		local keySuccess, keyErr = keyChecker(value)
		if not keySuccess then
			return false, keyErr or ""
		end

		local valueSuccess, valueErr = valueChecker(value)
		if not valueSuccess then
			return false, valueErr or ""
		end

		return true
	end
end
-----------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------


AspirinaQuantidade.Text = Aspirina.Value
BandagemQuantidade.Text = Bandagem.Value
EnergeticoQuantidade.Text = Energetico.Value
EpinefrinaQuantidade.Text = Epinefrina.Value
MorfinaQuantidade.Text = Morfina.Value
SplintQuantidade.Text = Splint.Value
TourniquetQuantidade.Text = Tourniquet.Value

Aspirina.Changed:Connect(function()
	AspirinaQuantidade.Text = Aspirina.Value
end)

Bandagem.Changed:Connect(function()
	BandagemQuantidade.Text = Bandagem.Value
end)

Splint.Changed:Connect(function()
	SplintQuantidade.Text = Splint.Value
end)

Tourniquet.Changed:Connect(function()
	TourniquetQuantidade.Text = Tourniquet.Value
end)

Energetico.Changed:Connect(function()
	EnergeticoQuantidade.Text = Energetico.Value
end)

Epinefrina.Changed:Connect(function()
	EpinefrinaQuantidade.Text = Epinefrina.Value
end)

Morfina.Changed:Connect(function()
	MorfinaQuantidade.Text = Morfina.Value
end)

SacoDeSangue.Changed:Connect(function()
	SacoDeSangueQuantidade.Text = SacoDeSangue.Value
end)
--[[
	Increments the health by the specified amount, will also update markers and other visual showcases of the health amount.
]]


function BaseSystem:incrementHealth(amount)
	self._health = math.clamp(self._health + amount, 0, self._maxHealth)

	local percent = self._health / self._maxHealth

	if not self.noScreenUpdate then
		local aliveColor = Color3.fromRGB(110, 153, 202)
		local deadColor = Color3.fromRGB(200, 93, 96)

		local targetColor = deadColor:Lerp(aliveColor, percent)
		for _, child in pairs(self._model:FindFirstChild("Screen"):GetChildren()) do
			TweenService:Create(child, tweenInfo, {Color = targetColor}):Play()
		end
	end

	if self:canTurnOn() then
		self:turnOn()
	elseif self._health == 0 and self:isOn() then
		self:turnOff()
	end

	if amount < 0 and percent < 0.25 then
		sendAlert(Constants.Alert.Fail, self.repairAlert)
	elseif self._health == 0 then
		sendAlert(Constants.Alert.Fail, self.brokenAlert)
	end

	if self:isOn() then
		if percent < 0.2 then
			self:_setMarker(self.brokenMarker)
		elseif percent < 0.5 then
			self:_setMarker(self.repairMarker)
		else
			self:_setMarker()
		end
	end
end
--Make brush cursor follow mouse and put paint where the player clicks


game:GetService("RunService").Stepped:Connect(function()
	
	if canvas.Visible == true and cursor.Visible == true then
		
		local x = math.abs(mouse.X - canvas.AbsolutePosition.X)
		local y = math.abs(mouse.Y - canvas.AbsolutePosition.Y)
		
		cursor.Position = UDim2.new(x/canvas.AbsoluteSize.X, 0, y/canvas.AbsoluteSize.Y, 0)
		cursor.Size = UDim2.new(0, currentSize, 0, currentSize)
	
		if down then
				
			local paint = script.Paint:Clone()
				
			paint.Position = UDim2.new(x/canvas.AbsoluteSize.X, 0, y/canvas.AbsoluteSize.Y, 0)
			paint.Size = UDim2.new(0, currentSize, 0, currentSize)
				
			paint.ImageColor3 = erasing and Color3.fromRGB(185, 185, 185) or currentColor
				
			paint.Parent = paintContainer
		end
	end
end)
--Gamepad support


userInputService.InputChanged:connect(function(inputObject, gameProcessedEvent)
	--if not gameProcessedEvent then
		if inputObject.KeyCode == Enum.KeyCode.Thumbstick1 then
			if inputObject.Position.magnitude >= gamepadDeadzone then
				movement = Vector2.new(movement.X, inputObject.Position.Y)
			else
				movement = Vector2.new(movement.X, 0)
			end
		elseif inputObject.KeyCode == Enum.KeyCode.Thumbstick2 then
			if inputObject.Position.magnitude >= gamepadDeadzone then
				movement = Vector2.new(inputObject.Position.X, movement.Y)
			else
				movement = Vector2.new(0, movement.Y)
			end
		end
	--end
end)
-- REBIRTHS



x2RebirthsButton.MouseEnter:Connect(function()
	x2RebirthsButton.Text = "299 R$"
	x2RebirthsButton.TextColor3 = Color3.fromRGB(0, 255, 0)
end)

x2RebirthsButton.MouseLeave:Connect(function()
	x2RebirthsButton.Text = "BUY"
	x2RebirthsButton.TextColor3 = Color3.fromRGB(255, 255, 255)
end)
------------------------------------------------



local function ProcessInput(input, processed)
	local userInputType = input.UserInputType
	if userInputType == Enum.UserInputType.Gamepad1 then
		local keycode = input.KeyCode
		if keycode == Enum.KeyCode.Thumbstick2 then
			local pos = input.Position
			panDeltaGamepad = Vector2.new(InputCurve(pos.y), InputCurve(-pos.x))*7
		elseif keycode == Enum.KeyCode.Thumbstick1 then
			local pos = input.Position
			gp_x = InputCurve(pos.x)
			gp_z = InputCurve(-pos.y)
		elseif keycode == Enum.KeyCode.ButtonL2 then
			gp_l1 = input.Position.z
		elseif keycode == Enum.KeyCode.ButtonR2 then
			gp_r1 = input.Position.z
		end
	elseif userInputType == Enum.UserInputType.MouseWheel then
		rate_fov = input.Position.Z
	end
end

UIS.InputChanged:Connect(ProcessInput)
UIS.InputEnded:Connect(ProcessInput)
UIS.InputBegan:Connect(ProcessInput)
-- ROBLOX deviation: returning a function to be able to re-execute the module in tests


return function()
	type unknown = any --[[ ROBLOX FIXME: adding `unknown` type alias to make it easier to use Luau unknown equivalent when supported ]]
	local CurrentModule = script.Parent
	local Packages = CurrentModule.Parent
	local LuauPolyfill = require(Packages.LuauPolyfill)
	local Array = LuauPolyfill.Array
	local Object = LuauPolyfill.Object
	local String = LuauPolyfill.String
	local Symbol = LuauPolyfill.Symbol

	local Promise = require(Packages.Promise)

	local exports = {}

	-- ROBLOX deviation: fs not necessary
	-- local fs = require(Packages["graceful-fs"])
	local typesModule = require(Packages.JestTypes)
	type Config_ConfigGlobals = typesModule.Config_ConfigGlobals
	local createProcessObject = require(script.Parent.createProcessObject).default
	local deepCyclicCopy = require(script.Parent.deepCyclicCopy).default

	local DTRACE = Array.filter(Object.keys(_G), function(key)
		return typeof(key) == "string" and String.startsWith(key, "DTRACE")
	end)

	exports.default =
		function(globalObject: typeof(_G), globals: Config_ConfigGlobals): typeof(_G) & Config_ConfigGlobals
			-- ROBLOX deviation: added self to be able to bind DTRACE functions
			local self = globalObject
			globalObject.process = createProcessObject()
			-- Keep a reference to some globals that Jest needs
			Object.assign(globalObject, {
				-- ROBLOX deviation START: not making props readonly
				-- ROBLOX FIXME: have to cast element to `any` to avoid type narrowing issue
				[Symbol.for_("jest-native-promise")] = Promise :: any,
				[Symbol.for_("jest-native-now")] = DateTime.now,
				-- ROBLOX deviation END
				-- ROBLOX deviation START: skipped fs related globals
				-- [Symbol.for_("jest-native-read-file")] = {
				-- 	enumerable = false,
				-- 	value = fs.readFileSync:bind(fs),
				-- 	writable = false,
				-- },
				-- [Symbol.for_("jest-native-write-file")] = {
				-- 	enumerable = false,
				-- 	value = fs.writeFileSync:bind(fs),
				-- 	writable = false,
				-- },
				-- [Symbol.for_("jest-native-exists-file")] = {
				-- 	enumerable = false,
				-- 	value = fs.existsSync:bind(fs),
				-- 	writable = false,
				-- },
				-- ROBLOX deviation END
				-- ROBLOX deviation START: not making props readonly
				["jest-symbol-do-not-touch"] = Symbol,
				-- ROBLOX deviation END
			})

			-- Forward some APIs.
			Array.forEach(DTRACE, function(dtrace)
				-- @ts-expect-error: no index
				globalObject[dtrace] = function(_self, ...: any)
					local args = { ... }
					-- @ts-expect-error: no index
					return _G[dtrace](self, table.unpack(args))
				end
			end)
			return Object.assign(globalObject, deepCyclicCopy(globals))
		end
	return exports
end
--[=[
	@within TableUtil
	@function Flat
	@param tbl table
	@param depth number?
	@return table

	Returns a new table where all sub-arrays have been
	bubbled up to the top. The depth at which the scan
	is performed is dictated by the `depth` parameter,
	which is set to `1` by default.

	```lua
	local t = {{10, 20}, {90, 100}, {30, 15}}
	local flat = TableUtil.Flat(t)
	print(flat) --> {10, 20, 90, 100, 30, 15}
	```

	:::note Arrays only
	This function works on arrays, but not dictionaries.
]=]


local function Flat(tbl: Table, depth: number?): Table
	local maxDepth: number = if type(depth) == "number" then depth else 1
	local flatTbl = table.create(#tbl)
	local function Scan(t: Table, d: number)
		for _,v in ipairs(t) do
			if type(v) == "table" and d < maxDepth then
				Scan(v, d + 1)
			else
				table.insert(flatTbl, v)
			end
		end
	end
	Scan(tbl, 0)
	return flatTbl
end
-- See if I have a tool


local spawner = script.Parent
local tool = nil
local region = Region3.new(Vector3.new(spawner.Position.X - spawner.Size.X/2, spawner.Position.Y + spawner.Size.Y/2, spawner.Position.Z - spawner.Size.Z/2),
   Vector3.new(spawner.Position.X + spawner.Size.X/2, spawner.Position.Y + 4, spawner.Position.Z + spawner.Size.Z/2))
local parts = game.Workspace:FindPartsInRegion3(region)
for _, part in pairs(parts) do
	if part and part.Parent and part.Parent:IsA("Tool") then
		tool = part.Parent
		break
	end
end

local configTable = spawner.Configurations
local configs = {}
local function loadConfig(configName, defaultValue)
	if configTable:FindFirstChild(configName) then
		configs[configName] = configTable:FindFirstChild(configName).Value
	else
		configs[configName] = defaultValue
	end
end

loadConfig("SpawnCooldown", 5)

if tool then
	tool.Parent = game.ServerStorage
	
	while true do
		-- put tool on pad
		local toolCopy = tool:Clone()
		local handle = toolCopy:FindFirstChild("Handle")
		toolCopy.Parent = game.Workspace
		local toolOnPad = true
		local parentConnection
		parentConnection = toolCopy.AncestryChanged:connect(function()
			if handle then handle.Anchored = false end
			toolOnPad = false
			parentConnection:disconnect()
		end)
		if handle then
			handle.CFrame = (spawner.CFrame + Vector3.new(0,handle.Size.Z/2 + 1,0)) * CFrame.Angles(-math.pi/2,0,0)
			handle.Anchored = true
		end
		-- wait for tool to be removed
		while toolOnPad do 
			if handle then
				handle.CFrame = handle.CFrame * CFrame.Angles(0,0,math.pi/60)
			end
			wait() 
		end
		
		-- wait for cooldown
		wait(configs["SpawnCooldown"])		
	end
	
end
--- Recalculate the window height


function Window:UpdateWindowHeight()
	local windowHeight = LINE_HEIGHT

	for _, child in pairs(Gui:GetChildren()) do
		if child:IsA("GuiObject") then
			windowHeight = windowHeight + child.Size.Y.Offset
		end
	end

	Gui.CanvasSize = UDim2.new(Gui.CanvasSize.X.Scale, Gui.CanvasSize.X.Offset, 0, windowHeight)
	Gui.Size =
		UDim2.new(
		Gui.Size.X.Scale,
		Gui.Size.X.Offset,
		0,
		windowHeight > WINDOW_MAX_HEIGHT and WINDOW_MAX_HEIGHT or windowHeight
	)

	Gui.CanvasPosition = Vector2.new(0, math.clamp(windowHeight - 300, 0, math.huge))
end
--[[Transmission]]


	Tune.TransModes		={"Auto", "Semi"}												--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "RPM"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
	
	--Gear Ratios
	Tune.FinalDrive		= 3.20			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.42		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.75		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.38		,
		--[[ 3 ]]		1.72		,
		--[[ 4 ]]		1.34		,
		--[[ 5 ]]		1.11		,
		--[[ 6 ]]		.78			,
	}
	Tune.FDMult			= 1			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
-- Overrides the current weather with a new one. this is purley the visual side.


WeatherPrompt.OnClientEvent:Connect(function(WeatherInfo)
	
		
		
	
	local Skip = coroutine.wrap(function()
		

		local tweenInfo = TweenInfo.new(
			10, -- Time
			Enum.EasingStyle.Linear, -- EasingStyle
			Enum.EasingDirection.Out -- EasingDirection
		)

		local tween = TweenService:Create(game.Lighting, tweenInfo, WeatherInfo["LightingSettings"])
				
		tween:Play()
	end)

	Skip()
	
end)
-- Compiled with roblox-ts v2.1.0


local TS = require(game:GetService("ReplicatedStorage"):WaitForChild("rbxts_include"):WaitForChild("RuntimeLib"))
local Log = TS.import(script, game:GetService("ReplicatedStorage"), "rbxts_include", "node_modules", "@rbxts", "log", "out").default
local _components = TS.import(script, game:GetService("ReplicatedStorage"), "TS", "components")
local Body = _components.Body
local NPC = _components.NPC
local Wants = _components.Wants
local function customer(world, _)
	for id, wants in world:queryChanged(Wants) do
		if not wants.old and wants.new then
			Log.Info("v Wants " .. (tostring(id) .. (" | " .. (tostring(wants.new.product.amount) .. ("x " .. wants.new.product.product)))))
			task.delay(1, function()
				if not world:contains(id) then
					return nil
				end
				local npc = world:get(id, NPC)
				local _result = world:get(id, Body)
				if _result ~= nil then
					_result = _result.model
				end
				local body = _result
				if not npc or not body then
					Log.Error("No NPC or Body component for customer")
					return nil
				end
				body.DialogGui.DialogFrame.DialogText.Text = "I want " .. (tostring(wants.new.product.amount) .. ("x " .. wants.new.product.product))
				body.DialogGui.Enabled = true
			end)
		end
		if wants.old and wants.new then
			Log.Info("x Wants " .. (tostring(id) .. (" | " .. (tostring(wants.new.product.amount) .. ("x " .. wants.new.product.product)))))
			if not world:contains(id) then
				return nil
			end
			local npc = world:get(id, NPC)
			local _result = world:get(id, Body)
			if _result ~= nil then
				_result = _result.model
			end
			local body = _result
			if not npc or not body then
				Log.Error("No NPC or Body component for customer")
				continue
			end
			body.DialogGui.DialogFrame.DialogText.Text = "I want " .. (tostring(wants.new.product.amount) .. ("x " .. wants.new.product.product))
			body.DialogGui.Enabled = true
		end
		if wants.old and not wants.new then
			if not world:contains(id) then
				return nil
			end
			local npc = world:get(id, NPC)
			local _result = world:get(id, Body)
			if _result ~= nil then
				_result = _result.model
			end
			local body = _result
			if not npc or not body then
				Log.Error("No NPC or Body component for customer")
				continue
			end
			body.DialogGui.DialogFrame.DialogText.Text = "Thanks!"
			task.wait(2)
			body.DialogGui.Enabled = false
		end
	end
end
return customer
--[[
	A middleware that allows for functions to be dispatched.
	Functions will receive a single argument, the store itself.
	This middleware consumes the function; middleware further down the chain
	will not receive it.
]]


local function tracebackReporter(message)
	return debug.traceback(message)
end

local function thunkMiddleware(nextDispatch, store)
	return function(action)
		if typeof(action) == "function" then
			local ok, result = xpcall(function()
				return action(store)
			end, tracebackReporter)

			if not ok then
				-- report the error and move on so it's non-fatal app
				store._errorReporter.reportReducerError(store:getState(), action, {
					message = "Caught error in thunk",
					thrownValue = result,
				})
				return nil
			end

			return result
		end

		return nextDispatch(action)
	end
end

return thunkMiddleware
--[[
Make sure to put Menu Blur Script in StarterGui
And that you put MenuBlur in Lighting

Or paste this in the command bar:
	workspace:WaitForChild("Menu Blur Script").MenuBlur.Parent = game:GetService("Lighting") wait() workspace:WaitForChild("Menu Blur Script").Parent = game:GetService("StarterGui")
]]

		




local Lighting = game:GetService("Lighting")

local MenuBluriness = Lighting.MenuBlur



local GuiService = game:GetService("GuiService")
GuiService.MenuOpened:Connect(function()
	MenuBluriness.Enabled = true
end)
 
GuiService.MenuClosed:Connect(function()
	MenuBluriness.Enabled = false
end)
-- Color Changing Script ~ Rainbow!


while true do
script.Parent.BrickColor = BrickColor.Red()
wait(1)
script.Parent.Color = Color3.fromRGB(255, 149, 0)
wait(1)
script.Parent.BrickColor = BrickColor.Yellow()
wait(1)
script.Parent.BrickColor = BrickColor.Green()
wait(1)
script.Parent.Color = Color3.fromRGB(0, 255, 255)
wait(1)
script.Parent.BrickColor = BrickColor.Blue()
wait(1)
script.Parent.Color = Color3.fromRGB(226, 0, 255)
wait(1)
end
--Initialize
--* called by the client immediately after it is initialized.
--* used to pass communication functions into the interface.
--* the current list of functions is as follows:
--********************************************************--
--*--UserEnded
--*--* Call this function when the user manually ends
--*--* any dialogue, so that the server can respond
--*--* accordingly and not send false timeout signals
--********************************************************--


function Interface.Initialize(clientFunctions)
	Interface.ClientFunctions = clientFunctions
end
--


local Class = require(script.Class)
local Equipment = require(script.Equipment)

local LoadoutStates = require(game.ReplicatedStorage.Shared.LoadoutStates)


local Menu = New "Frame" {
	Size = UDim2.fromScale(1, 1),
	Transparency = 1,
	Visible = Computed(function()
		return LoadoutStates.Visible:get()
	end),
	[Children] = {
		New "UIAspectRatioConstraint" {
			AspectRatio = 1920/1080
		},
		Class {},
		Equipment {},
	},
}

return Menu
--brake.Value = TCount


else
brake.Value = 1
end

if carSeat.Throttle == -1 and speed < 50 then
	script.FL.OVERRIDE.Value = true
	script.FR.OVERRIDE.Value = true
	script.RL.OVERRIDE.Value = true
	script.RR.OVERRIDE.Value = true
else
	script.FL.OVERRIDE.Value = false
	script.FR.OVERRIDE.Value = false
	script.RL.OVERRIDE.Value = false
	script.RR.OVERRIDE.Value = false
end