--==================================================
-- eXTHUS PLAYER TOOLS
-- Full updated version
--==================================================

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")

local LocalPlayer = Players.LocalPlayer

--==================================================
-- CONFIG
--==================================================

local Config = {
    Aimbot = {
        Enabled = false,
        Smoothness = 0.35,
        FOV = 180,
        TargetMode = "All",
        TargetGroup = "All",
        AimPart = "Head",
        ActivationMode = "Hold",
        VisibilityCheck = true,
        Bind = "Right Click",
        BindInput = Enum.UserInputType.MouseButton2
    },

    ESP = {
        Enabled = false,
        FillTransparency = 0.55,
        OutlineTransparency = 0,
        ShowNames = true,
        ShowDistance = true,
        ShowHealth = true
    },

    Speed = {
        Enabled = false,
        Value = 24
    },

    Fly = {
        Enabled = false,
        Speed = 50
    },

    JumpPower = {
        Enabled = false,
        Value = 75
    },

    Gravity = {
        Enabled = false,
        Value = 80
    },

    NoClip = false,
    InfiniteJump = false,
    AntiAFK = false,
    Spinbot = false,
    ForceField = false,

    TeleportSavedPosition = nil
}

--==================================================
-- GROUPS
--==================================================

local Groups = {
    All = {}
}

local SelectedGroup = "All"

local function rebuildAllGroup()
    Groups.All = {}

    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            Groups.All[player.UserId] = true
        end
    end
end

local function playerInGroup(player, groupName)
    if not player or not groupName then
        return false
    end

    local group = Groups[groupName]

    if not group then
        return false
    end

    return group[player.UserId] == true
end

rebuildAllGroup()

--==================================================
-- GUI
--==================================================

local gui = Instance.new("ScreenGui")
gui.Name = "eXthusPlayerTools"
gui.ResetOnSpawn = false
gui.ZIndexBehavior = Enum.ZIndexBehavior.Global
gui.DisplayOrder = 999999
gui.Parent = LocalPlayer:WaitForChild("PlayerGui")

local function forceZIndex(object)
    if object:IsA("GuiObject") then
        object.ZIndex = 999999
    end
end

for _, object in ipairs(gui:GetDescendants()) do
    forceZIndex(object)
end

gui.DescendantAdded:Connect(function(object)
    forceZIndex(object)
end)

--==================================================
-- MAIN WINDOW
--==================================================

local main = Instance.new("Frame")
main.Size = UDim2.fromOffset(330, 520)
main.Position = UDim2.new(0, 25, 0.5, -260)
main.BackgroundColor3 = Color3.fromRGB(17, 17, 21)
main.BorderSizePixel = 0
main.ZIndex = 999999
main.Parent = gui

local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 12)
corner.Parent = main

local stroke = Instance.new("UIStroke")
stroke.Color = Color3.fromRGB(65, 65, 75)
stroke.Parent = main

--==================================================
-- TITLE BAR
--==================================================

local titleBar = Instance.new("Frame")
titleBar.Size = UDim2.new(1, 0, 0, 44)
titleBar.BackgroundColor3 = Color3.fromRGB(25, 25, 31)
titleBar.BorderSizePixel = 0
titleBar.Parent = main

local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, -90, 1, 0)
title.Position = UDim2.fromOffset(14, 0)
title.BackgroundTransparency = 1
title.Text = "eXTHUS  •  PLAYER TOOLS"
title.TextColor3 = Color3.fromRGB(240, 240, 245)
title.Font = Enum.Font.GothamBold
title.TextSize = 14
title.TextXAlignment = Enum.TextXAlignment.Left
title.Parent = titleBar

local minimize = Instance.new("TextButton")
minimize.Size = UDim2.fromOffset(34, 34)
minimize.Position = UDim2.new(1, -75, 0, 5)
minimize.BackgroundTransparency = 1
minimize.Text = "−"
minimize.TextColor3 = Color3.fromRGB(190, 190, 200)
minimize.Font = Enum.Font.Gotham
minimize.TextSize = 18
minimize.Parent = titleBar

local close = Instance.new("TextButton")
close.Size = UDim2.fromOffset(34, 34)
close.Position = UDim2.new(1, -38, 0, 5)
close.BackgroundTransparency = 1
close.Text = "×"
close.TextColor3 = Color3.fromRGB(220, 100, 110)
close.Font = Enum.Font.GothamBold
close.TextSize = 22
close.Parent = titleBar

--==================================================
-- SCROLL
--==================================================

local scroll = Instance.new("ScrollingFrame")
scroll.Size = UDim2.new(1, -12, 1, -55)
scroll.Position = UDim2.fromOffset(6, 49)
scroll.BackgroundTransparency = 1
scroll.BorderSizePixel = 0
scroll.ScrollBarThickness = 4
scroll.CanvasSize = UDim2.new()
scroll.Parent = main

local layout = Instance.new("UIListLayout")
layout.Padding = UDim.new(0, 5)
layout.Parent = scroll

layout:GetPropertyChangedSignal("AbsoluteContentSize"):Connect(function()
    scroll.CanvasSize =
        UDim2.fromOffset(
            0,
            layout.AbsoluteContentSize.Y + 10
        )
end)

--==================================================
-- UI HELPERS
--==================================================

local function clearObject(object)
    for _, child in ipairs(object:GetChildren()) do
        child:Destroy()
    end
end

local function makeLabel(parent, text)
    local label = Instance.new("TextLabel")

    label.Size = UDim2.new(1, -8, 0, 25)
    label.BackgroundTransparency = 1
    label.Text = text
    label.TextColor3 = Color3.fromRGB(150, 150, 160)
    label.Font = Enum.Font.GothamMedium
    label.TextSize = 11
    label.TextXAlignment = Enum.TextXAlignment.Left
    label.Parent = parent

    return label
end

local function makeButton(parent, text, callback)
    local button = Instance.new("TextButton")

    button.Size = UDim2.new(1, -8, 0, 36)
    button.BackgroundColor3 = Color3.fromRGB(30, 30, 37)
    button.BorderSizePixel = 0
    button.Text = text
    button.TextColor3 = Color3.fromRGB(225, 225, 230)
    button.Font = Enum.Font.Gotham
    button.TextSize = 12
    button.Parent = parent

    local c = Instance.new("UICorner")
    c.CornerRadius = UDim.new(0, 7)
    c.Parent = button

    button.MouseEnter:Connect(function()
        button.BackgroundColor3 = Color3.fromRGB(42, 42, 51)
    end)

    button.MouseLeave:Connect(function()
        button.BackgroundColor3 = Color3.fromRGB(30, 30, 37)
    end)

    button.MouseButton1Click:Connect(callback)

    return button
