Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[=[
	@class Component

	Bind components to Roblox instances using the Component class and CollectionService tags.

	To avoid confusion of terms:
	- `Component` refers to this module.
	- `Component Class` (e.g. `MyComponent` through this documentation) refers to a class created via `Component.new`
	- `Component Instance` refers to an instance of a component class.
	- `Roblox Instance` refers to the Roblox instance to which the component instance is bound.

	Methods and properties are tagged with the above terms to help clarify the level at which they are used.
]=]


local Component = {}
Component.__index = Component
--// F key, HornOn


mouse.KeyDown:connect(function(key)
	if key=="h" then 
		veh.Lightbar.middle.Airhorn:Play()
		veh.Lightbar.middle.Wail.Volume = 0
		veh.Lightbar.middle.Yelp.Volume = 0
		veh.Lightbar.middle.Priority.Volume = 0 	
	end
end)
--[=[
	Returns the current value for the given player. This value
	will depend on if `SetFor` or `SetFilter` has affected the
	custom value for the player. If so, that custom value will
	be returned. Otherwise, the top-level value will be used
	(e.g. value from `Set`).

	```lua
	-- Set top level data:
	remoteProperty:Set("Data")
	print(remoteProperty:GetFor(somePlayer)) --> "Data"

	-- Set custom data:
	remoteProperty:SetFor(somePlayer, "CustomData")
	print(remoteProperty:GetFor(somePlayer)) --> "CustomData"

	-- Set top level again, overriding custom data:
	remoteProperty:Set("NewData")
	print(remoteProperty:GetFor(somePlayer)) --> "NewData"

	-- Set custom data again, and set top level without overriding:
	remoteProperty:SetFor(somePlayer, "CustomData")
	remoteProperty:SetTop("Data")
	print(remoteProperty:GetFor(somePlayer)) --> "CustomData"

	-- Clear custom data to use top level data:
	remoteProperty:ClearFor(somePlayer)
	print(remoteProperty:GetFor(somePlayer)) --> "Data"
	```
]=]


function RemoteProperty:GetFor(player: Player): any
	local playerValue = self._perPlayer[player]
	local value = if playerValue == nil then self._value elseif playerValue == None then nil else playerValue
	return value
end
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 200		--	[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	= 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)
--[[
This rotated region3 module is a bit different than the one I previously wrote. This uses GJK to do the collision calculations and 
as such does not calculate the minimum translation vector. In addition it does not calculate the intersection points anymore either. 
I don't think that had much place in a rotated region3 module.

As far as new features the module now supports a vast array of shapes and point clouds meaning more accurate collision!

API:

Constructors:
	region.new(cframe, size)
		> Creates a region from a cframe which acts as the center of the region and size which extends to 
		> the corners like a block part.
	region.block(cframe, size)
		> This is the exact same as the region.new constructor, but has a different name.
	region.wedge(cframe, size)
		> Creates a region from a cframe which acts as the center of the region and size which extends to 
		> the corners like a wedge part.
	region.cornerWedge(cframe, size)
		> Creates a region from a cframe which acts as the center of the region and size which extends to 
		> the corners like a cornerWedge part.
	region.cylinder(cframe, size)
		> Creates a region from a cframe which acts as the center of the region and size which extends to 
		> the corners like a cylinder part.
	region.ellipsoid(cframe, size)
		> Creates a region from a cframe which acts as the center of the region and size which extends to 
		> the corners like a ball part.
	region.pointCloud(cloud)
		> Creates a region from a table of points. The region is treated as a convex 3D shape when doing the collision detections.
	region.fromPart(part)
		> Creates a region from a part in the game. It can be used on any base part, but the region 
		> will treat unknown shapes (meshes, unions, etc) as block shapes.

Methods:
	region:cast(ignore instance or table (descendants as well), int maxParts)
		> returns a table full of parts that are inside the region
	region:castPart(basePart)
		> returns a boolean as to whether or not a given part is within a region or not
	region:castPoint(vector3)
		> returns a boolean as to whether or not a given point is within a region or not
	
Properties:
	region.CFrame
		> cframe that represents the center of the region
	region.Size
		> vector3 that represents the size of the region
--]]



