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


local Settings = {
	--	Rate: How many droplets spawn per second
	Rate = 8;

	--	Size: How large the droplets roughly are (in studs)
	Size = 0.1;

	--	Tint: What color the droplets are tinted (leave as nil for a default realistic light blue)
	Tint = Color3.fromRGB(226, 244, 255);

	--	Fade: How long it takes for a droplet to fade
	Fade = 1.5;
}

local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")

local UpVec = Vector3.new(0, 1, 0)
local DROPLET_SIZE = Vector3.new(1, 1, 1)
local EMPTY_CFRAME = CFrame.new()
-- These controllers handle only walk/run movement, jumping is handled by the
-- TouchJump controller if any of these are active


local ClickToMove = require(script:WaitForChild("ClickToMoveController"))
local TouchJump = require(script:WaitForChild("TouchJump"))

local VehicleController = require(script:WaitForChild("VehicleController"))

local CONTROL_ACTION_PRIORITY = Enum.ContextActionPriority.Default.Value

local FFlagUserFixMovementCameraStraightDownSuccess, FFlagUserFixMovementCameraStraightDownResult = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserFixMovementCameraStraightDown")
end)
local FFlagUserFixMovementCameraStraightDown = FFlagUserFixMovementCameraStraightDownSuccess and FFlagUserFixMovementCameraStraightDownResult
--		TeleportService:Teleport(placeID_Premium, player)


		
		local character = player.Character		
		local temp = Instance.new("Smoke")
		temp.Color = Color3.fromRGB(102,102,102)
		temp.Size = 0.1
		temp.RiseVelocity = 0.1
		temp.Parent = character.LowerTorso
		
		character.Humanoid.WalkSpeed += 8
	end
end)
-- Sometimes, e.g. when comparing two numbers, the output from jest-diff
-- does not contain more information than the 'Expected:' / 'Received:' already gives.
-- In those cases, we do not print a diff to make the output shorter and  not redundant.


function shouldPrintDiff(actual: any, expected: any)
	if typeof(actual) == "number" and typeof(expected) == "number" then
		return false
	end

	-- ROBLOX deviation: excluded if statement checking bigint types

	if typeof(actual) == "boolean" and typeof(expected) == "boolean" then
		return false
	end

	return true
end

function replaceMatchedToAsymmetricMatcher(
	replacedExpected: any,
	replacedReceived: any,
	expectedCycles: Array<any>,
	receivedCycles: Array<any>
)
	if not Replaceable.isReplaceable(replacedExpected, replacedReceived) then
		return {
			replacedExpected = replacedExpected,
			replacedReceived = replacedReceived,
		}
	end

	if
		Array.indexOf(expectedCycles, replacedExpected) ~= -1
		or Array.indexOf(receivedCycles, replacedReceived) ~= -1
	then
		return {
			replacedExpected = replacedExpected,
			replacedReceived = replacedReceived,
		}
	end

	table.insert(expectedCycles, replacedExpected)
	table.insert(receivedCycles, replacedReceived)

	local expectedReplaceable = Replaceable.new(replacedExpected)
	local receivedReplaceable = Replaceable.new(replacedReceived)

	expectedReplaceable:forEach(function(expectedValue: any, key: any)
		local receivedValue = receivedReplaceable:get(key)
		if isAsymmetricMatcher(expectedValue) then
			if expectedValue:asymmetricMatch(receivedValue) then
				receivedReplaceable:set(key, expectedValue)
			end
		elseif isAsymmetricMatcher(receivedValue) then
			if receivedValue:asymmetricMatch(expectedValue) then
				expectedReplaceable:set(key, receivedValue)
			end
		elseif Replaceable.isReplaceable(expectedValue, receivedValue) then
			local replaced = replaceMatchedToAsymmetricMatcher(
				expectedValue,
				receivedValue,
				expectedCycles,
				receivedCycles
			)
			expectedReplaceable:set(key, replaced.replacedExpected)
			receivedReplaceable:set(key, replaced.replacedReceived)
		end
	end)

	return {
		replacedExpected = expectedReplaceable.object,
		replacedReceived = receivedReplaceable.object,
	}
end
--[[
	
	CameraShakePresets.Bump
	CameraShakePresets.Explosion
	CameraShakePresets.Earthquake
	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.8, 4.5, 3, 12)
		c.PositionInfluence = Vector3.new(0.45, 0.45, 0.45)
		c.RotationInfluence = Vector3.new(2, 2, 5)
		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;
})
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,VRecoil = {7,12}				--- Vertical Recoil
	,HRecoil = {6,8}				--- Horizontal Recoil
	,AimRecover = .85				---- Between 0 & 1
	
	,RecoilPunch = .15
	,VPunchBase = 3.75				--- Vertical Punch
	,HPunchBase = 2.5				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .25
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = .25
	
	,MinSpread = 1.75				--- Min bullet spread value | Studs
	,MaxSpread = 40					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 1
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1.5					--- Max sway value based on player stamina | Studs
--Rescripted by Luckymaxer



