Pinkstack/roblox-luau-corpus-text huggingface dataset:
--// Use the power of the stars and hit as many people as you can to perform a chain attack!



local Properties = {
	DamageMode = "Normal", --What mode to reference the damage tables listed below
	
	Special = true,--The internal logical indicator to determine if we can use our special.
	
	Special_Reload = 10, --The Cooldown time until the ability is ready to be used.
	
	SpeedCap = 30, --This is the wielder's walkspeed when equipped

	DamageValues = {
		Normal = {
			Min = 2,
			Max = 5,
		},
		
		Lunge = {
			Min = 7,
			Max = 10
		}
	}

}

local FindFirstChild, FindFirstChildOfClass, WaitForChild = script.FindFirstChild, script.FindFirstChildOfClass, script.WaitForChild

local Clone, Destroy = script.Clone, script.Destroy

local GetChildren = script.GetChildren

local IsA = script.IsA

local Tool = script.Parent
Tool.Enabled = true

local DefaultGrip = FindFirstChild(Tool, "DefaultGrip") 
if not DefaultGrip then
	-- Create a new grip reference
	DefaultGrip = Instance.new("CFrameValue")
	DefaultGrip.Name = "DefaultGrip"
	DefaultGrip.Value = Tool.Grip
	DefaultGrip.Parent = Tool
end

Tool.Grip = DefaultGrip.Value --Reset the Tool's grip values to the DefaultGrip Value

local Handle = WaitForChild(Tool, "Handle")

pcall(function()
	Handle["Sparkle_Large_Blue"].Enabled = true --We're gonna use this as our visual indicator for our special.
end)

local Sounds = {
	Equip = WaitForChild(Handle, "Equip"),
	Slash = WaitForChild(Handle, "Slash"),
	Lunge = WaitForChild(Handle, "Lunge") 
}

local Players = (game:FindService("Players") or game:GetService("Players"))
local Debris = (game:FindService("Debris") or game:GetService("Debris"))
local RunService = (game:FindService("RunService") or game:GetService("RunService"))
local ServerScriptService = (game:FindService("ServerScriptService") or game:GetService("ServerScriptService"))

local NewRay = Ray.new
-------- OMG HAX



r = game:service("RunService")


local damage = 5


local slash_damage = 15


sword = script.Parent.Handle
Tool = script.Parent


local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "rbxasset://sounds\\swordslash.wav"
SlashSound.Parent = sword
SlashSound.Volume = .7


local UnsheathSound = Instance.new("Sound")
UnsheathSound.SoundId = "rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent = sword
UnsheathSound.Volume = 1

function isTurbo(character)
	return character:FindFirstChild("PirateHat") ~= nil
end



function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid~=nil and humanoid ~= hum and hum ~= nil then
		-- final check, make sure sword is in-hand

		local right_arm = vCharacter:FindFirstChild("Right Arm")
		if (right_arm ~= nil) then
			local joint = right_arm:FindFirstChild("RightGrip")
			if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
				tagHumanoid(humanoid, vPlayer)
				if (isTurbo(vCharacter) == true) then
					humanoid:TakeDamage(damage * 1.5)
				else
					humanoid:TakeDamage(damage)
				end
				
				wait(1)
				untagHumanoid(humanoid)
			end
		end


	end
end


function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end


function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
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

	

	attack()

	wait(.5)

	Tool.Enabled = true
end


function onEquipped()
	UnsheathSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
-- Inverse Kinematics will require profecient knowledge of trig and potentially calculus to understand completely.




local pi			=math.pi -- We are using radian-based angles (rather than degree), so we use pi! pi radians = 180 degrees
local hpi			=pi/2 -- pi/2 radians = 90 degrees
local tau			=2*pi -- 2pi radians = 360 degrees

local CF			=CFrame.new -- We don't want to type CFrame.new over and over
local V3			=Vector3.new -- We don't want to type Vector3.new over and over
local ANGLES		=CFrame.Angles -- Again, so we don't have to repeat it
local fromAxisAngle	=CFrame.fromAxisAngle -- Lol again
local NC			=CF() -- Get a blank cframe, same as Cframe.new(0,0,0)
local NV			=V3() -- Get a blank vector3, same as Vector3.new(0,0,0)
local forwardV3		=V3(0,0,-1) -- Get a forward-directional Vector3
local x_and_y		=V3(1,0,1) -- This will be used later; Vector3*x_and_y will remove the middle value, or the y-value.

