Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- ProductId 1218011291 for 100 Cash


developerProductFunctions[Config.DeveloperProductIds["100 Cash"]] = function(receipt, player)
	-- Logic/code for player buying 100 Cash (may vary)
	local leaderstats = player:FindFirstChild("leaderstats")
	local cash = leaderstats and leaderstats:FindFirstChild("Cash")
	if cash then
		if Utilities:OwnsGamepass(player, gamepassID) then
			cash.Value += 200
		else
			cash.Value += 100
		end	
		-- Indicate a successful purchase
		return true
	end
end
--!strict


local function run(LightChanger, reverse)
	local lights = LightChanger:GetLights("Numbered")
	for groupNumber, lightGroup in lights do
		local angle = if groupNumber % 2 == 0 then 60 else 30
		if reverse then
			if angle == 60 then
				angle = 30
			else
				angle = 60
			end
		end
		LightChanger:Tilt(angle, lightGroup)
	end
end

return function(LightChangerA, LightChangerB, reverse: boolean)
	run(LightChangerA, reverse)
	run(LightChangerB, reverse)
end
-- these numbers are how long it takes to switch. the numbers are in 1.4 seconds(IE: 6 = 1 1/2 seconds)


switch1 = 1
switch2 = 1
switch3 = 1
switch4 = 1
switch5 = 1
switch6 = 1


script.Parent.Parent.Character.Humanoid.WalkSpeed = start
while true do
x = script.Parent.Parent.Character.Torso.Position
wait(.25)
if script.Parent.Parent.PlayerGui.Bars.Charging.Value == false then
x = (script.Parent.Parent.Character.Torso.Position - x).Magnitude
if x < 1 then
script.Parent.Parent.Character.Humanoid.WalkSpeed = start
up1 = 0
up2 = 0
up3 = 0
up4 = 0
print("To normal")
end
if x >= 3 then
ch = math.random(1, 5)
if ch == 1 then
script.Parent.Parent.Data.Agility.AXP.Value = script.Parent.Parent.Data.Agility.AXP.Value + 50
end
if script.Parent.Parent.Character.Humanoid.WalkSpeed == start then
up1 = up1 + 1
if up1 == switch1 then
script.Parent.Parent.Character.Humanoid.WalkSpeed = stage1
up1 = 0
print("Speed Up")
end
end


if script.Parent.Parent.Character.Humanoid.WalkSpeed == stage1 then
up2 = up2 + 1
if up2 == switch2 then
script.Parent.Parent.Character.Humanoid.WalkSpeed = stage2
up2 = 0
print("Speed Up")
end
end


if script.Parent.Parent.Character.Humanoid.WalkSpeed == stage2 then
up3 = up3 + 1
if up3 == switch3 then
script.Parent.Parent.Character.Humanoid.WalkSpeed = stage3
up3 = 0
print("Speed Up")
end
end


if script.Parent.Parent.Character.Humanoid.WalkSpeed == stage3 then
up4 = up4 + 1
if up4 == switch4 then
script.Parent.Parent.Character.Humanoid.WalkSpeed = stage4
up4 = 0
print("Speed Up")
end
end


if script.Parent.Parent.Character.Humanoid.WalkSpeed == stage4 then
up5 = up5 + 1
if up5 == switch5 then
script.Parent.Parent.Character.Humanoid.WalkSpeed = stage5
up5 = 0
print("Speed Up")
end
end

if script.Parent.Parent.Character.Humanoid.WalkSpeed == stage5 then
up6 = up6 + 1
if up6 == switch6 then
script.Parent.Parent.Character.Humanoid.WalkSpeed = stage6
cha = math.random(1, 3)
if cha == 1 then
script.Parent.Parent.Data.Agility.AXP.Value = script.Parent.Parent.Data.Agility.AXP.Value + 16
else
script.Parent.Parent.Data.Agility.AXP.Value = script.Parent.Parent.Data.Agility.AXP.Value + 5
end
up6 = 0
print("Speed Up")
end
end
end
end
end
---------------------------------------------------