local gjk = require(script:WaitForChild("gjk"));
local support = require(script:WaitForChild("supports"));
local vertices = require(script:WaitForChild("vertices"));
local draw = require(script:WaitForChild("draw"));

local region3 = {};
local region3_mt = {__index = region3};
----- Service Table -----



local ProfileService = {

	ServiceLocked = false, -- Set to true once the server is shutting down

	IssueSignal = Madwork.NewScriptSignal(), -- (error_message, profile_store_name, profile_key) -- Fired when a DataStore API call throws an error
	CorruptionSignal = Madwork.NewScriptSignal(), -- (profile_store_name, profile_key) -- Fired when DataStore key returns a value that has
	-- all or some of it's profile components set to invalid data types. E.g., accidentally setting Profile.Data to a noon table value

	CriticalState = false, -- Set to true while DataStore service is throwing too many errors
	CriticalStateSignal = Madwork.NewScriptSignal(), -- (is_critical_state) -- Fired when CriticalState is set to true
	-- (You may alert players with this, or set up analytics)

	ServiceIssueCount = 0,

	_active_profile_stores = {}, -- {profile_store, ...}

	_auto_save_list = {}, -- {profile, ...} -- loaded profile table which will be circularly auto-saved

	_issue_queue = {}, -- [table] {issue_time, ...}
	_critical_state_start = 0, -- [number] 0 = no critical state / os.clock() = critical state start

	-- Debug:
	_mock_data_store = {},
	_user_mock_data_store = {},

	_use_mock_data_store = false,

}
--Allows users to do /w displayName along with /w userName, only works if PlayerDisplayNamesEnabled is 'true'


module.WhisperByDisplayName = true

local ChangedEvent = Instance.new("BindableEvent")

local proxyTable = setmetatable({},
{
	__index = function(tbl, index)
		return module[index]
	end,
	__newindex = function(tbl, index, value)
		module[index] = value
		ChangedEvent:Fire(index, value)
	end,
})

rawset(proxyTable, "SettingsChanged", ChangedEvent.Event)

return proxyTable
-- goro7



local plr = game.Players.LocalPlayer

function update()
	
	-- Calculate scale
	local scale = (plr.PlayerGui.MainGui.AbsoluteSize.Y) / script.Parent.Parent.Size.Y.Offset
	if scale > 1.5 then
		scale = 1.5
	end
	if scale > 0 then
		script.Parent.Scale = scale
	end
	
end

plr.PlayerGui:WaitForChild("MainGui"):GetPropertyChangedSignal("AbsoluteSize"):connect(update)
update()
--BasedWeld2.0


local JS = game:GetService("JointsService")
function MakeWeld(x,y,type,s) 
	if type==nil then type="Weld" end
	local W=Instance.new(type,JS) 
	W.Part0=x W.Part1=y 
	W.C0=x.CFrame:inverse()*x.CFrame 
	W.C1=y.CFrame:inverse()*x.CFrame 
	if type=="Motor" and s~=nil then 
		W.MaxVelocity=s 
	end 
	return W	
end

function ModelWeld(a,b) 
	if a:IsA("BasePart") then 
		MakeWeld(b,a,"Weld") 
	elseif a:IsA("Model") then 
		for i,v in pairs(a:GetChildren()) do 
			ModelWeld(v,b) 
		end 
	end 
end

function UnAnchor(a) 
	if a:IsA("BasePart") then a.Anchored=false  end for i,v in pairs(a:GetChildren()) do UnAnchor(v) end 
