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



local function __tostring(self)
	return self.ClassName
end

local function createClass(className, superClass)
	local class = {}
	class.__index = class
	class.__tostring = __tostring
	class.ClassName = className

	function class.new(...)
		local self = setmetatable({}, class)

		if self.__init then
			self:__init(...)
		end

		return self
	end

	if superClass then
		class.Super = superClass
		setmetatable(class, superClass)

		for methodName, shouldInherit in pairs(INHERITED) do
			if shouldInherit then
				class[methodName] = superClass[methodName]
			end
		end
	end

	return class
end
--[=[
	@param signal RBXScriptSignal
	@param fn (...: any) -> ()
	@return RBXScriptConnection
	Connects the function to the signal, adds the connection
	to the trove, and then returns the connection.

	This is shorthand for `trove:Add(signal:Connect(fn))`.

	```lua
	trove:Connect(workspace.ChildAdded, function(instance)
		print(instance.Name .. " added to workspace")
	end)
	```
]=]


function Trove:Connect(signal, fn)
	return self:Add(signal:Connect(fn))
end
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------



local toolAnimName = ""
local toolAnimTrack = nil
local toolAnimInstance = nil
local currentToolAnimKeyframeHandler = nil

function toolKeyFrameReachedFunc(frameName)
	if (frameName == "End") then
		playToolAnimation(toolAnimName, 0.0, Humanoid)
	end
end


function playToolAnimation(animName, transitionTime, humanoid, priority)	 		
		local idx = rollAnimation(animName)
		local anim = animTable[animName][idx].anim

		if (toolAnimInstance ~= anim) then
			
			if (toolAnimTrack ~= nil) then
				toolAnimTrack:Stop()
				toolAnimTrack:Destroy()
				transitionTime = 0
			end
					
			-- load it to the humanoid; get AnimationTrack
			toolAnimTrack = humanoid:LoadAnimation(anim)
			if priority then
				toolAnimTrack.Priority = priority
			end
			 
			-- play the animation
			toolAnimTrack:Play(transitionTime)
			toolAnimName = animName
			toolAnimInstance = anim

			currentToolAnimKeyframeHandler = toolAnimTrack.KeyframeReached:connect(toolKeyFrameReachedFunc)
		end
end

function stopToolAnimations()
	local oldAnim = toolAnimName

	if (currentToolAnimKeyframeHandler ~= nil) then
		currentToolAnimKeyframeHandler:disconnect()
	end

	toolAnimName = ""
	toolAnimInstance = nil
	if (toolAnimTrack ~= nil) then
		toolAnimTrack:Stop()
		toolAnimTrack:Destroy()
		toolAnimTrack = nil
	end

	return oldAnim
end
--// WIP


local function LoadPackage(package, folder, runNow)
	--// runNow - Run immediately after unpacking (default behavior is to just unpack (((only needed if loading after startup))))
	--// runNow currently not used (limitations) so all packages must be present at server startup
	local unpack; unpack = function(curFolder, unpackInto)
		if unpackInto then
			for i,obj in ipairs(curFolder:GetChildren()) do
				local clone = obj:Clone();
				if obj:IsA("Folder") then
					local realFolder = unpackInto:FindFirstChild(obj.Name);
					if not realFolder then
						clone.Parent = unpackInto;
					else
						unpack(obj, realFolder);
					end
				else
					clone.Parent = unpackInto;
				end
			end
		else
			warn("Missing parent to unpack into for ".. tostring(curFolder));
		end
	end;

	unpack(package, folder);
end;

