Pinkstack/roblox-luau-corpus-text huggingface dataset:
--viridian 6


if k == "v" and ibo.Value==true then
	bin.Blade.BrickColor = BrickColor.new("Pastel green")
	bin.Blade2.BrickColor = BrickColor.new("Institutional white")
	bin.Blade.White.Enabled=false colorbin.white.Value = false
	bin.Blade.Blue.Enabled=false colorbin.blue.Value = false
	bin.Blade.Green.Enabled=false colorbin.green.Value = false
	bin.Blade.Magenta.Enabled=false colorbin.magenta.Value = false
	bin.Blade.Orange.Enabled=false colorbin.orange.Value = false
	bin.Blade.Viridian.Enabled=true colorbin.viridian.Value = true
	bin.Blade.Violet.Enabled=false colorbin.violet.Value = false
	bin.Blade.Red.Enabled=false colorbin.red.Value = false
	bin.Blade.Silver.Enabled=false colorbin.silver.Value = false
	bin.Blade.Black.Enabled=false colorbin.black.Value = false
	bin.Blade.NavyBlue.Enabled=false colorbin.navyblue.Value = false
	bin.Blade.Yellow.Enabled=false colorbin.yellow.Value = false
	bin.Blade.Cyan.Enabled=false colorbin.cyan.Value = false
    end
--[[
	A utility used to create a function spy that can be used to robustly test
	that functions are invoked the correct number of times and with the correct
	number of arguments.

	This should only be used in tests.
]]



local assertDeepEqual = require(script.Parent.assertDeepEqual)

local function createSpy(inner)
	local self = {}
	self.callCount = 0
	self.values = {}
	self.valuesLength = 0
	self.value = function(...)
		self.callCount = self.callCount + 1
		self.values = { ... }
		self.valuesLength = select("#", ...)

		if inner ~= nil then
			return inner(...)
		end
		return nil
	end

	self.assertCalledWith = function(_, ...)
		local len = select("#", ...)

		if self.valuesLength ~= len then
			error(("Expected %d arguments, but was called with %d arguments"):format(self.valuesLength, len), 2)
		end

		for i = 1, len do
			local expected = select(i, ...)

			assert(self.values[i] == expected, "value differs")
		end
	end

	self.assertCalledWithDeepEqual = function(_, ...)
		local len = select("#", ...)

		if self.valuesLength ~= len then
			error(("Expected %d arguments, but was called with %d arguments"):format(self.valuesLength, len), 2)
		end

		for i = 1, len do
			local expected = select(i, ...)

			assertDeepEqual(self.values[i], expected)
		end
	end

	self.captureValues = function(_, ...)
		local len = select("#", ...)
		local result = {}

		assert(self.valuesLength == len, "length of expected values differs from stored values")

		for i = 1, len do
			local key = select(i, ...)
			result[key] = self.values[i]
		end

		return result
	end

	setmetatable(self, {
		__index = function(_, key)
			error(("%q is not a valid member of spy"):format(key))
		end,
	})

	return self
end

return createSpy
--// Recoil Settings	


	gunrecoil = -0.75; -- How much the gun recoils backwards when not aiming
	camrecoil = 1.1; -- How much the camera flicks when not aiming
	AimGunRecoil = -0.6; -- How much the gun recoils backwards when aiming
	AimCamRecoil = 1; -- How much the camera flicks when aiming
	
	CamShake = 1; -- THIS IS NEW!!!! CONTROLS CAMERA SHAKE WHEN FIRING
	AimCamShake = 1; -- THIS IS ALSO NEW!!!!
	
	Kickback = 6; -- Upward gun rotation when not aiming
	AimKickback = 2; -- Upward gun rotation when aiming
-- these accept or return opcodes in the form of string names


function luaP:GET_OPCODE(i) return self.ROpCode[i.OP] end
function luaP:SET_OPCODE(i, o) i.OP = self.OpCode[o] end

function luaP:GETARG_A(i) return i.A end
function luaP:SETARG_A(i, u) i.A = u end

function luaP:GETARG_B(i) return i.B end
function luaP:SETARG_B(i, b) i.B = b end

