-- 🦂 SCORPIO HUB (WindUI Version)
-- Converted from Obsidian UI to WindUI

-- LOAD WINDUI
local WindUI = loadstring(game:HttpGet("https://[Log in to view URL]"))()

local Window = WindUI:CreateWindow({
    Title = "SCORPIO HUB FREE BRONX SCRIPT", 
    Icon = "rbxassetid://110903923056307",
    Author = "Tha Bronx 3",
    Folder = "MySuperHub",
    
    Size = UDim2.fromOffset(2, 150),
    Transparent = true,
    Theme = "Crimson",
    Resizable = false,
    SideBarWidth = 150,
    BackgroundImageTransparency = 0,
    HideSearchBar = true,
    ScrollBarEnabled = true,
    
    Background = "rbxassetid://110903923056307",
    
    User = {
        Enabled = false,
        Anonymous = false,
        Callback = function()
            print("User clicked")
        end,
    },

    Thumbnail = {
        Image = "rbxassetid://110903923056307", 
        Title = "Thumbnail",
    },
})
Window:EditOpenButton({
    Title = "SCORPIO HUB THA BRONX 3 SCRIPT",
    Icon = "rbxassetid://110903923056307",
    CornerRadius = UDim.new(0,16),
    StrokeThickness = 2,
    Color = ColorSequence.new(Color3.fromRGB(128, 0, 0)), -- dark blue
    OnlyMobile = false,
    Enabled = true,
    Draggable = true,
    Position = UDim2.new(0.5, -75, 0, 50), -- Top middle of screen
    Size = UDim2.new(0, 150, 0, 50), -- Button size
})

-- TABS
local MainTab = Window:Tab({Title="Player Bypass"})
local TrollTab = Window:Tab({Title="Trolls"})
local FarmTab = Window:Tab({Title="Money/Dupe"})
local CombatTab = Window:Tab({Title="Combat"})
local ShopTab = Window:Tab({Title="Extra"})
local SettingsTab = Window:Tab({Title="Farms/Fits"})

-- SECTIONS
local MovementSection = MainTab:Section({Title="Movement"})
local BypassSection = MainTab:Section({Title="Bypasses"})

local TrollSection = TrollTab:Section({Title="Trolling"})
local PlayerSelectSection = TrollTab:Section({Title="Select Player"})
local PlayerOptionsSection = TrollTab:Section({Title="Player Options"})


local DupeSection = FarmTab:Section({Title="Gun Dupes"})
local TeleportSection = FarmTab:Section({Title="Teleport"})
local InfiniteMoneySection = FarmTab:Section({Title="Infinite Money"})

local GunSection = CombatTab:Section({Title="Gun Mods"})
local GunmarketSection = CombatTab:Section({Title="Gun Market"})
local CombatSection = CombatTab:Section({Title="Kill Aura"})

local HitboxSection = ShopTab:Section({Title="Hitbox"})
local SilentSection = ShopTab:Section({Title="Slient Aim"})

local FarmSection = SettingsTab:Section({Title="💵 AUTOFARMS"})
local ClothesSection = SettingsTab:Section({Title="CHANGE CLOTHES"})

-- 🦂 SCORPIO HUB BACKGROUND
task.spawn(function()
    local Players = game:GetService("Players")
    local LocalPlayer = Players.LocalPlayer
    local PlayerGui = LocalPlayer:WaitForChild("PlayerGui")

    -- Check if background already exists
    if PlayerGui:FindFirstChild("ScorpioBackground") then
        PlayerGui.ScorpioBackground:Destroy()
    end

    local BG = Instance.new("ScreenGui")
    BG.Name = "ScorpioBackground"
    BG.ResetOnSpawn = false
    BG.Parent = PlayerGui
    BG.DisplayOrder = 0 -- Ensures it stays behind WindUI (WindUI usually has higher DisplayOrder)

    local Image = Instance.new("ImageLabel")
    Image.Parent = BG
    Image.Size = UDim2.new(1,0,1,0)
    Image.Position = UDim2.new(0,0,0,0)
    Image.BackgroundTransparency = 1
    Image.Image = "rbxassetid://111089074878671"
    Image.ImageTransparency = 0.4 -- adjust for visibility
    Image.ScaleType = Enum.ScaleType.Crop
end)

-------------------------------------------------
-- FLIGHT
-------------------------------------------------

local flying = false

MovementSection:Toggle({
    Title = "Vehicle Fly",
    Default = false,
    Callback = function(state)
        flying = state
        if flying then
            print("Flight enabled")
        else
            print("Flight disabled")
        end
    end
})

-------------------------------------------------
-- ESP SECTION (MAKE SURE THIS EXISTS)
-------------------------------------------------
local ESPSection = CombatTab:Section({Title="ESP"})

-------------------------------------------------
-- SETTINGS
-------------------------------------------------
local ESPEnabled = false
local BoxEnabled = true
local HealthEnabled = true
local TracersEnabled = true

local MaxDistance = 3000

local BoxColor = Color3.fromRGB(255,255,255)
local HealthHigh = Color3.fromRGB(0,255,0)
local HealthLow = Color3.fromRGB(255,0,0)

-------------------------------------------------
-- ESP STORAGE
-------------------------------------------------
local ESP = {}
ESP.Players = {}

-------------------------------------------------
-- CREATE ESP
-------------------------------------------------
function ESP:Create(player)
    if player == LocalPlayer then return end

    local box = Drawing.new("Square")
    box.Thickness = 1.5
    box.Filled = false
    box.Color = BoxColor

    local name = Drawing.new("Text")
    name.Size = 13
    name.Center = true
    name.Outline = true
    name.Text = player.Name

    local healthBar = Drawing.new("Square")
    healthBar.Filled = true

    local healthBg = Drawing.new("Square")
    healthBg.Color = Color3.fromRGB(0,0,0)
    healthBg.Filled = true

    ESP.Players[player] = {
        Box = box,
        Name = name,
        HealthBar = healthBar,
        BehindHealthBar = healthBg
    }
end

-------------------------------------------------
-- REMOVE ESP
-------------------------------------------------
function ESP:Remove(player)
    if ESP.Players[player] then
        for _,v in pairs(ESP.Players[player]) do
            v:Remove()
        end
        ESP.Players[player] = nil
    end