Tool = script.Parent
Handle = Tool:WaitForChild("Handle")

Players = game:GetService("Players")

ServerControl = Tool:WaitForChild("ServerControl")
ClientControl = Tool:WaitForChild("ClientControl")

ClientControl.OnClientInvoke = (function(Mode, Value)
	if Mode == "PlaySound" and Value then
		Value:Play()
	end
end)

function InvokeServer(Mode, Value, arg)
	pcall(function()
		ServerControl:InvokeServer(Mode, Value, arg)
	end)
end

function Equipped(Mouse)
	local Character = Tool.Parent
	local Player = Players:GetPlayerFromCharacter(Character)
	local Humanoid = Character:FindFirstChild("Humanoid")
	if not Player or not Humanoid or Humanoid.Health == Humanoid.Heath - 100 then
		return
	end
	Mouse.Button1Down:connect(function()
		InvokeServer("Click", true, Mouse.Hit.p)
	end)
end

local function Unequipped()
	
end

Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)
--[=[
	Observes an attribute on an instance with a conditional statement.
	@param instance Instance
	@param attributeName string
	@param condition function | nil
	@return Observable<Brio<any>>
]=]


function RxAttributeUtils.observeAttributeBrio(instance, attributeName, condition)
	assert(typeof(instance) == "Instance", "Bad instance")
	assert(type(attributeName) == "string", "Bad attributeName")

	return Observable.new(function(sub)
		local maid = Maid.new()
		local lastValue = UNSET_VALUE

		local function handleAttributeChanged()
			local attributeValue = instance:GetAttribute(attributeName)

			-- Deferred events can cause multiple values to be queued at once
			-- but we operate at this post-deferred layer, so lets only output
			-- reflected values.
			if lastValue ~= attributeValue then
				lastValue = attributeValue

				if not condition or condition(attributeValue) then
					local brio = Brio.new(attributeValue)
					maid._lastBrio = brio

					-- The above line can cause us to be overwritten so make sure before firing.
					if maid._lastBrio == brio then
						sub:Fire(brio)
					end
				else
					maid._lastBrio = nil
				end
			end
		end

		maid:GiveTask(instance:GetAttributeChangedSignal(attributeName):Connect(handleAttributeChanged))
		handleAttributeChanged()

		return maid
	end)
end

return RxAttributeUtils
-- Converts a Color3 in RGB space to a Vector3 in Oklab space.


function Oklab.to(rgb: Color3): Vector3
	local l = rgb.R * 0.4122214708 + rgb.G * 0.5363325363 + rgb.B * 0.0514459929
	local m = rgb.R * 0.2119034982 + rgb.G * 0.6806995451 + rgb.B * 0.1073969566
	local s = rgb.R * 0.0883024619 + rgb.G * 0.2817188376 + rgb.B * 0.6299787005

    local lRoot = l ^ (1/3)
    local mRoot = m ^ (1/3)
    local sRoot = s ^ (1/3)

    return Vector3.new(
        lRoot * 0.2104542553 + mRoot * 0.7936177850 - sRoot * 0.0040720468,
        lRoot * 1.9779984951 - mRoot * 2.4285922050 + sRoot * 0.4505937099,
        lRoot * 0.0259040371 + mRoot * 0.7827717662 - sRoot * 0.8086757660
	)
end
------------


Player.Character.Torso["Left Shoulder"]:destroy()
glue111 = Instance.new("Glue", Player.Character.Torso)
glue111.Part0 = Player.Character.Torso
glue111.Part1 = leftarm
glue111.Name = "Left shoulder"
collider111 = Instance.new("Part", leftarm)
collider111.Position = Vector3.new(0,9999,0)
collider111.Size = Vector3.new(1.5, 1, 1)
collider111.Shape = "Cylinder"
local weld111 = Instance.new("Weld", collider111)
weld111.Part0 = leftarm
weld111.Part1 = collider111
weld111.C0 = CFrame.new(0,-0.2,0) * CFrame.fromEulerAnglesXYZ(0, 0, math.pi/2)
collider111.TopSurface = "Smooth"
collider111.BottomSurface = "Smooth"
collider111.formFactor = "Symmetric"
glue111.C0 = CFrame.new(-1.5, 0.5, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)
glue111.C1 = CFrame.new(0, 0.5, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)
collider111.Transparency = 1
--Main Control------------------------------------------------------------------------