function luaP:GETARG_C(i) return i.C end
function luaP:SETARG_C(i, b) i.C = b end

function luaP:GETARG_Bx(i) return i.Bx end
function luaP:SETARG_Bx(i, b) i.Bx = b end

function luaP:GETARG_sBx(i) return i.Bx - self.MAXARG_sBx end
function luaP:SETARG_sBx(i, b) i.Bx = b + self.MAXARG_sBx end

function luaP:CREATE_ABC(o,a,b,c)
  return {OP = self.OpCode[o], A = a, B = b, C = c}
end

function luaP:CREATE_ABx(o,a,bc)
  return {OP = self.OpCode[o], A = a, Bx = bc}
end
--[[
	CLIMAXIMUS's Saving Script.
	Equipped with the best of scripting.
	( Must be put in ServerScriptService(Reccomended!) or workspace. )
]]

--

gameStats = { --[[ <-- Player can save his stats on command ]]
	["DoChat?"] = {
		["DoIt?"] = true;
		["Keywords"] = {
			"/save"; "/ save"; 
			":save"; ": save"
		}
	}; 
	["DoMessages?"] = false; --[[ <-- Reminder of saving/loading ]]
	["IsAnObby?"] = false; --[[ <-- Respawns the character to fix loading ]]
	saveType = {
		["Normal?"] = true; --[[ <-- Set to false if other ]]
		["SavingList?"] = { --[[ <-- Specific wanted admins ]]
			["DoIt?"] = false;
			theList = {
				"Name1";
				"Name2";
				"Name3"
			}
		};
		["BestFriends?"] = false; --[[ <-- Best friends of your's only. ]]
		["Friends?"] = false; --[[ <-- Friends of your's only. ]]
		["OwnerOnly?"] = false; --[[ <-- Only you have saving stats ]]
		["Gamepass?"] = { --[[ <-- Needs a gamepass to save ]]
			["DoIt?"] = false;
			["GamepassId"] = 000000
		};
		["Asset/Item?"] = { --[[ Such as a T-Shirt ]]
			["DoIt?"] = false;
			["AssetId"] = 000000
		}
	};
}
--[[Transmission]]


	Tune.TransModes		= {"Auto", "Semi", "Manual"}								--[[
	[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		= 4.00			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	4.00		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		7.00		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		6.00		,
		--[[ 3 ]]		5.00		,
		--[[ 4 ]]		4.00		,
		--[[ 5 ]]		3.00		,
		--[[ 6 ]]		2.00		,
		--[[ 7 ]]       1.00
	}
	Tune.FDMult			= 10			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
--------------------------------------------------------------------------------



HealPart.Touched:Connect(function(HitPart)
	local Player = Players:GetPlayerFromCharacter(HitPart.Parent)
	local Humanoid = HitPart.Parent:FindFirstChild("Humanoid")
	
	if Player and Humanoid then
		local Magnitude = (HitPart.Parent:GetPivot().Position - HealPart.Position).Magnitude
		
		if Magnitude < 100 then -- The client can move this with them on the client-side, and touch events will still pass. Just makes it a tiny bit more tedious, cause then they'd have to TP :3
			if Cooldown[Player] then
				return
			end
			Cooldown[Player] = true
			
			Humanoid.Health = Humanoid.MaxHealth
			Fountain.Healed:FireClient(Player, workspace:GetServerTimeNow())
			
			task.wait(Timer)
			Cooldown[Player] = nil
		end
	end
end)
--local part,pos,norm,mat = workspace:FindPartOnRay(ray,shelly)
--shelly:MoveTo(Vector3.new(shelly.PrimaryPart.Position.X,pos.Y+2.25,shelly.PrimaryPart.Position.Z))
--bp.Position = Vector3.new(bp.Position.X,pos.Y+2.25,bp.Position.Z)


until (shelly.PrimaryPart.Position-goal).magnitude < 10 or tick()-start >15
--[=[
	@param thumbstick Enum.KeyCode
	@param deadzoneThreshold number?
	@return Vector2
	Gets the position of the given thumbstick. The two thumbstick
	KeyCodes are `Enum.KeyCode.Thumbstick1` and `Enum.KeyCode.Thumbstick2`.

	If `deadzoneThreshold` is not included, the `DefaultDeadzone` value is
	used instead.

	```lua
	local leftThumbstick = gamepad:GetThumbstick(Enum.KeyCode.Thumbstick1)
	print("Left thumbstick position", leftThumbstick)
	```
]=]


function Gamepad:GetThumbstick(thumbstick: Enum.KeyCode, deadzoneThreshold: number?): Vector2
	local pos = self.State[thumbstick].Position
	local deadzone = deadzoneThreshold or self.DefaultDeadzone
	return Vector2.new(
		ApplyDeadzone(pos.X, deadzone),
		ApplyDeadzone(pos.Y, deadzone)
	)
end
--//White List


local settings = require(module)
game.Players.PlayerAdded:Connect(function(player)
	local canUse = true
	if #settings.WhiteList > 0 then --There is a whitelist
		canUse = false
		for _,id in pairs(settings.WhiteList) do
			if id == player.UserId then
				canUse = true
				break
			end
		end
	end

	--Give player the local script
	if canUse then
		player.CharacterAdded:Connect(function(char)
			script["DoubleJump - Local"]:Clone().Parent = char
		end)
		if player.Character then
			script["DoubleJump - Local"]:Clone().Parent = player.Character
		end
	end
end)
-- This module enables you to place Zone wherever you like within the data model while
-- still enabling third-party applications (such as HDAdmin/Nanoblox) to locate it
-- This is necessary to prevent two ZonePlus applications initiating at runtime which would
-- diminish it's overall efficiency



local replicatedStorage = game:GetService("ReplicatedStorage")
local ZonePlusReference = {}

function ZonePlusReference.addToReplicatedStorage()
    local existingItem = replicatedStorage:FindFirstChild(script.Name)
    if existingItem then
        return false
    end
    local objectValue = Instance.new("ObjectValue")
    objectValue.Name = script.Name
    objectValue.Value = script.Parent
    objectValue.Parent = replicatedStorage
    local locationValue = Instance.new("BoolValue")
    locationValue.Name = (game:GetService("RunService"):IsClient() and "Client") or "Server"
    locationValue.Value = true
    locationValue.Parent = objectValue
    return objectValue
end

function ZonePlusReference.getObject()
    local objectValue = replicatedStorage:FindFirstChild(script.Name)
    if objectValue then
        return objectValue
    end
    return false
end

return ZonePlusReference
--Both


local Loudness = 9 --volume of the boost supplier (not exact volume so you kinda have to experiment with it also)

script:WaitForChild("Whistle")
script:WaitForChild("Whine")
script:WaitForChild("BOV")

for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

car.DriveSeat.ChildRemoved:connect(function(child)
	if child.Name=="SeatWeld" then
		for i,v in pairs(car.DriveSeat:GetChildren()) do
			for _,a in pairs(script:GetChildren()) do
				if v.Name==a.Name then v:Stop() wait() v:Destroy() end
			end
		end
	end
end)

if not _Tune.Engine then return end
handler:FireServer("newSound","Whistle",car.DriveSeat,script.Whistle.SoundId,0,script.Whistle.Volume,true)
handler:FireServer("newSound","Whine",car.DriveSeat,script.Whine.SoundId,0,script.Whine.Volume,true)
handler:FireServer("newSound","BOV",car.DriveSeat,script.BOV.SoundId,0,script.BOV.Volume,true)
handler:FireServer("playSound","Whistle")
handler:FireServer("playSound","Whine")
car.DriveSeat:WaitForChild("Whistle")
car.DriveSeat:WaitForChild("Whine")
car.DriveSeat:WaitForChild("BOV")
local ticc = tick()
local _TCount = 0
if _Tune.Aspiration == "Single" or _Tune.Aspiration == "Super" then _TCount = 1 elseif _Tune.Aspiration == "Double" then _TCount = 2 end

while wait() do
	local psi = (((script.Parent.Values.Boost.Value)/(_Tune.Boost*_TCount))*2)
	--(script.Parent.Values.RPM.Value/_Tune.Redline)
	local WP,WV,BP,BV,HP,HV = 0
	
	BOVact = math.floor(psi*20)
	if _Tune.Aspiration == "Single" or _Tune.Aspiration == "Double" then
		WP = (psi)
		WV = (psi/4)*Loudness
		
		BP = (1-(-psi/20))*BOV_Pitch
		BV = (((-0.5+((psi/2)*BOV_Loudness)))*(1 - script.Parent.Values.Throttle.Value))
	
		if BOVact < BOVact2 then if car.DriveSeat.BOV.IsPaused then if FE then handler:FireServer("playSound","BOV") else car.DriveSeat.BOV:Play() end end end
		if BOVact >= BOVact2 then if FE then handler:FireServer("stopSound","BOV") else car.DriveSeat.BOV:Stop() end end
	elseif _Tune.Aspiration == "Super" then
		psi = psi/2
		HP = (script.Parent.Values.RPM.Value/_Tune.Redline)*Whine_Pitch
		HV = (psi/4)*Loudness
	end
	
	handler:FireServer("updateSound","Whistle",script.Whistle.SoundId,WP,WV)
	handler:FireServer("updateSound","Whine",script.Whine.SoundId,HP,HV)
	handler:FireServer("updateSound","BOV",script.BOV.SoundId,BP,BV)
	
	if (tick()-ticc) >= 0.1 then
		BOVact2 = math.floor(psi*20)
		ticc = tick()
	end
end
---------END LEFT DOOR



game.Workspace.DoorValues.BackMoving.Value = true
wait(0.1)
until game.Workspace.DoorValues.BackClose.Value=="0" --how much you want to open - the lower the number, the wider the door opens.
end
game.Workspace.DoorValues.Moving.Value = false
end
end
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
--



local humanoidControl = {};
local humanoidControl_mt = {__index = humanoidControl};

function humanoidControl.new(player)
	local self = {};
	
	self.character = player.Character;
	self.humanoid = self.character:WaitForChild("Humanoid");
	self.hrp = self.character:WaitForChild("HumanoidRootPart");
	
	self._lockedMoveVector = self.humanoid.MoveDirection;
	self._forcedMoveVector = self.humanoid.MoveDirection;
	self._mode = Enum.HumanoidControlType.Default;
	
	return setmetatable(self, humanoidControl_mt);
end
-- model  by CatLeoYT XD --



local Tool = script.Parent
local speedforsmoke = 10

local CoilSound = Tool.Handle:WaitForChild("CoilSound")

Tool.Equipped:connect(function()
	local Handle = Tool:WaitForChild("Handle")
	local HRP = Tool.Parent:FindFirstChild("HumanoidRootPart")
	local Human = Tool.Parent:FindFirstChild("Humanoid")
	CoilSound:Play()
	Human.WalkSpeed = Human.WalkSpeed * Tool.SpeedBoostScript.SpeedMultiplier.Value
end)

Tool.Unequipped:Connect(function()
	local player = script.Parent.Parent.Parent
	
	player.Character.Humanoid.WalkSpeed = 16
end)
--[=[
	@tag Component Instance
	@within Component
	@prop Instance Instance
	
	A reference back to the _Roblox_ instance from within a _component_ instance. When
	a component instance is created, it is bound to a specific Roblox instance, which
	will always be present through the `Instance` property.

	```lua
	MyComponent.Started:Connect(function(component)
		local robloxInstance: Instance = component.Instance
		print("Component is bound to " .. robloxInstance:GetFullName())
	end)
	```
]=]



local CollectionService = game:GetService("CollectionService")
local RunService = game:GetService("RunService")

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

local IS_SERVER = RunService:IsServer()
local DEFAULT_ANCESTORS = { workspace, game:GetService("Players") }
local DEFAULT_TIMEOUT = 60
--// Module LoadOrder List; Core modules need to be loaded in a specific order; If you create new "Core" modules make sure you add them here or they won't load


local CORE_LOADING_ORDER = table.freeze {
	--// Nearly all modules rely on these to function
	"Logs";
	"Variables";
	"Functions";

	--// Core functionality
	"Core";
	"Remote";
	"Process";

	--// Misc
	"Admin";
	"HTTP";
	"Anti";
	"Commands";
}
-- Get the players set settings


local plr
local wasEquipped = false
if script.Parent.Parent.ClassName == "Backpack" then
	plr = script.Parent.Parent.Parent
else
	wasEquipped = true
	plr = game.Players:GetPlayerFromCharacter(script.Parent.Parent)
end
local setSkin = game.ReplicatedStorage.RevolverSkins:FindFirstChild(plr.Settings.SetRevolverSkin.Value)
--This module is for any client FX related to the lab debris



local DoorFX = {}

local tweenService = game:GetService("TweenService")

local tweenInfo = TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)



local InitialModelCFrames = {}

function DoorFX.OPEN(door)
	if not door then return end

	local TweenInf = TweenInfo.new(.5, Enum.EasingStyle.Linear)

	door.PurchaseDoor.Sound:Play()

	local Components = door:GetChildren()
	for _, Component in pairs (Components) do
		if not Component:IsA("Model") then continue end

		local descendants = Component:GetChildren()
		for _, item in pairs (descendants) do
			if item:IsA("BasePart") then
				coroutine.wrap(function()
					tweenService:Create(item, TweenInf, {Transparency = 1}):Play()
				end)()
			end
		end
	end
end

function DoorFX.CLOSE(door)
	if not door then return end

	local Components = door:GetChildren()
	for _, Component in pairs (Components) do
		if Component:IsA("Model") then
			Component.PrimaryPart.CFrame = InitialModelCFrames[Component] or Component.PrimaryPart.CFrame 
			--this errors when the module is called for some reason so thats why its like that
		end
	end
end

return DoorFX
-- Creates a vector which represents a direction for a projectile to travel based on the cameras CFrame
-- @param CFrame cameraCFrame
-- @return Vector3


function SpreadSimulator:GetSpreadDirection(cameraCFrame)
	
	-- Roll random angle
	local randomZ = self.rng:NextNumber(0,360)
	-- Make cframe based on random angle
	local randomAngleCFrame = CFrame.Angles(0,0,-randomZ)
	-- Rotate camera cframe
	local rotatedCFrame = cameraCFrame * randomAngleCFrame
	-- Get a random point based on the circumference
	local randomMagnitude = self.rng:NextNumber(-self.currentSpread,self.currentSpread)/2
	
	-- Make spread vector based on current spread and the random point on circumference
	local spreadDirection = rotatedCFrame.UpVector * (self.currentSpread * randomMagnitude)
	

	return cameraCFrame.LookVector * Spread_Distance_From_Camera + spreadDirection 
	
end
--	====================
--	INPUTS
--	List of inputs that can be customized
--	====================


	
		Keyboard = {
			Reload = Enum.KeyCode.R;
			HoldDown = Enum.KeyCode.H;
			Inspect = Enum.KeyCode.F;
			Switch = Enum.KeyCode.V;
			ToogleAim = Enum.KeyCode.T;
			Melee = Enum.KeyCode.Q;
			AltFire = Enum.KeyCode.C;
		};
	
		Controller = {
			Fire = Enum.KeyCode.ButtonR1;
			Reload = Enum.KeyCode.ButtonX;
			HoldDown = Enum.KeyCode.DPadUp;
			Inspect = Enum.KeyCode.DPadDown;
			Switch = Enum.KeyCode.DPadRight;
			ToogleAim = Enum.KeyCode.ButtonL1;
			Melee = Enum.KeyCode.ButtonR3;
			AltFire = Enum.KeyCode.DPadRight;
		};
-- ScreenSpace -> WorldSpace. Taking a screen height that you want that object to be
-- and a world height that is the size of that object, and returning the position to
-- put that object at to satisfy those.


function ScreenSpace.ScreenToWorldByHeight(x, y, screenHeight, worldHeight)
	local aspectRatio = ScreenSpace.AspectRatio()
	local hfactor = math.tan(math.rad(workspace.CurrentCamera.FieldOfView)/2)
	local wfactor = aspectRatio*hfactor
	local sx, sy = ScreenSpace.ViewSizeX(), ScreenSpace.ViewSizeY()
	--
	local depth = - (sy * worldHeight) / (screenHeight * 2 * hfactor)
	--
	local xf, yf = x/sx*2 - 1, y/sy*2 - 1
	local xpos = xf * -wfactor * depth
	local ypos = yf *  hfactor * depth
	--
	return Vector3.new(xpos, ypos, depth)
end
----------------------------------------------------------------------------------------------------
------------------=[ Status UI ]=-------------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,EnableStatusUI = false				--- Don't disabled it...
	,RunWalkSpeed = 22
	,NormalWalkSpeed = 16
	,SlowPaceWalkSpeed = 8	
	,CrouchWalkSpeed = 8
	,ProneWalksSpeed = 4

	,EnableHunger = false				--- Hunger and Thirst system
	,HungerWaitTime = 25

	,CanDrown = false 					--- Welp.. That's it
	
	,EnableStamina = false 				--- Weapon Sway based on stamina	
	,RunValue = 1						--- Stamina consumption
	,StandRecover = .25					--- Stamina recovery while stading
	,CrouchRecover = .5					--- Stamina recovery while crouching
	,ProneRecover = 1					--- Stamina recovery while lying

	,EnableGPS = false					--- GPS shows your allies around you
	,GPSdistance = 150
-- Initialize the tool


local SurfaceTool = {
	Name = 'Surface Tool';
	Color = BrickColor.new 'Bright violet';

	-- Default options
	Surface = 'All';

	-- State
	CurrentSurfaceType = nil;

	-- Signals
	OnSurfaceChanged = Signal.new();
	OnSurfaceTypeChanged = Signal.new();
}

SurfaceTool.ManualText = [[<font face="GothamBlack" size="16">Surface Tool  🛠</font>
Lets you change the surfaces of parts.<font size="6"><br /></font>

<b>TIP: </b>Click a part's surface to select it quickly.]]
--Checks if the object exceeds the boundries given by the plot----------


local function CheckBoundaries(Plot, Primary)
	local Position = Plot.CFrame
	local Size = CFrame.fromOrientation(0, Primary.Orientation.Y*math.pi/180, 0)*Primary.Size
	local CurrentPos = Position:Inverse()*Primary.CFrame

	local xBound = (Plot.Size.X - Size.X)
	local zBound = (Plot.Size.Z - Size.Z)

	return CurrentPos.X > xBound or CurrentPos.X < -xBound or CurrentPos.Z > zBound or CurrentPos.Z < -zBound
end

local function HandleCollisions(Character, Item, Collisions, Plot)
	if not Collisions then Item.PrimaryPart.Transparency = 1; return true end

	local Collision = CheckHitbox(Character, Item, Plot)
	if Collision then Item:Destroy(); return false end

	Item.PrimaryPart.Transparency = 1
	return true
end
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------


	,VRecoil = {7,14}				--- Vertical Recoil
	,HRecoil = {4.5,12}				--- Horizontal Recoil
	,AimRecover = .65				---- Between 0 & 1
	
	,RecoilPunch = .15
	,VPunchBase = 2.55				--- Vertical Punch
	,HPunchBase = 1.6				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .5
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = .25
	
	,MinSpread = 0.95				--- Min bullet spread value | Studs
	,MaxSpread = 47					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = .75
	,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
--- Gamepass purchase prompted!


_L.MarketplaceService.PromptGamePassPurchaseFinished:Connect(function(player, gamepassId, purchased)
	if player then
		--- Did player complete transaction?
		if purchased == true then
			--- Player bought gamepass! WHAT A MASSIVE LEGEND
			AddGamepass(player, gamepassId)
			
			--- Let client know purchase went through
			_L.Network.Fire("Gamepass Bought", player, gamepassId)
		end
	end
end)