Roblox/luau_corpus huggingface dataset:
--// Loccalllsssss
local _G, game, script, getfenv, setfenv, workspace,
getmetatable, setmetatable, loadstring, coroutine,
rawequal, typeof, print, math, warn, error,  pcall,
xpcall, select, rawset, rawget, ipairs, pairs,
next, Rect, Axes, os, time, Faces, unpack, string, Color3,
newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
NumberSequenceKeypoint, PhysicalProperties, Region3int16,
Vector3int16, require, table, type, wait,
Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, delay, spawn, task, tick, assert =
	_G, game, script, getfenv, setfenv, workspace,
	getmetatable, setmetatable, loadstring, coroutine,
	rawequal, typeof, print, math, warn, error,  pcall,
	xpcall, select, rawset, rawget, ipairs, pairs,
	next, Rect, Axes, os, time, Faces, unpack, string, Color3,
	newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
	NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
	NumberSequenceKeypoint, PhysicalProperties, Region3int16,
	Vector3int16, require, table, type, task.wait,
Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, task.delay, task.defer, task, tick, function(cond, errMsg) return cond or error(errMsg or "assertion failed!", 2) end;

local ServicesWeUse = {
	"Workspace";
	"Players";
	"Lighting";
	"ReplicatedStorage";
	"ReplicatedFirst";
	"ScriptContext";
	"JointsService";
	"LogService";
	"Teams";
	"SoundService";
	"StarterGui";
	"StarterPack";
	"StarterPlayers";
	"TestService";
	"NetworkClient";
};
------------------------------------------------------------------------
--
-- * used only in (lparser) luaY:subexpr()
------------------------------------------------------------------------
function luaK:infix(fs, op, v)
  if op == "OPR_AND" then
    self:goiftrue(fs, v)
  elseif op == "OPR_OR" then
    self:goiffalse(fs, v)
  elseif op == "OPR_CONCAT" then
    self:exp2nextreg(fs, v)  -- operand must be on the 'stack'
  elseif op == "OPR_ADD" or op == "OPR_SUB" or
         op == "OPR_MUL" or op == "OPR_DIV" or
         op == "OPR_MOD" or op == "OPR_POW" then
    if not self:isnumeral(v) then self:exp2RK(fs, v) end
  else
    self:exp2RK(fs, v)
  end
end
--[[Susupension]]
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled
	
	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 7000		-- Spring Force
	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FSusMaxExt		= .3		-- Max Extension Travel (in studs)
	Tune.FSusMaxComp	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	
	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 7000		-- Spring Force
	Tune.RSusLength		= 2			-- Suspension length (in studs)
	Tune.RSusMaxExt		= .3		-- Max Extension Travel (in studs)
	Tune.RSusMaxComp	= .1		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics	
	Tune.SusVisible		= true			-- Spring Visible
	Tune.WsBVisible		= false			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Really black"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness
--script.Parent.Parent.Mover2.part.Anchored = true
script.Parent.Parent.Mover2.part.PrismaticConstraint.Speed = 0
script.Parent.Parent.Mover2.part.PrismaticConstraint.TargetPosition = script.Parent.Parent.Mover1.part.PrismaticConstraint.CurrentPosition
wait(1)
script.Parent.Parent.Grabber.Claw.Drop.Disabled = false
script.Disabled = true
-- called to check for dead connections and run their cleanup tasks
local function runCleanupTasks()
	if numTasks == 0 then
		return
	end

	-- we want to clean as much stuff up as possible, but we don't want to hang
	-- the client, so we forcibly terminate after a short while
	local startTime = os.clock()
	local endTime = startTime + 1/1000

	-- run at most `numTask` times
	for _=1, numTasks do
		local taskData = tasks[currentIndex]

		if taskData.connection.Connected then
			-- instance is still alive, so move on to the next task
			currentIndex += 1
		else
			-- instance destroyed, so run cleanup and remove the task
			taskData.cleaned = true
			-- print("cleaning up", taskData.debugName)
			cleanup(taskData.task)

			table.remove(tasks, currentIndex)
			numTasks -= 1
		end

		-- wrap around if we passed the end of the task list
		if currentIndex > numTasks then
			currentIndex = 1
		end

		-- if this took too long, exit early to avoid hanging
		if os.clock() > endTime then
			break
		end
	end
end