This = script.Parent
Lift = This.Parent.Parent.Parent
CustomLabel = require(Lift.CustomLabel)
Characters = require(script.Characters)
CharactersDOT = require(script.CharactersDOT)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Lift:WaitForChild("Floor").Changed:connect(function(floor)
  --custom indicator code--
  ChangeFloor(tostring(floor))
end)

function ChangeFloor(SF)
	if CustomText[tonumber(SF)] then
		SF = CustomText[tonumber(SF)]
	end
	SetDisplay(1,(string.len(SF) == 2 and SF:sub(1,1) or "NIL"))		
	SetDisplay(2,(string.len(SF) == 2 and SF:sub(2,2) or SF))
end



function SetDisplay(ID,CHAR)
	if This.Display:FindFirstChild("DIG"..ID) and Characters[CHAR] ~= nil then
 		for i,l in pairs(Characters[CHAR]) do 
			for r=1,15 do	
				This.Display["DIG"..ID]["D"..r].BrickColor = BrickColor.new(l:sub(r,r) == "1" and "Pastel Blue" or "Black")
			end
		end
	end
end

function SetDisplayDOT(ID,CHAR)
	if This.Display:FindFirstChild("Matrix"..ID) and CharactersDOT[CHAR] ~= nil then
 		for i,l in pairs(CharactersDOT[CHAR]) do 
			for r=1,7 do	
				This.Display["Matrix"..ID]["Row"..i]["D"..r].BrickColor = BrickColor.new(l:sub(r,r) == "1" and "Persimmon" or "Black")
			end
		end
	end
end
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 95		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 800		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 8000		--		Use sliders to manipulate values
	Tune.Redline		= 9000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 6100
	Tune.PeakSharpness	= 3.8
	Tune.CurveMult		= 0.07
	
	--Incline Compensation
	Tune.InclineComp	= 1.5		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 450		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 150		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 0			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)
-- Check if input is of correct types


function Input:_isMovement (input)
	return --input.UserInputType == Enum.UserInputType.Touch or
	       input.UserInputType == Enum.UserInputType.MouseMovement;
end
function Input:_isDown (input)
	return input.UserInputType == Enum.UserInputType.MouseButton1 or
	       input.UserInputType == Enum.UserInputType.Touch;
end

Input.__index = Input;
return I;
-- Connect to the current and all future cameras


workspace.Changed:connect(OnWorkspaceChanged)
OnWorkspaceChanged('CurrentCamera')

Player.CharacterAdded:connect(OnCharacterAdded)
if Player.Character then
	OnCharacterAdded(Player.Character)
end

Invisicam:SetMode(STARTING_MODE)

Behaviors[MODE.CUSTOM] = function() end -- (Does nothing until SetCustomBehavior)
Behaviors[MODE.LIMBS] = LimbBehavior
Behaviors[MODE.MOVEMENT] = MoveBehavior
Behaviors[MODE.CORNERS] = CornerBehavior
Behaviors[MODE.CIRCLE1] = CircleBehavior
Behaviors[MODE.CIRCLE2] = CircleBehavior
Behaviors[MODE.LIMBMOVE] = LimbMoveBehavior

return Invisicam
--Made by Luckymaxer



Tool = script.Parent
Handle = Tool:WaitForChild("Handle")

Players = game:GetService("Players")
RunService = game:GetService("RunService")
UserInputService = game:GetService("UserInputService")

Animations = {}

ServerControl = Tool:WaitForChild("ServerControl")
ClientControl = Tool:WaitForChild("ClientControl")

Rate = (1 / 60)

ToolEquipped = false