Red = script.Parent.Red.Lamp
Yellow = script.Parent.Yellow.Lamp
Green = script.Parent.Green.Lamp
DRed = script.Parent.Red.DynamicLight
DYellow = script.Parent.Yellow.DynamicLight
DGreen = script.Parent.Green.DynamicLight
	if Turn.Value == 0 then
		Green.Enabled = false
		Yellow.Enabled = false
		Red.Enabled = false
		DGreen.Enabled = false
		DYellow.Enabled = false
		DRed.Enabled = false
	elseif Turn.Value == 1 then
		Green.Enabled = true
		Yellow.Enabled = false
		Red.Enabled = false
		DGreen.Enabled = true
		DYellow.Enabled = false
		DRed.Enabled = false
	elseif Turn.Value == 2 then
		Green.Enabled = false
		Yellow.Enabled = true
		Red.Enabled = false
		DGreen.Enabled = false
		DYellow.Enabled = true
		DRed.Enabled = false
	elseif Signal.Value == 3 then
		Green.Enabled = false
		Yellow.Enabled = false
		Red.Enabled = true
		DGreen.Enabled = false
		DYellow.Enabled = false
		DRed.Enabled = true
	elseif Turn.Value == 3 then
		while true do
		Red.Enabled = true
		Green.Enabled = false
		Yellow.Enabled = false
		DRed.Enabled = true
		DGreen.Enabled = false
		DYellow.Enabled = false
		wait(.5)
		Red.Enabled = false
		DRed.Enabled = false
		wait(.5)
		if Turn == 2 then break end
		if Turn == 1 then break end
		if Turn == 0 then break end
		if Signal ~= 3 then break end 
		if Signal ~= 0 then break end 
		end
	end
	wait()
end
--[=[
	@class RxLinkUtils
]=]



local require = require(script.Parent.loader).load(script)

local Brio = require("Brio")
local Maid = require("Maid")
local Observable = require("Observable")
local Rx = require("Rx")
local RxBrioUtils = require("RxBrioUtils")
local RxInstanceUtils = require("RxInstanceUtils")

local RxLinkUtils = {}
--Stickmasterluke
--A nice simple axe




sp=script.Parent

r=game:service("RunService")


anims={"RightSlash","LeftSlash","OverHeadSwing"}

basedamage=0 + (script.Parent.AddDam.Value/4)
slashdamage=0 + script.Parent.AddDam.Value
swingdamage=0 + script.Parent.AddDam.Value
damage=basedamage

sword=sp.Handle
sp.Taunting.Value=false

local SlashSound=Instance.new("Sound")
SlashSound.SoundId="rbxasset://sounds\\swordslash.wav"
SlashSound.Parent=sword
SlashSound.Volume=.7

local UnsheathSound=Instance.new("Sound")
UnsheathSound.SoundId="rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent=sword
UnsheathSound.Volume=0


function blow(hit)
	if (hit.Parent==nil) then return end -- happens when bullet hits sword
	local humanoid=hit.Parent:findFirstChild("Humanoid")
	local vCharacter=sp.Parent
	local vPlayer=game.Players:playerFromCharacter(vCharacter)
	local hum=vCharacter:findFirstChild("Humanoid") -- non-nil if sp held by a character
	if humanoid~=nil and humanoid~=hum and hum~=nil then
		-- final check, make sure sword is in-hand
		local right_arm=vCharacter:FindFirstChild("Right Arm")
		if (right_arm~=nil) then
			local joint=right_arm:FindFirstChild("RightGrip")
			if (joint~=nil and (joint.Part0==sword or joint.Part1==sword)) then
				tagHumanoid(humanoid, vPlayer)
				humanoid:TakeDamage(damage)
				wait(1)
				untagHumanoid(humanoid)
			end
		end
	end
end


function tagHumanoid(humanoid, player)
	local creator_tag=Instance.new("ObjectValue")
	creator_tag.Value=player
	creator_tag.Name="creator"
	creator_tag.Parent=humanoid
end

function untagHumanoid(humanoid)
	if humanoid~=nil then
		local tag=humanoid:findFirstChild("creator")
		if tag~=nil then
			tag.Parent=nil
		end
	end
end