RunService.Heartbeat:Connect(runCleanupTasks)

local function cleanupOnDestroy(instance: Instance?, task: cleanup.Task): (() -> ())
	-- set up connection so we can check if the instance is alive
	-- we don't care about the event we're connecting to, just that we can see
	-- when it's disconnected by the garbage collector
	local connection = (instance :: Instance):GetPropertyChangedSignal("ClassName"):Connect(noOp)

	-- store data about the task for later
	local taskData = {
		connection = connection,
		task = task,
		cleaned = false
	}

	-- remove instance reference so we don't accidentally inhibit gc
	instance = nil

	-- add task to list
	numTasks += 1
	tasks[numTasks] = taskData

	-- return disconnect function to stop listening for destroy
	return function()
		if taskData.cleaned then
			return
		end

		taskData.cleaned = true
		connection:Disconnect()

		local index = table.find(tasks, taskData)
		if index ~= nil then
			table.remove(tasks, index)
			numTasks -= 1
		end
	end
end

return cleanupOnDestroy
--[=[
	Round the given number to given precision

	```lua
	print(Math.round(72.1, 5)) --> 75
	```

	@param number number
	@param precision number? -- Defaults to 1
	@return number
]=]
function Math.round(number: number, precision: number?): number
	if precision then
		return math.floor((number/precision) + 0.5) * precision
	else
		return math.floor(number + 0.5)
	end
end
--[=[
	@tag Component Class
	`Start` is called when the component is started. At this point in time, it
	is safe to grab other components also bound to the same instance.

	```lua
	local MyComponent = Component.new({Tag = "MyComponent"})
	local AnotherComponent = require(somewhere.AnotherComponent)

	function MyComponent:Start()
		-- e.g., grab another component:
		local another = self:GetComponent(AnotherComponent)
	end
	```
]=]
function Component:Start() end
-- declarations

local sFallingDown = newSound("rbxasset://sounds/splat.wav")
local sGettingUp = newSound("rbxasset://sounds/action_get_up.mp3")
local sDied = newSound("rbxasset://sounds/uuhhh.mp3") 
local sFreeFalling = newSound("rbxasset://sounds/action_falling.mp3")
local sJumping = newSound("rbxasset://sounds/action_jump.mp3")
local sLanding = newSound("rbxasset://sounds/action_jump_land.mp3")
local sSplash = newSound("rbxasset://sounds/impact_water.mp3")
local sRunning = newSound("rbxasset://sounds/action_footsteps_plastic.mp3")
sRunning.Looped = true
local sSwimming = newSound("rbxasset://sounds/action_swim.mp3")
sSwimming.Looped = true
local sClimbing = newSound("rbxasset://sounds/action_footsteps_plastic.mp3")
sClimbing.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")

local prevState = "None"
-- Carregue a animação do ReplicatedStorage
local rp = game:GetService("ReplicatedStorage")
local viewmodel = rp.Main.bracos.braco_usp
viewmodel.Parent = workspace.Camera

local idleAnimation = viewmodel.AnimSaves.idle
----------------------------------------------------------------------------------------------------
--------------------=[ CFRAME ]=--------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	,EnableHolster = true
	,HolsterTo = 'Torso'				 -- Put the name of the body part you wanna holster to
	,HolsterPos = CFrame.new(1.2, -1, 0.1) * CFrame.Angles(math.rad(-110), math.rad(0), math.rad(0))

	,RightArmPos = CFrame.new(-0.575, 0.65, -1.185) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Server
	,LeftArmPos = CFrame.new(1.15,-0.1,-1.65) * CFrame.Angles(math.rad(-120),math.rad(20),math.rad(-25))	--server

	,ServerGunPos = CFrame.new(-.3, -1, -0.4) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))
	,GunPos = CFrame.new(0.15, -0.15, 1) * CFrame.Angles(math.rad(90), math.rad(0), math.rad(0))

	,RightPos = CFrame.new(-0.3,.4, -.6) * CFrame.Angles(math.rad(-90), math.rad(0), math.rad(0))	--Client
	,LeftPos = CFrame.new(.3,-0.2,-1.35) * CFrame.Angles(math.rad(-130),math.rad(20),math.rad(10))	--Client
}

