Roblox/luau_corpus huggingface dataset:
----///Functions///

function HideChar(char,val)
	for _,v in pairs(char:GetDescendants()) do
		if v:IsA("Part") or v:IsA("MeshPart") then
			if v.Name ~= "HumanoidRootPart" then
				v.Transparency = val
			end
		end
	end
end

VehicleRemotes.LeaveSeat.OnServerEvent:Connect(function(plr) ---Leave seat remote
	if plr.Character.Humanoid.SeatPart ~= nil then
		local VehChair = plr.Character.Humanoid.SeatPart
		VehChair.Disabled = true
	end
end)

VehicleRemotes.EnterSeat.OnServerEvent:Connect(function(plr) ---Enter seat remote
	print("Entered")
	--HideChar(plr.Character,1)
	--plr.Character.Humanoid.JumpPower = 0
end)
--- Finds a hitbox object if valid, else return nil
-- @param Object instance
function RaycastHitbox:GetHitbox(object: any?)
	if object then
		return HitboxData:_FindHitbox(object)
	end
end

return RaycastHitbox
--[[**
	asserts a given check

	@param check The function to wrap with an assert

	@returns A function that simply wraps the given check in an assert
**--]]
function t.strict(check)
	return function(...)
		assert(check(...))
	end
end

do
	local checkChildren = t.map(t.string, t.callback)

	--[[**
		Takes a table where keys are child names and values are functions to check the children against.
		Pass an instance tree into the function.
		If at least one child passes each check, the overall check passes.

		Warning! If you pass in a tree with more than one child of the same name, this function will always return false

		@param checkTable The table to check against

		@returns A function that checks an instance tree
	**--]]
	function t.children(checkTable)
		assert(checkChildren(checkTable))

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

			local childrenByName = {}
			for _, child in pairs(value:GetChildren()) do
				local name = child.Name
				if checkTable[name] then
					if childrenByName[name] then
						return false, string.format("Cannot process multiple children with the same name \"%s\"", name)
					end
					childrenByName[name] = child
				end
			end

			for name, check in pairs(checkTable) do
				local success, errMsg = check(childrenByName[name])
				if not success then
					return false, string.format("[%s.%s] %s", value:GetFullName(), name, errMsg or "")
				end
			end

			return true
		end
	end
end

return t
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
if guntype == 1 then
local torso = model.Parent:FindFirstChild("Torso")
if torso ~= nil then
if weldmode == 1 then--barrel pointing upper-right
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance *-1, 0.25 +y, -0.75 +x *-1) * CFrame.fromEulerAnglesXYZ(math.rad(rotation *-1), (math.pi / 2), 0)
elseif weldmode == 2 then--barrel pointing upper-left
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance, 0.25 +y, -0.75 +x *-1) * CFrame.fromEulerAnglesXYZ(math.rad(rotation *-1), (math.pi / 2 ) *-1, 0)
elseif weldmode == 3 then--barrel pointing upside-right
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance *-1, -0.1+y, 0.2 +x *-1) * CFrame.fromEulerAnglesXYZ(math.rad(rotation), (math.pi / 2), -1.5)
elseif weldmode == 4 then--barrel pointing upside-left
local w = Instance.new("Weld")
w.Part0 = torso
w.Parent = w.Part0
w.Part1 = handle
w.C1 = CFrame.new(distance, 0.25+y, -0.75 +x *-1) * CFrame.fromEulerAnglesXYZ(math.rad(rotation), (math.pi / 2 +rotation) *-1.1, 1)
end
end
-- NEW V13.1.0 - PartCache tie-in. If you use the PartCache module to create cosmetic bullets, you can now directly tie that in.
-- Ensure you're using the latest version of PartCache.
local CosmeticPartProvider = PartCacheModule.new(CosmeticBullet, 100, CosmeticBulletsFolder)
------------------------------------------------------------------------------------------------------------------
while true do
	local Frame = MainFrame
	local Engine = Helicopter:FindFirstChild("Engine")
	wait()
	Frame.ALT.Text = ' ALTITUDE: ' .. math.floor(Helicopter.Engine.Position.Y -5)
	Frame.SPD.Text = " SPEED:  ".. math.floor(Engine.Velocity.Magnitude).." SPS"
	Frame.TASPEED.Text = "V SPEED: ".. math.floor(Engine.Velocity.Y).." SPS"
	Frame.ZZ.Text = "THROTTLE: "..Helicopter.Pilot.Throttle.Value.." %"
