Roblox/luau_corpus huggingface dataset:
----------------------------------------------------------------------------------------------------
-----------------=[ General ]=----------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	 TeamKill = true					--- Enable TeamKill?
	,TeamDmgMult = 1					--- Between 0-1 | This will make you cause less damage if you hit your teammate
	
	,ReplicatedBullets = true			--- Keep in mind that some bullets will pass through surfaces...
	
	,AntiBunnyHop = true				--- Enable anti bunny hop system?
	,JumpCoolDown = 1.5					--- Seconds before you can jump again
	,JumpPower = 0						--- Jump power, default is 50
	
	,RealisticLaser = true				--- True = Laser line is invisible
	,ReplicatedLaser = true				
	,ReplicatedFlashlight = true
	
	,EnableRagdoll = true				--- Enable ragdoll death?
	,TeamTags = true					--- Aaaaaaa
	,HitmarkerSound = false				--- GGWP MLG 360 NO SCOPE xD
	,Crosshair = true					--- Crosshair for Hipfire shooters and arcade modes
	,CrosshairOffset = 5				--- Crosshair size offset
--[=[
	@param promise Promise
	@return Promise
	Gives the promise to the trove, which will cancel the promise if the trove is cleaned up or if the promise
	is removed. The exact promise is returned, thus allowing chaining.

	```lua
	trove:AddPromise(doSomethingThatReturnsAPromise())
		:andThen(function()
			print("Done")
		end)
	-- Will cancel the above promise (assuming it didn't resolve immediately)
	trove:Clean()

	local p = trove:AddPromise(doSomethingThatReturnsAPromise())
	-- Will also cancel the promise
	trove:Remove(p)
	```

	:::caution Promise v4 Only
	This is only compatible with the [roblox-lua-promise](https://eryn.io/roblox-lua-promise/) library, version 4.
	:::
]=]
function Trove:AddPromise(promise)
	AssertPromiseLike(promise)
	if promise:getStatus() == "Started" then
		promise:finally(function()
			return self:_findAndRemoveFromObjects(promise, false)
		end)
		self:Add(promise, "cancel")
	end
	return promise
end
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {
	i = {
		Hand = "rbxassetid://9873368030", 
		Eye = "rbxassetid://9873864431", 
		Bulb = "rbxassetid://9874204694"
	}
};
v1.icons = {
	Default = v1.i.Hand, 
	Interact = v1.i.Hand, 
	Inspect = v1.i.Eye, 
	Hint = v1.i.Bulb
};
function v1.getIcon(p1)
	local v2 = v1.icons[p1];
	if v2 then
		return v2;
	end;
	return v1.icons.Default;
end;
return v1;
----------------------------------------------------------------------------------------------------
-------------------=[ PROJETIL ]=-------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	,Distance = 0
	,BDrop = 0
	,BSpeed = 0

	,SuppressMaxDistance = 0	--- Studs
	,SuppressTime = 0			--- Seconds

	,BulletWhiz = false
	,BWEmitter = 0
	,BWMaxDistance = 0
	
	,BulletFlare = false
	,BulletFlareColor = Color3.fromRGB(0,0,0)

	,Tracer = false
	,TracerColor = Color3.fromRGB(0,0,0)
	,TracerLightEmission = 0
	,TracerLightInfluence = 0
	,TracerLifeTime = 0
	,TracerWidth = 0
	,RandomTracer = false
	,TracerEveryXShots = 0
	,TracerChance = 0
	
	,BulletLight = false
	,BulletLightBrightness = 0
	,BulletLightColor = Color3.fromRGB(0,0,0)
	,BulletLightRange = 0

	,ExplosiveHit = false
	,ExPressure = 0
	,ExpRadius = 0
	,DestroyJointRadiusPercent = 0	--- Between 0 & 1
	,ExplosionDamage = 0

	,LauncherDamage = 0
	,LauncherRadius = 0
	,LauncherPressure = 0
	,LauncherDestroyJointRadiusPercent = 0
---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- 

input.InputChanged:connect(function(inputObject)
	
	if inputObject.UserInputType == Enum.UserInputType.MouseMovement then
		local delta = Vector2.new(inputObject.Delta.x/Sensitivity,inputObject.Delta.y/Sensitivity) * Smoothness

		local X = TargetAngleX - delta.y 
		TargetAngleX = (X >= 80 and 80) or (X <= -80 and -80) or X 
		TargetAngleY = (TargetAngleY - delta.x) %360 
	end	
	
end)

input.InputBegan:connect(function(inputObject)
	
	if inputObject.UserInputType == Enum.UserInputType.Keyboard then
		if inputObject.KeyCode == CanToggleMouse.activationkey then
			if CanToggleMouse.allowed and freemouse == false then
				freemouse = true
			else
				freemouse = false
			end
		end
	end
	
	if inputObject.UserInputType == Enum.UserInputType.Keyboard then
		if inputObject.KeyCode == Enum.KeyCode.W then
			w = true
		end
		
		if inputObject.KeyCode == Enum.KeyCode.A then
			a = true
		end
		
		if inputObject.KeyCode == Enum.KeyCode.S then
			s = true
		end
		
		if inputObject.KeyCode == Enum.KeyCode.D then
			d = true
		end
		
		if inputObject.KeyCode == Enum.KeyCode.LeftShift then
			lshift = true
		end
	end
end)

input.InputEnded:connect(function(inputObject)
	if inputObject.UserInputType == Enum.UserInputType.Keyboard then
		if inputObject.KeyCode == Enum.KeyCode.W then
			w = false
		end
		
		if inputObject.KeyCode == Enum.KeyCode.A then
			a = false
		end
		
		if inputObject.KeyCode == Enum.KeyCode.S then
			s = false
		end
		
		if inputObject.KeyCode == Enum.KeyCode.D then
			d = false
		end
		
		if inputObject.KeyCode == Enum.KeyCode.LeftShift then
			lshift = false
		end
	end
end)
--[=[
	Shorthand for `Promise:andThen(nil, failureHandler)`.

	Returns a Promise that resolves if the `failureHandler` worked without encountering an additional error.

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


	@param failureHandler (...: any) -> ...any
	@return Promise<...any>
]=]
function Promise.prototype:catch(failureHandler)
	assert(failureHandler == nil or isCallable(failureHandler), string.format(ERROR_NON_FUNCTION, "Promise:catch"))
	return self:_andThen(debug.traceback(nil, 2), nil, failureHandler)
end
-- Toggle Event
ShiftLockController.OnShiftLockToggled = Instance.new('BindableEvent')
--Var
local isOpen = false

local MainMenuOpen = {}

function MainMenuOpen:ManipUI()
    isOpen = not isOpen 
    MainFrame.Visible = isOpen
end

function MainMenuOpen:Setup(UI, Main)
    Button = UI
    MainFrame = Main.MainMenu

    Button.MainToggle.MouseButton1Down:Connect(function()
        self:ManipUI()
    end)
end

return MainMenuOpen
-- Variables (best not to touch these!)
local button = script.Parent.Parent
local car = script.Parent.Parent.Parent.Car.Value
local sound = script.Parent.Start
local st = script.Parent.Stall
st.Parent = car.DriveSeat
sound.Parent = car.DriveSeat -- What brick the start sound is playing from.
button.MouseButton1Click:connect(function() -- Event when the button is clicked
	if script.Parent.Parent.Text == "Engine: Off" then -- If the text says it's off then..
		sound:Play() -- Startup sound plays..
		wait(1.1) -- I don't know what to put for this
		script.Parent.Parent.Parent.IsOn.Value = true -- The car is is on, or in other words, start up the car.
		button.Text = "Engine: On"  -- You don't really need this, but I would keep it.
	else -- If it's on then when you click the button,
		st:play()
		script.Parent.Parent.Parent.IsOn.Value = false -- The car is turned off.
		button.Text = "Engine: Off"
	end -- Don't touch this.
end) -- And don't touch this either.
-----
R = false
UIS.InputBegan:connect(function(i,GP) if not GP then if i.KeyCode == Enum.KeyCode.C then
if R == false then
script.Parent.Right.ImageColor3 = Color3.fromRGB(142, 255, 169)
R = true
else
script.Parent.Right.ImageColor3 = Color3.fromRGB(255,255,255)
R = false
end
end end end)
--// If youre here to add your team go to the module and add it in there, just tryna to clean this up alittle
local WhiteListedTeams = require(game.ReplicatedStorage.MotionDetectorsWhitelist.StandartPermission)

Detector.Touched:Connect(
	function(boop)
		if boop.Parent:FindFirstChild("Humanoid") then
			local char = boop.Parent
			local Player = game:GetService("Players"):GetPlayerFromCharacter(char)
			if WhiteListedTeams[Player.Team] ==nil then
				if not isTouched then  
					isTouched = true 

					wait(0.1)
					script.Parent.Alarm:Play()
					Light.Enabled = true
					L1.BrickColor = BrickColor.new ("Persimmon")
					L12.BrickColor = BrickColor.new ("Persimmon")
					L2.BrickColor = BrickColor.new ("Persimmon")
					L22.BrickColor = BrickColor.new ("Persimmon")
					wait(5)
					L1.BrickColor = BrickColor.new ("Pastel yellow")
					L12.BrickColor = BrickColor.new ("Pastel yellow")
					L2.BrickColor = BrickColor.new ("Pastel yellow")
					L22.BrickColor = BrickColor.new ("Pastel yellow")
					Light.Enabled = false
					wait(RESET_SECONDS)
					isTouched = false 
				end
			end
		end
	end
)
--requires luaP, luaX, luaK
local luaY = {}
local luaX = require(script.Parent.LuaX)
local luaK = require(script.Parent.LuaK)(luaY)
local luaP = require(script.Parent.LuaP)
--------LEFT DOOR --------
game.Workspace.doorleft.l11.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l23.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l32.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l53.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l62.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorleft.l71.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)