end

-------------------------------------------------
-- START / STOP
-------------------------------------------------
function ESP:Start()
    for _,plr in pairs(Players:GetPlayers()) do
        ESP:Create(plr)
    end
end

function ESP:Stop()
    for _,plr in pairs(ESP.Players) do
        ESP:Remove(plr)
    end
end

-------------------------------------------------
-- PLAYER JOIN/LEAVE
-------------------------------------------------
Players.PlayerAdded:Connect(function(plr)
    ESP:Create(plr)
end)

Players.PlayerRemoving:Connect(function(plr)
    ESP:Remove(plr)
end)

-------------------------------------------------
-- UPDATE LOOP (UPGRADED)
-------------------------------------------------
RunService.RenderStepped:Connect(function()

    if not ESPEnabled then return end

    local camera = workspace.CurrentCamera

    for player, elements in pairs(ESP.Players) do

        local character = player.Character
        if not character then continue end

        local hrp = character:FindFirstChild("HumanoidRootPart")
        local humanoid = character:FindFirstChildOfClass("Humanoid")

        if not hrp or not humanoid or humanoid.Health <= 0 then
            elements.Box.Visible = false
            elements.HealthBar.Visible = false
            elements.Name.Visible = false
            if elements.Tracer then elements.Tracer.Visible = false end
            continue
        end

        local distance = (camera.CFrame.Position - hrp.Position).Magnitude

        if distance > MaxDistance then
            elements.Box.Visible = false
            elements.HealthBar.Visible = false
            elements.Name.Visible = false
            if elements.Tracer then elements.Tracer.Visible = false end
            continue
        end

        local pos, onScreen = camera:WorldToViewportPoint(hrp.Position)

        if onScreen then

            local scale = math.clamp(1 / (distance / 100), 0.5, 3)

            local sizeX = 40 * scale
            local sizeY = 60 * scale

            elements.Box.Size = Vector2.new(sizeX, sizeY)
            elements.Box.Position = Vector2.new(pos.X - sizeX/2, pos.Y - sizeY/2)
            elements.Box.Color = BoxColor
            elements.Box.Visible = BoxEnabled

            elements.Name.Position = Vector2.new(pos.X, pos.Y - sizeY/2 - 14)
            elements.Name.Visible = true

            local hp = humanoid.Health / humanoid.MaxHealth

            elements.HealthBar.Size = Vector2.new(4, sizeY * hp)
            elements.HealthBar.Position = Vector2.new(pos.X - sizeX/2 - 6, pos.Y + sizeY/2 - (sizeY * hp))

            local blended = HealthLow:Lerp(HealthHigh, hp)
            elements.HealthBar.Color = blended

            elements.BehindHealthBar.Size = Vector2.new(4, sizeY)
            elements.BehindHealthBar.Position = Vector2.new(pos.X - sizeX/2 - 6, pos.Y - sizeY/2)

            elements.HealthBar.Visible = HealthEnabled
            elements.BehindHealthBar.Visible = HealthEnabled

            -- TRACERS
            if TracersEnabled then
                if not elements.Tracer then
                    local line = Drawing.new("Line")
                    line.Thickness = 1.5
                    elements.Tracer = line
                end

                elements.Tracer.From = Vector2.new(camera.ViewportSize.X/2, camera.ViewportSize.Y)
                elements.Tracer.To = Vector2.new(pos.X, pos.Y)
                elements.Tracer.Visible = true
            end

        else
            elements.Box.Visible = false
            elements.HealthBar.Visible = false
            elements.Name.Visible = false
            if elements.Tracer then elements.Tracer.Visible = false end
        end

    end

end)

-------------------------------------------------
-- UI CONTROLS
-------------------------------------------------

ESPSection:Toggle({
    Title = "ESP Enabled",
    Default = false,
    Callback = function(v)
        ESPEnabled = v
        if v then ESP:Start() else ESP:Stop() end
    end
})

ESPSection:Toggle({
    Title = "Boxes",
    Default = true,
    Callback = function(v)
        BoxEnabled = v
    end
})

ESPSection:Toggle({
    Title = "Health Bars",
    Default = true,
    Callback = function(v)
        HealthEnabled = v
    end
})

ESPSection:Toggle({
    Title = "Tracers",
    Default = true,
    Callback = function(v)
        TracersEnabled = v
    end
})

ESPSection:Slider({
    Title = "Render Distance",
    Min = 500,
    Max = 5000,
    Default = 3000,
    Callback = function(v)
        MaxDistance = v
    end
})

ESPSection:Colorpicker({
    Title = "Box Color",
    Default = BoxColor,
    Callback = function(c)
        BoxColor = c
    end
})

ESPSection:Colorpicker({
    Title = "Health High",
    Default = HealthHigh,
    Callback = function(c)
        HealthHigh = c
    end
})

ESPSection:Colorpicker({
    Title = "Health Low",
    Default = HealthLow,
    Callback = function(c)
        HealthLow = c
    end
})

-------------------------------------------------
-- DUPE BUTTONS
-------------------------------------------------

DupeSection:Button({
    Title = "Trunk Dupe",
    Callback = function()
        print("Running trunk dupe...")
    end
})

DupeSection:Button({
    Title = "Gun Dupe",
    Callback = function()
        loadstring(game:HttpGet("https://[Log in to view URL]"))()
    end
})

-------------------------------------------------
-- DUPE SECTION (CLEAN)
-------------------------------------------------

local DupeEnabled = false

DupeSection:Toggle({
    Title = "Auto Dupe",
    Default = false,
    Callback = function(v)
        loadstring(game:HttpGet("https://[Log in to view URL]"))()
    end
})

-------------------------------------------------
-- BYPASS SYSTEM
-------------------------------------------------

-- Noclip
local noclip = false

RunService.Stepped:Connect(function()
    if noclip and LocalPlayer.Character then
        for _,v in pairs(LocalPlayer.Character:GetDescendants()) do
            if v:IsA("BasePart") then
                v.CanCollide = false
            end
        end
    end
end)

BypassSection:Toggle({
    Title = "Noclip",
    Default = false,
    Callback = function(state)
        noclip = state
    end
})