end

--==================================================
-- SLIDER
--==================================================

local function makeSlider(parent, name, value, min, max, callback)
    local container = Instance.new("Frame")

    container.Size = UDim2.new(1, -8, 0, 55)
    container.BackgroundTransparency = 1
    container.Parent = parent

    local label = Instance.new("TextLabel")

    label.Size = UDim2.new(1, 0, 0, 20)
    label.BackgroundTransparency = 1
    label.Text = name .. ": " .. string.format("%.1f", value)
    label.TextColor3 = Color3.fromRGB(205, 205, 215)
    label.Font = Enum.Font.Gotham
    label.TextSize = 11
    label.TextXAlignment = Enum.TextXAlignment.Left
    label.Parent = container

    local bar = Instance.new("Frame")

    bar.Size = UDim2.new(1, -10, 0, 7)
    bar.Position = UDim2.fromOffset(5, 28)
    bar.BackgroundColor3 = Color3.fromRGB(45, 45, 53)
    bar.BorderSizePixel = 0
    bar.Parent = container

    local barCorner = Instance.new("UICorner")
    barCorner.CornerRadius = UDim.new(1, 0)
    barCorner.Parent = bar

    local fill = Instance.new("Frame")

    fill.Size = UDim2.new(
        math.clamp((value - min) / (max - min), 0, 1),
        0,
        1,
        0
    )

    fill.BackgroundColor3 = Color3.fromRGB(90, 150, 255)
    fill.BorderSizePixel = 0
    fill.Parent = bar

    local fillCorner = Instance.new("UICorner")
    fillCorner.CornerRadius = UDim.new(1, 0)
    fillCorner.Parent = fill

    local draggingSlider = false

    local function update(x)
        local percent =
            math.clamp(
                (
                    x -
                    bar.AbsolutePosition.X
                ) /
                bar.AbsoluteSize.X,
                0,
                1
            )

        local newValue =
            min +
            (max - min) *
            percent

        fill.Size =
            UDim2.new(
                percent,
                0,
                1,
                0
            )

        label.Text =
            name ..
            ": " ..
            string.format(
                "%.1f",
                newValue
            )

        callback(newValue)
    end

    bar.InputBegan:Connect(function(input)
        if input.UserInputType ==
            Enum.UserInputType.MouseButton1
        then
            draggingSlider = true
            update(input.Position.X)
        end
    end)

    UserInputService.InputChanged:Connect(function(input)
        if
            draggingSlider
            and input.UserInputType ==
                Enum.UserInputType.MouseMovement
        then
            update(input.Position.X)
        end
    end)

    UserInputService.InputEnded:Connect(function(input)
        if input.UserInputType ==
            Enum.UserInputType.MouseButton1
        then
            draggingSlider = false
        end
    end)
end

--==================================================
-- DROPDOWN
--==================================================

local function makeDropdown(parent, name, options, current, callback)
    local container = Instance.new("Frame")

    container.Size = UDim2.new(1, -8, 0, 36)
    container.BackgroundTransparency = 1
    container.Parent = parent

    local button = makeButton(
        container,
        name .. ": " .. tostring(current) .. " ▼",
        function()
            local open =
                container:GetAttribute("Open")

            container:SetAttribute(
                "Open",
                not open
            )
        end
    )

    local optionFrame = Instance.new("Frame")

    optionFrame.Size = UDim2.new(1, 0, 0, 0)
    optionFrame.Position = UDim2.fromOffset(0, 38)
    optionFrame.BackgroundTransparency = 1
    optionFrame.Visible = false
    optionFrame.Parent = container

    local optionLayout = Instance.new("UIListLayout")
    optionLayout.Padding = UDim.new(0, 3)
    optionLayout.Parent = optionFrame

    for _, option in ipairs(options) do
        local optionButton =
            makeButton(
                optionFrame,
                tostring(option),
                function()
                    callback(option)

                    button.Text =
                        name ..
                        ": " ..
                        tostring(option) ..
                        " ▼"

                    container:SetAttribute(
                        "Open",
                        false
                    )
                end
            )

        optionButton.Size =
            UDim2.new(1, 0, 0, 30)
    end

    container:SetAttribute("Open", false)

    container:GetAttributeChangedSignal("Open"):Connect(function()
        local open =
            container:GetAttribute("Open")

        optionFrame.Visible = open

        if open then
            container.Size =
                UDim2.new(
                    1,
                    -8,
                    0,
                    40 +
                    optionLayout.AbsoluteContentSize.Y
                )
        else
            container.Size =
                UDim2.new(
                    1,
                    -8,
                    0,
                    36
                )
        end
    end)
end

--==================================================
-- KEYBIND
--==================================================

local function makeKeybind(parent, name, current, callback)
    local listening = false

    local button = makeButton(
        parent,
        name .. ": " .. tostring(current),
        function()
            if listening then
                return
            end

            listening = true

            button.Text =
                name ..
                ": Press a key..."

            button.BackgroundColor3 =
                Color3.fromRGB(55, 55, 70)
        end
    )

    UserInputService.InputBegan:Connect(function(input)
        if not listening then
            return
        end

        if input.UserInputType ==
            Enum.UserInputType.MouseMovement
        then
            return
        end

        local bindName

        if input.UserInputType ==
            Enum.UserInputType.MouseButton1
        then
            bindName = "Left Click"

        elseif input.UserInputType ==
            Enum.UserInputType.MouseButton2
        then
            bindName = "Right Click"

        elseif input.UserInputType ==
            Enum.UserInputType.MouseButton3
        then
            bindName = "Middle Click"

        elseif input.KeyCode ~=
            Enum.KeyCode.Unknown
        then
            bindName = input.KeyCode.Name
        else
            return
        end

        listening = false

        button.Text =
            name ..
            ": " ..
            bindName

        button.BackgroundColor3 =
            Color3.fromRGB(30, 30, 37)

        local bindInput

        if input.UserInputType ==
            Enum.UserInputType.Keyboard
        then
            bindInput = input.KeyCode
        else
            bindInput = input.UserInputType
        end

        callback(
            bindInput,
            bindName
        )
    end)

    return button
end

--==================================================
-- TOGGLE
--==================================================

local ON_COLOR =
    Color3.fromRGB(35, 65, 48)

local OFF_COLOR =
    Color3.fromRGB(25, 25, 31)