game.Workspace.doorleft.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
--print("no building or player")
target = nil
targetType = nil
lastLock = tick()
-- / Functions / --
EventModule.ActivateEvent = function()
	local RandomPlayer = PlayingTeam:GetPlayers()[math.random(1, #PlayingTeam:GetPlayers())]

	if RandomPlayer then
		local Character = RandomPlayer.Character or RandomPlayer.CharacterAdded:Wait()
		
		if Character then
			local Humanoid = Character:WaitForChild("Humanoid")
			
			if Humanoid then	
				local HumanoidDescription = Humanoid:GetAppliedDescription()
				
				HumanoidDescription.HeadScale = 3
				
				Humanoid:ApplyDescription(HumanoidDescription)
				
				local Head = Character:WaitForChild("Head")
				
				if Head then
					Head.Massless = true
					Head.CanCollide = false
				end

			end
		end
	end
end
--local asdf = Instance.new("Part")
--asdf.Anchored = true
--asdf.Size = Vector3.new(2,2,2)
--asdf.CFrame = CFrame.new(pos)
--asdf.Parent = workspace
if part then
if part == workspace.Terrain and mat ~= Enum.Material.Water then
--[=[
	Cleans up all tasks and removes them as entries from the Maid.

	:::note
	Signals that are already connected are always disconnected first. After that
	any signals added during a cleaning phase will be disconnected at random times.
	:::

	:::tip
	DoCleaning() may be recursively invoked. This allows the you to ensure that
	tasks or other tasks. Each task will be executed once.

	However, adding tasks while cleaning is not generally a good idea, as if you add a
	function that adds itself, this will loop indefinitely.
	:::
]=]
function Maid:DoCleaning()
	local tasks = self._tasks

	-- Disconnect all events first as we know this is safe
	for index, job in pairs(tasks) do
		if typeof(job) == "RBXScriptConnection" then
			tasks[index] = nil
			job:Disconnect()
		end
	end

	-- Clear out tasks table completely, even if clean up tasks add more tasks to the maid
	local index, job = next(tasks)
	while job ~= nil do
		tasks[index] = nil
		if type(job) == "function" then
			job()
		elseif type(job) == "thread" then
			task.cancel(job)
		elseif typeof(job) == "RBXScriptConnection" then
			job:Disconnect()
		elseif job.Destroy then
			job:Destroy()
		end
		index, job = next(tasks)
	end
end
--blah
else
script.Parent.Parent = nil
end
end
script.Parent.Touched:connect(onTouched)
--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 plrData.Character.Purity.Value <= 50
end
--game.StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.All, false)

currentCamera.FieldOfView = customMenuFieldOfView
currentCamera.CameraType = Enum.CameraType.Scriptable
currentCamera.CFrame = spawnItems.CameraPart.CFrame
gameVersion.Text = configuration.GameVersionInfo.Value.." "..game.PlaceVersion
versionOpen:Play()
blurOpen:Play()
fade.Visible = true
Sounds.MenuMusic.Playing = configuration.MenuMusic.Value
menuMusicOn:Play()
wait(longLength)
fadeOpen:Play()
wait(longLength * 0.5)
buttonsOpen:Play()
titleOpen:Play()
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 553		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)
--[[
	Package link auto-generated by Rotriever
]]
local PackageIndex = script.Parent.Parent.Parent._Index