end
--[[
	berezaa's method of saving data (from the dev forum):

	What I do and this might seem a little over-the-top but it's fine as long as you're not using datastores excessively elsewhere is have a datastore and an ordereddatastore for each player. When you perform a save, add a key (can be anything) with the value of os.time() to the ordereddatastore and save a key with the os.time() and the value of the player's data to the regular datastore. Then, when loading data, get the highest number from the ordered data store (most recent save) and load the data with that as a key.

	Ever since I implemented this, pretty much no one has ever lost data. There's no caches to worry about either because you're never overriding any keys. Plus, it has the added benefit of allowing you to restore lost data, since every save doubles as a backup which can be easily found with the ordereddatastore

	edit: while there's no official comment on this, many developers including myself have noticed really bad cache times and issues with using the same datastore keys to save data across multiple places in the same game. With this method, data is almost always instantly accessible immediately after a player teleports, making it useful for multi-place games.
--]]
--------END LIGHTED RECTANGLES--------
--------SIDE DOOR--------



game.Workspace.rightsidedoor.l1.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.rightsidedoor.l2.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.rightsidedoor.l3.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.rightsidedoor.l4.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.rightsidedoor.l5.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--script.Parent.MouseClick:Connect(function()
--	script.Parent.MaxActivationDistance = 0
--	TweenA:Play()
--	wait(7)
--	TweenB:Play()
--	wait(3)
--	script.Parent.MaxActivationDistance = 20
--end)



function onClick(click)
	if click.TeamColor == BrickColor.new("White")then
			TweenA:Play()
		wait(7)
		TweenB:Play()
	end
end

script.Parent.MouseClick:Connect(onClick)
--------LEFT DOOR --------


game.Workspace.doorleft.l11.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l51.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--[=[
	`Construct` is called before the component is started, and should be used
	to construct the component instance.

	```lua
	local MyComponent = Component.new({Tag = "MyComponent"})

	function MyComponent:Construct()
		self.SomeData = 32
		self.OtherStuff = "HelloWorld"
	end
	```
]=]


function Component:Construct()
end
-- Listeners


SpawnSegway.OnServerEvent:connect(function(Player,Character,MaxSpeed,TurnSpeed,Tool,SpawnedSegway,Color)
	Functions.SpawnSegway(Player,Character,MaxSpeed,TurnSpeed,Tool,SpawnedSegway,Color)
end)

ConfigTool.OnServerEvent:connect(function(Player,Transparency,Tool,ShouldColor,Color)
	Functions.ConfigTool(Transparency,Tool,ShouldColor,Color)
end)

DestroySegway.OnServerEvent:connect(function(Player,Character,SpawnedSegway)
	Functions.DestroySegway(Character,SpawnedSegway)
end)

PlaySound.OnServerEvent:connect(function(Player,Sound,Pitch,Volume)
	Functions.PlaySound(Sound,Pitch,Volume)
end)

StopSound.OnServerEvent:connect(function(Player,Sound,Volume)
	Functions.StopSound(Sound,Volume)
end)

AnchorSegway.OnServerEvent:connect(function(Player,PrimaryPart,Anchored)
	Functions.AnchorPart(PrimaryPart,Anchored)
end)

UndoTags.OnServerEvent:connect(function(Player,SegwayObject,WeldObject,Thruster,TiltMotor)
	Functions.UndoTags(SegwayObject,WeldObject,Thruster,TiltMotor)
end)

UndoHasWelded.OnServerEvent:connect(function(Player,SeaterObject)
	Functions.UndoHasWelded(SeaterObject)
end)

function DeleteWelds.OnServerInvoke(Player,Part)
	Functions.DeleteWelds(Part)
	return true
end

ConfigHumanoid.OnServerEvent:connect(function(Player,Humanoid,PlatformStand,Jump,AutoRotate)
	Functions.ConfigHumanoid(Player.Character,Humanoid,PlatformStand,Jump,AutoRotate)
end)