local rhipcf		=CFrame.new(0.5, -0.4, 0) -- The right-hip reference CFrame, relative to the RightUpperLeg position
local lhipcf 		=CFrame.new(-0.5, -0.4, 0) -- The left-hip reference CFrame, relative to the LeftUpperLeg position
local rhipcf2 		=CFrame.new(0.5,-2.5,0)
local lhipcf2 		=CFrame.new(-0.5,-2.5,0)

local rIdle			=CFrame.new(0.25,-1.9,0) -- Idle CFrame of Motor6D joint
local lIdle			=CFrame.new(-0.25,-1.9,0) -- Idle CFrame of Motor6D joint
-- Set green edge if nothing toy


if script.Parent.ItemType.Value == "Toy" and itemName == "" then
					
	-- Check if equipped anywhere
	local equipped = false
	for _, o in pairs(settingVals) do
		if o.Value ~= "" then
			equipped = true
			break
		end
	end
	
	-- Only turn on border if nothing equipped
	if equipped then
		script.Parent.GreenEdge.Visible = false
	else
		script.Parent.GreenEdge.Visible = true
	end
	
end
-- Extends one table with another.
-- Similar to the spread operator in JavaScript.


function Util.Extend(original: AnyTable, extension: AnyTable): AnyTable
	local t = Util.DeepCopy(original)
	for k, v in pairs(extension) do
		if type(v) == "table" then
			if type(original[k]) == "table" then
				t[k] = Util.Extend(original[k], v)
			else
				t[k] = Util.DeepCopy(v)
			end
		elseif v == Util.None then
			t[k] = nil
		else
			t[k] = v
		end
	end
	return t
end

return Util
-- Signal class


local Signal = {}
Signal.__index = Signal

export type ClassType = typeof(setmetatable({} :: {
	_handlerListHead: SignalConnection?,
}, Signal))

function Signal.new(): ClassType
	return setmetatable({
		_handlerListHead = nil,
	}, Signal)
end

function Signal.Connect(self: ClassType, fn: Callback): SignalConnection
	local connection = Connection.new(self, fn)
	if self._handlerListHead then
		connection._next = self._handlerListHead :: SignalConnection

		self._handlerListHead = connection
	else
		self._handlerListHead = connection
	end
	return connection
end
--		print("Wha " .. Pose)


		Amplitude = 0.1
		Frequency = 1
		SetAngles = true
	end

	if SetAngles then
		DesiredAngle = (Amplitude * math.sin(Time * Frequency))

		--RightShoulder:SetDesiredAngle(DesiredAngle + ClimbFudge)
		--LeftShoulder:SetDesiredAngle(DesiredAngle - ClimbFudge)
		RightHip:SetDesiredAngle(-DesiredAngle)
		LeftHip:SetDesiredAngle(-DesiredAngle)
	end

	-- Tool Animation handling
	local Tool = GetTool()
	if Tool then
	
		AnimStringValueObject = GetToolAnim(Tool)

		if AnimStringValueObject then
			ToolAnim = AnimStringValueObject.Value
			-- message recieved, delete StringValue
			AnimStringValueObject.Parent = nil
			ToolAnimTime = (Time + 0.3)
		end

		if Time > ToolAnimTime then
			ToolAnimTime = 0
			ToolAnim = "None"
		end

		AnimateTool()		
	else
		StopToolAnimations()
		ToolAnim = "None"
		ToolAnimTime = 0
	end
end
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 1604		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 2000		--		Use sliders to manipulate values
	Tune.Redline		= 12000		--		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)
-- by Ganondude



ring1 = script.Parent.Parent.Rings.Ring1
lifts1 = ring1.Lifts:getChildren()
parts1 = ring1.Parts:getChildren()
ring2 = script.Parent.Parent.Rings.Ring2
lifts2 = ring2.Lifts:getChildren()
parts2 = ring2.Parts:getChildren()
ring3 = script.Parent.Parent.Rings.Ring3
lifts3 = ring3.Lifts:getChildren()
parts3 = ring3.Parts:getChildren()
ring4 = script.Parent.Parent.Rings.Ring4
lifts4 = ring4.Lifts:getChildren()
parts4 = ring4.Parts:getChildren()
ring5 = script.Parent.Parent.Rings.Ring5
lifts5 = ring5.Lifts:getChildren()
parts5 = ring5.Parts:getChildren()