return Config
--// Body Parts
local L_11_ = L_2_:WaitForChild('Humanoid')
local L_12_ = L_2_:WaitForChild('HumanoidRootPart')
local L_13_ = L_2_:WaitForChild('Head')
-- Detect when prompt is triggered
local function onPromptTriggered(promptObject, player)
	ObjectActions.promptTriggeredActions(promptObject, player)
end
--- Add a task to clean up. Tasks given to a maid will be cleaned when
--  maid[index] is set to a different value.
-- @usage
-- Maid[key] = (function)         Adds a task to perform
-- Maid[key] = (event connection) Manages an event connection
-- Maid[key] = (Maid)             Maids can act as an event connection, allowing a Maid to have other maids to clean up.
-- Maid[key] = (Object)           Maids can cleanup objects with a `Destroy` method
-- Maid[key] = nil                Removes a named task. If the task is an event, it is disconnected. If it is an object,
--                                it is destroyed.
function Maid:__newindex(index, newTask)
	if Maid[index] ~= nil then
		error(("'%s' is reserved"):format(tostring(index)), 2)
	end

	local tasks = self._tasks
	local oldTask = tasks[index]

	if oldTask == newTask then
		return
	end

	tasks[index] = newTask

	if oldTask then
		if type(oldTask) == "function" then
			oldTask()
		elseif typeof(oldTask) == "RBXScriptConnection" then
			oldTask:Disconnect()
		elseif oldTask.Destroy then
			oldTask:Destroy()
		end
	end
end
-- slash1
Attack(target,structureDamage)
end
wait(.3)
end
end

else
if not enRoute then
wait(math.random(1,4))
if not target then
ScanForPoint()
end
end

end

wait()
end -- end of loop
end)
movementCoroutine()

local scanCoroutine = coroutine.wrap(function()
while task.wait(3) do
local nearestPlayer,closestPlayerDist = nil,60
local nearestBuilding,closestBuildingDist = nil, 100

for _,player in next,game.Players:GetPlayers() do
if player.Character and player.Character:IsDescendantOf(workspace) then
local pos = player.Character.PrimaryPart.Position
local dist = (root.Position-pos).magnitude
if dist < closestPlayerDist then
nearestPlayer = player
closestPlayerDist = dist
end
end
game:GetService("RunService").Heartbeat:wait()
end

local structures = _G.worldStructures
for building,buildingData in next,structures do
local dist = (building.PrimaryPart.Position-root.Position).magnitude
if dist < closestBuildingDist then
nearestBuilding = building
closestBuildingDist = dist
end
game:GetService("RunService").Heartbeat:wait()
end

if nearestPlayer and nearestBuilding then
--------LIGHTED RECTANGLES--------

game.Workspace.pillar1.BrickColor = BrickColor.new(194)
game.Workspace.pillar2.BrickColor = BrickColor.new(194)
game.Workspace.pillar3.BrickColor = BrickColor.new(194)
game.Workspace.pillar4.BrickColor = BrickColor.new(194)
game.Workspace.pillar5.BrickColor = BrickColor.new(194)
game.Workspace.pillar6.BrickColor = BrickColor.new(194)
game.Workspace.pillar7.BrickColor = BrickColor.new(194)
game.Workspace.pillar8.BrickColor = BrickColor.new(194)
--[[Tires]]--
-- Tire Curve Profiler: https://www.desmos.com/calculator/og4x1gyzng
Tune.TireCylinders	= 4			-- 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)
--[[
	Converts a yielding function into a Promise-returning one.
]]
function Promise.promisify(callback)
	return function(...)
		return Promise._try(debug.traceback(nil, 2), callback, ...)
	end
end
Promise.Promisify = Promise.promisify
-- Adds verbose console logging for e.g. state updates, suspense, and work loop stuff.
-- Intended to enable React core members to more easily debug scheduling issues in DEV builds.
exports.enableDebugTracing = false
--[[Manage Plugins]]
	
script.Parent.Interface:WaitForChild("Bike").Value=bike
for i,v in pairs(script.Parent.Plugins:GetChildren()) do
	for _,a in pairs(v:GetChildren()) do
		if a:IsA("RemoteEvent") or a:IsA("RemoteFunction") then 
			a.Parent=bike
			for _,b in pairs(a:GetChildren()) do
				if b:IsA("Script") then b.Disabled=false end
			end	
		end
	end
	v.Parent = script.Parent.Interface
end
script.Parent.Plugins:Destroy()
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local _Tune = require(car["A-Chassis Tune"])
local on = 0