ConfigLights.OnServerEvent:connect(function(Player,Transparency,Color,Bool,Material,Lights,Notifiers)
	Functions.ConfigLights(Transparency,Color,Bool,Material,Lights,Notifiers)
end)
--[=[
	Utility functions to observe the state of Roblox. This is a very powerful way to query
	Roblox's state.

	:::tip
	Use RxInstanceUtils to program streaming enabled games, and make it easy to debug. This API surface
	lets you use Roblox as a source-of-truth which is very valuable.
	:::

	@class RxInstanceUtils
]=]



local require = require(script.Parent.loader).load(script)

local Brio = require("Brio")
local Maid = require("Maid")
local Observable = require("Observable")
local Rx = require("Rx")
local Symbol = require("Symbol")

local UNSET_VALUE = Symbol.named("unsetValue")

local RxInstanceUtils = {}
-- Listen to level changes


upgrades.Changed:Connect(function()
	Level.Text = upgrades.Value
end)

points.Changed:Connect(updateUpgrades)
GameplayUi:GetPropertyChangedSignal("Enabled"):Connect(toggleEnabled)
LobbyButton.Activated:Connect(toggleLobby)
humanoid.Died:Connect(function() ChangeController:FireServer(true) toggleLobby() end)
----------------------------------
-----------CONNECTIONS------------
----------------------------------



PianoKeysConnections = {};
ExitButtonConnection = nil;
SheetsButtonConnection = nil;
CapsButtonConnection = nil;
TransDnConnection = nil;
TransUpConnection = nil;
VolumeUpConnection = nil;
VolumeDownConnection = nil;

function MakeGuiConnections()
	for i, v in pairs(PianoGui.Keys:GetChildren()) do
		PianoKeysConnections[i] = v.InputBegan:connect(function(Object) PianoKeyPressed(Object, tonumber(v.Name)) end)
	end
	
	ExitButtonConnection = PianoGui.ExitButton.InputBegan:connect(ExitButtonPressed)
	SheetsButtonConnection = PianoGui.SheetsButton.InputBegan:connect(SheetsButtonPressed)
	CapsButtonConnection = PianoGui.CapsButton.InputBegan:connect(CapsButtonPressed)
	
	TransDnConnection = PianoGui.TransDnButton.MouseButton1Click:connect(function()
		Transpose(-1)
	end)
	
	TransUpConnection = PianoGui.TransUpButton.MouseButton1Click:connect(function()
		Transpose(1)
	end)
	
	VolumeUpConnection = PianoGui.VolumeUpButton.MouseButton1Click:connect(function()
		VolumeChange(.1)
	end)
	
	VolumeDownConnection = PianoGui.VolumeDownButton.MouseButton1Click:connect(function()
		VolumeChange(-.1)
	end)
end
function BreakGuiConnections()
	for i, v in pairs(PianoKeysConnections) do
		v:disconnect()
	end
	
	ExitButtonConnection:disconnect()
	SheetsButtonConnection:disconnect()
	CapsButtonConnection:disconnect()
end
----- NO EDITING BELOW -----


local weldedParts = {}
table.insert(weldedParts,mainPart)

function Weld(x, y)
	weld = Instance.new("Weld") 
	weld.Part0 = x
	weld.Part1 = y
	local CJ = CFrame.new(x.Position) 
	weld.C0 = x.CFrame:inverse() * CJ  
	weld.C1 = y.CFrame:inverse() * CJ  
	weld.Parent = x	
	table.insert(weldedParts,y)
end

function WeldRec(instance)
	local childs = instance:GetChildren()
	for _,v in pairs(childs) do
		if v:IsA("BasePart") then
			Weld(mainPart, v)
		end
		WeldRec(v)
	end	
end

WeldRec(P)
-- Provide an interface into the module


return {

	-- Provide access to internal options
	Options = Options;

	-- Provide client actions API
	PerformAction = function (Client, ActionName, ...)

		-- Make sure the action exists
		local Action = Actions[ActionName];
		if not Action then
			return;
		end;

		-- Ensure client is current player in tool mode
		if ToolMode == 'Tool' then
			--assert(Player and (Client == Player), 'Permission denied for client');
		end;

		-- Execute valid actions
		local rs = game:GetService("RunService")
		return Action(...);

	end;

};
--[[ Chassis Variables ]]

