Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local v1, v2 = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserRemoveMessageOnTextFilterFailures");
end);
local v3 = {
	ScrollBarThickness = 4
};
local l__Parent__4 = script.Parent;
local v5 = {};
v5.__index = v5;
local u1 = require(game:GetService("Chat"):WaitForChild("ClientChatModules"):WaitForChild("ChatSettings"));
function v5.Destroy(p1)
	p1.GuiObject:Destroy();
	p1.Destroyed = true;
end;
function v5.SetActive(p2, p3)
	p2.GuiObject.Visible = p3;
end;
local u2 = v1 or v2;
function v5.UpdateMessageFiltered(p4, p5)
	local v6 = nil;
	local v7 = 1;
	local l__MessageObjectLog__8 = p4.MessageObjectLog;
	while v7 <= #l__MessageObjectLog__8 do
		local v9 = l__MessageObjectLog__8[v7];
		if v9.ID == p5.ID then
			v6 = v9;
			break;
		end;
		v7 = v7 + 1;
	end;
	if v6 then
		if not u2 then
			v6.UpdateTextFunction(p5);
			p4:PositionMessageLabelInWindow(v6, v7);
			return;
		end;
	else
		return;
	end;
	if p5.Message == "" then
		p4:RemoveMessageAtIndex(v7);
		return;
	end;
	v6.UpdateTextFunction(p5);
	p4:PositionMessageLabelInWindow(v6, v7);
end;
local u3 = require(l__Parent__4:WaitForChild("MessageLabelCreator")).new();
function v5.AddMessage(p6, p7)
	p6:WaitUntilParentedCorrectly();
	local v10 = u3:CreateMessageLabel(p7, p6.CurrentChannelName);
	if v10 == nil then
		return;
	end;
	table.insert(p6.MessageObjectLog, v10);
	p6:PositionMessageLabelInWindow(v10, #p6.MessageObjectLog);
end;
function v5.RemoveMessageAtIndex(p8, p9)
	p8:WaitUntilParentedCorrectly();
	local v11 = p8.MessageObjectLog[p9];
	if v11 then
		v11:Destroy();
		table.remove(p8.MessageObjectLog, p9);
	end;
end;
function v5.AddMessageAtIndex(p10, p11, p12)
	local v12 = u3:CreateMessageLabel(p11, p10.CurrentChannelName);
	if v12 == nil then
		return;
	end;
	table.insert(p10.MessageObjectLog, p12, v12);
	p10:PositionMessageLabelInWindow(v12, p12);
end;
function v5.RemoveLastMessage(p13)
	p13:WaitUntilParentedCorrectly();
	p13.MessageObjectLog[1]:Destroy();
	table.remove(p13.MessageObjectLog, 1);
end;
function v5.IsScrolledDown(p14)
	local l__Offset__13 = p14.Scroller.CanvasSize.Y.Offset;
	local l__Y__14 = p14.Scroller.AbsoluteWindowSize.Y;
	local v15 = true;
	if not (l__Offset__13 < l__Y__14) then
		v15 = l__Offset__13 - p14.Scroller.CanvasPosition.Y <= l__Y__14 + 5;
	end;
	return v15;
end;
function v5.UpdateMessageTextHeight(p15, p16)
	local l__BaseFrame__16 = p16.BaseFrame;
	for v17 = 1, 10 do
		if p16.BaseMessage.TextFits then
			break;
		end;
		l__BaseFrame__16.Size = UDim2.new(1, 0, 0, p16.GetHeightFunction(p15.Scroller.AbsoluteSize.X - v17));
	end;
end;
function v5.PositionMessageLabelInWindow(p17, p18, p19)
	p17:WaitUntilParentedCorrectly();
	local l__BaseFrame__18 = p18.BaseFrame;
	local v19 = 1;
	if p17.MessageObjectLog[p19 - 1] then
		if p19 == #p17.MessageObjectLog then
			v19 = p17.MessageObjectLog[p19 - 1].BaseFrame.LayoutOrder + 1;
		else
			v19 = p17.MessageObjectLog[p19 - 1].BaseFrame.LayoutOrder;
		end;
	end;
	l__BaseFrame__18.LayoutOrder = v19;
	l__BaseFrame__18.Size = UDim2.new(1, 0, 0, p18.GetHeightFunction(p17.Scroller.AbsoluteSize.X));
	l__BaseFrame__18.Parent = p17.Scroller;
	if p18.BaseMessage then
		p17:UpdateMessageTextHeight(p18);
	end;
	if p17:IsScrolledDown() then
		p17.Scroller.CanvasPosition = Vector2.new(0, math.max(0, p17.Scroller.CanvasSize.Y.Offset - p17.Scroller.AbsoluteSize.Y));
	end;
end;
function v5.ReorderAllMessages(p20)
	p20:WaitUntilParentedCorrectly();
	if p20.GuiObject.AbsoluteSize.Y < 1 then
		return;
	end;
	for v20, v21 in pairs(p20.MessageObjectLog) do
		p20:UpdateMessageTextHeight(v21);
	end;
	if not p20:IsScrolledDown() then
		p20.Scroller.CanvasPosition = p20.Scroller.CanvasPosition;
		return;
	end;
	p20.Scroller.CanvasPosition = Vector2.new(0, math.max(0, p20.Scroller.CanvasSize.Y.Offset - p20.Scroller.AbsoluteSize.Y));
end;
function v5.Clear(p21)
	for v22, v23 in pairs(p21.MessageObjectLog) do
		v23:Destroy();
	end;
	p21.MessageObjectLog = {};
end;
function v5.SetCurrentChannelName(p22, p23)
	p22.CurrentChannelName = p23;
end;
function v5.FadeOutBackground(p24, p25)

end;
function v5.FadeInBackground(p26, p27)

end;
local u4 = require(l__Parent__4:WaitForChild("CurveUtil"));
function v5.FadeOutText(p28, p29)
	for v24 = 1, #p28.MessageObjectLog do
		if p28.MessageObjectLog[v24].FadeOutFunction then
			p28.MessageObjectLog[v24].FadeOutFunction(p29, u4);
		end;
	end;
end;
function v5.FadeInText(p30, p31)
	for v25 = 1, #p30.MessageObjectLog do
		if p30.MessageObjectLog[v25].FadeInFunction then
			p30.MessageObjectLog[v25].FadeInFunction(p31, u4);
		end;
	end;
end;
function v5.Update(p32, p33)
	for v26 = 1, #p32.MessageObjectLog do
		if p32.MessageObjectLog[v26].UpdateAnimFunction then
			p32.MessageObjectLog[v26].UpdateAnimFunction(p33, u4);
		end;
	end;
end;
function v5.WaitUntilParentedCorrectly(p34)
	while not p34.GuiObject:IsDescendantOf(game:GetService("Players").LocalPlayer) do
		p34.GuiObject.AncestryChanged:wait();
	end;
end;
local function u5()
	local v27 = Instance.new("Frame");
	v27.Selectable = false;
	v27.Size = UDim2.new(1, 0, 1, 0);
	v27.BackgroundTransparency = 1;
	local v28 = Instance.new("ScrollingFrame");
	v28.Selectable = u1.GamepadNavigationEnabled;
	v28.Name = "Scroller";
	v28.BackgroundTransparency = 1;
	v28.BorderSizePixel = 0;
	v28.Position = UDim2.new(0, 0, 0, 3);
	v28.Size = UDim2.new(1, -4, 1, -6);
	v28.CanvasSize = UDim2.new(0, 0, 0, 0);
	v28.ScrollBarThickness = v3.ScrollBarThickness;
	v28.Active = true;
	v28.Parent = v27;
	local v29 = Instance.new("UIListLayout");
	v29.SortOrder = Enum.SortOrder.LayoutOrder;
	v29.Parent = v28;
	return v27, v28, v29;
end;
function v3.new()
	local v30 = setmetatable({}, v5);
	v30.Destroyed = false;
	local v31, v32, v33 = u5();
	v30.GuiObject = v31;
	v30.Scroller = v32;
	v30.Layout = v33;
	v30.MessageObjectLog = {};
	v30.Name = "MessageLogDisplay";
	v30.GuiObject.Name = "Frame_" .. v30.Name;
	v30.CurrentChannelName = "";
	v30.GuiObject:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
		spawn(function()
			v30:ReorderAllMessages();
		end);
	end);
	local u6 = true;
	v30.Layout:GetPropertyChangedSignal("AbsoluteContentSize"):Connect(function()
		local l__AbsoluteContentSize__34 = v30.Layout.AbsoluteContentSize;
		v30.Scroller.CanvasSize = UDim2.new(0, 0, 0, l__AbsoluteContentSize__34.Y);
		if u6 then
			v30.Scroller.CanvasPosition = Vector2.new(0, l__AbsoluteContentSize__34.Y - v30.Scroller.AbsoluteWindowSize.Y);
		end;
	end);
	v30.Scroller:GetPropertyChangedSignal("CanvasPosition"):Connect(function()
		u6 = v30:IsScrolledDown();
	end);
	return v30;
end;
return v3;


Prompt: ------ Script: ------

Response:
Button.MouseEnter:Connect(function()
	GuiSounds.Mouse_Hover:Play()
end)

Button.MouseButton1Down:Connect(function()
	GuiSounds.Mouse_ClickedIn:Play()
end)

Button.MouseButton1Up:Connect(function()
	GuiSounds.Mouse_ClickedOut:Play()
end)


Prompt: --Functions--

Response:
UIS.InputBegan:Connect(function(input, isTyping)
	if isTyping then return end
	if input.KeyCode == Enum.KeyCode.X and Debounce == 1 and Enabled == true and Tool.Equip.Value == true and Tool.Active.Value == "None"  then
		ButtonDown = true
		Debounce = 2
		local properties = {FieldOfView = 50}
		local info1 = TweenInfo.new(0.2,Enum.EasingStyle.Sine,Enum.EasingDirection.InOut,0.1)
		local tween = ts:Create(game.Workspace.CurrentCamera,info1,properties)
		tween:Play()
		local ChargeEffect = script.Charge.Particles.Charge1:Clone()
		local Character = Player.Character
		ChargeEffect.Parent = Character.HumanoidRootPart
		ChargeEffect:Emit(25)
		game.Debris:AddItem(ChargeEffect,2)
		local StartSfx = game.ReplicatedStorage["Water Wheel"].Sounds.SwordSFX:Clone() -- Sound Effect
		StartSfx.Parent = Player.Character.HumanoidRootPart
		StartSfx.MaxDistance = 150
		StartSfx.TimePosition = 0
		StartSfx:Play()
		Player.Character.Humanoid.WalkSpeed = 5
		Player.Character.Humanoid.JumpPower = 0

		local CameraShaker = require(game.ReplicatedStorage["Water Wheel"].Modules.CameraShaker)
		local camshake = CameraShaker.new(Enum.RenderPriority.Camera.Value,function(shakeCFrame)
			camera.CFrame = camera.CFrame * shakeCFrame
		end)
		camshake:Start()
		camshake:Shake(CameraShaker.Presets.OldBump)

		script.Wheel:FireServer("Water Wheel", mouse.Hit.Position)
		ButtonDown = true
		local properties = {FieldOfView = 85}
		local info2 = TweenInfo.new(0.25,Enum.EasingStyle.Sine,Enum.EasingDirection.InOut,0.1)
		local tween2 = ts:Create(game.Workspace.CurrentCamera,info2,properties)
		tween2:Play()
		Player.Character.Humanoid.WalkSpeed = 0
		Player.Character.Humanoid.JumpPower = 0
		task.wait(0.5)
		local BV = Instance.new("BodyVelocity")
		BV.MaxForce = Vector3.new(300000,0,300000)
		BV.Parent = c.HumanoidRootPart

		while ButtonDown == true and Player.Character.HumanoidRootPart.Anchored ~= true do
			c.HumanoidRootPart.CFrame = CFrame.new(c.HumanoidRootPart.Position, Vector3.new(mouse.Hit.Position.X,c.HumanoidRootPart.Position.Y,mouse.Hit.Position.Z))
			BV.Velocity = c.HumanoidRootPart.CFrame.lookVector * 80
			RS.Heartbeat:Wait()

		end

		Enabled = true
		BV:Destroy()

	end
end)

UIS.InputEnded:Connect(function(input, IsTyping)
	if IsTyping then return end
	if input.KeyCode == Enum.KeyCode.X and Tool.Equip.Value == true and Tool.Active.Value == "None" and Debounce == 2 and 	ButtonDown == true then
		Debounce = 3

		script.Wheel:FireServer("Stop", mouse.Hit.Position)
		local properties = {FieldOfView = 70}
		local info3 = TweenInfo.new(0.25,Enum.EasingStyle.Sine,Enum.EasingDirection.InOut,0.1)
		local tween3 = ts:Create(game.Workspace.CurrentCamera,info3,properties)
		tween3:Play()
		local CameraShaker = require(game.ReplicatedStorage["Water Wheel"].Modules.CameraShaker)
		local camshake = CameraShaker.new(Enum.RenderPriority.Camera.Value,function(shakeCFrame)
			camera.CFrame = camera.CFrame * shakeCFrame
		end)
		camshake:Start()
		camshake:Shake(CameraShaker.Presets.OldBump)
		ButtonDown = false
		Key = nil
		wait(0.7)
		Tool.Active.Value = "None"
		Player.Character.Humanoid.WalkSpeed = 16
		Player.Character.Humanoid.JumpPower = 50
		wait(cooldown)
		Debounce = 1
	end
end)