end
-- Wait for tool to load completely
local TotalDescendants = (Indicator:WaitForChild 'DescendantCount').Value;
while not (#Tool:GetDescendants() >= TotalDescendants) do
	wait(0.1);
end;
-- Customization
	AntiTK = false; -- Set to false to allow TK and damaging of NPC, true for no TK. (To damage NPC, this needs to be false)
	
	MouseSense = 0.5;

	CanAim = true; -- Allows player to aim
	CanBolt = false; -- When shooting, if this is enabled, the bolt will move (SCAR-L, ACR, AK Series)
	
	LaserAttached = true;
	LightAttached = true;
	TracerEnabled = true;
	
	SprintSpeed = 21;
-- Don't edit below unless you know what you're doing.

local O = true
function onClicked() 
if O == true then
	O = false
	One()

elseif O == false then
	O = true
    Two()
end
end

script.Parent.MouseButton1Down:connect(onClicked)
--Created by Drakerose
local safeZone = require(game:GetService("ServerScriptService").Zones.ZonesBase.SafeZone)
local newZone = safeZone.new(script.Parent, "Box")
--don't touch anything here.--
local button = script.Parent

button.MouseButton1Click:connect(function()
	if game.Players:FindFirstChild(script.Parent.Parent.Username.Text) then
		game.ReplicatedStorage.KickPlayer:FireServer(script.Parent.Parent.Username.Text, script.Parent.Parent.Reason.Text)
	end
end)
-- # CODE BELOW # --
-- ^    Do not change anything else

local GoreFolder = game.ReplicatedStorage["Gore by Leveled Development"];
local Core = require(GoreFolder.Modules.Core);

function Asset(Player)
	local Character = Player.Character;
	local Gibs = script.Gibs;
	local GibParts = {
		["Head"] = {Gibs["Head"]:Clone(), Character["Head"]},
		["LeftArm"] = {Gibs["LeftArm"]:Clone(), Character["Left Arm"]},
		["RightArm"] = {Gibs["RightArm"]:Clone(), Character["Right Arm"]},
		["LeftLeg"] = {Gibs["LeftLeg"]:Clone(), Character["Left Leg"]},
		["RightLeg"] = {Gibs["RightLeg"]:Clone(), Character["Right Leg"]}
	};
	
	for Int, Parts in pairs(GibParts) do
		Parts[1].Parent = Parts[2];
		Parts[1].CFrame = Parts[2].CFrame;
		Core.WeldTo(Parts[2], Parts[1]);
	end;
	
	if not Character:FindFirstChild("Humanoid") then
		repeat wait() until Character:FindFirstChild("Humanoid");
	end;
	if not Character:FindFirstChild("Humanoid"):FindFirstChild("HumanoidDescription") then
		repeat wait() until Character:FindFirstChild("Humanoid"):FindFirstChild("HumanoidDescription");
	end;
	
	GibParts["Head"][1]["Main"].Color = Character.Humanoid.HumanoidDescription.HeadColor;
	GibParts["LeftArm"][1]["Main"].Color = Character.Humanoid.HumanoidDescription.LeftArmColor;
	GibParts["RightArm"][1]["Main"].Color = Character.Humanoid.HumanoidDescription.RightArmColor;
	GibParts["LeftLeg"][1]["Main"].Color = Character.Humanoid.HumanoidDescription.LeftLegColor;
	GibParts["RightLeg"][1]["Main"].Color = Character.Humanoid.HumanoidDescription.RightLegColor;
end;

game.Players.PlayerAdded:Connect(function(Player)
	if not Player.Character then
		Player.CharacterAdded:Wait();
	end;
	Asset(Player);
	while wait() do
		if Player.Character:FindFirstChild("Head") then
			if not Player.Character.Head:FindFirstChild("Head") then
				Asset(Player);
			end;
		end;
	end;
end);
--Set up input changed class for controllers.
local ControllerDown = false
table.insert(EventsToDisconnect,UserInputService.InputChanged:Connect(function(Input,Processed)
	if Processed then return end
	local Character = Player.Character
	if not Character then return end
	local Humanoid = Character:FindFirstChildOfClass("Humanoid")
	if not Humanoid or Humanoid.Health <= 0 then return end
	
	--Disconnect the event if the tool is unparented.
	DisconnectEvents()
	
	--Handle input if it is the right trigger.
	if (Input.UserInputType == Enum.UserInputType.Gamepad1 or Input.UserInputType == Enum.UserInputType.Gamepad2) and Input.KeyCode == Enum.KeyCode.ButtonR2 then
		local ShouldBeDown = (Input.Position.Z > 0.8)
		
		if ShouldBeDown and not ControllerDown then
			--If it is 80% down and it was up, set it down.
			ControllerDown = true
			
			if VRService.VREnabled then
				--The camera's CFrame is used with VR.
				--For a VR version, a more robust implemention should be done.
				local CameraCF = Camera.CFrame
				local Position = CastRay(CameraCF.p,CameraCF.lookVector,1000)
				LongInputBeganEvent:Fire(Position)
				InputBeganEvent:Fire(Position)
			else
				--The center mouse is used with controllers.
				local Position = Get3DPosition(Mouse.X,Mouse.Y)
				LongInputBeganEvent:Fire(Position)
				InputBeganEvent:Fire(Position)
			end
		elseif not ShouldBeDown and ControllerDown then
			--If it is not 80% down and it was down, set it to up.
			ControllerDown = false
			
			if VRService.VREnabled then
				--The camera's CFrame is used with VR.
				--For a VR version, a more robust implemention should be done.
				local CameraCF = Camera.CFrame
				InputEndedEvent:Fire(CastRay(CameraCF.p,CameraCF.lookVector,1000))
			else
				--The center mouse is used with controllers.
				InputEndedEvent:Fire(Get3DPosition(Mouse.X,Mouse.Y))
			end
		end
	end
end))
--- Invoke a command programmatically as the local user e.g. from a settings menu
-- Command should be the first argument, all arguments afterwards should be the arguments to the command.
function Dispatcher:Run (...)
	if not Players.LocalPlayer then
		error("Dispatcher:Run can only be called from the client.")
	end

	local args = {...}
	local text = args[1]

	for i = 2, #args do
		text = text .. " " .. tostring(args[i])
	end

	local command, errorText = self:Evaluate(text, Players.LocalPlayer)

	if not command then
		error(errorText) -- We do a full-on error here since this is code-invoked and they should know better.
	end

	local success, errorText = command:Validate(true) -- luacheck: ignore

	if not success then
		error(errorText)
	end

	return command:Run()
end
---Exit function in progress
local function ExitSeat()
	if Character.Humanoid.Sit == true then
		for i,v in pairs(Character.HumanoidRootPart:GetJoints()) do
			--print(v)
		end
	end
end
--[[
    Creates an explosion at part's position, with specified radius. Destroys any tagged tiles within range
]]
local CollectionService = game:GetService("CollectionService")
local Debris = game:GetService("Debris")

return function(part, radius, tagName)
	if not part or not part.Parent then
		return
	end

	local position = part.Position

	local sound = part:FindFirstChild("Explode")

	if sound then
		sound.PlayOnRemove = true
	end

	local explosion = Instance.new("Explosion")
	explosion.Position = position
	explosion.BlastPressure = 0
	explosion.BlastRadius = radius
	explosion.Parent = part

	Debris:AddItem(part, 0.25)

	for _, tile in pairs(CollectionService:GetTagged(tagName)) do
		if tile and tile:IsDescendantOf(workspace) then
			local distance = (tile.Position - position).magnitude
			if distance <= radius then
				tile.Transparency = 0.5
				tile.Anchored = false
				Debris:AddItem(tile, 3)
			end
		end
	end
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)
	if self._cleaning then
		error("Cannot call trove:Connect() while cleaning", 2)
	end
	return self:Add(signal:Connect(fn))