--
local VehicleParameters = { -- These are default values in the case the package structure is broken
	MaxSpeed = 75/mphConversion,
	ReverseSpeed = 45/mphConversion,
	DrivingTorque = 30000,
	BrakingTorque = 70000,
	StrutSpringStiffnessFront = 28000,
	StrutSpringDampingFront = 1430,
	StrutSpringStiffnessRear = 27000,
	StrutSpringDampingRear = 1400,
	TorsionSpringStiffness = 20000,
	TorsionSpringDamping = 150,
	MaxSteer = 0.55,
	WheelFriction = 2
}

local Chassis = nil
local LimitSteerAtHighVel = true
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 290		--	[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)
--[=[
	Chains onto an existing Promise and returns a new Promise.

	:::warning
	Within the failure handler, you should never assume that the rejection value is a string. Some rejections within the Promise library are represented by [[Error]] objects. If you want to treat it as a string for debugging, you should call `tostring` on it first.
	:::

	Return a Promise from the success or failure handler and it will be chained onto.

	@param successHandler (...: any) -> ...any
	@param failureHandler? (...: any) -> ...any
	@return Promise<...any>
]=]


function Promise.prototype:andThen(successHandler, failureHandler)
	assert(successHandler == nil or isCallable(successHandler), string.format(ERROR_NON_FUNCTION, "Promise:andThen"))
	assert(failureHandler == nil or isCallable(failureHandler), string.format(ERROR_NON_FUNCTION, "Promise:andThen"))

	return self:_andThen(debug.traceback(nil, 2), successHandler, failureHandler)
end
--// Recoil Settings	


	gunrecoil = -0.3; -- How much the gun recoils backwards when not aiming
	camrecoil = 0.05; -- How much the camera flicks when not aiming
	AimGunRecoil = -0.1; -- How much the gun recoils backwards when aiming
	AimCamRecoil = 0.02; -- How much the camera flicks when aiming
	
	Kickback = 3; -- Upward gun rotation when not aiming
	AimKickback = 0.1; -- Upward gun rotation when aiming
-- Remade by Truenus(1)


wait(0.05)
local car = script.Parent.Parent.Car.Value
local GBrake = script.Parent.Parent.Values.Brake
local lighton=BrickColor.new("Institutional white")
local lightoff=BrickColor.new("Dark stone grey")
function LightOn()
	for i,v in pairs(car.Body.Lights:GetChildren()) do
		if v.Name=="Light" then
			v.BrickColor=lighton
			v.Material=Enum.Material.Neon
			v.Light.Enabled = true
			for i,v in pairs(car.Body.Lights:GetChildren()) do
		if v.Name=="R" then
			v.Material=Enum.Material.Neon
			v.Light.Enabled = true
			v.Transparency =.02
		end
	end
		end
	end
end

function LightOff()
	for i,v in pairs(car.Body.Lights:GetChildren()) do
		if v.Name=="Light" then
			v.BrickColor=lightoff
			v.Material=Enum.Material.SmoothPlastic
			v.Light.Enabled = false
			
			for i,v in pairs(car.Body.Lights:GetChildren()) do
			if v.Name=="R" then
				v.BrickColor=BrickColor.new("Maroon")
			v.Material=Enum.Material.SmoothPlastic
			v.Light.Enabled = false
			v.Transparency =0
			end
			end
			end
			end
	end
function Auto()
	if (game.Lighting:GetMinutesAfterMidnight()<390 or game.Lighting:GetMinutesAfterMidnight()>1050) then
		LightOn()
	else
		LightOff()
		end