Response:
local  Paint = false

script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Salmon",Paint)
end)


Response:
local RoundTitle = {}
RoundTitle.__index = RoundTitle

function RoundTitle.new( holder: TextLabel ): ( {} )
    local self = setmetatable( {}, RoundTitle )
    self._janitor = Janitor.new()

    local function OnModeChanged(): ()
        holder.Text = workspace:GetAttribute("Mode")
    end

    workspace:GetAttributeChangedSignal("Mode"):Connect( OnModeChanged )
    OnModeChanged()
    return self
end

function RoundTitle:Destroy(): ()
    self._janitor:Destroy()
end

return RoundTitle


Prompt: --Weld stuff here

Response:
MakeWeld(car.Misc.Wheel.A,car.DriveSeat,"Motor",.2).Name="W"
ModelWeld(car.Misc.Wheel.Parts,car.Misc.Wheel.A)

MakeWeld(car.DriveSeat,misc:WaitForChild('Downforce'))

misc:WaitForChild("Spoiler")
MakeWeld(car.DriveSeat,misc.Spoiler:WaitForChild("A1")).Name="W"
MakeWeld(misc.Spoiler.A1,misc.Spoiler:WaitForChild("A2"),"Motor",.01).Name="W"
MakeWeld(misc.Spoiler.A2,misc.Spoiler:WaitForChild("A3"),"Motor",.02).Name="W"
MakeWeld(misc.Spoiler.A3,misc.Spoiler:WaitForChild("A"),"Motor",.01).Name="W"
MakeWeld(misc.Spoiler.A3,misc.Spoiler:WaitForChild("A4"),"Motor",.01).Name="P"
MakeWeld(misc.Spoiler.A4,misc.Spoiler:WaitForChild("Sp"),"Motor",.01).Name="W"
MakeWeld(misc.Spoiler.Sp,misc.Spoiler:WaitForChild("B1"))
MakeWeld(misc.Spoiler.B1,misc.Spoiler:WaitForChild("B"),"Motor",.01).Name="W"

car.DriveSeat.ChildAdded:connect(function(child)
	if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
		child.C0=CFrame.new(0,-.5,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0)*CFrame.Angles(math.rad(13),0,0)
	end
end)


Prompt:
-- Thanks for SonicUnleashedXY & Manofthelol for this script.
-- To remove the orginial script just go into shooter & right at the bottem you will see something like this:
-- script.Parent.Tool.Name = ""..script.Parent.Ammo.Value.."|"..script.Parent.StoredAmmo.Value..""
-- Remove only that & add this to the tool.
-- Remember this was designed for Manofthelol weapons so any other weapons might not work.
-- You have no permission to repubish this in you model even if it edited.
-- If your found then you will be ban from my place.

Response:
local Tool = script.Parent
local Ammo = Tool.Ammo
local MaxAmmo = Ammo.Value

local vPlayer
local Gui
local Text

function onChanged(value)
	if value == "Value" or value == Ammo.Value then
		if Gui ~= nil and Text ~= nil then
			if Ammo.Value >= 1 then
				Text.Text = ""..script.Parent.Ammo.Value.."|"..script.Parent.StoredAmmo.Value..""
			elseif math.floor(Ammo.Value) == 0 then
				Text.Text = ""..script.Parent.Ammo.Value.."|"..script.Parent.StoredAmmo.Value..""
			elseif Ammo.Value < 0 then
				for i = 0, 1, 0.03 / 2 do
					local Num = math.floor(i * MaxAmmo + 0.5)

					Text.Text = ""..script.Parent.Ammo.Value.."|"..script.Parent.StoredAmmo.Value..""
					wait()
				end
			end
		end
	end
end

function on2Changed()
	if Gui ~= nil and Text ~= nil then

		Text.Text = ""..script.Parent.Ammo.Value.."|"..script.Parent.StoredAmmo.Value..""
		wait()
	end
end

function setUpGui()
	if vPlayer == nil or vPlayer:findFirstChild("PlayerGui") == nil then
		return
	end

	Gui = Instance.new("ScreenGui")
	Text = Instance.new("TextLabel")

	Gui.Name = "DEDisplay"
	Gui.Parent = vPlayer.PlayerGui

	Text.BackgroundColor3 = BrickColor.Black().Color
   Text.BackgroundTransparency = 1
	Text.BorderColor3 = BrickColor.White().Color
   Text.BorderSizePixel = 0
	Text.Name = "Ammo"
	Text.Parent = Gui
	Text.Position = UDim2.new(0.85, 0, 0.825, 0)
	Text.Size = UDim2.new(0, 128, 0, 64)
   Text.FontSize = "Size18"
	Text.Text = ""..script.Parent.Ammo.Value.."|"..script.Parent.StoredAmmo.Value..""
	Text.TextColor3 = BrickColor.White().Color
end

function onEquippedLocal(mouse)
	vPlayer = game.Players.LocalPlayer

	setUpGui()
end

function onUnequippedLocal(mouse)
	if Gui then
		Gui:remove()
	end

	Gui = nil
	Text = nil
	vPlayer = nil
end

Tool.Equipped:connect(onEquippedLocal)
Tool.Unequipped:connect(onUnequippedLocal)

Ammo.Changed:connect(onChanged)
Tool.StoredAmmo.Changed:connect(on2Changed)


Prompt:
--[[
    A helper function to define a Rodux action creator with an associated name.

    Normally when creating a Rodux action, you can just create a function:

        return function(value)
            return {
                type = "MyAction",
                value = value,
            }
        end

    And then when you check for it in your reducer, you either use a constant,
    or type out the string name:

        if action.type == "MyAction" then
            -- change some state
        end

    Typos here are a remarkably common bug. We also have the issue that there's
    no link between reducers and the actions that they respond to!

    `Action` (this helper) provides a utility that makes this a bit cleaner.

    Instead, define your Rodux action like this:

        return Action("MyAction", function(value)
            return {
                value = value,
            }
        end)

    We no longer need to add the `type` field manually.

    Additionally, the returned action creator now has a 'name' property that can
    be checked by your reducer:

        local MyAction = require(Reducers.MyAction)

        ...

        if action.type == MyAction.name then
            -- change some state!
        end

    Now we have a clear link between our reducers and the actions they use, and
    if we ever typo a name, we'll get a warning in LuaCheck as well as an error
    at runtime!
]]

Response:
return function(name, fn)
    assert(type(name) == "string", "A name must be provided to create an Action")
    assert(type(fn) == "function", "A function must be provided to create an Action")

    return setmetatable({
        name = name,
    }, {
        __call = function(self, ...)
            local result = fn(...)

            assert(type(result) == "table", "An action must return a table")

            result.type = name

            return result
        end
    })
end


Prompt:
--[[
	Create a new test node. A pointer to the test plan, a phrase to describe it
	and the type of node it is are required. The modifier is optional and will
	be None if left blank.
]]

Response:
function TestNode.new(plan, phrase, nodeType, nodeModifier)
	nodeModifier = nodeModifier or TestEnum.NodeModifier.None

	local node = {
		plan = plan,
		phrase = phrase,
		type = nodeType,
		modifier = nodeModifier,
		children = {},
		callback = nil,
		parent = nil,
	}

	node.environment = newEnvironment(node, plan.extraEnvironment)
	return setmetatable(node, TestNode)
end

local function getModifier(name, pattern, modifier)
	if pattern and (modifier == nil or modifier == TestEnum.NodeModifier.None) then
		if name:match(pattern) then
			return TestEnum.NodeModifier.Focus
		else
			return TestEnum.NodeModifier.Skip
		end
	end
	return modifier
end

function TestNode:addChild(phrase, nodeType, nodeModifier)
	if nodeType == TestEnum.NodeType.It then
		for _, child in pairs(self.children) do
			if child.phrase == phrase then
				error("Duplicate it block found: " .. child:getFullName())
			end
		end
	end

	local childName = self:getFullName() .. " " .. phrase
	nodeModifier = getModifier(childName, self.plan.testNamePattern, nodeModifier)
	local child = TestNode.new(self.plan, phrase, nodeType, nodeModifier)
	child.parent = self
	table.insert(self.children, child)
	return child
end


Prompt:
---------------
-- Variables --
---------------

Response:
local RunService = game:GetService('RunService')
local PlayersService = game:GetService('Players')
local Player = PlayersService.LocalPlayer

local Camera = nil
local Character = nil
local HumanoidRootPart = nil
local TorsoPart = nil
local HeadPart = nil

local Mode = nil
local BehaviorFunction = nil

local childAddedConn = nil
local childRemovedConn = nil

local Behaviors = {} -- Map of modes to behavior fns
local SavedHits = {} -- Objects currently being faded in/out
local TrackedLimbs = {} -- Used in limb-tracking casting modes


Prompt:
-- This is basically a function that finds all unanchored parts and adds them to childList.
-- Note: This should only be run once for each object

Response:
function checkObject(obj)
	if (obj ~= hole) and (obj.className == "Part") then
		if (obj.Anchored == false) then
			table.insert(childList, 1, obj)
		end
	elseif (obj.className == "Model") or (obj.className == "Hat") or (obj.className == "Tool") or (obj == workspace) then
		local child = obj:GetChildren()
		for x = 1, #child do
			checkObject(child[x])
		end
		obj.ChildAdded:connect(checkObject)
	end
end

checkObject(workspace)

print("Black Hole script loaded.")

local n = 0
while true do
	if n < #childList then
		n = n + 1
		if n % 800 == 0 then
			wait()
		end
	else
		n = 1
		wait()
	end

	local child = childList[n]
	if (child ~= hole) and (child ~= script.Parent.Parent.Tornado) and (child.className == "Part") and (child.Anchored == false) then
		local relPos = hole.Position - child.Position
		local motivator = child:FindFirstChild("BlackHole Influence")
		if relPos.magnitude * 500 * massConstant < mass then
			child:BreakJoints()
			if (relPos.magnitude * 320 * massConstant < mass) and (child.Size.z + hole.Size.x >  relPos.magnitude * 2 - 4) then
				mass = mass + child:GetMass()
				table.remove(childList, n)
				n = n - 1 -- This is the reason I need a counter of my own design
			else
				child.CanCollide = false -- I Can assume that things won't escape the black hole.
				if motivator == nil then
					cleanupScript:clone().Parent = child
					motivator = Instance.new("BodyPosition")
					motivator.Parent = child
					motivator.Name = "BlackHole Influence"
				end
				motivator.position = hole.Position
				motivator.maxForce = Vector3.new(1, 1, 1) * mass * child:GetMass() / (relPos.magnitude * massConstant)
			end
		elseif motivator ~= nil then
			motivator:Remove()
		end
	end
end


Prompt: -- Constructor.

Response:
function FastCast.new()
	return setmetatable({
		LengthChanged = Signal.new("LengthChanged"),
		RayHit = Signal.new("RayHit"),
		RayPierced = Signal.new("RayPierced"),
		CastTerminating = Signal.new("CastTerminating"),
		WorldRoot = workspace
	}, FastCast)
end


Prompt: -- Methods and events to expose from the Dev Module.

Response:
local module = {
	-- Functions
	configure = config.configure,
	setTriggerWordsForChatAnimation = ChatEmotes.setTriggerWordsForChatAnimation,

	-- Events
	onChatAnimationPlayed = events.onChatAnimationPlayed.Event,
}

return module


Prompt:
-- When supplied, legacyCameraType is used and cameraMovementMode is ignored (should be nil anyways)
-- Next, if userCameraCreator is passed in, that is used as the cameraCreator

