Roblox/luau_corpus huggingface dataset:
---

MakeWeld(car.Misc.Und.base,car.DriveSeat)

MakeWeld(car.Misc.Und.Cover.A,car.Misc.Und.Cover.part1)

MakeWeld(car.Misc.Und.La.A,car.Misc.Und.La.part1)

MakeWeld(car.Misc.Und.H1.To,car.Misc.Und.H1.part1)
MakeWeld(car.Misc.Und.H1.H2.To,car.Misc.Und.H1.H2.part1)
MakeWeld(car.Misc.Und.H1.H2.H3.To,car.Misc.Und.H1.H2.H3.part1)
MakeWeld(car.Misc.Und.H1.H2.H3.H4.Ua_1,car.Misc.Und.H1.H2.H3.H4.part1)
MakeWeld(car.Misc.Und.H1.H2.H3.H4.Ua_2,car.Misc.Und.H1.H2.H3.H4.part1)
MakeWeld(car.Misc.Und.H1.H2.H3.H4.Ua_3,car.Misc.Und.H1.H2.H3.H4.part1)

MakeWeld(car.Misc.Und.H1.part0,car.Misc.Und.H1.part1,"Motor",.003).Name="Motor"
MakeWeld(car.Misc.Und.H1.H2.part0,car.Misc.Und.H1.H2.part1,"Motor",.006).Name="Motor"
MakeWeld(car.Misc.Und.H1.H2.H3.part0,car.Misc.Und.H1.H2.H3.part1,"Motor",.003).Name="Motor"
MakeWeld(car.Misc.Und.H1.H2.H3.H4.part0,car.Misc.Und.H1.H2.H3.H4.part1,"Motor",.006).Name="Motor"

MakeWeld(car.Misc.Und.Cover.part0,car.Misc.Und.Cover.part1,"Motor",.015).Name="Motor"
MakeWeld(car.Misc.Und.La.part0,car.Misc.Und.La.part1,"Motor",.003).Name="Motor"


MakeWeld(car.Misc.Und.H1.part0,car.Misc.Und.base)

MakeWeld(car.Misc.Und.Cover.part0,car.Misc.Und.base)

MakeWeld(car.Misc.Und.La.part0,car.Misc.Und.base)

MakeWeld(car.Misc.Und.H1.H2.part0,car.Misc.Und.H1.To)

MakeWeld(car.Misc.Und.H1.H2.H3.part0,car.Misc.Und.H1.H2.To)

MakeWeld(car.Misc.Und.H1.H2.H3.H4.part0,car.Misc.Und.H1.H2.H3.To)

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)
	end
end)
-- Those lines down there are poison effects given by
-- the gaster blaster.
wait(0.1)
human.Health = human.Health - 1
        end
end
script.Parent.Touched:connect(onTouched)
-- Menus
local menuContainer = Instance.new("Frame")
menuContainer.Active = true
menuContainer.Selectable = false
menuContainer.Name = "MenuContainer"
menuContainer.BackgroundTransparency = 1
menuContainer.BorderSizePixel = 0
menuContainer.AnchorPoint = Vector2.new(1, 0)
menuContainer.Size = UDim2.new(0, 500, 0, 50)
menuContainer.ZIndex = -2
menuContainer.ClipsDescendants = true
menuContainer.Visible = true
menuContainer.Parent = iconContainer
menuContainer.Active = false

local menuFrame = Instance.new("ScrollingFrame")
menuFrame.Active = true
menuFrame.Selectable = true
menuFrame.Name = "MenuFrame"
menuFrame.BackgroundTransparency = 1
menuFrame.BorderSizePixel = 0
menuFrame.AnchorPoint = Vector2.new(0, 0)
menuFrame.Position = UDim2.new(0, 0, 0, 0)
menuFrame.Size = UDim2.new(1, 0, 1, 0)
menuFrame.ZIndex = -1 + 10
menuFrame.ClipsDescendants = false
menuFrame.Visible = true
menuFrame.TopImage = ""--menuFrame.MidImage
menuFrame.BottomImage = ""--menuFrame.MidImage
menuFrame.HorizontalScrollBarInset = Enum.ScrollBarInset.Always
menuFrame.CanvasSize = UDim2.new(0, 0, 0, 0)
menuFrame.Parent = menuContainer
menuFrame.Active = false