local Package = require(PackageIndex["LuauPolyfill-2fca3173-0.3.4"]["LuauPolyfill"])

export type Array<T> = Package.Array<T> 
export type AssertionError = Package.AssertionError
export type Error = Package.Error
export type Map<T, V> = Package.Map<T, V> 
export type Object = Package.Object
export type PromiseLike<T> = Package.PromiseLike<T> 
export type Promise<T> = Package.Promise<T> 
export type Set<T> = Package.Set<T> 
export type Symbol = Package.Symbol
export type Timeout = Package.Timeout
export type Interval = Package.Interval
export type WeakMap<T, V> = Package.WeakMap<T, V> 


return Package
----------------------------------------------------------------------------------------------------
--------------------=[ OUTROS ]=--------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	,FastReload = true					--- Automatically operates the bolt on reload if needed
	,SlideLock = true
	,MoveBolt = false
	,BoltLock = false
	,CanBreachDoor = false
	,CanBreak = true					--- Weapon can jam?
	,JamChance = 800					--- This old piece of brick doesn't work fine >;c
	,IncludeChamberedBullet = true		--- Include the chambered bullet on next reload
	,Chambered = true					--- Start with the gun chambered?
	,LauncherReady = false				--- Start with the GL ready?
	,CanCheckMag = true					--- 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
	,GunFOVReduction = 5

	,BoltExtend = Vector3.new(0, 0, 0.225)
	,SlideExtend = Vector3.new(0, 0, 0.225)