local ON_TEXT =
    Color3.fromRGB(120, 235, 155)

local OFF_TEXT =
    Color3.fromRGB(225, 225, 230)

local function makeToggle(parent, text, value, callback)
    local button

    button = makeButton(
        parent,
        text ..
        ": " ..
        (
            value
            and "ON"
            or "OFF"
        ),

        function()
            value = not value

            button.Text =
                text ..
                ": " ..
                (
                    value
                    and "ON"
                    or "OFF"
                )

            callback(value)
        end
    )

    return button
end

--==================================================
-- MODULE
--==================================================

local function createModule(name, enabled, toggleCallback)
    local container =
        Instance.new("Frame")

    container.Size =
        UDim2.new(
            1,
            -8,
            0,
            42
        )

    container.BackgroundColor3 =
        enabled
        and ON_COLOR
        or OFF_COLOR

    container.BorderSizePixel = 0
    container.ClipsDescendants = true
    container.Parent = scroll

    local c = Instance.new("UICorner")
    c.CornerRadius = UDim.new(0, 8)
    c.Parent = container

    local header =
        Instance.new("TextButton")

    header.Size =
        UDim2.new(
            1,
            0,
            0,
            42
        )

    header.BackgroundTransparency = 1
    header.Text = ""
    header.Parent = container

    local text =
        Instance.new("TextLabel")

    text.Size =
        UDim2.new(
            1,
            -50,
            1,
            0
        )

    text.Position =
        UDim2.fromOffset(
            12,
            0
        )

    text.BackgroundTransparency = 1
    text.Text = name

    text.TextColor3 =
        enabled
        and ON_TEXT
        or OFF_TEXT

    text.Font =
        Enum.Font.GothamMedium

    text.TextSize = 13

    text.TextXAlignment =
        Enum.TextXAlignment.Left

    text.Parent = header

    local arrow =
        Instance.new("TextLabel")

    arrow.Size =
        UDim2.fromOffset(
            30,
            42
        )

    arrow.Position =
        UDim2.new(
            1,
            -35,
            0,
            0
        )

    arrow.BackgroundTransparency = 1
    arrow.Text = "›"

    arrow.TextColor3 =
        Color3.fromRGB(
            150,
            150,
            160
        )

    arrow.Font =
        Enum.Font.GothamBold

    arrow.TextSize = 18
    arrow.Parent = header

    local optionsFrame =
        Instance.new("Frame")

    optionsFrame.Size =
        UDim2.new(
            1,
            -14,
            0,
            0
        )

    optionsFrame.Position =
        UDim2.fromOffset(
            7,
            46
        )

    optionsFrame.BackgroundTransparency = 1
    optionsFrame.Parent = container

    local optionLayout =
        Instance.new("UIListLayout")

    optionLayout.Padding =
        UDim.new(
            0,
            4
        )

    optionLayout.Parent =
        optionsFrame

    local expanded = false

    local function updateHeight()
        local h =
            optionLayout.AbsoluteContentSize.Y

        if expanded then
            container.Size =
                UDim2.new(
                    1,
                    -8,
                    0,
                    50 + h
                )
        else
            container.Size =
                UDim2.new(
                    1,
                    -8,
                    0,
                    42
                )
        end
    end

    optionLayout:GetPropertyChangedSignal(
        "AbsoluteContentSize"
    ):Connect(updateHeight)

    header.MouseButton1Click:Connect(function()
        enabled = not enabled

        container.BackgroundColor3 =
            enabled
            and ON_COLOR
            or OFF_COLOR

        text.TextColor3 =
            enabled
            and ON_TEXT
            or OFF_TEXT

        toggleCallback(enabled)
    end)

    header.MouseButton2Click:Connect(function()
        if optionLayout.AbsoluteContentSize.Y <= 0 then
            return
        end

        expanded = not expanded

        arrow.Text =
            expanded
            and "⌄"
            or "›"

        updateHeight()
    end)

    return optionsFrame
end

--==================================================
-- ESP
--==================================================

local ESPConnections = {}
local CharacterConnections = {}

local function removeESP(character)
    if not character then
        return
    end

    local highlight =
        character:FindFirstChild(
            "eXthusESP"
        )

    if highlight then
        highlight:Destroy()
    end

    local head =
        character:FindFirstChild(
            "Head"
        )

    if head then
        local billboard =
            head:FindFirstChild(
                "eXthusESPInfo"
            )

        if billboard then
            billboard:Destroy()
        end
    end
end

local function addESP(player)
    if
        player == LocalPlayer
        or not Config.ESP.Enabled
    then
        return
    end

    local character =
        player.Character

    if not character then
        return
    end

    local humanoid =
        character:FindFirstChildOfClass(
            "Humanoid"
        )

    local head =
        character:FindFirstChild(
            "Head"
        )

    if not humanoid or not head then
        return
    end

    local highlight =
        character:FindFirstChild(
            "eXthusESP"
        )

    if not highlight then
        highlight =
            Instance.new("Highlight")

        highlight.Name =
            "eXthusESP"

        highlight.Adornee =
            character

        highlight.DepthMode =
            Enum.HighlightDepthMode.AlwaysOnTop

        highlight.FillTransparency =
            Config.ESP.FillTransparency

        highlight.OutlineTransparency =
            Config.ESP.OutlineTransparency

        highlight.FillColor =
            Color3.fromRGB(
                75,
                155,
                255
            )

        highlight.OutlineColor =
            Color3.fromRGB(
                255,
                255,
                255
            )

        highlight.Parent =
            character
    end

    local billboard =
        head:FindFirstChild(
            "eXthusESPInfo"
        )

    if not billboard then
        billboard =
            Instance.new("BillboardGui")

        billboard.Name =
            "eXthusESPInfo"

        billboard.Adornee =
            head

        billboard.Size =
            UDim2.fromOffset(
                200,
                70
            )

        billboard.StudsOffset =
            Vector3.new(
                0,
                3,
                0
            )

        billboard.AlwaysOnTop = true
        billboard.Parent = head
    end

    local info =
        billboard:FindFirstChild(
            "Info"
        )

    if not info then
        info =
            Instance.new("TextLabel")

        info.Name = "Info"

        info.Size =
            UDim2.fromScale(
                1,
                1
            )

        info.BackgroundTransparency = 1

        info.TextColor3 =
            Color3.fromRGB(
                255,
                255,
                255
            )

        info.TextStrokeTransparency =
            0.25

        info.Font =
            Enum.Font.GothamBold

        info.TextSize = 12

        info.Parent = billboard
    end

    humanoid.DisplayDistanceType =
        Enum.HumanoidDisplayDistanceType.None