function SetAnimation(mode, value)
	if mode == "PlayAnimation" and value and ToolEquipped and Humanoid then
		for i, v in pairs(Animations) do
			if v.Animation == value.Animation then
				v.AnimationTrack:Stop()
				table.remove(Animations, i)
			end
		end
		local AnimationTrack = Humanoid:LoadAnimation(value.Animation)
		table.insert(Animations, {Animation = value.Animation, AnimationTrack = AnimationTrack})
		AnimationTrack:Play(value.FadeTime, value.Weight, value.Speed)
	elseif mode == "StopAnimation" and value then
		for i, v in pairs(Animations) do
			if v.Animation == value.Animation then
				v.AnimationTrack:Stop(value.FadeTime)
				table.remove(Animations, i)
			end
		end
	end
end

function CheckIfAlive()
	return (((Character and Character.Parent and Humanoid and Humanoid.Parent and Humanoid.Health > 0 and Player and Player.Parent) and true) or false)
end

function Equipped(Mouse)
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChild("Humanoid")
	ToolEquipped = true
	if not CheckIfAlive() then
		return
	end
	PlayerMouse = Player:GetMouse()
end

function Unequipped()
	for i, v in pairs(Animations) do
		if v and v.AnimationTrack then
			v.AnimationTrack:Stop()
		end
	end
	Animations = {}
	ToolEquipped = false
end

function InvokeServer(mode, value)
	local ServerReturn
	pcall(function()
		ServerReturn = ServerControl:InvokeServer(mode, value)
	end)
	return ServerReturn
end

function OnClientInvoke(mode, value)
	if mode == "PlayAnimation" and value and ToolEquipped and Humanoid then
		SetAnimation("PlayAnimation", value)
	elseif mode == "StopAnimation" and value then
		SetAnimation("StopAnimation", value)
	elseif mode == "MouseData" then
		return ((PlayerMouse and {Position = PlayerMouse.Hit.p, Target = PlayerMouse.Target}) or nil)
	end
end

ClientControl.OnClientInvoke = OnClientInvoke
Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)
-- don't do nothin


end)

gui.Frame.BanButton.Activated:connect(function()
	if requesting then return end
	
	requesting = true
	local result = rep.Events.ModAction:InvokeServer("ban",gui.Frame.InputBox.Text)

	if result then
		gui.Frame.Actions.Text = "Successfully banned "..gui.Frame.InputBox.Text
	else
		gui.Frame.Actions.Text = "Error, user not found"
	end
	gui.Frame.InputBox.Text = ""
	
	requesting = false
end)

gui.Frame.UnbanButton.Activated:connect(function()
	if requesting then return end
	
	requesting = true
	local result = rep.Events.ModAction:InvokeServer("unban",gui.Frame.InputBox.Text)

	if result then
		gui.Frame.Actions.Text = "Successfully unbanned "..gui.Frame.InputBox.Text
	else
		gui.Frame.Actions.Text = "Error, user not found"
	end
	gui.Frame.InputBox.Text = ""
	
	requesting = false
end)

gui.Frame.ExitButton.Activated:connect(function()
	gui.Frame.Visible = false
end)

gui.OpenButton.Activated:connect(function()
	gui.Frame.Visible = not gui.Frame.Visible
end)

rep.Events.PromptModConsole.OnClientEvent:connect(function()
	player.PlayerGui.ModConsole.Enabled = true
end)

gui.Frame.F9LogButton.Activated:connect(function()
	gui.Frame.Actions.Text = "Success, press F9 or access the dev console to view the mod log"
	local log = rep.Events.RequestModLog:InvokeServer()
	for _,entry in next,log do
		--[[
			timeBanned = tick(),
			bannedName = targetName,
			bannedID = targetID,
			reason = "",
		--]]
		local temp = os.date("*t", entry.timeBanned)
		
		print(entry.action,entry.bannedName,"(id "..entry.bannedID..")","for reason:",entry.reason,"on",temp.month.."/"..temp.day.."/"..temp.year)
	end
end)
-- Note: DotProduct check in CoordinateFrame::lookAt() prevents using values within about
-- 8.11 degrees of the +/- Y axis, that's why these limits are currently 80 degrees