end
script.Parent.MouseButton1Click:connect(function()
	if script.Parent.Text=="Lights: Auto" then
		LightOn()
		script.Parent.Text = "Lights: On"
	elseif script.Parent.Text == "Lights: On" then
		LightOff()
		script.Parent.Text = "Lights: Off"
	elseif script.Parent.Text == "Lights: Off" then
		Auto()
		script.Parent.Text = "Lights: Auto"
	end
end)
script.Parent.Parent.Values.Brake.Changed:connect(function()
	for i,v in pairs(car.Body.Lights:GetChildren()) do
		if v.Name=="R" then
			if v.Light.Enabled==true then
				if GBrake.Value>0 then
					v.Transparency=0
					v.Light.Brightness=12
					v.Light.Range=15
					v.BrickColor=BrickColor.new("Really red")
				else
					v.BrickColor=BrickColor.new("Maroon")
					v.Material=Enum.Material.Sand
					v.Transparency=.02
					v.Light.Brightness=8
					v.Light.Range=10
				end
			else
				v.Transparency=0
				if GBrake.Value>0 then
					v.Material=Enum.Material.Neon
					v.BrickColor=BrickColor.new("Really red")
				else
					v.BrickColor=BrickColor.new("Maroon")
					v.Material=Enum.Material.Sand
				end
			end
		elseif v.Name=="RR" then
			if GBrake.Value>0 then
				v.Material=Enum.Material.Neon
				if v.Light.Enabled then
					v.Transparency=1
				else
					v.Transparency=0
				end
			else
				v.Transparency=1
				if v.Light.Enabled then
					v.Material=Enum.Material.Neon
				else
					v.Material=Enum.Material.Sand
				end
			end
		end
	end
end)

game.Lighting.Changed:connect(Auto)
Auto()
--[[Front]]

--
Tune.FSusDamping	= 10 		-- Dampening
Tune.FSusStiffness	= 250 		-- Stiffness

Tune.FSusLength		= 1.67	-- Suspension length (in studs)
Tune.FPreComp		= .82 		-- Vehicle height, relative to your suspension settings
Tune.FExtLimit		= 0 		-- Max Extension Travel (in studs)
Tune.FCompLimit		= 0 		-- Max Compression Travel (in studs)

Tune.FBaseOffset	= {			-- Suspension (steering point) base
	--[[Lateral]]		0		,	-- positive = outward
	--[[Vertical]]		0		,	-- positive = upward
	--[[Forward]]		0		}	-- positive = forward
Tune.FAxleOffset	= {			-- Suspension (axle point) base
	--[[Lateral]]		0		,	-- positive = outward
	--[[Vertical]]		0		,	-- positive = upward
	--[[Forward]]		0		}	-- positive = forward

Tune.FBricksVisible	= false 	-- Makes the front suspension bricks visible (Debug)
Tune.FConstsVisible	= false 	-- Makes the front suspension constraints visible (Debug)
-- Get sound id


get_material = function()
    
    local soundTable = footstepsModule:GetTableFromMaterial(humanoid.FloorMaterial)
    local randomSound = footstepsModule:GetRandomSound(soundTable)
    
    if check_repetition(randomSound) == false then
        return randomSound
    else
        randomSound = get_material()
        
        return randomSound
    end
end
--[[
	ROBLOX TODO: add default generic param when possible
	original code:
	export type Expect<State extends MatcherState = MatcherState> = {
]]


export type Expect<State> = {
	-- ROBLOX deviation: no way to express __call metamethod typing
	-- <T = unknown>(actual: T) -> Matchers<void, T>;

	-- TODO: this is added by test runners, not `expect` itself
	addSnapshotSerializer: (any) -> (),
	assertions: (number) -> (),
	-- TODO: remove this `T extends` - should get from some interface merging
	extend: <T>(MatchersObject<T>) -> (),
	extractExpectedAssertionsErrors: () -> ExpectedAssertionsErrors,
	getState: () -> State,
	hasAssertions: () -> (),
	setState: (Partial<MatcherState>) -> (),
} & AsymmetricMatchers & {
	never: AsymmetricMatchersOmitAnyAndAnything,
}