local menuList = Instance.new("UIListLayout")
menuList.Name = "MenuList"
menuList.FillDirection = Enum.FillDirection.Horizontal
menuList.HorizontalAlignment = Enum.HorizontalAlignment.Right
menuList.SortOrder = Enum.SortOrder.LayoutOrder
menuList.Parent = menuFrame

local menuInvisBlocker = Instance.new("Frame")
menuInvisBlocker.Name = "MenuInvisBlocker"
menuInvisBlocker.BackgroundTransparency = 1
menuInvisBlocker.Size = UDim2.new(0, -2, 1, 0)
menuInvisBlocker.Visible = true
menuInvisBlocker.LayoutOrder = 999999999
menuInvisBlocker.Parent = menuFrame
menuInvisBlocker.Active = false
-- Folder
local soundFold = rp.Storage.Sounds

local module = {}

function module.Play( Data)
	local sfx = Data.sfx
	local tim = Data.tim 
	local part = Data.part
	
	local sound = sfx:Clone()
	sound.Parent = part
	sound:Play()
	if tim then
		game.Debris:AddItem(sound, tim)
	end
	
	return sound
end
-- How many times per second the gun can fire
local FireRate = 10 / 60
--------|     Library     |--------
local _L = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"))
while (not _L.Loaded) do  game:GetService("RunService").Heartbeat:Wait()  end
--// # key, ManOn
mouse.KeyDown:connect(function(key)
	if key=="f" then 
		veh.Lightbar.middle.Man:Play()
		veh.Lightbar.middle.Wail.Volume = 0
		veh.Lightbar.middle.Yelp.Volume = 0
		veh.Lightbar.middle.Priority.Volume = 0
		script.Parent.Parent.Sirens.Man.BackgroundColor3 = Color3.fromRGB(215, 135, 110)
	end
end)
--[[Engine]]--
	
	-- Everything below can be illustrated and tuned with the graph below.
	-- https://www.desmos.com/calculator/x1h2vdccu1
	-- This includes everything, from the engines, to boost, to electric.
	
	-- Naturally Aspirated Engine
	Tune.Engine 		= true		
		
		Tune.IdleRPM		= 950
		Tune.Redline		= 10000
		Tune.PeakRPM		= 9000
		-- Horsepower
		Tune.Horsepower		= 65
		Tune.MH_PeakRPM		= Tune.PeakRPM
		Tune.MH_PeakSharp	= 2
		Tune.MH_CurveMult	= 0.02
		-- Torque
		Tune.M_EqPoint		= 8500
		Tune.MT_PeakRPM		= 11000
		Tune.MT_PeakSharp	= 5
		Tune.MT_CurveMult	= 0.5
	
	-- Electric Engine
	Tune.Electric		= false
		
		Tune.E_Redline	= 16000
		Tune.E_Trans1	= 4000
		Tune.E_Trans2	= 9000
		-- Horsepower
		Tune.E_Horsepower	= 223
		Tune.EH_FrontMult	= 0.15
		Tune.EH_EndMult		= 2.9
		Tune.EH_EndPercent	= 7
		-- Torque
		Tune.E_Torque		= 223
		Tune.ET_EndMult		= 1.505
		Tune.ET_EndPercent	= 27.5
		
	-- Turbocharger
	Tune.Turbochargers	= 1				-- Number of turbochargers in the engine
										-- Set to 0 for no turbochargers
		Tune.T_Boost		= 12
		Tune.T_Efficiency	= 6
		--Horsepower
		Tune.TH_PeakSharp	= 4
		Tune.TH_CurveMult	= 0.12
		--Torque
		Tune.TT_PeakSharp	= 4
		Tune.TT_CurveMult	= 0.12
		
		Tune.T_Size			= 20		-- Turbo Size; Bigger size = more turbo lag
		
	-- Supercharger
	Tune.Superchargers	= 0				-- Number of superchargers in the engine
										-- Set to 0 for no superchargers
		Tune.S_Boost		= 5
		Tune.S_Efficiency	= 6
		--Horsepower
		Tune.SH_PeakSharp	= 2
		Tune.SH_CurveMult	= 0.02
		--Torque
		Tune.ST_PeakSharp	= 2
		Tune.ST_CurveMult	= 0.02
		
		Tune.S_Sensitivity	= 0.05		-- Supercharger responsiveness/sensitivity, applied per tick (recommended values between 0.05 to 0.1)
	
	--Misc
	Tune.RevAccel		= 250		-- 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.Flywheel		= 500		-- Flywheel weight (higher = faster response, lower = more stable RPM)

    Tune.InclineComp	= 2.8
	--Aero
	Tune.Drag			= 0.5		-- 0 to 1, edit to change drag effect (0 = no effect, 1 = full effect)