-------------------------------------------------
-- INFINITE STATS
-------------------------------------------------

BypassSection:Toggle({
    Title = "Infinite Stamina",
    Default = false,
    Callback = function(Value)
        local StaminaBar = LocalPlayer.PlayerGui:FindFirstChild("Run") and 
        LocalPlayer.PlayerGui.Run.Frame.Frame.Frame:FindFirstChild("StaminaBarScript")

        if StaminaBar then
            StaminaBar.Enabled = not Value
        end
    end
})

BypassSection:Toggle({
    Title = "Infinite Hunger",
    Default = false,
    Callback = function(Value)
        local playerGui = LocalPlayer.PlayerGui
        local hungerBar = playerGui.Hunger.Frame.Frame.Frame:FindFirstChild("HungerBarScript")

        if hungerBar then
            hungerBar.Enabled = not Value
        end
    end
})

BypassSection:Toggle({
    Title = "Infinite Sleep",
    Default = false,
    Callback = function(Value)
        local sleepGui = LocalPlayer.PlayerGui.SleepGui
        local sleepBar = sleepGui.Frame.sleep.SleepBar:FindFirstChild("sleepScript")

        if sleepBar then
            sleepBar.Enabled = not Value
        end
    end
})

-------------------------------------------------
-- GAME BYPASSES
-------------------------------------------------

BypassSection:Toggle({
    Title = "No Rent Pay",
    Default = false,
    Callback = function(Value)
        local rentGui = game:GetService("StarterGui").RentGui
        local rentScript = rentGui:FindFirstChild("LocalScript")

        if rentScript then
            rentScript.Enabled = not Value
        end
    end
})

BypassSection:Toggle({
    Title = "Instant Prompt",
    Default = false,
    Callback = function(Value)
        for _,v in pairs(workspace:GetDescendants()) do
            if v:IsA("ProximityPrompt") then
                v.HoldDuration = Value and 0 or 1
                v.RequiresLineOfSight = not Value
            end
        end
    end
})

-------------------------------------------------
-- JUMP BYPASSES
-------------------------------------------------

local JumpDebounceBackup

BypassSection:Toggle({
    Title = "Remove Jump Cooldown",
    Default = false,
    Callback = function(Value)

        local JumpDebounce = LocalPlayer.PlayerGui:FindFirstChild("JumpDebounce")

        if Value then
            if JumpDebounce then
                JumpDebounceBackup = JumpDebounce:Clone()
                JumpDebounce:Destroy()
            end
        else
            if not LocalPlayer.PlayerGui:FindFirstChild("JumpDebounce") and JumpDebounceBackup then
                JumpDebounceBackup.Parent = LocalPlayer.PlayerGui
                JumpDebounceBackup = nil
            end
        end
    end
})

BypassSection:Toggle({
    Title = "Anti Jump Cooldown",
    Default = false,
    Callback = function(Value)

        local jumpDebounce = LocalPlayer.PlayerGui:FindFirstChild("JumpDebounce")
        local localScript = jumpDebounce and jumpDebounce:FindFirstChild("LocalScript")

        if localScript then
            localScript.Enabled = not Value
        end
    end
})

-------------------------------------------------
-- ANTI FALL DAMAGE
-------------------------------------------------

BypassSection:Toggle({
    Title = "Anti Fall Damage",
    Default = false,
    Callback = function(Value)

        local character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
        local fallDamage = character:FindFirstChild("FallDamageRagdoll")

        if Value then
            if fallDamage then
                fallDamage:Destroy()
            end
        end
    end
})

-------------------------------------------------
-- TELEPORT SYSTEM (CLEAN & STABLE)
-------------------------------------------------

local Locations = {
    ["Gunshop"] = Vector3.new(92972.28, 122097.95, 17022.78),
    ["Gunshop 2"] = Vector3.new(66202, 123615.71, 5749.81),
    ["Gunshop 3"] = Vector3.new(60819.78, 87609.14, -347.30),
    ["Safe Items"] = Vector3.new(68514.89, 52941.5, -796.09),
    ["Construction Site"] = Vector3.new(-1731.83, 370.81, -1176.83),
    ["Ice Box"] = Vector3.new(-249.57, 283.51, -1256.65),
    ["Frozen Shop"] = Vector3.new(-225.86, 283.84, -1169.94),
    ["Drip Store"] = Vector3.new(67462.69, 10489.03, 549.58),
    ["Bank"] = Vector3.new(-240.43, 283.62, -1214.41),
    ["Pawn Shop"] = Vector3.new(-1049.64, 253.53, -814.26),
    ["Penthouse"] = Vector3.new(-(555.4557 - (360 + 65)), 392.4685 + 27, -(822.7767 - (79 + 175))),
    ["Chicken Wings"] = Vector3.new(-957.91, 253.53, -815.94),
    ["Deli"] = Vector3.new(-927.72, 253.73, -691.36),
    ["Dominos"] = Vector3.new(-771.43, 253.22, -956.45),
    ["Car Dealer"] = Vector3.new(-410.52, 253.25, -1245.55),
    ["Laundromat"] = Vector3.new(-987.75, 253.91, -682.57),
    ["Margreens"] = Vector3.new(-384.37, 254.45, -373.76),
    ["Hospital"] = Vector3.new(-1579.51, 253.95, 24.49),
    ["Backpack"] = Vector3.new(-676.00, 253.78, -685.84),
}

local SelectedLocation = nil

-- Function to get keys from a table (location names)
local function tableKeys(tbl)
    local keys = {}
    for key, _ in pairs(tbl) do
        table.insert(keys, key)
    end
    return keys
end

local player = game:GetService("Players").LocalPlayer
local SelectedLocation = nil

-- Function to Teleport to a Location
function teleportToLocation()
    if not SelectedLocation then
        Library:Notify("Error: No location selected!", 3)
        return
    end
    local character = player.Character
    local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")

    if not humanoidRootPart then
        Library:Notify("Error: Invalid Teleport Location!", 3)
        return
    end

    -- Teleport the local player to the selected location by directly setting their CFrame
    humanoidRootPart.CFrame = CFrame.new(SelectedLocation)

    Library:Notify("Teleported to location", 3)
