-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

local Players           = game:GetService("Players")
local RunService        = game:GetService("RunService")
local UserInputService  = game:GetService("UserInputService")
local VirtualUser       = game:GetService("VirtualUser")
local Workspace         = game:GetService("Workspace")
local Lighting          = game:GetService("Lighting")
local TweenService      = game:GetService("TweenService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TextChatService   = game:GetService("TextChatService")
local CoreGui           = game:GetService("CoreGui")

local LocalPlayer = Players.LocalPlayer
local Camera      = Workspace.CurrentCamera

local env = (getgenv and getgenv()) or _G
if env.ArsenalHubLoaded then
    pcall(function()
        env.ArsenalHubUnload()
    end)
end

local libraryRepo = "https://raw.githubusercontent.com/deividcomsono/Obsidian/main/"
local loaded, Library = pcall(function()
    return loadstring(game:HttpGet(libraryRepo .. "Library.lua"))()
end)
if not loaded or not Library then
    warn("[Hub] Failed to load the Obsidian UI library: " .. tostring(Library))
    return
end

local Hub = {
    Alive       = true,
    Connections = {},
    Cleanups    = {},
    State       = {},
}

function Hub:Connect(signal, callback)
    local connection = signal:Connect(callback)
    table.insert(self.Connections, connection)
    return connection
end

function Hub:AddCleanup(fn)
    table.insert(self.Cleanups, fn)
end

function Hub:Notify(title, text, duration)
    pcall(function()
        Library:Notify({
            Title       = title,
            Description = text,
            Time        = duration or 3,
        })
    end)
end

function Hub:Unload()
    pcall(function()
        Library:Unload()
    end)
end

Library:OnUnload(function()
    Hub.Alive = false
    for _, fn in ipairs(Hub.Cleanups) do
        pcall(fn)
    end
    for _, connection in ipairs(Hub.Connections) do
        pcall(function()
            connection:Disconnect()
        end)
    end
    table.clear(Hub.Cleanups)
    table.clear(Hub.Connections)
    env.ArsenalHubLoaded = false
end)

env.ArsenalHubLoaded = true
env.ArsenalHubUnload = function()
    Hub:Unload()
end

local function getChar()
    return LocalPlayer.Character
end

local function getHumanoid()
    local char = getChar()
    return char and char:FindFirstChildOfClass("Humanoid")
end

local function getRoot()
    local char = getChar()
    return char and (char:FindFirstChild("HumanoidRootPart") or char:FindFirstChild("Torso"))
end

local function isTeammate(plr)
    local myTeam = LocalPlayer.Team
    return myTeam ~= nil and plr.Team == myTeam
end

local function newDrawing(class)
    local ok, object = pcall(function()
        return Drawing.new(class)
    end)
    if ok then
        return object
    end
    return nil
end

local function removeDrawing(object)
    if object then
        pcall(function()
            object:Remove()
        end)
    end
end

local DrawingSupported = false
do
    local probe = newDrawing("Line")
    if probe then
        DrawingSupported = true
        removeDrawing(probe)
    end
end

Hub:Connect(Workspace:GetPropertyChangedSignal("CurrentCamera"), function()
    Camera = Workspace.CurrentCamera
end)

local function getOtherPlayers()
    local list = {}
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= LocalPlayer then
            table.insert(list, plr)
        end
    end
    table.sort(list, function(a, b)
        return string.lower(a.Name) < string.lower(b.Name)
    end)
    return list
end

local Selectors = {}

local function createPlayerSelector(groupbox, id, text)
    local selector = { Index = 1, Label = nil, Slider = nil }

    function selector:Get()
        local list = getOtherPlayers()
        if #list == 0 then
            return nil
        end
        return list[math.clamp(self.Index, 1, #list)]
    end

    function selector:Refresh()
        local list = getOtherPlayers()
        local player = self:Get()
        pcall(function()
            self.Slider:SetMax(math.max(#list, 2))
        end)
        local name = "no other players"
        if player then
            name = player.DisplayName .. " (@" .. player.Name .. ")"
        end
        pcall(function()
            self.Label:SetText("Selected: " .. name)
        end)
    end

    selector.Label = groupbox:AddLabel("Selected: no other players")
    selector.Slider = groupbox:AddSlider(id, {
        Text     = text,
        Default  = 1,
        Min      = 1,
        Max      = 2,
        Rounding = 0,
        Callback = function(value)
            selector.Index = value
            selector:Refresh()
        end,
    })

    table.insert(Selectors, selector)
    selector:Refresh()
    return selector
end

local function refreshSelectors()
    for _, selector in ipairs(Selectors) do
        selector:Refresh()
    end
end

Hub:Connect(Players.PlayerAdded, function()
    task.defer(refreshSelectors)
end)

Hub:Connect(Players.PlayerRemoving, function()
    task.defer(refreshSelectors)
end)

local Window = Library:CreateWindow({
    Title            = "Arsenal Hub",
    Footer           = "Obsidian UI",
    NotifySide       = "Right",
    ShowCustomCursor = false,
})

local Tabs = {
    Combat   = Window:AddTab("Combat", "crosshair"),
    Weapon   = Window:AddTab("Gun Mods", "swords"),
    Movement = Window:AddTab("Movement", "zap"),
    Teleport = Window:AddTab("Teleport", "map-pin"),
    Visuals  = Window:AddTab("Visuals", "eye"),
    Settings = Window:AddTab("Settings", "settings"),
}

if game.PlaceId ~= 286090429 then
    Hub:Notify("Arsenal Hub", "This hub is built for Arsenal. Some features may not work in other games.", 5)
end

Hub.State.Aimbot             = false
Hub.State.AimMode            = "Hold Right Click"
Hub.State.AimPart            = "Head"
Hub.State.AimTeamCheck       = true
Hub.State.AimWallCheck       = false
Hub.State.AimSmoothness      = 30
Hub.State.ShowFOV            = false
Hub.State.FOVRadius          = 150
Hub.State.FOVColor           = Color3.fromRGB(255, 255, 255)

Hub.State.Silent             = false
Hub.State.SilentMethod       = 1
Hub.State.SilentPart         = "Head"
Hub.State.SilentFOV          = 200
Hub.State.SilentHitChance    = 100
Hub.State.SilentTeamCheck    = true
Hub.State.SilentWallCheck    = false
Hub.State.ShowSilentFOV      = false
Hub.State.SilentColor        = Color3.fromRGB(255, 80, 80)

Hub.State.Hitbox             = false
Hub.State.HitboxSize         = 15
Hub.State.HitboxTransparency = 0.6
Hub.State.HitboxPart         = "HeadHB"
Hub.State.HitboxTeamCheck    = true

Hub.State.InfAmmo            = false
Hub.State.NoRecoil           = false

Hub.State.Speed              = false
Hub.State.SpeedValue         = 50
Hub.State.SpeedMethod        = "WalkSpeed"

Hub.State.BehindDistance     = 4
Hub.State.BehindNearest      = true
Hub.State.StickBehind        = false

Hub.State.FlyEnabled = false
Hub.State.FlySpeed   = 60

local Fly = {
    BodyVelocity = nil,
    BodyGyro     = nil,
    Connection   = nil,
    Controls     = nil,
}

pcall(function()
    local playerModule = require(LocalPlayer:WaitForChild("PlayerScripts"):WaitForChild("PlayerModule"))
    Fly.Controls = playerModule:GetControls()
end)

local function getMoveVector()
    if Fly.Controls then
        local ok, vector = pcall(function()
            return Fly.Controls:GetMoveVector()
        end)
        if ok and vector then
            return vector
        end
    end

    local x, z = 0, 0
    if UserInputService:IsKeyDown(Enum.KeyCode.W) then z -= 1 end
    if UserInputService:IsKeyDown(Enum.KeyCode.S) then z += 1 end
    if UserInputService:IsKeyDown(Enum.KeyCode.A) then x -= 1 end
    if UserInputService:IsKeyDown(Enum.KeyCode.D) then x += 1 end
    return Vector3.new(x, 0, z)
end

function Fly:Stop()
    if self.Connection then
        self.Connection:Disconnect()
        self.Connection = nil
    end
    if self.BodyVelocity then
        self.BodyVelocity:Destroy()
        self.BodyVelocity = nil
    end
    if self.BodyGyro then
        self.BodyGyro:Destroy()
        self.BodyGyro = nil
    end
    local hum = getHumanoid()
    if hum then
        hum.PlatformStand = false
        hum:ChangeState(Enum.HumanoidStateType.GettingUp)
    end
end

function Fly:Start()
    self:Stop()

    local root = getRoot()
    local hum  = getHumanoid()
    if not root or not hum then
        return
    end

    hum.PlatformStand = true

    local gyro = Instance.new("BodyGyro")
    gyro.Name      = "HubFlyGyro"
    gyro.P         = 9e4
    gyro.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
    gyro.CFrame    = root.CFrame
    gyro.Parent    = root

    local velocity = Instance.new("BodyVelocity")
    velocity.Name     = "HubFlyVelocity"
    velocity.MaxForce = Vector3.new(9e9, 9e9, 9e9)
    velocity.Velocity = Vector3.zero
    velocity.Parent   = root

    self.BodyGyro     = gyro
    self.BodyVelocity = velocity

    self.Connection = RunService.RenderStepped:Connect(function()
        local currentHum = getHumanoid()
        if not currentHum or not velocity.Parent or not gyro.Parent then
            return
        end

        local cameraCFrame = Camera.CFrame
        local move = getMoveVector()
        local direction = (cameraCFrame.RightVector * move.X) + (cameraCFrame.LookVector * -move.Z)

        if UserInputService:IsKeyDown(Enum.KeyCode.Space) or currentHum.Jump then
            direction += Vector3.yAxis
        end
        if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl)
            or UserInputService:IsKeyDown(Enum.KeyCode.Q) then
            direction -= Vector3.yAxis
        end

        if direction.Magnitude > 0 then
            velocity.Velocity = direction.Unit * Hub.State.FlySpeed
        else
            velocity.Velocity = Vector3.zero
        end

        gyro.CFrame = cameraCFrame
    end)
end

local function setupFly(groupbox, maxSpeed)
    local toggle = groupbox:AddToggle("FlyToggle", {
        Text     = "Fly",
        Default  = false,
        Callback = function(value)
            Hub.State.FlyEnabled = value
            if value then
                Fly:Start()
            else
                Fly:Stop()
            end
        end,
    })

    toggle:AddKeyPicker("FlyKey", {
        Default         = "F",
        Mode            = "Toggle",
        Text            = "Fly",
        SyncToggleState = true,
    })

    groupbox:AddSlider("FlySpeedSlider", {
        Text     = "Fly Speed",
        Default  = math.min(60, maxSpeed),
        Min      = 10,
        Max      = maxSpeed,
        Rounding = 0,
        Suffix   = " studs/s",
        Callback = function(value)
            Hub.State.FlySpeed = value
        end,
    })

    groupbox:AddLabel({
        Text     = "WASD or thumbstick moves you toward where the camera looks. Space goes up, Ctrl or Q goes down.",
        DoesWrap = true,
    })
end

Hub:AddCleanup(function()
    Fly:Stop()
end)

Hub:Connect(LocalPlayer.CharacterAdded, function()
    if Hub.State.FlyEnabled then
        task.wait(0.6)
        Fly:Start()
    end
end)

local rayParams = RaycastParams.new()
rayParams.FilterType        = Enum.RaycastFilterType.Exclude
rayParams.IgnoreWater       = true
rayParams.RespectCanCollide = true

local function updateRayFilter()
    local list = {}
    local char = getChar()
    if char then
        table.insert(list, char)
    end
    for _, name in ipairs({ "Ray_Ignore", "Debris" }) do
        local folder = Workspace:FindFirstChild(name)
        if folder then
            table.insert(list, folder)
        end
    end
    rayParams.FilterDescendantsInstances = list
end

local function isVisible(part, targetChar)
    updateRayFilter()
    local origin = Camera.CFrame.Position
    local result = Workspace:Raycast(origin, part.Position - origin, rayParams)
    if not result then
        return true
    end
    return result.Instance:IsDescendantOf(targetChar)
end

local function getTargetPart(char, partName)
    if partName == "Head" then
        return char:FindFirstChild("Head")
    end
    return char:FindFirstChild("UpperTorso")
        or char:FindFirstChild("HumanoidRootPart")
        or char:FindFirstChild("Torso")
end

local function getAimCenter()
    if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
        return Camera.ViewportSize / 2
    end
    return UserInputService:GetMouseLocation()
end

local function getClosestTarget(center, radius, partName, teamCheck, wallCheck)
    local closestPart
    local closestDistance = radius

    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= LocalPlayer then
            local char = plr.Character
            local hum  = char and char:FindFirstChildOfClass("Humanoid")
            local part = char and getTargetPart(char, partName)

            if hum and part and hum.Health > 0 and not char:FindFirstChildOfClass("ForceField") then
                if not (teamCheck and isTeammate(plr)) then
                    local screenPos, onScreen = Camera:WorldToViewportPoint(part.Position)
                    if onScreen then
                        local distance = (Vector2.new(screenPos.X, screenPos.Y) - center).Magnitude
                        if distance < closestDistance then
                            if not wallCheck or isVisible(part, char) then
                                closestPart = part
                                closestDistance = distance
                            end
                        end
                    end
                end
            end
        end
    end

    return closestPart
end

local FOVCircle = newDrawing("Circle")
if FOVCircle then
    FOVCircle.Thickness    = 1.5
    FOVCircle.NumSides     = 64
    FOVCircle.Filled       = false
    FOVCircle.Transparency = 1
    FOVCircle.Visible      = false
end

Hub:AddCleanup(function()
    removeDrawing(FOVCircle)
    FOVCircle = nil
end)

local function isAiming()
    if Hub.State.AimMode == "Always On" then
        return true
    end
    return UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2)
end

Hub:Connect(RunService.RenderStepped, function(dt)
    local center = getAimCenter()

    if FOVCircle then
        FOVCircle.Visible  = Hub.State.ShowFOV
        FOVCircle.Position = center
        FOVCircle.Radius   = Hub.State.FOVRadius
        FOVCircle.Color    = Hub.State.FOVColor
    end

    if not Hub.State.Aimbot or not isAiming() then
        return
    end

    local part = getClosestTarget(
        center,
        Hub.State.FOVRadius,
        Hub.State.AimPart,
        Hub.State.AimTeamCheck,
        Hub.State.AimWallCheck
    )
    if not part then
        return
    end

    local targetCFrame = CFrame.lookAt(Camera.CFrame.Position, part.Position)
    local alpha = math.clamp(1 - Hub.State.AimSmoothness / 100, 0.02, 1)
    alpha = 1 - (1 - alpha) ^ (dt * 60)
    Camera.CFrame = Camera.CFrame:Lerp(targetCFrame, alpha)
end)

local aimGroup = Tabs.Combat:AddLeftGroupbox("Aimbot")

aimGroup:AddToggle("Aimbot", {
    Text     = "Aimbot",
    Default  = false,
    Callback = function(value)
        Hub.State.Aimbot = value
    end,
})

aimGroup:AddDropdown("AimMode", {
    Text     = "Aim Mode",
    Values   = { "Hold Right Click", "Always On" },
    Default  = 1,
    Callback = function(value)
        Hub.State.AimMode = value
    end,
})

aimGroup:AddDropdown("AimPart", {
    Text     = "Aim Part",
    Values   = { "Head", "Torso" },
    Default  = 1,
    Callback = function(value)
        Hub.State.AimPart = value
    end,
})

aimGroup:AddToggle("AimTeamCheck", {
    Text     = "Team Check",
    Default  = true,
    Callback = function(value)
        Hub.State.AimTeamCheck = value
    end,
})

aimGroup:AddToggle("AimWallCheck", {
    Text     = "Wall Check",
    Default  = false,
    Callback = function(value)
        Hub.State.AimWallCheck = value
    end,
})

aimGroup:AddSlider("AimSmoothness", {
    Text     = "Smoothness",
    Default  = 30,
    Min      = 0,
    Max      = 95,
    Rounding = 0,
    Suffix   = "%",
    Callback = function(value)
        Hub.State.AimSmoothness = value
    end,
})

local fovGroup = Tabs.Combat:AddRightGroupbox("FOV Circle")

fovGroup:AddToggle("ShowFOV", {
    Text     = "Show FOV Circle",
    Default  = false,
    Callback = function(value)
        Hub.State.ShowFOV = value
        if value and not DrawingSupported then
            Hub:Notify("FOV Circle", "Your executor does not support the Drawing library.", 4)
        end
    end,
})

fovGroup:AddSlider("FOVRadius", {
    Text     = "FOV Radius",
    Default  = 150,
    Min      = 30,
    Max      = 600,
    Rounding = 0,
    Suffix   = " px",
    Callback = function(value)
        Hub.State.FOVRadius = value
    end,
})

fovGroup:AddLabel("FOV Color"):AddColorPicker("FOVColor", {
    Default  = Hub.State.FOVColor,
    Title    = "FOV Color",
    Callback = function(value)
        Hub.State.FOVColor = value
    end,
})

local SilentMethods = {
    "FindPartOnRayWithIgnoreList",
    "Raycast",
    "Mouse.Hit / Target",
    "FindPartOnRay",
}

local Silent = {
    Target       = nil,
    OldNamecall  = nil,
    OldIndex     = nil,
    IndexHooked  = false,
}

local Mouse = LocalPlayer:GetMouse()

local hookSupported = type(hookmetamethod) == "function" and type(getnamecallmethod) == "function"
local wrapClosure   = newcclosure or function(fn) return fn end
local isOurCall     = checkcaller or function() return false end

local function shouldRedirect()
    if not Hub.Alive or not Hub.State.Silent or not Silent.Target then
        return false
    end
    if isOurCall() then
        return false
    end
    return math.random(1, 100) <= Hub.State.SilentHitChance
end

if hookSupported then
    Silent.OldNamecall = hookmetamethod(game, "__namecall", wrapClosure(function(self, ...)
        local method = getnamecallmethod()

        if self == Workspace and method == SilentMethods[Hub.State.SilentMethod] and shouldRedirect() then
            local args = table.pack(...)

            if method == "Raycast" then
                local origin    = args[1]
                local direction = args[2]
                if typeof(origin) == "Vector3" and typeof(direction) == "Vector3" then
                    args[2] = (Silent.Target.Position - origin).Unit * direction.Magnitude
                    return Silent.OldNamecall(self, table.unpack(args, 1, args.n))
                end
            elseif method == "FindPartOnRayWithIgnoreList" or method == "FindPartOnRay" then
                local ray = args[1]
                if typeof(ray) == "Ray" then
                    args[1] = Ray.new(
                        ray.Origin,
                        (Silent.Target.Position - ray.Origin).Unit * math.max(ray.Direction.Magnitude, 1)
                    )
                    return Silent.OldNamecall(self, table.unpack(args, 1, args.n))
                end
            end
        end

        return Silent.OldNamecall(self, ...)
    end))
end

local function ensureIndexHook()
    if not hookSupported or Silent.IndexHooked then
        return
    end
    Silent.IndexHooked = true
    Silent.OldIndex = hookmetamethod(game, "__index", wrapClosure(function(self, key)
        if self == Mouse
            and (key == "Hit" or key == "Target")
            and SilentMethods[Hub.State.SilentMethod] == "Mouse.Hit / Target"
            and shouldRedirect() then
            if key == "Hit" then
                return CFrame.new(Silent.Target.Position)
            end
            return Silent.Target
        end
        return Silent.OldIndex(self, key)
    end))
end

local SilentCircle = newDrawing("Circle")
if SilentCircle then
    SilentCircle.Thickness    = 1.5
    SilentCircle.NumSides     = 64
    SilentCircle.Filled       = false
    SilentCircle.Transparency = 1
    SilentCircle.Visible      = false
end

Hub:AddCleanup(function()
    Silent.Target = nil
    removeDrawing(SilentCircle)
    SilentCircle = nil
end)

Hub:Connect(RunService.RenderStepped, function()
    local state  = Hub.State
    local center = getAimCenter()

    if SilentCircle then
        SilentCircle.Visible  = state.ShowSilentFOV
        SilentCircle.Position = center
        SilentCircle.Radius   = state.SilentFOV
        SilentCircle.Color    = state.SilentColor
    end

    if state.Silent then
        Silent.Target = getClosestTarget(
            center,
            state.SilentFOV,
            state.SilentPart,
            state.SilentTeamCheck,
            state.SilentWallCheck
        )
    else
        Silent.Target = nil
    end
end)

local silentGroup = Tabs.Combat:AddLeftGroupbox("Silent Aim")

silentGroup:AddToggle("SilentAim", {
    Text     = "Silent Aim",
    Default  = false,
    Callback = function(value)
        if value and not hookSupported then
            Hub:Notify("Silent Aim", "Your executor does not support hookmetamethod.", 5)
            return
        end
        Hub.State.Silent = value
    end,
})

silentGroup:AddSlider("SilentMethod", {
    Text     = "Silent Aim Method",
    Default  = 1,
    Min      = 1,
    Max      = #SilentMethods,
    Rounding = 0,
    HideMax  = true,
    Suffix   = " - " .. SilentMethods[1],
    Callback = function(value)
        Hub.State.SilentMethod = value
        pcall(function()
            Library.Options.SilentMethod:SetSuffix(" - " .. SilentMethods[value])
        end)
        if SilentMethods[value] == "Mouse.Hit / Target" then
            ensureIndexHook()
        end
    end,
})

silentGroup:AddLabel({
    Text     = "If shots do not redirect, slide the method until one works. Arsenal usually uses method 1 or 2.",
    DoesWrap = true,
})

silentGroup:AddDropdown("SilentPart", {
    Text     = "Silent Aim Part",
    Values   = { "Head", "Torso" },
    Default  = 1,
    Callback = function(value)
        Hub.State.SilentPart = value
    end,
})

silentGroup:AddSlider("SilentHitChance", {
    Text     = "Hit Chance",
    Default  = 100,
    Min      = 1,
    Max      = 100,
    Rounding = 0,
    Suffix   = "%",
    Callback = function(value)
        Hub.State.SilentHitChance = value
    end,
})

local silentOptions = Tabs.Combat:AddRightGroupbox("Silent Aim Settings")

silentOptions:AddSlider("SilentFOV", {
    Text     = "Silent Aim FOV",
    Default  = 200,
    Min      = 30,
    Max      = 800,
    Rounding = 0,
    Suffix   = " px",
    Callback = function(value)
        Hub.State.SilentFOV = value
    end,
})

silentOptions:AddToggle("SilentTeamCheck", {
    Text     = "Team Check",
    Default  = true,
    Callback = function(value)
        Hub.State.SilentTeamCheck = value
    end,
})

silentOptions:AddToggle("SilentWallCheck", {
    Text     = "Wall Check",
    Default  = false,
    Callback = function(value)
        Hub.State.SilentWallCheck = value
    end,
})

silentOptions:AddToggle("ShowSilentFOV", {
    Text     = "Show Silent FOV Circle",
    Default  = false,
    Callback = function(value)
        Hub.State.ShowSilentFOV = value
        if value and not DrawingSupported then
            Hub:Notify("Silent FOV", "Your executor does not support the Drawing library.", 4)
        end
    end,
})

silentOptions:AddLabel("Silent FOV Color"):AddColorPicker("SilentColor", {
    Default  = Hub.State.SilentColor,
    Title    = "Silent FOV Color",
    Callback = function(value)
        Hub.State.SilentColor = value
    end,
})

local HitboxOriginals = setmetatable({}, { __mode = "k" })

local function restoreHitboxPart(part)
    local data = HitboxOriginals[part]
    if not data then
        return
    end
    HitboxOriginals[part] = nil
    if part.Parent then
        pcall(function()
            part.Size         = data.Size
            part.Transparency = data.Transparency
            part.CanCollide   = data.CanCollide
            part.Massless     = data.Massless
        end)
    end
end

local function restoreAllHitboxes()
    local parts = {}
    for part in pairs(HitboxOriginals) do
        table.insert(parts, part)
    end
    for _, part in ipairs(parts) do
        restoreHitboxPart(part)
    end
end

local function getHitboxParts(char)
    local mode  = Hub.State.HitboxPart
    local parts = {}

    if mode == "HeadHB" or mode == "Both" then
        local headBox = char:FindFirstChild("HeadHB") or char:FindFirstChild("Head")
        if headBox then
            table.insert(parts, headBox)
        end
    end
    if mode == "HumanoidRootPart" or mode == "Both" then
        local root = char:FindFirstChild("HumanoidRootPart")
        if root then
            table.insert(parts, root)
        end
    end

    return parts
end

local function applyHitboxPart(part)
    if not HitboxOriginals[part] then
        HitboxOriginals[part] = {
            Size         = part.Size,
            Transparency = part.Transparency,
            CanCollide   = part.CanCollide,
            Massless     = part.Massless,
        }
    end

    local size = Vector3.new(Hub.State.HitboxSize, Hub.State.HitboxSize, Hub.State.HitboxSize)
    if (part.Size - size).Magnitude > 0.01 then
        part.Size = size
    end
    if math.abs(part.Transparency - Hub.State.HitboxTransparency) > 0.001 then
        part.Transparency = Hub.State.HitboxTransparency
    end
    if part.CanCollide then
        part.CanCollide = false
    end
    if not part.Massless then
        part.Massless = true
    end
end

Hub:Connect(RunService.Heartbeat, function()
    if not Hub.State.Hitbox then
        return
    end

    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= LocalPlayer then
            local char = plr.Character
            local hum  = char and char:FindFirstChildOfClass("Humanoid")

            if char and hum then
                local valid = hum.Health > 0
                    and not (Hub.State.HitboxTeamCheck and isTeammate(plr))

                for _, part in ipairs(getHitboxParts(char)) do
                    if valid then
                        applyHitboxPart(part)
                    elseif HitboxOriginals[part] then
                        restoreHitboxPart(part)
                    end
                end
            end
        end
    end
end)

Hub:AddCleanup(restoreAllHitboxes)

local hitboxGroup = Tabs.Combat:AddRightGroupbox("Hitbox Expander")

hitboxGroup:AddToggle("HitboxExpander", {
    Text     = "Hitbox Expander",
    Default  = false,
    Callback = function(value)
        Hub.State.Hitbox = value
        if not value then
            restoreAllHitboxes()
        end
    end,
})

hitboxGroup:AddSlider("HitboxSize", {
    Text     = "Hitbox Size",
    Default  = 15,
    Min      = 2,
    Max      = 60,
    Rounding = 0,
    Suffix   = " studs",
    Callback = function(value)
        Hub.State.HitboxSize = value
    end,
})

hitboxGroup:AddSlider("HitboxTransparency", {
    Text     = "Hitbox Transparency",
    Default  = 0.6,
    Min      = 0,
    Max      = 1,
    Rounding = 2,
    Callback = function(value)
        Hub.State.HitboxTransparency = value
    end,
})

hitboxGroup:AddDropdown("HitboxPart", {
    Text     = "Hitbox Part",
    Values   = { "HeadHB", "HumanoidRootPart", "Both" },
    Default  = 1,
    Callback = function(value)
        restoreAllHitboxes()
        Hub.State.HitboxPart = value
    end,
})

hitboxGroup:AddToggle("HitboxTeamCheck", {
    Text     = "Team Check",
    Default  = true,
    Callback = function(value)
        Hub.State.HitboxTeamCheck = value
        if value then
            for _, plr in ipairs(Players:GetPlayers()) do
                local char = plr.Character
                if char and isTeammate(plr) then
                    for _, part in ipairs(getHitboxParts(char)) do
                        restoreHitboxPart(part)
                    end
                end
            end
        end
    end,
})

hitboxGroup:AddLabel({
    Text     = "Arsenal checks hits on your client, so bigger HeadHB and HumanoidRootPart boxes register. Very large sizes are easier for other players to notice.",
    DoesWrap = true,
})

local gunGroup = Tabs.Weapon:AddLeftGroupbox("Gun Mods")

local AmmoCache = { Primary = nil, Secondary = nil }

local function findAmmoValues()
    local gui       = LocalPlayer:FindFirstChild("PlayerGui")
    local main      = gui and gui:FindFirstChild("GUI")
    local client    = main and main:FindFirstChild("Client")
    local variables = client and client:FindFirstChild("Variables")
    if not variables then
        AmmoCache.Primary   = nil
        AmmoCache.Secondary = nil
        return
    end
    AmmoCache.Primary   = variables:FindFirstChild("ammocount")
    AmmoCache.Secondary = variables:FindFirstChild("ammocount2")
end

local RecoilOriginals = setmetatable({}, { __mode = "k" })

local function scanRecoil()
    local weapons = ReplicatedStorage:FindFirstChild("Weapons")
    if not weapons then
        return
    end
    for _, item in ipairs(weapons:GetDescendants()) do
        if item:IsA("NumberValue") or item:IsA("IntValue") then
            if string.find(string.lower(item.Name), "recoil", 1, true) then
                if RecoilOriginals[item] == nil then
                    RecoilOriginals[item] = item.Value
                end
                if item.Value ~= 0 then
                    item.Value = 0
                end
            end
        end
    end
end

local ammoTimer   = 0
local recoilTimer = 0

Hub:Connect(RunService.Heartbeat, function(dt)
    if Hub.State.InfAmmo then
        ammoTimer += dt
        if ammoTimer >= 0.1 then
            ammoTimer = 0
            if not (AmmoCache.Primary and AmmoCache.Primary.Parent) then
                findAmmoValues()
            end
            pcall(function()
                if AmmoCache.Primary then
                    AmmoCache.Primary.Value = 999
                end
                if AmmoCache.Secondary then
                    AmmoCache.Secondary.Value = 999
                end
            end)
        end
    end

    if Hub.State.NoRecoil then
        recoilTimer += dt
        if recoilTimer >= 1 then
            recoilTimer = 0
            pcall(scanRecoil)
        end
    end
end)

gunGroup:AddToggle("InfAmmo", {
    Text     = "Infinite Ammo",
    Default  = false,
    Callback = function(value)
        Hub.State.InfAmmo = value
        if value then
            findAmmoValues()
        end
    end,
})

gunGroup:AddToggle("NoRecoil", {
    Text     = "No Recoil",
    Default  = false,
    Callback = function(value)
        Hub.State.NoRecoil = value
        if value then
            pcall(scanRecoil)
        else
            local items = {}
            for item, original in pairs(RecoilOriginals) do
                items[item] = original
            end
            table.clear(RecoilOriginals)
            for item, original in pairs(items) do
                if item.Parent then
                    pcall(function()
                        item.Value = original
                    end)
                end
            end
        end
    end,
})

gunGroup:AddLabel({
    Text     = "Infinite Ammo keeps your ammo counters full. No Recoil zeroes the recoil values on every weapon. Switch weapons once after turning No Recoil on so the game reloads its stats.",
    DoesWrap = true,
})

Hub:AddCleanup(function()
    local items = {}
    for item, original in pairs(RecoilOriginals) do
        items[item] = original
    end
    table.clear(RecoilOriginals)
    for item, original in pairs(items) do
        if item.Parent then
            pcall(function()
                item.Value = original
            end)
        end
    end
end)

Hub:Connect(RunService.Heartbeat, function(dt)
    if not Hub.State.Speed or Hub.State.FlyEnabled then
        return
    end

    local hum  = getHumanoid()
    local root = getRoot()
    if not hum or not root then
        return
    end

    if Hub.State.SpeedMethod == "WalkSpeed" then
        if hum.WalkSpeed ~= Hub.State.SpeedValue then
            hum.WalkSpeed = Hub.State.SpeedValue
        end
    else
        local direction = hum.MoveDirection
        if direction.Magnitude > 0 then
            local extra = math.max(Hub.State.SpeedValue - 16, 0)
            root.CFrame = root.CFrame + direction * extra * dt
        end
    end
end)

local speedGroup = Tabs.Movement:AddLeftGroupbox("Speed")

speedGroup:AddToggle("SpeedToggle", {
    Text     = "Speed",
    Default  = false,
    Callback = function(value)
        Hub.State.Speed = value
        if not value then
            local hum = getHumanoid()
            if hum then
                hum.WalkSpeed = 16
            end
        end
    end,
})

speedGroup:AddSlider("SpeedSlider", {
    Text     = "Speed Amount",
    Default  = 50,
    Min      = 16,
    Max      = 200,
    Rounding = 0,
    Suffix   = " studs/s",
    Callback = function(value)
        Hub.State.SpeedValue = value
    end,
})

speedGroup:AddDropdown("SpeedMethod", {
    Text     = "Speed Method",
    Values   = { "WalkSpeed", "CFrame" },
    Default  = 1,
    Callback = function(value)
        Hub.State.SpeedMethod = value
        local hum = getHumanoid()
        if hum and value == "CFrame" then
            hum.WalkSpeed = 16
        end
    end,
})

speedGroup:AddLabel({
    Text     = "If the game resets your WalkSpeed, switch the method to CFrame.",
    DoesWrap = true,
})

local flyGroup = Tabs.Movement:AddRightGroupbox("Fly")
setupFly(flyGroup, 200)

local teleportGroup = Tabs.Teleport:AddLeftGroupbox("Teleport Behind Player")
local behindSelector = createPlayerSelector(teleportGroup, "BehindPlayerSlider", "Player (when not using nearest)")

local function getNearestEnemy()
    local root = getRoot()
    if not root then
        return nil
    end

    local nearest
    local nearestDistance = math.huge

    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= LocalPlayer and not isTeammate(plr) then
            local char = plr.Character
            local hum  = char and char:FindFirstChildOfClass("Humanoid")
            local targetRoot = char and char:FindFirstChild("HumanoidRootPart")
            if hum and targetRoot and hum.Health > 0 then
                local distance = (targetRoot.Position - root.Position).Magnitude
                if distance < nearestDistance then
                    nearest = plr
                    nearestDistance = distance
                end
            end
        end
    end

    return nearest
end

local function getBehindTarget()
    if Hub.State.BehindNearest then
        return getNearestEnemy()
    end
    return behindSelector:Get()
end

local function getBehindCFrame(targetRoot, distance)
    local position = (targetRoot.CFrame * CFrame.new(0, 0, distance)).Position
    return CFrame.lookAt(position, targetRoot.Position)
end

local function teleportBehind()
    local root = getRoot()
    local target = getBehindTarget()
    local targetChar = target and target.Character
    local targetRoot = targetChar and targetChar:FindFirstChild("HumanoidRootPart")
    if not root or not targetRoot then
        Hub:Notify("Teleport", "No valid target found.", 3)
        return
    end
    root.CFrame = getBehindCFrame(targetRoot, Hub.State.BehindDistance)
end

Hub:Connect(RunService.Heartbeat, function()
    if not Hub.State.StickBehind then
        return
    end
    local root = getRoot()
    local target = getBehindTarget()
    local targetChar = target and target.Character
    local targetRoot = targetChar and targetChar:FindFirstChild("HumanoidRootPart")
    local targetHum  = targetChar and targetChar:FindFirstChildOfClass("Humanoid")
    if root and targetRoot and targetHum and targetHum.Health > 0 then
        root.CFrame = getBehindCFrame(targetRoot, Hub.State.BehindDistance)
        root.AssemblyLinearVelocity = Vector3.zero
    end
end)

teleportGroup:AddToggle("BehindNearest", {
    Text     = "Use Nearest Enemy",
    Default  = true,
    Callback = function(value)
        Hub.State.BehindNearest = value
    end,
})

teleportGroup:AddSlider("BehindDistance", {
    Text     = "Distance Behind",
    Default  = 4,
    Min      = 1,
    Max      = 15,
    Rounding = 1,
    Suffix   = " studs",
    Callback = function(value)
        Hub.State.BehindDistance = value
    end,
})

teleportGroup:AddButton({
    Text = "Teleport Behind Target",
    Func = teleportBehind,
})

teleportGroup:AddToggle("StickBehind", {
    Text     = "Stick Behind Target",
    Default  = false,
    Callback = function(value)
        Hub.State.StickBehind = value
    end,
})

local teleportInfo = Tabs.Teleport:AddRightGroupbox("Info")
teleportInfo:AddLabel({
    Text     = "Teleports your CFrame to just behind the target and turns you to face them. Stick Behind Target keeps you there every frame.",
    DoesWrap = true,
})

Hub.State.NameESP         = false
Hub.State.HealthESP       = false
Hub.State.TracerESP       = false
Hub.State.Chams           = false
Hub.State.Outline         = false
Hub.State.ESPTeamCheck    = false
Hub.State.TeamColors      = false
Hub.State.TracerOrigin    = "Bottom"
Hub.State.ESPMaxDistance  = 5000
Hub.State.ChamsTransparency = 0.5
Hub.State.NameColor       = Color3.fromRGB(255, 255, 255)
Hub.State.TracerColor     = Color3.fromRGB(255, 80, 80)
Hub.State.ChamsColor      = Color3.fromRGB(255, 60, 60)
Hub.State.OutlineColor    = Color3.fromRGB(255, 255, 255)

local ESP = {
    Objects = {},
    Folder  = nil,
}

local function getGuiContainer()
    local ok, container = pcall(function()
        if gethui then
            return gethui()
        end
        return CoreGui
    end)
    if ok and container then
        return container
    end
    return LocalPlayer:WaitForChild("PlayerGui")
end

ESP.Folder = Instance.new("Folder")
ESP.Folder.Name = "HubVisuals"
do
    local parented = pcall(function()
        ESP.Folder.Parent = getGuiContainer()
    end)
    if not parented or not ESP.Folder.Parent then
        ESP.Folder.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end
end

local function createESP(plr)
    if plr == LocalPlayer or ESP.Objects[plr] then
        return
    end

    local gui = Instance.new("BillboardGui")
    gui.Name        = "HubTag"
    gui.AlwaysOnTop = true
    gui.Size        = UDim2.fromOffset(170, 48)
    gui.StudsOffset = Vector3.new(0, 3, 0)
    gui.Enabled     = false
    gui.Parent      = ESP.Folder

    local nameLabel = Instance.new("TextLabel")
    nameLabel.Name                   = "NameLabel"
    nameLabel.BackgroundTransparency = 1
    nameLabel.Size                   = UDim2.new(1, 0, 0, 16)
    nameLabel.Font                   = Enum.Font.GothamBold
    nameLabel.TextSize               = 14
    nameLabel.TextStrokeTransparency = 0
    nameLabel.TextColor3             = Hub.State.NameColor
    nameLabel.Parent                 = gui

    local healthGroup = Instance.new("Frame")
    healthGroup.Name                   = "HealthGroup"
    healthGroup.BackgroundTransparency = 1
    healthGroup.Position               = UDim2.new(0, 0, 0, 18)
    healthGroup.Size                   = UDim2.new(1, 0, 0, 30)
    healthGroup.Visible                = false
    healthGroup.Parent                 = gui

    local barBack = Instance.new("Frame")
    barBack.Name             = "BarBack"
    barBack.BackgroundColor3 = Color3.fromRGB(20, 20, 20)
    barBack.BorderSizePixel  = 0
    barBack.Position         = UDim2.new(0.15, 0, 0, 2)
    barBack.Size             = UDim2.new(0.7, 0, 0, 6)
    barBack.Parent           = healthGroup

    local barFill = Instance.new("Frame")
    barFill.Name             = "BarFill"
    barFill.BackgroundColor3 = Color3.fromRGB(0, 255, 0)
    barFill.BorderSizePixel  = 0
    barFill.Size             = UDim2.fromScale(1, 1)
    barFill.Parent           = barBack

    local healthLabel = Instance.new("TextLabel")
    healthLabel.Name                   = "HealthLabel"
    healthLabel.BackgroundTransparency = 1
    healthLabel.Position               = UDim2.new(0, 0, 0, 10)
    healthLabel.Size                   = UDim2.new(1, 0, 0, 14)
    healthLabel.Font                   = Enum.Font.GothamBold
    healthLabel.TextSize               = 12
    healthLabel.TextColor3             = Color3.fromRGB(255, 255, 255)
    healthLabel.TextStrokeTransparency = 0
    healthLabel.Parent                 = healthGroup

    local highlight = Instance.new("Highlight")
    highlight.Name      = "HubHighlight"
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.Enabled   = false
    highlight.Parent    = ESP.Folder

    local tracer = newDrawing("Line")
    if tracer then
        tracer.Thickness    = 1.5
        tracer.Transparency = 1
        tracer.Visible      = false
    end

    ESP.Objects[plr] = {
        Gui         = gui,
        NameLabel   = nameLabel,
        HealthGroup = healthGroup,
        BarFill     = barFill,
        HealthLabel = healthLabel,
        Highlight   = highlight,
        Tracer      = tracer,
    }
end

local function removeESP(plr)
    local object = ESP.Objects[plr]
    if not object then
        return
    end
    ESP.Objects[plr] = nil
    pcall(function() object.Gui:Destroy() end)
    pcall(function() object.Highlight:Destroy() end)
    removeDrawing(object.Tracer)
end

local function hideESP(object)
    object.Gui.Enabled       = false
    object.Highlight.Enabled = false
    if object.Tracer then
        object.Tracer.Visible = false
    end
end

local function getTracerOrigin(viewport)
    local origin = Hub.State.TracerOrigin
    if origin == "Center" then
        return Vector2.new(viewport.X / 2, viewport.Y / 2)
    elseif origin == "Mouse" then
        return UserInputService:GetMouseLocation()
    end
    return Vector2.new(viewport.X / 2, viewport.Y)
end

local function resolveColor(plr, fallback)
    if Hub.State.TeamColors and plr.Team then
        return plr.TeamColor.Color
    end
    return fallback
end

Hub:Connect(RunService.RenderStepped, function()
    local state    = Hub.State
    local viewport = Camera.ViewportSize
    local camPos   = Camera.CFrame.Position

    for plr, object in pairs(ESP.Objects) do
        local char = plr.Character
        local hum  = char and char:FindFirstChildOfClass("Humanoid")
        local root = char and char:FindFirstChild("HumanoidRootPart")
        local head = char and char:FindFirstChild("Head")

        local valid = hum and root and head and hum.Health > 0
            and not (state.ESPTeamCheck and isTeammate(plr))

        local distance = valid and (camPos - root.Position).Magnitude or 0
        if valid and distance > state.ESPMaxDistance then
            valid = false
        end

        if not valid then
            hideESP(object)
        else
            local showTag = state.NameESP or state.HealthESP
            object.Gui.Enabled = showTag

            if showTag then
                if object.Gui.Adornee ~= head then
                    object.Gui.Adornee = head
                end

                object.NameLabel.Visible = state.NameESP
                if state.NameESP then
                    object.NameLabel.Text       = plr.DisplayName .. " [" .. math.floor(distance) .. "m]"
                    object.NameLabel.TextColor3 = resolveColor(plr, state.NameColor)
                end

                object.HealthGroup.Visible = state.HealthESP
                if state.HealthESP then
                    local ratio = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
                    object.BarFill.Size             = UDim2.fromScale(ratio, 1)
                    object.BarFill.BackgroundColor3 = Color3.fromHSV(ratio * 0.33, 1, 1)
                    object.HealthLabel.Text         = math.floor(hum.Health) .. " HP"
                end
            end

            if object.Tracer then
                if state.TracerESP then
                    local screenPos, onScreen = Camera:WorldToViewportPoint(root.Position)
                    if onScreen then
                        object.Tracer.From    = getTracerOrigin(viewport)
                        object.Tracer.To      = Vector2.new(screenPos.X, screenPos.Y)
                        object.Tracer.Color   = resolveColor(plr, state.TracerColor)
                        object.Tracer.Visible = true
                    else
                        object.Tracer.Visible = false
                    end
                else
                    object.Tracer.Visible = false
                end
            end

            local highlight = object.Highlight
            if state.Chams or state.Outline then
                if highlight.Adornee ~= char then
                    highlight.Adornee = char
                end
                highlight.FillColor           = resolveColor(plr, state.ChamsColor)
                highlight.OutlineColor        = resolveColor(plr, state.OutlineColor)
                highlight.FillTransparency    = state.Chams and state.ChamsTransparency or 1
                highlight.OutlineTransparency = state.Outline and 0 or 1
                highlight.Enabled             = true
            else
                highlight.Enabled = false
            end
        end
    end
end)

Hub:Connect(Players.PlayerAdded, createESP)
Hub:Connect(Players.PlayerRemoving, removeESP)

for _, plr in ipairs(Players:GetPlayers()) do
    createESP(plr)
end

Hub:AddCleanup(function()
    local list = {}
    for plr in pairs(ESP.Objects) do
        table.insert(list, plr)
    end
    for _, plr in ipairs(list) do
        removeESP(plr)
    end
    if ESP.Folder then
        ESP.Folder:Destroy()
        ESP.Folder = nil
    end
end)

local function setupESP(tab)
    local main = tab:AddLeftGroupbox("ESP")

    main:AddToggle("NameESP", {
        Text     = "Name ESP",
        Default  = false,
        Callback = function(value)
            Hub.State.NameESP = value
        end,
    })

    main:AddToggle("HealthESP", {
        Text     = "Health ESP",
        Default  = false,
        Callback = function(value)
            Hub.State.HealthESP = value
        end,
    })

    main:AddToggle("TracerESP", {
        Text     = "Tracer ESP",
        Default  = false,
        Callback = function(value)
            Hub.State.TracerESP = value
            if value and not DrawingSupported then
                Hub:Notify("Tracer ESP", "Your executor does not support the Drawing library.", 4)
            end
        end,
    })

    main:AddToggle("ChamsESP", {
        Text     = "Charm ESP (Chams)",
        Default  = false,
        Callback = function(value)
            Hub.State.Chams = value
        end,
    })

    main:AddToggle("OutlineESP", {
        Text     = "Highlight ESP (Outline)",
        Default  = false,
        Callback = function(value)
            Hub.State.Outline = value
        end,
    })

    main:AddToggle("ESPTeamCheck", {
        Text     = "Team Check (hide teammates)",
        Default  = false,
        Callback = function(value)
            Hub.State.ESPTeamCheck = value
        end,
    })

    main:AddToggle("ESPTeamColors", {
        Text     = "Use Team Colors",
        Default  = false,
        Callback = function(value)
            Hub.State.TeamColors = value
        end,
    })

    main:AddDropdown("TracerOrigin", {
        Text     = "Tracer Origin",
        Values   = { "Bottom", "Center", "Mouse" },
        Default  = 1,
        Callback = function(value)
            Hub.State.TracerOrigin = value
        end,
    })

    main:AddSlider("ChamsTransparency", {
        Text     = "Chams Transparency",
        Default  = 0.5,
        Min      = 0,
        Max      = 1,
        Rounding = 2,
        Callback = function(value)
            Hub.State.ChamsTransparency = value
        end,
    })

    main:AddSlider("ESPMaxDistance", {
        Text     = "Max Distance",
        Default  = 5000,
        Min      = 100,
        Max      = 5000,
        Rounding = 0,
        Suffix   = " studs",
        Callback = function(value)
            Hub.State.ESPMaxDistance = value
        end,
    })

    local colors = tab:AddRightGroupbox("ESP Colors")

    colors:AddLabel("Name Color"):AddColorPicker("NameColor", {
        Default  = Hub.State.NameColor,
        Title    = "Name Color",
        Callback = function(value)
            Hub.State.NameColor = value
        end,
    })

    colors:AddLabel("Tracer Color"):AddColorPicker("TracerColor", {
        Default  = Hub.State.TracerColor,
        Title    = "Tracer Color",
        Callback = function(value)
            Hub.State.TracerColor = value
        end,
    })

    colors:AddLabel("Chams Color"):AddColorPicker("ChamsColor", {
        Default  = Hub.State.ChamsColor,
        Title    = "Chams Color",
        Callback = function(value)
            Hub.State.ChamsColor = value
        end,
    })

    colors:AddLabel("Highlight Outline Color"):AddColorPicker("OutlineColor", {
        Default  = Hub.State.OutlineColor,
        Title    = "Highlight Outline Color",
        Callback = function(value)
            Hub.State.OutlineColor = value
        end,
    })

    colors:AddLabel({
        Text     = "Team Colors overrides these colors with each player's team color.",
        DoesWrap = true,
    })
end

local function setupSettings(tab)
    local menu = tab:AddLeftGroupbox("Menu")

    menu:AddLabel("Menu keybind"):AddKeyPicker("MenuKeybind", {
        Default = "RightControl",
        NoUI    = true,
        Text    = "Menu keybind",
    })

    pcall(function()
        Library.ToggleKeybind = Library.Options.MenuKeybind
    end)

    menu:AddButton({
        Text        = "Unload Script",
        DoubleClick = true,
        Risky       = true,
        Func        = function()
            Hub:Unload()
        end,
    })

    local info = tab:AddRightGroupbox("Info")
    info:AddLabel({
        Text     = "Press the menu keybind to hide or show this window. Unloading removes every feature and restores the game.",
        DoesWrap = true,
    })
    info:AddLabel({
        Text     = "Cheating can get your account reported or banned. Use an alt account.",
        DoesWrap = true,
    })
end

setupESP(Tabs.Visuals)
setupSettings(Tabs.Settings)

Hub:Notify("Arsenal Hub", "Loaded. Press Right Control to hide or show the menu.", 5)