--[[ Controls State Management ]]--
local onControlsChanged = nil
if IsTouchDevice then
	createTouchGuiContainer()
	onControlsChanged = function()
		local newModuleToEnable = nil
		if not IsUserChoice then
			if DevMovementMode == Enum.DevTouchMovementMode.Thumbstick then
				newModuleToEnable = ControlModules.Thumbstick
				isJumpEnabled = true
			elseif DevMovementMode == Enum.DevTouchMovementMode.Thumbpad then
				newModuleToEnable = ControlModules.Thumbpad
				isJumpEnabled = true
			elseif DevMovementMode == Enum.DevTouchMovementMode.DPad then
				newModuleToEnable = ControlModules.DPad
			elseif DevMovementMode == Enum.DevTouchMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = nil
			elseif DevMovementMode == Enum.DevTouchMovementMode.Scriptable then
				newModuleToEnable = nil
			end
		else
			if UserMovementMode == Enum.TouchMovementMode.Default or UserMovementMode == Enum.TouchMovementMode.Thumbstick then
				newModuleToEnable = ControlModules.Thumbstick
				isJumpEnabled = true
			elseif UserMovementMode == Enum.TouchMovementMode.Thumbpad then
				newModuleToEnable = ControlModules.Thumbpad
				isJumpEnabled = true
			elseif UserMovementMode == Enum.TouchMovementMode.DPad then
				newModuleToEnable = ControlModules.DPad
			elseif UserMovementMode == Enum.TouchMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = nil
			end
		end
		setClickToMove()
		if newModuleToEnable ~= CurrentControlModule then
			if CurrentControlModule then
				CurrentControlModule:Disable()
			end
			setJumpModule(isJumpEnabled)
			CurrentControlModule = newModuleToEnable
			if CurrentControlModule and not IsModalEnabled then
				CurrentControlModule:Enable()
				if isJumpEnabled then TouchJumpModule:Enable() end
			end
		end
	end