localdeb = script.Parent.Debounce
foreigndeb = script.Parent.Parent.Parent:findFirstChild(script.Parent.Parent.Destination.Value).Button.Debounce

function onTouched(hit)
if (localdeb.Value~=true) and (foreigndeb.Value~=true) then
localdeb.Value = true
foreigndeb.Value = true
-- Arceusinator's Easing Functions


local function RevBack(t, b, c, d)
	t = 1 - t / d
	return c * (1 - (sin(t * 1.5707963267948965579989817342720925807952880859375) + (sin(t * 3.14159265358979311599796346854418516159057617187) * (cos(t * 3.14159265358979311599796346854418516159057617187) + 1) * 0.5))) + b
end

local function RidiculousWiggle(t, b, c, d)
	t = t / d
	return c * sin(sin(t * 3.14159265358979311599796346854418516159057617187) * 1.5707963267948965579989817342720925807952880859375) + b
end
--[[
	
	Creates & returns a value instance from 1st argument.
	
	Functions.QuickValue(
		..., 					<-- |REQ|	Anything
	)
	
--]]





return function(value, parent)
	--- Var
	local valueType
	
	--- Grab type of userdata
	if type(value) == "boolean" then
		--- Booleans
		valueType = "BoolValue"
	
	elseif type(value) == "number" then
		--- Numbers/integers
		valueType = "NumberValue"
		
	elseif type(value) == "string" then
		--- Strings
		valueType = "StringValue"
		
	elseif typeof(value) == "BrickColor" then
		--- BrickColors
		valueType = "BrickColorValue"
	
	elseif typeof(value) == "CFrame" then
		--- CFrames
		valueType = "CFrameValue"
		
	elseif typeof(value) == "Color3" then
		--- Color3s
		valueType = "Color3Value"
		
	elseif typeof(value) == "Ray" then
		--- Rays
		valueType = "RayValue"
		
	elseif typeof(value) == "Vector3" then
		--- Vector3s
		valueType = "Vector3Value"
	
	elseif typeof(value) == "Instance" then
		--- Instances
		valueType = "ObjectValue"
	end
	
	--- Successfully grabbed type?
	if valueType then
		--- Create value instance
		local valueObj = Instance.new(valueType)
		valueObj.Value = value
		
		--- Parent if argument provided
		if parent then
			valueObj.Parent = parent
		end
		
		--
		return valueObj
		
	else
		--- Value not supported (or nil)
		_L.Print("Value type not supported", true)
	end
end
--Locals


local uis = game:GetService("UserInputService")
local player = game.Players.LocalPlayer
local char = player.Character
local bp = player.Backpack
local hum = char:WaitForChild("Humanoid")
local frame = script.Parent.Frame
local template = frame.Template
local equipped = 0
local unequipped = 0.3

local iconSize = template.Size
local iconBorder = {x = 5, y = 15}

local inputKeys = {
	--To add more keys just copy and paste and add more slots
	["One"] = {txt = "1"},
	["Two"] = {txt = "2"},
	["Three"] = {txt = "3"},
	
}

local inputOrder = {
	inputKeys["One"],inputKeys["Two"],inputKeys["Three"],inputKeys["Four"],inputKeys["Five"],
}
---------------------------------------------------------------------------------------------------------------
-- Do not edit past here or you will be risking breaking the script!!!! --
---------------------------------------------------------------------------------------------------------------



	-- VERY UGLY HACK
	-- Will this leak threads?
	-- Is the problem even what I think it is (player arrived before character)?

	while true do
		if newPlayer.Character ~= nil then break end
		wait(5)
	end

	local humanoid = newPlayer.Character.Humanoid

	humanoid.Died:connect(function() onHumanoidDied(humanoid, newPlayer) end )

	-- start to listen for new humanoid
	newPlayer.Changed:connect(function(property) onPlayerRespawn(property, newPlayer) end )


	stats.Parent = newPlayer

end

function Send_DB_Event_Died(victim, killer)
	-- killer may be nil
	local killername = "unknown"
	if killer ~= nil then killername = killer.Name end
	print(victim.Name, " was killed by ", killername)

	if shared["deaths"] ~= nil then 
		shared["deaths"](victim, killer)
		print("Death event sent.")
	end
end

function Send_DB_Event_Kill(killer, victim)
	print(killer.Name, " killed ", victim.Name)
	if shared["kills"] ~= nil then 
		shared["kills"](killer, victim)
		print("Kill event sent.")
	end
end



