--------------------------------------------------
-- VANTA CORE DISCORD GATE
--------------------------------------------------

local DISCORD_URL = "https://discord.gg/UG2x3gnkUV"

local function createDiscordGate()
    local Players = game:GetService("Players")
    local CoreGui = game:GetService("CoreGui")
    local GuiService = game:GetService("GuiService")
    local LP = Players.LocalPlayer

    local gateGui = Instance.new("ScreenGui")
    gateGui.Name = "VantaCore_DiscordGate"
    gateGui.ResetOnSpawn = false
    gateGui.IgnoreGuiInset = true
    gateGui.DisplayOrder = 1000000

    local mounted = false
    if gethui then
        local ok, parent = pcall(gethui)
        if ok and parent then
            gateGui.Parent = parent
            mounted = true
        end
    end

    if not mounted then
        local ok = pcall(function()
            gateGui.Parent = CoreGui
        end)
        if not ok then
            gateGui.Parent = LP:WaitForChild("PlayerGui")
        end
    end

    local overlay = Instance.new("Frame")
    overlay.Size = UDim2.fromScale(1, 1)
    overlay.BackgroundColor3 = Color3.fromRGB(7, 8, 12)
    overlay.BackgroundTransparency = 0.15
    overlay.BorderSizePixel = 0
    overlay.Parent = gateGui

    local window = Instance.new("Frame")
    window.AnchorPoint = Vector2.new(0.5, 0.5)
    window.Position = UDim2.fromScale(0.5, 0.5)
    window.Size = UDim2.fromOffset(430, 250)
    window.BackgroundColor3 = Color3.fromRGB(17, 18, 25)
    window.BorderSizePixel = 0
    window.Parent = overlay

    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(0, 14)
    corner.Parent = window

    local stroke = Instance.new("UIStroke")
    stroke.Color = Color3.fromRGB(42, 45, 60)
    stroke.Thickness = 1
    stroke.Transparency = 0.15
    stroke.Parent = window

    local title = Instance.new("TextLabel")
    title.Position = UDim2.fromOffset(22, 20)
    title.Size = UDim2.new(1, -44, 0, 30)
    title.BackgroundTransparency = 1
    title.Text = "VANTA CORE"
    title.TextColor3 = Color3.fromRGB(240, 242, 250)
    title.Font = Enum.Font.GothamBold
    title.TextSize = 22
    title.TextXAlignment = Enum.TextXAlignment.Left
    title.Parent = window

    local sub = Instance.new("TextLabel")
    sub.Position = UDim2.fromOffset(22, 55)
    sub.Size = UDim2.new(1, -44, 0, 38)
    sub.BackgroundTransparency = 1
    sub.Text = "Connect to the official Discord before continuing."
    sub.TextWrapped = true
    sub.TextColor3 = Color3.fromRGB(145, 150, 170)
    sub.Font = Enum.Font.Gotham
    sub.TextSize = 12
    sub.TextXAlignment = Enum.TextXAlignment.Left
    sub.Parent = window

    local status = Instance.new("TextLabel")
    status.Position = UDim2.fromOffset(22, 104)
    status.Size = UDim2.new(1, -44, 0, 30)
    status.BackgroundTransparency = 1
    status.Text = "Discord connection required."
    status.TextColor3 = Color3.fromRGB(255, 185, 90)
    status.Font = Enum.Font.Gotham
    status.TextSize = 11
    status.TextXAlignment = Enum.TextXAlignment.Left
    status.Parent = window

    local connectButton = Instance.new("TextButton")
    connectButton.Position = UDim2.fromOffset(22, 148)
    connectButton.Size = UDim2.new(0.5, -27, 0, 44)
    connectButton.BackgroundColor3 = Color3.fromRGB(88, 101, 242)
    connectButton.BorderSizePixel = 0
    connectButton.Text = "Connect Discord"
    connectButton.TextColor3 = Color3.fromRGB(255, 255, 255)
    connectButton.Font = Enum.Font.GothamBold
    connectButton.TextSize = 13
    connectButton.AutoButtonColor = true
    connectButton.Parent = window

    local cc = Instance.new("UICorner")
    cc.CornerRadius = UDim.new(0, 9)
    cc.Parent = connectButton

    local continueButton = Instance.new("TextButton")
    continueButton.Position = UDim2.new(0.5, 5, 0, 148)
    continueButton.Size = UDim2.new(0.5, -27, 0, 44)
    continueButton.BackgroundColor3 = Color3.fromRGB(32, 34, 46)
    continueButton.BorderSizePixel = 0
    continueButton.Text = "Continue"
    continueButton.TextColor3 = Color3.fromRGB(110, 115, 135)
    continueButton.Font = Enum.Font.GothamBold
    continueButton.TextSize = 13
    continueButton.AutoButtonColor = false
    continueButton.Parent = window

    local ctc = Instance.new("UICorner")
    ctc.CornerRadius = UDim.new(0, 9)
    ctc.Parent = continueButton

    local footer = Instance.new("TextLabel")
    footer.Position = UDim2.fromOffset(22, 205)
    footer.Size = UDim2.new(1, -44, 0, 20)
    footer.BackgroundTransparency = 1
    footer.Text = DISCORD_URL
    footer.TextColor3 = Color3.fromRGB(90, 95, 115)
    footer.Font = Enum.Font.Gotham
    footer.TextSize = 10
    footer.TextXAlignment = Enum.TextXAlignment.Left
    footer.Parent = window

    local connected = false
    local event = Instance.new("BindableEvent")

    local function markConnected()
        if connected then return end
        connected = true
        status.TextColor3 = Color3.fromRGB(90, 235, 150)
        status.Text = "Discord opened! Join the server, then click Continue."
        continueButton.BackgroundColor3 = Color3.fromRGB(0, 190, 255)
        continueButton.TextColor3 = Color3.fromRGB(255, 255, 255)
        continueButton.AutoButtonColor = true
    end

    connectButton.MouseButton1Click:Connect(function()
        local opened = false

        -- Try opening the invite directly when supported.
        pcall(function()
            GuiService:OpenBrowserWindow(DISCORD_URL)
            opened = true
        end)

        -- Also copy the invite when clipboard access is available.
        if setclipboard then
            pcall(setclipboard, DISCORD_URL)
        end

        markConnected()
    end)

    continueButton.MouseButton1Click:Connect(function()
        if not connected then
            status.TextColor3 = Color3.fromRGB(255, 100, 110)
            status.Text = "Connect Discord first."
            return
        end

        gateGui:Destroy()
        event:Fire()
    end)

    event.Event:Wait()
    event:Destroy()
    return true
end

if not createDiscordGate() then
    return
end

--------------------------------------------------
-- END DISCORD GATE
--------------------------------------------------