script:WaitForChild("Wheel")

if not FE then
	for i,v in pairs(car.Body.WHEEL:GetChildren()) do
		for _,a in pairs(script:GetChildren()) do
			if v.Name==a.Name then v:Stop() wait() v:Destroy() end
		end
	end
	for i,v in pairs(script:GetChildren()) do
		v.Parent=car.Body.WHEEL
	end
	
	
	car.Body.WHEEL.Wheel:Play()
	
	while wait() do
		local _RPM = script.Parent.Values.RPM.Value
		
		if not car.DriveSeat.IsOn.Value then on=math.max(on-.015,0) else on=1 end
		
car.Body.WHEEL.Wheel.Pitch = (car.Body.WHEEL.Wheel.SetPitch.Value + car.Body.WHEEL.Wheel.SetRev.Value*_RPM/_Tune.Redline)*on^2

		if _RPM == 700 then
	
			car.Body.WHEEL.Wheel.Volume = 0.1
	
			
		end

	end
else
	local handler = car.AC6_FE_Sounds
	
	handler:FireServer("newSound","Wheel",car.Body.WHEEL,script.Wheel.SoundId,0,script.Wheel.Volume,true)
	handler:FireServer("playSound","Wheel")
	
	local pitch4=0
	while wait() do
		local _RPM = script.Parent.Values.RPM.Value
		
		if not car.DriveSeat.IsOn.Value then on=math.max(on-.015,0) else on=1 end
		
		pitch4 = (script.Wheel.SetPitch.Value + script.Wheel.SetRev.Value*_RPM/_Tune.Redline)*on^2
	
		handler:FireServer("updateSound","Wheel",script.idle.SoundId,pitch4,script.Wheel.Volume)
	end
end
-- Decompiled with the Synapse X Luau decompiler.

local l__LocalPlayer__1 = game.Players.LocalPlayer;
local v2 = {};
local l__LocalPlayer__3 = game.Players.LocalPlayer;
local v4 = require(game:GetService("ReplicatedStorage"):WaitForChild("ReplicaDataModule"));
v2.value = 250;
v2.event = v4.event.Boosts;
v4.event.Boosts.Event:connect(function(p1)
	if type(p1) == "number" then
		v2.value = p1;
		return;
	end;
	v2.value = 250;
end);
v2.value = v4.data.Boosts;
return v2;
--// Connections
L_108_.OnClientEvent:connect(function(L_191_arg1, L_192_arg2, L_193_arg3, L_194_arg4, L_195_arg5, L_196_arg6, L_197_arg7)
	if L_191_arg1 and not L_15_ then
		MakeFakeArms()
		
		L_42_ = L_2_.PlayerGui.MainGui
		L_26_ = L_42_:WaitForChild('Others')
		L_27_ = L_26_:WaitForChild('Kill')
		L_28_ = L_42_:WaitForChild('GameGui'):WaitForChild('AmmoFrame')
		L_29_ = L_28_:WaitForChild('Ammo')
		L_30_ = L_28_:WaitForChild('AmmoBackground')
		L_31_ = L_28_:WaitForChild('MagCount')
		L_32_ = L_28_:WaitForChild('MagCountBackground')
		L_33_ = L_28_:WaitForChild('DistDisp')
		L_34_ = L_28_:WaitForChild('Title')
		L_35_ = L_28_:WaitForChild('Mode1')
		L_36_ = L_28_:WaitForChild('Mode2')
		L_37_ = L_28_:WaitForChild('Mode3')
		L_38_ = L_28_:WaitForChild('Mode4')
		L_39_ = L_28_:WaitForChild('Mode5')
		L_40_ = L_28_:WaitForChild('Stances')
		L_41_ = L_42_:WaitForChild('Shading')
		L_41_.Visible = false
		
		L_34_.Text = L_1_.Name
		UpdateAmmo()
		
		L_43_ = L_192_arg2
		L_44_ = L_193_arg3
		L_45_ = L_194_arg4
		L_46_ = L_195_arg5
		L_47_ = L_196_arg6
		L_48_ = L_197_arg7	
		L_49_ = L_62_.Bolt
		
		L_87_ = L_48_.C1
		L_88_ = L_48_.C0
		
		if L_1_:FindFirstChild('AimPart2') then
			L_57_ = L_1_:WaitForChild('AimPart2')
		end
		
		if L_1_:FindFirstChild('FirePart2') then
			L_60_ = L_1_.FirePart2
		end
		
		if L_24_.FirstPersonOnly then
			L_2_.CameraMode = Enum.CameraMode.LockFirstPerson
		end
		--uis.MouseIconEnabled = false
		L_5_.FieldOfView = 70
		L_15_ = true
	elseif L_15_ then
		if L_3_ and L_3_.Humanoid and L_3_.Humanoid.Health > 0 and L_9_ then
			Stand()
			Unlean()
		end	
		
		L_93_ = 0
		L_80_ = false
		L_81_ = false
		L_82_ = false
		L_64_ = false
		L_67_ = false
		L_66_ = false
		Shooting = false
		
		L_97_ = 70
		
		RemoveArmModel()
		
		L_42_:Destroy()	
		
		for L_198_forvar1, L_199_forvar2 in pairs(IgnoreList) do
			if L_199_forvar2 ~= L_3_ and L_199_forvar2 ~= L_5_ and L_199_forvar2 ~= L_101_ then
				table.remove(IgnoreList, L_198_forvar1)
			end
		end
		
		if L_3_:FindFirstChild('Right Arm') and L_3_:FindFirstChild('Left Arm') then
			L_3_['Right Arm'].LocalTransparencyModifier = 0
			L_3_['Left Arm'].LocalTransparencyModifier = 0
		end	

		L_78_ = false
		L_69_ = true
		
		L_2_.CameraMode = Enum.CameraMode.Classic
		L_107_.MouseIconEnabled = true		
		L_5_.FieldOfView = 70
		L_15_ = false
		L_107_.MouseDeltaSensitivity = L_52_
		L_4_.Icon = ""
		L_15_ = false
		L_4_.TargetFilter = nil
	end
end)
--Make sure players stay banned.
	