elseif UserInputService.KeyboardEnabled then
	onControlsChanged = function()
		-- NOTE: Click to move still uses keyboard. Leaving cases in case this ever changes.
		local newModuleToEnable = nil
		if not IsUserChoice then
			if DevMovementMode == Enum.DevComputerMovementMode.KeyboardMouse then
				newModuleToEnable = ControlModules.Keyboard
			elseif DevMovementMode == Enum.DevComputerMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = ControlModules.Keyboard
			end 
		else
			if UserMovementMode == Enum.ComputerMovementMode.KeyboardMouse or UserMovementMode == Enum.ComputerMovementMode.Default then
				newModuleToEnable = ControlModules.Keyboard
			elseif UserMovementMode == Enum.ComputerMovementMode.ClickToMove then
				-- Managed by CameraScript
				newModuleToEnable = ControlModules.Keyboard
			end
		end
		if newModuleToEnable ~= CurrentControlModule then
			if CurrentControlModule then
				CurrentControlModule:Disable()
			end
			CurrentControlModule = newModuleToEnable
			if CurrentControlModule then
				CurrentControlModule:Enable()
			end
		end
	end
elseif UserInputService.GamepadEnabled then
	onControlsChanged = function()
		-- nil for now, probably needs some stuff later
	end
end
--		print("2!!!",hum.Health)
		if hum.Health<1 then return end
	end
	
	if string.upper(Type) == "AOE" then
		-- AoE
		explosion = Instance.new("Explosion")
		explosion.Position = bullet.Position
		explosion.ExplosionType = ("NoCraters")
		-- 		find instigator tag
		--local creator = script.Parent:findFirstChild("creator")
		--if creator ~= nil then
		--	explosion.Hit:connect(function(part, distance)  onPlayerBlownUp(part, distance, creator) end)
		--end
		explosion.Parent = game.Workspace		
	else -- SINGLE
		local hum = hit.Parent:FindFirstChild("Humanoid")
	    if hum~= nil then
	        hum:TakeDamage(damage)
	    end
	end
	
	connection:disconnect()
	wait(.1)
	bullet:remove()
end
-- TODO: Optimize for vertical faces
function BitOps.getConnectivityForFace(connectivity, face)
	local result = 0

	local bitIndexes = BitOps.CONNECTIVITY_INDEXES_FOR_FACE[tostring(BitOps.normalizeVec3(face))]
	for _, index in ipairs(bitIndexes) do
		result = bit32.lshift(result, 1)
		result = bit32.bor(result, bit32.extract(connectivity, index))
	end

	return result
end

function BitOps.getVerticalFaceFromOccupancy(occupancy)
	local horizontalFace
	for _, face in pairs(BitOps.FACES) do
		horizontalFace = face.Y ~= 0
		if not horizontalFace and occupancy == BitOps.OCCUPANCY_FACE_MASK[tostring(face)] then
			return face
		end
	end

	return false
end

function BitOps.applyFaceOccupancy(targetOccupancy, targetFace, appliedOccupancy, appliedFace)
	local appliedOccupancyFaceBit = bit32.extract(appliedOccupancy, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(appliedFace))])
	if appliedOccupancyFaceBit == 1 then
		targetOccupancy =
			bit32.replace(targetOccupancy, appliedOccupancyFaceBit, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(targetFace))])
	end

	return targetOccupancy
end

function BitOps.removeFaceOccupancy(targetOccupancy, targetFace, appliedOccupancy, appliedFace)
	local appliedOccupancyFaceBit = bit32.extract(appliedOccupancy, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(appliedFace))])
	if appliedOccupancyFaceBit == 1 then
		targetOccupancy =
		bit32.replace(targetOccupancy, 0, BitOps.OCCUPANCY_INDEX_FOR_FACE[tostring(BitOps.normalizeVec3(targetFace))])
	end

	return targetOccupancy