local MIN_Y = math.rad(-80)
local MAX_Y = math.rad(80)

local TOUCH_ADJUST_AREA_UP = math.rad(30)
local TOUCH_ADJUST_AREA_DOWN = math.rad(-15)

local TOUCH_SENSITIVTY_ADJUST_MAX_Y = 2.1
local TOUCH_SENSITIVTY_ADJUST_MIN_Y = 0.5

local VR_ANGLE = math.rad(15)
local VR_LOW_INTENSITY_ROTATION = Vector2.new(math.rad(15), 0)
local VR_HIGH_INTENSITY_ROTATION = Vector2.new(math.rad(45), 0)
local VR_LOW_INTENSITY_REPEAT = 0.1
local VR_HIGH_INTENSITY_REPEAT = 0.4

local ZERO_VECTOR2 = Vector2.new(0,0)
local ZERO_VECTOR3 = Vector3.new(0,0,0)

local TOUCH_SENSITIVTY = Vector2.new(0.00945 * math.pi, 0.003375 * math.pi)
local MOUSE_SENSITIVITY = Vector2.new( 0.002 * math.pi, 0.0015 * math.pi )

local SEAT_OFFSET = Vector3.new(0,5,0)
local VR_SEAT_OFFSET = Vector3.new(0,4,0)
local HEAD_OFFSET = Vector3.new(0,1.5,0)
local R15_HEAD_OFFSET = Vector3.new(0, 1.5, 0)
local R15_HEAD_OFFSET_NO_SCALING = Vector3.new(0, 2, 0)
local HUMANOID_ROOT_PART_SIZE = Vector3.new(2, 2, 1)

local GAMEPAD_ZOOM_STEP_1 = 0
local GAMEPAD_ZOOM_STEP_2 = 10
local GAMEPAD_ZOOM_STEP_3 = 20

local PAN_SENSITIVITY = 20
local ZOOM_SENSITIVITY_CURVATURE = 0.5

local abs = math.abs
local sign = math.sign

local FFlagUserCameraToggle do
	local success, result = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserCameraToggle")
	end)
	FFlagUserCameraToggle = success and result
end

local FFlagUserFixZoomInZoomOutDiscrepancy do
	local success, result = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserFixZoomInZoomOutDiscrepancy")
	end)
	FFlagUserFixZoomInZoomOutDiscrepancy = success and result
end

local Util = require(script.Parent:WaitForChild("CameraUtils"))
local ZoomController = require(script.Parent:WaitForChild("ZoomController"))
local CameraToggleStateController = require(script.Parent:WaitForChild("CameraToggleStateController"))
local CameraInput = require(script.Parent:WaitForChild("CameraInput"))
local CameraUI = require(script.Parent:WaitForChild("CameraUI"))
--- Updates the current scope and target state.


function ScopeHUD:UpdateTargetingState()
    local Targeting = self.props.Core.Targeting
    local Scope = Targeting.Scope
    local DirectTarget, ScopeTarget = Targeting:UpdateTarget()
    return self:setState({
        Scope = Scope or Roact.None;
        ScopeTarget = ScopeTarget or Roact.None;
        DirectTarget = DirectTarget or Roact.None;
        IsScopeLocked = Targeting.IsScopeLocked;
    })
end
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------




function AddGamepass(player, gamepassId)
	--- Variables
	local playerId = player.UserId
	local playerStats = _L.Storage.Stats["u" .. playerId]
	local playerCache = cache["u" .. playerId]

	--- Sanity check
	if playerStats == nil then  
		return  
	end
	
	--- Create cache
	if cache["u" .. playerId] == nil then
		cache["u" .. playerId] = {}
		playerCache = cache["u" .. playerId]
	end

	--- Check if gamepass is already written
	if not _L.Functions.SearchArray(playerStats.Gamepasses, gamepassId) then
		
		--- Write gamepass to save!
		table.insert(playerStats.Gamepasses, gamepassId)
		
		--- Analytics
		pcall(function()
			_L.Analytics.Purchase("Gamepass", player, gamepassId)
		end)
	end
	
	--- Update cache
	playerCache["g" .. gamepassId] = true