local function CleanUp()
	--local env = getfenv(2)
	--local ran,ret = pcall(function() return env.script:GetFullName() end)
	warn("Beginning Adonis cleanup & shutdown process...")
	--warn("CleanUp called from "..tostring((ran and ret) or "Unknown"))
	--local loader = server.Core.ClientLoader
	server.Model.Name = "Adonis_Loader"
	server.Model.Parent = service.ServerScriptService
	server.Running = false

	pcall(service.Threads.StopAll)
	pcall(function()
		for i,v in pairs(RbxEvents) do
			print("Disconnecting event")
			v:Disconnect()
			table.remove(RbxEvents, i)
		end
	end)
	--loader.Archivable = false
	--loader.Disabled = true
	--loader:Destroy()
	if server.Core and server.Core.RemoteEvent then
		pcall(server.Core.DisconnectEvent);
	end

	--[[delay(0, function()
		for i,v in next,server do
			server[i] = nil; --// Try to break it to prevent any potential hanging issues; Not very graceful...
		end
	--end)--]]

	warn("Unloading complete")
end;

server = {
	Running = true;
	Modules = {};
	Pcall = Pcall;
	cPcall = cPcall;
	Routine = Routine;
	LogError = logError;
	ErrorLogs = ErrorLogs;
	ServerStartTime = os.time();
	CommandCache = {};
};

locals = {
	server = server;
	CodeName = "";
	Settings = server.Settings;
	HookedEvents = HookedEvents;
	ErrorLogs = ErrorLogs;
	logError = logError;
	origEnv = origEnv;
	Routine = Routine;
	Folder = Folder;
	GetEnv = GetEnv;
	cPcall = cPcall;
	Pcall = Pcall;
};

service = require(Folder.Shared.Service)(function(eType, msg, desc, ...)
	local extra = {...}
	if eType == "MethodError" then
		if server and server.Logs and server.Logs.AddLog then
			server.Logs.AddLog("Script", {
				Text = "Cached method doesn't match found method: "..tostring(extra[1]);
				Desc = "Method: "..tostring(extra[1])
			})
		end
	elseif eType == "ServerError" then
		--print("Server error")
		logError("Server", msg)
	elseif eType == "TaskError" then
		--print("Task error")
		logError("Task", msg)
	end
end, function(c, parent, tab)
	if not isModule(c) and c ~= server.Loader and c ~= server.Dropper and c ~= server.Runner and c ~= server.Model and c ~= script and c ~= Folder and parent == nil then
		tab.UnHook()
	end
end, ServiceSpecific, GetEnv(nil, {server = server}))
--[[Weld functions]]



	local JS = game:GetService("JointsService")
	local PGS_ON = workspace:PGSIsEnabled()
	
	function MakeWeld(x,y,type,s) 
		if type==nil then type="Weld" end
		local W=Instance.new(type,JS) 
		W.Part0=x W.Part1=y 
		W.C0=x.CFrame:inverse()*x.CFrame 
		W.C1=y.CFrame:inverse()*x.CFrame 
		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  end for _,v in ipairs(a:GetChildren()) do UnAnchor(v) end 
	end
-- functions



function stopAllAnimations()
	local oldAnim = currentAnim

	-- return to idle if finishing an emote
	if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
		oldAnim = "idle"
	end

	currentAnim = ""
	currentAnimInstance = nil
	if (currentAnimKeyframeHandler ~= nil) then
		currentAnimKeyframeHandler:disconnect()
	end

	if (currentAnimTrack ~= nil) then
		currentAnimTrack:Stop()
		currentAnimTrack:Destroy()
		currentAnimTrack = nil
	end

	-- clean up walk if there is one
	if (runAnimKeyframeHandler ~= nil) then
		runAnimKeyframeHandler:disconnect()
	end
	
	if (runAnimTrack ~= nil) then
		runAnimTrack:Stop()
		runAnimTrack:Destroy()
		runAnimTrack = nil
	end
	
	return oldAnim
end

local smallButNotZero = 0.0001
function setRunSpeed(speed)

	if speed < 0.33 then
		currentAnimTrack:AdjustWeight(1.0)		
		runAnimTrack:AdjustWeight(smallButNotZero)
	elseif speed < 0.66 then
		local weight = ((speed - 0.33) / 0.33)
		currentAnimTrack:AdjustWeight(1.0 - weight + smallButNotZero)
		runAnimTrack:AdjustWeight(weight + smallButNotZero)
	else
		currentAnimTrack:AdjustWeight(smallButNotZero)
		runAnimTrack:AdjustWeight(1.0)
	end
	
	local speedScaled = speed * 1.25
	runAnimTrack:AdjustSpeed(speedScaled)
	currentAnimTrack:AdjustSpeed(speedScaled)