end

--==================================================
-- CHARACTER TRACKING
--==================================================

local function trackCharacter(player, character)
    if player == LocalPlayer then
        return
    end

    if CharacterConnections[player] then
        CharacterConnections[player]:Disconnect()
        CharacterConnections[player] = nil
    end

    if not character then
        return
    end

    CharacterConnections[player] =
        character.ChildAdded:Connect(function()
            if Config.ESP.Enabled then
                task.defer(function()
                    addESP(player)
                end)
            end
        end)

    task.spawn(function()
        local humanoid =
            character:WaitForChild(
                "Humanoid",
                10
            )

        local head =
            character:WaitForChild(
                "Head",
                10
            )

        if humanoid and head then
            task.wait(0.1)

            if Config.ESP.Enabled then
                addESP(player)
            end
        end
    end)
end

local function trackPlayer(player)
    if player == LocalPlayer then
        return
    end

    if ESPConnections[player] then
        ESPConnections[player]:Disconnect()
        ESPConnections[player] = nil
    end

    ESPConnections[player] =
        player.CharacterAdded:Connect(
            function(character)
                trackCharacter(
                    player,
                    character
                )
            end
        )

    if player.Character then
        trackCharacter(
            player,
            player.Character
        )
    end
end

--==================================================
-- ALWAYS REFRESH PLAYERS
--==================================================

task.spawn(function()
    while gui.Parent do
        rebuildAllGroup()

        for _, player in ipairs(
            Players:GetPlayers()
        ) do
            if player ~= LocalPlayer then
                if not ESPConnections[player] then
                    trackPlayer(player)
                end

                local character =
                    player.Character

                if character and Config.ESP.Enabled then
                    local humanoid =
                        character:FindFirstChildOfClass(
                            "Humanoid"
                        )

                    local head =
                        character:FindFirstChild(
                            "Head"
                        )

                    if humanoid and head then
                        addESP(player)
                    end
                end
            end
        end

        task.wait(0.2)
    end
end)

--==================================================
-- PLAYER EVENTS
--==================================================

Players.PlayerAdded:Connect(function(player)
    trackPlayer(player)

    task.defer(function()
        rebuildAllGroup()
    end)
end)

Players.PlayerRemoving:Connect(function(player)
    if ESPConnections[player] then
        ESPConnections[player]:Disconnect()
        ESPConnections[player] = nil
    end

    if CharacterConnections[player] then
        CharacterConnections[player]:Disconnect()
        CharacterConnections[player] = nil
    end

    for _, group in pairs(Groups) do
        group[player.UserId] = nil
    end

    rebuildAllGroup()
end)

for _, player in ipairs(
    Players:GetPlayers()
) do
    trackPlayer(player)
end

--==================================================
-- ESP INFO UPDATE
--==================================================

local espTimer = 0

local function updateESPInfo()
    if not Config.ESP.Enabled then
        return
    end

    local myRoot =
        LocalPlayer.Character
        and LocalPlayer.Character:FindFirstChild(
            "HumanoidRootPart"
        )

    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        if player ~= LocalPlayer then
            local character =
                player.Character

            if character then
                local head =
                    character:FindFirstChild(
                        "Head"
                    )

                local humanoid =
                    character:FindFirstChildOfClass(
                        "Humanoid"
                    )

                local root =
                    character:FindFirstChild(
                        "HumanoidRootPart"
                    )

                if
                    head
                    and humanoid
                    and root
                then
                    local billboard =
                        head:FindFirstChild(
                            "eXthusESPInfo"
                        )

                    if billboard then
                        local info =
                            billboard:FindFirstChild(
                                "Info"
                            )

                        if info then
                            local lines = {}

                            if Config.ESP.ShowNames then
                                table.insert(
                                    lines,
                                    player.DisplayName
                                )
                            end

                            if
                                Config.ESP.ShowDistance
                                and myRoot
                            then
                                local distance =
                                    math.floor(
                                        (
                                            myRoot.Position
                                            -
                                            root.Position
                                        ).Magnitude
                                    )

                                table.insert(
                                    lines,
                                    distance ..
                                    " studs"
                                )
                            end

                            if Config.ESP.ShowHealth then
                                local health =
                                    math.max(
                                        0,
                                        math.floor(
                                            humanoid.Health
                                        )
                                    )

                                local maxHealth =
                                    math.max(
                                        1,
                                        math.floor(
                                            humanoid.MaxHealth
                                        )
                                    )

                                table.insert(
                                    lines,
                                    "HP: " ..
                                    health ..
                                    " / " ..
                                    maxHealth
                                )
                            end

                            info.Text =
                                table.concat(
                                    lines,
                                    "\n"
                                )
                        end
                    end
                end
            end
        end
    end
end

RunService.RenderStepped:Connect(function(dt)
    espTimer += dt

    if espTimer >= 0.05 then
        espTimer = 0
        updateESPInfo()
    end
end)

local function setESPEnabled(enabled)
    Config.ESP.Enabled = enabled

    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        if player ~= LocalPlayer then
            if enabled then
                addESP(player)
            elseif player.Character then
                local humanoid =
                    player.Character:FindFirstChildOfClass(
                        "Humanoid"
                    )

                if humanoid then
                    humanoid.DisplayDistanceType =
                        Enum.HumanoidDisplayDistanceType.Viewer
                end

                removeESP(
                    player.Character
                )
            end
        end
    end
end

--==================================================
-- ESP MODULE
--==================================================

local ESPOptions =
    createModule(
        "ESP",
        false,
        function(enabled)
            setESPEnabled(enabled)
        end
    )

makeSlider(
    ESPOptions,
    "Fill transparency",
    Config.ESP.FillTransparency,
    0,
    1,
    function(v)
        Config.ESP.FillTransparency = v

        for _, player in ipairs(
            Players:GetPlayers()
        ) do
            if player.Character then
                local highlight =
                    player.Character:FindFirstChild(
                        "eXthusESP"
                    )

                if highlight then
                    highlight.FillTransparency = v
                end
            end
        end
    end
)

makeSlider(
    ESPOptions,
    "Outline transparency",
    Config.ESP.OutlineTransparency,
    0,
    1,
    function(v)
        Config.ESP.OutlineTransparency = v

        for _, player in ipairs(
            Players:GetPlayers()
        ) do
            if player.Character then
                local highlight =
                    player.Character:FindFirstChild(
                        "eXthusESP"
                    )

                if highlight then
                    highlight.OutlineTransparency = v
                end
            end
        end
    end
)