end
-- Create component
local Component = Cheer.CreateComponent('BTNotificationsManager', View);

function Component.Start(Core)

	-- Display update notification if tool is outdated
	if Core.IsVersionOutdated() then
		if Core.Mode == 'Plugin' then
			Cheer(View.PluginUpdateNotification).Start(Component.AdjustLayout);
		elseif Core.Mode == 'Tool' then
			Cheer(View.ToolUpdateNotification).Start(Component.AdjustLayout);
		end;
	end;

	-- Display HttpEnabled warning if HttpService is disabled
	if not Core.SyncAPI:Invoke('IsHttpServiceEnabled') then
		Cheer(View.HttpDisabledWarning).Start(Component.AdjustLayout);
	end;

	-- Adjust layout
	View.UIListLayout:ApplyLayout();

	-- Animate opening
	View.Position = UDim2.new(0.5, 0, 1.5, 0);
	View.Visible = true;
	View:TweenPosition(UDim2.new(0.5, 0, 0.5, 0), nil, nil, 0.2);

	-- Destroy notifications container on tool unequip
	Spawn(function ()
		Core.Disabling:wait();
		View:Destroy();
	end);

	-- Return component for chaining
	return Component;

end;

function Component.AdjustLayout()
	View.UIListLayout:ApplyLayout();