end


function setAnimationSpeed(speed)
	if speed ~= currentAnimSpeed then
		currentAnimSpeed = speed
		if currentAnim == "walk" then
			setRunSpeed(speed)
		else
			currentAnimTrack:AdjustSpeed(currentAnimSpeed)
		end
	end
end

function keyFrameReachedFunc(frameName)
-- declarations


local sGettingUp = newSound("GettingUp", "rbxasset://sounds/action_get_up.mp3")
local sDied = newSound("Died", "rbxasset://sounds/uuhhh.mp3") 
local sFreeFalling = newSound("FreeFalling", "rbxasset://sounds/action_falling.mp3")
local sJumping = newSound("Jumping", "rbxasset://sounds/action_jump.mp3")
local sLanding = newSound("Landing", "rbxasset://sounds/action_jump_land.mp3")
local sSplash = newSound("Splash", "rbxasset://sounds/impact_water.mp3")
local sRunning = newSound("Running", "rbxasset://sounds/action_footsteps_plastic.mp3")
sRunning.Looped = true
local sSwimming = newSound("Swimming", "rbxasset://sounds/action_swim.mp3")
sSwimming.Looped = true
local sClimbing = newSound("Climbing", "rbxasset://sounds/action_footsteps_plastic.mp3")
sClimbing.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid;
for _,Child in pairs(Figure:GetChildren())do
if Child and Child.ClassName=="Humanoid"then
Humanoid=Child;
end;
end;
local hasPlayer = game.Players:GetPlayerFromCharacter(script.Parent)

local prevState = "None"
--------RIGHT DOOR --------


game.Workspace.doorright.l11.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l12.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l13.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l21.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l22.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l23.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l31.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l33.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l42.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l43.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l52.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l61.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l62.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l63.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l72.BrickColor = BrickColor.new(194)
game.Workspace.doorright.l73.BrickColor = BrickColor.new(194)
game.Workspace.doorright.pillar.BrickColor = BrickColor.new(194)
--- RUNTIME ---



local Tool = {}

Tool.MouseButton1 = function(Character)
	if Character:GetAttribute("Cooldown") == true then return end
	Character:SetAttribute("Cooldown", true)
	
	local Tool = Character[script.Name]
	
	local Animation = Character.Humanoid:LoadAnimation(script["Animation"..AnimationStep])
	AnimationStep += 1
	
	if AnimationStep >= 3 then
		AnimationStep = 1
	end
	
	Animation:Play()
	
	local OGWalkSpeed = Character.Humanoid.WalkSpeed
	Character.Humanoid.WalkSpeed = 0

	Tool.Handle.Swing:Play()

	task.wait(0.47)
	
	local ConnectionA = nil
	Tool.Handle.Touched:Connect(function(Hit)
		if Hit.Parent:FindFirstChild("Humanoid") and Hit.Parent ~= Character and not table.find(HitEntities, Hit.Parent) and Hit.Parent.Parent == workspace.Enemies then

			table.insert(HitEntities, Hit.Parent)
			
				Tool.Handle.Hit:Play()
				
				Hit.Parent.Humanoid:TakeDamage(35)
				
				local boopyve = Instance.new("BodyVelocity")
				boopyve.Velocity = Character.Torso.CFrame.LookVector * 5
				boopyve.MaxForce = Vector3.new(math.huge, math.huge, math.huge)
				boopyve.Parent = Hit.Parent.HumanoidRootPart
				game.Debris:AddItem(boopyve, .15)
			
		end
	end)
	
	task.wait(0.43)
	
	Animation:Stop(.25)
	
	Character.Humanoid.WalkSpeed = OGWalkSpeed
	
	Character:SetAttribute("Cooldown", false)
	
	table.clear(HitEntities)