-- Defina a propriedade "AngularVelocity" em todos os motores CylindricalConstraint
local function setMotorVelocity(vel)
	motorFL.AngularVelocity = vel
	motorBL.AngularVelocity = vel
	-- Os motores do lado direito estão voltados para a direção oposta, portanto, a velocidade negativa deve ser usada
	motorFR.AngularVelocity = -vel
	motorBR.AngularVelocity = -vel
end
--Casts a ray to find the height for the character to hover at even if the path is going up or down
function findHeight(distanceInFront)
	local torso = character.HumanoidRootPart
	local ray = Ray.new(
    Vector3.new(torso.Position.X, torso.Position.Y + 50, torso.Position.Z - distanceInFront), 	-- origin
    (Vector3.new(0, -1, 0)).Unit * 300)	 														-- direction
	local ignore = character
	local hit, position = game.Workspace:FindPartOnRay(ray, ignore)
	return position.Y + 40
end

function highest(tableOfValues)
	local highestSoFar = tableOfValues[1]
	for i = 2, #tableOfValues do
		if tableOfValues[i] > highestSoFar then
			highestSoFar = tableOfValues[i]
		end
	end
	return highestSoFar
end

function fastStart()
	if started == false then	
		started = true
		local fastStartPosition = Instance.new("BodyPosition")
		fastStartPosition.Name = "FastStart"
		fastStartPosition.maxForce = Vector3.new(0, 15000, 0)
		fastStartPosition.Parent = character.HumanoidRootPart
		local fastStartVelocity = Instance.new("BodyVelocity")
		fastStartVelocity.maxForce = Vector3.new(0, 0, 15000)
		fastStartVelocity.velocity = Vector3.new(0, 0, -150)
		fastStartVelocity.Parent = character.HumanoidRootPart
		fastStartPosition.position = Vector3.new(0, highest({findHeight(0), findHeight(10), findHeight(20), findHeight(30)}), 0)
		while character.HumanoidRootPart.Position.Z > spawnLocation.Z - 1000 do
			wait(1)
			if character:FindFirstChild("HumanoidRootPart") == nil then
				break
			end
			fastStartPosition.position = Vector3.new(0, highest({findHeight(0), findHeight(10), findHeight(20), findHeight(30)}), 0)
		end
		fastStartVelocity.velocity = Vector3.new(0, 0, 0)
		wait(2)
		if character:FindFirstChild("HumanoidRootPart") then
			fastStartPosition:Destroy()
			fastStartVelocity:Destroy()
			local shield = Instance.new("ForceField")
			shield.Name = "Shield"		
			shield.Parent = character
			game:GetService("Debris"):AddItem(shield, 3)
		end
		fastStart:Destroy()
		script:Destroy()
	end
end