makeToggle(
    ESPOptions,
    "Names",
    true,
    function(v)
        Config.ESP.ShowNames = v
    end
)

makeToggle(
    ESPOptions,
    "Distance",
    true,
    function(v)
        Config.ESP.ShowDistance = v
    end
)

makeToggle(
    ESPOptions,
    "Health",
    true,
    function(v)
        Config.ESP.ShowHealth = v
    end
)

--==================================================
-- AIMBOT
--==================================================

local lockedTarget = nil
local aimbotHeld = false
local aimbotToggled = false

local function isAimbotBind(input)
    local bind =
        Config.Aimbot.BindInput

    if not bind then
        return false
    end

    if bind.EnumType ==
        Enum.KeyCode
    then
        return input.KeyCode == bind
    end

    if bind.EnumType ==
        Enum.UserInputType
    then
        return input.UserInputType == bind
    end

    return false
end

UserInputService.InputBegan:Connect(
    function(input, processed)
        if processed then
            return
        end

        if not isAimbotBind(input) then
            return
        end

        if Config.Aimbot.ActivationMode ==
            "Hold"
        then
            aimbotHeld = true
            lockedTarget = nil

        elseif Config.Aimbot.ActivationMode ==
            "Toggle"
        then
            aimbotToggled =
                not aimbotToggled

            lockedTarget = nil
        end
    end
)

UserInputService.InputEnded:Connect(
    function(input)
        if not isAimbotBind(input) then
            return
        end

        if Config.Aimbot.ActivationMode ==
            "Hold"
        then
            aimbotHeld = false
            lockedTarget = nil
        end
    end
)

--==================================================
-- AIMBOT TARGET VALIDATION
--==================================================

local function getTargetPart(player)
    if
        not player
        or not player.Character
    then
        return nil
    end

    local character =
        player.Character

    local part =
        character:FindFirstChild(
            Config.Aimbot.AimPart
        )

    if part then
        return part
    end

    return character:FindFirstChild(
        "Head"
    )
end

local function validTarget(player)
    if
        not player
        or player == LocalPlayer
    then
        return false
    end

    if not player.Parent then
        return false
    end

    local character =
        player.Character

    if not character then
        return false
    end

    local humanoid =
        character:FindFirstChildOfClass(
            "Humanoid"
        )

    if
        not humanoid
        or humanoid.Health <= 0
    then
        return false
    end

    local targetPart =
        getTargetPart(player)

    if not targetPart then
        return false
    end

    if Config.Aimbot.TargetMode ==
        "All"
    then
        return true
    end

    if Config.Aimbot.TargetMode ==
        "Group"
    then
        return playerInGroup(
            player,
            Config.Aimbot.TargetGroup
        )
    end

    return false
end

--==================================================
-- VISIBILITY
--==================================================

local function isVisible(player, targetPart)
    if not targetPart then
        return false
    end

    local camera =
        workspace.CurrentCamera

    if not camera then
        return false
    end

    local character =
        player.Character

    if not character then
        return false
    end

    local origin =
        camera.CFrame.Position

    local direction =
        targetPart.Position -
        origin

    local params =
        RaycastParams.new()

    params.FilterType =
        Enum.RaycastFilterType.Exclude

    params.FilterDescendantsInstances = {
        LocalPlayer.Character
    }

    params.IgnoreWater = true

    local result =
        workspace:Raycast(
            origin,
            direction,
            params
        )

    if not result then
        return true
    end

    return result.Instance:IsDescendantOf(
        character
    )
end

--==================================================
-- FIND NEAREST VALID TARGET
--==================================================

local function nearestTarget()
    local root =
        LocalPlayer.Character
        and LocalPlayer.Character:FindFirstChild(
            "HumanoidRootPart"
        )

    if not root then
        return nil
    end

    local closest = nil
    local closestDistance = math.huge

    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        if validTarget(player) then
            local targetPart =
                getTargetPart(player)

            if targetPart then
                local visible = true

                if Config.Aimbot.VisibilityCheck then
                    visible =
                        isVisible(
                            player,
                            targetPart
                        )
                end

                if visible then
                    local distance =
                        (
                            root.Position
                            -
                            targetPart.Position
                        ).Magnitude

                    if distance <
                        closestDistance
                    then
                        closestDistance =
                            distance

                        closest =
                            player
                    end
                end
            end
        end
    end

    return closest
end

local function aimbotActive()
    if not Config.Aimbot.Enabled then
        return false
    end

    if Config.Aimbot.ActivationMode ==
        "Always"
    then
        return true
    end

    if Config.Aimbot.ActivationMode ==
        "Toggle"
    then
        return aimbotToggled
    end

    if Config.Aimbot.ActivationMode ==
        "Hold"
    then
        return aimbotHeld
    end

    return false
end

--==================================================
-- AIMBOT MODULE
--==================================================

local AimbotOptions =
    createModule(
        "Aimbot",
        false,
        function(enabled)
            Config.Aimbot.Enabled =
                enabled

            if not enabled then
                lockedTarget = nil
                aimbotHeld = false
                aimbotToggled = false
            end
        end
    )

makeSlider(
    AimbotOptions,
    "Smoothness",
    Config.Aimbot.Smoothness,
    0.05,
    1,
    function(v)
        Config.Aimbot.Smoothness = v
    end
)

makeSlider(
    AimbotOptions,
    "FOV",
    Config.Aimbot.FOV,
    20,
    500,
    function(v)
        Config.Aimbot.FOV = v
    end
)

makeDropdown(
    AimbotOptions,
    "Aim part",
    {
        "Head",
        "HumanoidRootPart",
        "Torso"
    },
    Config.Aimbot.AimPart,
    function(v)
        Config.Aimbot.AimPart = v
        lockedTarget = nil
    end
)

makeDropdown(
    AimbotOptions,
    "Target mode",
    {
        "All",
        "Group"
    },
    Config.Aimbot.TargetMode,
    function(v)
        Config.Aimbot.TargetMode = v
        lockedTarget = nil
    end
)

--==================================================
-- DYNAMIC GROUP DROPDOWN
--==================================================

local targetGroupContainer =
    Instance.new("Frame")

targetGroupContainer.Size =
    UDim2.new(
        1,
        -8,
        0,
        36
    )

targetGroupContainer.BackgroundTransparency = 1
targetGroupContainer.Parent = AimbotOptions