function onHumanoidDied(humanoid, player)
	local stats = player:findFirstChild("leaderstats")
	if stats ~= nil then
		local deaths = stats:findFirstChild("Deaths")
		deaths.Value = deaths.Value + 1

		-- do short dance to try and find the killer

		local killer = getKillerOfHumanoidIfStillInGame(humanoid)


		Send_DB_Event_Died(player, killer)
		handleKillCount(humanoid, player)
	end
end

function onPlayerRespawn(property, player)
	-- need to connect to new humanoid
	
	if property == "Character" and player.Character ~= nil then
		local humanoid = player.Character.Humanoid
			local p = player
			local h = humanoid
			humanoid.Died:connect(function() onHumanoidDied(h, p) end )
	end
end

function getKillerOfHumanoidIfStillInGame(humanoid)
	-- returns the player object that killed this humanoid
	-- returns nil if the killer is no longer in the game

	-- check for kill tag on humanoid - may be more than one - todo: deal with this
	local tag = humanoid:findFirstChild("creator")

	-- find player with name on tag
	if tag ~= nil then
		
		local killer = tag.Value
		if killer.Parent ~= nil then -- killer still in game
			return killer
		end
	end

	return nil
end

function handleKillCount(humanoid, player)
	local killer = getKillerOfHumanoidIfStillInGame(humanoid)
	if killer ~= nil then
		local stats = killer:findFirstChild("leaderstats")
		if stats ~= nil then
			local kills = stats:findFirstChild("Kills")
		   local cash = stats:findFirstChild("Cash")
         local xp = stats:findFirstChild("XP")
			if killer ~= player then
				kills.Value = kills.Value + 1
            cash.Value = cash.Value + 50
            xp.Value = xp.Value + 3
				
			else
				kills.Value = kills.Value - 0
				
			end
			Send_DB_Event_Kill(killer, player)
		end
	end
end

game.Players.ChildAdded:connect(onPlayerEntered)
----- Creator By: Kaario Studios -----
----- Don't Forget To Join Group! -----



local Delay = 7 --- Waiting time when clicked
local player = game.Players.LocalPlayer
local enabled = true
script.Parent.MouseButton1Click:Connect(function()
	local char = player.Character
	if enabled == true then
		enabled = false
		if char:FindFirstChild('Humanoid')then
			char.Head.CFrame = CFrame.new(game.Workspace.Position.Position)--- Workspace.(Position) <-- Name Of Block (Teleport)
			wait (Delay)
			enabled = true
		end
	end
end)
-- made by Bertox
-- lul
-- Edited by Yukinoshida




 script.Parent.Parent.Parent.Parent.Electrics.Changed:connect(function()
	if script.Parent.Parent.Parent.Parent.Electrics.Value == true then
		script.Parent.Material = Enum.Material.Neon
		script.Parent.BrickColor = BrickColor.new("Medium blue")
	else
		script.Parent.Material = Enum.Material.SmoothPlastic
		script.Parent.BrickColor = BrickColor.new("Institutional white") 
	end
end)
--Made by Luckymaxer



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

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

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 KeyPressed(Key, Down)
	InvokeServer("KeyPressed", {Key = Key, Down = Down})
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 = Mouse
	PlayerMouse.KeyDown:connect(function(Key)
		KeyPressed(Key, true)
	end)
	PlayerMouse.KeyUp:connect(function(Key)
		KeyPressed(Key, false)
	end)
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 == "PlaySound" and value then
		value:Play()
	elseif mode == "StopSound" and value then
		value:Stop()
	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)
--[[
local gui = game.StarterGui.HDAdminGUIs
for a,b in pairs(gui:GetDescendants()) do
	if b:IsA("GuiObject") and b.BackgroundColor3 == Color3.fromRGB(0, 100, 150) and b:FindFirstChild("Theme") == nil then
		local bool = Instance.new("BoolValue")
		bool.Name = "Theme"
		bool.Parent = b
	end
end
--]]
--[[Tires]]

--
	-- Tire Curve Profiler: https://www.desmos.com/calculator/og4x1gyzng
	Tune.TireCylinders	= 8			-- How many cylinders are used for the tires. More means a smoother curve but way more parts meaning lag. (Default = 4)
	Tune.TiresVisible	= false		-- Makes the tires visible (Debug)
--fetching effectlib


