Solinium V3point5 Lite

-- \\ Solinium V3.5 Lite // --

-- \\ Define Variables // --
local Settings = {
    Prefix = "-",
    AutoCommands = {"antikick"}, -- No prefix required
    WhitelistedPlayers = {}, -- UserId's (UNUSED)
    BlacklistedGear = {}, -- (UNUSED)
    Debug = false, -- (UNUSED)
    BannedPlayers = {}, -- User-id's, must be numbers not strings
    Disable3DRendering = false
}
if Settings.Disable3DRendering then
    game:GetService("RunService"):Set3dRenderingEnabled(false)
end
local Variables = {}
local Characters = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","0","1","2","3","4","5","6","7","8","9","!","\"","#","$","%","&","'","(",")","*","+",",","-",".","/",":",";","<","=",">","?","@","[","\\","]","^","_","`","{","|","}","~"," "}
local Functions = {}
local RemovedObjects = {}
local Connections = {}
local Handler = {}
local Commands = {}
local Aliases = {}

-- \\ Define Functions // --
function Functions:RandomString(Length)
    local String = ""
    for i = 1 , Length do
        String ..= Characters[math.random(1, #Characters)]
    end
    return String
end

function Functions:Chat(String)
    if game.Players.LocalPlayer.PlayerGui:FindFirstChild("Chat") and game.Players.LocalPlayer.PlayerGui:FindFirstChild("Chat"):FindFirstChild("Frame") and game.Players.LocalPlayer.PlayerGui:FindFirstChild("Chat"):FindFirstChild("Frame").Visible == true then
        game.ReplicatedStorage.DefaultChatSystemChatEvents.SayMessageRequest:FireServer(String, "System")
    else
        game:GetService("TextChatService"):WaitForChild("TextChannels"):WaitForChild("RBXGeneral"):SendAsync(String)
    end
end

function Functions:Notification(TitleText, MessageText, DurationSeconds)
    game.StarterGui:SetCore("SendNotification", {Title = TitleText, Text = MessageText, Duration = DurationSeconds})
end

function Handler:CheckArguments(Table1, Table2)
    local Arguments = {}
    for i,v in Table1 do
        if string.sub(v, 1, 1) .. string.sub(v, -1) == "**" then
            table.insert(Arguments, {v,1})
        else
            table.insert(Arguments, {v,0})
        end
    end
    for i,v in Arguments do
        if not Table2[i] and v[2] == 1 then
            Functions:Notification("Solinium Argument Handler", "Missing or Invalid Argument #"..tostring(i), 5)
            return false
        end
    end
    return true
end

function Functions:IsItemAllowed(Item)
    local IsItemClassAllowed = (Item:IsA 'BasePart' and not Item:IsA 'Terrain') or (Item:IsA 'Model' and not Item:IsA 'Workspace') or Item:IsA 'Folder' or Item:IsA 'Smoke' or Item:IsA 'Fire' or Item:IsA 'Sparkles' or Item:IsA 'DataModelMesh' or Item:IsA 'Decal' or Item:IsA 'Texture' or Item:IsA 'Light'
    if not IsItemClassAllowed or not Item:IsDescendantOf(workspace) then
        return false
    end
    return true
end

function Handler:AddCommand(Name, CommandTable, Function)
    Commands[string.lower(Name)] = {CommandTable, Function}
    if not CommandTable.Arguments then
        CommandTable.Arguments = {}
    end
    if CommandTable.Aliases and #CommandTable.Aliases > 0 then
        for i,v in CommandTable.Aliases do
            Aliases[string.lower(v)] = Name
        end
    end
    if not CommandTable.Description then
        CommandTable.Description = ""
    end
end

function Handler:RunCommand(CommandName, Arguments, FullString)
    local Command = Commands[CommandName] or Commands[Aliases[CommandName]]
    if not Command then
        Functions:Notification("Solinium Command Handler", "Invalid Command Name", 5)
        return
    end
    local ArgumentsApproved = Handler:CheckArguments(Command[1].Args, Arguments)
    if ArgumentsApproved then
        Command[2](Arguments, FullString)
    end
end

function f3x(tbl) -- f3x id: 142785488
	local tool
	tool = game.Players.LocalPlayer.Backpack:FindFirstChild("Building Tools") or (game.Players.LocalPlayer.Character and game.Players.LocalPlayer.Character:FindFirstChild("Building Tools"))
	if not tool then
		Functions:Chat("btools me")
		tool = game.Players.LocalPlayer.Backpack:WaitForChild("Building Tools", 2)
	end
	assert(tool, "Failed to get Building Tools")
	local SyncAPI = tool:WaitForChild("SyncAPI", 2)
	assert(SyncAPI, "Failed to retrieve SyncAPI")
	local ServerEndpoint = SyncAPI:WaitForChild("ServerEndpoint", 2)
	assert(ServerEndpoint, "Failed to retrieve ServerEndpoint")
	if tbl then
		return ServerEndpoint:InvokeServer(unpack(tbl))
	end
end

function Functions:GetChildrenOfName(instance, name)
    local tbl = {}
    for i,v in instance:GetChildren() do
        if v.Name == name then
            table.insert(tbl, v)
        end
    end
    return tbl
end

function Functions:GetChildrenOfClass(instance, classname)
    local tbl = {}
    for i,v in instance:GetChildren() do
        if v:IsA(classname) then
            table.insert(tbl, v)
        end
    end
    return tbl
end

function gp(str)
	if str and type(str) == "string" and str ~= "" then
		local players = game.Players:GetPlayers()
		if str:lower() == "all" then
			return players
		elseif str:lower() == "others" then
			table.remove(players, table.find(players, game.Players.LocalPlayer))
			return players
		elseif str:lower() == "me" then
			return {game.Players.LocalPlayer}
		elseif str:lower() == "friends" then
			for i, v in players do
				if not v:IsFriendsWith(game.Players.LocalPlayer.UserId) then
					table.remove(players, i)
				end
			end
			return players
        elseif str:lower() == "nonfriends" then
            table.remove(players, table.find(players, game.Players.LocalPlayer))
            for i, v in players do
				if v:IsFriendsWith(game.Players.LocalPlayer.UserId) then
					table.remove(players, i)
				end
			end
			return players
        elseif str:lower() == "random" then
            return {players[math.random(1, #players)]}
		else
			players = {}
			for i, v in game.Players:GetPlayers() do
				if v.Name:lower():sub(1, str:len()) == str:lower() or v.DisplayName:lower():sub(1, str:len()) == str:lower() then
					table.insert(players, v)
				end
			end
			return players
		end
	else
		return {}
	end
end

function Functions:WaitForChildOfClass(instance, classname, timeout)
    for i,v in instance:GetChildren() do
        if v:IsA(classname) then
            return v
        end
    end
    local start = os.clock()
    local found
    local connection
    connection = instance.ChildAdded:Connect(function(child)
        if child:IsA(classname) then
            found = child
        end
    end)
    while not found do
        if timeout and (os.clock() - start) >= timeout then
            connection:Disconnect()
            return nil
        end
        task.wait()
    end
    connection:Disconnect()
    return found
end

-- \\ Commands // --

Handler:AddCommand("solcommands", {Args = {}, Aliases = {"scmds"}, Description = ""}, function(Arguments, FullString)
    local Str = "\nAsterisks around an argument means the argument is required for the command to function and vice-versa\n\n"
    for i,v in Commands do
        Str ..= Settings.Prefix..i.." Description = \""..v[1].Description.."\" | Arguments = {"..table.concat(v[1].Args, ", ").."} | Aliases = {"..table.concat(v[1].Aliases, ", ").."}\n\n"
    end
    print(Str)
    Functions:Notification("Alert", "Check developer console to see a list of commands.", 5)
end)

Handler:AddCommand("antikick", {Args = {}, Aliases = {}, Description = ""}, function(Arguments, FullString)
    Variables.AntiKick = true
    for i,Object in workspace:GetDescendants() do
        if Object:IsA("SkateboardPlatform") then
            Object.CanTouch = false
        end
    end
end)

Handler:AddCommand("unantikick", {Args = {}, Aliases = {}, Description = ""}, function(Arguments, FullString)
    Variables.AntiKick = false
    for i,v in workspace:GetDescendants() do
        if v:IsA("SkateboardPlatform") then
            v.CanTouch = true
        end
    end
end)

Handler:AddCommand("skateboardkicksetup", {Args = {}, Aliases = {"sks"}, Description = "Sets up the skateboard kick."}, function(Arguments, FullString)
    if Variables.SKickFolder and Variables.SKickFolder.Parent == workspace.Terrain and Variables.SKickFolder:FindFirstChildOfClass("SkateboardPlatform") then
        Functions:Notification("Error", "Kick Folder Already Exists!", 3)
        return
    end
    local ToBeRemoved = {}
    for i,v in workspace:GetChildren() do
        if v.Name == "Skateboard" then
            table.insert(ToBeRemoved, v)
        end
    end
    f3x({"Remove", ToBeRemoved})
    Functions:Chat("gear me 27902303")
    local SkateboardTool = game.Players.LocalPlayer.Backpack:WaitForChild("ROBLOXSkateboard", 3)
    if not SkateboardTool then
        Functions:Notification("Error", "Failed to get tool.", 3)
        return
    end
    SkateboardTool.Parent = game.Players.LocalPlayer.Character
    SkateboardTool:Activate()
    local SkateboardModel = workspace:WaitForChild("Skateboard", 5)
    if not SkateboardModel then
        Functions:Notification("Error", "Failed to get model, did you place it?", 3)
        return
    end
    local SkateboardPlatform = SkateboardModel:WaitForChild("SkateboardPlatform", 3)
    if not SkateboardPlatform then
        Functions:Notification("Error", "Failed to get kickpart.", 3)
        return
    end
    task.spawn(function()
        f3x({"SetName", {SkateboardPlatform}, Functions:RandomString(math.random(25, 100))})
    end)
    f3x({"Remove", {SkateboardPlatform:FindFirstChildOfClass("Mesh")}})
    f3x({"SyncMaterial", {{Part = SkateboardPlatform, Transparency = 1}}})
    if SkateboardPlatform.Anchored == true then
        SkateboardPlatform:GetPropertyChangedSignal("Anchored"):Wait()
    end
    f3x({"SyncAnchor", {{Part = SkateboardPlatform, Anchored = true}}})
    f3x({"SyncResize", {{Part = SkateboardPlatform, CFrame = CFrame.new(0, -565, 0), Size = Vector3.new(50,50,50)}}})
    Variables.SKickFolder = f3x({"CreateGroup", "Model", workspace.Terrain, {}})
    task.spawn(function()
        f3x({"SetName", {Variables.SKickFolder}, Functions:RandomString(math.random(25,100))})
    end)
    local TemporaryFolder = f3x({"CreateGroup", "Folder", Variables.SKickFolder, {SkateboardPlatform}})
    repeat task.wait() until TemporaryFolder and SkateboardPlatform.Parent == TemporaryFolder
    f3x({"Ungroup", {TemporaryFolder}})
    f3x({"Remove", {SkateboardModel}})
    repeat task.wait() until SkateboardPlatform.Parent == Variables.SKickFolder
    Functions:Chat("removetools others fuck")
    Functions:Notification("Success", "Set up successfully!", 3)
end)

Handler:AddCommand("skateboardkick", {Args = {"*Player*"}, Aliases = {"skick","sk","kick"}, Description = "Sets up the skateboard kick."}, function(Arguments, FullString)
    if not Variables.SKickFolder or Variables.SKickFolder.Parent ~= workspace.Terrain or not Variables.SKickFolder:FindFirstChildOfClass("SkateboardPlatform") then
        Functions:Notification("Error", "Kick Folder Doesn't exist or is broken!", 3)
        return
    end
    for i,v in gp(Arguments[1]) do
        task.spawn(function()
            local kicktime = os.clock()
            local SkateboardPlatform = Variables.SKickFolder:FindFirstChildOfClass("SkateboardPlatform")
            task.spawn(function()
                f3x({"Clone", {SkateboardPlatform}, v.Character})
            end)
            SkateboardPlatform = Functions:WaitForChildOfClass(v.Character, "SkateboardPlatform")
            local OriginalCFrame = SkateboardPlatform.CFrame
            f3x({"SyncResize", {{Part = SkateboardPlatform, CFrame = CFrame.new(math.random(10000, 100000),math.random(10000, 100000),math.random(10000, 100000)), Size = Vector3.new(100, 100, 100)}}})
            repeat task.wait() until SkateboardPlatform.CFrame ~= OriginalCFrame
            local Timer
            task.delay(10, function()
                Timer = true
            end)
            local SkateboardCFrame = SkateboardPlatform.CFrame
            local FormattedCFrame = SkateboardCFrame * CFrame.new(0, ((v.Character.Torso.Size.Y/2) + (v.Character.Head.Size.Y/2)), 0)
            repeat
                if v.Character and v.Character.HumanoidRootPart and v.Character.Torso and v.Character.Head then
                    task.spawn(function()
                        f3x({"SyncMove", {{Part = v.Character.HumanoidRootPart, CFrame = SkateboardCFrame}, {Part = v.Character.Torso, CFrame = SkateboardCFrame}, {Part = v.Character.Head, CFrame = FormattedCFrame}, {Pivot = FormattedCFrame, Model = v.Character}}})
                    end)
                end
                task.wait(2.5)
            until not table.find(game.Players:GetPlayers(), v) or Timer
            if Timer then
                print("10 seconds have passed, abandoning kick and cleaning up the mess.")
                f3x({"Remove", {SkateboardPlatform, v.Character}})
            else
                local FinalTime = tostring(math.floor((os.clock() - kicktime) * 1000))
                print("Kicked player: \""..v.DisplayName.."\" in "..FinalTime.." milliseconds")
                Functions:Notification("Kicked "..v.DisplayName, FinalTime.."ms", 3)
                f3x({"Remove", {SkateboardPlatform, v.Character}})
            end
        end)
    end
end)

Handler:AddCommand("ban", {Args = {"*Player*"}, Aliases = {}, Description = "Bans a player using the skateboard method."}, function(Arguments, FullString)
    for i,v in gp(Arguments[1]) do
        table.insert(Settings.BannedPlayers, v.UserId)
        Commands["skateboardkick"][2]({v.Name})
    end
end)

Handler:AddCommand("idban", {Args = {"*User-Id*"}, Aliases = {}, Description = "Bans a user-id from joining."}, function(Arguments, FullString)
    if tonumber(Arguments[1]) ~= nil and not table.find(Settings.BannedPlayers, tonumber(Arguments[1])) then
        table.insert(Settings.BannedPlayers, tonumber(Arguments[1]))
        for i,v in game.Players:GetPlayers() do
            if v.UserId == tonumber(Arguments[1]) then
                Commands["skateboardkick"][2]({v.Name})
                break
            end
        end
    end
end)

Handler:AddCommand("unban", {Args = {"*User-Id*"}, Aliases = {}, Description = "Unbans a player using their user-id."}, function(Arguments, FullString)
    local UserId = tonumber(Arguments[1])
    if table.find(Settings.BannedPlayers, UserId) then
        table.remove(Settings.BannedPlayers, table.find(Settings.BannedPlayers, UserId))
        local Success, Username = pcall(function()
            return game.Players:GetNameFromUserIdAsync(UserId)
        end)
        if Success then
            Functions:Notification("Success", "Unbanned: "..Username, 3)
        end
    else
        Functions:Notification("Error", "Player not banned.", 3)
    end
end)

Handler:AddCommand("banlist", {Args = {}, Aliases = {"bans"}, Description = "Prints list of banned players"}, function(Arguments, FullString)
    local Str = "\n"
    for i,v in Settings.BannedPlayers do
        Str ..= tostring(v).."\n"
    end
    print(Str)
end)

Handler:AddCommand("clearbans", {Args = {}, Aliases = {}, Description = "Clears banlist."}, function(Arguments, FullString)
    Settings.BannedPlayers = {}
end)

Handler:AddCommand("serverlock", {Args = {"*Skateboard*"}, Aliases = {}, Description = "Locks the server."}, function(Arguments, FullString)
    local Option
    if not Arguments[1] then
        return
    elseif string.sub("skateboard", 1, string.len(Arguments[1])) == Arguments[1]:lower() then
        Option = "Skateboard"
    else
        return
    end
    Variables.ServerLock = Option
    Functions:Notification("ServerLock", "Set mode to: "..Option, 3)
end)

Handler:AddCommand("unserverlock", {Args = {}, Aliases = {}, Description = "Unlocks the server."}, function(Arguments, FullString)
    Variables.ServerLock = nil
    Functions:Notification("ServerLock","Successfully disabled ServerLock", 3)
end)

Handler:AddCommand("potatokick", {Args = {"*Player*"}, Aliases = {"pkick","pk"}, Description = "potato kick."}, function(Arguments, FullString)
    if not Variables.PKS then
        return
    end
    for i,v in gp(Arguments[1]) do
        f3x({"SyncAnchor", {{Part = v.Character:FindFirstChildOfClass("Part"), Anchored = true}}})
        Functions:Chat("blind "..v.Name)
        Functions:Chat("size "..v.Name.." nan")
        local Tool = Variables.PKS:FindFirstChildOfClass("Tool")
        if not Tool then
            print("Tool not found, aborting kick...")
            return
        end
        f3x({"SetName", {Tool}, "Crashed by Solinium"})
        repeat task.wait() until (v.Character.Head.Position - v.Character.HumanoidRootPart.Position).Magnitude < 0.5
        f3x({"Clone", table.create(3, Tool), v.Character})
        f3x({"SetName", {Tool}, Functions:RandomString(math.random(25,100))})
    end
end)

Handler:AddCommand("potatokicksetup", {Args = {}, Aliases = {"pks"}, Description = "potato kick setup."}, function(Arguments, FullString)
    if Variables.PKS then
        return
    end
    local TempPart = f3x({"CreatePart", "Normal", CFrame.new(0,0,0), workspace.Terrain})
    f3x({"CreateLights", {{Part = TempPart, LightType = "PointLight"}}})
    f3x({"SyncLighting", {{Part = TempPart, LightType = "PointLight", Brightness = 0}}})
    Variables.PKS = TempPart:WaitForChild("PointLight")
    f3x({"SetName", {Variables.PKS}, Functions:RandomString(math.random(1,100))})
    f3x({"Ungroup", {TempPart}})
    Functions:Chat("gear me ??")
    local Tool = game.Players.LocalPlayer.Backpack:WaitForChild("Tool")
    Tool.Parent = game.Players.LocalPlayer.Character
    f3x({"SetParent", {Tool}, Variables.PKS})
    f3x({"SetName", {Tool}, Functions:RandomString(math.random(1,100))})
end)

-- \\ Connections // --
task.spawn(function()
    Connections[#Connections + 1] = game.TextChatService.SendingMessage:Connect(function(Message)
        Message = Message.Text
        if string.sub(Message, 1, string.len(Settings.Prefix)) == Settings.Prefix then
            Message = string.sub(Message, string.len(Settings.Prefix) + 1)
            local Arguments = {}
            for i in string.gmatch(Message, "([^%s]+)") do
                table.insert(Arguments, i)
            end
            task.spawn(function()
                Handler:RunCommand(Arguments[1], {table.unpack(Arguments, 2)}, Message)
            end)
        end
    end)
end)

task.spawn(function()
    Connections[#Connections + 1] = workspace.DescendantAdded:Connect(function(Object)
        if Object:IsA("SkateboardPlatform") and Variables.AntiKick then
            Object.CanTouch = false
        end
    end)
end)

task.spawn(function()
    Connections[#Connections + 1] = game.Players.LocalPlayer.PlayerGui.ChildAdded:Connect(function(Object)
        if Object:IsA("LocalScript") and Object.Name == "Crash" then
            Object.Enabled = false
            game.Debris:AddItem(Object,0)
            print("Intercepted potato crash script.")
        end
    end)
end)

task.spawn(function()
    Connections[#Connections + 1] = game.Players.PlayerAdded:Connect(function(Player)
        print("[Solinium V3.5]: Player \""..Player.DisplayName.."\" aka \""..Player.Name.."\" has joined the server, user-id: "..Player.UserId)
        if Variables.ServerLock and Variables.ServerLock == "Skateboard" then
            Player.CharacterAdded:Wait()
            repeat task.wait() until Player.Character:FindFirstChild("HumanoidRootPart") and Player.Character:FindFirstChild("Torso") and Player.Character:FindFirstChild("Head")
            Commands["skateboardkick"][2]({Player.Name})
        elseif table.find(Settings.BannedPlayers, Player.UserId) then
            Player.CharacterAdded:Wait()
            repeat task.wait() until Player.Character:FindFirstChild("HumanoidRootPart") and Player.Character:FindFirstChild("Torso") and Player.Character:FindFirstChild("Head")
            Commands["skateboardkick"][2]({Player.Name})
        end
    end)
end)

task.spawn(function()
    Connections[#Connections + 1] = game.Players.PlayerRemoving:Connect(function(Player)
        print("[Solinium V3.5]: Player \""..Player.DisplayName.."\" aka \""..Player.Name.."\" has left the server, user-id: "..Player.UserId)
    end)
end)

task.spawn(function()
    for i,Message in Settings.AutoCommands do
        task.spawn(function()
            local Arguments = {}
            for i in string.gmatch(Message, "([^%s]+)") do
                table.insert(Arguments, i)
            end
            task.spawn(function()
                Handler:RunCommand(Arguments[1], {table.unpack(Arguments, 2)}, Message)
                print("[Startup-Commands]: \""..Message.."\"")
            end)
        end)
    end
end)

-- \\ Command Bar // --
task.spawn(function()
    local ScreenGui = Instance.new("ScreenGui")
	local Frame = Instance.new("Frame")
	local Frame_2 = Instance.new("Frame")
	local TextBox = Instance.new("TextBox")
	local UIStroke = Instance.new("UIStroke")
	local enabled;

	ScreenGui.Parent = game.CoreGui
	ScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
	ScreenGui.DisplayOrder = 9999
	ScreenGui.IgnoreGuiInset = true
	ScreenGui.ResetOnSpawn = false

	Frame.Parent = ScreenGui
	Frame.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
	Frame.BackgroundTransparency = 1.000
	Frame.BorderColor3 = Color3.fromRGB(0, 0, 0)
	Frame.BorderSizePixel = 0
	Frame.Transparency = 1
	Frame.Size = UDim2.new(1, 0, 1, 0)

	Frame_2.Parent = Frame
	Frame_2.BackgroundColor3 = Color3.fromRGB(31, 31, 31)
	Frame_2.BackgroundTransparency = 0.200
	Frame_2.BorderColor3 = Color3.fromRGB(0, 0, 0)
	Frame_2.BorderSizePixel = 0
	Frame_2.Position = UDim2.new(-0.0132391872, 0, 0, 0)
	Frame_2.Transparency = 0.2
	Frame_2.Size = UDim2.new(1.0260371, 0, 0.0892857164, 0)

	UIStroke.Parent = Frame_2
	UIStroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
	UIStroke.LineJoinMode = Enum.LineJoinMode.Round
	UIStroke.Thickness = 2.5
	UIStroke.Color = Color3.fromRGB(2, 48, 255)

	TextBox.Parent = Frame_2
	TextBox.BackgroundColor3 = Color3.fromRGB(31, 31, 31)
	TextBox.BackgroundTransparency = 1.000
	TextBox.BorderColor3 = Color3.fromRGB(0, 0, 0)
	TextBox.BorderSizePixel = 0
	TextBox.Position = UDim2.new(0.0228084419, 0, 0.119999997, 0)
	TextBox.Size = UDim2.new(0.954382956, 0, 0.75999999, 0)
	TextBox.Transparency = 1
	TextBox.TextTransparency = 0
	TextBox.Font = Enum.Font.SourceSans
	TextBox.PlaceholderColor3 = Color3.fromRGB(140, 140, 140)
	TextBox.PlaceholderText = "Type Here"
	TextBox.Text = ""
	TextBox.TextColor3 = Color3.fromRGB(255, 255, 255)
	TextBox.TextSize = 20.000
	TextBox.TextXAlignment = Enum.TextXAlignment.Left
	task.wait(0.5)
	Frame_2:TweenPosition(UDim2.new(-0.0132391872, 0, -1, 0), "Out", "Quad", 0.3)
	enabled = false
	TextBox.Focused:Connect(function()
		TextBox.Text = ""
		enabled = true
		Frame_2.Position = UDim2.new(-0.0132391872, 0, 0, 0)
	end)
	TextBox.FocusLost:Connect(function()
		if TextBox.Text ~= "" then
            if string.sub(TextBox.Text, 1, string.len(Settings.Prefix)) == Settings.Prefix then
                local Message = string.sub(TextBox.Text, string.len(Settings.Prefix) + 1)
                local Arguments = {}
                for i in string.gmatch(Message, "([^%s]+)") do
                    table.insert(Arguments, i)
                end
                task.spawn(function()
                    Handler:RunCommand(Arguments[1], {table.unpack(Arguments, 2)}, Message)
                end)
            else
                Functions:Chat(TextBox.Text)
            end
			TextBox.Text = ""
		end
		enabled = false
		Frame_2.Position = UDim2.new(-0.0132391872, 0, -1, 0)
	end)
	game:GetService("UserInputService").InputEnded:Connect(function(key, gpe)
		if key.KeyCode == Enum.KeyCode.Semicolon and not gpe then
			if not enabled then
				TextBox:CaptureFocus()
			end
		end
	end)
end)