local targetGroupButton =
    makeButton(
        targetGroupContainer,
        "Target group: All ▼",
        function()
            local open =
                targetGroupContainer:GetAttribute(
                    "Open"
                )

            targetGroupContainer:SetAttribute(
                "Open",
                not open
            )
        end
    )

local targetGroupOptions =
    Instance.new("Frame")

targetGroupOptions.Size =
    UDim2.new(
        1,
        0,
        0,
        0
    )

targetGroupOptions.Position =
    UDim2.fromOffset(
        0,
        38
    )

targetGroupOptions.BackgroundTransparency = 1
targetGroupOptions.Visible = false
targetGroupOptions.Parent =
    targetGroupContainer

local targetGroupLayout =
    Instance.new("UIListLayout")

targetGroupLayout.Padding =
    UDim.new(
        0,
        3
    )

targetGroupLayout.Parent =
    targetGroupOptions

local function refreshTargetGroups()
    clearObject(
        targetGroupOptions
    )

    local names = {}

    for name in pairs(Groups) do
        table.insert(
            names,
            name
        )
    end

    table.sort(names)

    for _, name in ipairs(names) do
        makeButton(
            targetGroupOptions,
            name,
            function()
                Config.Aimbot.TargetGroup =
                    name

                targetGroupButton.Text =
                    "Target group: " ..
                    name ..
                    " ▼"

                targetGroupContainer:SetAttribute(
                    "Open",
                    false
                )

                lockedTarget = nil
            end
        )
    end
end

targetGroupContainer:SetAttribute(
    "Open",
    false
)

targetGroupContainer:GetAttributeChangedSignal(
    "Open"
):Connect(function()
    local open =
        targetGroupContainer:GetAttribute(
            "Open"
        )

    targetGroupOptions.Visible =
        open

    if open then
        refreshTargetGroups()

        targetGroupContainer.Size =
            UDim2.new(
                1,
                -8,
                0,
                40 +
                targetGroupLayout.AbsoluteContentSize.Y
            )
    else
        targetGroupContainer.Size =
            UDim2.new(
                1,
                -8,
                0,
                36
            )
    end
end)

makeDropdown(
    AimbotOptions,
    "Activation",
    {
        "Always",
        "Toggle",
        "Hold"
    },
    Config.Aimbot.ActivationMode,
    function(v)
        Config.Aimbot.ActivationMode = v

        aimbotHeld = false
        aimbotToggled = false
        lockedTarget = nil
    end
)

makeDropdown(
    AimbotOptions,
    "Visibility",
    {
        "Visible Only",
        "All Players"
    },
    Config.Aimbot.VisibilityCheck
        and "Visible Only"
        or "All Players",
    function(v)
        Config.Aimbot.VisibilityCheck =
            v == "Visible Only"

        lockedTarget = nil
    end
)

makeKeybind(
    AimbotOptions,
    "Bind",
    Config.Aimbot.Bind,
    function(input, name)
        Config.Aimbot.BindInput =
            input

        Config.Aimbot.Bind =
            name

        aimbotHeld = false
        aimbotToggled = false
        lockedTarget = nil
    end
)

--==================================================
-- AIMBOT LOOP
--==================================================

RunService.RenderStepped:Connect(function()
    if not aimbotActive() then
        lockedTarget = nil
        return
    end

    -- Target disappeared/dead/respawned:
    -- immediately select another valid player.
    if not validTarget(lockedTarget) then
        lockedTarget = nearestTarget()
    end

    if not lockedTarget then
        return
    end

    local targetPart =
        getTargetPart(
            lockedTarget
        )

    if not targetPart then
        lockedTarget = nearestTarget()
        return
    end

    -- If the locked player becomes hidden,
    -- immediately search for another visible target.
    if Config.Aimbot.VisibilityCheck then
        if not isVisible(
            lockedTarget,
            targetPart
        ) then
            lockedTarget = nearestTarget()

            if not lockedTarget then
                return
            end

            targetPart =
                getTargetPart(
                    lockedTarget
                )

            if not targetPart then
                return
            end
        end
    end

    local camera =
        workspace.CurrentCamera

    if not camera then
        return
    end

    local targetCFrame =
        CFrame.lookAt(
            camera.CFrame.Position,
            targetPart.Position
        )

    camera.CFrame =
        camera.CFrame:Lerp(
            targetCFrame,
            Config.Aimbot.Smoothness
        )
end)

--==================================================
-- SPEED
--==================================================

local SpeedOptions =
    createModule(
        "Speed",
        false,
        function(enabled)
            Config.Speed.Enabled =
                enabled
        end
    )

makeSlider(
    SpeedOptions,
    "Speed",
    Config.Speed.Value,
    16,
    100,
    function(v)
        Config.Speed.Value = v
    end
)

--==================================================
-- FLY
--==================================================

local FlyOptions =
    createModule(
        "Fly",
        false,
        function(enabled)
            Config.Fly.Enabled =
                enabled
        end
    )

makeSlider(
    FlyOptions,
    "Fly speed",
    Config.Fly.Speed,
    10,
    150,
    function(v)
        Config.Fly.Speed = v
    end
)

--==================================================
-- JUMP POWER
--==================================================

local JumpOptions =
    createModule(
        "Jump Power",
        false,
        function(enabled)
            Config.JumpPower.Enabled =
                enabled
        end
    )

makeSlider(
    JumpOptions,
    "Jump power",
    Config.JumpPower.Value,
    25,
    150,
    function(v)
        Config.JumpPower.Value = v
    end
)

--==================================================
-- GRAVITY
--==================================================

local GravityOptions =
    createModule(
        "Gravity",
        false,
        function(enabled)
            Config.Gravity.Enabled =
                enabled
        end
    )

makeSlider(
    GravityOptions,
    "Gravity",
    Config.Gravity.Value,
    0,
    196,
    function(v)
        Config.Gravity.Value = v
    end
)

--==================================================
-- EXTRA MODULES
--==================================================

createModule(
    "NoClip",
    false,
    function(enabled)
        Config.NoClip = enabled
    end
)

createModule(
    "Infinite Jump",
    false,
    function(enabled)
        Config.InfiniteJump = enabled
    end
)

createModule(
    "Anti-AFK",
    false,
    function(enabled)
        Config.AntiAFK = enabled
    end
)

createModule(
    "Spinbot",
    false,
    function(enabled)
        Config.Spinbot = enabled
    end
)

createModule(
    "ForceField",
    false,
    function(enabled)
        Config.ForceField = enabled
    end
)

--==================================================
-- ACTION BUTTONS
--==================================================