local DataStore = game:GetService("DataStoreService"):GetDataStore("motfAdminPanel")
function checkBan(player)	
	
	local Reason = DataStore:GetAsync(string.lower(player.Name))
	
	if Reason == nil or Reason == 0 then
		return
	end
	
	wait(1)
	if Reason == 1 then
		player:Kick("You are banned")
	else
		player:Kick("You are banned for the following reason: " .. Reason)
	end
end

game.Players.PlayerAdded:connect(checkBan)
--redgreen -xmas
script.Parent.Color = randval2 --Color3.new(math.random(), math.random(), math.random()) 
wait(0.5)
script.Parent.Color = randval1 --Color3.new(math.random(), math.random(), math.random()) 
wait(0.5)
mode9()
end

function mode10()
--print(GBCF(n.CFrame,v[1].p))
pcall(function() n.CFrame = GBCF(n.CFrame,v[1].p)*(v[1]-v[1].p) end)
end
end
wait()
end
end
Finished = Finished+1
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 1 -- cooldown for use of the tool again

BoneModelName = "Fork" -- name the zone model

HumanoidName = "Humanoid"-- the name of player or mob u want to damage
-- A very simple module that only gives the included tools to people inside of the groupID.
-- Just place the

local module = {}

local function dostuff(p, core)
	--print("new player")
	local rank = core.getPlayerRank(p)
	--print(rank)
	if rank ~= 0 then
		p.CharacterAdded:Connect(function()
			--print("new char")
			for i, v in pairs(script:GetChildren()) do
				v:Clone().Parent = p.Backpack
			end
		end)
		-- for first spawn
		--print("first spawn")
		for i, v in pairs(script:GetChildren()) do
			v:Clone().Parent = p.Backpack
		end
	end
end

function module.loadServer(core)
	--print(core)
	game:GetService("Players").PlayerAdded:Connect(function(p)
		dostuff(p, core)
	end)
	
	for i, v in pairs(game:GetService("Players"):GetChildren()) do -- first load
		dostuff(v, core)
	end
end

return module
--//=================================\\
--|| 			FUNCTIONS
--\\=================================//

