Roblox/luau_corpus huggingface dataset:
--[[
function onKeyDown(key)
	local Character = Tool.Parent
	if Character:findFirstChild("Humanoid") == nil then return end
	if game.Players:GetPlayerFromCharacter(Character) == nil then return end
	local Humanoid = Character.Humanoid
	if Humanoid.Health < 0.01 then return end

	if key == "" then
	end
end
]]
function SetCollide()
	if Tool:IsDescendantOf(game.Workspace) == true then
		Tool.On.Value = false
		for i = 1, #ToolPart do
			if ToolPart[i].className == "Part" then
				if ToolPart[i]:findFirstChild("Collide") ~= nil then
					if ToolPart[i]["Collide"].Value == false then
					ToolPart[i].CanCollide = false
					end
				else
					ToolPart[i].CanCollide = true
				end
			end
		end
	end
	if Tool:IsDescendantOf(game.Players) == true then
		for i = 1, #ToolPart do
			if ToolPart[i].className == "Part" then
			ToolPart[i].CanCollide = false
			end
		end
	end
end


Tool.Equipped:connect(Equip)
Tool.Unequipped:connect(Unequip)
--[[Drivetrain]]	
	Tune.Config			= "RWD"		--"FWD" , "RWD" , "AWD"
	Tune.TorqueVector	= 0			--AWD ONLY, "-1" has a 100% front bias, "0" has a 50:50 bias, and "1" has a 100% rear bias. Can be any number between that range.
	
	--Differential Settings	
	Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 50		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 80		-- 1 - 100%
	Tune.RDiffLockThres	= 20		-- 0 - 100%
	Tune.CDiffSlipThres	= 50		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 50		-- 0 - 100%				[AWD Only]
	
	--Traction Control Settings
	Tune.TCSEnabled		= false		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)
-- If you want to know how to retexture a hat, read this:  http://www.roblox.com/Forum/ShowPost.aspx?PostID=10502388








debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "Hat"   -- It doesn't make a difference, but if you want to make your place in Explorer neater, change this to the name of your hat.
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle" 
		p.formFactor = 0
		p.Size = Vector3.new(-0,-0,-1) 
		p.BottomSurface = 0 
		p.TopSurface = 0 
		p.Locked = true 
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentPos = Vector3.new(0, 0.35, 0.15) -- Change these to change the positiones of your hat, as I said earlier.
		wait(5)		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)
-- Open or close dev console
return function()
	local visible = starterGui:GetCore("DevConsoleVisible")
	starterGui:SetCore("DevConsoleVisible", not visible)
end
--[[ 
Hey, this is Cancels!
	Today I bring to you the Cancels CoreGui Settings, an invention by ... well
	... ROBLOX. 
	
	If you want to change a setting, do it like this!
	
	"true" = WILL show.
	"false" = WILL show.
	
	Don't mess with anything else.
	
	Bye, and cheers for taking!
			-Cancels
--]]

Health_Bar = false
Player_List = true
Tool_Bar = true
Chat = true
--/CONFIG

local hoursInDay = dayEnd-dayStart
local hoursInNight = 24-hoursInDay
local day = true

local originalFog = game.Lighting.FogColor

while true do
	local updateDelta = wait(updateTick)
	local step = 0
	if game.Lighting.ClockTime >=dayStart and game.Lighting.ClockTime <=dayEnd then
		step = hoursInDay/daytimeInSeconds
		if not day then
			day = true
			local tween = TweenService:Create(game.Lighting,FogTweenInfo,{FogColor = originalFog})
			tween:Play()
		end
	else
		step = hoursInNight/nightInSeconds
		if day then
			day = false
			local tween = TweenService:Create(game.Lighting,FogTweenInfo,{FogColor = Color3.fromRGB(50, 56, 66)})
			tween:Play()
		end
	end
	game.Lighting.ClockTime += step*updateDelta
end
--- Basic node interacting with the octree
-- @classmod OctreeNode
local OctreeRegionUtils = require(script.Parent.OctreeRegionUtils)

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