local function actionModule(name, callback)
    local container =
        Instance.new("Frame")

    container.Size =
        UDim2.new(
            1,
            -8,
            0,
            42
        )

    container.BackgroundColor3 =
        OFF_COLOR

    container.BorderSizePixel = 0
    container.Parent = scroll

    local c = Instance.new("UICorner")
    c.CornerRadius = UDim.new(0, 8)
    c.Parent = container

    local button =
        Instance.new("TextButton")

    button.Size =
        UDim2.fromScale(
            1,
            1
        )

    button.BackgroundTransparency = 1
    button.Text = name
    button.TextColor3 = OFF_TEXT
    button.Font = Enum.Font.GothamMedium
    button.TextSize = 13
    button.TextXAlignment =
        Enum.TextXAlignment.Left

    button.Parent = container

    local padding =
        Instance.new("UIPadding")

    padding.PaddingLeft =
        UDim.new(
            0,
            12
        )

    padding.Parent = button

    button.MouseButton1Click:Connect(
        callback
    )
end

actionModule(
    "Sit",
    function()
        local hum =
            LocalPlayer.Character
            and LocalPlayer.Character:FindFirstChildOfClass(
                "Humanoid"
            )

        if hum then
            hum.Sit = true
        end
    end
)

actionModule(
    "Lay",
    function()
        local hum =
            LocalPlayer.Character
            and LocalPlayer.Character:FindFirstChildOfClass(
                "Humanoid"
            )

        if hum then
            hum.PlatformStand = true
        end
    end
)

actionModule(
    "Respawn",
    function()
        local hum =
            LocalPlayer.Character
            and LocalPlayer.Character:FindFirstChildOfClass(
                "Humanoid"
            )

        if hum then
            hum.Health = 0
        end
    end
)

actionModule(
    "Reset Character",
    function()
        LocalPlayer:LoadCharacter()
    end
)

actionModule(
    "Save Position",
    function()
        local root =
            LocalPlayer.Character
            and LocalPlayer.Character:FindFirstChild(
                "HumanoidRootPart"
            )

        if root then
            Config.TeleportSavedPosition =
                root.CFrame
        end
    end
)

actionModule(
    "Teleport Back",
    function()
        local root =
            LocalPlayer.Character
            and LocalPlayer.Character:FindFirstChild(
                "HumanoidRootPart"
            )

        if
            root
            and Config.TeleportSavedPosition
        then
            root.CFrame =
                Config.TeleportSavedPosition
        end
    end
)

--==================================================
-- NOCLIP
--==================================================

RunService.Stepped:Connect(function()
    if not Config.NoClip then
        return
    end

    local character =
        LocalPlayer.Character

    if character then
        for _, part in ipairs(
            character:GetDescendants()
        ) do
            if part:IsA("BasePart") then
                part.CanCollide = false
            end
        end
    end
end)

--==================================================
-- INFINITE JUMP
--==================================================

UserInputService.JumpRequest:Connect(function()
    if not Config.InfiniteJump then
        return
    end

    local hum =
        LocalPlayer.Character
        and LocalPlayer.Character:FindFirstChildOfClass(
            "Humanoid"
        )

    if hum then
        hum:ChangeState(
            Enum.HumanoidStateType.Jumping
        )
    end
end)

--==================================================
-- MOVEMENT
--==================================================

RunService.Heartbeat:Connect(function()
    local hum =
        LocalPlayer.Character
        and LocalPlayer.Character:FindFirstChildOfClass(
            "Humanoid"
        )

    if hum then
        if Config.Speed.Enabled then
            hum.WalkSpeed =
                Config.Speed.Value
        end

        if Config.JumpPower.Enabled then
            hum.UseJumpPower = true
            hum.JumpPower =
                Config.JumpPower.Value
        end
    end

    if Config.Gravity.Enabled then
        workspace.Gravity =
            Config.Gravity.Value
    end
end)

--==================================================
-- FLY
--==================================================

RunService.RenderStepped:Connect(function()
    if not Config.Fly.Enabled then
        return
    end

    local character =
        LocalPlayer.Character

    local root =
        character
        and character:FindFirstChild(
            "HumanoidRootPart"
        )

    local camera =
        workspace.CurrentCamera

    if not root or not camera then
        return
    end

    local direction =
        Vector3.zero

    if UserInputService:IsKeyDown(
        Enum.KeyCode.W
    ) then
        direction +=
            camera.CFrame.LookVector
    end

    if UserInputService:IsKeyDown(
        Enum.KeyCode.S
    ) then
        direction -=
            camera.CFrame.LookVector
    end

    if UserInputService:IsKeyDown(
        Enum.KeyCode.A
    ) then
        direction -=
            camera.CFrame.RightVector
    end

    if UserInputService:IsKeyDown(
        Enum.KeyCode.D
    ) then
        direction +=
            camera.CFrame.RightVector
    end

    if UserInputService:IsKeyDown(
        Enum.KeyCode.Space
    ) then
        direction +=
            Vector3.yAxis
    end

    if UserInputService:IsKeyDown(
        Enum.KeyCode.LeftControl
    ) then
        direction -=
            Vector3.yAxis
    end

    if direction.Magnitude > 0 then
        direction = direction.Unit
    end

    root.AssemblyLinearVelocity =
        direction *
        Config.Fly.Speed
end)

--==================================================
-- FORCEFIELD
--==================================================

RunService.Heartbeat:Connect(function()
    local character =
        LocalPlayer.Character

    if not character then
        return
    end

    local existing =
        character:FindFirstChild(
            "eXthusForceField"
        )

    if Config.ForceField then
        if not existing then
            local force =
                Instance.new(
                    "ForceField"
                )

            force.Name =
                "eXthusForceField"

            force.Parent =
                character
        end
    elseif existing then
        existing:Destroy()
    end
end)

--==================================================
-- SPINBOT
--==================================================

RunService.RenderStepped:Connect(function()
    if not Config.Spinbot then
        return
    end

    local character =
        LocalPlayer.Character

    local root =
        character
        and character:FindFirstChild(
            "HumanoidRootPart"
        )

    if root then
        root.CFrame =
            root.CFrame *
            CFrame.Angles(
                0,
                math.rad(15),
                0
            )
    end
end)

--==================================================
-- ANTI-AFK
--==================================================

task.spawn(function()
    local VirtualUser =
        game:GetService(
            "VirtualUser"
        )

    while gui.Parent do
        if Config.AntiAFK then
            VirtualUser:CaptureController()

            VirtualUser:ClickButton2(
                Vector2.new(0, 0)
            )
        end

        task.wait(30)
    end
end)