local common_modules = game.ReplicatedStorage.CommonModules
EFFECT_LIB = require(common_modules.EffectLib)
local GenColor = function(t, rate)
  
  local get_t = (t - math.floor(t / rate) * rate) / rate * math.pi * 2
  local red = math.sin(get_t + 0) * 0.5 + 0.5
  local green = math.sin(get_t + math.pi / 2) * 0.5 + 0.5
  local blue = math.sin(get_t + math.pi) * 0.5 + 0.5
  return Color3.new(red, green, blue)
end
-- Ensures that 'actual' is of type 'number'


local function ensureActualIsNumber(actual: any, matcherName: string, options: MatcherHintOptions?): ()
	-- ROBLOX deviation: we do not support a "bigint" type
	if typeof(actual) ~= "number" then
		-- Prepend maybe not only for backward compatibility
		local matcherString = matcherName

		if not options then
			matcherString = "[.never]" .. matcherString
		end

		error(
			Error(
				matcherErrorMessage(
					matcherHint(matcherString, nil, nil, options),
					RECEIVED_COLOR("received") .. " value must be a number",
					printWithType("Received", actual, printReceived)
				)
			)
		)
	end
end
-- +3 PETS EQUIPPED



PetsEquippedButton.MouseEnter:Connect(function()
	PetsEquippedButton.Text = "149 R$"
	PetsEquippedButton.TextColor3 = Color3.fromRGB(0, 255, 0)
end)

PetsEquippedButton.MouseLeave:Connect(function()
	PetsEquippedButton.Text = "BUY"
	PetsEquippedButton.TextColor3 = Color3.fromRGB(255, 255, 255)
end)
--[[ Roblox Services ]]

--
local UserInputService = game:GetService("UserInputService")
local ContextActionService = game:GetService("ContextActionService")
local PathfindingService = game:GetService("PathfindingService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local DebrisService = game:GetService('Debris')
local ReplicatedStorage = game:GetService('ReplicatedStorage')
local TweenService = game:GetService("TweenService")
--[[
	Function to call and retry a given function, up to maxAttempts times.
	This function waits pauseConstant + (pauseExponent ^ numAttempts) between retries for progressive exponential backoff.
	Calls are made with the functionCallHandler (default: pcall)
	and the results of this (in the form of success, errorMessage or ...) are returned.
--]]



type Function = (...any) -> ...any
export type FunctionHandler = (...any) -> (boolean, ...any)

local function retryAsync(
	func: Function,
	maxAttempts: number,
	optionalPauseConstant: number?,
	optionalPauseExponent: number?,
	optionalFunctionCallHandler: ((Function) -> (boolean, ...any))?
): (boolean, ...any)
	-- Using separate variables to satisfy the type checker
	local pauseConstant: number = optionalPauseConstant or 0
	local pauseExponent: number = optionalPauseExponent or 0
	local functionCallHandler: FunctionHandler = optionalFunctionCallHandler or pcall

	local attempts = 0
	local success: boolean, result: { any }

	while attempts < maxAttempts do
		attempts = attempts + 1

		local returnValues: { any }

		returnValues = { functionCallHandler(func) }

		success = table.remove(returnValues, 1) :: boolean
		result = returnValues

		if success then
			break
		end

		local pauseTime = pauseConstant + (pauseExponent ^ attempts)

		if attempts < maxAttempts then
			task.wait(pauseTime)
		end
	end

	if success then
		return success, table.unpack(result)
	else
		local errorMessage = not success and result[1] :: any or nil
		return success, errorMessage :: any
	end
end

return retryAsync
----------------------------------------------------------------------------------------------------
--------------------=[ OUTROS ]=--------------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,FastReload = false					--- Automatically operates the bolt on reload if needed
	,SlideLock = false
	,MoveBolt = false
	,BoltLock = false
	,CanBreachDoor = false
	,CanBreak = false					--- Weapon can jam?
	,JamChance = 0						--- This old piece of brick doesn't work fine >;c
	,IncludeChamberedBullet = false		--- Include the chambered bullet on next reload
	,Chambered = false					--- Start with the gun chambered?
	,LauncherReady = false				--- Start with the GL ready?
	,CanCheckMag = false				--- You can check the magazine
	,ArcadeMode = false					--- You can see the bullets left in magazine
	,RainbowMode = false				--- Operation: Party Time xD
	,ModoTreino = false					--- Surrender enemies instead of killing them
	,GunSize = 1.25
	,GunFOVReduction = 5

	,BoltExtend = Vector3.new(0, 0, 0)
	,SlideExtend = Vector3.new(0, 0, 0)