Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[=[
	@class ClientRemoteProperty
	@client
	Created via `ClientComm:GetProperty()`.
]=]


local ClientRemoteProperty = {}
ClientRemoteProperty.__index = ClientRemoteProperty

function ClientRemoteProperty.new(re: RemoteEvent, inboundMiddleware: Types.ClientMiddleware?, outboudMiddleware: Types.ClientMiddleware?)
	local self = setmetatable({}, ClientRemoteProperty)
	self._rs = ClientRemoteSignal.new(re, inboundMiddleware, outboudMiddleware)
	self._ready = false
	self._value = nil
	self.Changed = Signal.new()
	self._readyPromise = self:OnReady():andThen(function()
		self._readyPromise = nil
		self.Changed:Fire(self._value)
		self._changed = self._rs:Connect(function(value)
			if value == self._value then return end
			self._value = value
			self.Changed:Fire(value)
		end)
	end)
	self._rs:Fire()
	return self
end
--[=[
	Throttles emission of observables on the defer stack to the last emission.
	@return (source: Observable) -> Observable
]=]


function Rx.throttleDefer()
	return function(source)
		assert(Observable.isObservable(source), "Bad observable")

		return Observable.new(function(sub)
			local maid = Maid.new()

			local lastResult

			maid:GiveTask(source:Subscribe(function(...)
				if not lastResult then
					lastResult = table.pack(...)

					-- Queue up our result
					task.defer(function()
						local current = lastResult
						lastResult = nil

						if sub:IsPending() then
							sub:Fire(table.unpack(current, 1, current.n))
						end
					end)
				else
					lastResult = table.pack(...)
				end
			end, sub:GetFailComplete()))

			return maid
		end)
	end
end

return Rx
--------END RIGHT DOOR --------



game.Workspace.doorleft.l11.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l23.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l32.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l62.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l71.BrickColor = BrickColor.new(1003)
game.Workspace.doorleft.l12.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l33.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l42.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l51.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l63.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l72.BrickColor = BrickColor.new(1003)
game.Workspace.doorleft.l13.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l22.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l43.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l52.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(1003)

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

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

end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
--Restore Default Settings


local restore = pages.custom["AX Restore"]
local loading = restore.Loading
local restoreDe = 0
restore.MouseButton1Down:Connect(function()
	if restoreDe < 2 then
		local h,s,v = Color3.toHSV(restore.BackgroundColor3)
		loading.BackgroundColor3 = Color3.fromHSV(h, s, v*0.5)
		loading.Visible = true
		if restoreDe == 0 then
			restoreDe = 1
			loading.Blocker.Visible = false
			loading.TextLabel.Text = "Confirm?"
			wait(1)
		elseif restoreDe == 1 then
			restoreDe = 2
			loading.Blocker.Visible = true
			loading.TextLabel.Text = "Loading..."
			local returnMsg = main.signals.RestoreDefaultSettings:InvokeServer()
			if returnMsg == "Success" then
				updateSettings()
				main:GetModule("PageCommands"):CreateCommands()
				local notice = main:GetModule("cf"):FormatNotice("RestoreDefaultSettings")
				main:GetModule("Notices"):Notice("Notice", notice[1], notice[2])
			else
				restore.TextLabel.Text = returnMsg
			end
			wait(1)
		end
		restoreDe = 0
		loading.Visible = false
		loading.Blocker.Visible = false
	end
end)
--02fzx



local FlingAmount = 1000000000000000000000000000000000000000000000000000000000000000000000000	--sky
local sound = false		--well i mean its god hand so..
local sit = false			--If it makes the player sit.
local e = false				--Do not change.
local explode = true		--This one just kills you



function hit(Touch) 
	local blender = Touch.Parent:FindFirstChild("Head") 
	if not (blender == nil) then
		if e == false then
		e = true
		local bv = Instance.new("BodyVelocity")
		bv.P = 1250
		bv.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
		bv.Velocity = blender.CFrame.lookVector*-FlingAmount
		bv.Parent = blender
		if sit == true then
		Touch.Parent:FindFirstChild("Humanoid").Sit = true
		end
		if sound == true then
				local s = script.Parent.Yeet:Clone()
				local MAAAA = script.Parent.Scream:Clone()
			local random = math.random(8,12)/10
			s.Parent = blender
			s.PlaybackSpeed = 1
				s:Play()
				Touch.Parent:FindFirstChild("Humanoid").Health = 100
				MAAAA.Parent = blender
				MAAAA:Play()
				MAAAA.STOP.Disabled = false
		end
		wait(.05)
		bv:Destroy()
		wait(.2)
	
	e = false
		wait(1)
			if explode == true then
				wait(5)
			Touch.Parent:FindFirstChild("Humanoid").Health = 0
		end



		end
	end 