fastStart() --Script starts disabled, only enabled when a player starts running
--[[**
	ensures Lua primitive none type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.none = t.typeof("nil")
t["nil"] = t.none
-- Touch
-- Stephen Leitnick
-- March 14, 2021

local Trove = require(script.Parent.Parent.Trove)
local Signal = require(script.Parent.Parent.Signal)

local UserInputService = game:GetService("UserInputService")
-- Flight experiments
exports.enableBlocksAPI = _G.__EXPERIMENTAL__
exports.enableLazyElements = _G.__EXPERIMENTAL__
--- Same as indexing, but uses an incremented number as a key.
-- @param task An item to clean
-- @treturn number taskId
function Maid:GiveTask(task)
	assert(task, "Task cannot be false or nil")

	local taskId = #self._tasks+1
	self[taskId] = task

	if type(task) == "table" and (not task.Destroy) then
		warn("[Maid.GiveTask] - Gave table task without .Destroy\n\n" .. debug.traceback())
	end

	return taskId
end

function Maid:GivePromise(promise)
	if not promise:IsPending() then
		return promise
	end

	local newPromise = promise.resolved(promise)
	local id = self:GiveTask(newPromise)

	-- Ensure GC
	newPromise:Finally(function()
		self[id] = nil
	end)

	return newPromise
end
--Feel free to change other properties
trail.Parent = script.Parent.HumanoidRootPart
att0.Parent = script.Parent.HumanoidRootPart
att1.Parent = script.Parent.HumanoidRootPart
trail.Attachment0 = att0
trail.Attachment1 = att1
trail.Enabled = true
trail.Color = ColorSequence.new(Color3.new(1, 0, 1), Color3.new(1, 1, 0))
att0.Position = Vector3.new(.5, 0, 0)
att1.Position = Vector3.new(-.5, 0, 0)
--print("Cutscene should start now")
for i=1,#cutsceneinfo:GetChildren(),1 do
	camera.CFrame = cutsceneinfo:FindFirstChild("Position"..i).Value
	--print("Reached Position "..i)
	if i ~= #cutsceneinfo:GetChildren() then
		--Theres more coming, play a tween to the next position
		local tweentime = cutsceneinfo:FindFirstChild("Position"..i+1).Time.Value
		local easingstyle = EasingStyles[cutsceneinfo:FindFirstChild("Position"..i+1).EasingStyle.Value]
		local easingdirection = EasingDirections[cutsceneinfo:FindFirstChild("Position"..i+1).EasingDirection.Value]
		local cf = cutsceneinfo:FindFirstChild("Position"..i+1).Value
		game.TweenService:Create(camera,TweenInfo.new(tweentime,easingstyle,easingdirection),{CFrame=cf}):Play()
		wait(tweentime)
	else
		--The cutscene is over. Don't do anything after this point
	end
end

game.Workspace.CurrentCamera.CameraType = currentcameramode
game.Debris:AddItem(script)
--[[
	// Name:   AdvancedGroupService
	// Author: Sebastian Erik Bauer (SimplyData)
	// Date:   20/02/2019
--]]
local GroupService = {}
local RbxGroupService = game:GetService("GroupService")

local function PagesToArray(Pages)
	local Array = {}
	while true do
		for _, Value in ipairs(Pages:GetCurrentPage()) do table.insert(Array, Value) end
		if Pages.IsFinished then break end
		pcall(Pages.AdvanceToNextPageAsync, Pages)
	end

	return Array
end

function GroupService:GetRankInGroupAsync(Player, GroupID)
	local Groups = GroupService:GetGroupsAsync(Player)
	for Index = 1, #Groups do
		local Group = Groups[Index]
		if Group.Id == GroupID then
			return Group.Rank
		end
	end
	return 0
end

function GroupService:GetRoleInGroupAsync(Player, GroupID)
	local Groups = GroupService:GetGroupsAsync(Player)
	for Index = 1, #Groups do
		local Group = Groups[Index]
		if Group.Id == GroupID then
			return Group.Role
		end
	end
	return "Guest"
end

function GroupService:GetPrimaryGroupAsync(Player)
	local Groups = GroupService:GetGroupsAsync(Player)
	for Index = 1, #Groups do
		local Group = Groups[Index]
		if Group.IsPrimary then
			return Group
		end
	end
	return nil
end

function GroupService:IsInGroupAsync(Player, GroupID)
	local Groups = GroupService:GetGroupsAsync(Player)
	for Index = 1, #Groups do
		if Groups[Index].Id == GroupID then
			return true
		end
	end
	return false
end

function GroupService:IsPrimaryGroupAsync(Player)
	local Groups = GroupService:GetGroupsAsync(Player)
	for Index = 1, #Groups do
		if Groups[Index].IsPrimary then
			return true
		end
	end
	return false
end

function GroupService:IsGroupAlly(GroupID, TargetGroupID)
	local Groups = GroupService:GetGroupAlliesAsync(GroupID)
	for Index = 1, #Groups do
		if Groups[Index].Id == TargetGroupID then
			return true
		end
	end
	return false
end

function GroupService:IsGroupEnemy(GroupID, TargetGroupID)
	local Groups = GroupService:GetGroupEnemiesAsync(GroupID)
	for Index = 1, #Groups do
		if Groups[Index].Id == TargetGroupID then
			return true
		end
	end
	return false
end

function GroupService:GetGroupAlliesAsync(GroupID)
	local Success, GroupAlliesPages = pcall(RbxGroupService.GetAlliesAsync, RbxGroupService, GroupID)
	local GroupAllies = Success and GroupAlliesPages and PagesToArray(GroupAlliesPages)
	return GroupAllies
end

function GroupService:GetEnemiesAsync(GroupID)
	local Success, GroupEnemiesPages = pcall(RbxGroupService.GetEnemiesAsync, RbxGroupService, GroupID)
	local GroupEnemies = Success and GroupEnemiesPages and PagesToArray(GroupEnemiesPages)
	return GroupEnemies
end

function GroupService:GetGroupsAsync(Player)
	local Success, Groups = pcall(RbxGroupService.GetGroupsAsync, RbxGroupService, Player.UserId)
	return Success and Groups or {}
end

function GroupService:GetGroupInfoAsync(GroupID)
	local Success, GroupInfo = pcall(RbxGroupService.GetGroupInfoAsync, RbxGroupService, GroupID)
	return Success and GroupInfo or {}
end

return GroupService
--[[
	Registers developer products to the ReceiptProcessor and starts listening for purchases
	being made.
--]]

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

local ReceiptProcessor = require(ServerStorage.Source.ReceiptProcessor)
local ItemCategory = require(ReplicatedStorage.Source.SharedConstants.ItemCategory)
local PlayerDataServer = require(ServerStorage.Source.PlayerData.Server)
local Attribute = require(ReplicatedStorage.Source.SharedConstants.Attribute)
local PlayerDataKey = require(ReplicatedStorage.Source.SharedConstants.PlayerDataKey)
local getSortedIdsInCategory = require(ReplicatedStorage.Source.Utility.Farm.getSortedIdsInCategory)
local getItemByIdInCategory = require(ReplicatedStorage.Source.Utility.Farm.getItemByIdInCategory)
local getAttribute = require(ReplicatedStorage.Source.Utility.getAttribute)

local function registerDevProducts()
	local coinBundleIds = getSortedIdsInCategory(ItemCategory.CoinBundles)

	for _, coinBundleId in ipairs(coinBundleIds) do
		local bundleModel = getItemByIdInCategory(coinBundleId, ItemCategory.CoinBundles)

		local developerProductId: number = getAttribute(bundleModel, Attribute.DeveloperProductId)
		local bundleSize: number = getAttribute(bundleModel, Attribute.CoinBundleSize)

		ReceiptProcessor.registerProductCallback(developerProductId, function(player: Player)
			PlayerDataServer.updateValue(player, PlayerDataKey.Coins, function(oldValueMaybe: number?)
				local oldValue: number = oldValueMaybe or 0

				return oldValue + bundleSize
			end)
		end)
	end

	ReceiptProcessor.start()
end

return registerDevProducts
-- Replace FADE_TIME with the time (in seconds) it should take to fade out the sound.
local FADE_TIME = EasyLoadConfig.FadeTime

local sound = script.Parent.Parent.Parent.Parent.Parent.Sound.Sound
if not sound or sound.ClassName ~= "Sound" then
	error("Could not find sound \"" .. SOUND_NAME .. "\"")
end
--------END SIDE DOOR--------

end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
------------------------------------------------------------------------
-- writes an instruction of type ABx
-- * calls luaK:code(), called by luaK:codeAsBx()
------------------------------------------------------------------------
function luaK:codeABx(fs, o, a, bc)
  assert(luaP:getOpMode(o) == luaP.OpMode.iABx or
             luaP:getOpMode(o) == luaP.OpMode.iAsBx)
  assert(luaP:getCMode(o) == luaP.OpArgMask.OpArgN)
  return self:code(fs, luaP:CREATE_ABx(o, a, bc), fs.ls.lastline)
end
--// All global vars will be wiped/replaced except script

return function(data, env)
	if env then
		setfenv(1, env)
	end

	local playergui = service.PlayerGui
	local localplayer = service.Players.LocalPlayer
	local scr = client.UI.Prepare(script.Parent.Parent)
	local main = scr.Main
	local t1 = main.Title
	local t2 = main.Message
	local msg = data.Message
	local color = data.Color

	local found = client.UI.Get("Output")
	if found then
		for i,v in found do
			local p = v.Object
			if p and p.Parent then
				p.Main.Position = UDim2.new(0, 0, 0.35, p.Main.Position.Y.Offset+50)
			end
		end
	end

	t2.Text = msg

	task.spawn(function()
		local sound = Instance.new("Sound",service.LocalContainer())
		sound.SoundId = "rbxassetid://7152562261"
		sound.Volume = 0.1
		sound:Play()
		task.wait(0.8)
		sound:Destroy()
	end)

	main.Size = UDim2.new(1, 0, 0, 0)
	gTable.Ready()
	main:TweenSize(UDim2.new(1, 0, 0, 50), Enum.EasingDirection.Out, Enum.EasingStyle.Quad, 0.1)
	task.wait(5)
	gTable.Destroy()
end
------------------------------------------------------------------------
--
-- * used in luaK:removevalues(), luaK:patchlistaux()
------------------------------------------------------------------------
function luaK:patchtestreg(fs, node, reg)
  local i = self:getjumpcontrol(fs, node)
  if luaP:GET_OPCODE(i) ~= "OP_TESTSET" then
    return false  -- cannot patch other instructions
  end
  if reg ~= luaP.NO_REG and reg ~= luaP:GETARG_B(i) then
    luaP:SETARG_A(i, reg)
  else  -- no register to put value or register already has the value
    -- due to use of a table as i, i cannot be replaced by another table
    -- so the following is required; there is no change to ARG_C
    luaP:SET_OPCODE(i, "OP_TEST")
    local b = luaP:GETARG_B(i)
    luaP:SETARG_A(i, b)
    luaP:SETARG_B(i, 0)
    -- *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i)); /* C */
  end
  return true
