Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[[Run]]



	--Print Version
	local build=require(bike.Tuner.README)
	local ver=script.Parent.Version.Value
	--print("[Novena] NCT: M Loaded - Build: "..build..", Version: "..tostring(ver))
	print("[Novena] NCT: M Beta Loaded - Version: "..tostring(ver))
	
	--Runtime Loops
	
	-- ~60 c/s
	game["Run Service"].Heartbeat:connect(function(dt)	
		_IsOn = script.Parent.IsOn.Value
		_InControls = script.Parent.ControlsOpen.Value
		
		--Steering
		Steering(dt)
		
		--Gear
		Gear()
		
		--Power
		Engine(dt)
		
		--Update External Values
		script.Parent.Values.Gear.Value = _CGear
		script.Parent.Values.RPM.Value = _RPM
		script.Parent.Values.Boost.Value = ((_TBoost/2)*_TPsi)+((_SBoost/2)*_SPsi)
		script.Parent.Values.BoostTurbo.Value = (_TBoost/2)*_TPsi
		script.Parent.Values.BoostSuper.Value = (_SBoost/2)*_SPsi
		script.Parent.Values.HpNatural.Value = _NH
		script.Parent.Values.HpElectric.Value = _EH
		script.Parent.Values.HpTurbo.Value = _TH
		script.Parent.Values.HpSuper.Value = _SH
		script.Parent.Values.HpBoosted.Value = _BH
		script.Parent.Values.Horsepower.Value = _HP
		script.Parent.Values.TqNatural.Value = _NT/_Tune.Ratios[_CGear+1]/fFD/hpScaling
		script.Parent.Values.TqElectric.Value = _ET/_Tune.Ratios[_CGear+1]/fFD/hpScaling
		script.Parent.Values.TqTurbo.Value = _TT/_Tune.Ratios[_CGear+1]/fFD/hpScaling
		script.Parent.Values.TqSuper.Value = _ST/_Tune.Ratios[_CGear+1]/fFD/hpScaling
		script.Parent.Values.TqBoosted.Value = script.Parent.Values.TqTurbo.Value+script.Parent.Values.TqSuper.Value
		script.Parent.Values.Torque.Value = script.Parent.Values.TqNatural.Value+script.Parent.Values.TqElectric.Value+script.Parent.Values.TqBoosted.Value
		script.Parent.Values.TransmissionMode.Value = _TMode
		script.Parent.Values.Throttle.Value = _GThrot
		script.Parent.Values.Brake.Value = _GBrake
		if script.Parent.Values.AutoClutch.Value then
			script.Parent.Values.Clutch.Value = _Clutch
		end
		script.Parent.Values.SteerC.Value = _GSteerC
		script.Parent.Values.SteerT.Value = _GSteerT
		script.Parent.Values.PBrake.Value = _PBrake
		script.Parent.Values.TCS.Value = _TCS
		script.Parent.Values.TCSActive.Value = _TCSActive
		script.Parent.Values.TCSAmt.Value = 1-_TCSAmt
		script.Parent.Values.ABS.Value = _ABS
		script.Parent.Values.ABSActive.Value = _fABSActive or _rABSActive
		script.Parent.Values.MouseSteerOn.Value = _MSteer
		script.Parent.Values.Velocity.Value = bike.DriveSeat.Velocity
	end)
	
	while wait(.0667) do
		if _TMode == "Auto" then Auto() end
	end
-- << Variables >> --



local Player = game:GetService("Players").LocalPlayer
local Mouse = Player:GetMouse()
local Camera = game:GetService("Workspace").CurrentCamera
local UserInputService = game:GetService("UserInputService")
local Humanoid = Player.Character:WaitForChild("Humanoid")
local bobbing = nil
local func1 = 0
local func2 = 0
local func3 = 0
local func4 = 0
local val = 0
local val2 = 0
local int = 8
local int2 = 16
local vect3 = Vector3.new()
--immediatly


game.Workspace.window.die.Transparency = 0.4
game.Workspace.Specksoof.ParticleEmitter.Enabled = true
game.Workspace.Firereactor.Particles.Enabled = true
game.Workspace.Firereactor.Particles1.Enabled = true
game.Workspace.Firereactor.Smoke.Enabled = true
game.Workspace.Firereactor.Light.Enabled = true
game.Workspace.Firereactor.Sound:Play()
--[[
	Set the current node's status based on that of its children. If all children
	are skipped, mark it as skipped. If any are fails, mark it as failed.
	Otherwise, mark it as success.
]]


