Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[[Weight and CG]]


	Tune.Weight			= 3847		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		7.28		,
	 --[[Height]]		5.57		,
	 --[[Length]]		18.39		}
	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
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 380		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 800		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--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)
-- Engine Sound Parameters


local RPM_CROSSOVER = 250 -- How much more engine power is needed to crossover to the next engine audio track
local ENGINE_GAIN_ACCEL = 1 -- Exponent that builds the engine RPM when accelerating (gives the engine sound more oomph the higher the value)
local ENGINE_GAIN_DECCEL = 1 -- Exponent that builds the engine RPM when decelerating (braking)
local BASE_RPM = Vehicle:GetAttribute("BaseEngineRPM") or 1500 -- Resting state for the engine
local MAX_RPM = Vehicle:GetAttribute("MaxEngineRPM") or 5000 -- The engine RPM correlating to the highest pitch for engine sounds
local MAX_IDEAL_RPM = MAX_RPM-(MAX_RPM-BASE_RPM)/4 -- engine RPM correlating to normal usage (not under stress)
local MAX_SPEED = 125 -- The rotational velocity a vehicle's wheels would be reaching for the highest pitched engine sounds
--- Splits a string by space but taking into account quoted sequences which will be treated as a single argument.


function Util.SplitString(text, max)
	text = encodeControlChars(text)
	max = max or math.huge
	local t = {}
	local spat, epat = [=[^(['"])]=], [=[(['"])$]=]
	local buf, quoted
	for str in text:gmatch("[^ ]+") do
		str = Util.ParseEscapeSequences(str)
		local squoted = str:match(spat)
		local equoted = str:match(epat)
		local escaped = str:match([=[(\*)['"]$]=])
		if squoted and not quoted and not equoted then
			buf, quoted = str, squoted
		elseif buf and equoted == quoted and #escaped % 2 == 0 then
			str, buf, quoted = buf .. " " .. str, nil, nil
		elseif buf then
			buf = buf .. " " .. str
		end
		if not buf then
			t[#t + (#t > max and 0 or 1)] = decodeControlChars(str:gsub(spat, ""):gsub(epat, ""))
		end
	end

	if buf then
		t[#t + (#t > max and 0 or 1)] = decodeControlChars(buf)
	end

	return t
end
--Leave this


Heat = 0

if GUI then
	script.Parent.Visible = true
else
	script.Parent.Visible = false
end

if not FE then
	
radiator.Oil.Enabled = false
radiator.Antifreeze.Enabled = false
radiator.Liquid.Volume = 0
radiator.Fan:Play()
radiator.Fan.Pitch = 1+FanSpeed
radiator.Steam:Play()
radiator.Liquid:Play()
script.Blown.Value = false
	
	Load = ((script.Parent.Parent.Values.Throttle.Value*script.Parent.Parent.Values.RPM.Value*10*OverheatSpeed)/math.ceil((car.DriveSeat.Velocity.magnitude+.0000001)/100)/75000)-CoolingEfficiency
	Heat = math.max(RunningTemp,(Heat+Load)+FanCool)
	
script.Celsius.Changed:Connect(function()
	intmp.Rotation = -30 + Heat * 250 / 8000
end)
	
	while wait(.2) do
	if Heat > FanTemp and Fan == true then
		FanCool = -FanSpeed
		radiator.Fan.Volume = FanVolume
	elseif Heat < FanTempAlpha then
		FanCool = 0
		radiator.Fan.Volume = 0
	end
	end
	
	if Heat >= BlowupTemp then
		Heat = BlowupTemp
		radiator.Break:Play()
		radiator.Liquid.Volume = .5
		radiator.Oil.Enabled = true
		radiator.Antifreeze.Enabled = true
		script.Parent.Parent.IsOn.Value = false
		script.Blown.Value = true
	elseif Heat >= BlowupTemp-20 then
		radiator.Smoke.Transparency = NumberSequence.new((BlowupTemp-Heat)/10,1)
		radiator.Smoke.Enabled = true
		dash.Warn.Transparency = 0
		radiator.Steam.Volume = math.abs(((BlowupTemp-Heat)-10)/10)
	else
		radiator.Smoke.Enabled = false
		radiator.Steam.Volume = 0
		dash.Warn.Transparency = 1
	end
	
	script.Celsius.Value = Heat
	script.Parent.Temp.Text = math.floor(Heat).."°c"
	script.Parent.Temp.TextColor3 = Color3.fromRGB(255,255-((Heat-FanTemp)*10),255-((Heat-FanTemp)*10))

else

	handler:FireServer("Initialize",FanSpeed)
while wait(.2) do
	
	if Heat > FanTemp and Fan == true then
		FanCool = -FanSpeed
		handler:FireServer("FanVolume",FanVolume)
	else
		FanCool = 0
		handler:FireServer("FanVolume",0)
	end
	
	Load = ((script.Parent.Parent.Values.Throttle.Value*script.Parent.Parent.Values.RPM.Value*10*OverheatSpeed)/math.ceil((car.DriveSeat.Velocity.magnitude+.0000001)/100)/75000)-CoolingEfficiency
	Heat = math.max(RunningTemp,(Heat+Load)+FanCool)
	
	if Heat >= BlowupTemp then
		Heat = BlowupTemp
		handler:FireServer("Blown")
		script.Parent.Parent.IsOn.Value = false
		script.Blown.Value = true
	elseif Heat >= BlowupTemp-20 then
		handler:FireServer("Smoke",true,BlowupTemp,Heat)
	else
		handler:FireServer("Smoke",false,BlowupTemp,Heat)
	end
	
	script.Celsius.Value = Heat
	script.Parent.Temp.Text = math.floor(Heat).."°c"
	
	handler:FireServer("Gauge",script.Celsius.Value,intmp)
	
end
end
-- ROBLOX NOTE: no upstream
-- this plugin serializes Roblox Instance objects
-- https://developer.roblox.com/en-us/api-reference/class/Instance



local CurrentModule = script.Parent.Parent
local Packages = CurrentModule.Parent

local JestGetType = require(Packages.JestGetType)
local getType = JestGetType.getType

local LuauPolyfill = require(Packages.LuauPolyfill)
local instanceof = LuauPolyfill.instanceof

local RobloxInstance = require(Packages.RobloxShared).RobloxInstance
local getRobloxProperties = RobloxInstance.getRobloxProperties
local InstanceSubset = RobloxInstance.InstanceSubset

local printTableEntries = require(CurrentModule.Collections).printTableEntries

local Types = require(CurrentModule.Types)
type Config = Types.Config
type Refs = Types.Refs
type Printer = Types.Printer

local function printInstance(
	val: any,
	config: Config,
	indentation: string,
	depth: number,
	refs: Refs,
	printer: Printer
): string
	local result = ""

	local children = val:GetChildren()
	table.sort(children, function(a, b)
		return a.Name < b.Name
	end)
	local props = getRobloxProperties(val.ClassName)

	if #props > 0 or #children > 0 then
		result = result .. config.spacingOuter

		local indentationNext = indentation .. config.indent

		-- print properties of Instance
		for i, v in ipairs(props) do
			local name = printer(v, config, indentationNext, depth, refs)

			local value = val[v]
			-- collapses output for Instance values to avoid loops
			if getType(value) == "Instance" then
				value = printer(value, config, indentationNext, math.huge, refs)
			else
				value = printer(value, config, indentationNext, depth, refs)
			end

			result = string.format("%s%s%s: %s", result, indentationNext, name, value)

			if i < #props or #children > 0 then
				result = result .. "," .. config.spacingInner
			elseif not config.min then
				result = result .. ","
			end
		end

		-- recursively print children of Instance
		for i, v in ipairs(children) do
			local name = printer(v.Name, config, indentationNext, depth, refs)
			local value = printer(v, config, indentationNext, depth, refs)

			result = string.format("%s%s%s: %s", result, indentationNext, name, value)

			if i < #children then
				result = result .. "," .. config.spacingInner
			elseif not config.min then
				result = result .. ","
			end
		end

		result = result .. config.spacingOuter .. indentation
	end

	return result
end

local function serialize(
	val: any,
	config: Config,
	indentation: string,
	depth: number,
	refs: Refs,
	printer: Printer
): string
	depth = depth + 1

	if depth >= config.maxDepth then
		return string.format('"%s" [%s]', val.Name, val.ClassName)
	end

	if instanceof(val, InstanceSubset) then
		return val.ClassName .. " {" .. printTableEntries(val.subset, config, indentation, depth, refs, printer) .. "}"
	end

	return val.ClassName .. " {" .. printInstance(val, config, indentation, depth, refs, printer) .. "}"
end

local function test(val: any): boolean
	return getType(val) == "Instance" or instanceof(val, InstanceSubset)
end

return {
	serialize = serialize,
	test = test,
}
--DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!


local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.KittySword -- Change "Sword" to the name of your tool, make sure your tool is in ServerStorage

hitPart.Touched:Connect(function(hit)
	if debounce == true then
		if hit.Parent:FindFirstChild("Humanoid") then
			local plr = game.Players:FindFirstChild(hit.Parent.Name)
			if plr then
				debounce = false
				hitPart.BrickColor = BrickColor.new("Bright red")
				tool:Clone().Parent = plr.Backpack
				wait(3) -- Change "3" to however long you want the player to have to wait before they can get the tool again
				debounce = true
				hitPart.BrickColor = BrickColor.new("Bright green")
			end
		end
	end
end)
-- Private Functions



local function arcLengthIntegrand(self, spline, t)
	local a, b, c, d = unpack(self.Coefficients)
	local dv = b[spline] + 2*c[spline]*t + 3*d[spline]*t*t
	return dv.Magnitude
end

local function integrate(self, spline, t)
	local h = t / SIMPSON_N
	local xi0, xi1, xi2 = arcLengthIntegrand(self, spline, t), 0, 0
	
	for i = 0, SIMPSON_N - 1 do
		local x = i*h
		if (i % 2 == 0) then
			xi2 = xi2 + arcLengthIntegrand(self, spline, x)
		else
			xi1 = xi1 + arcLengthIntegrand(self, spline, x)
		end
	end
	
	return h * (xi0 + 2*xi2 + 4*xi1) / 3
end

local function clampedCubicSpline(p, fpo, fpn)
	local n = #p
	local a, b, c, d = {unpack(p)}, {}, {}, {}
	
	local aa = {}
	aa[1] = 3*(a[2] - a[1]) - 3*fpo
	aa[n] = 3*fpn - 3*(a[n] - a[n-1])
	
	for i = 2, n - 1 do
		aa[i] = 3 * (a[i+1] - 2*a[i] + a[i-1])
	end
	
	local l, mu, z = {2}, {0.5}, {aa[1]/2}
	
	for i = 2, n - 1 do
		l[i] = 4 - mu[i-1]
		mu[i] = 1 / l[i]
		z[i] = (aa[i] - z[i-1]) / l[i]
	end
	
	l[n] = 2 - mu[n-1]
	z[n] = (aa[n] - z[n-1]) / l[n]
	c[n] = z[n]
	
	for j = n - 1, 1, -1 do
		c[j] = z[j] - mu[j]*c[j+1]
		d[j] = (c[j+1] - c[j]) / 3
		b[j] = p[j+1] - p[j] - c[j] - d[j]
	end
	
	return a, b, c, d
end

local function naturalCubicSpline(p)
	local n = #p
	local a, b, c, d = {unpack(p)}, {}, {}, {}
	
	local aa = {}
	
	for i = 2, n - 1 do
		aa[i] = 3 * (a[i+1] - 2*a[i] + a[i-1])
	end
	
	local start = Vector3.new(0, 10, 0)
	local l, mu, z = {1}, {0}, {ZERO}
	l[n], z[n], c[n] = 1, ZERO, ZERO

	for i = 2, n - 1 do
		l[i] = 4 - mu[i-1]
		mu[i] = 1 / l[i]
		z[i] = (aa[i] - z[i-1]) / l[i]
	end
	
	for j = n - 1, 1, -1 do
		c[j] = z[j] - mu[j]*c[j+1]
		d[j] = (c[j+1] - c[j]) / 3
		b[j] = p[j+1] - p[j] - c[j] - d[j]
	end
	
	return a, b, c, d
end
----- Controller Table -----



local ReplicaController = {

	NewReplicaSignal = Madwork.NewScriptSignal(), -- (Replica)
	InitialDataReceivedSignal = Madwork.NewScriptSignal(), -- ()
	InitialDataReceived = false,

	_replicas = {
		--[[
			[replica_id] = {
				Data = {}, -- [table] Replicated Replica data table
				Id = 1, -- [integer] Replica id
				Class = "", -- [string] Primary Replica identifier
				Tags = {UserId = 2312310}, -- [table] Secondary Replica identifiers
				
				Parent = Replica, -- [Replica / nil] -- Child replicas inherit replication settings
				Children = {}, -- [table] {replica, ...}
						
				_write_lib = {[func_id] = function, ...} / nil, -- [table] List of wrapped write functions
				_write_lib_dictionary = {["function_name"] = func_id, ...} / nil, -- [table] Dictionary of function names and their id's
				
				_table_listeners = {[1] = {}} -- [table] Listeners of specific value changes in replica data
				_function_listeners = {[func_id] = {listener, ...}, ...} -- [table] Listeners of write function calls
				_raw_listeners = {listener, ...},
				
				_signal_listeners = {},
				_maid = maid,
			}
		--]]
	},

	_class_listeners = {}, -- {["replica_class"] = script_signal, ...}
	_child_listeners = {}, -- {[replica_id] = {listener, ...}, ...}

}
----------------------------------------------------------------------------------------------------------------



local SmoothDamp = {}
SmoothDamp.__index = SmoothDamp

function SmoothDamp.new()
	return setmetatable({
		MaxSpeed = math.huge;
		_update = tick();
		_velocity = Vector3_new();
	}, SmoothDamp)
end

function SmoothDamp:Update(current, target, smoothTime)
	local currentVelocity = self._velocity
	local now = tick()
	local deltaTime = (now - self._update)
	smoothTime = math_max(0.0001, smoothTime)
	local num = (2 / smoothTime)
	local num2 = (num * deltaTime)
	local d = (1 / (1 + num2 + 0.48 * num2 * num2 + 0.235 * num2 * num2 * num2))
	local vector = (current - target)
	local vector2 = target
	local maxLength = (self.MaxSpeed * smoothTime)
	vector = vector.Magnitude > maxLength and (vector.Unit * maxLength) or vector -- Clamp magnitude.
	target = (current - vector)
	local vector3 = ((currentVelocity + num * vector) * deltaTime)
	currentVelocity = ((currentVelocity - num * vector3) * d)
	local vector4 = (target + (vector + vector3) * d)
	if ((vector2 - current):Dot(vector4 - vector2) > 0) then
		vector4 = vector2
		currentVelocity = ((vector4 - vector2) / deltaTime)
	end
	self._velocity = currentVelocity
	self._update = now
	return vector4
end

function SmoothDamp:UpdateAngle(current, target, smoothTime)
	return self:Update(current, (current + DeltaAngleV3(current, target)), smoothTime)
end

return SmoothDamp
--SeregaTopYTReal2
--Put the "died" sound to npc's head



local NPC = script.Parent
local Head = NPC.Torso
local Humanoid
for i,v in pairs(NPC:GetChildren()) do 
	if v:IsA('Humanoid') then 
		Humanoid = v 
	end 
end

if Humanoid then
	Humanoid.Died:Connect(function()
		wait(0.0001)
		Head:FindFirstChild("dead"):Play()
	end)
else
	warn('Cannot find Humanoid in DeathSound Script!')
end
--------RIGHT DOOR --------


game.Workspace.doorright.l11.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l21.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l31.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l61.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(1003)

game.Workspace.doorright.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--BotHit


Door.Touched:Connect(function(hit)
	if hit.Parent:FindFirstChild("Humanoid") and hit.Parent:FindFirstChild("Bot") then
		if Ready == true then
			if Open == false then
				Ready = false
				Unlock:Play()
				hit.Parent.HumanoidRootPart.Anchored = true
				wait(1)
				hit.Parent.HumanoidRootPart.Anchored = false
				Open = true
				Handle.TargetAngle = 90
				OpenSound:Play()
				OpenTween:Play()
				wait(.5)
				Ready = true
			end
		end
	end
end)
--[[
	Returns the UpVector used for each face to determine Camera rotation when doing CFrame calculation.
]]


function CameraModule:_getUpVectorByFace(cframe, face)
	local upVectorsByFace = {
		[Enum.NormalId.Front] = cframe.UpVector,
		[Enum.NormalId.Back] = cframe.UpVector,
		[Enum.NormalId.Right] = cframe.UpVector,
		[Enum.NormalId.Left] = cframe.UpVector,
		[Enum.NormalId.Top] = cframe.RightVector,
		[Enum.NormalId.Bottom] = cframe.RightVector,
	}

	return upVectorsByFace[face]
end

return CameraModule
--> LOCAL VARIABLES


local Flare = script.Parent
local Player = game.Players.LocalPlayer
local ClickedEvent = Flare:WaitForChild("PlayerClicked")
local FlareHandle = Flare:WaitForChild("Handle")
local ReloadTime = Flare:WaitForChild("Customisation"):WaitForChild("ReloadTime").Value
local FireAnim = Flare:WaitForChild("FireAnimation")
local ReloadAnim = Flare:WaitForChild("ReloadAnimation")
local Reloading = false
-- In GNU diff format, indexes are one-based instead of zero-based.


local function createPatchMark(
	aStart: number,
	aEnd: number,
	bStart: number,
	bEnd: number,
	options: DiffOptionsNormalized
): string
	return options.patchColor(
		string.format("@@ -%d,%d +%d,%d @@", aStart + 1, aEnd - aStart, bStart + 1, bEnd - bStart)
	)
end
--[[
	Singleton manager that controls the monsters.
]]


local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

local Registry = require(ReplicatedStorage.Dependencies.GameUtils.Components.Registry)
local TableUtils = require(ReplicatedStorage.Dependencies.LuaUtils.TableUtils)
local Monster = require(ServerStorage.Source.Components.Monster)
local getRandomClearLocationInRegionAsync = require(ServerStorage.Source.Common.getRandomClearLocationInRegionAsync)

local CLEAR_AREA_TO_SPAWN = Vector3.new(5, 5, 5)

local monsters = Registry.new(Monster)
local interests = {}
local monsterId = 1

local MonsterManager = {}
--[[
	Merges all arrays into one array, eliminating duplicate values
--]]



local function mergeArraysUniqueOnly(...: { any })
	local results = {}

	for _, array in ipairs({ ... }) do
		if not array then
			continue
		end
		for _, value in ipairs(array) do
			if not table.find(results, value) then
				table.insert(results, value)
			end
		end
	end

	return results
end

return mergeArraysUniqueOnly
--function onKeyPress(inputObject, gameProcessedEvent)
--	if not gameProcessedEvent then
--		if inputObject.KeyCode == Enum.KeyCode.E then
--			if Mode == "Narrow" then
--				Tool.RemoteEvent:FireServer(nil, "Narrow")
--				Mode = "Fog"
--			else
--				Tool.RemoteEvent:FireServer(nil, "Fog")
--				Mode = "Narrow"
--			end
--		end
--	end
--end
--game:GetService("UserInputService").InputEnded:connect(onKeyPress)
--[[Brakes]]


	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS) 

	Tune.BrakeForce		= 2500		-- Total brake force (LuaInt)
	Tune.BrakeBias		= .6		-- Brake bias towards the front, percentage (1 = Front, 0 = Rear, .5 = 50/50)
	Tune.PBrakeForce	= 5000		-- Handbrake force
	Tune.PBrakeBias		= 0			-- Handbrake bias towards the front, percentage (1 = Front, 0 = Rear, .5 = 50/50)
	Tune.EBrakeForce	= 500		-- Engine braking force at redline
-- Check if character is there


if script.Owner.Value.Character ~= nil then
	
	-- Find knife
	local knife = nil
	if script.Owner.Value.Backpack:FindFirstChild("Knife") then
		knife = script.Owner.Value.Backpack.Knife
	elseif script.Owner.Value.Character:FindFirstChild("Knife") then
		knife = script.Owner.Value.Character.Knife
	end
	if knife ~= nil then
		
		-- Make it go through players
		knife.KnifeScript.KnifeProjectileScript.MultikillsAllowed.Value = true
		
	end
	
end
---------------------------
--[[
	--Main anchor point is the DriveSeat <car.DriveSeat>	
	
	Usage:
		MakeWeld(Part1,Part2,WeldType*,MotorVelocity**) *default is "Weld"  **Applies to Motor welds only
		ModelWeld(Model,MainPart)
	Example:
		MakeWeld(car.DriveSeat,misc.PassengerSeat)
		MakeWeld(car.DriveSeat,misc.SteeringWheel,"Motor",.2)
		ModelWeld(car.DriveSeat,misc.Door)
]]
--Weld stuff here


MakeWeld(car.DriveSeat,misc:WaitForChild('Downforce'))

misc:WaitForChild("Spoiler")
MakeWeld(car.DriveSeat,misc.Spoiler:WaitForChild("A1")).Name="W"
MakeWeld(misc.Spoiler.A1,misc.Spoiler:WaitForChild("A2"),"Motor",.01).Name="W"
MakeWeld(misc.Spoiler.A2,misc.Spoiler:WaitForChild("A3"),"Motor",.02).Name="W"
MakeWeld(misc.Spoiler.A3,misc.Spoiler:WaitForChild("A"),"Motor",.01).Name="W"
MakeWeld(misc.Spoiler.A3,misc.Spoiler:WaitForChild("A4"),"Motor",.01).Name="P"
MakeWeld(misc.Spoiler.A4,misc.Spoiler:WaitForChild("Sp"),"Motor",.01).Name="W"
MakeWeld(misc.Spoiler.Sp,misc.Spoiler:WaitForChild("B1"))
MakeWeld(misc.Spoiler.B1,misc.Spoiler:WaitForChild("B"),"Motor",.01).Name="W"

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,-.5,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0)*CFrame.Angles(math.rad(13),0,0)
	end
end)
--[=[
	Sets the BasicPane to be visible

	@param isVisible boolean -- Whether or not the pane should be visible
	@param doNotAnimate boolean? -- True if this visiblity should not animate
]=]


function BasicPane:SetVisible(isVisible, doNotAnimate)
	assert(type(isVisible) == "boolean", "Bad isVisible")

	if self._visible ~= isVisible then
		self._visible = isVisible

		local maid = Maid.new()
		self._maid._paneVisibleMaid = maid
		self.VisibleChanged:Fire(self._visible, doNotAnimate, maid)
	end
end
--[[ SCRIPT VARIABLES ]]


local CHAT_BUBBLE_FONT = Enum.Font.SourceSans
local CHAT_BUBBLE_FONT_SIZE = Enum.FontSize.Size24 -- if you change CHAT_BUBBLE_FONT_SIZE_INT please change this to match
local CHAT_BUBBLE_FONT_SIZE_INT = 24 -- if you change CHAT_BUBBLE_FONT_SIZE please change this to match
local CHAT_BUBBLE_LINE_HEIGHT = CHAT_BUBBLE_FONT_SIZE_INT + 10
local CHAT_BUBBLE_TAIL_HEIGHT = 14
local CHAT_BUBBLE_WIDTH_PADDING = 30
local CHAT_BUBBLE_FADE_SPEED = 1.5

local BILLBOARD_MAX_WIDTH = 400
local BILLBOARD_MAX_HEIGHT = 250	--This limits the number of bubble chats that you see above characters

local ELIPSES = "..."
local MaxChatMessageLength = 128 -- max chat message length, including null terminator and elipses.
local MaxChatMessageLengthExclusive
if FFlagUserChatNewMessageLengthCheck2 then
	MaxChatMessageLengthExclusive = MaxChatMessageLength - getMessageLength(ELIPSES) - 1
else
	MaxChatMessageLengthExclusive = MaxChatMessageLength - string.len(ELIPSES) - 1
end

local NEAR_BUBBLE_DISTANCE = 65	--previously 45
local MAX_BUBBLE_DISTANCE = 100	--previously 80
-- Existance in this list signifies that it is an emote, the value indicates if it is a looping emote


EmoteNames = {
	Wave = false,
	Point = false,
	Dance = true,
	Dance2 = true,
	Dance3 = true,
	Laugh = false,
	Cheer = false
}

math.randomseed(tick())

function ConfigureAnimationSet(Name, FileList)
	if AnimTable[Name] then
		for i, Connection in pairs(AnimTable[Name].Connections) do
			Connection:disconnect()
		end
	end
	AnimTable[Name] = {}
	AnimTable[Name].Count = 0
	AnimTable[Name].TotalWeight = 0	
	AnimTable[Name].Connections = {}

	-- check for config values
	local Config = script:FindFirstChild(Name)
	if Config then