end



return Tool
--Springs--



frontstiffness = 1290 * StiffnessFront 
frontdamping = 40 *  StiffnessFront /1.5
rearstiffness = 1290 * StiffnessRear 
reardamping = 40 * StiffnessRear /1.5

minLF = SuspensionTravelF
minLR = SuspensionTravelR
maxL = ((RideHeightRear + RideHeightFront)/2) + 4

ffl = RideHeightFront+2
rfl = RideHeightRear+2

local springFL = Instance.new("SpringConstraint", SFL)
springFL.Attachment0 = SFL.Attachment
springFL.Attachment1 = SSML.Attachment
springFL.Damping = frontdamping
springFL.FreeLength = ffl
springFL.Stiffness = frontstiffness
springFL.Visible = false
springFL.LimitsEnabled = true
springFL.MinLength = minLF
springFL.MaxLength = maxL

local springFR = Instance.new("SpringConstraint", SFR)
springFR.Attachment0 = SFR.Attachment
springFR.Attachment1 = SSMR.Attachment
springFR.Damping = frontdamping
springFR.FreeLength = ffl
springFR.Stiffness = frontstiffness
springFR.Visible = false
springFR.LimitsEnabled = true
springFR.MinLength = minLF
springFR.MaxLength = maxL

local springRL = Instance.new("SpringConstraint", SRL)
springRL.Attachment0 = SRL.Attachment
springRL.Attachment1 = BRL.Attachment
springRL.Damping = reardamping
springRL.FreeLength = rfl
springRL.Stiffness = rearstiffness
springRL.Visible = false
springRL.LimitsEnabled = true
springRL.MinLength = minLR
springRL.MaxLength = maxL

local springRR = Instance.new("SpringConstraint", SRR)
springRR.Attachment0 = SRR.Attachment
springRR.Attachment1 = BRR.Attachment
springRR.Damping = reardamping
springRR.FreeLength = rfl
springRR.Stiffness = rearstiffness
springRR.Visible = false
springRR.LimitsEnabled = true
springRR.MinLength = minLR
springRR.MaxLength = maxL


local XSteeringL = Instance.new("HingeConstraint", SSL)
XSteeringL.Attachment0 = SSL.Attachment
XSteeringL.Attachment1 = SSML.Attachment
XSteeringL.ActuatorType = "Motor"
XSteeringL.LimitsEnabled = true
XSteeringL.LowerAngle = SteeringAngle*-1
XSteeringL.UpperAngle = SteeringAngle
XSteeringL.MotorMaxTorque = 200000

local XSteeringR = Instance.new("HingeConstraint", SSR)
XSteeringR.Attachment0 = SSR.Attachment
XSteeringR.Attachment1 = SSMR.Attachment
XSteeringR.ActuatorType = "Motor"
XSteeringR.LimitsEnabled = true
XSteeringR.LowerAngle = SteeringAngle*-1
XSteeringR.UpperAngle = SteeringAngle
XSteeringR.MotorMaxTorque = 200000

local BGL = Instance.new("BodyGyro")
BGL.Parent = xSSL
BGL.Name = "Gyro"
BGL.D = 180
BGL.MaxTorque = Vector3.new(900, 0, 900)
BGL.P = 300

local BGR = Instance.new("BodyGyro")
BGR.Parent = xSSR
BGR.Name = "Gyro"
BGR.D = 180
BGR.MaxTorque = Vector3.new(900, 0, 900)
BGR.P = 300

local flip = Instance.new("BodyGyro", script.Parent)
flip.Name = "Flip"
flip.D = 1000
flip.MaxTorque = Vector3.new(0,0,0)
flip.P = 30000
----- water handler -----



