Roblox/luau_corpus huggingface dataset:
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {};
v1.__index = v1;
local v2 = {};
function v2.__call(p1, ...)
	return v1.new(...);
end;
setmetatable(v1, v2);
function v1.new()
	return setmetatable({}, v1);
end;
function v1.CharacterAdded(p2, p3, p4)

end;
function v1.CharacterRemoving(p5, p6, p7)

end;
function v1.OnCameraSubjectChanged(p8, p9)

end;
function v1.GetOcclusionMode(p10)
	warn("BaseOcclusion GetOcclusionMode must be overridden by derived classes");
	return nil;
end;
function v1.Enable(p11, p12)
	warn("BaseOcclusion Enable must be overridden by derived classes");
end;
function v1.Update(p13, p14, p15, p16)
	warn("BaseOcclusion Update must be overridden by derived classes");
	return p15, p16;
end;
return v1;
--[=[
	@interface Service
	.[any] any
	@within KnitClient
]=]
type Service = {
	[any]: any,
}
--[[**
	ensures Roblox NumberSequence type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.NumberSequence = t.typeof("NumberSequence")
-- ROBLOX TODO: ADO-1554 clean up the following deviations and move them to the
-- appropriate locations
-- ROBLOX deviation START: for now we extend the snapshot matchers in the Expect file instead
-- of jest-jasmine2/jestExpect
local JestSnapshot = require(Packages.JestSnapshot)
local toMatchSnapshot = JestSnapshot.toMatchSnapshot
local toThrowErrorMatchingSnapshot = JestSnapshot.toThrowErrorMatchingSnapshot
setMatchers({
	toMatchSnapshot = toMatchSnapshot,
	toThrowErrorMatchingSnapshot = toThrowErrorMatchingSnapshot,
}, false, Expect)
--[[Weight and CG]]
	Tune.Weight			= 3300		-- 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
-----------------------------------------------------------------------------------------------

script.Parent:WaitForChild("Speedo")
script.Parent:WaitForChild("Tach")
script.Parent:WaitForChild("ln")
script.Parent:WaitForChild("Gear")
script.Parent:WaitForChild("Speed")

local player=game.Players.LocalPlayer
local mouse=player:GetMouse()

local car = script.Parent.Parent.Car.Value
car.DriveSeat.HeadsUpDisplay = false

local _Tune = require(car["A-Chassis Tune"])

local _pRPM = _Tune.PeakRPM
local _lRPM = _Tune.Redline

local currentUnits = 1
local revEnd = math.ceil(_lRPM/1000)

local intach = car.Body.Dash.Tac.G.Needle
local inspd = car.Body.Dash.Spd.G.Needle
--edit the function below to return true when you want this response/prompt to be valid
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	return (plrData.Character.NPCSpecifics.GaveFoodToArtie.Value == true)
end
-- Stops a confetti from firing again once it's out of bounds.
function _Confetti:Toggle()
	self.Enabled = not(self.Enabled);
end;

_Confetti.setGravity(Vector2.new(0, 1));

local Conffetis = {}

for _ = 1, 10 do
	
	table.insert(Conffetis, (_Confetti.createParticle(Vector2.new(0.5, 1), Vector2.new(math.random(90) - 45, math.random(70, 100)), script.Parent.Parent)))
	
end

local Debounce = false

RunService.RenderStepped:Connect(function()
	
	for _, Conffeti in pairs(Conffetis) do
		
		Conffeti.Enabled = Debounce
		
		Conffeti:Update()
		
	end
	
end)

function _Confetti.fire()
	
	spawn(function()
		
		Debounce = true
		
		wait(tick)
		
		Debounce = false
		
	end)
	
end

return _Confetti;
--[[
	Returns a new list containing only the elements within the given range.
]]

local function getRange(list, startIndex, endIndex)
	assert(startIndex <= endIndex, "startIndex must be less than or equal to endIndex")

	local new = {}
	local index = 1

	for i = math.max(1, startIndex), math.min(#list, endIndex) do
		new[index] = list[i]
		index = index + 1
	end

	return new
end

return getRange
--LIGHTING FUNCTIONS

script.Parent.OnServerEvent:connect(function(pl,n) if lt~=1 then pr = true else pr=false end lt=n
	if lt~=3 then
		RefMt.DesiredAngle = RefMt.CurrentAngle%math.rad(360)
		RefMt.CurrentAngle = RefMt.CurrentAngle%math.rad(360)
		UpdateLt(1,white)
		UpdatePt(false,white)
		StopMt(pr)
		repeat wait() until (lt==3)
	elseif lt == 3 then
		wait(1/3)
		UpdateLt(.25,red)
		UpdatePt(true,red)
		UpdateMt(0,9e9,1)
		repeat 
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 90 then UpdateLt(.25,amber) end
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 90 then UpdatePt(true,amber) end
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 270 then UpdateLt(.25,white) end
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 270 then UpdatePt(true,white) end
			wait()
		until lt~=3
	end
end)
--[[Wheel Alignment]]
	--[Don't physically apply alignment to wheels]
	--[Values are in degrees]
	Tune.FCamber		= -0.5
	Tune.RCamber		= -0.5
	Tune.FToe			= 0
	Tune.RToe			= 0
--[=[
	@param signal RBXScriptSignal
	@param fn (...: any) -> any
	@return RBXScriptConnection
	Connects the function to the signal, adds the connection
	to the Janitor, and then returns the connection.

	```lua
	Janitor:Connect(workspace.ChildAdded, function(instance)
		print(instance.Name .. " added to workspace")
	end)
	```
]=]
function Janitor:Connect(signal, fn)
	return self:Add(signal:Connect(fn))
end
--------

local Handler = require(script.MainHandler)
local HitboxClass = require(script.HitboxObject)

function RaycastHitbox:Initialize(object, ignoreList)
	assert(object, "You must provide an object instance.")
	
	local newHitbox = Handler:check(object)
	if not newHitbox then
		newHitbox = HitboxClass:new()
		newHitbox:config(object, ignoreList)
		newHitbox:seekAttachments(RaycastHitbox.AttachmentName, RaycastHitbox.WarningMessage)
		newHitbox.debugMode = RaycastHitbox.DebugMode
		Handler:add(newHitbox)
	end
	return newHitbox
end

function RaycastHitbox:Deinitialize(object)
	Handler:remove(object)
end

function RaycastHitbox:GetHitbox(object)
   return Handler:check(object, RaycastHitbox.WarningMessage)
end

return RaycastHitbox
---
	elseif sys.Code.Value == true and folder.KV.Value.Value ~= config.AllCode.Value then
		---
		folder.Display.Value = folder.KV
		folder.CodePrivate.Value = ""
		huh.Parent.Display.SurfaceGui.TextLabel.TextTransparency = 0
		---
err()
		wait(1)
		sys.Code.Value = false
	elseif folder.KV.Value.Value == "" and config.AllCodes.Value == false then
		usercodefalse()
--[=[
	Returns true if the value is a ValueBase instance

	@param instance Instance
	@return boolean
]=]
function ValueBaseUtils.isValueBase(instance)
	return typeof(instance) == "Instance" and instance:IsA("ValueBase")
end
--Mobile Controllability
if UserInputService.TouchEnabled then
	ContextActionService:BindActionToInputTypes('RidableHorse_Dismount', (function()
		Dismount()
	end), true, Enum.KeyCode.LeftControl)
	ContextActionService:SetTitle("RidableHorse_Dismount", "Dismount")
end

ServerControl.Changed:connect(function(Property)
	if Property == "Parent" and not ServerControl.Parent then
		ContextActionService:UnbindAction("RidableHorse_Dismount")
		Debris:AddItem(script, 1)
	end
end)
-- Initialize resize tool
local ResizeTool = require(CoreTools:WaitForChild 'Resize')
Core.AssignHotkey('X', Core.Support.Call(Core.EquipTool, ResizeTool));
Core.Dock.AddToolButton(Core.Assets.ResizeIcon, 'X', ResizeTool, 'ResizeInfo');
----------------------------------
------------FUNCTIONS-------------
----------------------------------

function Receive(player, action, ...)
	local args = {...}
	if player == User and action == "play" then
		if not MODEL.IsActive.Value or Piano.On.Value then
			Connector:FireAllClients("play", User, args[1], Settings.SoundSource.Position, Settings.PianoSoundRange, Settings.PianoSounds, args[2], Settings.IsCustom)
			HighlightPianoKey((args[1] > 61 and 61) or (args[1] < 1 and 1) or args[1],args[3])
		end
	elseif player == User and action == "abort" then
		Deactivate()
		if SeatWeld then
			SeatWeld:remove()
		end
	end
end

function Activate(player)
	Connector:FireClient(player, "activate", Settings.CameraCFrame, Settings.PianoSounds, true)
	User = player
end

function Deactivate()
	if User and User.Parent then
		Connector:FireClient(User, "deactivate")
		User.Character:SetPrimaryPartCFrame(Box.CFrame + Vector3.new(0, 5, 0))
	end
	
	User = nil
end
-- NintendoZERG

function Entered(p)

if p:findFirstChild("leaderstats") == nil then

stats = Instance.new("IntValue")
stats.Parent = p
stats.Name = "leaderstats"

money = Instance.new("IntValue")
money.Value = 0 -- How much money each player starts with.
money.Name = "Money"
money.Parent = stats

ao = Instance.new("IntValue")
ao.Value = 0
ao.Name = "AlreadyOwned"
ao.Parent = p

end
end

game.Players.PlayerAdded:connect(Entered)

p = game.Players:GetChildren()
for i = 1, #p do
Entered(p[i])
end
print("LinkedLeaderboard script version 5.00 loaded")

stands = {}
CTF_mode = false

function handleKillCount(humanoid, player)
	local killer = getKillerOfHumanoidIfStillInGame(humanoid)
	if killer ~= nil then
		local stats = killer:findFirstChild("leaderstats")
		if stats ~= nil then
			local kills = stats:findFirstChild("KOs")
			if killer ~= player then
				kills.Value = kills.Value + 1
				
			else
				kills.Value = kills.Value - 1
				
			end
		end
	end
end

function onPlayerEntered(newPlayer)

	if CTF_mode == true then

		local stats = Instance.new("IntValue")
		stats.Name = "leaderstats"


		captures.Parent = stats

		-- VERY UGLY HACK
		-- Will this leak threads?
		-- Is the problem even what I think it is (player arrived before character)?
		while true do
			if newPlayer.Character ~= nil then break end
			wait(5)
		end

		stats.Parent = newPlayer

	else

		local stats = Instance.new("IntValue")
		stats.Name = "leaderstats"

		local kills = Instance.new("IntValue")
		kills.Name = "KOs"
		kills.Value = 0

		kills.Parent = stats
		deaths.Parent = stats

		-- VERY UGLY HACK
		-- Will this leak threads?
		-- Is the problem even what I think it is (player arrived before character)?
		while true do
			if newPlayer.Character ~= nil then break end
			wait(5)
		end

		local humanoid = newPlayer.Character.Humanoid

		humanoid.Died:connect(function() onHumanoidDied(humanoid, newPlayer) end )

		-- start to listen for new humanoid
		newPlayer.Changed:connect(function(property) onPlayerRespawn(property, newPlayer) end )


		stats.Parent = newPlayer

	end

end
-- Weighted selection
-- 100 total weight
petModule.rarities = {
	
	["Legendary"] = 5; -- 5% chance

	["Rare"] = 15; -- 15% chance
	
	["Uncommon"] = 30; -- 30% chance
	
	["Common"] = 50; -- 50% chance

}

petModule.chooseRandomPet = function()

	local randomNumber = math.random(1,100)
	
	local counter = 0
	
	for rarity, weight in pairs(petModule.rarities) do
		counter = counter + weight
		if randomNumber <= counter then
			
			local rarityTable = petModule.pets[rarity]
			local chosenPet = rarityTable[math.random(1,#rarityTable)]
			
			return chosenPet
			
		end
	end
	
	
end

return petModule
--- Source: https://web.archive.org/web/20131225070434/http://snippets.luacode.org/snippets/Deep_Comparison_of_Two_Values_3
function CompareTable(t1,t2,ignore_mt)
	local ty1 = type(t1)
	local ty2 = type(t2)
	
	if ty1 ~= ty2 then return false end
	
	--- Non-table types can be directly compared
	if ty1 ~= 'table' and ty2 ~= 'table' then return t1 == t2 end
	
	--- As well as tables which have the metamethod __eq
	local mt = getmetatable(t1)
	
	if not ignore_mt and mt and mt.__eq then return t1 == t2 end
	
	for k1,v1 in pairs(t1) do
		local v2 = t2[k1]
		if v2 == nil or not CompareTable(v1,v2) then return false end
	end
	
	for k2,v2 in pairs(t2) do
		local v1 = t1[k2]
		
		if v1 == nil or not CompareTable(v1,v2) then return false end
	end
	
	return true
end
--[=[
	Returns `true` if the given object is a Timer.
]=]
function Timer.Is(obj: any): boolean
	return type(obj) == "table" and getmetatable(obj) == Timer
end


function Timer:_startTimer()
	local t = self.TimeFunction
	local nextTick = t() + self.Interval
	self._runHandle = self.UpdateSignal:Connect(function()
		local now = t()
		if now >= nextTick then
			nextTick = now + self.Interval
			self.Tick:Fire()
		end
	end)
end


function Timer:_startTimerNoDrift()
	assert(self.Interval > 0, "Interval must be greater than 0 when AllowDrift is set to false")
	local t = self.TimeFunction
	local n = 1
	local start = t()
	local nextTick = start + self.Interval
	self._runHandle = self.UpdateSignal:Connect(function()
		local now = t()
		while now >= nextTick do
			n += 1
			nextTick = start + (self.Interval * n)
			self.Tick:Fire()
		end
	end)
end
--Weld stuff here


car.DriveSeat.ChildAdded:connect(function(child)
	if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
		child.C0=CFrame.new(0,1,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0)*CFrame.Angles(math.rad(13),0,0)
		child.C0=CFrame.Angles(-1.55,0,0)
	end
end)
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 180		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 5500		--		Use sliders to manipulate values
	Tune.Redline		= 6000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 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)
--[[
	Welds primaryPart to secondaryPart in place
--]]

local function weldParts(primaryPart: BasePart, secondaryPart: BasePart)
	local weld = Instance.new("WeldConstraint")
	weld.Part0 = primaryPart
	weld.Part1 = secondaryPart
	weld.Parent = secondaryPart

	return weld
end

return weldParts
--[[
	Finds the top-level farm model from any descendant and
	returns the OwnerId attribute value of that farm.
--]]

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local FarmConstants = require(ReplicatedStorage.Source.Farm.FarmConstants)
local Attribute = require(ReplicatedStorage.Source.SharedConstants.Attribute)
local getAttribute = require(ReplicatedStorage.Source.Utility.getAttribute)

function getFarmOwnerIdFromInstance(instance: Instance)
	local farm = instance

	while farm and farm.Parent ~= FarmConstants.FarmContainer do
		farm = farm:FindFirstAncestor("Farm")
	end

	assert(farm, "The given instance does not belong to a farm")

	return getAttribute(farm, Attribute.OwnerId) :: number
end

return getFarmOwnerIdFromInstance
-- LOCAL FUNCTIONS
local function dictLength(dictionary)
	local count = 0
	for _, _ in pairs(dictionary) do
		count += 1
	end
	return count
end

local function fillOccupants(zonesAndOccupantsTable, zone, occupant)
	local occupantsDict = zonesAndOccupantsTable[zone]
	if not occupantsDict then
		occupantsDict = {}
		zonesAndOccupantsTable[zone] = occupantsDict
	end
	occupantsDict[occupant] = (occupant.Character or true)
end

local heartbeatActions = {
	["player"] = function(recommendedDetection)
		return ZoneController._getZonesAndPlayers(activeZones, activeZonesTotalVolume, true, recommendedDetection)
	end,
	["localPlayer"] = function(recommendedDetection)
		local zonesAndOccupants = {}
		local touchingZones = ZoneController.getTouchingZones(localPlayer, true, recommendedDetection)
		for _, zone in pairs(touchingZones) do
			if zone.activeTriggers["localPlayer"] then
				fillOccupants(zonesAndOccupants, zone, localPlayer)
			end
		end
		return zonesAndOccupants
	end,
}
--[[Brakes]]
	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS) 

	Tune.FBrakeForce	= 150000		-- Front brake force
	Tune.RBrakeForce	= 100000		-- Rear brake force
	Tune.PBrakeForce	= 500000		-- Handbrake force
	
	Tune.FLgcyBForce	= 150000		-- Front brake force [PGS OFF]
	Tune.RLgcyBForce	= 100000		-- Rear brake force [PGS OFF]
	Tune.LgcyPBForce	= 500000	-- Handbrake force [PGS OFF]
--forced walkspeed
function module.Blockingsped(hum)
	coroutine.wrap(function()
		while true do
			task.wait()
			
			if hum.Parent.Data["IsBlocking"].Value  == true then
				hum.WalkSpeed = 3
				hum.JumpPower = 1
				
			elseif hum.Parent.Data["IsBlocking"].Value == false then
				hum.WalkSpeed = 16
				hum.JumpPower = defJump
				break
			end
		end
	end)()
end
-- << CONSTANTS & SETUP >>
local rs = game:GetService("ReplicatedStorage")
local pos = math.random(1,#music_list)
local sound = Instance.new("Sound",workspace)
sound.Volume = volume
--[=[
	A class which holds data and methods for ScriptConnections.

	@class ScriptConnection
]=]
local ScriptConnection = {}
ScriptConnection.__index = ScriptConnection
--/Sight
module.SightZoom 	= 10 	-- Set to 0 if you want to use weapon's default zoom
module.SightZoom2 	= 0		--Set this to alternative zoom or Aimpart2 Zoom
--Rear Suspension
Tune.RSusDamping	= 500		-- Spring Dampening
Tune.RSusStiffness	= 8000		-- Spring Force
Tune.RSusLength		= 2			-- Suspension length (in studs)
Tune.RSusMaxExt		= .3		-- Max Extension Travel (in studs)
Tune.RSusMaxComp	= .1		-- Max Compression Travel (in studs)
Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

Tune.RWsBoneLen		= 5			-- Wishbone Length
Tune.RWsBoneAngle	= 0			-- 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
--[[
	Returns true if the system is on
]]
function BaseSystem:isOn()
	return self._isOn
end
--[[
	Defines ProximityPrompt visibility logic specific to the CanHarvest cta
--]]

local CollectionService = game:GetService("CollectionService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")

local WagonTag = require(ReplicatedStorage.Source.SharedConstants.CollectionServiceTag.WagonTag)
local CharacterTag = require(ReplicatedStorage.Source.SharedConstants.CollectionServiceTag.CharacterTag)

local getWagonModelFromOwnerId = require(ReplicatedStorage.Source.Utility.Farm.getWagonModelFromOwnerId)
local localPlayer = Players.LocalPlayer :: Player

local function shouldEnable(promptParent: Instance)
	local wagonMaybe = getWagonModelFromOwnerId(localPlayer.UserId)
	if not wagonMaybe then
		-- Wagon doesn't exist, which only happens during the first FTUE stage.
		-- Harvesting triggers the next stage, so we allow harvesting without the wagon.
		return true
	end
	local wagon = wagonMaybe :: Model

	-- If wagon or Character doesn't exist, HasTag() returns false, so this still works correctly
	local isWagonFull = CollectionService:HasTag(wagon, WagonTag.WagonFull)

	local character = localPlayer.Character
	if not character then
		return false
	end

	local isHoldingPlant = CollectionService:HasTag(character :: Model, CharacterTag.Holding)

	-- Can't carry multiple plants
	if isHoldingPlant then
		return false
	end

	-- Don't want the player to be stuck holding a plant they can't place
	if isWagonFull then
		return false
	end

	return true
end

return shouldEnable
------------------------------------------------------------------------
-- closing of a function
------------------------------------------------------------------------
function luaY:close_func(ls)
  local L = ls.L
  local fs = ls.fs
  local f = fs.f
  self:removevars(ls, 0)
  luaK:ret(fs, 0, 0)  -- final return
  -- luaM_reallocvector deleted for f->code, f->lineinfo, f->k, f->p,
  -- f->locvars, f->upvalues; not required for Lua table arrays
  f.sizecode = fs.pc
  f.sizelineinfo = fs.pc
  f.sizek = fs.nk
  f.sizep = fs.np
  f.sizelocvars = fs.nlocvars
  f.sizeupvalues = f.nups
  --assert(luaG_checkcode(f))  -- currently not implemented
  assert(fs.bl == nil)
  ls.fs = fs.prev
  -- the following is not required for this implementation; kept here
  -- for completeness
  -- L->top -= 2;  /* remove table and prototype from the stack */
  -- last token read was anchored in defunct function; must reanchor it
  if fs then self:anchor_token(ls) end
end
-- Set the ImageLabel's content to the user thumbnail
PlayerInfo.AccountIcon.Image = content
PlayerInfo.Welcome.Text = "Welcome, "..(Player.Name).."!"
--

local function tripleProduct(a, b, c)
	return b * c:Dot(a) - a * c:Dot(b)
end
--[[Transmission]]
	Tune.TransModes		= {"Semi"}												--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "RPM"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		-- Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		-- Automatic downshift point (relative to peak RPM, positive = Under-rev)
	Tune.ShiftTime = .25				-- The time delay in which you initiate a shift and the car changes gear
	
	--Gear Ratios
	Tune.FinalDrive		= 3.21		 --	[TRANSMISSION CALCULATIONS FOR NERDS]
	Tune.Ratios			= {			 --		SPEED [SPS]	 = (Wheel diameter(studs) * pi(3.14) * RPM) / (60 * Gear Ratio * Final Drive * Multiplier)
		--[[Reverse]]	5.000		,--		WHEEL TORQUE = Engine Torque * Gear Ratio * Final Drive * Multiplier
		--[[Neutral]]	0			,
		--[[ 1 ]]		3.519      	,
		--[[ 2 ]]		2.320		,
		--[[ 3 ]]		1.700		,
		--[[ 4 ]]		1.400		,
		--[[ 5 ]]		0.907		,
	}
	Tune.FDMult			= 1.3			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
-- Close win dialog
local function closeDlg(input)
	local mouse = Enum.UserInputType.MouseButton1
	local touch = Enum.UserInputType.Touch
	
	if input.UserInputType == mouse or input.UserInputType == touch then
		dlg.Visible = false
	end
end -- closeDlg()
--CONFIG VARIABLES
local tweenTime = 1
local closeWaitTime = 3
local easingStyle = Enum.EasingStyle.Quad
local easingDirection = Enum.EasingDirection.InOut
local repeats = 0
local reverse = false
local delayTime = 0
--[[
	For when the Server is in state
]]
local ServerStorage = game:GetService("ServerStorage")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")

local SystemManager = require(ServerStorage.Source.Managers.SystemManager)
local RoomManager = require(ServerStorage.Source.Managers.RoomManager)
local Constants = require(ReplicatedStorage.Source.Common.Constants)
local tagMap = require(ServerStorage.Source.tagMap)
local spawnToolsAsync = require(ServerStorage.Source.spawnToolsAsync)
local spawnMeteor = require(ServerStorage.Source.spawnMeteor)
local sendAlert = require(ServerStorage.Source.Common.sendAlert)
local translate = require(ReplicatedStorage.Dependencies.GameUtils.TranslateUtils).translate

local METEOR_FREQUENCY_PER_PLAYER = 45
local SHIELD_DEFLECT_RATE = 40
local connections = {}

local ServerGame = {}
-- Constant CFrame to move all models to so that all viewports are from the same angle
local MODEL_POSITION = Vector3.new()
local MODEL_CFRAME = CFrame.new()