function CreatePart(FORMFACTOR, PARENT, MATERIAL, REFLECTANCE, TRANSPARENCY, BRICKCOLOR, NAME, SIZE, ANCHOR)
	local NEWPART = IT("Part")
	NEWPART.formFactor = FORMFACTOR
	NEWPART.Reflectance = REFLECTANCE
	NEWPART.Transparency = TRANSPARENCY
	NEWPART.CanCollide = false
	NEWPART.Locked = true
	NEWPART.Anchored = true
	if ANCHOR == false then
		NEWPART.Anchored = false
	end
	NEWPART.BrickColor = BRICKC(tostring(BRICKCOLOR))
	NEWPART.Name = NAME
	NEWPART.Size = SIZE
	NEWPART.Position = TORSO.Position
	NEWPART.Material = MATERIAL
	NEWPART:BreakJoints()
	NEWPART.Parent = PARENT
	return NEWPART
end

function Raycast(POSITION, DIRECTION, RANGE, IGNOREDECENDANTS)
	return workspace:FindPartOnRay(Ray.new(POSITION, DIRECTION.unit * RANGE), IGNOREDECENDANTS)
end
--I M P O R T A N T--
------------------------------------------------------------------------
--Don't change any of this unless you know what you are doing.
--This script is the blur affect but also the exit button script.
------------------------------------------------------------------------

local blur = game.Lighting.Blur
local frame = script.Parent
local close = script.Parent.CloseButton

if 
	frame.Visible == true
then
	blur.Enabled = true
end

close.MouseButton1Click:Connect(function()
	frame.Visible = false
end)

close.MouseButton1Click:Connect(function()
	blur.Enabled = false
end)
-- Public Functions

function PlayerManager:SetGameRunning(running)
	GameRunning = running
end

function PlayerManager:ClearPlayerScores()
	for _, player in ipairs(Players:GetPlayers()) do
		local leaderstats = player:FindFirstChild('leaderstats')
		if leaderstats then
			local Captures = leaderstats:FindFirstChild('Captures')
			if Captures then
				Captures.Value = 0
			end
		end
	end
end

function PlayerManager:LoadPlayers()
	for _, player in ipairs(Players:GetPlayers()) do
		player:LoadCharacter()
	end
end

function PlayerManager:AllowPlayerSpawn(allow)
	PlayersCanSpawn = allow
end

function PlayerManager:DestroyPlayers()
	for _, player in ipairs(Players:GetPlayers()) do
		player.Character:Destroy()
		for _, item in ipairs(player.Backpack:GetChildren()) do
			item:Destroy()
		end
	end
	ResetMouseIcon:FireAllClients()
end

function PlayerManager:AddPlayerScore(player, score)
	player.leaderstats.Captures.Value = player.leaderstats.Captures.Value + score
	local success, message = pcall(function() spawn(function() PointsService:AwardPoints(player.userId, score) end) end)
end
--
TCS.OnIncomingMessage = function(Msg)
	if Msg.Metadata then
		local overrideProperties = Instance.new("TextChatMessageProperties")
		overrideProperties.Text = Msg.Text
		return overrideProperties
	else
		-- do nothing
		return nil
	end
end
--[=[
	Provide a variety of utility table operations
	@class Table
]=]

local Table = {}
-- Tell owner to show footsteps
game.ReplicatedStorage.Interactions.Client.Perks.UseXRay:FireClient(script.Owner.Value)
-- Inject types
local TypeDefs = require(script.Parent.TypeDefinitions)
type CanPenetrateFunction = TypeDefs.CanPenetrateFunction
type CanHitFunction = TypeDefs.CanHitFunction
type GenericTable = TypeDefs.GenericTable
type Caster = TypeDefs.Caster
type FastCastBehavior = TypeDefs.FastCastBehavior
type CastTrajectory = TypeDefs.CastTrajectory
type CastStateInfo = TypeDefs.CastStateInfo
type CastRayInfo = TypeDefs.CastRayInfo
type ActiveCast = TypeDefs.ActiveCast

local TestService = game:GetService("TestService")
local table = require(script.Parent.Table)

local SignalStatic = {}
SignalStatic.__index = SignalStatic
SignalStatic.__type = "Signal" -- For compatibility with TypeMarshaller
local ConnectionStatic = {}
ConnectionStatic.__index = ConnectionStatic
ConnectionStatic.__type = "SignalConnection" -- For compatibility with TypeMarshaller

export type Signal = {
	Name: string,
	Connections: {[number]: Connection},
	YieldingThreads: {[number]: BindableEvent}
}

export type Connection = {
	Signal: Signal?,
	Delegate: any,
	Index: number	
}