end

-------------------------------------------------
-- UI
-------------------------------------------------

TeleportSection:Dropdown({
    Title = "Select Location",
    Values = GetLocationNames(),
    Callback = function(name)
        SelectedLocation = Locations[name]
    end
})

TeleportSection:Button({
    Title = "Teleport",
    Callback = function()

        if not SelectedLocation then
            warn("No location selected!")
            return
        end

        local character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
        local hrp = character:FindFirstChild("HumanoidRootPart")

        if not hrp then
            warn("HRP not found!")
            return
        end

        -- Smooth teleport (less detection + no fling)
        local tween = TweenService:Create(
            hrp,
            TweenInfo.new(0.8, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            {CFrame = CFrame.new(SelectedLocation)}
        )

        tween:Play()

        print("Teleported!")
    end
})

-------------------------------------------------
-- BUY SUPPLIES (YOUR VERSION - FIXED)
-------------------------------------------------

InfiniteMoneySection:Button({
    Title = "Buy Supplies",
    Callback = function()

        local player = game.Players.LocalPlayer
        repeat task.wait() until player.Character and player.Character:FindFirstChild("HumanoidRootPart")

        local character = player.Character
        local hrp = character:FindFirstChild("HumanoidRootPart")

        local ReplicatedStorage = game:GetService("ReplicatedStorage")
        local Workspace = game:GetService("Workspace")

        local ExoticShopRemote = ReplicatedStorage:WaitForChild("ExoticShopRemote")
        local Backpack = player:WaitForChild("Backpack")

        -------------------------------------------------
        -- FUNCTIONS
        -------------------------------------------------

        local function teleport(position)
            if not hrp then return end

            getgenv().SwimMethod = true
            task.wait(0.5)

            hrp.CFrame = CFrame.new(position)

            getgenv().SwimMethod = false
            print("Teleported")
        end

        local function BuyItem(itemName)
            pcall(function()
                ExoticShopRemote:InvokeServer(itemName)
            end)
        end

        local function nearprompt(filterText)
            local closestPrompt, minDistance = nil, math.huge

            for _, v in pairs(Workspace:GetDescendants()) do
                if v:IsA("ProximityPrompt") and v.Enabled and v.Parent then

                    if filterText and not v.ActionText:find(filterText) then continue end

                    local part = v.Parent:IsA("Attachment") and v.Parent.Parent or v.Parent

                    if part and part:IsA("BasePart") then
                        local distance = (hrp.Position - part.Position).Magnitude

                        if distance < minDistance then
                            closestPrompt = v
                            minDistance = distance
                        end
                    end
                end
            end

            return closestPrompt
        end

        local function fireprompt(prompt)
            if prompt then
                prompt.HoldDuration = 0
                fireproximityprompt(prompt)
            end
        end

        local function equipTool(name)
            local tool = Backpack:FindFirstChild(name) or character:FindFirstChild(name)

            if tool then
                character.Humanoid:EquipTool(tool)
                task.wait(0.2)
            end
        end

        local function useTool(name)
            equipTool(name)

            local prompt = nearprompt()
            if prompt then
                fireprompt(prompt)
            end

            task.wait(2)
        end

        -------------------------------------------------
        -- MAIN LOGIC
        -------------------------------------------------

        teleport(Vector3.new(-1608.93, 253.85, -485.95))
        task.wait(1)

        -- BUY ITEMS
        BuyItem("FreshWater")
        task.wait(1)

        BuyItem("FijiWater")
        task.wait(1)

        BuyItem("Ice-Fruit Bag")
        task.wait(1)

        BuyItem("Ice-Fruit Cupz")
        task.wait(1)

        task.wait(2)

        -- USE ITEMS
        useTool("FreshWater")
        useTool("FreshWater")

        useTool("FijiWater")
        useTool("Ice-Fruit Bag")

        -- FILL CUP
        while true do
            task.wait(0.5)

            local fillPrompt = nearprompt("Fill Pitcher Cup")

            if fillPrompt then
                equipTool("Ice-Fruit Cupz")
                fireprompt(fillPrompt)
                print("Pitcher filled")
                break
            end
        end

        print("Buy Supplies Finished")

    end
})

-------------------------------------------------
-- INFINITE MONEY
-------------------------------------------------

InfiniteMoneySection:Button({
    Title = "Infinite Money",
    Callback = function()

        local Player = game:GetService("Players").LocalPlayer
        local Character = Player.Character or Player.CharacterAdded:Wait()
        local HRP = Character:WaitForChild("HumanoidRootPart")

        local TeleportPosition = Vector3.new(-(3630.7261 - 2703), 35.1368 + 218, -(1575.3687 - 884))

        local function TeleportViaSeat(pos)
            HRP.CFrame = CFrame.new(pos)
        end

        local function SpamPrompt(Prompt)

            local Total = 974000
            local BatchSize = 500

            for i = 1, Total, BatchSize do

                for j = 1, BatchSize do

                    local Stored = Player:FindFirstChild("stored")
                    local FilthyStack = Stored and Stored:FindFirstChild("FilthyStack")

                    if FilthyStack and FilthyStack:IsA("IntValue") and (FilthyStack.Value == 990000 or FilthyStack.Value == 1600000) then
                        TeleportViaSeat(TeleportPosition)
                        print("Finished! Clean your money now!")
                        return
                    end

                    pcall(function()
                        Prompt.HoldDuration = 0
                        Prompt:InputHoldBegin()
                        Prompt:InputHoldEnd()
                    end)

                end

                task.wait()

            end
        end

        local function GoToJuice()

            local OriginalPosition = HRP.Position

            for _, Obj in ipairs(workspace:GetDescendants()) do

                if Obj:IsA("ProximityPrompt") and Obj.ObjectText == "Juice" then

                    local Part = Obj.Parent

                    if Part and Part:IsA("BasePart") then

                        local OffsetPos = Vector3.new(-50.18476104736328, 286.7206115722656, -338.2304382324219)

                        TeleportViaSeat(OffsetPos)

                        task.wait(0.6)

                        local juiceTargetPos = Part.Position + Vector3.new(0,3,3)

                        TeleportViaSeat(juiceTargetPos)

                        task.wait(0.6)

                        SpamPrompt(Obj)

                        task.wait(0.6)

                        TeleportViaSeat(OriginalPosition)

                        break

                    end
                end
            end
        end

        GoToJuice()

    end
})

-- INFO LABELS
InfiniteMoneySection:Paragraph({
    Title = "Instructions",
    Desc = "Click Buy Supplies → It will teleport → Wait until finished → Then press Infinite Money again."
})

-------------------------------------------------
-- GUN MODS
-------------------------------------------------

-------------------------------------------------
-- INFINITE AMMO (STABLE VERSION)
-------------------------------------------------

GunSection:Button({
    Title = "Infinite Ammo (Inf)",
    Callback = function()

        local player = game.Players.LocalPlayer

        local function ApplyAmmo(tool)

            if tool and tool:FindFirstChild("Setting") then
                pcall(function()

                    local settings = require(tool.Setting)

                    settings.LimitedAmmoEnabled = false
                    settings.MaxAmmo = 99999
                    settings.AmmoPerMag = 99999
                    settings.Ammo = 99999

                    print("99999 Ammo applied to:", tool.Name)

                end)
            end
        end

        -- Apply to current gun
        local char = player.Character or player.CharacterAdded:Wait()
        local tool = char:FindFirstChildOfClass("Tool")
        ApplyAmmo(tool)

        -- Apply when new gun equipped
        char.ChildAdded:Connect(function(child)
            if child:IsA("Tool") then
                task.wait(0.2)
                ApplyAmmo(child)
            end
        end)

    end
})

GunSection:Button({
    Title = "No Recoil",
    Callback = function()
        local tool = game.Players.LocalPlayer.Character:FindFirstChildOfClass("Tool")
        if tool and tool:FindFirstChild("Setting") then
            require(tool.Setting).Recoil = 0
            print("No Recoil applied")
        end
    end
})

GunSection:Button({
    Title = "Automatic Gun",
    Callback = function()
        local tool = game.Players.LocalPlayer.Character:FindFirstChildOfClass("Tool")
        if tool and tool:FindFirstChild("Setting") then
            require(tool.Setting).Auto = true
            print("Gun set to Automatic")
        end
    end
})

GunSection:Button({
    Title = "No Fire Rate",
    Callback = function()
        local tool = game.Players.LocalPlayer.Character:FindFirstChildOfClass("Tool")
        if tool and tool:FindFirstChild("Setting") then
            require(tool.Setting).FireRate = 0
            print("No Fire Rate applied")
        end
    end
})

GunSection:Button({
    Title = "Infinite Damage",
    Callback = function()
        local tool = game.Players.LocalPlayer.Character:FindFirstChildOfClass("Tool")
        if tool and tool:FindFirstChild("Setting") then
            require(tool.Setting).BaseDamage = 9e9
            print("Infinite Damage applied")
        end
    end
})

-------------------------------------------------
-- GUN MARKET / QUICK SHOP
-------------------------------------------------

local player = game.Players.LocalPlayer
local gunsFolder = workspace:WaitForChild("GUNS")

local Guns = {}
local SelectedGun = nil

-- Scan gun folder
for _, gunModel in ipairs(gunsFolder:GetChildren()) do

    local modelChild = gunModel:FindFirstChild("Model")

    if modelChild and modelChild:IsA("Model") then

        local buyPrompt = modelChild:FindFirstChildWhichIsA("ProximityPrompt", true)

        if buyPrompt and buyPrompt.Name == "BuyPrompt" then

            local parentPart = buyPrompt.Parent

            if parentPart and parentPart:IsA("BasePart") then

                Guns[gunModel.Name] = {
                    Part = parentPart,
                    BuyPrompt = buyPrompt
                }

            end
        end
    end
end

-- Collect gun names
local gunNames = {}
for name in pairs(Guns) do
    table.insert(gunNames,name)
end

-- Buy Gun Function
local function BuyGun(gunData)

    if not gunData then return end

    local character = player.Character or player.CharacterAdded:Wait()
    local hrp = character:FindFirstChild("HumanoidRootPart")

    if not hrp then return end

    local originalPos = hrp.CFrame

    getgenv().SwimMethod = true

    task.wait(1)

    hrp.CFrame = gunData.Part.CFrame + Vector3.new(0,2,0)

    task.wait(0.2)

    fireproximityprompt(gunData.BuyPrompt)

    task.wait(1)

    hrp.CFrame = originalPos

    getgenv().SwimMethod = false

end

-- Gun Dropdown
GunmarketSection:Dropdown({
    Title = "Select Gun",
    Values = gunNames,
    Callback = function(v)
        SelectedGun = Guns[v]
    end
})

-- Buy Gun Button
GunmarketSection:Button({
    Title = "Buy Selected Gun",
    Callback = function()
        if SelectedGun then
            BuyGun(SelectedGun)
        else
            print("No gun selected")
        end
    end
})

-------------------------------------------------
-- QUICK SHOP ITEMS
-------------------------------------------------

GunmarketSection:Button({
    Title = "Buy Shiesty",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("Shiesty")
    end
})

GunmarketSection:Button({
    Title = "Buy Red Camo Gloves",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("RedCamoGloves")
    end
})

GunmarketSection:Button({
    Title = "Buy Yello Camo Gloves",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("YelloCamoGloves")
    end
})

GunmarketSection:Button({
    Title = "Buy Purple Camo Gloves",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("PurpleCamoGloves")
    end
})

GunmarketSection:Button({
    Title = "Buy Water",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("Water")
    end
})

GunmarketSection:Button({
    Title = "Buy Fake Card",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("FakeCard")
    end
})

GunmarketSection:Button({
    Title = "Buy Camo Gloves",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("CamoGloves")
    end
})

GunmarketSection:Button({
    Title = "Buy Blu Camo Gloves",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("BluCamoGloves")
    end
})

GunmarketSection:Button({
    Title = "Buy Pink Camo Gloves",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("PinkCamoGloves")
    end
})

GunmarketSection:Button({
    Title = "Buy Camo Shiesty",
    Callback = function()
        game:GetService("ReplicatedStorage").ShopRemote:InvokeServer("CamoShiesty")
    end
})

GunmarketSection:Button({
    Title = "Buy Extended",
    Callback = function()
         game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer(".Extended")
    end
})

GunmarketSection:Button({
    Title = "Buy Drum",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer(".Drum")
    end
})

GunmarketSection:Button({
    Title = "Buy 5.56",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("5.56")
    end
})

GunmarketSection:Button({
    Title = "Buy 7.62",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("7.62")
    end
})

GunmarketSection:Button({
    Title = "Buy Ice-Fruit Cupz",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("ice-Fruit Cupz")
    end
})

GunmarketSection:Button({
    Title = "Buy Ice-Fruit Bag",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("ice-Fruit Bag")
    end
})

GunmarketSection:Button({
    Title = "Buy FreshWater",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("FreshWater")
    end
})

GunmarketSection:Button({
    Title = "Buy FijiWater",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("FijiWater")
    end
})

GunmarketSection:Button({
    Title = "Buy Bandage",
    Callback = function()
        game:GetService("ReplicatedStorage"):WaitForChild("ExoticShopRemote"):InvokeServer("Bandage")
    end
})

-------------------------------------------------
-- HITBOX EXPANDER
-------------------------------------------------

local HitboxEnabled = false
local HitboxSize = 15

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

    player.CharacterAdded:Connect(function(char)
        task.wait(1)

        local hrp = char:FindFirstChild("HumanoidRootPart")
        if hrp and HitboxEnabled then
            hrp.Size = Vector3.new(HitboxSize, HitboxSize, HitboxSize)
            hrp.Transparency = 0.6
            hrp.BrickColor = BrickColor.new("Really red")
            hrp.Material = Enum.Material.Neon
            hrp.CanCollide = false
        end
    end)
end

-- apply to existing players
for _,plr in pairs(Players:GetPlayers()) do
    ExpandHitbox(plr)
end

Players.PlayerAdded:Connect(ExpandHitbox)

-- loop updater (keeps it applied)
RunService.RenderStepped:Connect(function()
    if HitboxEnabled then
        for _,plr in pairs(Players:GetPlayers()) do
            if plr ~= LocalPlayer and plr.Character then
                local hrp = plr.Character:FindFirstChild("HumanoidRootPart")
                if hrp then
                    hrp.Size = Vector3.new(HitboxSize, HitboxSize, HitboxSize)
                    hrp.Transparency = 0.5
                    hrp.CanCollide = false
                end
            end
        end
    end
end)

-------------------------------------------------
-- UI CONTROLS
-------------------------------------------------

HitboxSection:Toggle({
    Title = "Hitbox Expander",
    Default = false,
    Callback = function(state)
        HitboxEnabled = state

        if not state then
            -- reset hitboxes
            for _,plr in pairs(Players:GetPlayers()) do
                if plr.Character then
                    local hrp = plr.Character:FindFirstChild("HumanoidRootPart")
                    if hrp then
                        hrp.Size = Vector3.new(2,2,1)
                        hrp.Transparency = 1
                    end
                end
            end
        end
    end
})

HitboxSection:Slider({
    Title = "Hitbox Size",
    Min = 2,
    Max = 25,
    Default = 15,
    Rounding = 0,
    Callback = function(v)
        HitboxSize = v
    end
})

-------------------------------------------------
-- STUDIO AUTOFARM (FIXED)
-------------------------------------------------

local AutofarmActive = false

FarmSection:Toggle({
    Title = "Studio Autofarm",
    Default = false,
    Callback = function(state)

        AutofarmActive = state

        local RunService = game:GetService("RunService")

        local function getChar()
            local char = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
            local hum = char:WaitForChild("Humanoid")
            local hrp = char:WaitForChild("HumanoidRootPart")
            return char, hum, hrp
        end

        local char, hum, hrp = getChar()

        LocalPlayer.CharacterAdded:Connect(function()
            char, hum, hrp = getChar()
        end)

        -------------------------------------------------
        -- FREEFALL BYPASS
        -------------------------------------------------

        local FreeFallLoop

        local function setFreefall(enabled)
            if enabled then
                getgenv().SwimMethod = true

                if not FreeFallLoop then
                    FreeFallLoop = RunService.Heartbeat:Connect(function()
                        if hum then
                            hum:ChangeState(Enum.HumanoidStateType.FallingDown)
                        end
                    end)
                end
            else
                getgenv().SwimMethod = false

                if FreeFallLoop then
                    FreeFallLoop:Disconnect()
                    FreeFallLoop = nil
                end

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

        -------------------------------------------------
        -- ROB FUNCTION
        -------------------------------------------------

        local function robStudio(payName)
            if not hrp then return end

            local oldCFrame = hrp.CFrame

            local studio = workspace:FindFirstChild("StudioPay")
            if not studio then return end

            local pay = studio:FindFirstChild("Money")
            pay = pay and pay:FindFirstChild(payName)

            local prompt = pay and pay:FindFirstChild("StudioMoney1")
            prompt = prompt and prompt:FindFirstChild("Prompt")

            if prompt then
                hrp.CFrame = prompt.Parent.CFrame + Vector3.new(0,2,0)

                task.wait(0.1)

                prompt.HoldDuration = 0
                prompt.RequiresLineOfSight = false

                pcall(function()
                    fireproximityprompt(prompt, 0)
                end)

                task.wait(0.3)
                hrp.CFrame = oldCFrame
            end
        end

        -------------------------------------------------
        -- MAIN LOOP
        -------------------------------------------------

        if state then
            task.spawn(function()
                while AutofarmActive do

                    setFreefall(true)
                    task.wait(0.5)

                    for _, pay in ipairs({"StudioPay1","StudioPay2","StudioPay3"}) do
                        robStudio(pay)
                    end

                    task.wait(1)
                    setFreefall(false)

                    task.wait(1)
                end
            end)
        else
            setFreefall(false)
            print("Autofarm stopped.")
        end
    end
})

-------------------------------------------------
-- CONSTRUCTION FARM (FIXED)
-------------------------------------------------

local ConstructionFarmActive = false

FarmSection:Toggle({
    Title = "Construction Farm + Server Hop",
    Default = false,
    Callback = function(state)

        ConstructionFarmActive = state
        local speaker = LocalPlayer

        if not speaker then return end  

        print("[Construction Farm]", state and "ON" or "OFF")

        -------------------------------------------------
        -- FUNCTIONS
        -------------------------------------------------

        local function getCharacter()
            return speaker.Character or speaker.CharacterAdded:Wait()
        end

        local function getBackpack()
            return speaker:FindFirstChild("Backpack")
        end

        local function hasPlyWood()
            local backpack = getBackpack()
            local character = getCharacter()
            return (backpack and backpack:FindFirstChild("PlyWood")) 
                or (character and character:FindFirstChild("PlyWood"))
        end

        local function equipPlyWood()
            local backpack = getBackpack()
            if backpack then
                local ply = backpack:FindFirstChild("PlyWood")
                if ply then
                    ply.Parent = getCharacter()
                end
            end
        end

        local function firePrompt(prompt)
            if prompt then
                fireproximityprompt(prompt)
            end
        end

        -------------------------------------------------
        -- GRAB WOOD
        -------------------------------------------------

        local function grabWood()
            local char = getCharacter()
            local hrp = char:WaitForChild("HumanoidRootPart")

            hrp.CFrame = CFrame.new(-1727, 371, -1178)
            task.wait(0.1)

            while ConstructionFarmActive and not hasPlyWood() do
                local prompt = workspace.ConstructionStuff["Grab Wood"]:FindFirstChildOfClass("ProximityPrompt")
                firePrompt(prompt)
                task.wait(0.1)
                equipPlyWood()
            end
        end

        -------------------------------------------------
        -- BUILD WALL
        -------------------------------------------------

        local function buildWall(name, pos)
            local char = getCharacter()
            local hrp = char:WaitForChild("HumanoidRootPart")

            local prompt = workspace.ConstructionStuff[name]:FindFirstChildOfClass("ProximityPrompt")

            while ConstructionFarmActive and prompt and prompt.Enabled do
                hrp.CFrame = pos
                task.wait(0.05)

                firePrompt(prompt)

                if not hasPlyWood() then
                    grabWood()
                end
            end
        end

        -------------------------------------------------
        -- MAIN LOOP
        -------------------------------------------------

        if state then
            task.spawn(function()

                local char = getCharacter()
                local hrp = char:WaitForChild("HumanoidRootPart")

                -- START JOB
                hrp.CFrame = CFrame.new(-1728, 371, -1172)
                task.wait(0.2)

                firePrompt(workspace.ConstructionStuff["Start Job"]:FindFirstChildOfClass("ProximityPrompt"))
                task.wait(0.5)

                while ConstructionFarmActive do

                    if not hasPlyWood() then
                        grabWood()
                    end

                    buildWall("Wall2 Prompt", CFrame.new(-1705, 368, -1151))
                    buildWall("Wall3 Prompt", CFrame.new(-1732, 368, -1152))
                    buildWall("Wall4 Prompt2", CFrame.new(-1772, 368, -1152))
                    buildWall("Wall1 Prompt3", CFrame.new(-1674, 368, -1166))

                    print("[DONE] Walls complete → Server hopping...")
                    serverHop()

                    break
                end
            end)
        else
            print("[STOP] Construction Farm Off")
        end
    end
})

-------------------------------------------------
-- CLOTHES SYSTEM (FIXED)
-------------------------------------------------

-- FUNCTIONS
local function BuyCloth(category, item)
    if not category or not item then return end
    game:GetService("ReplicatedStorage").ClothShopRemote:FireServer("Buy", category, item)
end

local function WearCloth(category, item)
    if not category or not item then return end
    game:GetService("ReplicatedStorage").ClothShopRemote:FireServer("Wear", category, item)
end

-------------------------------------------------
-- DRIP FIT
-------------------------------------------------

ClothesSection:Button({
    Title = "Drip Fit",
    Callback = function()

        -- BUY
        BuyCloth("Shirts", "Blu Moncler")
        BuyCloth("Pants", "Amiri Blue Jeans")
        BuyCloth("Shiestys", "Shiesty")

        task.wait(0.3)

        -- WEAR
        WearCloth("Shirts", "Blu Moncler")
        WearCloth("Pants", "Amiri Blue Jeans")
        WearCloth("Shiestys", "Shiesty")

        print("Drip Fit Applied")
    end
})

-------------------------------------------------
-- DRIP FIT
-------------------------------------------------

ClothesSection:Button({
    Title = "Drip Fit",
    Callback = function()

        -- BUY
        BuyCloth("Shirts", "Amiri Star Hoodie")
        BuyCloth("Pants", "Black Amiri Jeans B22")
        BuyCloth("Shiestys", "Shiesty")

        task.wait(0.3)

        -- WEAR
        WearCloth("Shirts", "Amiri Star Hoodie")
        WearCloth("Pants", "Black Amiri Jeans B22")
        WearCloth("Shiestys", "Shiesty")

        print("Drip Fit Applied")
    end
})

-------------------------------------------------
-- DRIP FIT
-------------------------------------------------

ClothesSection:Button({
    Title = "Drip Fit",
    Callback = function()

        -- BUY
        BuyCloth("Shirts", "Red Sp5der Sweats")
        BuyCloth("Pants", "Red Sp5der Sweats")
        BuyCloth("Shiestys", "RedShiesty")

        task.wait(0.3)

        -- WEAR
        WearCloth("Shirts", "Red Sp5der Sweats")
        WearCloth("Pants", "Red Sp5der Sweats")
        WearCloth("Shiestys", "RedShiesty")

        print("Drip Fit Applied")
    end
})

-------------------------------------------------
-- DRIP FIT
-------------------------------------------------

ClothesSection:Button({
    Title = "Drip Fit",
    Callback = function()

        -- BUY
        BuyCloth("Shirts", "Green Sp5der Sweats")
        BuyCloth("Pants", "Green Sp5der Sweats")
        BuyCloth("Shiestys", "Shiesty")

        task.wait(0.3)

        -- WEAR
        WearCloth("Shirts", "Green Sp5der Hoodie")
        WearCloth("Pants", "Green Sp5der Sweats")
        WearCloth("Shiestys", "Shiesty")

        print("Drip Fit Applied")
    end
})

-------------------------------------------------
-- DRIP FIT
-------------------------------------------------

ClothesSection:Button({
    Title = "Drip Fit",
    Callback = function()

        -- BUY
        BuyCloth("Shirts", "Blue Sp5der Hoodie")
        BuyCloth("Pants", "Blue Sp5der Sweats")
        BuyCloth("Shiestys", "Shiesty")

        task.wait(0.3)

        -- WEAR
        WearCloth("Shirts", "Blue Sp5der Hoodie")
        WearCloth("Pants", "Blue Sp5der Sweats")
        WearCloth("Shiestys", "Shiesty")

        print("Drip Fit Applied")
    end
})

-------------------------------------------------
-- DRIP FIT
-------------------------------------------------

ClothesSection:Button({
    Title = "Drip Fit",
    Callback = function()

        -- BUY
        BuyCloth("Shirts", "Red Zipped Jacket")
        BuyCloth("Pants", "White AF1 BJeans")
        

        task.wait(0.3)

        -- WEAR
        WearCloth("Shirts", "Red Zipped Jacket")
        WearCloth("Pants", "White AF1 BJeans")
        

        print("Drip Fit Applied")
    end
})

-------------------------------------------------
-- KILL AURA
-------------------------------------------------

local KillAura = false
local Range = 450

CombatSection:Toggle({
    Title = "Enable KillAura - Hold Gun",
    Default = false,
    Callback = function(v)
        KillAura = v
    end
})

CombatSection:Slider({
    Title = "Kill Aura Range",
    Min = 10,
    Max = 500,
    Default = 450,
    Rounding = 0,
    Callback = function(v)
        Range = v
    end
})

-- KILL AURA LOOP
RunService.RenderStepped:Connect(function()

    if not KillAura then return end

    local character = LocalPlayer.Character
    if not character then return end

    local tool = character:FindFirstChildOfClass("Tool")
    if not tool then return end -- must hold gun

    local hrp = character:FindFirstChild("HumanoidRootPart")
    if not hrp then return end

    for _,player in pairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and player.Character then

            local targetHRP = player.Character:FindFirstChild("HumanoidRootPart")
            local humanoid = player.Character:FindFirstChildOfClass("Humanoid")

            if targetHRP and humanoid and humanoid.Health > 0 then

                local distance = (hrp.Position - targetHRP.Position).Magnitude

                if distance <= Range then
                    humanoid:TakeDamage(10)
                end

            end
        end
    end

end)

-------------------------------------------------
-- GUN VISUALS (FIXED + CLEAN)
-------------------------------------------------

local GunVisualSection = CombatTab:Section({Title="Gun Visuals"})

local GunChams = false
local RainbowChams = false
local ChamsColor = Color3.fromRGB(255, 0, 0)

-- STORE ORIGINAL COLORS
local OriginalColors = {}

-------------------------------------------------
-- UI
-------------------------------------------------

GunVisualSection:Toggle({
    Title = "Enable Gun Chams",
    Default = false,
    Callback = function(v)
        GunChams = v

        -- RESET WHEN TURNED OFF
        if not v then
            for part, color in pairs(OriginalColors) do
                if part and part.Parent then
                    part.Color = color
                    part.Material = Enum.Material.Plastic
                end
            end
            OriginalColors = {}
        end
    end
})

GunVisualSection:Toggle({
    Title = "Rainbow Chams",
    Default = false,
    Callback = function(v)
        RainbowChams = v
    end
})

GunVisualSection:Colorpicker({
    Title = "Gun Color",
    Default = ChamsColor,
    Callback = function(color)
        ChamsColor = color
    end
})

-------------------------------------------------
-- APPLY LOOP (FIXED)
-------------------------------------------------

RunService.RenderStepped:Connect(function()

    if not GunChams then return end

    local char = LocalPlayer.Character
    if not char then return end

    local tool = char:FindFirstChildOfClass("Tool")
    if not tool then return end

    for _,v in pairs(tool:GetDescendants()) do
        if v:IsA("BasePart") then

            -- SAVE ORIGINAL ONCE
            if not OriginalColors[v] then
                OriginalColors[v] = v.Color
            end

            -- APPLY COLOR
            if RainbowChams then
                local hue = (tick() % 5) / 5
                v.Color = Color3.fromHSV(hue, 1, 1)
            else
                v.Color = ChamsColor
            end

            v.Material = Enum.Material.Neon
        end
    end

end)

-------------------------------------------------
-- SILENT / AIM SECTION (SAFE VERSION)
-------------------------------------------------

local SilentSection = ShopTab:Section({Title="Aim Assist"})

local AimEnabled = false
local FOV = 130
local TargetPart = "HumanoidRootPart"

SilentSection:Toggle({
    Title = "Enable Aim Assist",
    Default = false,
    Callback = function(v)
        AimEnabled = v
    end
})

SilentSection:Slider({
    Title = "FOV",
    Min = 50,
    Max = 300,
    Default = 130,
    Callback = function(v)
        FOV = v
    end
})

SilentSection:Dropdown({
    Title = "Target Part",
    Values = {"Head","HumanoidRootPart"},
    Default = "HumanoidRootPart",
    Callback = function(v)
        TargetPart = v
    end
})

-------------------------------------------------
-- AIMBOT SECTION (SHOP TAB)
-------------------------------------------------
local AimbotSection = ShopTab:Section({Title="Aimbot"})

AimbotSection:Toggle({
    Title = "Enable Aimbot",
    Default = false,
    Callback = function(v)
        AimbotEnabled = v
    end
})

AimbotSection:Toggle({
    Title = "Visibility Check",
    Default = true,
    Callback = function(v)
        VisibleCheck = v
    end
})

AimbotSection:Slider({
    Title = "FOV",
    Min = 50,
    Max = 500,
    Default = 200,
    Callback = function(v)
        AimbotFOV = v
    end
})

AimbotSection:Slider({
    Title = "Prediction",
    Min = 100,
    Max = 2000,
    Default = 800,
    Callback = function(v)
        BulletSpeed = v
    end
})

print("🦂 Scorpio Hub WindUI Loaded")