Response:
function CameraModule:ActivateCameraController(cameraMovementMode, legacyCameraType: Enum.CameraType?)
	local newCameraCreator = nil

	if legacyCameraType~=nil then
		--[[
			This function has been passed a CameraType enum value. Some of these map to the use of
			the LegacyCamera module, the value "Custom" will be translated to a movementMode enum
			value based on Dev and User settings, and "Scriptable" will disable the camera controller.
		--]]

		if legacyCameraType == Enum.CameraType.Scriptable then
			if self.activeCameraController then
				self.activeCameraController:Enable(false)
				self.activeCameraController = nil
			end
			return

		elseif legacyCameraType == Enum.CameraType.Custom then
			cameraMovementMode = self:GetCameraMovementModeFromSettings()

		elseif legacyCameraType == Enum.CameraType.Track then
			-- Note: The TrackCamera module was basically an older, less fully-featured
			-- version of ClassicCamera, no longer actively maintained, but it is re-implemented in
			-- case a game was dependent on its lack of ClassicCamera's extra functionality.
			cameraMovementMode = Enum.ComputerCameraMovementMode.Classic

		elseif legacyCameraType == Enum.CameraType.Follow then
			cameraMovementMode = Enum.ComputerCameraMovementMode.Follow

		elseif legacyCameraType == Enum.CameraType.Orbital then
			cameraMovementMode = Enum.ComputerCameraMovementMode.Orbital

		elseif legacyCameraType == Enum.CameraType.Attach or
			   legacyCameraType == Enum.CameraType.Watch or
			   legacyCameraType == Enum.CameraType.Fixed then
			newCameraCreator = LegacyCamera
		else
			warn("CameraScript encountered an unhandled Camera.CameraType value: ",legacyCameraType)
		end
	end

	if not newCameraCreator then
		if FFlagUserFlagEnableNewVRSystem and VRService.VREnabled then
			newCameraCreator = VRCamera
		elseif cameraMovementMode == Enum.ComputerCameraMovementMode.Classic or
			cameraMovementMode == Enum.ComputerCameraMovementMode.Follow or
			cameraMovementMode == Enum.ComputerCameraMovementMode.Default or
			cameraMovementMode == Enum.ComputerCameraMovementMode.CameraToggle then
			newCameraCreator = ClassicCamera
		elseif cameraMovementMode == Enum.ComputerCameraMovementMode.Orbital then
			newCameraCreator = OrbitalCamera
		else
			warn("ActivateCameraController did not select a module.")
			return
		end
	end

	local isVehicleCamera = self:ShouldUseVehicleCamera()
	if isVehicleCamera then
		if FFlagUserFlagEnableNewVRSystem and VRService.VREnabled then
			newCameraCreator = VRVehicleCamera
		else
			newCameraCreator = VehicleCamera
		end
	end

	-- Create the camera control module we need if it does not already exist in instantiatedCameraControllers
	local newCameraController
	if not instantiatedCameraControllers[newCameraCreator] then
		newCameraController = newCameraCreator.new()
		instantiatedCameraControllers[newCameraCreator] = newCameraController
	else
		newCameraController = instantiatedCameraControllers[newCameraCreator]
		if newCameraController.Reset then
			newCameraController:Reset()
		end
	end

	if self.activeCameraController then
		-- deactivate the old controller and activate the new one
		if self.activeCameraController ~= newCameraController then
			self.activeCameraController:Enable(false)
			self.activeCameraController = newCameraController
			self.activeCameraController:Enable(true)
		elseif not self.activeCameraController:GetEnabled() then
			self.activeCameraController:Enable(true)
		end
	elseif newCameraController ~= nil then
		-- only activate the new controller
		self.activeCameraController = newCameraController
		self.activeCameraController:Enable(true)
	end

	if self.activeCameraController then
		if cameraMovementMode~=nil then
			self.activeCameraController:SetCameraMovementMode(cameraMovementMode)
		elseif legacyCameraType~=nil then
			-- Note that this is only called when legacyCameraType is not a type that
			-- was convertible to a ComputerCameraMovementMode value, i.e. really only applies to LegacyCamera
			self.activeCameraController:SetCameraType(legacyCameraType)
		end
	end
end


Prompt:
------------------------------------------------------------------------------
--------------------[ MAIN PROGRAM ]------------------------------------------
------------------------------------------------------------------------------

Response:
local Touched = false

Main.Touched:connect(function(Obj)
	if IsIgnored(Obj) or Touched then return end
	Touched = true

	local W = Instance.new("Weld")
	W.Name = "Sticky"
	W.Part0 = Main
	W.Part1 = Obj
	W.C0 = Main.CFrame:toObjectSpace(Obj.CFrame)
	W.Parent = Main

	Main.ChildRemoved:connect(function(C)
		if C.Name == "Sticky" then
			local W = Instance.new("Weld")
			W.Name = "Sticky"
			W.Part0 = Main
			W.Part1 = Obj
			W.C0 = Main.CFrame:toObjectSpace(Obj.CFrame)
			W.Parent = Main
		end
	end)

	if Obj then
		if Obj.Parent.ClassName == "Hat" then
			local HitHumanoid = FindFirstClass(Obj.Parent.Parent, "Humanoid")
			if HitHumanoid and IsEnemy(HitHumanoid) then
				local CreatorTag = Instance.new("ObjectValue")
				CreatorTag.Name = "creator"
				CreatorTag.Value = Plyr
				CreatorTag.Parent = HitHumanoid
				HitHumanoid:TakeDamage(HitHumanoid.MaxHealth)
				MarkHit()
			end
		else
			local HitHumanoid = FindFirstClass(Obj.Parent, "Humanoid")
			if HitHumanoid and IsEnemy(HitHumanoid) then
				local CreatorTag = Instance.new("ObjectValue")
				CreatorTag.Name = "creator"
				CreatorTag.Value = Plyr
				CreatorTag.Parent = HitHumanoid
				HitHumanoid:TakeDamage(HitHumanoid.MaxHealth)
				MarkHit()
			end
		end
	end

	wait(3)

	Main.Parent:Destroy()
end)


Prompt:
--[[
	Utility function to log a Fusion-specific error, without halting execution.
]]

Response:
local Package = script.Parent.Parent
local Types = require(Package.Types)
local messages = require(Package.Logging.messages)

local function logErrorNonFatal(messageID: string, errObj: Types.Error?, ...)
	local formatString: string

	if messages[messageID] then
		formatString = messages[messageID]
	else
		messageID = "unknownMessage"
		formatString = "Unknown error: ERROR_MESSAGE"
	end

	local errorString
	if errObj == nil then
		errorString = string.format("[Fusion] " .. formatString .. "\n(ID: " .. messageID .. ")", ...)
	else
		formatString = formatString:gsub("ERROR_MESSAGE", errObj.message)
		errorString = string.format("[Fusion] " .. formatString .. "\n(ID: " .. messageID .. ")\n---- Stack trace ----\n" .. errObj.trace, ...)
	end

	task.spawn(function(...)
		error(errorString:gsub("\n", "\n    "), 0)
	end, ...)
end

return logErrorNonFatal


Prompt:
-- counts how many sets are currently stored in `initialisedStack`, whether
-- they're currently in use or not

Response:
local initialisedStackCapacity = 0

local function captureDependencies(saveToSet: Types.Set<Types.Dependency<any>>, callback: (any) -> any, ...): (boolean, any)
	-- store whichever set was being saved to previously, and replace it with
	-- the new set which was passed in
	local prevDependencySet = sharedState.dependencySet
	sharedState.dependencySet = saveToSet

	-- Add a new 'initialised' set to the stack of initialised sets.
	-- If a dependency is created inside the callback (even if indirectly inside
	-- a different `captureDependencies` call), it'll be added to this set.
	-- This can be used to ignore dependencies that were created inside of the
	-- callback.
	sharedState.initialisedStackSize += 1
	local initialisedStackSize = sharedState.initialisedStackSize

	local initialisedSet

	-- instead of constructing new sets all of the time, we can simply leave old
	-- sets in the stack and keep track of the 'real' number of sets ourselves.
	-- this means we don't have to keep creating and throwing away tables, which
	-- is great for performance at the expense of slightly more memory usage.
	if initialisedStackSize > initialisedStackCapacity then
		-- the stack has grown beyond any previous size, so we need to create
		-- a new table
		initialisedSet = {}
		initialisedStack[initialisedStackSize] = initialisedSet
		initialisedStackCapacity = initialisedStackSize
	else
		-- the stack is smaller or equal to some previous size, so we just need
		-- to clear whatever set was here before
		initialisedSet = initialisedStack[initialisedStackSize]
		table.clear(initialisedSet)
	end

	-- now that the shared state has been set up, call the callback in a pcall.
	-- using a pcall means the shared state can be reset afterwards, even if an
	-- error occurs.
	local ok, value = xpcall(callback, parseError, ...)

	-- restore the previous set being saved to
	sharedState.dependencySet = prevDependencySet
	-- shrink the stack of initialised sets (essentially removing this set)
	sharedState.initialisedStackSize -= 1

	return ok, value
end

return captureDependencies


Response:
SYNC_RATE:Connect(function()
	for Index, Object in ipairs(ActiveHitboxes) do
		if Object.deleted then
			Handler:remove(Object.object)
		else
			for _, Point in ipairs(Object.points) do
				if not Object.active then
					Point.LastPosition = nil
				else
					local rayStart, rayDir, RelativePointToWorld = Point.solver:solve(Point, game:GetService("ReplicatedStorage"):WaitForChild("ClientSettings").Debug.Value)
					local raycastResult = workspace:Raycast(rayStart, rayDir, Object.raycastParams)
					Point.solver:lastPosition(Point, RelativePointToWorld)

					if raycastResult then
						local hitPart = raycastResult.Instance
						local findModel = not Object.partMode and hitPart:FindFirstAncestorOfClass("Model")
						local humanoid = findModel and findModel:FindFirstChildOfClass("Humanoid")
						local target = humanoid or (Object.partMode and hitPart)

						if target and not Object.targetsHit[target] then
							Object.targetsHit[target] = true
							Object.OnHit:Fire(hitPart, humanoid, raycastResult, Point.group)
						end
					end

					if Object.endTime > 0 then
						if Object.endTime <= clock() then
							Object.endTime = 0
							Object:HitStop()
						end
					end

					Object.OnUpdate:Fire(Point.LastPosition)
				end
			end
		end
	end
end)

return Handler


Prompt: -- Robase?

Response:
return function(centiseconds)
	local minutes = string.format("%02.f", math.floor(centiseconds / 6000))
	local seconds = string.format("%02.f", math.floor((centiseconds - (minutes * 6000)) / 100))
	centiseconds = string.format("%02.f", math.floor(centiseconds - (minutes * 6000) - (seconds * 100)))
	return minutes .. ":" .. seconds .. "." .. centiseconds
end


Prompt:
--[[
	Put this inside a LocalScript in a TextButton - For closing
--]]

Response:
script.Parent.MouseButton1Click:Connect(function()
	script.Parent.Parent.Visible = false
	script.Parent.Parent.Parent.Buttons.Visible = false
end)


Prompt: --[[Weight and CG]]

Response:
	Tune.Weight			= 100000		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		3.5		,
	 --[[Length]]		14		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible

	--Unsprung Weight
	Tune.FWheelDensity	= 1		-- Front Wheel Density
	Tune.RWheelDensity	= 1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]

	Tune.AxleSize		= 5			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= 1		-- Density of structural members


Prompt:
--[[**
	ensure value is an Instance and it's ClassName matches the given ClassName

	@param className The class name to check for

	@returns A function that will return true iff the condition is passed
**--]]

Response:
function t.instanceOf(className, childTable)
	assert(t.string(className))

	local childrenCheck
	if childTable ~= nil then
		childrenCheck = t.children(childTable)
	end

	return function(value)
		local instanceSuccess = t.Instance(value)
		if not instanceSuccess then
			return false
		end

		if value.ClassName ~= className then
			return false
		end

		if childrenCheck then
			local childrenSuccess = childrenCheck(value)
			if not childrenSuccess then
				return false
			end
		end

		return true
	end
end

t.instance = t.instanceOf


Prompt:
-- Mouse
-- Stephen Leitnick
-- November 07, 2020

Response:
local Trove = require(script.Parent.Parent.Trove)
local Signal = require(script.Parent.Parent.Signal)

local UserInputService = game:GetService("UserInputService")

local RAY_DISTANCE = 1000


Prompt: -- Setup Items

Response:
local Button = WaitForItem(StealthLava.Parent, "ClickDetector")
local Head = WaitForItem(StealthLava.Parent, "Head")


Prompt: -- connect events

Response:
Humanoid.Died:connect(onDied)
Humanoid.Running:connect(onRunning)
Humanoid.Jumping:connect(onJumping)
Humanoid.Climbing:connect(onClimbing)
Humanoid.GettingUp:connect(onGettingUp)
Humanoid.FreeFalling:connect(onFreeFall)
Humanoid.FallingDown:connect(onFallingDown)
Humanoid.Seated:connect(onSeated)
Humanoid.PlatformStanding:connect(onPlatformStanding)
Humanoid.Swimming:connect(onSwimming)

playAnimation("idle", 0.1, Humanoid)
pose = "Standing"
while Character.Parent ~= nil do
	local _, currentGameTime = wait(0.1)
	stepAnimate(currentGameTime)
end


Prompt: -- Set up portals

Response:
for _,portal in pairs(workspace.Portals:GetChildren()) do
	local label = script.PortalLabel:Clone()
	label.RankLabel.Text = portal.RequiredRank.Value
	label.Parent = portal.Portal
	portal.Portal.Touched:Connect(function(part)
		local player = players:GetPlayerFromCharacter(part.Parent)
		if player and player.Stats.Rank.Value >= portal.RequiredRank.Value and not portal:FindFirstChild(player.Name .. "Cooldown") then
			replicatedStorage.ClientRemotes.TeleportToArea:FireClient(player, portal.AreaToTeleportTo.Value.Name)
			player.Stats.CurrentArea.Value = portal.AreaToTeleportTo.Value
			player.RespawnLocation = portal.AreaToTeleportTo.Value.Spawn
			local tag = Instance.new("Model")
			tag.Name = player.Name .. "Cooldown"
			tag.Parent = portal
			game:GetService("Debris"):AddItem(tag, 3)
		end
	end)
end