-- VANTA CORE V6 MODERN
-- Classic V1 wallhack + Aimbot + wallbang + hitbox + viewmodel + ultra-light modern GUI
-- Default keybinds: RightShift = GUI | Q = Aimbot | X = Wallhack | V = Wallbang | P = Potato | Delete = unload

local ENV = getgenv and getgenv() or _G

if ENV.VantaCore and ENV.VantaCore.Unload then
    pcall(ENV.VantaCore.Unload)
end

local Players = game:GetService("Players")
local UIS = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local CoreGui = game:GetService("CoreGui")
local Lighting = game:GetService("Lighting")

local LP = Players.LocalPlayer
local Camera = workspace.CurrentCamera

local CFG = {
    TeamCheck = true,
    TeamRadius = 30,

    -- Aimbot
    Aimbot = false,
    AimHoldRMB = true,
    AimVisibleCheck = true,
    AimHead = true,
    AimFOV = 180,
    AimSmooth = 12,
    AimMaxDistance = 2500,

    -- Modern low-impact wallhack / ESP
    ESP = true,
    Highlight = true,
    HighlightFill = true,
    BoxESP = true,
    Name = true,
    Health = true,
    Distance = true,
    MaxDistance = 2200,
    ESPUpdateRate = 0.08, -- classic V1 refresh; Potato Mode never changes ESP behavior

    -- Viewmodel / hands
    ViewmodelEnabled = false,
    ViewmodelFOV = 75,
    ViewmodelX = 0.00,
    ViewmodelY = 0.00,
    ViewmodelZ = 0.00,

    -- Performance
    PotatoMode = false,


    -- Head hitbox
    HeadExpand = false,
    HeadSize = 6,
    HeadTransparency = 0.55,

    -- Wallbang
    Wallbang = false,
    PenetrationDepth = 3,

    -- Keybinds
    MenuKey = Enum.KeyCode.RightShift,
    AimbotKey = Enum.KeyCode.Q,
    ESPKey = Enum.KeyCode.X,
    WallbangKey = Enum.KeyCode.V,
    PotatoKey = Enum.KeyCode.P,
    UnloadKey = Enum.KeyCode.Delete,
}

local running = true
local connections = {}
local ESP = {}
local originalHeads = {}
local roundTeam = {}
local roundActive = false
local roundEndedAt = 0
local roundNumber = 0
local refreshAllESP
local aimHeld = false


-- PERFORMANCE / POTATO STATE
local originalLighting = {
    GlobalShadows = Lighting.GlobalShadows,
    EnvironmentDiffuseScale = Lighting.EnvironmentDiffuseScale,
    EnvironmentSpecularScale = Lighting.EnvironmentSpecularScale,
    FogEnd = Lighting.FogEnd,
}
local originalEffects = {}
local terrain = workspace:FindFirstChildOfClass("Terrain")
local originalDecoration = nil
if terrain then
    pcall(function() originalDecoration = terrain.Decoration end)
end

local function rememberEffect(effect)
    if effect:IsA("PostEffect") and originalEffects[effect] == nil then
        originalEffects[effect] = effect.Enabled
    end
end
for _, child in ipairs(Lighting:GetChildren()) do rememberEffect(child) end

local function applyPotatoMode(enabled)
    CFG.PotatoMode = enabled == true
    if CFG.PotatoMode then
        pcall(function() Lighting.GlobalShadows = false end)
        pcall(function() Lighting.EnvironmentDiffuseScale = 0 end)
        pcall(function() Lighting.EnvironmentSpecularScale = 0 end)
        pcall(function() Lighting.FogEnd = 1000000 end)
        if terrain then pcall(function() terrain.Decoration = false end) end
        for _, child in ipairs(Lighting:GetChildren()) do
            rememberEffect(child)
            if child:IsA("PostEffect") then pcall(function() child.Enabled = false end) end
        end
    else
        pcall(function() Lighting.GlobalShadows = originalLighting.GlobalShadows end)
        pcall(function() Lighting.EnvironmentDiffuseScale = originalLighting.EnvironmentDiffuseScale end)
        pcall(function() Lighting.EnvironmentSpecularScale = originalLighting.EnvironmentSpecularScale end)
        pcall(function() Lighting.FogEnd = originalLighting.FogEnd end)
        if terrain and originalDecoration ~= nil then
            pcall(function() terrain.Decoration = originalDecoration end)
        end
        for effect, state in pairs(originalEffects) do
            if effect and effect.Parent then pcall(function() effect.Enabled = state end) end
        end
    end
end