end

function BitOps.applyFaceConnectivity(targetConnectivity, targetFace, appliedConnectivity, appliedFace)
	local appliedConnectivityFaceBits = BitOps.getConnectivityForFace(appliedConnectivity, appliedFace)
	local targetConnectivityFaceBits = BitOps.getConnectivityForFace(targetConnectivity, targetFace)
	local newTargetConnectivityFaceBits = bit32.bor(targetConnectivityFaceBits, appliedConnectivityFaceBits)

	targetConnectivity = BitOps.setFaceConnectivity(targetConnectivity, targetFace, newTargetConnectivityFaceBits)

	return targetConnectivity
end
--//Setup//--
Humanoid:SetStateEnabled(Enum.HumanoidStateType.Swimming, false)
--Remove with FFlagPlayerScriptsBindAtPriority
function BaseCamera:OnKeyDown(input, processed)
	if not self.hasGameLoaded and VRService.VREnabled then
		return
	end

	if processed then
		return
	end

	if self.distanceChangeEnabled then
		if input.KeyCode == Enum.KeyCode.I then
			self:SetCameraToSubjectDistance( self.currentSubjectDistance - 5 )
		elseif input.KeyCode == Enum.KeyCode.O then
			self:SetCameraToSubjectDistance( self.currentSubjectDistance + 5 )
		end
	end

	if self.panBeginLook == nil and self.keyPanEnabled then
		if input.KeyCode == Enum.KeyCode.Left then
			self.turningLeft = true
		elseif input.KeyCode == Enum.KeyCode.Right then
			self.turningRight = true
		elseif input.KeyCode == Enum.KeyCode.Comma then
			local angle = Util.RotateVectorByAngleAndRound(self:GetCameraLookVector() * Vector3.new(1,0,1), -math.pi*0.1875, math.pi*0.25)
			if angle ~= 0 then
				self.rotateInput = self.rotateInput + Vector2.new(angle, 0)
				self.lastUserPanCamera = tick()
				self.lastCameraTransform = nil
			end
		elseif input.KeyCode == Enum.KeyCode.Period then
			local angle = Util.RotateVectorByAngleAndRound(self:GetCameraLookVector() * Vector3.new(1,0,1), math.pi*0.1875, math.pi*0.25)
			if angle ~= 0 then
				self.rotateInput = self.rotateInput + Vector2.new(angle, 0)
				self.lastUserPanCamera = tick()
				self.lastCameraTransform = nil
			end
		elseif input.KeyCode == Enum.KeyCode.PageUp then
			self.rotateInput = self.rotateInput + Vector2.new(0,math.rad(15))
			self.lastCameraTransform = nil
		elseif input.KeyCode == Enum.KeyCode.PageDown then
			self.rotateInput = self.rotateInput + Vector2.new(0,math.rad(-15))
			self.lastCameraTransform = nil
		end
	end
end
--Purchase and receive gamepasses
main.marketplaceService.PromptGamePassPurchaseFinished:Connect(function(player,assetId,isPurchased)
	local pdata = main.pd[player]
	if isPurchased and pdata then
		local validGamepass = main.permissions.gamepasses[tostring(assetId)]
		if validGamepass and not main:GetModule("cf"):FindValue(pdata.Gamepasses, assetId) then
			main:GetModule("PlayerData"):InsertStat(player, "Gamepasses", assetId)
			main:GetModule("cf"):RankPlayerSimple(player, validGamepass.Rank)
			if not main:GetModule("cf"):FindValue(main.products, assetId) then
				main:GetModule("cf"):FormatAndFireNotice(player, "UnlockRank", main:GetModule("cf"):GetRankName(validGamepass.Rank))
			end
			main:GetModule("cf"):CheckAndRankToDonor(player, pdata, assetId)
		end
	end
end)




return module
--	====================
--	CAMERA SHAKING
--	Make user's camera shaking when shooting
--	====================

		CameraShakingEnabled = true;
		Intensity = 0.5; --In degree
-- Set up the event handler for the GClippsly button
btn.MouseButton1Click:Connect(toggleWindow)