function TestSession:setStatusFromChildren()
	assert(#self.nodeStack > 0, "Attempting to set status from children on empty stack")

	local last = self.nodeStack[#self.nodeStack]
	local status = TestEnum.TestStatus.Success
	local skipped = true

	-- If all children were skipped, then we were skipped
	-- If any child failed, then we failed!
	for _, child in ipairs(last.children) do
		if child.status ~= TestEnum.TestStatus.Skipped then
			skipped = false

			if child.status == TestEnum.TestStatus.Failure then
				status = TestEnum.TestStatus.Failure
			end
		end
	end

	if skipped then
		status = TestEnum.TestStatus.Skipped
	end

	last.status = status
end

return TestSession
--[[Engine]]



	--		[TORQUE CURVE VISUAL]
	--		https://www.desmos.com/calculator/nap6stpjqf
	--		Use sliders to manipulate values
	--		Edit everything as if your car is NATURALLY aspirated, or as if it lacks a turbo.
	
	Tune.Horsepower		= 750
	Tune.IdleRPM		= 800
	Tune.PeakRPM		= 4500
	Tune.Redline		= 4350
	Tune.EqPoint		= 4350
	Tune.PeakSharpness	= 20
	Tune.CurveMult		= 0.2
	
	Tune.InclineComp	= 1.2		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Turbo Settings
	Tune.Aspiration		= "Super"												--[[
	[Aspiration]
		"Natural"		: N/A, Naturally aspirated engine
		"Single"		: Single turbocharger
		"Double"		: Twin turbocharger
		"Super"			: Supercharger												]]
	
	Tune.Boost			= 3			--Max PSI (If you have two turbos and this is 15, the PSI will be 30)
	Tune.TurboSize		= 25		--Turbo size; the bigger it is, the more lag it has.
	Tune.CompressRatio	= 9			--The compression ratio (look it up)
	Tune.Sensitivity	= 0.05		--How quickly the Supercharger (if appllied) will bring boost when throttle is applied. (Increment applied per tick, suggested values from 0.05 to 0.1)
	
	--Misc
	Tune.RevAccel		= 300		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 250		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)
--[[Gabes variables]]


	
	local CurrKickdown = 0
	local LaunchBuild = _Tune.IdleRPM
	local Rev = script.Parent.Values.RPM

	car.DriveSeat.DriveMode.Changed:Connect(function()
		if car.DriveSeat.DriveMode.Value == "SportPlus" then
		   if _Tune.TCSEnabled and _IsOn then
					_TCS = false
		   end
		else
		   if _Tune.TCSEnabled and _IsOn then
					_TCS = true
		   end			
		end
	end)
-- Ganondude



local time_zone = -5		-- Time zone, offset from GMT.

local clock = script.Parent
local face = clock.Face
local hour_hand = clock.Hour
local minute_hand = clock.Minute
local second_hand = clock.Second

local secondsInDay = 60*60*24

function rotateClockHand(hand,rotation)
	local lv = (face.CFrame*CFrame.Angles(math.pi/2,0,0)).lookVector*face.Size.Y/2.5

	hand.CFrame = face.CFrame*CFrame.Angles(0,-rotation,0) + lv
	hand.CFrame = hand.CFrame - hand.CFrame.lookVector*hand.Size.Z/2
end

while true do
	local tick = math.fmod(tick(),secondsInDay)

	local hour = math.floor(tick/3600) + 5 + time_zone
	local minute = math.floor(tick/60 - 60*hour)
	local second = math.floor(math.fmod(tick,60))

	rotateClockHand(hour_hand,hour*(math.pi/6) + minute*(math.pi/500))
	rotateClockHand(minute_hand,minute*(math.pi/30))
	rotateClockHand(second_hand,second*(math.pi/30))

	wait(0.1)
end
--game.Players.LocalPlayer:WaitForChild("PlayerGui"):WaitForChild("Sound"):Play()



while game:GetService("RunService").RenderStepped:wait() do
	workspace.CurrentCamera.CameraType = "Scriptable"
	local l = 0--(game.Players.LocalPlayer:WaitForChild("PlayerGui"):WaitForChild("Sound").PlaybackLoudness /10)
	l = (l^3)/500
	local lv = Vector3.new(-l,l/5,0)
	workspace.CurrentCamera:Interpolate(workspace:WaitForChild("CamPart").CFrame,workspace:WaitForChild("CamPart").CFrame + (workspace:WaitForChild("CamPart").CFrame.lookVector * Vector3.new(10,10,10)) + lv,2)
end
-- Private Methods



function init(self)
	local label = self.Frame.Label
	local container = self.Frame.CheckContainer
	local checkmark = self.Button.Checkmark
	
	local function contentSizeUpdate()
		local absSize = self.Frame.AbsoluteSize
		local ratio = absSize.y / absSize.x
		container.Size = UDim2.new(ratio, 0, 1, 0)
		label.Size = UDim2.new(1 - ratio, -10, 1, 0)
		label.Position = UDim2.new(ratio, 10, 0, 0)
	end
	
	contentSizeUpdate()
	self._Maid:Mark(self.Frame:GetPropertyChangedSignal("AbsoluteSize"):Connect(contentSizeUpdate))
	
	self._Maid:Mark(self.Button.Activated:Connect(function()
		self:SetValue(not checkmark.Visible)
	end))
end
-- LOCAL FUNCTIONS


local function checkTopbarEnabled()
	local success, bool = xpcall(function()
		return starterGui:GetCore("TopbarEnabled")
	end,function(err)
		--has not been registered yet, but default is that is enabled
		return true	
	end)
	return (success and bool)
end

local function checkTopbarEnabledAccountingForMimic()
	local topbarEnabledAccountingForMimic = (checkTopbarEnabled() or not IconController.mimicCoreGui)
	return topbarEnabledAccountingForMimic
end
------------------------------------------------------------------------
-- this is a stripped-down luaM_growvector (from lmem.h) which is a
-- macro based on luaM_growaux (in lmem.c); all the following does is
-- reproduce the size limit checking logic of the original function
-- so that error behaviour is identical; all arguments preserved for
-- convenience, even those which are unused
-- * set the t field to nil, since this originally does a sizeof(t)
-- * size (originally a pointer) is never updated, their final values
--   are set by luaY:close_func(), so overall things should still work
------------------------------------------------------------------------


function luaY:growvector(L, v, nelems, size, t, limit, e)
  if nelems >= limit then
    error(e)  -- was luaG_runerror
  end
end
-- // Public Methods \\ --


function CastVisualiser:Hide()
	self.CastOriginPart.Parent = nil
end

function CastVisualiser:Raycast(Origin: Vector3, Direction: Vector3, RaycastParameters: RaycastParams?)
	local self: CastVisualiserPrivate = self
	
	local Cast = self.WorldRoot:Raycast(Origin, Direction, RaycastParameters)
	if not Cast then
		self:Hide()
		return
	end
	
	self.CastOriginPart.CFrame = CFrame.lookAt(Origin, Cast.Position)

	self.LineVisual.Length = Cast.Distance - CONE_HEIGHT
	self.ConeVisual.CFrame = CFrame.new(0, 0, -Cast.Distance)
	
	self.BoxVisual.Visible = false
	self.SphereVisual.Visible = false
	
	self.CastOriginPart.Parent = self.WorldRoot:FindFirstChild("Terrain") or self.WorldRoot
end


function CastVisualiser:Blockcast(CF: CFrame, Size: Vector3, Direction: Vector3, RaycastParameters: RaycastParams?)
	local self: CastVisualiserPrivate = self
	
	local Cast = self.WorldRoot:Blockcast(CF, Size, Direction, RaycastParameters)
	if not Cast then
		self:Hide()
		return
	end
	
	local FinalPos = CF.Position + (Direction.Unit * Cast.Distance)
	
	self.CastOriginPart.CFrame = CFrame.lookAt(CF.Position, FinalPos)
	
	self.LineVisual.Length = Cast.Distance - CONE_HEIGHT
	self.ConeVisual.CFrame = CFrame.new(0, 0, -Cast.Distance)
	
	self.BoxVisual.CFrame = CFrame.new(0, 0, -Cast.Distance)
	self.BoxVisual.Size = Size
	
	self.BoxVisual.Visible = true
	self.SphereVisual.Visible = false
	
	self.CastOriginPart.Parent = self.WorldRoot:FindFirstChild("Terrain") or self.WorldRoot
end


function CastVisualiser:SphereCast(Origin: Vector3, Radius: number, Direction: Vector3, RaycastParameters: RaycastParams?)
	local self: CastVisualiserPrivate = self
	
	local Cast = self.WorldRoot:Spherecast(Origin, Radius, Direction, RaycastParameters)
	if not Cast then
		self:Hide()
		return
	end
	
	local FinalPos = Origin + (Direction.Unit * Cast.Distance)

	self.CastOriginPart.CFrame = CFrame.lookAt(Origin, FinalPos)

	self.LineVisual.Length = Cast.Distance - CONE_HEIGHT
	self.ConeVisual.CFrame = CFrame.new(0, 0, -Cast.Distance)
	
	self.SphereVisual.CFrame = CFrame.new(0, 0, -Cast.Distance)
	self.SphereVisual.Radius = Radius
	
	self.SphereVisual.Visible = true
	self.BoxVisual.Visible = false
	
	self.CastOriginPart.Parent = self.WorldRoot:FindFirstChild("Terrain") or self.WorldRoot
end
-- if not version then
-- 	return Error(
-- 		chalk.red(
-- 			chalk.bold('Outdated snapshot') .. ": No snapshot header found. " ..
-- 			"Jest 19 introduced version snapshots to ensure all developers " ..
-- 			"on a project are using the same version of Jest. " ..
-- 			"Please update all snapshots during this upgrade of Jest.\n\n"
-- 		) .. SNAPSHOT_VERSION_WARNING
-- 	)
-- end
--[[

		SCRIPT VERSION:
			1.3, 10/19/21
		
		CURRENT ISSUE:
			Nothing
		
--]]



if not game.Loaded or not workspace:FindFirstChild("Terrain") then
	game.Loaded:Wait();
	game:GetService("Players").LocalPlayer.CharacterAdded:Wait();
end;

local Players = game:GetService("Players")
local Player = Players.LocalPlayer;

local Screen = script.Parent.Parent.Leveled.Admin;
local Sidebar = Screen.Sidebar.Inside;

function Animate(Instance, Time, Style, Direction, Animation, WaitForAnimation)
	game:GetService("TweenService"):Create(Instance, TweenInfo.new(Time, Style, Direction, 0, false, 0), Animation):Play();
	if WaitForAnimation == true then
		wait(Time);
	end;
end;

for Int, Button in pairs(Sidebar:GetChildren()) do
	if Button:IsA("ImageButton") then
		Button.MouseButton1Click:Connect(function()
			if Screen:FindFirstChild(Button.Name).Visible == true then
				Screen:FindFirstChild(Button.Name).Visible = false;
				Button.ImageColor3 = Color3.fromRGB(120, 120, 125);
				return;
			end;
			
			local WantScreen = Screen:FindFirstChild(Button.Name);
			for Int, Ue1 in pairs(Screen:GetChildren()) do
				if Ue1.Name ~= "Sidebar" then
					Ue1.Visible = false;
					Sidebar:FindFirstChild(Ue1.Name).ImageColor3 = Color3.fromRGB(120, 120, 125);
				end;
			end;
			WantScreen.Visible = true;
			Button.ImageColor3 = Color3.fromRGB(255, 255, 255);
		end);
	end;
end;
--[[
Classes.RadialMenu

This class creates a radial menu. It is by far the most "raw" module in this library as so much of how you interact with it is developer defined.

Constructors:
	new(subN [integer], tPercent [float], rotation [float])
		> Creates a radial menu divided into subN sections where the ring is tPercent width of the frame radius
		> and the ring is rotationally offset by rotation radians

Properties:
	Frame [instance]
		> The container frame for the radial menu. Can be used for positioning and resizing.
		> Note that this frame should always be square, by default it's set to YY size constraining
	Rotation [float]
 		> The rotation offset that the developer entered as an argument when creating the radial menu.
	SubN [integer]
		> The number of subsections that the developer entered as an argument when creating the radial menu.
	Enabled [boolean]
		> Whether or not the radial menu is actively tracking input.
		> Defaults to true
	DeadZoneIn [float]
		> Number represents a percentage from the radius that will be ignored in regards to input
		> By default this is 0.5 meaning the center 50% of the radial frame ignores input
	DeadZoneOut [float]
		> Number represents a percentage from the radius that once passed will be ignored in regards to input.
		> By default this is math.huge meaning that as long as your outside of DeadZoneIn your input will not be ignored.

Methods:
	:SetRadialProps(props [dictionary]) [void]
		> Sets the properties of all the radial background UI
	:SetDialProps(props [dictionary]) [void]
		> Sets the properties of the radial dial UI
	:GetTheta(userInputType [Enum.UserInputType]) [float]
		> Depending on if MouseMovement, Touch, or a Gamepad returns the directional angle that the user is inputting on their device
		> If input is not in deadzone range then this method returns nil
		> Returns the angle in radians
	:PickIndex(theta) [integer]
		> Given a directional angle returns the closest element on the radial wheel as an index.
	:GetRadial(index) [instance]
		> Returns the radial background UI for that index.
	:GetAttachment(index) [instance]
		> Returns the radial attachment UI for that index.
		> This frame is useful for putting text or images in.
	:IsVisible() [boolean]
		> Returns whether or not the radial menu is visible to the user or not.
	:Destroy() [void]
		> Destroys the RadioButtonGroup and all the events, etc that were running it.

Events:
	.Clicked:Connect(function(index [integer])
		> Fired when the user selects an element on the radial menu.
	.Hover:Connect(function(oldIndex [integer], newIndex [integer])
		> Fired when the user hovers in the direction of a new element on the radial menu
--]]
-------------------------------------------


local weld2 = Instance.new("Weld")
weld2.Part0 = torso
weld2.Parent = torso
weld2.Part1 = arms[2]
weld2.C1 = CFrame.new(0.5,0.5,0.3) * CFrame.fromEulerAnglesXYZ(math.rad(20),0.1,0.1)
arms[2].Name = "RDave"
arms[2].CanCollide = true
welds[2] = weld2
--[=[
	Unions the set with the other set, making a copy.
	@param set table
	@param otherSet table
	@return table
]=]


function Set.union(set, otherSet)
	local newSet = {}
	for key, _ in pairs(set) do
		newSet[key] = true
	end
	for key, _ in pairs(otherSet) do
		newSet[key] = true
	end
	return newSet
end
--[[
	DataStore2: A wrapper for data stores that caches and saves player's data.

	DataStore2(dataStoreName, player) - Returns a DataStore2 DataStore

	DataStore2 DataStore:
	- Get([defaultValue])
	- Set(value)
	- Update(updateFunc)
	- Increment(value, defaultValue)
	- BeforeInitialGet(modifier)
	- BeforeSave(modifier)
	- Save()
	- SaveAsync()
	- OnUpdate(callback)
	- BindToClose(callback)

	local coinStore = DataStore2("Coins", player)

	To give a player coins:

	coinStore:Increment(50)

	To get the current player's coins:

	coinStore:Get()
--]]



local RunService = game:GetService("RunService")
local ServerStorage = game:GetService("ServerStorage")

local Constants = require(script.Constants)
local IsPlayer = require(script.IsPlayer)
local Promise = require(script.Promise)
local SavingMethods = require(script.SavingMethods)
local Settings = require(script.Settings)
local TableUtil = require(script.TableUtil)
local Verifier = require(script.Verifier)

local SaveInStudioObject = ServerStorage:FindFirstChild("SaveInStudio")
local SaveInStudio = SaveInStudioObject and SaveInStudioObject.Value

local function clone(value)
	if typeof(value) == "table" then
		return TableUtil.clone(value)
	else
		return value
	end
end
--[=[
	Locks the mouse in its current position on screen. Call `mouse:Unlock()`
	to unlock the mouse.

	:::caution Must explicitly unlock
	Be sure to explicitly call `mouse:Unlock()` before cleaning up the mouse.
	The `Destroy` method does _not_ unlock the mouse since there is no way
	to guarantee who "owns" the mouse lock.
]=]


function Mouse:Lock()
	UserInputService.MouseBehavior = Enum.MouseBehavior.LockCurrentPosition
end
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]




local autoscaling	= false					--Estimates top speed

local UNITS	= {								--Click on speed to change units
											--First unit is default	
	{
		units			= "MPH"				,
		scaling			= (10/12) * (60/88)	, -- 1 stud : 10 inches | ft/s to MPH
		maxSpeed		= 160				,
		spInc			= 20				, -- Increment between labelled notches
	},
	
	{
		units			= "KM/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 260				,
		spInc			= 20				, -- Increment between labelled notches
	},
	
	{
		units			= "SPS"				,
		scaling			= 1					, -- Roblox standard
		maxSpeed		= 270				,
		spInc			= 20				, -- Increment between labelled notches
	}
}
--[[
	By
	  Precious
	          Beam
--]]


game.Players.PlayerAdded:connect(function(player)
		local datastore = game:GetService("DataStoreService"):GetDataStore(player.Name.."Stats")
	
	player:WaitForChild("Data")
	wait(1)
	local stats = player:FindFirstChild("Data"):GetChildren()
	for i = 1, #stats do			
	stats[i].Value = datastore:GetAsync(stats[i].Name)
	print("stat numba "..i.." has been found")
		end
end)
--[=[
	@param name string
	@param inboundMiddleware ServerMiddleware?
	@param outboundMiddleware ServerMiddleware?
	@return RemoteSignal
]=]


function ServerComm:CreateSignal(name: string, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?)
	return Comm.Server.CreateSignal(self._instancesFolder, name, inboundMiddleware, outboundMiddleware)
end
--[[
INSTRUCTIONS ARE BELOW.

Look in the Configuration, there are 2 IntValues, 1 is GroupId and the other is RankId. The rank
Id is the numbers that you set the rank to in your group, the numbers are (1-255), it will not 
only just work for that rank level, it will work for the rank and ABOVE. The GroupId is the numbers
at the end of your group's URL.Copy those numbers and but it in the Value section for GroupId. Now
You have finished the set up for the group door! WARNING : DONT TOUCH ANYTHING DOWN THERE...
]]



local config = script.Parent.Configuration

script.Parent.Touched:connect(function(part)
	if part.Parent and Game:GetService('Players'):GetPlayerFromCharacter(part.Parent) then
		local player = Game:GetService('Players'):GetPlayerFromCharacter(part.Parent)
		if player:GetRankInGroup(config.GroupId.Value) >= config.RankId.Value then
			script.Parent.Transparency = 1
			script.Parent.CanCollide = false
			wait(2)
			script.Parent.Transparency = 1
			script.Parent.CanCollide = true
		end
	end
end)
-- Handle event fire


local function toggleDoor(player, door)
	local motor
	if door == "freezer" then
		motor = freezerMotor
	elseif door == "door" then
		motor = doorMotor
	else
		return
	end
	
	
	-- Check distance to the character's Torso. If too far, don't do anything
	if player.Character and player.Character:FindFirstChild("Torso") then	
		local torso = player.Character:FindFirstChild("Torso")
		local toTorso = torso.Position - fridge.FreezerPadding.Position
		if toTorso.magnitude < clickDistance then
			if open then
				motor.DesiredAngle = 0
				open = false
			else
				motor.DesiredAngle = math.pi/2
				open = true
			end
			if door == "freezer" then
				fridge.FreezerBlock.Smoke.Enabled = open
			end
		end
	end
end

fridge.DoorPadding.ROBLOXInteractionEvent.OnServerEvent:connect(function(player, arguments)
	toggleDoor(player, "door")
end)

fridge.Door.ROBLOXInteractionEvent.OnServerEvent:connect(function(player, arguments)
	toggleDoor(player, "door")
end)

fridge.FreezerPadding.ROBLOXInteractionEvent.OnServerEvent:connect(function(player, arguments)
	toggleDoor(player, "freezer")
end)

fridge.FreezerDoor.ROBLOXInteractionEvent.OnServerEvent:connect(function(player, arguments)
	toggleDoor(player, "freezer")
end)
-- you can mess with these settings


local easingtime = 0.1 --0~1
local walkspeeds = {
	enabled =		  true;
	walkingspeed =		10;
	backwardsspeed =	6;
	sidewaysspeed =		8;
	diagonalspeed =		9;
	runningspeed =		14;
	runningFOV=			80;
}
--[=[
	Rejects the promise with the values given
	@param ... T -- Params to reject with
]=]


function Promise:Reject(...)
	self:_reject({...}, select("#", ...))
end

function Promise:_reject(values, valuesLength)
	if not self._pendingExecuteList then
		return
	end

	self._rejected = values
	self._valuesLength = valuesLength

	local list = self._pendingExecuteList
	self._pendingExecuteList = nil
	for _, data in pairs(list) do
		self:_executeThen(unpack(data))
	end

	-- Check for uncaught exceptions
	if self._unconsumedException and self._valuesLength > 0 then
		task.defer(function()
			-- Yield to end of frame, giving control back to Roblox.
			-- This is the equivalent of giving something back to a task manager.
			if self._unconsumedException then
				local errOutput = self:_toHumanReadable(self._rejected[1])

				if ENABLE_TRACEBACK then
					warn(("[Promise] - Uncaught exception in promise\n\n%q\n\n%s")
						:format(errOutput, self._source))
				else
					warn(("[Promise] - Uncaught exception in promise: %q")
						:format(errOutput))
				end
			end
		end)
	end
end

function Promise:_toHumanReadable(data)
	if type(data) == "table" then
		local errOutput
		local ok = pcall(function()
			errOutput = HttpService:JSONEncode(data)
		end)
		if not ok then
			errOutput = tostring(data)
		end
		return errOutput
	else
		return tostring(data)
	end
end