end
--MainScript
repeat
	local Code1 = Object.Code
	local EnteredCode1 = Object.EnteredCode
	wait()
until Code1.Value == EnteredCode1.Value and Ready == true
local Button = script.Parent.Buttons
Button.Button1.Add.Enabled = false
Button.Button1.Subtract.Enabled = false

Button.Button2.Add.Enabled = false
Button.Button2.Subtract.Enabled = false

Button.Button3.Add.Enabled = false
Button.Button3.Subtract.Enabled = false

wait(2)
wait(1)
script.Parent.Teleport.Enabled = true
wait(60)
script.Parent.Teleport:Destroy()
script:Destroy()
-----------------
--| Constants |--
-----------------

local BLAST_RADIUS = 8 -- Blast radius of the explosion
local BLAST_DAMAGE = 200 -- Amount of damage done to players
local BLAST_FORCE = 5000 -- Amount of force applied to parts

local IGNORE_LIST = {rocket = 1, handle = 1, effect = 1, water = 1} -- Rocket will fly through things named these
------------------------------------------------------------------------
-- create a chunk writer that writes to a string
-- * returns the writer function and a table containing the string
-- * to get the final result, look in buff.data
------------------------------------------------------------------------
function luaU:make_setS()
  local buff = {}
        buff.data = ""
  local writer =
    function(s, buff)  -- chunk writer
      if not s then return 0 end
      buff.data = buff.data..s
      return 0
    end
  return writer, buff