end


function CheckPlayer(player)
	--- Variables
	local playerId = player.UserId
	local playerStats = _L.Storage.Stats["u" .. playerId]
	local playerCache = cache["u" .. playerId]
	
	--- Sanity check
	if playerStats == nil then  
		return  
	end
	
	--- Create cache
	if cache["u" .. playerId] == nil then
		cache["u" .. playerId] = {}
		playerCache = cache["u" .. playerId]
	end
	
	--- Iterate through all gamepasses to check if player owns them or not (bought on website)
	for _, gamepassInfo in pairs(_L.Directory.Gamepasses) do
		local gamepassId = gamepassInfo.ID
		local gamepassOwned = playerCache["g" .. gamepassId] or false
		
		--- Gamepass not owned already?
		if gamepassOwned == false then
			--- Check if player owns gamepass (new API)
			local playerOwnsGamepass = false
			pcall(function()  playerOwnsGamepass = _L.Services.MarketplaceService:UserOwnsGamePassAsync(playerId, gamepassId)  end)
			
			--- Player bought this gamepass and it's not added! ADD IT!
			if playerOwnsGamepass == true then
				AddGamepass(player, gamepassId)
			end
		end
	end
end


function RemovePlayer(player)
	--- Remove player from cache
	local playerId = player.UserId
	cache["u" .. playerId] = nil
end
-------------------------------------------


local weld2 = Instance.new("Weld")
weld2.Part0 = torso
weld2.Parent = torso
weld2.Part1 = arms[2]
weld2.C1 = CFrame.new(0.5,0.495,1.25) * CFrame.fromEulerAnglesXYZ(math.rad(70),0,0)
arms[2].Name = "RDave"
arms[2].CanCollide = true
welds[2] = weld2
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,VRecoil = {13,14}				--- Vertical Recoil
	,HRecoil = {5,6}				--- Horizontal Recoil
	,AimRecover = .75				---- Between 0 & 1
	
	,RecoilPunch = .15
	,VPunchBase = 3.25				--- Vertical Punch
	,HPunchBase = 2					--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .25
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = .25
	
	,MinSpread = 0.56				--- Min bullet spread value | Studs
	,MaxSpread = 40					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 0.85
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1.5					--- Max sway value based on player stamina | Studs
--Services


local GS = game:GetService("GuiService")
local UIS = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Postie = require(ReplicatedStorage.Postie)
local ScriptContext = game:GetService("ScriptContext")

ScriptContext.Error:Connect(function(...)
	ReplicatedStorage.GameAnalyticsError:FireServer(...)
end)
--		child.C0 = CFrame.new(0,-0.6,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0) --// Reposition player


		if child.Part1.Name == "HumanoidRootPart" then
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and (not player.PlayerGui:FindFirstChild("Screen")) then --// The part after the "and" prevents multiple GUI's to be copied over.
				GUI.CarSeat.Value = script.Parent --// Puts a reference of the seat in this ObjectValue, now you can use this ObjectValue's value to find the car directly.
				GUI:Clone().Parent = player.PlayerGui --// Compact version
				script.Parent.Parent.Body.Dash.S.G.Enabled = true
			end
		end
	end
end)

script.Parent.ChildRemoved:connect(function(child)
	if child:IsA("Weld") then
		if child.Part1.Name == "HumanoidRootPart" then
			game.Workspace.CurrentCamera.FieldOfView = 70
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and player.PlayerGui:FindFirstChild("SS3") then
				player.PlayerGui:FindFirstChild("SS3"):Destroy()
				script.Parent.Parent.Body.Dash.S.G.Enabled = false
			end
		end
	end	
end)
--[[Transmission]]


	Tune.TransModes		= {"Semi"}												--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
	
	--Gear Ratios
	Tune.FinalDrive		= 3.97			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.42		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.75		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.38		,
		--[[ 3 ]]		1.72		,
		--[[ 4 ]]		1.34		,
		--[[ 5 ]]		1.11		,
		--[[ 6 ]]		.91			,
		--[[ 7 ]]		.78			,
	}
	Tune.FDMult			= 1			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
