Pinkstack/roblox-luau-corpus-text huggingface dataset:
--Stickmasterluke



sp=script.Parent
framerate=30

frames=1
running=false
direction=1


function waitForChild(instance,name)
	while not instance:FindFirstChild(name) do
		instance.ChildAdded:wait()
	end
end

waitForChild(sp,"Bottom")
waitForChild(sp.Bottom,"OpenDoor")
waitForChild(sp.Bottom,"Configuration")


function checkframes()
	if sp:FindFirstChild("Bottom") then
		local config=sp.Bottom:FindFirstChild("Configuration")
		if config then
			frames=math.floor(config.TimeToMove.Value*framerate)+1
		end
	end
end
sp.Bottom.Configuration.TimeToMove.Changed:connect(checkframes)
checkframes()


function updatedoor(frame)
	local percentage=frame/frames
	if sp:FindFirstChild("Bottom") then
		local hingedist=1.9
		local hinge1=sp.Bottom:FindFirstChild("Door1")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(-hingedist,-hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(hingedist,hingedist,0)
		end
		local hinge1=sp.Bottom:FindFirstChild("Door2")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(-hingedist,hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(hingedist,-hingedist,0)
		end
		local hinge1=sp.Bottom:FindFirstChild("Door3")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(hingedist,hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(-hingedist,-hingedist,0)
		end
		local hinge1=sp.Bottom:FindFirstChild("Door4")
		if hinge1~=nil then
			hinge1.C1=CFrame.new(hingedist,-hingedist,0)*CFrame.Angles(0,0,(math.pi/2)*percentage)*CFrame.new(-hingedist,hingedist,0)
		end
	end
end

function runloop()
	if not running then
		running=true
		while true do
			if sp:FindFirstChild("Bottom") then
				local frame=sp.Bottom:FindFirstChild("Frame")
				if frame then
					frame.Value=frame.Value+direction
					if frame.Value>frames then
						frame.Value=frames
					end
					if frame.Value<=0 then
						frame.Value=0
					end
					updatedoor(frame.Value)
					wait(1/framerate)
					if frame then
						if (frame.Value<=0 and direction==-1) or (frame.Value>=frames and direction==1) then
							break
						end
					end
				else
					break
				end
			else
				break
			end
		end
		running=false
	end
end

function check(val)
	if val>.5 then
		direction=1
	else
		direction=-1
	end
	runloop()
end

sp.Bottom.OpenDoor.SourceValueChanged:connect(check)
check(sp.Bottom.OpenDoor:GetCurrentValue())
--------SIDE SQUARES--------



game.Workspace.sidesquares.l11.BrickColor = BrickColor.new(1023)
game.Workspace.sidesquares.l12.BrickColor = BrickColor.new(1023)
game.Workspace.sidesquares.l21.BrickColor = BrickColor.new(1023)
game.Workspace.sidesquares.l31.BrickColor = BrickColor.new(1023)

game.Workspace.rightpalette.l11.BrickColor = BrickColor.new(1023)
game.Workspace.rightpalette.l12.BrickColor = BrickColor.new(1023)
game.Workspace.rightpalette.l21.BrickColor = BrickColor.new(1023)
game.Workspace.rightpalette.l22.BrickColor = BrickColor.new(1023)

game.Workspace.sidesquares.l13.BrickColor = BrickColor.new(106)
game.Workspace.sidesquares.l23.BrickColor = BrickColor.new(106)
game.Workspace.sidesquares.l33.BrickColor = BrickColor.new(106)
game.Workspace.sidesquares.l34.BrickColor = BrickColor.new(106)

game.Workspace.rightpalette.l13.BrickColor = BrickColor.new(106)
game.Workspace.rightpalette.l23.BrickColor = BrickColor.new(106)
game.Workspace.rightpalette.l14.BrickColor = BrickColor.new(106)
game.Workspace.rightpalette.l24.BrickColor = BrickColor.new(106)

game.Workspace.sidesquares.l14.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l15.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l24.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l25.BrickColor = BrickColor.new(1013)
game.Workspace.sidesquares.l35.BrickColor = BrickColor.new(1013)

game.Workspace.rightpalette.l15.BrickColor = BrickColor.new(1013)
game.Workspace.rightpalette.l25.BrickColor = BrickColor.new(1013)
game.Workspace.rightpalette.l16.BrickColor = BrickColor.new(1013)
game.Workspace.rightpalette.l26.BrickColor = BrickColor.new(1013)
-- Function to preload audio assets


AudioPlayer.preloadAudio = function(assetArray)
	local audioAssets = {}
 
	-- Add new "Sound" assets to "audioAssets" array
	for name, audioID in pairs(assetArray) do
		local audioInstance = Instance.new("Sound")
		audioInstance.SoundId = "rbxassetid://" .. audioID
		audioInstance.Name = name
		audioInstance.Parent = SoundService
		
		table.insert(audioAssets, audioInstance)
	end
 
	local success, assets = pcall(function()
		ContentProvider:PreloadAsync(audioAssets)
	end)
end
--BasedWeld2.0


function MakeWeld(x,y,type,s) 
	local W=Instance.new(type) 
	W.Part0=x W.Part1=y 
	W.C0=x.CFrame:inverse()*x.CFrame 
	W.C1=y.CFrame:inverse()*x.CFrame 
	W.Parent=x 
	if type=="Motor" and s~=nil then 
		W.MaxVelocity=s 
	end 
	return W	
end
function ModelWeld(a,b) 
	if a:IsA("BasePart") then 
		MakeWeld(b,a,"Weld") 
	elseif a:IsA("Model") then 
		for i,v in pairs(a:GetChildren()) do 
			ModelWeld(v,b) 
		end 
	end 
end
function UnAnchor(a) 
	if a:IsA("BasePart") then a.Anchored=false elseif a:IsA("Model") then for i,v in pairs(a:GetChildren()) do UnAnchor(v) end end 
end
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 580		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 4.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- 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		= 500		-- Clutch engagement threshold (higher = faster response)
--- Connect a new handler to the event. Returns a connection object that can be disconnected.
-- @tparam function handler Function handler called with arguments passed when `:Fire(...)` is called
-- @treturn Connection Connection object that can be disconnected


function Signal:Connect(handler)
	if not (type(handler) == "function") then
		error(("connect(%s)"):format(typeof(handler)), 2)
	end

	return self._bindableEvent.Event:Connect(function()
		handler(unpack(self._argData, 1, self._argCount))
	end)
end
--Feel free to change other properties


trail.Parent = script.Parent.HumanoidRootPart
att0.Parent = script.Parent.HumanoidRootPart
att1.Parent = script.Parent.HumanoidRootPart
trail.Attachment0 = att0
trail.Attachment1 = att1
trail.Enabled = true
att0.Position = Vector3.new(.5, 0, 0)
att1.Position = Vector3.new(-.5, 0, 0)
-- Builds a set of runnable Tweens from a table of instances and values


local function BuildTweens(root, tweenTable)
	local tweens = {}

	VisitAllInstances(root, tweenTable, function(instance, props)
		for prop, values in pairs(props) do
			local keyframes = values.Keyframes
			local lastTime = 0
			for _, keyframe in ipairs(keyframes) do
				local tweenInfo = TweenInfo.new(keyframe.Time - lastTime,
					keyframe.EasingStyle,keyframe.EasingDirection, 0, false, 0)
				local propTable = {
					[prop] = keyframe.Value
				}
				local tween = TweenService:Create(instance, tweenInfo, propTable)
				table.insert(tweens, {
					Tween = tween,
					DelayTime = lastTime,
				})
				lastTime = keyframe.Time
			end
		end
	end)

	return tweens
end

local TweenUtilities = {}
TweenUtilities.__index = TweenUtilities

function TweenUtilities.new(root, tweenTable)
	local self = {
		running = false,
		root = root,
		tweenTable = tweenTable,
		tweens = BuildTweens(root, tweenTable),
	}
	setmetatable(self, TweenUtilities)
	return self
end

function TweenUtilities:ResetValues()
	VisitAllInstances(self.root, self.tweenTable, function(instance, props)
		for prop, values in pairs(props) do
			local initialValue = values.InitialValue
			instance[prop] = initialValue
		end
	end)
end

function TweenUtilities:PlayTweens(callback)
	if self.running then
		self:PauseTweens()
	end
	self.running = true

	local delayedTweens = {}
	for _, props in pairs(self.tweens) do
		local tween = props.Tween
		local delayTime = props.DelayTime
		if delayTime == 0 then
			tween:Play()
		else
			table.insert(delayedTweens, {
				Tween = tween,
				DelayTime = delayTime,
				Playing = false,
			})
		end
	end

	local heartbeatConnection
	local start = tick()
	local tweensDone = false
	heartbeatConnection = RunService.Heartbeat:Connect(function()
		local now = tick() - start
		if not self.running then
			self.running = false
			heartbeatConnection:Disconnect()
			if callback then
				callback()
			end
			return
		end
		if tweensDone then
			local allDone = true
			for _, props in pairs(self.tweens) do
				local tween = props.Tween
				if tween.PlaybackState == Enum.PlaybackState.Playing then
					allDone = false
				end
			end
			if allDone then
				self.running = false
				heartbeatConnection:Disconnect()
				if callback then
					callback()
				end
				return
			end
		else
			local allPlaying = true
			for _, props in pairs(delayedTweens) do
				if not props.Playing then
					if now > props.DelayTime then
						props.Playing = true
						props.Tween:Play()
					else
						allPlaying = false
					end
				end
			end
			tweensDone = allPlaying
		end
	end)
end

function TweenUtilities:PauseTweens()
	self.running = false
	for _, props in pairs(self.tweens) do
		local tween = props.Tween
		tween:Cancel()
	end
end

return TweenUtilities
---------------------------------------Function end here.


end


Tool.Enabled = true
function onActivated()

	if not Tool.Enabled then
		return
	end

	--Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end

	if (check()) then
	fire(script.Parent.Parent["Humanoid"].TargetPoint)
	wait(0.0)
	onActivated()
	end
	return

	--Tool.Enabled = true
end


script.Parent.Activated:connect(onActivated)
--[[Weight and CG]]


	Tune.Weight			= 100000		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		3.5		,
	 --[[Length]]		14		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= 5		-- Front Wheel Density
	Tune.RWheelDensity	= 5		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 5			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= 1		-- Density of structural members
----------------------------------
-----------CONNECTIONS------------
----------------------------------



SeatWeldConnection = nil

function MakeSeatConnections()
	SeatWeldConnection = SeatWeld.Changed:connect(WeldChanged)
end
function BreakSeatConnections()
	SeatWeldConnection:disconnect()
end

Piano.Bench.Seat.Changed:Connect(function()
	Piano.Bench.Seat.Changed:Wait()
	if Piano.Bench.Seat.Occupant == nil or Piano.Bench.Seat.Changed == "" or not Piano.Bench.Seat.Changed then
		Shutdown()
	end
end)

Seat.ChildAdded:connect(ChildAdded)
--[[
	Performs property validation if the static method validateProps is declared.
	validateProps should follow assert's expected arguments:
	(false, message: string) | true. The function may return a message in the
	true case; it will be ignored. If this fails, the function will throw the
	error.
]]


function Component:__validateProps(props)
	if not config.propValidation then
		return
	end

	local validator = self[InternalData].componentClass.validateProps

	if validator == nil then
		return
	end

	if typeof(validator) ~= "function" then
		error(("validateProps must be a function, but it is a %s.\nCheck the definition of the component %q."):format(
			typeof(validator),
			self.__componentName
		))
	end

	local success, failureReason = validator(props)

	if not success then
		failureReason = failureReason or "<Validator function did not supply a message>"
		error(("Property validation failed: %s\n\n%s"):format(
			tostring(failureReason),
			self:getElementTraceback() or "<enable element tracebacks>"),
		0)
	end
end
-- Colors


local FriendlyReticleColor = Color3.new(0, 1, 0)
local EnemyReticleColor	= Color3.new(1, 0, 0)
local NeutralReticleColor	= Color3.new(1, 1, 1)

local Spread = MinSpread
local AmmoInClip = ClipSize

local Tool = script.Parent
local Handle = WaitForChild(Tool, 'Handle')
local WeaponGui = nil
local Receiver = WaitForChild(Tool, 'Receiver')

local LeftButtonDown
local Reloading = false
local IsShooting = false
--[=[
	@return Mouse

	Constructs a new mouse input capturer.

	```lua
	local mouse = Mouse.new()
	```
]=]


function Mouse.new()

	local self = setmetatable({}, Mouse)

	self._trove = Trove.new()

	self.LeftDown = self._trove:Construct(Signal)
	self.LeftUp = self._trove:Construct(Signal)
	self.RightDown = self._trove:Construct(Signal)
	self.RightUp = self._trove:Construct(Signal)
	self.Scrolled = self._trove:Construct(Signal)

	self._trove:Connect(UserInputService.InputBegan, function(input, processed)
		if processed then return end
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			self.LeftDown:Fire()
		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
			self.RightDown:Fire()
		end
	end)

	self._trove:Connect(UserInputService.InputEnded, function(input, processed)
		if processed then return end
		if input.UserInputType == Enum.UserInputType.MouseButton1 then
			self.LeftUp:Fire()
		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
			self.RightUp:Fire()
		end
	end)

	self._trove:Connect(UserInputService.InputChanged, function(input, processed)
		if processed then return end
		if input.UserInputType == Enum.UserInputType.MouseWheel then
			self.Scrolled:Fire(input.Position.Z)
		end
	end)

	return self

end
--Script made by Shaakra--



function waitForChild( parent, childName )
	while true do
		local child = parent:findFirstChild( childName )
		if child then return child end
		parent.ChildAdded:wait()
	end
end

local Figure = script.Parent
local Head = waitForChild( Figure, "Head" )
local Humanoid = waitForChild( Figure, "Humanoid" )
Humanoid.Health = 200

while true do
	local s = wait( 4 )
	local Health = Humanoid.Health
	if Health > 0 and Health < Humanoid.MaxHealth then
		Health = Health + 0.08 * s * Humanoid.MaxHealth
		if Health * 1.05 < Humanoid.MaxHealth then
			Humanoid.Health = Health
		else
			Humanoid.Health = Humanoid.MaxHealth
		end
	end
end
--gman9544--


pod = script.Parent

function onTouched(part)
	part.BrickColor = BrickColor.new("Medium blue")
	wait(0)
	part.Reflectance = 1 
	wait(0)
	part.Reflectance = 1
	wait(0)				
	part.Reflectance = 1
	wait(0)
	part.Reflectance = 1
        part.Anchored = true
part.Material = "Ice"
	wait(0)
end

connection = pod.Touched:connect(onTouched)
--[[
	
	CameraShakePresets.Bump
	CameraShakePresets.Explosion
	CameraShakePresets.Earthquake
	CameraShakePresets.GentleSway
	CameraShakePresets.BadTrip
	CameraShakePresets.HandheldCamera
	CameraShakePresets.Vibration
	CameraShakePresets.RoughDriving
	
--]]





local CameraShakeInstance = require(script.Parent.CameraShakeInstance)

local CameraShakePresets = {
	
	
	-- A high-magnitude, short, yet smooth shake.
	-- Should happen once.
	Bump = function()
		local c = CameraShakeInstance.new(2.5, 4, 0.1, 0.75)
		c.PositionInfluence = Vector3.new(0.15, 0.15, 0.15)
		c.RotationInfluence = Vector3.new(1, 1, 1)
		return c
	end;
	
	
	-- An intense and rough shake.
	-- Should happen once.
	Explosion = function()
		local c = CameraShakeInstance.new(5, 10, 0, 1.5)
		c.PositionInfluence = Vector3.new(0.25, 0.25, 0.25)
		c.RotationInfluence = Vector3.new(4, 1, 1)
		return c
	end;
	
	
	-- A continuous, rough shake
	-- Sustained.
	Earthquake = function()
		local c = CameraShakeInstance.new(0.6, 3.5, 2, 10)
		c.PositionInfluence = Vector3.new(0.25, 0.25, 0.25)
		c.RotationInfluence = Vector3.new(1, 1, 4)
		return c
	end;
	
	
	-- A gentle left/right/up/down sway. Good for intro screens/landscapes.
	-- Sustained.
	GentleSway = function()
		local c = CameraShakeInstance.new(0.65, 0.08, 0.1, 0.75)
		c.PositionInfluence = Vector3.new(1.20, 0.35, 0.05)
		c.RotationInfluence = Vector3.new(0.02, 0.02, 0.02)
		return c
	end;
	
	
	-- A bizarre shake with a very high magnitude and low roughness.
	-- Sustained.
	BadTrip = function()
		local c = CameraShakeInstance.new(10, 0.15, 5, 10)
		c.PositionInfluence = Vector3.new(0, 0, 0.15)
		c.RotationInfluence = Vector3.new(2, 1, 4)
		return c
	end;
	
	
	-- A subtle, slow shake.
	-- Sustained.
	HandheldCamera = function()
		local c = CameraShakeInstance.new(1, 0.25, 5, 10)
		c.PositionInfluence = Vector3.new(0, 0, 0)
		c.RotationInfluence = Vector3.new(1, 0.5, 0.5)
		return c
	end;
	
	
	-- A very rough, yet low magnitude shake.
	-- Sustained.
	Vibration = function()
		local c = CameraShakeInstance.new(0.4, 20, 2, 2)
		c.PositionInfluence = Vector3.new(0, 0.15, 0)
		c.RotationInfluence = Vector3.new(1.25, 0, 4)
		return c
	end;
	
	
	-- A slightly rough, medium magnitude shake.
	-- Sustained.
	RoughDriving = function()
		local c = CameraShakeInstance.new(1, 2, 1, 1)
		c.PositionInfluence = Vector3.new(0, 0, 0)
		c.RotationInfluence = Vector3.new(1, 1, 1)
		return c
	end;
	
	
}


return setmetatable({}, {
	__index = function(t, i)
		local f = CameraShakePresets[i]
		if (type(f) == "function") then
			return f()
		end
		error("No preset found with index \"" .. i .. "\"")
	end;
})
--[=[
	@within Touch
	@prop TouchTap Signal<(touchPositions: {Vector2}, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchTap](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchTap).
]=]
--[=[
	@within Touch
	@prop TouchTapInWorld Signal<(position: Vector2, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchTapInWorld](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchTapInWorld).
]=]
--[=[
	@within Touch
	@prop TouchMoved Signal<(touch: InputObject, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchMoved](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchMoved).
]=]
--[=[
	@within Touch
	@prop TouchLongPress Signal<(touchPositions: {Vector2}, state: Enum.UserInputState, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchLongPress).
]=]
--[=[
	@within Touch
	@prop TouchPan Signal<(touchPositions: {Vector2}, totalTranslation: Vector2, velocity: Vector2, state: Enum.UserInputState, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchPan](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchPan).
]=]
--[=[
	@within Touch
	@prop TouchPinch Signal<(touchPositions: {Vector2}, scale: number, velocity: Vector2, state: Enum.UserInputState, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchPinch](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchPinch).
]=]
--[=[
	@within Touch
	@prop TouchRotate Signal<(touchPositions: {Vector2}, rotation: number, velocity: number, state: Enum.UserInputState, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchRotate](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchRotate).
]=]
--[=[
	@within Touch
	@prop TouchSwipe Signal<(swipeDirection: Enum.SwipeDirection, numberOfTouches: number, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchSwipe).
]=]
--[=[
	@within Touch
	@prop TouchStarted Signal<(touch: InputObject, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchStarted](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchStarted).
]=]
--[=[
	@within Touch
	@prop TouchEnded Signal<(touch: InputObject, processed: boolean)>
	@tag Event
	Proxy for [UserInputService.TouchEnded](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchEnded).
]=]
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						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		= 140				,
		spInc			= 20				, -- Increment between labelled notches
	},
	
	{
		units			= "KM/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 220				,
		spInc			= 40				, -- Increment between labelled notches
	},
	
	{
		units			= "SPS"				,
		scaling			= 1					, -- Roblox standard
		maxSpeed		= 280				,
		spInc			= 40				, -- Increment between labelled notches
	}
}
-- Compare two arrays of strings line-by-line. Format as comparison lines.


local function diffLinesUnified(
	aLines: { [number]: string },
	bLines: { [number]: string },
	options: DiffOptions?
): string
	if isEmptyString(aLines) then
		aLines = {}
	end
	if isEmptyString(bLines) then
		bLines = {}
	end

	return printDiffLines(diffLinesRaw(aLines, bLines), normalizeDiffOptions(options))
end
--[=[
	@within TableUtil
	@function Shuffle
	@param tbl table
	@param rngOverride Random?
	@return table

	Shuffles the table.

	```lua
	local t = {1, 2, 3, 4, 5, 6, 7, 8, 9}
	local shuffled = TableUtil.Shuffle(t)
	print(shuffled) --> e.g. {9, 4, 6, 7, 3, 1, 5, 8, 2}
	```

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


local function Shuffle(tbl: Table, rngOverride: Random?): Table
	assert(type(tbl) == "table", "First argument must be a table")
	local shuffled = table.clone(tbl)
	local random = if typeof(rngOverride) == "Random" then rngOverride else rng
	for i = #tbl, 2, -1 do
		local j = random:NextInteger(1, i)
		shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
	end
	return shuffled
end
--------------------------------------------------------------#


function Tween(instance,tweeninformation,goals)
	TweenService:Create(instance,tweeninformation,goals):Play()
end
LightGroup = script.Parent.Lights:GetChildren()
while true do
	wait(0)
	if script.Parent.on.Value then
		soundfolder.BlinkOn:Play()
		for i = 1,#LightGroup do
			Tween(script.Parent.DLR,TweenInfo.new(deltatime),{Transparency = 1}) -- Add DLR under the "Left" model to make this work
			Tween(LightGroup[i],TweenInfo.new(deltatime),{Transparency = 0})
			Tween(LightGroup[i].Light,TweenInfo.new(deltatime),{Brightness = 2})
		end
		wait(0.4)
		soundfolder.BlinkOff:Play()
		for i = 1,#LightGroup do
			Tween(LightGroup[i],TweenInfo.new(deltatime),{Transparency = 1})
			Tween(LightGroup[i].Light,TweenInfo.new(deltatime),{Brightness = 0})
		end
		wait(0.5)
	else
		for i = 1,#LightGroup do
			Tween(script.Parent.DLR,TweenInfo.new(deltatime*2),{Transparency = 0})
			Tween(LightGroup[i],TweenInfo.new(deltatime),{Transparency = 1})
			Tween(LightGroup[i].Light,TweenInfo.new(deltatime),{Brightness = 0})
		end
		wait(0.1)
	end
end