while true do
	if script.Parent.HotOn.Value == true and script.Parent.ColdOn.Value == true and script.Parent.Plugged.Value == true and water.Scale.Y <= 0.6 then -- if BOTH ON and PLUGGED		
		water.Scale = water.Scale + Vector3.new(0, 0.01, 0)
		water.Offset = Vector3.new(0, water.Scale.Y/2, 0)
		hotWater = hotWater + 1
		coldWater = coldWater + 1
		drainSound:Stop()
	elseif (script.Parent.HotOn.Value == true or script.Parent.ColdOn.Value == true) and script.Parent.Plugged.Value == true and water.Scale.Y <= 0.6 then -- if ON and PLUGGED
		water.Scale = water.Scale + Vector3.new(0, 0.01, 0)
		water.Offset = Vector3.new(0, water.Scale.Y/2, 0)
		if script.Parent.HotOn.Value == true then
			hotWater = hotWater + 1
		else
			coldWater = coldWater + 1
		end
		drainSound:Stop()
	elseif (script.Parent.HotOn.Value == true or script.Parent.ColdOn.Value == true) and script.Parent.Plugged.Value == false and water.Scale.Y <= 0.6 then -- if ON and NOT PLUGGED
		if script.Parent.HotOn.Value == true then
			coldWater = coldWater - 1			
		else
			hotWater = hotWater - 1
		end
		drainSound:Stop()
	elseif (script.Parent.HotOn.Value == false and script.Parent.ColdOn.Value == false) and script.Parent.Plugged.Value == false and water.Scale.Y > 0 then -- if NOT ON and NOT PLUGGED
		water.Scale = water.Scale + Vector3.new(0, -0.02, 0)
		water.Offset = Vector3.new(0, water.Scale.Y/2, 0)
		coldWater = coldWater - 1
		hotWater = hotWater - 1
		drainSound.TimePosition = 0
		drainSound:Play()
	end
	
	if coldWater < 1 then
		coldWater = 1
	end
	if hotWater < 1 then
		hotWater = 1
	end
	
	waterTemp = hotWater/coldWater	
	
	if waterTemp > 1 then
		water.Parent.SteamEmitter.Enabled = true
	else
		water.Parent.SteamEmitter.Enabled = false
	end
	wait(0.1)
	
	if script.Parent.ColdOn.Value == true or script.Parent.HotOn.Value == true then
		script.Parent.Splash.ParticleEmitter.Enabled = true
	else
		script.Parent.Splash.ParticleEmitter.Enabled = false
	end
	
	if water.Scale.Y <= 0 then
		drainSound:Stop()
	end
end
-------------------------


function onClicked()
R.Function1.Disabled = true
R.Function2.Disabled = false
R.BrickColor = BrickColor.new("Institutional white")
g.DJM.MIX.BrickColor = BrickColor.new("Really black")
g.DJM.REMIX.BrickColor = BrickColor.new("Really red")
g.DJM.Screen.SurfaceGui.Menu.Visible = true
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
-- Variables to store waypoints table and zombie's current waypoint


local waypoints
local currentWaypointIndex

local function followPath(destinationObject)
	-- Compute and check the path
	path:ComputeAsync(zombie.Position, destinationObject)
	-- Empty waypoints table after each new path computation
	waypoints = {}

	if path.Status == Enum.PathStatus.Success then
		-- Get the path waypoints and start zombie walking
		waypoints = path:GetWaypoints()
		-- Move to first waypoint
		currentWaypointIndex = 1
		human:MoveTo(waypoints[currentWaypointIndex].Position)
	else
		-- Error (path not found); stop humanoid
		human:MoveTo(zombie.Position)
	end
end

local function onWaypointReached(reached)
	if reached and waypoints ~= nil and currentWaypointIndex ~= nil and currentWaypointIndex < #waypoints then
		currentWaypointIndex = currentWaypointIndex + 1
		human:MoveTo(waypoints[currentWaypointIndex].Position)
	end
end

local function onPathBlocked(blockedWaypointIndex)
	-- Check if the obstacle is further down the path
	if blockedWaypointIndex > currentWaypointIndex then
		-- Call function to re-compute the path
		followPath(destination)
	end