end
--[[**
	ensures Roblox Axes type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Axes = t.typeof("Axes")
-- Starting data values
GameSettings.startUpgrades = 1
GameSettings.startPoints = 0

GameSettings.pointsName = "Points"
GameSettings.upgradeName = "Upgrades"
--/Barrel
module.IsSuppressor 	= false
module.IsFlashHider		= false
--clockwork

bin = script.Parent



function onButton1Down(mouse)

	local player = game.Players.LocalPlayer
	if player == nil then return end
	player.Character.Head:remove()
	mouse.Icon = "rbxasset://textures\\ArrowCursor.png"

end

function onSelected(mouse)
	mouse.Icon = "rbxasset://textures\\ArrowCursor.png"
	mouse.Button1Down:connect(function() onButton1Down(mouse) end)
end

bin.Selected:connect(onSelected)
--[ENGINE // Caching]
Tune.CurveCache = true		--Default = true (Caches the engine and boost curves)
Tune.CacheInc = 100 		--Default = 100 (How many points the curve will have.)
	--[[Examples: 1 = every RPM increment [will freeze your computer at low settings like this], 
				  100 = default and recommended, 
				  1000 or more = death															]]

return Tune
-- Torque
Tune.E_Torque		= 286
Tune.ET_EndMult		= 1.505
Tune.ET_EndPercent	= 27.5
--[[
	Rejects the promise after `seconds` seconds.
]]
function Promise.prototype:timeout(seconds, rejectionValue)
	local traceback = debug.traceback(nil, 2)

	return Promise.race({
		Promise.delay(seconds):andThen(function()
			return Promise.reject(rejectionValue == nil and Error.new({
				kind = Error.Kind.TimedOut,
				error = "Timed out",
				context = string.format(
					"Timeout of %d seconds exceeded.\n:timeout() called at:\n\n%s",
					seconds,
					traceback
				),
			}) or rejectionValue)
		end),
		self,
	})
end

function Promise.prototype:getStatus()
	return self._status
end
--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 true
end