Response:
function DoorClose()
	if Shaft00.MetalDoor.CanCollide == false then
		Shaft00.MetalDoor.CanCollide = true
		while Shaft00.MetalDoor.Transparency > 0.0 do
			Shaft00.MetalDoor.Transparency = Shaft00.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft01.MetalDoor.CanCollide == false then
		Shaft01.MetalDoor.CanCollide = true
		while Shaft01.MetalDoor.Transparency > 0.0 do
			Shaft01.MetalDoor.Transparency = Shaft01.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft02.MetalDoor.CanCollide == false then
		Shaft02.MetalDoor.CanCollide = true
		while Shaft02.MetalDoor.Transparency > 0.0 do
			Shaft02.MetalDoor.Transparency = Shaft02.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft03.MetalDoor.CanCollide == false then
		Shaft03.MetalDoor.CanCollide = true
		while Shaft03.MetalDoor.Transparency > 0.0 do
			Shaft03.MetalDoor.Transparency = Shaft03.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft04.MetalDoor.CanCollide == false then
		Shaft04.MetalDoor.CanCollide = true
		while Shaft04.MetalDoor.Transparency > 0.0 do
			Shaft04.MetalDoor.Transparency = Shaft04.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft05.MetalDoor.CanCollide == false then
		Shaft05.MetalDoor.CanCollide = true
		while Shaft05.MetalDoor.Transparency > 0.0 do
			Shaft05.MetalDoor.Transparency = Shaft05.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft06.MetalDoor.CanCollide == false then
		Shaft06.MetalDoor.CanCollide = true
		while Shaft06.MetalDoor.Transparency > 0.0 do
			Shaft06.MetalDoor.Transparency = Shaft06.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft07.MetalDoor.CanCollide == false then
		Shaft07.MetalDoor.CanCollide = true
		while Shaft07.MetalDoor.Transparency > 0.0 do
			Shaft07.MetalDoor.Transparency = Shaft07.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft08.MetalDoor.CanCollide == false then
		Shaft08.MetalDoor.CanCollide = true
		while Shaft08.MetalDoor.Transparency > 0.0 do
			Shaft08.MetalDoor.Transparency = Shaft08.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft09.MetalDoor.CanCollide == false then
		Shaft09.MetalDoor.CanCollide = true
		while Shaft09.MetalDoor.Transparency > 0.0 do
			Shaft09.MetalDoor.Transparency = Shaft09.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft10.MetalDoor.CanCollide == false then
		Shaft10.MetalDoor.CanCollide = true
		while Shaft10.MetalDoor.Transparency > 0.0 do
			Shaft10.MetalDoor.Transparency = Shaft10.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft11.MetalDoor.CanCollide == false then
		Shaft11.MetalDoor.CanCollide = true
		while Shaft11.MetalDoor.Transparency > 0.0 do
			Shaft11.MetalDoor.Transparency = Shaft11.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft12.MetalDoor.CanCollide == false then
		Shaft12.MetalDoor.CanCollide = true
		while Shaft12.MetalDoor.Transparency > 0.0 do
			Shaft12.MetalDoor.Transparency = Shaft12.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
	if Shaft13.MetalDoor.CanCollide == false then
		Shaft13.MetalDoor.CanCollide = true
		while Shaft13.MetalDoor.Transparency > 0.0 do
			Shaft13.MetalDoor.Transparency = Shaft13.MetalDoor.Transparency - .1
			wait(0.000001)
		end
	end
end

function onClicked()
DoorClose()

Car.BodyVelocity.velocity = Vector3.new(0, -20, 0)	--Change 10 to change the speed.
end
script.Parent.MouseButton1Click:connect(onClicked)

script.Parent.MouseButton1Click:connect(function()
	if clicker == true
		then clicker = false
	else
		return

	end
end)

Car.Touched:connect(function(otherPart)
	if otherPart == Elevator.Floors:FindFirstChild(script.Parent.Name)
		then StopE() DoorOpen()
	end
end)

function StopE()
 Car.BodyVelocity.velocity = Vector3.new(0, 0, 0)
 Car.BodyPosition.position = Elevator.Floors:FindFirstChild(script.Parent.Name).Position
	clicker = true
end

function DoorOpen()
	while Shaft00.MetalDoor.Transparency < 1.0 do
	Shaft00.MetalDoor.Transparency = Shaft00.MetalDoor.Transparency + .1
	wait(0.000001)
	end
	Shaft00.MetalDoor.CanCollide = false
end

DoorOpen()


Prompt:
--[=[
	@within TableUtil
	@function Reduce
	@param tbl table
	@param predicate (accumulator: any, value: any, index: any, tbl: table) -> result: any
	@return table

	Performs a reduce operation against the given table, which can be used to
	reduce the table into a single value. This could be used to sum up a table
	or transform all the values into a compound value of any kind.

	For example:

	```lua
	local t = {10, 20, 30, 40}
	local result = TableUtil.Reduce(t, function(accum, value)
		return accum + value
	end)
	print(result) --> 100
	```
]=]

Response:
local function Reduce<T, R>(t: { T }, predicate: (R, T, any, { T }) -> R, init: R): R
	assert(type(t) == "table", "First argument must be a table")
	assert(type(predicate) == "function", "Second argument must be a function")
	local result = init :: R
	if #t > 0 then
		local start = 1
		if init == nil then
			result = (t[1] :: any) :: R
			start = 2
		end
		for i = start, #t do
			result = predicate(result, t[i], i, t)
		end
	else
		local start = nil
		if init == nil then
			result = (next(t) :: any) :: R
			start = result
		end

		for k, v in next, t, start :: any? do
			result = predicate(result, v, k, t)
		end
	end
	return result
end


Prompt: --Rescripted by Luckymaxer

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

Players = game:GetService("Players")

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

ClientControl.OnClientInvoke = (function(Mode, Value)
	if Mode == "PlaySound" and Value then
		Value:Play()
	end
end)

function InvokeServer(Mode, Value, arg)
	pcall(function()
		ServerControl:InvokeServer(Mode, Value, arg)
	end)
end

function Equipped(Mouse)
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChild("Humanoid")
	if not Player or not Humanoid or Humanoid.Health == 0 then
		return
	end
	Mouse.Button1Down:connect(function()
		InvokeServer("Click", true, Mouse.Hit.p)
	end)
end

local function Unequipped()

end
script.Parent:GetPropertyChangedSignal("Parent"):Connect(function()
	if script.Parent.Parent == game.Players.LocalPlayer.Character then
		Equipped(game.Players.LocalPlayer:GetMouse())
	else
		Unequipped()
	end
end)


Prompt: --// Admin