end

script.Parent.Touched:connect(hit)
--[[**
	ensures value is a given literal value

	@param literal The literal to use

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


function t.literal(literal)
	return function(value)
		if value ~= literal then
			return false, string.format("expected %s, got %s", tostring(literal), tostring(value))
		end
		return true
	end
end
-- ONLY SUPPORTS ORDINAL TABLES (ARRAYS). Removes the specified object from this array.


Table.removeObject = function (tbl, obj)
	local index = Table.indexOf(tbl, obj)
	if index then
		table.remove(tbl, index)
	end
end

return setmetatable({}, {
	__index = function(tbl, index)
		if Table[index] ~= nil then
			return Table[index]
		else
			return RobloxTable[index]
		end
	end;

	__newindex = function(tbl, index, value)
		error("Add new table entries by editing the Module itself.")
	end;
})
-- << COMMANDS >>


local module = {
	
	-----------------------------------
	{
	Name = "";
	Aliases	= {};
	Prefixes = {settings.Prefix};
	Rank = 1;
	RankLock = false;
	Loopable = false;
	Tags = {};
	Description = "Free Admin";
	Contributors = {};
	--
	Args = {};
	Function = function(speaker, args)
		
	end;
	UnFunction = function(speaker, args)
		
	end;
	--
	};
	
	
	
	
	-----------------------------------
	{
	Name = "";
	Aliases	= {};
	Prefixes = {settings.Prefix};
	Rank = 1;
	RankLock = false;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {};
	--[[
	ClientCommand = true;
	FireAllClients = true;
	BlockWhenPunished = true;
	PreFunction = function(speaker, args)
		
	end;
	Function = function(speaker, args)
		wait(1)
	end;
	--]]
	--
	};
	
	
	
	
	-----------------------------------
	
};



return module
--[[
	A special key for property tables, which adds user-specified tasks to be run
	when the instance is destroyed.
]]




local Cleanup = {}
Cleanup.type = "SpecialKey"
Cleanup.kind = "Cleanup"
Cleanup.stage = "observer"

function Cleanup:apply(userTask: any, applyTo: Instance, cleanupTasks)
	table.insert(cleanupTasks, userTask)
end

return Cleanup
--[[**
	ensures value is a number where value < max

	@param max The maximum to use

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


function t.numberMaxExclusive(max)
	return function(value)
		local success, errMsg = t.number(value)
		if not success then
			return false, errMsg or ""
		end
		if value < max then
			return true
		else
			return false, string.format("number < %s expected, got %s", max, value)
		end
	end
end
------------------------------------------------------------------------------------------------------------------------------------------------


local BASE_HEIGHT 		= 20	--10			-- The main height factor for the terrain.
local CHUNK_SCALE 		= 4		--3				-- The grid scale for terrain generation. Should be kept relatively low if used in real-time.
local RENDER_DISTANCE 	= 360 / 4	--120		-- The length/width of chunks in voxels that should be around the player at all times
local X_SCALE 			= 90 / 4 --90			-- How much we should strech the X scale of the generation noise
local Z_SCALE 			= 90 / 4				-- How much we should strech the Z scale of the generation noise
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 239		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		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	= 4.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)
---


	script.Parent.Values.Gear.Changed:connect(function()
		if script.Parent.Values.Gear.Value == -1 then
			for index, child in pairs(car.Body.Lights.Rev:GetChildren()) do
			child.Material = Enum.Material.Neon
			car.DriveSeat.Reverse:Play()
			end
		else
			for index, child in pairs(car.Body.Lights.Rev:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			car.DriveSeat.Reverse:Stop()
			end
		end
	end)
	
	while wait() do
		if (car.DriveSeat.Velocity.magnitude/40)+0.300 < 1.3 then
		car.DriveSeat.Reverse.Pitch = (car.DriveSeat.Velocity.magnitude/40)+0.300
		car.DriveSeat.Reverse.Volume = (car.DriveSeat.Velocity.magnitude/150)	
		else
		car.DriveSeat.Reverse.Pitch = 1.3
		car.DriveSeat.Reverse.Volume = .2
		end
	end
-- Properties


local held = false
local step = 0.1
local percentage = 0

function snap(number, factor)
	if factor == 0 then
		return number
	else
		return math.floor(number/factor+0.5)*factor
	end
end

UIS.InputEnded:connect(function(input, processed)
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		held = false
	end
end)

SliderBtn.MouseButton1Down:connect(function()
	held = true
end)

RuS.RenderStepped:connect(function(delta)
	if held then
		local MousePos = UIS:GetMouseLocation().X
		local BtnPos = SliderBtn.Position
		local SliderSize = Slider.AbsoluteSize.X
		local SliderPos = Slider.AbsolutePosition.X
		local pos = snap((MousePos-SliderPos)/SliderSize,step)
		percentage = math.clamp(pos,0,1)
		SliderBtn.Position = UDim2.new(percentage,0,BtnPos.Y.Scale, BtnPos.Y.Offset)
		local old = percentage
		wait()
		if old ~= percentage then
			game.Players.LocalPlayer.Character["Vibe Radio"].changevolume:FireServer(percentage)
		end
	end
end)
------[RGB_SLIDER_MOVEMENT, RGB_TEXT_CHANGED]------


for z = 1, #ColorPickers do
	for i = 1, #RGBSliders[z] do
		----[STOP RGB SLIDER MOVEMENT]----
		local function RGBSliderEnded(Input)
			if Input.UserInputType == Enum.UserInputType.MouseButton1 then
				IsDraggingSliders[i] = false
			end
		end
		RGBSliderHitboxes[z][i].InputEnded:Connect(RGBSliderEnded)
		
		----[CHECK FOR RGB SLIDER MOVEMENT]----
		local function CheckForRGBSliderMovement()
			if not IsDraggingSliders[i] then
				IsDraggingSliders[i] = true
			end	
			while IsDraggingSliders[i] do--and UIS:IsMouseButtonPressed(Enum.UserInputType.MouseButton1) do
				wait()
				local MouseLocation = Plugin:GetRelativeMousePosition()
				if OldMouseLocation ~= MouseLocation then
					RGBSliderMovement(MouseLocation.X, z, i)
					OldMouseLocation = MouseLocation
				end
			end
			IsDraggingSliders[i] = false
		end
		RGBSliderHitboxes[z][i].MouseButton1Down:Connect(CheckForRGBSliderMovement)
		
		----[CHECK IF RGB TEXT CHANGED]----
		local function RGBTextChanged()
			if tonumber(RGBInputs[z][i].Text) == nil then
				RGBInputs[z][i]. Text = "0"
			elseif tonumber(RGBInputs[z][i].Text) <= 0 then
				RGBInputs[z][i].Text = "0"
			elseif tonumber(RGBInputs[z][i].Text) >= 256 then
				RGBInputs[z][i].Text = "255"	
			end
			
			PreviewColor[z].BackgroundColor3 = Color3.fromRGB(tonumber(RGBInputs[z][1].Text), tonumber(RGBInputs[z][2].Text), tonumber(RGBInputs[z][3].Text))
			RGBSliders[z][i].Position = UDim2.new(0, PreviewColor[z].BackgroundColor3[rgb[i]] * RGBSliderHitboxes[z][i].AbsoluteSize.X, RGBSliders[z][i].Position.Y.Scale, 0)
			end
		RGBInputs[z][i].FocusLost:Connect(RGBTextChanged)
	end
end
--Tune--


local StockHP = 450		--Power output desmos: https://www.desmos.com/calculator/wezfve8j90 (does not come with torque curve)
local TurboCount = 1	--(1 = SingleTurbo),(2 = TwinTurbo),(if bigger then it will default to 2 turbos)
local TurboSize = 50	--bigger the turbo, the more lag it has (actually be realistic with it) no 20mm turbos
local WasteGatePressure = 10	--Max PSI for each turbo (if twin and running 10 PSI, thats 10PSI for each turbo)
local CompressionRatio = 8/1	--Compression of your car (look up the compression of the engine you are running)
local AntiLag = true	--if true basically keeps the turbo spooled up so less lag

local BOV_Loudness = 6	--volume of the BOV (not exact volume so you kinda have to experiment with it)
local BOV_Pitch = 0.8	--max pitch of the BOV (not exact so might have to mess with it)
local TurboLoudness = 2.3 --volume of the Turbo (not exact volume so you kinda have to experiment with it also)
-- TODO: retry multiple time if HTTP call fail


local function getTextureId(id: number): number?
	local assetInfo = MarketplaceService:GetProductInfo(id, Enum.InfoType.Asset)

	if assetInfo.AssetTypeId == Enum.AssetType.Image.Value then
		return id
	elseif assetInfo.AssetTypeId == Enum.AssetType.Decal.Value then
		return HttpService:GetAsync(`http://f3xteam.com/bt/getDecalImageID/{id}`)
	end

	return
end

Remote.OnServerEvent:Connect(function(plr, id: number | string, pos)
	if Helper.Owner ~= plr then
		return
	end

	local assetId = tonumber(tostring(id):match("%d+") or 0) :: number

	if assetId == 0 then
		return
	end

	local textureId = getTextureId(assetId)

	if not textureId then
		return
	end

	if textureId ~= 0 then
		local rayOrigin = Tool.Handle.Position
		local rayDestination = pos

		local rayDirection = rayDestination - rayOrigin

		if rayDirection.Magnitude >= 10 then
			return
		end

		local raycastParams = RaycastParams.new()
		raycastParams.FilterDescendantsInstances = {plr.Character}
		raycastParams.FilterType = Enum.RaycastFilterType.Exclude
		raycastParams.IgnoreWater = true

		local raycastResult = workspace:Raycast(rayOrigin, rayDirection*2, raycastParams)

		if (raycastResult) and raycastResult.Instance then
			if raycastResult.Instance:FindFirstAncestorWhichIsA("Model") then
				if raycastResult.Instance:FindFirstAncestorWhichIsA("Model"):FindFirstChildWhichIsA("Humanoid") then
					return
				end
			end
			if raycastResult.Instance:FindFirstAncestorWhichIsA("Tool") then
				return
			end
			
			local sprays = {}

			for _, i in ipairs(workspace.Sprays:GetChildren()) do
				if i:GetAttribute("User") then
					if i:GetAttribute("User") == plr.UserId then
						table.insert(sprays, i)
					end
				end
			end

			if #sprays >= 3 then
				if sprays[1] then
					sprays[1]:Destroy()
				end
			end
			
			Tool.Handle.Spray:Play()

			local object = game.ServerStorage.PaintedObject:Clone()
			object.Decal.Texture =`rbxassetid://{textureId}`
			object.CFrame = CFrame.lookAt(raycastResult.Position, raycastResult.Position - raycastResult.Normal)
			object:SetAttribute("User", plr.UserId)
			object.Parent = workspace.Sprays

			if raycastResult.Instance.Anchored == false then
				object.Anchored = false

				local c0 = raycastResult.Instance.CFrame:Inverse()
				local c1 = object.CFrame:Inverse()

				local weld = Instance.new("Weld")
				weld.Parent = object

				weld.Part0 = raycastResult.Instance
				weld.Part1 = object

				weld.C0 = c0
				weld.C1 = c1
			end
		end
	end
end)
--				{ id = "slash.xml", weight = 10 } 


			},
	toollunge = {
				{ id = "http://www.roblox.com/asset/?id=129967478", weight = 10 } 
			},
	wave = {
				{ id = "http://www.roblox.com/asset/?id=128777973", weight = 10 } 
			},
	point = {
				{ id = "http://www.roblox.com/asset/?id=128853357", weight = 10 } 
			},
	dance = {
				{ id = "http://www.roblox.com/asset/?id=130018893", weight = 10 }, 
				{ id = "http://www.roblox.com/asset/?id=132546839", weight = 10 }, 
				{ id = "http://www.roblox.com/asset/?id=132546884", weight = 10 } 
			},
	laugh = {
				{ id = "http://www.roblox.com/asset/?id=129423131", weight = 10 } 
			},
	cheer = {
				{ id = "http://www.roblox.com/asset/?id=129423030", weight = 10 } 
			},
}
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]


local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local on = 0

script:WaitForChild("Idle")

if not FE then
	for i,v in pairs(car.DriveSeat:GetChildren()) do
		for _,a in pairs(script:GetChildren()) do
			if v.Name==a.Name then v:Stop() wait() v:Destroy() end
		end
	end
	for i,v in pairs(script:GetChildren()) do
		v.Parent=car.DriveSeat
	end
	
	car.DriveSeat.Idle:Play()
	
	while wait() do
		local _RPM = script.Parent.Values.RPM.Value
		
		if not car.DriveSeat.IsOn.Value then on=math.max(on-.015,0) else on=1 end
		car.DriveSeat.Idle.Pitch = (car.DriveSeat.Idle.SetPitch.Value + car.DriveSeat.Idle.SetRev.Value*_RPM/_Tune.Redline)*on^2
	end
else
	local handler = car.AC6_FE_Idle
	handler:FireServer("newSound","Idle",car.DriveSeat,script.Idle.SoundId,0,script.Idle.Volume,true)
	handler:FireServer("playSound","Idle")
	local pitch=0
	while wait() do
		local _RPM = script.Parent.Values.RPM.Value
		
		if not car.DriveSeat.IsOn.Value then on=math.max(on-.015,0) else on=1 end
		pitch = (script.Idle.SetPitch.Value + script.Idle.SetRev.Value*_RPM/_Tune.Redline)*on^2
		handler:FireServer("updateSound","Idle",script.Idle.SoundId,pitch,script.Idle.Volume)
	end
end
--[[

	Component.Auto(folder)
		-> Create components automatically from descendant modules of this folder
		-> Each module must have a '.Tag' string property
		-> Each module optionally can have '.RenderPriority' number property

	component = Component.FromTag(tag)
		-> Retrieves an existing component from the tag name

	component = Component.new(tag, class [, renderPriority])
		-> Creates a new component from the tag name, class module, and optional render priority

	component:GetAll()
	component:GetFromInstance(instance)
	component:GetFromID(id)
	component:Filter(filterFunc)
	component:WaitFor(instanceOrName)
	component:Destroy()

	component.Added(obj)
	component.Removed(obj)

	-----------------------------------------------------------------------

	A component class must look something like this:

		-- DEFINE
		local MyComponent = {}
		MyComponent.__index = MyComponent

		-- CONSTRUCTOR
		function MyComponent.new(instance)
			local self = setmetatable({}, MyComponent)
			return self
		end

		-- FIELDS AFTER CONSTRUCTOR COMPLETES
		MyComponent.Instance: Instance

		-- OPTIONAL LIFECYCLE HOOKS
		function MyComponent:Init() end                     -> Called right after constructor
		function MyComponent:Deinit() end                   -> Called right before deconstructor
		function MyComponent:HeartbeatUpdate(dt) ... end    -> Updates every heartbeat
		function MyComponent:SteppedUpdate(dt) ... end      -> Updates every physics step
		function MyComponent:RenderUpdate(dt) ... end       -> Updates every render step

		-- DESTRUCTOR
		function MyComponent:Destroy()
		end


	A component is then registered like so:
		
		local Component = require(Knit.Util.Component)
		local MyComponent = require(somewhere.MyComponent)
		local tag = "MyComponent"

		local myComponent = Component.new(tag, MyComponent)


	Components can be listened and queried:

		myComponent.Added:Connect(function(instanceOfComponent)
			-- New MyComponent constructed
		end)

		myComponent.Removed:Connect(function(instanceOfComponent)
			-- New MyComponent deconstructed
		end)

--]]




local Maid = require(script.Parent.Maid)
local Signal = require(script.Parent.Signal)
local Promise = require(script.Parent.Promise)
local Thread = require(script.Parent.Thread)
local TableUtil = require(script.Parent.TableUtil)
local CollectionService = game:GetService("CollectionService")
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")

local IS_SERVER = RunService:IsServer()
local DEFAULT_WAIT_FOR_TIMEOUT = 60
local ATTRIBUTE_ID_NAME = "ComponentServerId"
--attack function


function attack()
	for i,v in pairs(workspace:GetChildren()) do
		if v:FindFirstChild("Humanoid") then
			if v ~= script.Parent then
				if (v.Head.Position - script.Parent.Head.Position).Magnitude < damagerange then
					v.Humanoid:TakeDamage(damage)
				end
			end
		end
	end
	wait(0.3)
end
-- Clear any existing animation tracks
-- Fixes issue with characters that are moved in and out of the Workspace accumulating tracks


local animator = if Humanoid then Humanoid:FindFirstChildOfClass("Animator") else nil
if animator then
	local animTracks = animator:GetPlayingAnimationTracks()
	for i, track in ipairs(animTracks) do
		track:Stop(0)
		track:Destroy()
	end
end

for name, fileList in pairs(animNames) do
	configureAnimationSet(name, fileList)
end
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]



local car = script.Parent.Car.Value
local vl = script.Parent.Values

local strength = 350

local max = 4 --in sps

while wait() do
	if vl.Throttle.Value < 0.1 and vl.RPM.Value > 0 and vl.Velocity.Value.Magnitude < max and (math.abs(vl.Gear.Value) > 0) then
		car.Body.Creep.BV.MaxForce = Vector3.new(strength,0,strength)
	else
		car.Body.Creep.BV.MaxForce = Vector3.new(0,0,0)
	end
	car.Body.Creep.BV.Velocity = car.Body.Creep.CFrame.lookVector*(8*(math.min(vl.Gear.Value,1)))
end