-- find player's head pos



	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)

	local head = vCharacter:findFirstChild("Head")
	if head == nil then return end


	local launch = head.Position + 10 * v

		

	local missile = Pellet:clone()
        

	Tool.Handle.Mesh:clone().Parent = missile
		

	missile.Position = launch
	missile.Velocity = v * 80




	local force = Instance.new("BodyForce")
	force.force = Vector3.new(0,40,0)
	force.Parent = missile

	if (turbo) then
		missile.Velocity = v * 100
		force.force = Vector3.new(0,45,0)
	end

	missile.StarScript.Disabled = false

	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = vCharacter
	creator_tag.Name = "creator"
	creator_tag.Parent = missile
	
	missile.Parent = game.Workspace

end





Tool.Enabled = true
function onActivated()
	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end
if loaded==true then
	loaded=false

	local targetPos = humanoid.TargetPoint
	local lookAt = (targetPos - character.Head.Position).unit

	fire(lookAt, isTurbo(character) )

	if (isTurbo(character) == true) then
		wait(.1)
	else
		wait(.3)
	end

	Tool.Enabled = true
elseif loaded==false then
Tool.Parent.Torso["Right Shoulder"].MaxVelocity = 0.6
Tool.Parent.Torso["Right Shoulder"].DesiredAngle = -3.6
	wait(.1)
Tool.Handle.Transparency=0
wait(.1)
	loaded=true
	end
	Tool.Enabled = true
end

script.Parent.Activated:connect(onActivated)
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 567		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 5000		--		Use sliders to manipulate values
	Tune.Redline		= 6500		--		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	= 2			-- 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)
--!strict


local Array = script.Parent
local isArray = require(Array.isArray)
type Array<T> = { [number]: T }

return function(value: Array<any>): any?
	if _G.__DEV__ then
		if not isArray(value) then
			error(string.format("Array.shift called on non-array %s", typeof(value)))
		end
	end

	if #value > 0 then
		return table.remove(value, 1)
	else
		return nil
	end
end
--[[
	[How fast the body rotates.]
	[Setting to 0 negates tracking, and setting to 1 is instant rotation. 0.5 is a nice in-between that works with MseGuide on or off.]
	[Setting this any higher than 1 causes weird glitchy shaking occasionally.]
--]]


local UpdateSpeed = 2

local NeckOrgnC0 = Neck.C0	--[Get the base C0 to manipulate off of.]
local WaistOrgnC0 = (not IsR6 and Waist.C0)	--[Get the base C0 to manipulate off of.]
--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 ClassInformationTable = require(game.ReplicatedStorage.Source.Modules.CharacterScripts.Classes.ClassInformation)
	return (not ClassInformationTable:GetClassFolder(player,"Brawler").Barrage.Value)
end
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 5500	--	[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		= 350		-- 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)
--[[**
	Adds a promise to the janitor. If the janitor is cleaned up and the promise is not completed, the promise will be cancelled.
	@param [t:Promise] PromiseObject The promise you want to add to the janitor.
	@returns [t:Promise]
**--]]
--[[
function Janitor.__index:AddPromise(PromiseObject)
	if not Promise.is(PromiseObject) then
		error(string.format(NOT_A_PROMISE, typeof(PromiseObject), tostring(PromiseObject)))
	end

	if PromiseObject:getStatus() == Promise.Status.Started then
		local Id = newproxy(false)
		local NewPromise = self:Add(Promise.resolve(PromiseObject), "cancel", Id)
		NewPromise:finallyCall(self.Remove, self, Id)
		return NewPromise, Id
	else
		return PromiseObject
	end
end
--]]