function OctreeNode.new(octree, object)
	local self = setmetatable({}, OctreeNode)

	self._octree = octree or error("No octree")
	self._object = object or error("No object")

	self._currentLowestRegion = nil
	self._position = nil

	return self
end

function OctreeNode:KNearestNeighborsSearch(k, radius)
	return self._octree:KNearestNeighborsSearch(self._position, k, radius)
end

function OctreeNode:GetObject()
	return self._object
end

function OctreeNode:RadiusSearch(radius)
	return self._octree:RadiusSearch(self._position, radius)
end

function OctreeNode:GetPosition()
	return self._position
end

function OctreeNode:GetRawPosition()
	return self._px, self._py, self._pz
end

function OctreeNode:SetPosition(position)
	if self._position == position then
		return
	end

	local px, py, pz = position.x, position.y, position.z

	self._px = px
	self._py = py
	self._pz = pz
	self._position = position

	if self._currentLowestRegion then
		if OctreeRegionUtils.inRegionBounds(self._currentLowestRegion, px, py, pz) then
			return
		end
	end

	local newLowestRegion = self._octree:GetOrCreateLowestSubRegion(px, py, pz)

	-- Sanity check for debugging
	-- if not OctreeRegionUtils.inRegionBounds(newLowestRegion, px, py, pz) then
	-- 	error("[OctreeNode.SetPosition] newLowestRegion is not in region bounds!")
	-- end

	if self._currentLowestRegion then
		OctreeRegionUtils.moveNode(self._currentLowestRegion, newLowestRegion, self)
	else
		OctreeRegionUtils.addNode(newLowestRegion, self)
	end

	self._currentLowestRegion = newLowestRegion
end

function OctreeNode:Destroy()
	if self._currentLowestRegion then
		OctreeRegionUtils.removeNode(self._currentLowestRegion, self)
	end
end

return OctreeNode
--// All global vars will be wiped/replaced except script

return function(data, env)
	if env then
		setfenv(1, env)
	end
	
	local playergui = service.PlayerGui
	local localplayer = service.Players.LocalPlayer
	local scr = client.UI.Prepare(script.Parent.Parent)
	local main = scr.Main
	local t1 = main.Title
	local t2 = main.Message
	local msg = data.Message
	local color = data.Color
	--[[
	local found = client.UI.Get("Output")
	if found then
		for i,v in pairs(found) do
			local p = v.Object
			if p and p.Parent then
				p.Main.Position = UDim2.new(0, 0, 0.35, p.Main.Position.Y.Offset+50)
			end
		end
	end--]]

	t2.Text = msg
	t2.Font = "Arial"
	--t2.Position = UDim2.new(0, 0, 0.35, 0)
	gTable.Ready()
	wait(5)
	gTable.Destroy()
end
---------------------------------
local force = Instance.new("BodyForce")
force.Parent = torso
f = force
Tool.Parent.Humanoid.WalkSpeed = 0
wait(0.01)
elseif ison == 0 then
if arms then
sh[1].Part1 = arms[1]
sh[2].Part1 = arms[2]
f.Parent = nil
arms[2].Name = "Right Leg"
arms[1].Name = "Left Leg"
welds[1].Parent = nil
welds[2].Parent = nil
Tool.Parent.Humanoid.WalkSpeed = 16
end
end
--local PlaceId = 12095647369
local Players = game:GetService("Players")
local DeathEvent = game.ReplicatedStorage.DeathEvent

script.Parent.MouseButton1Click:Connect(function()
	--game:GetService("TeleportService"):Teleport(game.PlaceId)
	Players.LocalPlayer.Character:WaitForChild("Humanoid").Health = 0
	
	DeathEvent:FireServer()
	
	print("1")
end)
--[[ TWEENS/LOCALS ]]--