local function connect(signal, callback)
    local c = signal:Connect(callback)
    connections[#connections + 1] = c
    return c
end

local function getRoot(player)
    local c = player and player.Character
    if not c then return nil end
    return c:FindFirstChild("HumanoidRootPart")
        or c:FindFirstChild("UpperTorso")
        or c:FindFirstChild("Torso")
end

local function getHumanoid(player)
    local c = player and player.Character
    return c and c:FindFirstChildOfClass("Humanoid")
end

local function getHP(player)
    local c = player and player.Character
    if not c then return 0 end

    local hum = c:FindFirstChildOfClass("Humanoid")
    if hum then return hum.Health end

    local hp = c:GetAttribute("Health") or c:GetAttribute("HP")
    if typeof(hp) == "number" then return hp end

    return getRoot(player) and 100 or 0
end

local function alive(player)
    return getHP(player) > 0
end

local function standardTeammate(a, b)
    if not a or not b then return false end

    if a.Team and b.Team then
        return a.Team == b.Team
    end

    if not a.Neutral and not b.Neutral and a.TeamColor and b.TeamColor then
        return a.TeamColor == b.TeamColor
    end

    for _, key in ipairs({"Team", "TeamId", "TeamID", "Side", "Faction"}) do
        local x = a:GetAttribute(key)
        local y = b:GetAttribute(key)
        if x ~= nil and y ~= nil then
            return tostring(x) == tostring(y)
        end
    end

    return false
end

local function hasExplicitTeamData(player)
    if not player then return false end
    if player.Team ~= nil then return true end
    if not player.Neutral and player.TeamColor ~= nil then return true end
    for _, key in ipairs({"Team", "TeamId", "TeamID", "Side", "Faction"}) do
        if player:GetAttribute(key) ~= nil then return true end
    end
    return false
end

local function teammate(player)
    if player == LP then return true end

    -- Prefer the game's actual replicated team data. This prevents enemies
    -- standing near us from being hidden by the spawn-radius fallback.
    if hasExplicitTeamData(LP) and hasExplicitTeamData(player) then
        return standardTeammate(LP, player)
    end

    if standardTeammate(LP, player) then return true end
    return roundTeam[player] == true
end

local function validTarget(player)
    if player == LP then return false end
    if not alive(player) then return false end
    if CFG.TeamCheck and teammate(player) then return false end
    return true
end

local T = {
    Bg = Color3.fromRGB(10, 11, 16),
    Panel = Color3.fromRGB(16, 18, 26),
    Card = Color3.fromRGB(23, 26, 37),
    Card2 = Color3.fromRGB(29, 33, 46),
    Border = Color3.fromRGB(47, 53, 72),
    Text = Color3.fromRGB(239, 242, 250),
    Dim = Color3.fromRGB(142, 150, 170),
    Accent = Color3.fromRGB(98, 114, 255),
    Accent2 = Color3.fromRGB(76, 210, 255),
    Green = Color3.fromRGB(90, 225, 144),
    Red = Color3.fromRGB(255, 83, 105),
    Enemy = Color3.fromRGB(255, 82, 104),
    Team = Color3.fromRGB(76, 210, 255),
    White = Color3.new(1, 1, 1),
}

local function new(className, props)
    local o = Instance.new(className)
    for k, v in pairs(props or {}) do
        if k ~= "Parent" then o[k] = v end
    end
    if props and props.Parent then o.Parent = props.Parent end
    return o
end

local function corner(parent, radius)
    return new("UICorner", {CornerRadius = UDim.new(0, radius or 8), Parent = parent})
end

local function stroke(parent, transparency)
    return new("UIStroke", {
        Color = T.Border,
        Thickness = 1,
        Transparency = transparency or 0.25,
        Parent = parent,
    })
end

-- AIMBOT HELPERS
local aimRayParams = RaycastParams.new()
aimRayParams.FilterType = Enum.RaycastFilterType.Exclude
aimRayParams.IgnoreWater = true

local function getAimPart(player)
    local char = player and player.Character
    if not char then return nil end
    if CFG.AimHead then
        return char:FindFirstChild("Head")
            or char:FindFirstChild("HumanoidRootPart")
            or char:FindFirstChild("UpperTorso")
    end
    return char:FindFirstChild("HumanoidRootPart")
        or char:FindFirstChild("UpperTorso")
        or char:FindFirstChild("Torso")
        or char:FindFirstChild("Head")
end

local function aimVisible(player, part)
    if not CFG.AimVisibleCheck then return true end
    Camera = workspace.CurrentCamera
    if not Camera or not part then return false end

    local ignored = {}
    if LP.Character then ignored[#ignored + 1] = LP.Character end
    aimRayParams.FilterDescendantsInstances = ignored

    local origin = Camera.CFrame.Position
    local direction = part.Position - origin
    local hit = workspace:Raycast(origin, direction, aimRayParams)
    if not hit then return true end

    local char = player.Character
    return char and hit.Instance and hit.Instance:IsDescendantOf(char)
end

local function getBestAimTarget()
    Camera = workspace.CurrentCamera
    if not Camera then return nil end

    local vp = Camera.ViewportSize
    local center = Vector2.new(vp.X * 0.5, vp.Y * 0.5)
    local camPos = Camera.CFrame.Position
    local bestPart = nil
    local bestScreenDistance = CFG.AimFOV

    for _, player in ipairs(Players:GetPlayers()) do
        if validTarget(player) then
            local part = getAimPart(player)
            if part and part:IsA("BasePart") then
                local worldDistance = (part.Position - camPos).Magnitude
                if worldDistance <= CFG.AimMaxDistance then
                    local screenPos, onScreen = Camera:WorldToViewportPoint(part.Position)
                    if onScreen and screenPos.Z > 0 then
                        local screenDistance = (Vector2.new(screenPos.X, screenPos.Y) - center).Magnitude
                        if screenDistance <= bestScreenDistance and aimVisible(player, part) then
                            bestScreenDistance = screenDistance
                            bestPart = part
                        end
                    end
                end
            end
        end
    end

    return bestPart
end

-- GUI ROOT
local gui = new("ScreenGui", {
    Name = "VantaCore_" .. math.random(1000, 9999),
    ResetOnSpawn = false,
    IgnoreGuiInset = true,
    DisplayOrder = 999999,
})

local mounted = false
if gethui then
    local ok, parent = pcall(gethui)
    if ok and parent then
        gui.Parent = parent
        mounted = true
    end
end
if not mounted then
    local ok = pcall(function() gui.Parent = CoreGui end)
    if not ok then gui.Parent = LP:WaitForChild("PlayerGui") end
end

-- Static UI only: no gradients, blur, particles, continuous tweens or GUI render loops.
local window = new("Frame", {
    Name = "Window",
    Size = UDim2.fromOffset(760, 486),
    Position = UDim2.new(0.5, -380, 0.5, -243),
    BackgroundColor3 = T.Panel,
    BorderSizePixel = 0,
    ClipsDescendants = true,
    Parent = gui,
})
corner(window, 14)
stroke(window, 0.08)

local sidebar = new("Frame", {
    Size = UDim2.new(0, 184, 1, 0),
    BackgroundColor3 = T.Bg,
    BorderSizePixel = 0,
    Parent = window,
})

local brandAccent = new("Frame", {
    Position = UDim2.fromOffset(16, 20),
    Size = UDim2.fromOffset(4, 34),
    BackgroundColor3 = T.Accent,
    BorderSizePixel = 0,
    Parent = sidebar,
})
corner(brandAccent, 4)

new("TextLabel", {
    Position = UDim2.fromOffset(30, 18),
    Size = UDim2.new(1, -42, 0, 22),
    BackgroundTransparency = 1,
    Text = "VANTA CORE",
    TextColor3 = T.Text,
    Font = Enum.Font.GothamBlack,
    TextSize = 17,
    TextXAlignment = Enum.TextXAlignment.Left,
    Parent = sidebar,
})
new("TextLabel", {
    Position = UDim2.fromOffset(30, 40),
    Size = UDim2.new(1, -42, 0, 16),
    BackgroundTransparency = 1,
    Text = "V6  •  LOW IMPACT",
    TextColor3 = T.Dim,
    Font = Enum.Font.GothamMedium,
    TextSize = 9,
    TextXAlignment = Enum.TextXAlignment.Left,
    Parent = sidebar,
})

new("TextLabel", {
    Position = UDim2.fromOffset(18, 78),
    Size = UDim2.new(1, -36, 0, 18),
    BackgroundTransparency = 1,
    Text = "MODULES",
    TextColor3 = T.Dim,
    Font = Enum.Font.GothamBold,
    TextSize = 9,
    TextXAlignment = Enum.TextXAlignment.Left,
    Parent = sidebar,
})

local navHost = new("Frame", {
    Position = UDim2.fromOffset(10, 102),
    Size = UDim2.new(1, -20, 0, 250),
    BackgroundTransparency = 1,
    Parent = sidebar,
})
new("UIListLayout", {Padding = UDim.new(0, 6), SortOrder = Enum.SortOrder.LayoutOrder, Parent = navHost})

local sideFoot = new("Frame", {
    Position = UDim2.new(0, 12, 1, -72),
    Size = UDim2.new(1, -24, 0, 54),
    BackgroundColor3 = T.Card,
    BorderSizePixel = 0,
    Parent = sidebar,
})
corner(sideFoot, 10)
new("TextLabel", {
    Position = UDim2.fromOffset(10, 7),
    Size = UDim2.new(1, -20, 0, 16),
    BackgroundTransparency = 1,
    Text = "PERFORMANCE UI",
    TextColor3 = T.Green,
    Font = Enum.Font.GothamBold,
    TextSize = 9,
    TextXAlignment = Enum.TextXAlignment.Left,
    Parent = sideFoot,
})
new("TextLabel", {
    Position = UDim2.fromOffset(10, 24),
    Size = UDim2.new(1, -20, 0, 20),
    BackgroundTransparency = 1,
    Text = "No blur • No particles • No UI loops",
    TextColor3 = T.Dim,
    Font = Enum.Font.Gotham,
    TextSize = 8,
    TextWrapped = true,
    TextXAlignment = Enum.TextXAlignment.Left,
    Parent = sideFoot,
})

local main = new("Frame", {
    Position = UDim2.fromOffset(184, 0),
    Size = UDim2.new(1, -184, 1, 0),
    BackgroundTransparency = 1,
    Parent = window,
})

local header = new("Frame", {
    Size = UDim2.new(1, 0, 0, 72),
    BackgroundTransparency = 1,
    Parent = main,
})
local pageTitle = new("TextLabel", {
    Position = UDim2.fromOffset(22, 16),
    Size = UDim2.new(1, -100, 0, 24),
    BackgroundTransparency = 1,
    Text = "Combat",
    TextColor3 = T.Text,
    Font = Enum.Font.GothamBold,
    TextSize = 20,
    TextXAlignment = Enum.TextXAlignment.Left,
    Parent = header,
})
local pageSubtitle = new("TextLabel", {
    Position = UDim2.fromOffset(22, 41),
    Size = UDim2.new(1, -100, 0, 16),
    BackgroundTransparency = 1,
    Text = "Aim and penetration controls",
    TextColor3 = T.Dim,
    Font = Enum.Font.Gotham,
    TextSize = 10,
    TextXAlignment = Enum.TextXAlignment.Left,
    Parent = header,
})

local closeBtn = new("TextButton", {
    Position = UDim2.new(1, -48, 0, 18),
    Size = UDim2.fromOffset(30, 30),
    BackgroundColor3 = T.Card,
    BorderSizePixel = 0,
    Text = "×",
    TextColor3 = T.Dim,
    Font = Enum.Font.GothamBold,
    TextSize = 18,
    AutoButtonColor = false,
    Parent = header,
})
corner(closeBtn, 8)

local body = new("Frame", {
    Position = UDim2.fromOffset(18, 72),
    Size = UDim2.new(1, -36, 1, -88),
    BackgroundTransparency = 1,
    Parent = main,
})

local pages = {}
local navButtons = {}
local pageMeta = {
    Combat = "Aim and penetration controls",
    Visuals = "Classic V1 wallhack and enemy information",
    Hitbox = "Head hitbox configuration",
    Viewmodel = "First-person hand and weapon position",
    Settings = "Keybinds and performance options",
}

local function makePage(name)
    local page = new("ScrollingFrame", {
        Name = name,
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        ScrollBarThickness = 2,
        ScrollBarImageColor3 = T.Accent,
        AutomaticCanvasSize = Enum.AutomaticSize.Y,
        CanvasSize = UDim2.new(),
        Visible = false,
        Parent = body,
    })
    new("UIListLayout", {Padding = UDim.new(0, 9), SortOrder = Enum.SortOrder.LayoutOrder, Parent = page})
    pages[name] = page
    return page
end

local function switchPage(name)
    for pageName, page in pairs(pages) do page.Visible = pageName == name end
    for btnName, data in pairs(navButtons) do
        local active = btnName == name
        data.Button.BackgroundColor3 = active and T.Card2 or T.Bg
        data.Button.TextColor3 = active and T.Text or T.Dim
        data.Dot.BackgroundTransparency = active and 0 or 1
    end
    pageTitle.Text = name
    pageSubtitle.Text = pageMeta[name] or ""
end

local function navButton(name, glyph)
    local b = new("TextButton", {
        Size = UDim2.new(1, 0, 0, 40),
        BackgroundColor3 = T.Bg,
        BorderSizePixel = 0,
        Text = "   " .. glyph .. "   " .. name,
        TextColor3 = T.Dim,
        Font = Enum.Font.GothamMedium,
        TextSize = 11,
        TextXAlignment = Enum.TextXAlignment.Left,
        AutoButtonColor = false,
        Parent = navHost,
    })
    corner(b, 9)
    local dot = new("Frame", {
        AnchorPoint = Vector2.new(1, 0.5),
        Position = UDim2.new(1, -10, 0.5, 0),
        Size = UDim2.fromOffset(4, 18),
        BackgroundColor3 = T.Accent,
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Parent = b,
    })
    corner(dot, 4)
    navButtons[name] = {Button = b, Dot = dot}
    connect(b.MouseButton1Click, function() switchPage(name) end)
end

local combatPage = makePage("Combat")
local visualsPage = makePage("Visuals")
local hitboxPage = makePage("Hitbox")
local viewmodelPage = makePage("Viewmodel")
local settingsPage = makePage("Settings")

navButton("Combat", "◎")
navButton("Visuals", "◈")
navButton("Hitbox", "◇")
navButton("Viewmodel", "▱")
navButton("Settings", "⚙")

local function section(parent, title, subtitle)
    local card = new("Frame", {
        Size = UDim2.new(1, -4, 0, 52),
        BackgroundColor3 = T.Card2,
        BorderSizePixel = 0,
        Parent = parent,
    })
    corner(card, 11)
    new("Frame", {
        Position = UDim2.fromOffset(0, 9),
        Size = UDim2.fromOffset(3, 34),
        BackgroundColor3 = T.Accent,
        BorderSizePixel = 0,
        Parent = card,
    })
    new("TextLabel", {
        Position = UDim2.fromOffset(14, 7),
        Size = UDim2.new(1, -28, 0, 17),
        BackgroundTransparency = 1,
        Text = title,
        TextColor3 = T.Text,
        Font = Enum.Font.GothamBold,
        TextSize = 11,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = card,
    })
    new("TextLabel", {
        Position = UDim2.fromOffset(14, 26),
        Size = UDim2.new(1, -28, 0, 15),
        BackgroundTransparency = 1,
        Text = subtitle or "",
        TextColor3 = T.Dim,
        Font = Enum.Font.Gotham,
        TextSize = 9,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = card,
    })
end

local function toggle(parent, name, key, callback)
    local holder = new("Frame", {
        Size = UDim2.new(1, -4, 0, 42),
        BackgroundColor3 = T.Card,
        BorderSizePixel = 0,
        Parent = parent,
    })
    corner(holder, 10)
    new("TextLabel", {
        Position = UDim2.fromOffset(13, 0),
        Size = UDim2.new(1, -74, 1, 0),
        BackgroundTransparency = 1,
        Text = name,
        TextColor3 = T.Text,
        Font = Enum.Font.GothamMedium,
        TextSize = 10,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = holder,
    })
    local sw = new("Frame", {
        Position = UDim2.new(1, -49, 0.5, -9),
        Size = UDim2.fromOffset(35, 18),
        BorderSizePixel = 0,
        Parent = holder,
    })
    corner(sw, 10)
    local knob = new("Frame", {Size = UDim2.fromOffset(12, 12), BorderSizePixel = 0, BackgroundColor3 = T.White, Parent = sw})
    corner(knob, 8)
    local function paint()
        local on = CFG[key] == true
        sw.BackgroundColor3 = on and T.Accent or Color3.fromRGB(50, 55, 70)
        knob.Position = on and UDim2.new(1, -15, 0.5, -6) or UDim2.new(0, 3, 0.5, -6)
    end
    local click = new("TextButton", {Size = UDim2.fromScale(1, 1), BackgroundTransparency = 1, Text = "", Parent = holder})
    connect(click.MouseButton1Click, function()
        CFG[key] = not CFG[key]
        paint()
        if callback then callback(CFG[key]) end
    end)
    paint()
    return paint
end

local function slider(parent, name, key, mn, mx, step, callback)
    local holder = new("Frame", {
        Size = UDim2.new(1, -4, 0, 58),
        BackgroundColor3 = T.Card,
        BorderSizePixel = 0,
        Parent = parent,
    })
    corner(holder, 10)
    local label = new("TextLabel", {
        Position = UDim2.fromOffset(13, 5),
        Size = UDim2.new(1, -26, 0, 20),
        BackgroundTransparency = 1,
        TextColor3 = T.Text,
        Font = Enum.Font.Gotham,
        TextSize = 10,
        TextXAlignment = Enum.TextXAlignment.Left,
        Parent = holder,
    })
    local bar = new("Frame", {
        Position = UDim2.new(0, 13, 1, -16),
        Size = UDim2.new(1, -26, 0, 4),
        BackgroundColor3 = Color3.fromRGB(48, 53, 68),
        BorderSizePixel = 0,
        Parent = holder,
    })
    corner(bar, 4)
    local fill = new("Frame", {BackgroundColor3 = T.Accent, BorderSizePixel = 0, Parent = bar})
    corner(fill, 4)
    local dragging = false
    local function set(value)
        value = math.clamp(value, mn, mx)
        value = math.floor(value / step + 0.5) * step
        value = tonumber(string.format("%.3f", value))
        CFG[key] = value
        fill.Size = UDim2.fromScale((value - mn) / (mx - mn), 1)
        label.Text = step < 1 and (name .. ": " .. string.format("%.2f", value)) or (name .. ": " .. tostring(math.floor(value)))
        if callback then callback(value) end
    end
    local function update(x)
        if bar.AbsoluteSize.X <= 0 then return end
        local ratio = math.clamp((x - bar.AbsolutePosition.X) / bar.AbsoluteSize.X, 0, 1)
        set(mn + (mx - mn) * ratio)
    end
    connect(bar.InputBegan, function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 then dragging = true update(i.Position.X) end
    end)
    connect(UIS.InputChanged, function(i)
        if dragging and i.UserInputType == Enum.UserInputType.MouseMovement then update(i.Position.X) end
    end)
    connect(UIS.InputEnded, function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 then dragging = false end
    end)
    set(CFG[key])
end

local bindingKey = nil
local bindingButton = nil
local function keybind(parent, labelText, key)
    local holder = new("Frame", {Size = UDim2.new(1, -4, 0, 42), BackgroundColor3 = T.Card, BorderSizePixel = 0, Parent = parent})
    corner(holder, 10)
    new("TextLabel", {
        Position = UDim2.fromOffset(13, 0), Size = UDim2.new(1, -126, 1, 0), BackgroundTransparency = 1,
        Text = labelText, TextColor3 = T.Text, Font = Enum.Font.GothamMedium, TextSize = 10,
        TextXAlignment = Enum.TextXAlignment.Left, Parent = holder,
    })
    local b = new("TextButton", {
        Position = UDim2.new(1, -106, 0.5, -13), Size = UDim2.fromOffset(92, 26), BackgroundColor3 = T.Card2,
        BorderSizePixel = 0, Text = CFG[key].Name, TextColor3 = T.Accent2, Font = Enum.Font.GothamBold,
        TextSize = 9, AutoButtonColor = false, Parent = holder,
    })
    corner(b, 7)
    connect(b.MouseButton1Click, function() bindingKey = key bindingButton = b b.Text = "PRESS KEY" end)
end

-- PAGE CONTENT
section(combatPage, "AIMBOT", "Camera-based aim assist with team and visibility filtering.")
toggle(combatPage, "Aimbot Enabled", "Aimbot")
toggle(combatPage, "Hold RMB to Aim", "AimHoldRMB")
toggle(combatPage, "Aim at Head", "AimHead")
toggle(combatPage, "Visible Check", "AimVisibleCheck")
slider(combatPage, "Aim FOV", "AimFOV", 20, 500, 5)
slider(combatPage, "Aim Smooth", "AimSmooth", 1, 35, 1)
slider(combatPage, "Aim Max Distance", "AimMaxDistance", 100, 5000, 100)

section(combatPage, "WALLBANG", "Client penetration helper.")
toggle(combatPage, "Wallbang Enabled", "Wallbang")
slider(combatPage, "Penetration Depth", "PenetrationDepth", 1, 8, 1)

section(visualsPage, "CLASSIC WALLHACK", "Always-on-top V1 enemy highlight with throttled updates.")
toggle(visualsPage, "Wallhack / ESP", "ESP")
toggle(visualsPage, "Through-Wall Highlight", "Highlight")
toggle(visualsPage, "Enemy Fill", "HighlightFill")
toggle(visualsPage, "Head Box", "BoxESP")
toggle(visualsPage, "Player Name", "Name")
toggle(visualsPage, "Health", "Health")
toggle(visualsPage, "Distance", "Distance")
slider(visualsPage, "ESP Max Distance", "MaxDistance", 100, 5000, 100)
slider(visualsPage, "ESP Update", "ESPUpdateRate", 0.08, 0.40, 0.01)
toggle(visualsPage, "Team Check", "TeamCheck")
slider(visualsPage, "Spawn Team Radius", "TeamRadius", 5, 60, 1)

section(hitboxPage, "HEAD HITBOX", "Optional local head expansion with automatic restore.")
toggle(hitboxPage, "Head Expansion", "HeadExpand")
slider(hitboxPage, "Head Size", "HeadSize", 1, 30, 0.5)
slider(hitboxPage, "Head Transparency", "HeadTransparency", 0, 1, 0.05)

section(viewmodelPage, "HANDS / VIEWMODEL", "Move your first-person hands and weapon model.")
toggle(viewmodelPage, "Custom Viewmodel", "ViewmodelEnabled")
slider(viewmodelPage, "Viewmodel FOV", "ViewmodelFOV", 45, 120, 1)
slider(viewmodelPage, "Side (X)", "ViewmodelX", -3, 3, 0.05)
slider(viewmodelPage, "Up / Down (Y)", "ViewmodelY", -3, 3, 0.05)
slider(viewmodelPage, "Forward / Back (Z)", "ViewmodelZ", -4, 4, 0.05)

section(settingsPage, "KEYBINDS", "Click a bind, then press the new key.")
keybind(settingsPage, "Menu", "MenuKey")
keybind(settingsPage, "Aimbot", "AimbotKey")
keybind(settingsPage, "Wallhack / ESP", "ESPKey")
keybind(settingsPage, "Wallbang", "WallbangKey")
keybind(settingsPage, "Potato Mode", "PotatoKey")
keybind(settingsPage, "Unload", "UnloadKey")

section(settingsPage, "PERFORMANCE", "Static GUI and lightweight graphics controls.")
toggle(settingsPage, "Potato Mode", "PotatoMode", function(v)
    applyPotatoMode(v)
    task.defer(refreshAllESP)
end)
new("TextLabel", {
    Size = UDim2.new(1, -4, 0, 72), BackgroundColor3 = T.Card, BorderSizePixel = 0,
    Text = "Potato Mode disables shadows and post-processing.\nThe GUI itself has no animated effects or permanent UI update loops.",
    TextWrapped = true, TextColor3 = T.Dim, Font = Enum.Font.Gotham, TextSize = 9, Parent = settingsPage,
})

switchPage("Combat")

-- DRAG
local draggingWindow = false
local dragStart = nil
local startPos = nil

connect(header.InputBegan, function(i)
    if i.UserInputType == Enum.UserInputType.MouseButton1 then
        draggingWindow = true
        dragStart = i.Position
        startPos = window.Position
    end
end)

connect(UIS.InputChanged, function(i)
    if draggingWindow and i.UserInputType == Enum.UserInputType.MouseMovement then
        local d = i.Position - dragStart
        window.Position = UDim2.new(
            startPos.X.Scale,
            startPos.X.Offset + d.X,
            startPos.Y.Scale,
            startPos.Y.Offset + d.Y
        )
    end
end)

connect(UIS.InputEnded, function(i)
    if i.UserInputType == Enum.UserInputType.MouseButton1 then
        draggingWindow = false
    end
end)

-- HEAD RESTORE
local function restoreOneHead(head)
    local o = originalHeads[head]
    if not o then return end
    originalHeads[head] = nil
    if not head.Parent then return end

    pcall(function()
        head.Size = o.Size
        head.Transparency = o.Transparency
        head.CanCollide = o.CanCollide
        head.Massless = o.Massless
    end)
end

local function restoreHeads()
    local list = {}
    for head in pairs(originalHeads) do list[#list + 1] = head end
    for _, head in ipairs(list) do restoreOneHead(head) end
end

local function updateHeads()
    local wanted = Vector3.new(CFG.HeadSize, CFG.HeadSize, CFG.HeadSize)
    local valid = {}

    for _, p in ipairs(Players:GetPlayers()) do
        if validTarget(p) then
            local char = p.Character
            local head = char and char:FindFirstChild("Head")
            if head and head:IsA("BasePart") then
                valid[head] = true

                if not originalHeads[head] then
                    originalHeads[head] = {
                        Size = head.Size,
                        Transparency = head.Transparency,
                        CanCollide = head.CanCollide,
                        Massless = head.Massless,
                    }
                end

                pcall(function()
                    head.Size = wanted
                    head.Transparency = CFG.HeadTransparency
                    head.CanCollide = false
                    head.Massless = true
                end)
            end
        end
    end

    local restore = {}
    for head in pairs(originalHeads) do
        if not valid[head] then restore[#restore + 1] = head end
    end
    for _, head in ipairs(restore) do restoreOneHead(head) end
end

-- CLASSIC THROUGH-WALL ESP (V1 STYLE)
-- Recreates missing ESP automatically, just like the first NOVA version.
local function hideESP(d)
    if not d then return end
    if d.Highlight then d.Highlight.Enabled = false end
    if d.HeadBox then d.HeadBox.Visible = false end
    if d.Gui then d.Gui.Enabled = false end
end

local function removeESP(player)
    local d = ESP[player]
    if not d then return end
    pcall(function() if d.Highlight then d.Highlight:Destroy() end end)
    pcall(function() if d.HeadBox then d.HeadBox:Destroy() end end)
    pcall(function() if d.Gui then d.Gui:Destroy() end end)
    ESP[player] = nil
end

local function createESP(player)
    removeESP(player)
    if player == LP then return end

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

    local head = char:FindFirstChild("Head")
    if not head then return end

    local highlight = new("Highlight", {
        Adornee = char,
        DepthMode = Enum.HighlightDepthMode.AlwaysOnTop,
        FillColor = T.Enemy,
        OutlineColor = T.Enemy,
        FillTransparency = 0.75,
        OutlineTransparency = 0,
        Enabled = false,
        Parent = char,
    })

    local box = new("BoxHandleAdornment", {
        Adornee = head,
        AlwaysOnTop = true,
        ZIndex = 10,
        Size = head.Size,
        Color3 = Color3.fromRGB(255, 215, 60),
        Transparency = 0.55,
        Visible = false,
        Parent = head,
    })

    local bill = new("BillboardGui", {
        Adornee = head,
        Size = UDim2.fromOffset(260, 40),
        StudsOffset = Vector3.new(0, 2.7, 0),
        AlwaysOnTop = true,
        Enabled = false,
        Parent = head,
    })

    local text = new("TextLabel", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        TextColor3 = T.Enemy,
        TextStrokeTransparency = 0,
        Font = Enum.Font.GothamBold,
        TextSize = 13,
        Parent = bill,
    })

    ESP[player] = {
        Head = head,
        Highlight = highlight,
        HeadBox = box,
        Gui = bill,
        Text = text,
    }
end

refreshAllESP = function()
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LP and p.Character then
            createESP(p)
        end
    end
end

local function hookPlayer(player)
    if player == LP then return end

    connect(player.CharacterAdded, function(char)
        -- First attempt quickly, then retry after the character finishes loading.
        task.delay(0.15, function()
            if running and player.Character == char then createESP(player) end
        end)
        task.delay(0.75, function()
            if running and player.Character == char and not ESP[player] then createESP(player) end
        end)
    end)

    connect(player.CharacterRemoving, function()
        removeESP(player)
        roundTeam[player] = nil
    end)

    if player.Character then createESP(player) end
end

for _, p in ipairs(Players:GetPlayers()) do hookPlayer(p) end
connect(Players.PlayerAdded, hookPlayer)
connect(Players.PlayerRemoving, function(p)
    removeESP(p)
    roundTeam[p] = nil
end)

-- ROUND TEAM
local function clearRoundTeam()
    table.clear(roundTeam)
end

local function rebuildRoundTeam()
    clearRoundTeam()

    local myRoot = getRoot(LP)
    if not myRoot or not alive(LP) then return end

    local count = 0
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LP and alive(p) then
            local root = getRoot(p)
            if root then
                local distance = (root.Position - myRoot.Position).Magnitude
                if distance <= CFG.TeamRadius then
                    roundTeam[p] = true
                    count += 1
                end
            end
        end
    end

    roundNumber += 1
    print("[VANTA] round #" .. roundNumber .. " team=" .. count)
end

local roundAcc = 0
connect(RunService.Heartbeat, function(dt)
    roundAcc += dt
    if roundAcc < 0.5 then return end
    roundAcc = 0

    local count = 0
    for _, p in ipairs(Players:GetPlayers()) do
        if alive(p) then count += 1 end
    end

    local meAlive = alive(LP)
    if roundActive then
        if not meAlive or count <= 1 then
            roundActive = false
            roundEndedAt = os.clock()
            clearRoundTeam()
        end
    else
        if meAlive and count >= 2 and os.clock() - roundEndedAt >= 1 then
            roundActive = true
            task.delay(0.8, function()
                if running and roundActive and alive(LP) then rebuildRoundTeam() end
            end)
        end
    end
end)

-- WALLBANG
local wallRestore = {}
local wallBusy = false
local wallParams = RaycastParams.new()
wallParams.FilterType = Enum.RaycastFilterType.Exclude
wallParams.IgnoreWater = true

local function characterPart(part)
    if not part then return false end
    local model = part:FindFirstAncestorOfClass("Model")
    if not model then return false end
    if Players:GetPlayerFromCharacter(model) then return true end
    return model:FindFirstChildOfClass("Humanoid") ~= nil
end

local function rememberWall(part)
    if wallRestore[part] then return end
    wallRestore[part] = {
        CanQuery = part.CanQuery,
        LocalTransparencyModifier = part.LocalTransparencyModifier,
    }
end

local function restoreWalls()
    local list = {}
    for part in pairs(wallRestore) do list[#list + 1] = part end

    for _, part in ipairs(list) do
        local old = wallRestore[part]
        wallRestore[part] = nil
        if part and part.Parent then
            pcall(function()
                part.CanQuery = old.CanQuery
                part.LocalTransparencyModifier = old.LocalTransparencyModifier
            end)
        end
    end
end

local function prepareWallbang()
    if wallBusy or not CFG.Wallbang then return end

    Camera = workspace.CurrentCamera
    if not Camera then return end

    wallBusy = true
    local vp = Camera.ViewportSize
    local ray = Camera:ViewportPointToRay(vp.X * 0.5, vp.Y * 0.5)
    local ignored = {}
    if LP.Character then ignored[1] = LP.Character end

    local origin = ray.Origin
    local direction = ray.Direction * 5000

    for _ = 1, CFG.PenetrationDepth do
        wallParams.FilterDescendantsInstances = ignored
        local hit = workspace:Raycast(origin, direction, wallParams)
        if not hit or not hit.Instance then break end

        local part = hit.Instance
        if characterPart(part) then break end

        if part:IsA("BasePart") then
            rememberWall(part)
            pcall(function()
                part.CanQuery = false
                part.LocalTransparencyModifier = math.max(part.LocalTransparencyModifier, 0.60)
            end)
        end
        ignored[#ignored + 1] = part
    end

    -- Keep ignored geometry disabled long enough for the weapon's client raycast
    -- to run in the same input frame, then restore everything immediately.
    task.delay(0.15, function()
        restoreWalls()
        wallBusy = false
    end)
end

-- CLASSIC V1 ESP + HITBOX UPDATE
-- Potato Mode intentionally does NOT change this loop or ESP visibility.
local updateAcc = 0
connect(RunService.Heartbeat, function(dt)
    if not running then return end

    updateAcc += dt
    if updateAcc < CFG.ESPUpdateRate then return end
    updateAcc = 0

    Camera = workspace.CurrentCamera
    if not Camera then return end

    if CFG.HeadExpand then
        updateHeads()
    elseif next(originalHeads) then
        restoreHeads()
    end

    local camPos = Camera.CFrame.Position

    -- Iterate actual Players, not only the ESP cache. This is the key V1 behavior:
    -- if a character/head appears late after joining or respawning, ESP is rebuilt.
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LP then
            local char = p.Character
            local head = char and char:FindFirstChild("Head")
            local root = getRoot(p)

            if head and root then
                local d = ESP[p]

                if not d or d.Head ~= head then
                    createESP(p)
                    d = ESP[p]
                end

                if d then
                    local distance = (root.Position - camPos).Magnitude
                    local show = CFG.ESP and validTarget(p) and distance <= CFG.MaxDistance

                    if show then
                        d.Highlight.FillTransparency = CFG.HighlightFill and 0.75 or 1
                        d.Highlight.OutlineTransparency = 0
                        d.Highlight.Enabled = CFG.Highlight

                        d.HeadBox.Visible = CFG.BoxESP
                        d.HeadBox.Size = head.Size

                        local pieces = {}
                        if CFG.Name then pieces[#pieces + 1] = p.DisplayName end
                        if CFG.Health then pieces[#pieces + 1] = math.floor(getHP(p)) .. " HP" end
                        if CFG.Distance then pieces[#pieces + 1] = math.floor(distance) .. "m" end

                        d.Gui.Enabled = #pieces > 0
                        d.Text.Text = table.concat(pieces, " | ")
                    else
                        hideESP(d)
                    end
                end
            elseif ESP[p] then
                hideESP(ESP[p])
            end
        end
    end
end)

-- AIMBOT UPDATE
connect(RunService.RenderStepped, function(dt)
    if not running or not CFG.Aimbot then return end
    if CFG.AimHoldRMB and not aimHeld then return end

    Camera = workspace.CurrentCamera
    if not Camera then return end

    local target = getBestAimTarget()
    if not target then return end

    local origin = Camera.CFrame.Position
    local desired = CFrame.lookAt(origin, target.Position)
    local alpha = math.clamp(dt * CFG.AimSmooth, 0, 1)
    Camera.CFrame = Camera.CFrame:Lerp(desired, alpha)
end)

-- VIEWMODEL / HANDS (ROBUST CAMERA-DESCENDANT DETECTION)
local detectedViewmodel = nil
local detectedBaseRel = nil
local detectedOriginalScale = nil
local lastViewmodelScan = 0
local lastAppliedViewmodelFOV = nil
local viewmodelBindName = "VantaViewmodel_" .. tostring(math.random(100000,999999))
local viewmodelWasEnabled = false

local function modelPartCount(model)
    local n = 0
    for _, obj in ipairs(model:GetDescendants()) do
        if obj:IsA("BasePart") then n += 1 end
    end
    return n
end

local function scoreViewmodel(model)
    local name = string.lower(model.Name)
    local score = modelPartCount(model)
    if string.find(name, "viewmodel") or string.find(name, "view_model") then score += 1000 end
    if string.find(name, "arms") or string.find(name, "arm") then score += 500 end
    if string.find(name, "weapon") or string.find(name, "gun") then score += 300 end
    if string.find(name, "vm") then score += 150 end
    return score
end

local function restoreDetectedViewmodel()
    if detectedViewmodel and detectedViewmodel.Parent and detectedOriginalScale then
        pcall(function() detectedViewmodel:ScaleTo(detectedOriginalScale) end)
    end
    detectedViewmodel = nil
    detectedBaseRel = nil
    detectedOriginalScale = nil
    lastAppliedViewmodelFOV = nil
end

local function findViewmodel(force)
    Camera = workspace.CurrentCamera
    if not Camera then return nil end

    if not force and detectedViewmodel and detectedViewmodel.Parent and detectedViewmodel:IsDescendantOf(Camera) then
        return detectedViewmodel
    end

    local now = os.clock()
    if not force and now - lastViewmodelScan < 0.40 then return nil end
    lastViewmodelScan = now

    local best, bestScore = nil, -1
    for _, obj in ipairs(Camera:GetDescendants()) do
        if obj:IsA("Model") and (not LP.Character or not obj:IsDescendantOf(LP.Character)) then
            local count = modelPartCount(obj)
            if count > 0 then
                local score = scoreViewmodel(obj)
                if score > bestScore then
                    best, bestScore = obj, score
                end
            end
        end
    end

    if best then
        restoreDetectedViewmodel()
        detectedViewmodel = best
        local okPivot, pivot = pcall(function() return best:GetPivot() end)
        if okPivot and pivot then detectedBaseRel = Camera.CFrame:ToObjectSpace(pivot) end
        local okScale, scale = pcall(function() return best:GetScale() end)
        detectedOriginalScale = okScale and scale or 1
    end

    return detectedViewmodel
end

local function applyViewmodelScale(vm)
    if not vm or not detectedOriginalScale then return end
    if lastAppliedViewmodelFOV == CFG.ViewmodelFOV then return end

    -- Practical viewmodel-FOV approximation: higher FOV => slightly smaller hands/weapon.
    local ratio = math.clamp(75 / math.max(CFG.ViewmodelFOV, 1), 0.60, 1.55)
    pcall(function() vm:ScaleTo(detectedOriginalScale * ratio) end)
    lastAppliedViewmodelFOV = CFG.ViewmodelFOV
end

local function updateViewmodel()
    if not CFG.ViewmodelEnabled then return end
    Camera = workspace.CurrentCamera
    if not Camera then return end

    local vm = findViewmodel(false) or findViewmodel(true)
    if not vm then return end

    if not detectedBaseRel then
        local ok, pivot = pcall(function() return vm:GetPivot() end)
        if not ok or not pivot then return end
        detectedBaseRel = Camera.CFrame:ToObjectSpace(pivot)
    end

    applyViewmodelScale(vm)

    local offset = CFrame.new(CFG.ViewmodelX, CFG.ViewmodelY, CFG.ViewmodelZ)
    pcall(function()
        vm:PivotTo(Camera.CFrame * detectedBaseRel * offset)
    end)
end

-- Run after the normal camera pass so weapon scripts are less likely to overwrite our position.
pcall(function()
    RunService:BindToRenderStep(viewmodelBindName, Enum.RenderPriority.Camera.Value + 20, function()
        if not running then return end
        if CFG.ViewmodelEnabled then
            viewmodelWasEnabled = true
            updateViewmodel()
        elseif viewmodelWasEnabled then
            viewmodelWasEnabled = false
            restoreDetectedViewmodel()
        end
    end)
end)

-- INPUT + KEYBIND EDITOR
connect(UIS.InputBegan, function(input, processed)
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        aimHeld = true
    end

    if bindingKey and input.KeyCode ~= Enum.KeyCode.Unknown then
        CFG[bindingKey] = input.KeyCode
        if bindingButton then bindingButton.Text = input.KeyCode.Name end
        bindingKey = nil
        bindingButton = nil
        return
    end

    if input.UserInputType == Enum.UserInputType.MouseButton1 and CFG.Wallbang then
        prepareWallbang()
    end

    if processed then return end
    if input.KeyCode == Enum.KeyCode.Unknown then return end

    if input.KeyCode == CFG.MenuKey then
        window.Visible = not window.Visible
    elseif input.KeyCode == CFG.AimbotKey then
        CFG.Aimbot = not CFG.Aimbot
    elseif input.KeyCode == CFG.ESPKey then
        CFG.ESP = not CFG.ESP
        if not CFG.ESP then
            for _, d in pairs(ESP) do hideESP(d) end
        end
    elseif input.KeyCode == CFG.WallbangKey then
        CFG.Wallbang = not CFG.Wallbang
        if not CFG.Wallbang then restoreWalls() end
    elseif input.KeyCode == CFG.PotatoKey then
        applyPotatoMode(not CFG.PotatoMode)
        task.defer(refreshAllESP)
    elseif input.KeyCode == CFG.UnloadKey then
        if ENV.VantaCore and ENV.VantaCore.Unload then
            task.defer(ENV.VantaCore.Unload)
        end
    end
end)


connect(UIS.InputEnded, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        aimHeld = false
    end
end)

-- UNLOAD
local unloading = false
local function unload()
    if unloading then return end
    unloading = true
    running = false

    pcall(function() RunService:UnbindFromRenderStep(viewmodelBindName) end)
    restoreDetectedViewmodel()
    restoreHeads()
    restoreWalls()
    applyPotatoMode(false)
    clearRoundTeam()

    for _, c in ipairs(connections) do
        pcall(function() c:Disconnect() end)
    end

    for p in pairs(ESP) do removeESP(p) end
    pcall(function() gui:Destroy() end)

    ENV.VantaCore = nil
    print("[VANTA] unloaded")
end

connect(closeBtn.MouseButton1Click, unload)

ENV.VantaCore = {
    Config = CFG,
    Unload = unload,
    RebuildTeam = rebuildRoundTeam,
    IsTeammate = teammate,
    IsTarget = validTarget,
}

print("[VANTA] V6 loaded | aimbot | classic wallhack | wallbang | ultra-light modern GUI")