--==================================================
-- GROUPS
--==================================================

local groupModule =
    Instance.new("Frame")

groupModule.Size =
    UDim2.new(
        1,
        -8,
        0,
        42
    )

groupModule.BackgroundColor3 =
    OFF_COLOR

groupModule.BorderSizePixel = 0
groupModule.ClipsDescendants = true
groupModule.Parent = scroll

local groupCorner =
    Instance.new("UICorner")

groupCorner.CornerRadius =
    UDim.new(0, 8)

groupCorner.Parent =
    groupModule

local groupHeader =
    Instance.new("TextButton")

groupHeader.Size =
    UDim2.new(
        1,
        0,
        0,
        42
    )

groupHeader.BackgroundTransparency = 1
groupHeader.Text = "Groups  ›"
groupHeader.TextColor3 = OFF_TEXT
groupHeader.Font = Enum.Font.GothamMedium
groupHeader.TextSize = 13
groupHeader.TextXAlignment =
    Enum.TextXAlignment.Left

groupHeader.Parent =
    groupModule

local groupPadding =
    Instance.new("UIPadding")

groupPadding.PaddingLeft =
    UDim.new(
        0,
        12
    )

groupPadding.Parent =
    groupHeader

local groupOptions =
    Instance.new("Frame")

groupOptions.Size =
    UDim2.new(
        1,
        -14,
        0,
        0
    )

groupOptions.Position =
    UDim2.fromOffset(
        7,
        46
    )

groupOptions.BackgroundTransparency = 1
groupOptions.Parent =
    groupModule

local groupLayout =
    Instance.new("UIListLayout")

groupLayout.Padding =
    UDim.new(
        0,
        4
    )

groupLayout.Parent =
    groupOptions

local groupsOpen = false

local function refreshGroups()
    clearObject(
        groupOptions
    )

    local groupNames = {}

    for name in pairs(Groups) do
        table.insert(
            groupNames,
            name
        )
    end

    table.sort(
        groupNames
    )

    makeLabel(
        groupOptions,
        "Select group"
    )

    for _, name in ipairs(
        groupNames
    ) do
        makeButton(
            groupOptions,
            (
                name == SelectedGroup
                and "▶ "
                or ""
            ) ..
            name,
            function()
                SelectedGroup =
                    name

                refreshGroups()
            end
        )
    end

    makeButton(
        groupOptions,
        "+ Create group",
        function()
            local index = 1

            local name =
                "Group " ..
                index

            while Groups[name] do
                index += 1

                name =
                    "Group " ..
                    index
            end

            Groups[name] = {}

            SelectedGroup =
                name

            refreshGroups()
        end
    )

    if SelectedGroup ~= "All" then
        makeLabel(
            groupOptions,
            "Players"
        )

        for _, player in ipairs(
            Players:GetPlayers()
        ) do
            if player ~= LocalPlayer then
                local selected =
                    Groups[
                        SelectedGroup
                    ][player.UserId] ==
                    true

                makeButton(
                    groupOptions,
                    (
                        selected
                        and "[✓] "
                        or "[ ] "
                    ) ..
                    player.Name,
                    function()
                        Groups[
                            SelectedGroup
                        ][player.UserId] =
                            not selected

                        refreshGroups()
                    end
                )
            end
        end
    end

    task.defer(function()
        groupModule.Size =
            UDim2.new(
                1,
                -8,
                0,
                50 +
                groupLayout.AbsoluteContentSize.Y
            )
    end)
end

groupHeader.MouseButton1Click:Connect(function()
    groupsOpen =
        not groupsOpen

    groupOptions.Visible =
        groupsOpen

    groupHeader.Text =
        groupsOpen
        and "Groups  ⌄"
        or "Groups  ›"

    if groupsOpen then
        refreshGroups()
    else
        groupModule.Size =
            UDim2.new(
                1,
                -8,
                0,
                42
            )
    end
end)

--==================================================
-- KEEP GROUP UI UPDATED
--==================================================

task.spawn(function()
    while gui.Parent do
        rebuildAllGroup()

        if groupsOpen then
            refreshGroups()
        end

        task.wait(1)
    end
end)

--==================================================
-- DRAGGING
--==================================================

local dragging = false
local dragStart
local startPosition

titleBar.InputBegan:Connect(function(input)
    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
    then
        dragging = true

        dragStart =
            input.Position

        startPosition =
            main.Position
    end
end)

UserInputService.InputChanged:Connect(function(input)
    if
        dragging
        and input.UserInputType ==
            Enum.UserInputType.MouseMovement
    then
        local delta =
            input.Position -
            dragStart

        main.Position =
            UDim2.new(
                startPosition.X.Scale,
                startPosition.X.Offset +
                delta.X,

                startPosition.Y.Scale,
                startPosition.Y.Offset +
                delta.Y
            )
    end
end)

UserInputService.InputEnded:Connect(function(input)
    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
    then
        dragging = false
    end
end)

--==================================================
-- MINIMIZE
--==================================================

local minimized = false

minimize.MouseButton1Click:Connect(function()
    minimized =
        not minimized

    scroll.Visible =
        not minimized

    if minimized then
        main.Size =
            UDim2.fromOffset(
                330,
                44
            )

        minimize.Text = "+"

    else
        main.Size =
            UDim2.fromOffset(
                330,
                520
            )

        minimize.Text = "−"
    end
end)

--==================================================
-- CLOSE
--==================================================

close.MouseButton1Click:Connect(function()
    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        if player.Character then
            local humanoid =
                player.Character:FindFirstChildOfClass(
                    "Humanoid"
                )

            if humanoid then
                humanoid.DisplayDistanceType =
                    Enum.HumanoidDisplayDistanceType.Viewer
            end

            removeESP(
                player.Character
            )
        end
    end

    for _, connection in pairs(
        ESPConnections
    ) do
        connection:Disconnect()
    end

    for _, connection in pairs(
        CharacterConnections
    ) do
        connection:Disconnect()
    end

    gui:Destroy()
end)

--==================================================
-- LOCAL RESPAWN
--==================================================

LocalPlayer.CharacterAdded:Connect(function()
    task.wait(0.5)

    if Config.ESP.Enabled then
        for _, player in ipairs(
            Players:GetPlayers()
        ) do
            if player ~= LocalPlayer then
                addESP(player)
            end
        end
    end
end)

--==================================================
-- INITIAL TARGET GROUP REFRESH
--==================================================

refreshTargetGroups()

--==================================================
-- DONE
--==================================================