local LoadingImage = script.Parent.ImageLabel
local tweenInfo = TweenInfo.new(4, Enum.EasingStyle.Linear, Enum.EasingDirection.In, -1)
local tween = TweenService:Create(LoadingImage, tweenInfo, {Rotation=360})
tween:Play()
--[=[
	Merges two arrays; array2 will be added to array1- this means that the indexes of array1 will be the same.
	
	```lua
	local FirstArray = {"A", "B", "C", "D"}
	local SecondArray = {"E", "F", "G", "H"}
	
	print(TableKit.MergeArrays(FirstArray, SecondArray)) -- prints {"A", "B", "C", D", "E", "F", "G", "H"}
	```

	@within TableKit
	@param array1 table
	@param array2 table
	@return table
]=]
function TableKit.MergeArrays<a, b>(a: { unknown }, b: { unknown }): a & b
	local result = table.clone(a)
	table.move(b, 1, #b, #result + 1, result)
	return result
end
-- << INFO >>
info.m1.Text = "Welcome back, "..main.player.Name.."!"
info.Take.MouseButton1Down:Connect(function()
	main.marketplaceService:PromptPurchase(main.player, 857927023)
end)
function module:UpdateProfileIcon()
	info.PlayerImage.Image = cf:GetUserImage(main.player.UserId)
end
function module:UpdateRankName()
	info.m2RankName.Text = "'".. cf:GetRankName(main.pdata.Rank).."'"
end
--Opening Hatch--	
	script.Parent.Parent.Part1:Remove()
	script.Parent.Parent.Part2:Remove()
	wait(1)
	script.Parent.Parent.Part3:Remove()
	script.Parent.Parent.Part4:Remove()
	wait(1)
	script.Parent.Parent.Part5:Remove()
	script.Parent.Parent.Part6:Remove()
--[[

	LEMBRANDO QUE esse module não está 100% pronto para usar, pois
	você caso as funções sejam chamadas várias vezes, ele irá bugar.
	Faça alguma forma de evitar isso, pois a ideia do module é apenas
	de dar as base das funções que envolvem uma parte mais "complexa"!

]]

local module = {}

local TweenService = game:GetService("TweenService")

local Sufixes = {'K','M','B','T','qd','Qn','sx','Sp','O','N','de','Ud','DD','tdD','qdD','QnD','sxD','SpD','OcD','NvD','Vgn','UVg','DVg','TVg','qtV','QnV','SeV','SPG','OVG','NVG','TGN','UTG','DTG','tsTG','qtTG','QnTG','ssTG','SpTG','OcTG','NoAG','UnAG','DuAG','TeAG','QdAG','QnAG','SxAG','SpAG','OcAG','NvAG','CT'}
local digitsProgression = 3

local defaultInfo = {
	Duration = .7,
	EasingStyle = Enum.EasingStyle.Exponential,
	EasingDirection = Enum.EasingDirection.Out
}

function module.formatNumber(number)
	
	local digits = math.floor(math.log10(math.abs(number)))
	
	local level = math.floor(digits/digitsProgression)
	
	if level >= 1 then
		level = math.clamp(level, 1, #Sufixes)
		
		local sufix = Sufixes[level]
		local divNumber = number / (10^digits)
		return string.format("%.2f %s", divNumber, sufix)
	end
	return string.format("%.2f", number)
end

function module.updateNumber(Label, oldValue, newValue, Info)
	Info = typeof(Info) == table and Info or defaultInfo
	
	local diference = newValue - oldValue
	local startTick = tick() 
	local endTick = startTick + Info.Duration
	repeat
		local currentTick = tick()
		local tickRatio = (currentTick-startTick)/(endTick-startTick)
		local tweenMultiplier = TweenService:GetValue(tickRatio, Info.EasingStyle, Info.EasingDirection)
		
		local nextNumber = oldValue + diference*tweenMultiplier
		Label.Text = module.formatNumber(nextNumber)
		
		task.wait()
	until tick() >= endTick
	Label.Text = module.formatNumber(newValue)
end

return module
--[[ The Module ]]--
local VRBaseCamera = require(script.Parent:WaitForChild("VRBaseCamera"))
local VRCamera = setmetatable({}, VRBaseCamera)
VRCamera.__index = VRCamera

function VRCamera.new()
	local self = setmetatable(VRBaseCamera.new(), VRCamera)

	self.lastUpdate = tick()
	self:Reset()

	return self
end

function VRCamera:Reset()
	self.needsReset = true
	self.needsBlackout = true
	self.motionDetTime = 0.0
	self.blackOutTimer = 0
	self.lastCameraResetPosition = nil
	self.stepRotateTimeout = 0.0
	self.cameraOffsetRotation = 0
	self.cameraOffsetRotationDiscrete = 0
end

function VRCamera:Update(timeDelta)
	local camera = workspace.CurrentCamera
	local newCameraCFrame = camera.CFrame
	local newCameraFocus = camera.Focus

	local player = PlayersService.LocalPlayer
	local humanoid = self:GetHumanoid()
	local cameraSubject = camera.CameraSubject

	if self.lastUpdate == nil or timeDelta > 1 then
		self.lastCameraTransform = nil
	end

	-- update fullscreen effects
	self:UpdateFadeFromBlack(timeDelta)
	self:UpdateEdgeBlur(player, timeDelta)

	local lastSubjPos = self.lastSubjectPosition
	local subjectPosition: Vector3 = self:GetSubjectPosition()
	-- transition from another camera or from spawn
	if self.needsBlackout then 
		self:StartFadeFromBlack()

		local dt = math.clamp(timeDelta, 0.0001, 0.1)
		self.blackOutTimer += dt
		if self.blackOutTimer > CAMERA_BLACKOUT_TIME and game:IsLoaded() then
			self.needsBlackout = false
			self.needsReset = true
		end
	end

	if subjectPosition and player and camera then
		newCameraFocus = self:GetVRFocus(subjectPosition, timeDelta)

		if self:IsInFirstPerson() then
			-- update camera CFrame
			newCameraCFrame, newCameraFocus = self:UpdateFirstPersonTransform(
				timeDelta,newCameraCFrame, newCameraFocus, lastSubjPos, subjectPosition)
		else -- 3rd person
			-- update camera CFrame
			newCameraCFrame, newCameraFocus = self:UpdateThirdPersonTransform(
				timeDelta, newCameraCFrame, newCameraFocus, lastSubjPos, subjectPosition)
		end

		self.lastCameraTransform = newCameraCFrame
		self.lastCameraFocus = newCameraFocus
	end

	self.lastUpdate = tick()
	return newCameraCFrame, newCameraFocus
end
-------- OMG HAX

r = game:service("RunService")


local damage = 5


local slash_damage = 12
local lunge_damage = 35

sword = script.Parent.Handle
Tool = script.Parent


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

local LungeSound = Instance.new("Sound")
LungeSound.SoundId = "rbxasset://sounds\\swordlunge.wav"
LungeSound.Parent = sword
LungeSound.Volume = .6

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


function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool 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


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end

function lunge()
	damage = lunge_damage

	LungeSound:play()

	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Lunge"
	anim.Parent = Tool
	
	
	force = Instance.new("BodyVelocity")
	force.velocity = Vector3.new(0,10,0) --Tool.Parent.Torso.CFrame.lookVector * 80
	force.Parent = Tool.Parent.Torso
	wait(.25)
	swordOut()
	wait(.25)
	force.Parent = nil
	wait(.5)
	swordUp()

	damage = slash_damage
end

function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
end

function swordAcross()
	-- parry
end


Tool.Enabled = true
local last_attack = 0
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

	t = r.Stepped:wait()

	if (t - last_attack < .2) then
		lunge()
	else
		attack()
	end

	last_attack = t

	--wait(.5)

	Tool.Enabled = true
end


function onEquipped()
	UnsheathSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
--------------------------------------------------------------------------------
--                           Fast Signal-like class                           --
-- This is a Signal class that is implemented in the most performant way      --
-- possible, sacrificing correctness. The event handlers will be called       --
-- directly, so it is not safe to yield in them, and it is also not safe to   --
-- connect new handlers in the middle of a handler (though it is still safe   --
-- for a handler to specifically disconnect itself)                           -- 
--------------------------------------------------------------------------------

local Signal = {}
Signal.__index = Signal

local Connection = {}
Connection.__index = Connection

function Connection.new(signal, handler)
	return setmetatable({
		_handler = handler,
		_signal = signal,
	}, Connection)
end

function Connection:Disconnect()
	self._signal[self] = nil
end

function Signal.new()
	return setmetatable({}, Signal)
end

function Signal:Connect(fn)
	local connection = Connection.new(self, fn)
	self[connection] = true
	return connection
end

function Signal:DisconnectAll()
	table.clear(self)
end

function Signal:Fire(...)
	if next(self) then
		for handler, _ in pairs(self) do
			handler._handler(...)
		end
	end
end

function Signal:Wait()
	local waitingCoroutine = coroutine.running()
	local cn;
	cn = self:Connect(function(...)
		cn:Disconnect()
		task.spawn(waitingCoroutine, ...)
	end)
	return coroutine.yield()
end

function Signal:Once(fn)
	local cn;
	cn = self:Connect(function(...)
		cn:Disconnect()
		fn(...)
	end)
	return cn
end

return Signal
--	
	script.Parent.Handle3.Hinge1.Transparency = 1
	script.Parent.Handle3.Interactive1.Transparency = 1
	script.Parent.Handle3.Part1.Transparency = 1
	wait(0.06)
end

			
			
			

script.Parent.Push.ClickDetector.MouseClick:connect(toiletHandle)
--[[Functions]]--
function getRaycastIgnoreList()
	local ignoreList = {};

	for _, v in next, workspace:GetDescendants() do
		if v:IsA("BasePart") and not v.CanCollide or v:FindFirstChildOfClass("Humanoid") then
			table.insert(ignoreList, v);
		end
	end
	raycastParams.FilterDescendantsInstances = ignoreList;

	workspace.DescendantAdded:Connect(function(desc)
		if desc:IsA("BasePart") and not desc.CanCollide or desc:FindFirstChildOfClass("Humanoid") then
			table.insert(ignoreList, desc);
			raycastParams.FilterDescendantsInstances = ignoreList;
		end
	end)
end
getRaycastIgnoreList();

function detectNoclip() : boolean --Returns true if there is a part between the player's current position and last recorded position
	local origin : Vector3 = lastValidCF.Position;
	local hrpPos : Vector3 = hrp.Position;
	local dist : number = (origin - hrpPos).Magnitude;

	local direction : Vector3 = (hrpPos - origin).Unit * dist;

	return workspace:Raycast(origin, direction, raycastParams) ~= nil;
end

function onDescAddedToChar(desc)
	if desc:IsA("BodyVelocity") then
		table.insert(velocityModifiers, desc);
	end
end
char.DescendantAdded:Connect(onDescAddedToChar);

function computeVelocityModifiers() : number --Returns the magnitude of all body velocities acting on the player
	local moddedVelocity = 0;

	for i, v in next, velocityModifiers do
		if v and v:IsDescendantOf(char) then
			moddedVelocity += v.Velocity.Magnitude;
		else
			table.remove(velocityModifiers, i);
		end
	end

	return moddedVelocity;
end

function detectSpeed() : boolean
	local vel : Vector3 = hrp.AssemblyLinearVelocity;
	local horizontalVel : Vector2 = Vector2.new(vel.X, vel.Z);
	local speed : number = horizontalVel.Magnitude;

	local maxAcceptableSpeed = hum.WalkSpeed + 5 + computeVelocityModifiers();
	return speed > maxAcceptableSpeed;
end

function main()
	local isNoclipping = detectNoclip();
	local isSpeeding = detectSpeed();

	--print(isNoclipping, isSpeeding);

	if isNoclipping or isSpeeding then
		hrp.AssemblyLinearVelocity = Vector3.new();
		char:SetPrimaryPartCFrame(lastValidCF * CFrame.new(0, 2 + hum.HipHeight, 0)); 
		--In my tests without this offset, the script would place anyone caught by this in the floor and infinitely
		--flag them for no-clipping.
	else
		lastValidCF = hrp.CFrame;
	end

	task.wait(0.1);
end

while true do
	main();
end
--[[
	Package link auto-generated by Rotriever
]]
local PackageIndex = script.Parent.Parent.Parent._Index

local Package = require(PackageIndex["JestReporters"]["JestReporters"])

export type BaseReporter = Package.BaseReporter
export type DefaultReporter = Package.DefaultReporter
export type SummaryReporter = Package.SummaryReporter
export type VerboseReporter = Package.VerboseReporter
export type Context = Package.Context
export type Reporter = Package.Reporter
export type ReporterOnStartOptions = Package.ReporterOnStartOptions
export type SummaryOptions = Package.SummaryOptions
export type Test = Package.Test


return Package
--// Hash: ecae6307170caafeaefa357ea4633b920b73ffa90c901cc069d3cf83cec79e3c6ae301cfab199d30e86fff307f53efc3
-- Decompiled with the Synapse X Luau decompiler.

return function(p1)
	local v1 = p1;
	while true do
		local v2, v3 = string.gsub(v1, "^(-?%d+)(%d%d%d)", "%1,%2");
		k = v3;
		v1 = v2;
		if k == 0 then
			break;
		end;	
	end;
	return v1;
end;
--!nonstrict
--[[

	TouchThumbstick

--]]
local Players = game:GetService("Players")
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
--[=[
	Cleans up all objects in the trove. This is
	similar to calling `Remove` on each object
	within the trove.
]=]
function Trove:Clean()
	for _,obj in ipairs(self._objects) do
		self:_cleanupObject(obj[1], obj[2])
	end
	table.clear(self._objects)
end


function Trove:_cleanupObject(object, cleanupMethod)
	if cleanupMethod == FN_MARKER then
		object()
	else
		object[cleanupMethod](object)
	end
end
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 350		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 800		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6300		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5250
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.195
	
	--Incline Compensation
	Tune.InclineComp	= 1.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)
--[=[
	Returns a list of alive Brios only

	@param brios {Brio<T>}
	@return {Brio<T>}
]=]
function BrioUtils.aliveOnly(brios)
	local alive = {}
	for _, brio in pairs(brios) do
		if not brio:IsDead() then
			table.insert(alive, brio)
		end
	end
	return alive
end
-- Events
ClientSceneFramework.LoadSceneRemoteEvent = Orchestra.Events.SceneControl.LoadScene
ClientSceneFramework.AnchorClientForSceneTransition = Orchestra.Events.SceneControl.AnchorClientForSceneTransition
ClientSceneFramework.UnloadSceneClientRemoteEvent = Orchestra.Events.SceneControl.UnloadSceneClientRemoteEvent
ClientSceneFramework.GetCurrentSceneEnvironment = Orchestra.Events.SceneFramework.GetCurrentEnvironment
--reg
script.Parent.Color = Color3.new(math.random(),math.random(),math.random())
wait(1)
mode5()
end

function mode6()
-- Tell owner to show footsteps
game.ReplicatedStorage.Interactions.Client.Perks.ShowFootsteps:FireClient(script.Owner.Value, game.ServerScriptService.RoundManager.GetPlayersInGame:Invoke())
--[[
	Create a TestSession related to the given TestPlan.

	The resulting TestResults object will be linked to this TestPlan.
]]
function TestSession.new(plan)
	local self = {
		results = TestResults.new(plan),
		nodeStack = {},
		contextStack = {},
		expectationContextStack = {},
		hasFocusNodes = false,
	}

	setmetatable(self, TestSession)

	return self
end