end
--[[**
	ensure value is an Instance and it's ClassName matches the given ClassName by an IsA comparison

	@param className The class name to check for

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


function t.instanceIsA(className, childTable)
	assert(t.string(className))

	local childrenCheck
	if childTable ~= nil then
		childrenCheck = t.children(childTable)
	end

	return function(value)
		local instanceSuccess, instanceErrMsg = t.Instance(value)
		if not instanceSuccess then
			return false, instanceErrMsg or ""
		end

		if not value:IsA(className) then
			return false, string.format("%s expected, got %s", className, value.ClassName)
		end

		if childrenCheck then
			local childrenSuccess, childrenErrMsg = childrenCheck(value)
			if not childrenSuccess then
				return false, childrenErrMsg
			end
		end

		return true
	end
end
--[=[
	Binds an update event to a signal until the update function stops returning a truthy
	value.

	@param signal Signal | RBXScriptSignal
	@param update () -> boolean -- should return true while it needs to update
	@return (...) -> () -- Connect function
	@return () -> () -- Disconnect function
]=]


function StepUtils.bindToSignal(signal, update)
	if typeof(signal) ~= "RBXScriptSignal" then
		error("signal must be of type RBXScriptSignal")
	end
	if type(update) ~= "function" then
		error(("update must be of type function, got %q"):format(type(update)))
	end

	local conn = nil
	local function disconnect()
		if conn then
			conn:Disconnect()
			conn = nil
		end
	end

	local function connect(...)
		-- Ignore if we have an existing connection
		if conn and conn.Connected then
			return
		end

		-- Check to see if we even need to bind an update
		if not update(...) then
			return
		end

		-- Avoid reentrance, if update() triggers another connection, we'll already be connected.
		if conn and conn.Connected then
			return
		end

		-- Usually contains just the self arg!
		local args = {...}

		-- Bind to render stepped
		conn = signal:Connect(function()
			if not update(unpack(args)) then
				disconnect()
			end
		end)
	end

	return connect, disconnect
end
-------------------LIGHTCONTROLS------------------- 


				if(key == "l") and (on == true) and (plane:findFirstChild("Lights") ~= nil) 
					and(light == true) then
					local lm = plane.Lights
					local val = plane.Values.Light
					if(val.Value == false) then
						for i,v in pairs(lm:GetChildren()) do 
							if(v.Name == "Posli") then 
								v.Gui.Enabled = true
							elseif(v.Name == "Flali") then 
									lm:findFirstChild("FlashScript").Disabled = false
								end
							end
						val.Value = true
						elseif(val.Value == true) then 
						for i,v in pairs(lm:GetChildren()) do 
						if(v.Name == "Posli") then
							v.Gui.Enabled = false
						elseif(v.Name == "Flali") then
							lm:findFirstChild("FlashScript").Disabled = true 
							v.Gui.Enabled = false
						end
						end
						val.Value = false
					end
				end
--!strict
-- upstream: https://github.com/facebook/react/blob/92fcd46cc79bbf45df4ce86b0678dcef3b91078d/packages/react/src/ReactCurrentBatchConfig.js
--[[*
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @flow
]]
--[[
Classes.Dropdown

This class creates a dropdown that the user can select a list of options from.

Constructors:
	new(frame [instance], listFrame [instance])
		>
	Create(list[] [string], max [integer])
		> Creates a dropdown from the list with a max scrolling number.

Properties:
	Frame [instance]
		> The container frame for the dropdown. Can be used for positioning and resizing.
	ListFrame [instance]
 		> The contaienr frame for the dropdown list. Parented underneath the main container frame.

Methods:
	:Set(option [instance]) [void]
		> option is a child of the ListFrame and you can set it as the selected option of the dropdown with this method
	:Get() [instance]
		> Returns the selected option frame (which is again, a child of the ListFrame)
	:Show(bool [boolean])
		> Set whether the dropdown list is visible or not.
	:Destroy() [void]
		> Destroys the RadioButtonGroup and all the events, etc that were running it.

Events:
	.Changed:Connect(function(option [instance])
		> Fired when the user selects a new option from the dropdown list.
--]]