Response:
return function(Vargs, GetEnv)
	local env = GetEnv(nil, {script = script})
	setfenv(1, env)

	local server = Vargs.Server;
	local service = Vargs.Service;
	local cloneTable = service.CloneTable;

	local Functions, Admin, Anti, Core, HTTP, Logs, Remote, Process, Variables, Settings, Commands
	local AddLog, TrackTask, Defaults
	local CreatorId = game.CreatorType == Enum.CreatorType.User and game.CreatorId or service.GetGroupCreatorId(game.CreatorId)
	local function Init()
		Functions = server.Functions;
		Admin = server.Admin;
		Anti = server.Anti;
		Core = server.Core;
		HTTP = server.HTTP;
		Logs = server.Logs;
		Remote = server.Remote;
		Process = server.Process;
		Variables = server.Variables;
		Settings = server.Settings;
		Commands = server.Commands;
		Defaults = server.Defaults

		TrackTask = service.TrackTask
		AddLog = Logs.AddLog;

		TrackTask("Thread: ChatServiceHandler", function()

			--// Support for modern TextChatService
			if service.TextChatService and service.TextChatService.ChatVersion == Enum.ChatVersion.TextChatService and Settings.OverrideChatCallbacks then
				local function onNewTextchannel(textchannel)
					AddLog("Script", "Connected to textchannel: "..textchannel.Name)

					textchannel.ShouldDeliverCallback = function(chatMessage, textSource)
						if
							chatMessage.Status == Enum.TextChatMessageStatus.Success
							or chatMessage.Status == Enum.TextChatMessageStatus.Sending
						then
							local player = service.Players:GetPlayerByUserId(textSource.UserId)
							local slowCache = Admin.SlowCache

							if not player then
								return true
							elseif Admin.DoHideChatCmd(player, chatMessage.Text) then -- // Hide chat commands?
								return false
							elseif Admin.IsMuted(player) then -- // Mute handler
								Remote.MakeGui(player, "Notification", {
									Title = "You are muted!";
									Message = "You are muted and cannot talk in the chat right now.";
									Time = 10;
								})

								return false
							elseif Admin.SlowMode and not Admin.CheckAdmin(player) and slowCache[player] and os.time() - slowCache[player] < Admin.SlowMode then
								Remote.MakeGui(player, "Notification", {
									Title = "You are chatting too fast!";
									Message = string.format("[Adonis] :: Slow mode enabled! (%g second(s) remaining)", Admin.SlowMode - (os.time() - slowCache[player]));
									Time = 10;
								})

								return false
							end

							if Variables.DisguiseBindings[textSource.UserId] then -- // Disguise command handler
								chatMessage.PrefixText = Variables.DisguiseBindings[textSource.UserId].TargetUsername..":"
							end

							if Admin.SlowMode then
								slowCache[player] = os.time()
							end
						end

						return true
					end
				end

				local function onTextChannelsAdded(textChannels)
					for _, v in textChannels:GetChildren() do
						if v:IsA("TextChannel") then
							task.spawn(onNewTextchannel, v)
						end
					end

					textChannels.ChildAdded:Connect(function(child)
						if child:IsA("TextChannel") then
							task.spawn(onNewTextchannel, child)
						end
					end)
				end

				if service.TextChatService:FindFirstChild("TextChannels") then
					task.spawn(pcall, onTextChannelsAdded, service.TextChatService:FindFirstChild("TextChannels"))
				end

				service.TextChatService.ChildAdded:Connect(function(child)
					if child.Name == "TextChannels" then
						task.spawn(onTextChannelsAdded, child)
					end
				end)

				AddLog("Script", "TextChatService Handler Loaded")
			end

			--// Support for legacy Lua chat system
			--// ChatService mute handler (credit to Coasterteam)
			local chatService = Functions.GetChatService()
			if chatService then
				chatService:RegisterProcessCommandsFunction("ADONIS_CMD", function(speakerName, message)
					local speaker = chatService:GetSpeaker(speakerName)
					local speakerPlayer = speaker and speaker:GetPlayer()

					if not speakerPlayer then
						return false
					end

					if Admin.DoHideChatCmd(speakerPlayer, message) then
						return true
					end

					return false
				end)

				chatService:RegisterProcessCommandsFunction("ADONIS_MUTE_SERVER", function(speakerName, _, channelName)
					local slowCache = Admin.SlowCache

					local speaker = chatService:GetSpeaker(speakerName)
					local speakerPlayer = speaker and speaker:GetPlayer()

					if not speakerPlayer then
						return false
					end

					if speakerPlayer and Admin.IsMuted(speakerPlayer) then
						speaker:SendSystemMessage("[Adonis] :: You are muted!", channelName)
						return true
					elseif speakerPlayer and Admin.SlowMode and not Admin.CheckAdmin(speakerPlayer) and slowCache[speakerPlayer] and os.time() - slowCache[speakerPlayer] < Admin.SlowMode then
						speaker:SendSystemMessage(string.format("[Adonis] :: Slow mode enabled! (%g second(s) remaining)", Admin.SlowMode - (os.time() - slowCache[speakerPlayer])), channelName)
						return true
					end

					if Admin.SlowMode then
						slowCache[speakerPlayer] = os.time()
					end

					return false
				end)

				AddLog("Script", "ChatService Handler Loaded")
			else
				warn("Place is missing ChatService; Vanilla Roblox chat related features may not work")
				AddLog("Script", "ChatService Handler Not Found")
			end
		end)

		--// Make sure the default ranks are always present for compatability with existing commands
		local Ranks = Settings.Ranks
		for rank, data in Defaults.Settings.Ranks do
			if not Ranks[rank] then
				for r, d in Ranks do
					if d.Level == data.Level then
						data.Hidden = true
						break
					end
				end
				Ranks[rank] = data
			end
		end

		--// Old settings/plugins backwards compatibility
		for _, rank in {"Owners", "HeadAdmins", "Admins", "Moderators", "Creators"} do
			if Settings[rank] then
				Settings.Ranks[if rank == "Owners" then "HeadAdmins" else rank].Users = Settings[rank]
			end
		end

		--[[Settings.HeadAdmins = Settings.Ranks.HeadAdmins.Users;
		Settings.Admins = Settings.Ranks.Admins.Users;
		Settings.Moderators = Settings.Ranks.Moderators.Users;--]]

		if Settings.CustomRanks then
			local Ranks = Settings.Ranks
			for name, users in Settings.CustomRanks do
				if not Ranks[name] then
					Ranks[name] = {
						Level = 1;
						Users = users;
					};
				end
			end
		end

		if Settings.CommandCooldowns then
			for cmdName, cooldownData in Settings.CommandCooldowns do
				local realCmd = Admin.GetCommand(cmdName)

				if realCmd then
					if cooldownData.Player then
						realCmd.PlayerCooldown = cooldownData.Player
					end

					if cooldownData.Server then
						realCmd.ServerCooldown = cooldownData.Server
					end

					if cooldownData.Cross then
						realCmd.CrossCooldown = cooldownData.Cross
					end
				end
			end
		end

		if Settings.CommandCooldowns then
			for cmdName, cooldownData in Settings.CommandCooldowns do
				local realCmd = Admin.GetCommand(cmdName)

				if realCmd then
					if cooldownData.Player then
						realCmd.PlayerCooldown = cooldownData.Player
					end

					if cooldownData.Server then
						realCmd.ServerCooldown = cooldownData.Server
					end

					if cooldownData.Cross then
						realCmd.CrossCooldown = cooldownData.Cross
					end
				end
			end
		end

		if Settings.CommandCooldowns then
			for cmdName, cooldownData in pairs(Settings.CommandCooldowns) do
				local realCmd = Admin.GetCommand(cmdName)

				if realCmd then
					if cooldownData.Player then
						realCmd.PlayerCooldown = cooldownData.Player
					end

					if cooldownData.Server then
						realCmd.ServerCooldown = cooldownData.Server
					end

					if cooldownData.Cross then
						realCmd.CrossCooldown = cooldownData.Cross
					end
				end
			end
		end

		Admin.Init = nil;
		AddLog("Script", "Admin Module Initialized")
	end;

	local function RunAfterPlugins(data)
		--// Backup Map
		if Settings.AutoBackup then
			TrackTask("Thread: Initial Map Backup", Admin.RunCommand, `{Settings.Prefix}backupmap`)
		end

		--// Run OnStartup Commands
		for i,v in Settings.OnStartup do
			warn(`Running startup command {v}`)
			TrackTask(`Thread: Startup_Cmd: {v}`, Admin.RunCommand, v)
			AddLog("Script", {
				Text = `Startup: Executed {v}`;
				Desc = `Executed startup command; {v}`;
			})
		end

		--// Check if Shutdownlogs is set and if not then set it
		if Core.DataStore and not Core.GetData("ShutdownLogs") then
			Core.SetData("ShutdownLogs", {})
		end

		Admin.RunAfterPlugins = nil;
		AddLog("Script", "Admin Module RunAfterPlugins Finished")
	end

	service.MarketplaceService.PromptGamePassPurchaseFinished:Connect(function(player, id, purchased)
		if Variables and player.Parent and id == 1348327 and purchased then
			Variables.CachedDonors[tostring(player.UserId)] = os.time()
		end
	end)

	local function stripArgPlaceholders(alias)
		return service.Trim(string.gsub(alias, "<%S+>", ""))
	end

	local function FormatAliasArgs(alias, aliasCmd, msg)
		local uniqueArgs = {}
		local argTab = {}
		local numArgs = 0

		--// First try to extract args info from the alias
		for arg in string.gmatch(alias, "<(%S+)>") do
			if arg ~= "" and arg ~= " " then
				local arg = `<{arg}>`
				if not uniqueArgs[arg] then
					numArgs += 1
					uniqueArgs[arg] = true
					table.insert(argTab, arg)
				end
			end
		end

		--// If no args in alias string, check the command string instead and try to guess args based on order of appearance
		if numArgs == 0 then
			for arg in string.gmatch(aliasCmd, "<(%S+)>") do
				if arg ~= "" and arg ~= " " then
					local arg = `<{arg}>`
					if not uniqueArgs[arg] then --// Get only unique placeholder args, repeats will be matched to the same arg pos
						numArgs += 1
						uniqueArgs[arg] = true --// :cmd <arg1> <arg2>
						table.insert(argTab, arg)
					end
				end
			end
		end

		local suppliedArgs = Admin.GetArgs(msg, numArgs) -- User supplied args (when running :alias arg)
		local out = aliasCmd

		local EscapeSpecialCharacters = service.EscapeSpecialCharacters
		for i,argType in argTab do
			local replaceWith = suppliedArgs[i]
			if replaceWith then
				out = string.gsub(out, EscapeSpecialCharacters(argType), replaceWith)
			end
		end

		return out
	end

	server.Admin = {
		Init = Init;
		RunAfterPlugins = RunAfterPlugins;

		SpecialLevels = {};
		TempAdmins = {};

		PrefixCache = {};
		CommandCache = {};
		SlowCache = {};
		UserIdCache = {};
		GroupsCache = {};

		BlankPrefix = false;

		--// How long admin levels will be cached (unless forcibly updated via something like :admin user)
		AdminLevelCacheTimeout = 30;

		DoHideChatCmd = function(p: Player, message: string, data: {[string]: any}?)
			local pData = data or Core.GetPlayer(p)
			if pData.Client.HideChatCommands then
				if Variables.BlankPrefix and
					(string.sub(message,1,1) ~= Settings.Prefix or string.sub(message,1,1) ~= Settings.PlayerPrefix) then
					local isCMD = Admin.GetCommand(message)
					if isCMD then
						return true
					else
						return false
					end
				elseif (string.sub(message,1,1) == Settings.Prefix or string.sub(message,1,1) == Settings.PlayerPrefix)
					and string.sub(message,2,2) ~= string.sub(message,1,1) then
					return true;
				end
			end
		end;

		GetPlayerGroups = function(p: Player)
			if not p or p.Parent ~= service.Players then
				return {}
			end
			return Admin.GetGroups(p.UserId)
		end;

		GetPlayerGroup = function(p, group)
			local groups = Admin.GetPlayerGroups(p)
			local isId = type(group) == "number"
			if groups and #groups > 0 then
				for _, g in groups do
					if (isId and g.Id == group) or (not isId and g.Name == group) then
						return g
					end
				end
			end
		end;

		GetGroups = function(uid, updateCache)
			uid = tonumber(uid)

			if type(uid) == "number" then
				local existCache = Admin.GroupsCache[uid]
				local canUpdate = false

				if not updateCache then
					--> Feel free to adjust the time to update over or less than 300 seconds (5 minutes).
					--> 300 seconds is recommended in the event of unexpected server breakdowns with Roblox and faster performance.
					if existCache and (os.time()-existCache.LastUpdated > 300) then
						canUpdate = true
					elseif not existCache then
						canUpdate = true
					end
				else
					canUpdate = true
				end

				if canUpdate then
					local cacheTab = {
						Groups = (existCache and existCache.Groups) or {};
						LastUpdated = os.time();
					}
					Admin.GroupsCache[uid] = cacheTab

					local suc,groups = pcall(function()
						return service.GroupService:GetGroupsAsync(uid) or {}
					end)

					if suc and type(groups) == "table" then
						cacheTab.Groups = groups
						return cacheTab.Groups
					end

					Admin.GroupsCache[uid] = cacheTab
					return cloneTable(cacheTab.Groups)
				else
					return cloneTable((existCache and existCache.Groups) or {})
				end
			end
		end;

		GetGroupLevel = function(uid, groupId)
			groupId = tonumber(groupId)

			if groupId then
				local groups = Admin.GetGroups(uid) or {}

				for _, group in groups do
					if group.Id == groupId then
						return group.Rank
					end
				end
			end

			return 0
		end;

		CheckInGroup = function(uid, groupId)
			local groups = Admin.GetGroups(uid) or {}
			groupId = tonumber(groupId)

			if groupId then
				for i,group in groups do
					if group.Id == groupId then
						return true
					end
				end
			end

			return false
		end,

		IsLax = function(str)
			for _, v in {"plr", "user", "player", "brickcolor"} do
				if string.match(string.lower(str), v) then
					return true
				end
			end

			return false
		end,

		IsMuted = function(player)
			local DoCheck = Admin.DoCheck
			for _, v in Settings.Muted do
				if DoCheck(player, v) then
					return true
				end
			end

			for _, v in HTTP.Trello.Mutes do
				if DoCheck(player, v) then
					return true
				end
			end

			if HTTP.WebPanel.Mutes then
				for _, v in HTTP.WebPanel.Mutes do
					if DoCheck(player, v) then
						return true
					end
				end
			end
		end;

		DoCheck = function(pObj, check, banCheck)
			local pType = typeof(pObj)
			local cType = typeof(check)

			local pUnWrapped = service.UnWrap(pObj)

			local plr: Player = if pType == "userdata" and pObj:IsA("Player") then pObj
				elseif pType == "number" then service.Players:GetPlayerByUserId(pObj)
				elseif pType == "string" then service.Players:FindFirstChild(pObj)
				elseif typeof(pUnWrapped) == "Instance" and pUnWrapped:IsA("Player") then pUnWrapped
				elseif pType == "userdata" then service.Players:GetPlayerByUserId(pObj.UserId)
				else nil
			if not plr then
				return false
			end

			if cType == "number" then
				return plr.UserId == check
			elseif cType == "string" then
				if plr.Name == check then
					return true
				end

				local filterName, filterData = string.match(check, "^(.-):(.+)$")
				if filterName then
					filterName = string.lower(filterName)
				else
					return false
				end
				if filterName == "group" then
					local groupId = tonumber((string.match(filterData, "^%d+")))
					if groupId then
						local plrRank = Admin.GetGroupLevel(plr.UserId, groupId)
						local requiredRank = tonumber((string.match(filterData, "^%d+:(.+)$")))
						if requiredRank then
							return plrRank == requiredRank or (requiredRank < 0 and plrRank >= math.abs(requiredRank))
						end
						return plrRank > 0
					end
					return false
				elseif filterName == "item" then
					local itemId = tonumber((string.match(filterData, "^%d+")))
					return itemId and service.CheckAssetOwnership(plr, itemId)
				elseif filterName == "gamepass" then
					local gamepassId = tonumber((string.match(filterData, "^%d+")))
					return gamepassId and service.CheckPassOwnership(plr, gamepassId)
				else
					local username, userId = string.match(check, "^(.*):(.*)")
					if username and userId and (plr.UserId == tonumber(userId) or string.lower(plr.Name) == string.lower(username)) then
						return true
					end

					if not banCheck and type(check) == "string" and not string.find(check, ":") then
						local cache = Functions.GetUserIdFromNameAsync(check)
						if cache and plr.UserId == cache then
							return true
						end
					end
				end
			elseif cType == "table" then
				local groupId, rank = check.Group, check.Rank
				if groupId and rank then
					local plrGroupInfo = Admin.GetPlayerGroup(plr, groupId)
					if plrGroupInfo then
						local plrRank = plrGroupInfo.Rank
						return plrRank == rank or (rank < 0 and plrRank >= math.abs(rank))
					end
				end
			end

			return check == plr
		end;

		LevelToList = function(lvl)
			local lvl = tonumber(lvl)
			if not lvl then return nil end
			local listName = Admin.LevelToListName(lvl)
			if listName then
				local list = Settings.Ranks[listName];
				if list then
					return list.Users, listName, list;
				end
			end
		end;

		LevelToListName = function(lvl)
			if lvl > 999 then
				return "Place Owner"
			elseif lvl == 0 then
				return "Players"
			end

			--// Check if this is a default rank and if the level matches the default (so stuff like [Trello] Admins doesn't appear in the command list)
			for i,v in server.Defaults.Settings.Ranks do
				local tRank = Settings.Ranks[i];
				if tRank and tRank.Level == v.Level and v.Level == lvl then
					return i
				end
			end

			for i,v in Settings.Ranks do
				if v.Level == lvl then
					return i
				end
			end
		end;

		UpdateCachedLevel = function(p, data)
			local data = data or Core.GetPlayer(p)
			local oLevel, oRank = data.AdminLevel, data.AdminRank
			local level, rank = Admin.GetUpdatedLevel(p, data)

			data.AdminLevel = level
			data.AdminRank = rank
			data.LastLevelUpdate = os.time()

			AddLog("Script", {
				Text = `Updating cached level for {p.Name}`;
				Desc = `Updating the cached admin level for {p.Name}`;
				Player = p;
			})

			if Settings.Console and (oLevel ~= level or oRank ~= rank) then
				if not Settings.Console_AdminsOnly or (Settings.Console_AdminsOnly and level > 0) then
					task.defer(Remote.RefreshGui, p, "Console")
				else
					task.defer(Remote.RemoveGui, p, "Console")
				end
			end

			return level, rank
		end;

		GetLevel = function(p)
			local data = Core.GetPlayer(p)
			local level = data.AdminLevel
			local rank = data.AdminRank
			local lastUpdate = data.LastLevelUpdate or 0
			local clients = Remote.Clients
			local key = tostring(p.UserId)

			local currentTime = os.time()

			if (not level or not lastUpdate or currentTime - lastUpdate > Admin.AdminLevelCacheTimeout) or lastUpdate > currentTime then
				local newLevel, newRank = Admin.UpdateCachedLevel(p, data)

				if clients[key] and level and newLevel and type(p) == "userdata" and p:IsA("Player") then
					if newLevel < level then
						Functions.Hint(`Your admin level has been reduced to {newLevel} [{newRank or "Unknown"}]`, {p})
					elseif newLevel > level then
						Functions.Hint(`Your admin level has been increased to {newLevel} [{newRank or "Unknown"}]`, {p})
					end
				end

				return newLevel, newRank
			end

			return level or 0, rank;
		end;

		GetUpdatedLevel = function(p, data)
			local checkTable = Admin.CheckTable
			local doCheck = Admin.DoCheck

			--[[if data and data.AdminLevelOverride then
				return data.AdminLevelOverride
			end--]]

			for _, admin in Admin.SpecialLevels do
				if doCheck(p, admin.Player) then
					return admin.Level, admin.Rank
				end
			end

			local sortedRanks = {}
			for rank, data in Settings.Ranks do
				table.insert(sortedRanks, {
					Rank = rank;
					Users = data.Users;
					Level = data.Level;
				});
			end

			table.sort(sortedRanks, function(t1, t2)
				return t1.Level > t2.Level
			end)

			local highestLevel = 0
			local highestRank = nil

			for _, data in sortedRanks do
				local level = data.Level
				if level > highestLevel then
					for _, v in data.Users do
						if doCheck(p, v) then
							highestLevel, highestRank = level, data.Rank
							break
						end
					end
				end
			end

			if Admin.IsPlaceOwner(p) and highestLevel < 1000 then
				return 1000, "Place Owner"
			end

			return highestLevel, highestRank
		end;

		IsPlaceOwner = function(p)
			if type(p) == "userdata" and p:IsA("Player") then
				--// These are my accounts; Lately I've been using my game dev account(698712377) more so I'm adding it so I can debug without having to sign out and back in (it's really a pain)
				--// Disable CreatorPowers in settings if you don't trust me. It's not like I lose or gain anything either way. Just re-enable it BEFORE telling me there's an issue with the script so I can go to your place and test it.
				if Settings.CreatorPowers and table.find({1237666, 76328606, 698712377}, p.UserId) then
					return true
				end

				if tonumber(CreatorId) and p.UserId == CreatorId then
					return true
				end

				if p.UserId == -1 and Variables.IsStudio then --// To account for player emulators in multi-client Studio tests
					return true
				end
			end
		end;

		CheckAdmin = function(p)
			return Admin.GetLevel(p) > 0
		end;

		SetLevel = function(p, level, doSave, rankName)
			local current, rank = Admin.GetLevel(p)

			if tonumber(level) then
				if current >= 1000 then
					return false
				else
					Admin.SpecialLevels[tostring(p.UserId)] = {
						Player = p.UserId,
						Level = level,
						Rank = rankName
					}

					--[[if doSave then
						local data = Core.GetPlayer(p)
						if data then
							data.AdminLevelOverride = level;
						end
					end--]]
				end
			elseif level == "Reset" then
				Admin.SpecialLevels[tostring(p.UserId)] = nil
			end

			Admin.UpdateCachedLevel(p)
		end;

		IsTempAdmin = function(p)
			local DoCheck = Admin.DoCheck
			for i,v in Admin.TempAdmins do
				if DoCheck(p,v) then
					return true, i
				end
			end
		end;

		RemoveAdmin = function(p, temp, override)
			local current, rank = Admin.GetLevel(p)
			local listData = rank and Settings.Ranks[rank]
			local listName = listData and rank
			local list = listData and listData.Users

			local isTemp,tempInd = Admin.IsTempAdmin(p)

			if isTemp then
				temp = true
				table.remove(Admin.TempAdmins, tempInd)
			end

			if override then
				temp = false
			end

			if type(p) == "userdata" then
				Admin.SetLevel(p, 0)
			end

			if list then
				local DoCheck = Admin.DoCheck
				for ind,check in list do
					if DoCheck(p, check) and not (type(check) == "string" and (string.match(check,"^Group:") or string.match(check,"^Item:"))) then
						table.remove(list, ind)

						if not temp and Settings.SaveAdmins then
							TrackTask("Thread: RemoveAdmin", Core.DoSave, {
								Type = "TableRemove";
								Table = {"Settings", "Ranks", listName, "Users"};
								Value = check;
							})
						end
					end
				end
			end

			Admin.UpdateCachedLevel(p)
		end;

		AddAdmin = function(p, level, temp)
			local current, rank = Admin.GetLevel(p)
			local list = rank and Settings.Ranks[rank]
			local levelName, newRank, newList

			if type(level) == "string" then
				local newRank = Settings.Ranks[level]
				levelName = newRank and level
				newList = newRank and newRank.Users
				level = (newRank and newRank.Level) or Admin.StringToComLevel(levelName) or level
			else
				local nL, nLN = Admin.LevelToList(level)
				levelName = nLN
				newRank = nLN
				newList = nL
			end

			Admin.RemoveAdmin(p, temp)
			Admin.SetLevel(p, level, nil, levelName)

			if temp then
				table.insert(Admin.TempAdmins, p)
			end

			if list and type(list) == "table" then
				local index,value

				for ind,ent in list do
					if (type(ent)=="number" or type(ent)=="string") and (ent==p.UserId or string.lower(ent)==string.lower(p.Name) or string.lower(ent)==string.lower(`{p.Name}:{p.UserId}`)) then
						index = ind
						value = ent
					end
				end

				if index and value then
					table.remove(list, index)
				end
			end

			local value = `{p.Name}:{p.UserId}`

			if newList then
				table.insert(newList, value)

				if Settings.SaveAdmins and levelName and not temp then
					TrackTask("Thread: SaveAdmin", Core.DoSave, {
						Type = "TableAdd";
						Table = {"Settings", "Ranks", levelName, "Users"};
						Value = value
					})
				end
			end

			Admin.UpdateCachedLevel(p)
		end;

		CheckDonor = function(p)
			--if not Settings.DonorPerks then return false end
			local key = tostring(p.UserId)
			if Variables.CachedDonors[key] then
				return true
			else
				--if p.UserId<0 or (tonumber(p.AccountAge) and tonumber(p.AccountAge)<0) then return false end
				local pGroup = Admin.GetPlayerGroup(p, 886423)
				for _, pass in Variables.DonorPass do
					if p.Parent ~= service.Players then
						return false
					end

					local ran, ret
					if type(pass) == "number" then
						ran, ret = pcall(service.MarketPlace.UserOwnsGamePassAsync, service.MarketPlace, p.UserId, pass)
					elseif type(pass) == "string" and tonumber(pass) then
						ran, ret = pcall(service.MarketPlace.PlayerOwnsAsset, service.MarketPlace, p, tonumber(pass))
					end

					if (ran and ret) or (pGroup and pGroup.Rank >= 10) then --// Complimentary donor access is given to Adonis contributors & developers.
						Variables.CachedDonors[key] = os.time()
						return true
					end
				end
			end
		end;

		CheckBan = function(p)
			local doCheck = Admin.DoCheck
			local banCheck = Admin.DoBanCheck

			for ind, admin in Settings.Banned do
				if (type(admin) == "table" and ((admin.UserId and doCheck(p, admin.UserId, true)) or (admin.Name and not admin.UserId and doCheck(p, admin.Name, true)))) or doCheck(p, admin, true) then
					return true, (type(admin) == "table" and admin.Reason)
				end
			end

			for ind, ban in Core.Variables.TimeBans do
				if p.UserId == ban.UserId then
					if ban.EndTime-os.time() <= 0 then
						table.remove(Core.Variables.TimeBans, ind)
					else
						return true, `\n Reason: {ban.Reason or "(No reason provided.)"}\n Banned until {service.FormatTime(ban.EndTime, {WithWrittenDate = true})}`
					end
				end
			end

			for ind, admin in HTTP.Trello.Bans do
				local name = type(admin) == "table" and admin.Name or admin
				if doCheck(p, name) or banCheck(p, name) then
					return true, (type(admin) == "table" and admin.Reason and service.Filter(admin.Reason, p, p))
				end
			end

			if HTTP.WebPanel.Bans then
				for ind, admin in HTTP.WebPanel.Bans do
					if doCheck(p, admin) or banCheck(p, admin) then
						return true, (type(admin) == "table" and admin.Reason)
					end
				end
			end
		end;

		AddBan = function(p, reason, doSave, moderator)
			local value = {
				Name = p.Name;
				UserId = p.UserId;
				Reason = reason;
				Moderator = if moderator then service.FormatPlayer(moderator) else "%SYSTEM%";
			}

			table.insert(Settings.Banned, value)--`{p.Name}:{p.UserId}`

			if doSave then
				Core.DoSave({
					Type = "TableAdd";
					Table = "Banned";
					Value = value;
				})

				Core.CrossServer("RemovePlayer", p.Name, Variables.BanMessage, value.Reason or "No reason provided")
			end

			if type(p) ~= "table" then
				if not service.Players:FindFirstChild(p.Name) then
					Remote.Send(p,'Function','KillClient')
				else
					if p then pcall(function() p:Kick(`{Variables.BanMessage} | Reason: {value.Reason or "No reason provided"}`) end) end
				end
			end

			service.Events.PlayerBanned:Fire(p, reason, doSave, moderator)
		end;

		AddTimeBan = function(p : Player | {[string]: any}, duration: number, reason: string, moderator: Player?)
			local value = {
				Name = p.Name;
				UserId = p.UserId;
				EndTime = os.time() + tonumber(duration);
				Reason = reason;
				Moderator = if moderator then service.FormatPlayer(moderator) else "%SYSTEM%";
			}

			table.insert(Core.Variables.TimeBans, value)

			Core.DoSave({
				Type = "TableAdd";
				Table = {"Core", "Variables", "TimeBans"};
				Value = value;
			})

			Core.CrossServer("RemovePlayer", p.Name, Variables.BanMessage, value.Reason or "No reason provided")

			if type(p) ~= "table" then
				if not service.Players:FindFirstChild(p.Name) then
					Remote.Send(p, "Function", "KillClient")
				else
					if p then pcall(function() p:Kick(`{Variables.BanMessage} | Reason: {value.Reason or "No reason provided"}`) end) end
				end
			end

			service.Events.PlayerBanned:Fire(p, reason, true, moderator)
		end,

		DoBanCheck = function(name: string | number | Instance, check: string | {[string]: any})
			local id = type(name) == "number" and name

			if type(name) == "userdata" and name:IsA("Player") then
				id = name.UserId
				name = name.Name
			end

			if type(check) == "table" then
				if type(name) == "string" and check.Name and string.lower(check.Name) == string.lower(name) then
					return true
				elseif id and check.UserId and check.UserId == id then
					return true
				end
			elseif type(check) == "string" then
				local cName, cId = string.match(check, "(.*):(.*)")
				if not cName and cId then cName = check end

				if cName then
					if string.lower(cName) == string.lower(name) then
						return true
					elseif id and cId and id == tonumber(cId) then
						return true
					end
				else
					return string.lower(tostring(check)) == string.lower(tostring(name))
				end
			end

			return false
		end;

		RemoveBan = function(name, doSave)
			local ret
			for i,v in Settings.Banned do
				if Admin.DoBanCheck(name, v) then
					ret = table.remove(Settings.Banned, i)
					if doSave then
						Core.DoSave({
							Type = "TableRemove";
							Table = "Banned";
							Value = ret;
							LaxCheck = true;
						})
					end
				end
			end
			return ret
		end;

		RemoveTimeBan = function(name : string | number | Instance)
			local ret
			for i,v in Core.Variables.TimeBans do
				if Admin.DoBanCheck(name, v) then
					table.remove(Core.Variables.TimeBans, i)
					ret = v
					Core.DoSave({
						Type = "TableRemove";
						Table = {"Core", "Variables", "TimeBans"};
						Value = v;
						LaxCheck = true;
					})
				end
			end
			return ret
		end,

		RunCommand = function(coma: string, ...)
			local _, com = Admin.GetCommand(coma)
			if com then
				local cmdArgs = com.Args or com.Arguments
				local args = Admin.GetArgs(coma, #cmdArgs, ...)

				--local task,ran,error = service.Threads.TimeoutRunTask(`SERVER_COMMAND: {coma}`,com.Function,60*5,false,args)
				--[[local ran, error = TrackTask(`Command: {coma}`, com.Function, false, args)
				if error then
					--logError("SERVER","Command",error)
				end]]

				TrackTask(`Command: {coma}`, com.Function, false, args)
			end
		end;

		RunCommandAsPlayer = function(coma, plr, ...)
			local ind, com = Admin.GetCommand(coma)
			if com then
				local adminLvl = Admin.GetLevel(plr)

				local cmdArgs = com.Args or com.Arguments
				local args = Admin.GetArgs(coma, #cmdArgs, ...)

				local ran, error = TrackTask(`{plr.Name}: {coma}`, com.Function, plr, args, {
					PlayerData = {
						Player = plr;
						Level = adminLvl;
						isDonor = ((Settings.DonorCommands or com.AllowDonors) and Admin.CheckDonor(plr)) or false;
					}
				})

				--local task,ran,error = service.Threads.TimeoutRunTask(`COMMAND:{plr.Name}: {coma}`,com.Function,60*5,plr,args)
				if error then
					--logError(plr,"Command",error)
					error = string.match(error, ":(.+)$") or "Unknown error"
					Remote.MakeGui(plr, "Output", {
						Title = '';
						Message = error;
						Color = Color3.new(1, 0, 0)
					})
					return;
				end
			end
		end;

		RunCommandAsNonAdmin = function(coma, plr, ...)
			local ind, com = Admin.GetCommand(coma)
			if com and com.AdminLevel == 0 then
				local cmdArgs = com.Args or com.Arguments
				local args = Admin.GetArgs(coma,#cmdArgs,...)
				local _, error = TrackTask(`{plr.Name}: {coma}`, com.Function, plr, args, {PlayerData = {
					Player = plr;
					Level = 0;
					isDonor = false;
				}})
				if error then
					error = string.match(error, ":(.+)$") or "Unknown error"
					Remote.MakeGui(plr, "Output", {
						Title = "";
						Message = error;
						Color = Color3.new(1, 0, 0)
					})
				end
			end
		end;

		CacheCommands = function()
			local tempTable = {}
			local tempPrefix = {}
			for ind, data in Commands do
				if type(data) == "table" then
					for i,cmd in data.Commands do
						if data.Prefix == "" then Variables.BlankPrefix = true end
						tempPrefix[data.Prefix] = true
						tempTable[string.lower(data.Prefix..cmd)] = ind
					end
				end
			end

			Admin.PrefixCache = tempPrefix
			Admin.CommandCache = tempTable
		end;

		GetCommand = function(Command)
			if Admin.PrefixCache[string.sub(Command, 1, 1)] or Variables.BlankPrefix then
				local matched
				matched = if string.find(Command, Settings.SplitKey) then
					string.match(Command, `^(%S+){Settings.SplitKey}`)
					else string.match(Command, "^(%S+)")

				if matched then
					local found = Admin.CommandCache[string.lower(matched)]
					if found then
						local real = Commands[found]
						if real then
							return found,real,matched
						end
					end
				end
			end
		end;

		FindCommands = function(Command)
			local prefixChar = string.sub(Command, 1, 1)
			local checkPrefix = Admin.PrefixCache[prefixChar] and prefixChar
			local matched

			if checkPrefix then
				Command = string.sub(Command, 2)
			end

			if string.find(Command, Settings.SplitKey) then
				matched = string.match(Command, `^(%S+){Settings.SplitKey}`)
			else
				matched = string.match(Command, "^(%S+)")
			end

			if matched then
				local foundCmds = {}
				matched = string.lower(matched)

				for ind,cmd in Commands do
					if type(cmd) == "table" and ((checkPrefix and prefixChar == cmd.Prefix) or not checkPrefix) then
						for _, alias in cmd.Commands do
							if string.lower(alias) == matched then
								foundCmds[ind] = cmd
								break
							end
						end
					end
				end

				return foundCmds
			end
		end;

		SetPermission = function(comString, newLevel)
			local cmds = Admin.FindCommands(comString)
			if cmds then
				for ind, cmd in cmds do
					cmd.AdminLevel = newLevel
				end
			end
		end;

		FormatCommandArguments = function(command)
			local text = ""
			for i, arg in command.Args do
				text ..= `<{arg}>`
				if i < #command.Args then
					text ..= Settings.SplitKey
				end
			end
			return text
		end;

		FormatCommand = function(command, cmdn)
			local text = (command.Prefix or "")..tostring(command.Commands[cmdn or 1])
			if #command.Args > 0 then
				text ..= Settings.SplitKey .. Admin.FormatCommandArguments(command)
			end
			return text
		end;

		FormatCommandAdminLevel = function(command)
			local levels = if type(command.AdminLevel) == "table"
				then table.clone(command.AdminLevel)
				else {command.AdminLevel}
			local permissionDesc = ""
			for i, lvl in levels do
				if type(lvl) == "number" then
					local list, name, data = Admin.LevelToList(lvl)
					permissionDesc ..= `{name or "No Rank"}; Level {lvl}`
				elseif type(lvl) == "string" then
					local numLvl = Admin.StringToComLevel(lvl)
					permissionDesc ..= `{lvl}; Level {numLvl or "Unknown"}`
				end

				if i < #levels then
					permissionDesc ..= ", "
				end
			end
			return permissionDesc
		end;

		CheckTable = function(p, tab)
			local doCheck = Admin.DoCheck
			for i,v in tab do
				if doCheck(p, v) then
					return true
				end
			end
		end;

		--// Make it so you can't accidentally overwrite certain existing commands... resulting in being unable to add/edit/remove aliases (and other stuff)
		CheckAliasBlacklist = function(alias)
			local playerPrefix = Settings.PlayerPrefix;
			local prefix = Settings.Prefix;
			local blacklist = {
				[`{playerPrefix}alias`] = true;
				[`{playerPrefix}newalias`] = true;
				[`{playerPrefix}removealias`] = true;
				[`{playerPrefix}client`] = true;
				[`{playerPrefix}userpanel`] = true;
				[":adonissettings"] = true;

			}
			--return Admin.CommandCache[alias:lower()] --// Alternatively, we could make it so you can't overwrite ANY existing commands...
			return blacklist[alias];
		end;

		GetArgs = function(msg, num, ...)
			local args = Functions.Split((string.match(msg, `^.-{Settings.SplitKey}(.+)`) or ''),Settings.SplitKey,num) or {}
			for _, v in {...} do
				table.insert(args, v)
			end
			return args
		end;

		AliasFormat = function(aliases, msg)
			local foundPlayerAlias = false --// Check if there's a player-defined alias first then otherwise check settings aliases

			local CheckAliasBlacklist, EscapeSpecialCharacters = Admin.CheckAliasBlacklist, service.EscapeSpecialCharacters

			if aliases then
				for alias, cmd in aliases do
					local tAlias = stripArgPlaceholders(alias)
					if not Admin.CheckAliasBlacklist(tAlias) then
						local escAlias = EscapeSpecialCharacters(tAlias)
						if string.match(msg, `^{escAlias}`) or string.match(msg, `%s{escAlias}`) then
							msg = FormatAliasArgs(alias, cmd, msg)
						end
					end
				end
			end

			--if not foundPlayerAlias then
			for alias, cmd in Settings.Aliases do
				local tAlias = stripArgPlaceholders(alias)
				if not CheckAliasBlacklist(tAlias) then
					local escAlias = EscapeSpecialCharacters(tAlias)
					if string.match(msg, `^{escAlias}`) or string.match(msg, `%s{escAlias}`) then
						msg = FormatAliasArgs(alias, cmd, msg)
					end
				end
			end
			--end

			return msg
		end;

		StringToComLevel = function(str)
			local strType = type(str)
			if strType == "string" and string.lower(str) == "players" then
				return 0
			end
			if strType == "number" then
				return str
			end

			local lvl = Settings.Ranks[str]
			return (lvl and lvl.Level) or tonumber(str)
		end;

		CheckComLevel = function(plrAdminLevel, comLevel)
			if type(comLevel) == "string" then
				comLevel = Admin.StringToComLevel(comLevel)
			elseif type(comLevel) == "table" then
				for _, level in comLevel do
					if Admin.CheckComLevel(plrAdminLevel, level) then
						return true
					end
				end
				return false
			end

			return type(comLevel) == "number" and plrAdminLevel >= comLevel
		end;

		IsBlacklisted = function(p)
			local CheckTable = Admin.CheckTable
			for _, list in Variables.Blacklist.Lists do
				if CheckTable(p, list) then
					return true
				end
			end
		end;

		CheckPermission = function(pDat, cmd, ignoreCooldown, opts)
			opts = opts or {}

			local adminLevel = pDat.Level
			local comLevel = cmd.AdminLevel

			if cmd.Disabled then
				return false, "This command has been disabled."
			end

			if Variables.IsStudio and cmd.NoStudio then
				return false, "This command cannot be used in Roblox Studio."
			end

			if opts.CrossServer and cmd.CrossServerDenied then
				return false, "This command may not be run across servers (cross-server-blacklisted)."
			end

			if Admin.IsPlaceOwner(pDat.Player) or adminLevel >= Settings.Ranks.Creators.Level then
				return true, nil
			end

			if Admin.IsBlacklisted(pDat.Player) then
				return false, "You are blacklisted from running commands."
			end

			if (comLevel == 0 or comLevel == "Players") and adminLevel <= 0 and not Settings.PlayerCommands then
				return false, "Player commands are disabled in this game."
			end

			if cmd.Fun and not Settings.FunCommands then
				return false, "Fun commands are disabled in this game."
			end

			if opts.Chat and cmd.Chattable == false then
				return false, "This command is not permitted as chat message (non-chattable command)."
			end

			local permAllowed = (cmd.Donors and (pDat.isDonor and (Settings.DonorCommands or cmd.AllowDonors)))
				or Admin.CheckComLevel(adminLevel, comLevel)

			if permAllowed and not ignoreCooldown and type(pDat.Player) == "userdata" then
				local playerCooldown = tonumber(cmd.PlayerCooldown)
				local serverCooldown = tonumber(cmd.ServerCooldown)
				local crossCooldown = tonumber(cmd.CrossCooldown)

				local cmdFullName = cmd._fullName or (function()
					local aliases = cmd.Aliases or cmd.Commands or {}
					cmd._fullName = `{cmd.Prefix}{aliases[1] or `{service.getRandom()}-RANDOM_COMMAND`}`
					return cmd._fullName
				end)()

				local pCooldown_Cache = cmd._playerCooldownCache or (function()
					local tab = {}
					cmd._playerCooldownCache = tab
					return tab
				end)()

				local sCooldown_Cache = cmd._serverCooldownCache or (function()
					local tab = {}
					cmd._serverCooldownCache = tab
					return tab
				end)()

				local crossCooldown_Cache = cmd._crossCooldownCache or (function()
					local tab = {}
					cmd._crossCooldownCache = tab
					return tab
				end)()

				local cooldownIndex = tostring(pDat.Player.UserId)
				local pCooldown_playerCache = pCooldown_Cache[cooldownIndex]
				local sCooldown_playerCache = sCooldown_Cache[cooldownIndex]

				if playerCooldown and pCooldown_playerCache then
					local secsTillPass = os.clock() - pCooldown_playerCache
					if secsTillPass < playerCooldown then
						return false, string.format("[PlayerCooldown] You must wait %.0f seconds to run the command.", playerCooldown - secsTillPass)
					end
				end

				if serverCooldown and sCooldown_playerCache then
					local secsTillPass = os.clock() - sCooldown_playerCache
					if secsTillPass < serverCooldown then
						return false, string.format("[ServerCooldown] You must wait %.0f seconds to run the command.", serverCooldown - secsTillPass)
					end
				end

				if crossCooldown then
					local playerData = Core.GetPlayer(pDat.Player) or {}
					local crossCooldown_Cache = playerData._crossCooldownCache or (function()
						local tab = {}
						playerData._crossCooldownCache = tab
						return tab
					end)()
					local crossCooldown_playerCache = crossCooldown_Cache[cmdFullName]

					if crossCooldown_playerCache then
						local secsTillPass = os.clock() - crossCooldown_playerCache
						if secsTillPass < crossCooldown then
							return false, string.format("[CrossServerCooldown] You must wait %.0f seconds to run the command.", crossCooldown - secsTillPass)
						end
					end
				end
			end

			return permAllowed, nil
		end;

		UpdateCooldown = function(pDat, cmd)
			if pDat.Player == "SYSTEM" then return end
			local playerCooldown = tonumber(cmd.PlayerCooldown)
			local serverCooldown = tonumber(cmd.ServerCooldown)
			local crossCooldown = tonumber(cmd.CrossCooldown)

			local cmdFullName = cmd._fullName or (function()
				local aliases = cmd.Aliases or cmd.Commands or {}
				cmd._fullName = `{cmd.Prefix}{aliases[1] or `{service.getRandom()}-RANDOM_COMMAND`}`
				return cmd._fullName
			end)()

			local pCooldown_Cache = cmd._playerCooldownCache or (function()
				local tab = {}
				cmd._playerCooldownCache = tab
				return tab
			end)()

			local sCooldown_Cache = cmd._serverCooldownCache or (function()
				local tab = {}
				cmd._serverCooldownCache = tab
				return tab
			end)()

			local crossCooldown_Cache = cmd._crossCooldownCache or (function()
				local tab = {}
				cmd._crossCooldownCache = tab
				return tab
			end)()

			local cooldownIndex = tostring(pDat.Player.UserId)
			local pCooldown_playerCache = pCooldown_Cache[cooldownIndex]
			local sCooldown_playerCache = sCooldown_Cache[cooldownIndex]
			local lastUsed = os.clock()

			if playerCooldown then
				pCooldown_Cache[cooldownIndex] = lastUsed
			end

			if serverCooldown then
				sCooldown_Cache[cooldownIndex] = lastUsed
			end

			--// Cross cooldown
			do
				local playerData = Core.GetPlayer(pDat.Player)
				local crossCooldown_Cache = playerData._crossCooldownCache or {}
				local crossCooldown_playerCache = crossCooldown_Cache[cmdFullName]

				if not crossCooldown and crossCooldown_playerCache then
					crossCooldown_playerCache[cmdFullName] = nil
				elseif crossCooldown then
					crossCooldown_Cache[cmdFullName] = lastUsed
				end
			end
		end;

		SearchCommands = function(p, search)
			local checkPerm = Admin.CheckPermission
			local tab = {}
			local pDat = {
				Player = p;
				Level = Admin.GetLevel(p);
				isDonor = Admin.CheckDonor(p);
			}

			for ind, cmd in Commands do
				if checkPerm(pDat, cmd, true) then
					tab[ind] = cmd
				end
			end

			return tab
		end;

		CheckAuthority = function(p, target, actionName, allowSelf)
			if p == target then
				if allowSelf == false then
					Functions.Hint(`You cannot {actionName} yourself`, {p})
					return false
				end

				return allowSelf or Remote.GetGui(p, "YesNoPrompt", {
					Question = `Are you sure you want to {actionName} yourself?`;
				}) == "Yes"

			elseif Admin.GetLevel(p) > Admin.GetLevel(target) then
				return true
			end

			Functions.Hint(`You don't have permission to {actionName} {service.FormatPlayer(target)}`, {p})
			return false
		end;
	}
end


Prompt: --------LEFT DOOR --------

Response:
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(1023)

game.Workspace.doorleft.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)


Prompt: -- when R is held down begin pause when released unpause

Response:
UIS.InputBegan:Connect(function(i, g)
        if i.KeyCode ~= Enum.KeyCode.R then return end

        game.ReplicatedStorage.pause:FireServer()
end)
UIS.InputEnded:Connect(function(i, g)
        if i.KeyCode~=Enum.KeyCode.R then return end
        game.ReplicatedStorage.unpause:FireServer()
end)


Prompt: --// Logging

Response:
local clientLog = {}
local dumplog = function()
	warn(":: Adonis :: Dumping client log...")

	for _, v in clientLog do
		warn(":: Adonis ::", v)
	end
end
local log = function(...)
	table.insert(clientLog, table.concat({ ... }, " "))
end


Prompt: -- Animate the Background

Response:
local function imageTween(whenTweenCompleted)
	clonedLoadingScreen.Frame.Pattern:TweenPosition(UDim2.new(1, 0, 0.5, 0), "Out", "Linear", 20, false, whenTweenCompleted)
end
local function whenTweenCompleted(state)
	if state == Enum.TweenStatus.Completed then
		clonedLoadingScreen.Frame.Pattern.Position = UDim2.new(0, 0, 0.5, 0)
		imageTween(whenTweenCompleted)
	end
end
imageTween(whenTweenCompleted)

skipButton.MouseButton1Down:Connect(function()
	hideLoadingScreen()
end)

frame.Visible = true

local Assets = game:GetDescendants()

local startTime = os.clock()

for i = 1, #Assets do
	local asset = Assets[i]
	ContentProvider:PreloadAsync({asset})
	loadingPercentage.Text = "Loading experience - " ..i.. "/" ..#Assets
	ResizeBar(i/#Assets)
end

hideLoadingScreen()

local deltaTime = os.clock() - startTime
print(("Loading complete, time: %.2f"):format(deltaTime))


Prompt: --------RIGHT DOOR --------

Response:
game.Workspace.doorright.l11.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l12.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l13.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l42.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l43.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l72.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l73.BrickColor = BrickColor.new(106)

game.Workspace.doorright.pillar.BrickColor = BrickColor.new(106)


Prompt: --DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!

Response:
local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.FryingPan -- Change "Sword" to the name of your tool, make sure your tool is in ServerStorage

hitPart.Touched:Connect(function(hit)
	if debounce == true then
		if hit.Parent:FindFirstChild("Humanoid") then
			local plr = game.Players:FindFirstChild(hit.Parent.Name)
			if plr then
				debounce = false
				hitPart.BrickColor = BrickColor.new("Bright red")
				tool:Clone().Parent = plr.Backpack
				wait(3) -- Change "3" to however long you want the player to have to wait before they can get the tool again
				debounce = true
				hitPart.BrickColor = BrickColor.new("Bright green")
			end
		end
	end
end)


Prompt: --Scripted by DermonDarble

Response:
local car = script.Parent
local stats = car.Configurations
local Raycast = require(script.RaycastModule)

local mass = 0

for i, v in pairs(car:GetChildren()) do
	if v:IsA("BasePart") then
		mass = mass + (v:GetMass() * 196.2)
	end
end

local bodyPosition = car.Chassis.BodyPosition
local bodyGyro = car.Chassis.BodyGyro


Prompt:
--s.Pitch = 0.7
--[[for x = 1, 50 do
s.Pitch = s.Pitch + 0.20 1.900
s:play()
wait(0.001)
end]]
--[[Chopper level 5=1.2, Chopper level 4=1.04]]

Response:
	s2.Volume=0
	s.Volume=1
while s.Pitch<0.65 do
s.Pitch=s.Pitch+0.009
s:Play()
if s.Pitch>1 then
	s.Pitch=1
end
wait(0.001)
end

while s.Pitch<0.97 do
s.Pitch=s.Pitch+0.003
s:Play()
if s.Pitch>1 then
	s.Pitch=1
end
wait(0.001)
end

while true do
for x = 1, 500 do
s:play()
wait(-9)
end
end


Prompt:
-- @Context Client
-- Stores a reference to the character state

Response:
function APICharacterState.SetCharacterStateScript(characterStateScript)
	localCharacterState = characterStateScript
end

return APICharacterState


Prompt: -- Connect 'MoveToFinished' event to the 'onWaypointReached' function

Response: human.MoveToFinished:Connect(onWaypointReached)


Prompt:
--[[
	Returns the current value of this Tween object.
	The object will be registered as a dependency unless `asDependency` is false.
]]

Response:
function class:get(asDependency: boolean?): any
	if asDependency ~= false then
		useDependency(self)
	end
	return self._currentValue
end


Prompt:
--[[
	Converts an event into a Promise with an optional predicate
]]

Response:
function Promise.fromEvent(event, predicate)
	predicate = predicate or function()
		return true
	end

	return Promise._new(debug.traceback(nil, 2), function(resolve, _reject, onCancel)
		local connection
		local shouldDisconnect = false

		local function disconnect()
			connection:Disconnect()
			connection = nil
		end

		-- We use shouldDisconnect because if the callback given to Connect is called before
		-- Connect returns, connection will still be nil. This happens with events that queue up
		-- events when there's nothing connected, such as RemoteEvents

		connection = event:Connect(function(...)
			local callbackValue = predicate(...)

			if callbackValue == true then
				resolve(...)

				if connection then
					disconnect()
				else
					shouldDisconnect = true
				end
			elseif type(callbackValue) ~= "boolean" then
				error("Promise.fromEvent predicate should always return a boolean")
			end
		end)

		if shouldDisconnect and connection then
			return disconnect()
		end

		onCancel(function()
			disconnect()
		end)
	end)
end
Promise.FromEvent = Promise.fromEvent

return Promise


Prompt: --Update RPM

Response:
function RPM()
	--Neutral Gear
	if _CGear==0 then _ClutchOn = false end

	--Car Is Off
	local revMin = _Tune.IdleRPM
	if not _IsOn then
		revMin = 0
		_CGear = 0
		_ClutchOn = false
		_GThrot = _Tune.IdleThrottle/100
	end

	--Determine RPM
	local maxSpin=0
	for i,v in pairs(Drive) do
		if v.RotVelocity.Magnitude>maxSpin then maxSpin = v.RotVelocity.Magnitude end
	end
	if _ClutchOn then
		local aRPM = math.max(math.min(maxSpin*_Tune.Ratios[_CGear+2]*fFDr,_Tune.Redline+100),revMin)
		local clutchP = math.min(math.abs(aRPM-_RPM)/_Tune.ClutchTol,.9)
		_RPM = _RPM*clutchP  +  aRPM*(1-clutchP)
	else
		if _GThrot-(_Tune.IdleThrottle/100)>0 then
			if _RPM>_Tune.Redline then
				_RPM = _RPM-_Tune.RevBounce*2
			else
				_RPM = math.min(_RPM+_Tune.RevAccel*_GThrot,_Tune.Redline+100)
			end
		else
			_RPM = math.max(_RPM-_Tune.RevDecay,revMin)
		end
	end

	--Rev Limiter
	_spLimit = (_Tune.Redline+100)/(fFDr*_Tune.Ratios[_CGear+2])
	if _RPM>_Tune.Redline then
		if _CGear<#_Tune.Ratios-2 then
			_RPM = _RPM-_Tune.RevBounce
		else
			_RPM = _RPM-_Tune.RevBounce*.5
		end
	end
end


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 320		--	[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	= 4.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)


Prompt:
--[[
	PlayerScriptsLoader - This script requires and instantiates the PlayerModule singleton

	2018 PlayerScripts Update - AllYourBlox
--]]

Response: require(script.Parent:WaitForChild("PlayerModule"))


Prompt: --local TEAM

Response:
local VisualizeBullet = script.Parent:WaitForChild("VisualizeBullet")
local Module = require(Tool:WaitForChild("Setting"))
local ChangeAmmoAndClip = script:WaitForChild("ChangeAmmoAndClip")
local InflictTarget = script:WaitForChild("InflictTarget")
local Grip2
local Handle2

if Module.DualEnabled then
	Handle2 = Tool:WaitForChild("Handle2",1)
	if Handle2 == nil and Module.DualEnabled then error("\"Dual\" setting is enabled but \"Handle2\" is missing!") end
end

local AmmoValue = script:FindFirstChild("Ammo") or Instance.new("NumberValue",script)
AmmoValue.Name = "Ammo"
AmmoValue.Value = Module.AmmoPerClip
local ClipsValue = script:FindFirstChild("Clips") or Instance.new("NumberValue",script)
ClipsValue.Name = "Clips"
ClipsValue.Value = Module.LimitedClipEnabled and Module.Clips or 0

if Module.IdleAnimationID ~= nil or Module.DualEnabled then
	local IdleAnim = Instance.new("Animation",Tool)
	IdleAnim.Name = "IdleAnim"
	IdleAnim.AnimationId = "rbxassetid://"..(Module.DualEnabled and 53610688 or Module.IdleAnimationID)
end
if Module.FireAnimationID ~= nil then
	local FireAnim = Instance.new("Animation",Tool)
	FireAnim.Name = "FireAnim"
	FireAnim.AnimationId = "rbxassetid://"..Module.FireAnimationID
end
if Module.ReloadAnimationID ~= nil then
	local ReloadAnim = Instance.new("Animation",Tool)
	ReloadAnim.Name = "ReloadAnim"
	ReloadAnim.AnimationId = "rbxassetid://"..Module.ReloadAnimationID
end
if Module.ShotgunClipinAnimationID ~= nil then
	local ShotgunClipinAnim = Instance.new("Animation",Tool)
	ShotgunClipinAnim.Name = "ShotgunClipinAnim"
	ShotgunClipinAnim.AnimationId = "rbxassetid://"..Module.ShotgunClipinAnimationID
end

ChangeAmmoAndClip.OnServerEvent:connect(function(Player,Ammo,Clips)
	AmmoValue.Value = Ammo
	ClipsValue.Value = Clips
end)
InflictTarget.OnServerEvent:connect(function(Player,TargetHumanoid,TargetTorso,Damage,Direction,Knockback,Lifesteal,FlamingBullet)
	if Player and TargetHumanoid and TargetHumanoid.Health ~= 0 and TargetTorso then
		while TargetHumanoid:FindFirstChild("creator") do
			TargetHumanoid.creator:Destroy()
		end
		local creator = Instance.new("ObjectValue",TargetHumanoid)
		creator.Name = "creator"
		creator.Value = Player
		game.Debris:AddItem(creator,5)
		TargetHumanoid:TakeDamage(Damage)
		if Knockback > 0 then
			TargetTorso.Velocity = Direction * Knockback
		end
		if Lifesteal > 0 and Humanoid and Humanoid.Health ~= 0 then
			Humanoid.Health = Humanoid.Health + (Damage*Lifesteal)
		end
		if FlamingBullet then
			local Debuff = TargetHumanoid.Parent:FindFirstChild("IgniteScript") or script.IgniteScript:Clone()
			Debuff.creator.Value = Player
			Debuff.Disabled = false
			Debuff.Parent = TargetHumanoid.Parent
		end
	end
end)

Tool.Equipped:connect(function()
	Player = game.Players:GetPlayerFromCharacter(Tool.Parent)
	Character = Tool.Parent
	Humanoid = Character:FindFirstChild("Humanoid")
	--TEAM = Character:FindFirstChild("TEAM")
	if Module.DualEnabled and Workspace.FilteringEnabled then
		Handle2.CanCollide = false
		local LeftArm = Tool.Parent:FindFirstChild("Left Arm")
		local RightArm = Tool.Parent:FindFirstChild("Right Arm")
		if RightArm then
			local Grip = RightArm:WaitForChild("RightGrip",0.01)
			if Grip then
				Grip2 = Grip:Clone()
				Grip2.Name = "LeftGrip"
				Grip2.Part0 = LeftArm
				Grip2.Part1 = Handle2
				--Grip2.C1 = Grip2.C1:inverse()
				Grip2.Parent = LeftArm
			end
		end
	end
end)

Tool.Unequipped:connect(function()
	if Module.DualEnabled and Workspace.FilteringEnabled then
		Handle2.CanCollide = true
		if Grip2 then Grip2:Destroy() end
	end
end)


Prompt: --[[Engine]]

Response:
	--		[TORQUE CURVE VISUAL]
	--		https://www.desmos.com/calculator/nap6stpjqf
	--		Use sliders to manipulate values
	--		Edit everything as if your car is NATURALLY aspirated, or as if it lacks a turbo.

	Tune.Horsepower		= 250
	Tune.IdleRPM		= 700
	Tune.PeakRPM		= 6000
	Tune.Redline		= 7000
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 20
	Tune.CurveMult		= 0.2

	Tune.InclineComp	= 1.2		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Turbo Settings
	Tune.Aspiration		= "Super"												--[[
	[Aspiration]
		"Natural"		: N/A, Naturally aspirated engine
		"Single"		: Single turbocharger
		"Double"		: Twin turbocharger
		"Super"			: Supercharger												]]

	Tune.Boost			= 5			--Max PSI (If you have two turbos and this is 15, the PSI will be 30)
	Tune.TurboSize		= 80		--Turbo size; the bigger it is, the more lag it has.
	Tune.CompressRatio	= 9			--The compression ratio (look it up)
	Tune.Sensitivity	= 0.05		--How quickly the Supercharger (if appllied) will bring boost when throttle is applied. (Increment applied per tick, suggested values from 0.05 to 0.1)

	--Misc
	Tune.RevAccel		= 300		-- 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		= 250		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)