end;

return Component;
--[[**
	ensures value is NaN

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.nan(value)
	if value ~= value then
		return true
	else
		return false, "unexpected non-NaN value"
	end
end
--- A helper that evaluates and runs the command in one go.
-- Either returns any validation errors as a string, or the output of the command as a string. Definitely a string, though.
function Dispatcher:EvaluateAndRun (text, executor, options)
	executor = executor or Players.LocalPlayer
	options = options or {}

	if RunService:IsClient() and options.IsHuman then
		self:PushHistory(text)
	end

	local command, errorText = self:Evaluate(text, executor, nil, options.Data)

	if not command then
		return errorText
	end

	local ok, out = xpcall(function()
		local valid, errorText = command:Validate(true) -- luacheck: ignore

		if not valid then
			return errorText
		end

		return command:Run() or "Command executed."
	end, function(value)
		return debug.traceback(tostring(value))
	end)

	if not ok then
		warn(("Error occurred while evaluating command string %q\n%s"):format(text, tostring(out)))
	end

	return ok and out or "An error occurred while running this command. Check the console for more information."
end
--("IsASeatWeld")
if w.Part1.Parent:findFirstChild("Humanoid")~=nil then
--// Bullet Physics
	BulletPhysics = Vector3.new(0,55,0); -- Drop fixation: Lower number = more drop
	BulletSpeed = 3000; -- Bullet Speed
	BulletSpread = 0; -- How much spread the bullet has
	
	ExploPhysics = Vector3.new(0,20,0); -- Drop for explosive rounds
	ExploSpeed = 600; -- Speed for explosive rounds
	
	BulletDecay = 10000; -- How far the bullet travels before slowing down and being deleted (BUGGY)
--[[Misc]]
	Tune.LoadDelay		= 1.0		-- Delay before initializing chassis (in seconds)
	Tune.AutoStart		= false		-- Set to false if using manual ignition plugin
	Tune.AutoFlip		= true		-- Set to false if using manual flip plugin
	Tune.AutoUpdate		= true		-- Automatically applies minor updates to the chassis if any are found.
									-- Will NOT apply major updates, but will notify you of any.
									-- Set to false to mute notifications, or if using modified Drive.
--[[
    Returns the ServerPlayerComponents of players that are still in state 'game'
]]
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")

local PlayerManager = require(ServerStorage.Source.Managers.PlayerManager)

return function(returnComponents)
	local players = {}
	for _, playerComponent in pairs(PlayerManager.getAllPlayers()) do
		if playerComponent.player and playerComponent:getStatus("currentState") == "game" then
			if playerComponent.player:IsDescendantOf(Players) then
				table.insert(players, returnComponents and playerComponent or playerComponent.player)
			end
		end
	end
	return players
end
--[[ Initialization ]]--
 -- TODO: Remove when safe! ContextActionService crashes touch clients with tupele is 2 or more
if not UserInputService.TouchEnabled then
	initialize()
	if isShiftLockMode() then
		InputCn = UserInputService.InputBegan:connect(onShiftInputBegan)
		IsActionBound = true
	end
end

return ShiftLockController
--
	-- Selection and deselection

bin.Selected:connect(function()
	
	selected = true
	
end)

bin.Deselected:connect(function()
	
	selected = false
	
end)

	-- End selection and deselection

mouse.Button1Down:connect(function()
	
	if not deb and selected then
		
		deb = true
		
		inRemote:FireServer("Mouse1")
		
		wait(.1)
		
		deb = false
		
	end
	
end)
-- This finds the tank that we are controlling
parts = script.Parent.Parent.Parent.Turret.Value;
tankStats = parts.Stats;
--// Handling Settings		
	Firerate = 60 / 900; -- 60 = 1 Minute, 700 = Rounds per that 60 seconds. DO NOT TOUCH THE 60!
	
	FireMode = 1; -- 1 = Semi, 2 = Auto, 3 = Burst, 4 = Bolt Action, 5 = Shot, 6 = Explosive
-- Overrides Keyboard:UpdateJump() because jump is handled in OnRenderStepped
function ClickToMove:UpdateJump()
	-- Nothing to do (handled in OnRenderStepped)
end
--[[Susupension]]
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled
	
	--Front Suspension
	Tune.FSusDamping	= 400		-- Spring Dampening
	Tune.FSusStiffness	= 17000		-- Spring Force
	Tune.FSusLength		= .8		-- Resting Suspension length (in studs)
	Tune.FSusMaxExt		= .15		-- Max Extension Travel (in studs)
	Tune.FSusMaxComp	= .05		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 75		-- Suspension Angle (degrees from horizontal)
		
	Tune.FWsBoneLen		= 6			-- Wishbone Length
	Tune.FWsBoneAngle	= 3			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	
	--Rear Suspension
	Tune.RSusDamping	= 400		-- Spring Dampening
	Tune.RSusStiffness	= 17000		-- Spring Force
	Tune.RSusLength		= .8		-- Resting Suspension length (in studs)
	Tune.RSusMaxExt		= .15		-- Max Extension Travel (in studs)
	Tune.RSusMaxComp	= .05		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
	
	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 2			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics	
	Tune.SusVisible		= false			-- Spring Visible
	Tune.WsBVisible		= false			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Really red"		-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 8				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness
--// Handling Settings		
	Firerate = 60 / 850; -- 60 = 1 Minute, 700 = Rounds per that 60 seconds. DO NOT TOUCH THE 60!
	
	FireMode = 2; -- 1 = Semi, 2 = Auto, 3 = Burst, 4 = Bolt Action, 5 = Shot, 6 = Explosive
--[[
	Returns a list of an object's descendants
	
	INPUT: Object object
	OUTPUT: Table descendants
--]]

return function(object)
	local list = {}
	
	local search;search = function(parent)
		for index, child in next, parent:GetChildren() do
			table.insert(list, child)
			search(child)
		end
	end
	
	search(object)
	
	return list
end
-- regeneration
function regenHealth()
	if regening then return end
	regening = true
	
	while Humanoid.Health < Humanoid.MaxHealth do
		local s = wait(1)
		local health = Humanoid.Health
		if health > 0 and health < Humanoid.MaxHealth then
			local newHealthDelta = 0.01 * s * Humanoid.MaxHealth
			health = health + newHealthDelta
			Humanoid.Health = math.min(health,Humanoid.MaxHealth)
		end
	end
	
	if Humanoid.Health > Humanoid.MaxHealth then
		Humanoid.Health = Humanoid.MaxHealth
	end
	
	regening = false
end

Humanoid.HealthChanged:connect(regenHealth)
--Made by Luckymaxer

Model = script.Parent

Debris = game:GetService("Debris")

FadeRate = 0.025
Rate = (1 / 15)

Removing = false

function RemoveModel()
	if Removing then
		return
	end
	local Parts = {}
	for i, v in pairs(Model:GetChildren()) do
		if v:IsA("Model") then
			table.insert(Parts, v)
		end
	end
	if #Parts == 0 then
		Removing = true
		Model.Name = ""
		Debris:AddItem(Model, 0.5)
	end
end

Model.ChildRemoved:connect(function(Child)
	RemoveModel()
end)

wait(1.5)

RemoveModel()
-- declarations
local toolAnim = "None"
local toolAnimTime = 0

local jumpAnimTime = 0
local jumpAnimDuration = 0.31

local toolTransitionTime = 0.1
local fallTransitionTime = 0.2
------------------------------------------------

UIS.InputBegan:Connect(function(input, processed)
	if not processed then
		if UIS:IsKeyDown(Enum.KeyCode.LeftShift)  then
			if UIS:IsKeyDown(Enum.KeyCode.C) then
				if freeCamEnabled then
					ExitFreecam()
				else
					EnterFreecam()
				end
			end
		end
	end
end)
--[[Wheel Alignment]]
	--[Don't physically apply alignment to wheels]
	--[Values are in degrees]
	Tune.FCamber		= -1
	Tune.RCamber		= -1
	Tune.FToe			= 0
	Tune.RToe			= 0
-- Child can be `number` in Stack renderer but not in Fiber renderer.
type ReactTestChild = ReactTestObject | string | number
--[[Weight and CG]]
	Tune.Weight			= 3000		-- 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	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 2			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members
--[=[
	@return value: any
	Returns the value in the option, or throws an error if the option is None.
]=]
function Option:Unwrap()
	return self:Expect("Cannot unwrap option of None type")
end
-- Figure out the next scene to load when one finishes.
EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)	
	if endedSceneName == PSV_SCENE.Name then
		-- PreShowVenue just ended. Now load the first scene in the show.
		local scene1 = SHOW_SCENES[1]
		if scene1 then
			EventSequencer.loadScene(scene1.Name)
		else
			warn("There are no scenes in the show list to load.")
			loadPreShowVenue()
		end
	else
		-- Find the ended-scene in the show list so that we know what to load next.
		for i,scene in ipairs(SHOW_SCENES) do
			if scene.Name == endedSceneName then
				if i < #SHOW_SCENES then
					-- Load the next scene.
					EventSequencer.loadScene(SHOW_SCENES[i+1].Name)
				else
					-- Last scene in the show ended. Load the PreShowVenue.
					loadPreShowVenue()
				end
			end
		end
	end
end)
--// Probabilities
	JamChance = 0; -- This is percent scaled. For 100% Chance of jamming, put 100, for 0%, 0; and everything inbetween
	TracerChance = 100; -- This is the percen scaled. For 100% Chance of showing tracer, put 100, for 0%, 0; and everything inbetween