sp.Enabled=true
function onActivated()
	if sp.Enabled and not sp.Taunting.Value then
		sp.Enabled=false
		local character=sp.Parent;
		local humanoid=character.Immortal
		if humanoid==nil then
			print("Humanoid not found")
			return 
		end
		SlashSound:play()
		newanim=anims[math.random(1,#anims)]
		while newanim==sp.RunAnim.Value do
			newanim=anims[math.random(1,#anims)]
		end
		sp.RunAnim.Value=newanim
		if newanim=="OverHeadSwing" then
			damage=swingdamage
		else
			damage=slashdamage
		end
		wait(1)
		damage=basedamage
		sp.Enabled=true
	end
end

function onEquipped()
	UnsheathSound:play()
end

sp.Activated:connect(onActivated)
sp.Equipped:connect(onEquipped)

connection=sword.Touched:connect(blow)
--[[ 
	
	HOW TO USE THIS PLUGIN:
	
	In the body, everything except the wheels are set to be non-cancollidable.
	For hitboxes, or any part that you'd like to be cancollidable, name them "Hitbox".
	
	THE SCRIPT WILL ONLY ENABLE CANCOLLIDE ON PARTS NAMED "Hitbox"!
	
]]

--
-- places a brick at pos and returns the position of the brick's opposite corner


function placeBrick(cf, pos)
	local brick = Instance.new("Part")
	brick.Size = Vector3.new(brickWidth, brickHeight, brickDepth)
	brick.BrickColor = colors[math.random(1, #colors)]
	brick.Friction = .01
	brick.CFrame = cf * CFrame.new(pos + brick.size / 2)

	if ( math.random() > .5) then
		brick.Material = Enum.Material.Ice
	else
		brick.Transparency = .1 + (math.random(1,4) / 10)
	end

	brick.Parent = game.Workspace
	brick:makeJoints()
	return  brick, pos +  brick.size
end

function buildWall(cf)

	local bricks = {}

	assert(wallWidth>0)
	local y = 0
	while y < wallHeight do
		local p
		local x = -wallWidth/2
		while x < wallWidth/2 do
			local brick
			brick, p = placeBrick(cf, Vector3.new(x, y, 0), color)
			x = p.x
			table.insert(bricks, brick)
			wait(brickSpeed)
		end
		y = p.y
	end

	return bricks

end


function snap(v)
	if math.abs(v.x)>math.abs(v.z) then
		if v.x>0 then
			return Vector3.new(1,0,0)
		else
			return Vector3.new(-1,0,0)
		end
	else
		if v.z>0 then
			return Vector3.new(0,0,1)
		else
			return Vector3.new(0,0,-1)
		end
	end
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

	local targetPos = humanoid.TargetPoint
	local lookAt = snap( (targetPos - character.Head.Position).unit )
	local cf = CFrame.new(targetPos, targetPos + lookAt)

	if (targetPos - character.Torso.Position).magnitude < 64 then
		staffOut()
		Tool.Handle.UseSound:Play()
		buildWall(cf)
		staffUp()
		wait(5)
	end

	Tool.Enabled = true
end

script.Parent.Activated:connect(onActivated)
--[[Engine]]
--Torque Curve


Tune.Horsepower		= 280		--	[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
--All sounds are referenced by this ID


local SFX = {
	Died = 0;
	Running = 1;
	Swimming = 2;
	Climbing = 3,
	Jumping = 4;
	GettingUp = 5;
	FreeFalling = 6;
	FallingDown = 7;
	Landing = 8;
	Splash = 9;
}

local Humanoid = nil
local Head = nil
-- Works backwards, joining the arguments until it resolves to an absolute path.
-- If an absolute path is not resolved, then the current working directory is
-- prepended


function Path:resolve(...: string)
	local paths: Array<string> = { ... }
	local resolvedpath = ""
	local resolveddrive = nil
	local isabsolute = false
	for i = #paths, 1, -1 do
		local path = paths[i]
		if path and path ~= "" then
			local root = resolveddrive and self:getRoot(path)
			if self:isDriveRelative(path) then
				root = root or self:getRoot(path)
				resolveddrive = resolveddrive or root
				path = path:sub(root:len() + 1)
			end
			if not root or resolveddrive:sub(1, 2) == root:sub(1, 2) then
				resolvedpath = self:join(self:normalize(path), resolvedpath)
				if self:isAbsolute(resolvedpath) then
					isabsolute = true
					break
				end
			end
		end
	end
	if not isabsolute then
		if resolveddrive then
			local drivecwd = process.env["=" .. resolveddrive]
			if drivecwd and self:pathsEqual(drivecwd:sub(1, 2), resolveddrive) then
				resolvedpath = self:join(drivecwd, resolvedpath)
			else
				resolvedpath = self:join(resolveddrive, resolvedpath)
			end
		else
			resolvedpath = self:join(process.cwd(), resolvedpath)
		end
	end

	local trailing_slashes = resolvedpath:match("[" .. self.sep .. "]*$")
	if trailing_slashes then
		resolvedpath = resolvedpath:sub(1, -trailing_slashes:len() - 1)
	end

	return resolvedpath
end
--[=[
	@within TableUtil
	@function Sync
	@param srcTbl table -- Source table
	@param templateTbl table -- Template table
	@return table

	Synchronizes the `srcTbl` based on the `templateTbl`. This will make
	sure that `srcTbl` has all of the same keys as `templateTbl`, including
	removing keys in `srcTbl` that are not present in `templateTbl`. This
	is a _deep_ operation, so any nested tables will be synchronized as
	well.

	```lua
	local template = {kills = 0, deaths = 0, xp = 0}
	local data = {kills = 10, experience = 12}
	data = TableUtil.Sync(data, template)
	print(data) --> {kills = 10, deaths = 0, xp = 0}
	```

	:::caution Data Loss Warning
	This is a two-way sync, so the source table will have data
	_removed_ that isn't found in the template table. This can
	be problematic if used for player data, where there might
	be dynamic data added that isn't in the template.

	For player data, use `TableUtil.Reconcile` instead.
]=]


local function Sync(srcTbl: Table, templateTbl: Table): Table

	assert(type(srcTbl) == "table", "First argument must be a table")
	assert(type(templateTbl) == "table", "Second argument must be a table")

	local tbl = table.clone(srcTbl)

	-- If 'tbl' has something 'templateTbl' doesn't, then remove it from 'tbl'
	-- If 'tbl' has something of a different type than 'templateTbl', copy from 'templateTbl'
	-- If 'templateTbl' has something 'tbl' doesn't, then add it to 'tbl'
	for k,v in pairs(tbl) do

		local vTemplate = templateTbl[k]

		-- Remove keys not within template:
		if vTemplate == nil then
			tbl[k] = nil

		-- Synchronize data types:
		elseif type(v) ~= type(vTemplate) then
			if type(vTemplate) == "table" then
				tbl[k] = Copy(vTemplate, true)
			else
				tbl[k] = vTemplate
			end

		-- Synchronize sub-tables:
		elseif type(v) == "table" then
			tbl[k] = Sync(v, vTemplate)
		end

	end

	-- Add any missing keys:
	for k,vTemplate in pairs(templateTbl) do

		local v = tbl[k]

		if v == nil then
			if type(vTemplate) == "table" then
				tbl[k] = Copy(vTemplate, true)
			else
				tbl[k] = vTemplate
			end
		end

	end

	return tbl

end
--------------------------------------------------------------
-- Connection



local Connection = {}
Connection.__index = Connection

function Connection.new(event, connection)
	local self = setmetatable({
		_conn = connection;
		_event = event;
		Connected = true;
	}, Connection)
	return self
end

function Connection:IsConnected()
	if self._conn then
		return self._conn.Connected
	end
	return false
end

function Connection:Disconnect()
	if self._conn then
		self._conn:Disconnect()
		self._conn = nil
	end
	if not self._event then return end
	self.Connected = false
	local connections = self._event._connections
	for i,c in ipairs(connections) do
		if c == self then
			connections[i] = connections[#connections]
			connections[#connections] = nil
			break
		end
	end
	self._event = nil
end

Connection.Destroy = Connection.Disconnect
-- Editable Values


local TurboId = 240323039
local SuperId = 404779487
local BovId = 3568930062

local TurboVol = .025				--Per Psi
local TurboRollOffMax = 1000
local TurboRollOffMin = 10

local SuperVol = .1				--Per Psi
local SuperRollOffMax = 1000
local SuperRollOffMin = 10

local BovVol = .025				--Per Psi
local BovRollOffMax = 1000
local BovRollOffMin = 10
local BovSensitivity = .5

local TurboSetPitch = 1		--Base Pitch
local SuperSetPitch = .8	--Base Pitch
local BovSetPitch = .7		--Base Pitch
local TurboPitchIncrease = .05	--Per Psi
local SuperPitchIncrease = .05	--Per Psi
local BovPitchIncrease = .05	--Per Psi

local FE=true
--------LEFT DOOR 3--------


game.Workspace.doorleft.l71.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l72.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l63.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l62.BrickColor = BrickColor.new(135)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(135)

game.Workspace.doorleft.l11.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l12.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l13.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l42.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l43.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l22.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l23.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l52.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l32.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l33.BrickColor = BrickColor.new(102)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(102)