-- ============================================================
--  VOID UNIVERSAL — Venyx UI Library
--  Original by B0Xaz | Converted to Venyx
-- ============================================================

-- Cleanup previous instance
if getgenv().VoidLibrary then
    pcall(function() getgenv().VoidLibrary:Destroy() end)
    getgenv().VoidLibrary = nil
end

if getgenv().VoidConnections then
    for _, conn in ipairs(getgenv().VoidConnections) do
        if conn and conn.Connected then conn:Disconnect() end
    end
end
getgenv().VoidConnections = {}

if getgenv().VoidDrawingESP then
    for _, espData in pairs(getgenv().VoidDrawingESP) do
        for _, drawing in pairs(espData) do pcall(function() drawing:Remove() end) end
    end
end
getgenv().VoidDrawingESP = {}

if getgenv().VoidTracerLines then
    for _, line in ipairs(getgenv().VoidTracerLines) do pcall(function() line:Remove() end) end
end
getgenv().VoidTracerLines = {}

if getgenv().VoidSkeletonLines then
    for _, lines in pairs(getgenv().VoidSkeletonLines) do
        for _, line in ipairs(lines) do pcall(function() line:Remove() end) end
    end
end
getgenv().VoidSkeletonLines = {}

if getgenv().VoidHighlights then
    for _, h in pairs(getgenv().VoidHighlights) do pcall(function() h:Destroy() end) end
end
getgenv().VoidHighlights = {}

if getgenv().VoidFOVCircle then
    pcall(function() getgenv().VoidFOVCircle:Remove() end)
    getgenv().VoidFOVCircle = nil
end

if getgenv().VoidMobileGUI then
    pcall(function() getgenv().VoidMobileGUI:Destroy() end)
    getgenv().VoidMobileGUI = nil
end

getgenv().VoidAimState = { PlayerTarget = nil, HoldActive = false }

local function TrackConnection(conn)
    table.insert(getgenv().VoidConnections, conn)
    return conn
end

-- ── Services & Locals ─────────────────────────────────────────

local Lighting         = game:GetService("Lighting")
local camera           = workspace.CurrentCamera
local RunService       = game:GetService("RunService")
local Players          = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local WS               = game:GetService("Workspace")
local LocalPlayer      = Players.LocalPlayer
local Mouse            = LocalPlayer:GetMouse()
local IsMobile         = UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled

-- Save default lighting once
if not getgenv().VoidDefaultLighting then
    getgenv().VoidDefaultLighting = {
        FogEnd                   = Lighting.FogEnd,
        FogStart                 = Lighting.FogStart,
        FogColor                 = Lighting.FogColor,
        GlobalShadows            = Lighting.GlobalShadows,
        Ambient                  = Lighting.Ambient,
        Brightness               = Lighting.Brightness,
        ColorShift_Bottom        = Lighting.ColorShift_Bottom,
        ColorShift_Top           = Lighting.ColorShift_Top,
        EnvironmentDiffuseScale  = Lighting.EnvironmentDiffuseScale,
        EnvironmentSpecularScale = Lighting.EnvironmentSpecularScale,
        OutdoorAmbient           = Lighting.OutdoorAmbient,
        ShadowSoftness           = Lighting.ShadowSoftness,
        ClockTime                = Lighting.ClockTime,
        GeographicLatitude       = Lighting.GeographicLatitude,
        ExposureCompensation     = Lighting.ExposureCompensation,
    }
end
local DefaultLighting = getgenv().VoidDefaultLighting

-- ── Helper Functions ──────────────────────────────────────────

local function GetCharacter() return LocalPlayer.Character end
local function GetHumanoid()  local c = GetCharacter() return c and c:FindFirstChildOfClass("Humanoid") end
local function GetRootPart()  local c = GetCharacter() return c and c:FindFirstChild("HumanoidRootPart") end

local function IsAlive(p)
    local c = p.Character
    return c and c:FindFirstChild("HumanoidRootPart") and c:FindFirstChild("Humanoid") and c.Humanoid.Health > 0
end

local function SameTeam(p)
    return LocalPlayer.Team and p.Team and LocalPlayer.Team == p.Team
end

local function IsVisible(part)
    if not part then return true end
    local origin    = camera.CFrame.Position
    local direction = part.Position - origin
    local params    = RaycastParams.new()
    params.FilterDescendantsInstances = { LocalPlayer.Character, camera }
    params.FilterType  = Enum.RaycastFilterType.Exclude
    params.IgnoreWater = true
    local result = WS:Raycast(origin, direction, params)
    return not result or result.Instance:IsDescendantOf(part.Parent)
end

local function GetPlayerByName(name)
    for _, p in ipairs(Players:GetPlayers()) do if p.Name == name then return p end end
    return nil
end

local function GetPlayerList()
    local list = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LocalPlayer then table.insert(list, p.Name) end
    end
    return list
end

local function ApplyStats()
    local hum = GetHumanoid()
    if hum then
        hum.WalkSpeed = getgenv().VoidSpeedValue
        hum.JumpPower = getgenv().VoidJumpValue
    end
end

-- ── Defaults ──────────────────────────────────────────────────

getgenv().Aimbot = getgenv().Aimbot or {
    Status         = true,
    Keybind        = 'C',
    Hitpart        = 'HumanoidRootPart',
    Smoothness     = 1,
    LockMode       = "Toggle",
    Prediction     = { Horizontal = 0.165, Vertical = 0.100 },
    TeamCheck      = false,
    VisCheck       = false,
    MaxDistance    = 200,
    ShakeIntensity = 0,
    AirHitpart     = "Head",
    FOVSize        = 100,
    ShowFOV        = false,
    FOVFilled      = false,
    FOVThickness   = 2,
    FOVSides       = 64,
    RainbowFOV     = false,
    PulseFOV       = false,
    LockNPC        = false,
}

getgenv().VoidFOV          = getgenv().VoidFOV        or 90
getgenv().VoidNoclip       = getgenv().VoidNoclip      or false
getgenv().VoidESPEnabled   = getgenv().VoidESPEnabled  or false
getgenv().VoidFullbright   = getgenv().VoidFullbright  or false
getgenv().VoidInfJump      = getgenv().VoidInfJump     or false
getgenv().VoidSpeedValue   = getgenv().VoidSpeedValue  or 16
getgenv().VoidJumpValue    = getgenv().VoidJumpValue   or 50
getgenv().VoidBHop         = false
getgenv().VoidSafeWalk     = false

getgenv().VoidESPBoxEnabled    = false
getgenv().VoidESPNameEnabled   = false
getgenv().VoidESPHealthEnabled = false
getgenv().VoidESPDistEnabled   = false
getgenv().VoidESPTracers       = false
getgenv().VoidESPSkeleton      = false
getgenv().VoidESPHeadDot       = false
getgenv().VoidESPLookDir       = false
getgenv().VoidESPTeamCheck     = false
getgenv().VoidESPMaxDist       = 500
getgenv().VoidESPColor         = Color3.fromRGB(0, 200, 255)
getgenv().VoidChamsEnabled     = false
getgenv().VoidChamsColor       = Color3.fromRGB(0, 170, 255)
getgenv().VoidChamsOutline     = Color3.fromRGB(255, 255, 255)
getgenv().VoidFlying           = getgenv().VoidFlying   or false
getgenv().VoidFlySpeed         = getgenv().VoidFlySpeed or 50

-- ── Load Venyx Library ────────────────────────────────────────

local library = loadstring(game:HttpGet("https://raw.githubusercontent.com/GreenDeno/Venyx-UI-Library/main/source.lua"))()
local venyx   = library.new("Void Universal", 5013109572)
getgenv().VoidLibrary = venyx

-- ============================================================
--  PAGES & SECTIONS
-- ============================================================

-- AIM PAGE
local aimPage       = venyx:addPage("Aim", 5012544693)
local aimGenSec     = aimPage:addSection("General")
local aimLockSec    = aimPage:addSection("Lock & Checks")
local aimFOVSec     = aimPage:addSection("FOV Circle")
local aimPredSec    = aimPage:addSection("Prediction")
local aimSmoothSec  = aimPage:addSection("Smoothness")

-- MOVEMENT PAGE
local movePage      = venyx:addPage("Movement", 5012544693)
local moveSpeedSec  = movePage:addSection("Speed & Jump")
local moveMiscSec   = movePage:addSection("Misc")
local moveFlySec    = movePage:addSection("Fly")
local moveGravSec   = movePage:addSection("Gravity & Hip")
local moveTpSec     = movePage:addSection("Teleport")

-- TARGET PAGE
local targetPage    = venyx:addPage("Target", 5012544693)
local targetSelSec  = targetPage:addSection("Select Target")
local targetActSec  = targetPage:addSection("Actions")
local targetFling   = targetPage:addSection("Fling")
local targetOrbit   = targetPage:addSection("Orbit & Annoy")
local targetFreeze  = targetPage:addSection("Freeze")
local targetInfo    = targetPage:addSection("Info")

-- VISUALS PAGE
local visualsPage   = venyx:addPage("Visuals", 5012544693)
local espSec        = visualsPage:addSection("ESP")
local espSetSec     = visualsPage:addSection("ESP Settings")
local chamsSec      = visualsPage:addSection("Chams")
local camSec        = visualsPage:addSection("Camera")

-- GRAPHICS PAGE
local graphicsPage  = venyx:addPage("Graphics", 5012544693)
local lightSec      = graphicsPage:addSection("Lighting")
local postFxSec     = graphicsPage:addSection("Post FX")
local perfSec       = graphicsPage:addSection("Performance")

-- EXTRAS PAGE
local extrasPage    = venyx:addPage("Extras", 5012544693)
local hitboxSec     = extrasPage:addSection("Hitbox Expander")
local killAuraSec   = extrasPage:addSection("Kill Aura")
local spinSec       = extrasPage:addSection("Spin Bot")
local silentSec     = extrasPage:addSection("Silent Aim")
local crosshairSec  = extrasPage:addSection("Crosshair")
local miscSec       = extrasPage:addSection("Misc")
local audioSec      = extrasPage:addSection("Audio")
local chatSec       = extrasPage:addSection("Chat Spam")
local statsSec      = extrasPage:addSection("My Stats")

-- ============================================================
--  AIM PAGE
-- ============================================================

aimGenSec:addToggle("Aimbot Enabled", getgenv().Aimbot.Status, function(v)
    getgenv().Aimbot.Status = v
    if not v then
        getgenv().VoidAimState.PlayerTarget = nil
        getgenv().VoidAimState.HoldActive   = false
    end
end)

aimGenSec:addTextbox("Aimbot Keybind (PC)", getgenv().Aimbot.Keybind, function(text, focusLost)
    if focusLost and text and #text > 0 then
        getgenv().Aimbot.Keybind = text:sub(1,1):upper()
        venyx:Notify("Keybind", "Set to: " .. getgenv().Aimbot.Keybind)
    end
end)

aimGenSec:addDropdown("Hit Part", {"HumanoidRootPart","Head","UpperTorso","LowerTorso"}, function(v)
    getgenv().Aimbot.Hitpart = v
end)

aimGenSec:addDropdown("Air Hit Part", {"Head","HumanoidRootPart","UpperTorso","LowerTorso"}, function(v)
    getgenv().Aimbot.AirHitpart = v
end)

-- Lock Mode
aimLockSec:addDropdown("Lock Mode", {"Toggle","Hold"}, function(v)
    getgenv().Aimbot.LockMode           = v
    getgenv().VoidAimState.HoldActive   = false
    getgenv().VoidAimState.PlayerTarget = nil
end)

aimLockSec:addToggle("Team Check", false, function(v) getgenv().Aimbot.TeamCheck = v end)
aimLockSec:addToggle("Visibility Check", false, function(v) getgenv().Aimbot.VisCheck = v end)
aimLockSec:addToggle("Lock NPCs / Mobs", false, function(v) getgenv().Aimbot.LockNPC = v end)

aimLockSec:addSlider("Max Lock Distance", getgenv().Aimbot.MaxDistance, 50, 500, function(v)
    getgenv().Aimbot.MaxDistance = v
end)

-- FOV Circle
aimFOVSec:addToggle("Show FOV Circle", false, function(v) getgenv().Aimbot.ShowFOV = v end)
aimFOVSec:addToggle("FOV Filled",      false, function(v) getgenv().Aimbot.FOVFilled = v end)
aimFOVSec:addToggle("Rainbow FOV",     false, function(v) getgenv().Aimbot.RainbowFOV = v end)
aimFOVSec:addToggle("Pulse FOV",       false, function(v) getgenv().Aimbot.PulseFOV = v end)

aimFOVSec:addSlider("FOV Circle Size",      getgenv().Aimbot.FOVSize,      10,  500, function(v) getgenv().Aimbot.FOVSize      = v end)
aimFOVSec:addSlider("FOV Thickness",        getgenv().Aimbot.FOVThickness,  1,   10, function(v) getgenv().Aimbot.FOVThickness = v end)
aimFOVSec:addSlider("FOV Sides",            getgenv().Aimbot.FOVSides,      3,  100, function(v) getgenv().Aimbot.FOVSides     = v end)
aimFOVSec:addSlider("Camera FOV",          getgenv().VoidFOV,              70,  120, function(v) getgenv().VoidFOV             = v end)

-- Prediction
aimPredSec:addSlider("Prediction Horizontal", math.floor(getgenv().Aimbot.Prediction.Horizontal * 200), 0, 100, function(v)
    getgenv().Aimbot.Prediction.Horizontal = v / 100 * 0.5
end)
aimPredSec:addSlider("Prediction Vertical", math.floor(getgenv().Aimbot.Prediction.Vertical * 200), 0, 100, function(v)
    getgenv().Aimbot.Prediction.Vertical = v / 100 * 0.5
end)
aimPredSec:addButton("Reset Prediction", function()
    getgenv().Aimbot.Prediction.Horizontal = 0.165
    getgenv().Aimbot.Prediction.Vertical   = 0.100
    venyx:Notify("Prediction", "Reset to defaults")
end)

-- Smoothness
aimSmoothSec:addSlider("Smoothness",       getgenv().Aimbot.Smoothness * 10,    1,  50, function(v) getgenv().Aimbot.Smoothness     = math.max(v/10, 0.1) end)
aimSmoothSec:addSlider("Shake Intensity",  getgenv().Aimbot.ShakeIntensity or 0, 0,  10, function(v) getgenv().Aimbot.ShakeIntensity = v end)

aimSmoothSec:addButton("Reset Smoothness Defaults", function()
    getgenv().Aimbot.Smoothness     = 1
    getgenv().Aimbot.ShakeIntensity = 0
    getgenv().Aimbot.MaxDistance    = 200
    venyx:Notify("Aimbot", "Smoothness/Shake/Distance reset")
end)

-- ============================================================
--  MOVEMENT PAGE
-- ============================================================

moveSpeedSec:addSlider("Walk Speed", getgenv().VoidSpeedValue, 16, 500, function(v)
    getgenv().VoidSpeedValue = v
    local hum = GetHumanoid() if hum then hum.WalkSpeed = v end
end)
moveSpeedSec:addButton("Reset Walk Speed", function()
    getgenv().VoidSpeedValue = 16
    local hum = GetHumanoid() if hum then hum.WalkSpeed = 16 end
    venyx:Notify("Speed", "Reset to 16")
end)
moveSpeedSec:addSlider("Jump Power", getgenv().VoidJumpValue, 50, 500, function(v)
    getgenv().VoidJumpValue = v
    local hum = GetHumanoid() if hum then hum.JumpPower = v end
end)
moveSpeedSec:addButton("Reset Jump Power", function()
    getgenv().VoidJumpValue = 50
    local hum = GetHumanoid() if hum then hum.JumpPower = 50 end
    venyx:Notify("Jump", "Reset to 50")
end)

moveMiscSec:addToggle("Noclip", false, function(v)
    getgenv().VoidNoclip = v
    if not v then
        local char = GetCharacter()
        if char then for _, p in char:GetDescendants() do if p:IsA("BasePart") then p.CanCollide = true end end end
    end
end)
moveMiscSec:addToggle("Infinite Jump", false, function(v) getgenv().VoidInfJump = v end)
moveMiscSec:addToggle("Bunny Hop", false, function(v) getgenv().VoidBHop = v end)
moveMiscSec:addToggle("Safe Walk (No Fall Damage)", false, function(v) getgenv().VoidSafeWalk = v end)
moveMiscSec:addToggle("Freeze Character", false, function(v)
    local hum = GetHumanoid() local root = GetRootPart()
    if hum  then hum.PlatformStand = v end
    if root then root.Anchored      = v end
end)
moveMiscSec:addButton("Sit",   function() local h = GetHumanoid() if h then h.Sit = true  end end)
moveMiscSec:addButton("Stand", function() local h = GetHumanoid() if h then h.Sit = false end end)

-- Fly (vars forward declared so StartFly/StopFly can use them)
local flyBodyVelocity, flyBodyGyro = nil, nil

local function CleanupFlyObjects()
    if flyBodyVelocity then pcall(function() flyBodyVelocity:Destroy() end) flyBodyVelocity = nil end
    if flyBodyGyro     then pcall(function() flyBodyGyro:Destroy()     end) flyBodyGyro     = nil end
end

local function StartFly()
    if getgenv().VoidFlying then return end
    local hum = GetHumanoid() local root = GetRootPart()
    if not hum or not root then return end
    CleanupFlyObjects()
    getgenv().VoidFlying = true
    flyBodyVelocity = Instance.new("BodyVelocity")
    flyBodyVelocity.MaxForce = Vector3.new(1e5,1e5,1e5)
    flyBodyVelocity.Velocity = Vector3.new(0,0,0)
    flyBodyVelocity.Parent   = root
    flyBodyGyro = Instance.new("BodyGyro")
    flyBodyGyro.MaxTorque = Vector3.new(1e5,1e5,1e5)
    flyBodyGyro.D         = 50
    flyBodyGyro.P         = 1000
    flyBodyGyro.CFrame    = root.CFrame
    flyBodyGyro.Parent    = root
end

local function StopFly()
    if not getgenv().VoidFlying then return end
    getgenv().VoidFlying = false
    CleanupFlyObjects()
    local hum = GetHumanoid() local root = GetRootPart()
    if hum  then hum.PlatformStand = false hum.AutoRotate = true end
    if root then pcall(function() root.Velocity = Vector3.new(0,0,0) root.RotVelocity = Vector3.new(0,0,0) end) end
end

moveFlySec:addSlider("Fly Speed", getgenv().VoidFlySpeed, 10, 500, function(v) getgenv().VoidFlySpeed = v end)
moveFlySec:addToggle("Enable Fly", false, function(v)
    if v then StartFly() else StopFly() end
end)
if not IsMobile then
    moveFlySec:addKeybind("Fly Keybind", Enum.KeyCode.F, function()
        if getgenv().VoidFlying then StopFly() else StartFly() end
    end)
end

moveGravSec:addSlider("Workspace Gravity", 196, 0, 300, function(v) WS.Gravity = v end)
moveGravSec:addButton("Reset Gravity", function() WS.Gravity = 196 venyx:Notify("Gravity", "Reset to 196") end)
moveGravSec:addSlider("Hip Height", 0, 0, 50, function(v)
    local hum = GetHumanoid() if hum then hum.HipHeight = v end
end)
moveGravSec:addButton("Reset Hip Height", function()
    local hum = GetHumanoid() if hum then hum.HipHeight = 0 end
end)

local tpToMouseEnabled = false
moveTpSec:addToggle(IsMobile and "Teleport on Tap" or "Teleport to Mouse (CTRL+Click)", false, function(v)
    tpToMouseEnabled = v
end)
moveTpSec:addButton("Save / Return to Position", function()
    local root = GetRootPart()
    if root then
        if not getgenv().VoidSavedCFrame then
            getgenv().VoidSavedCFrame = root.CFrame
            venyx:Notify("Position", "Saved! Press again to return")
        else
            root.CFrame = getgenv().VoidSavedCFrame
            getgenv().VoidSavedCFrame = nil
            venyx:Notify("Position", "Returned to saved position")
        end
    end
end)
moveTpSec:addSlider("Time Scale", 100, 10, 300, function(v)
    getgenv().VoidTimeScale = v / 100
end)

-- ============================================================
--  TARGET PAGE
-- ============================================================

local SelectedPlayerName = nil

targetSelSec:addDropdown("Target Player", GetPlayerList(), function(v)
    SelectedPlayerName = v
    venyx:Notify("Target", "Selected: " .. tostring(v))
end)
targetSelSec:addButton("Refresh Player List", function()
    venyx:Notify("Players", "Re-open dropdown to see updated list")
end)

-- Actions
targetActSec:addButton("Teleport to Selected", function()
    if not SelectedPlayerName then venyx:Notify("TP", "Select a player first") return end
    local target = GetPlayerByName(SelectedPlayerName) local myRoot = GetRootPart()
    if target and target.Character and myRoot then
        local root = target.Character:FindFirstChild("HumanoidRootPart")
        if root then myRoot.CFrame = root.CFrame + Vector3.new(3,0,0) venyx:Notify("TP", "Teleported to " .. SelectedPlayerName) return end
    end
    venyx:Notify("TP", "Could not find target")
end)

targetActSec:addButton("Teleport to Aim Target", function()
    local state = getgenv().VoidAimState local myRoot = GetRootPart()
    if state.PlayerTarget and myRoot then
        local root = state.PlayerTarget.model:FindFirstChild("HumanoidRootPart")
        if root then myRoot.CFrame = root.CFrame * CFrame.new(0,0,3) venyx:Notify("TP", "Teleported to " .. state.PlayerTarget.name) return end
    end
    venyx:Notify("TP", "No aim target locked")
end)

targetActSec:addButton("View Selected Player", function()
    if not SelectedPlayerName then venyx:Notify("View", "Select a player first") return end
    local target = GetPlayerByName(SelectedPlayerName)
    if target and target.Character then
        local hum = target.Character:FindFirstChildOfClass("Humanoid")
        if hum then WS.CurrentCamera.CameraSubject = hum venyx:Notify("View", "Viewing " .. SelectedPlayerName) return end
    end
    venyx:Notify("View", "Failed")
end)

targetActSec:addButton("Reset Camera to Self", function()
    local char = GetCharacter() local hum = char and char:FindFirstChildOfClass("Humanoid")
    if hum then WS.CurrentCamera.CameraSubject = hum WS.CurrentCamera.CameraType = Enum.CameraType.Custom end
    venyx:Notify("Camera", "Reset to self")
end)

targetActSec:addButton("Copy Aim Target Name", function()
    local state = getgenv().VoidAimState
    if state.PlayerTarget then
        pcall(function() setclipboard(state.PlayerTarget.name) end)
        venyx:Notify("Copied", state.PlayerTarget.name)
    else venyx:Notify("Copy", "No aim target") end
end)

targetActSec:addButton("Spectate Selected", function()
    if not SelectedPlayerName then venyx:Notify("Spectate", "Select a player first") return end
    local target = GetPlayerByName(SelectedPlayerName)
    if target and target.Character then
        local hum = target.Character:FindFirstChildOfClass("Humanoid")
        if hum then WS.CurrentCamera.CameraSubject = hum WS.CurrentCamera.CameraType = Enum.CameraType.Follow
            venyx:Notify("Spectating", SelectedPlayerName) return end
    end
    venyx:Notify("Spectate", "Failed")
end)

targetActSec:addButton("Stop Spectating", function()
    local char = GetCharacter() local hum = char and char:FindFirstChildOfClass("Humanoid")
    if hum then WS.CurrentCamera.CameraSubject = hum WS.CurrentCamera.CameraType = Enum.CameraType.Custom end
    venyx:Notify("Spectate", "Returned to own camera")
end)

local loopTeleportEnabled = false
targetActSec:addToggle("Loop Teleport to Target", false, function(v)
    loopTeleportEnabled = v
end)

-- Fling
local flingPower = 500000
targetFling:addSlider("Fling Power", flingPower, 100000, 5000000, function(v) flingPower = v end)

targetFling:addButton("Fling Selected", function()
    if not SelectedPlayerName then venyx:Notify("Fling", "Select a player first") return end
    local target = GetPlayerByName(SelectedPlayerName)
    if not target or not target.Character then venyx:Notify("Fling", "Target not found") return end
    local myRoot = GetRootPart() local tRoot = target.Character:FindFirstChild("HumanoidRootPart")
    if not myRoot or not tRoot then return end
    local saved = myRoot.CFrame myRoot.CFrame = tRoot.CFrame
    local bv = Instance.new("BodyVelocity")
    bv.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
    bv.Velocity = Vector3.new(math.random(-1,1)*flingPower, flingPower, math.random(-1,1)*flingPower)
    bv.Parent = tRoot
    task.delay(0.1, function() pcall(function() bv:Destroy() end) myRoot.CFrame = saved end)
    venyx:Notify("Flung", SelectedPlayerName)
end)

targetFling:addButton("Fling Aim Target", function()
    local state = getgenv().VoidAimState
    if not state.PlayerTarget then venyx:Notify("Fling", "No aim target") return end
    local myRoot = GetRootPart() local tRoot = state.PlayerTarget.model:FindFirstChild("HumanoidRootPart")
    if not myRoot or not tRoot then return end
    local saved = myRoot.CFrame myRoot.CFrame = tRoot.CFrame
    local bv = Instance.new("BodyVelocity")
    bv.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
    bv.Velocity = Vector3.new(math.random(-1,1)*flingPower, flingPower, math.random(-1,1)*flingPower)
    bv.Parent = tRoot
    task.delay(0.1, function() pcall(function() bv:Destroy() end) myRoot.CFrame = saved end)
    venyx:Notify("Flung", state.PlayerTarget.name)
end)

local loopFlingEnabled = false
targetFling:addToggle("Loop Fling Selected", false, function(v) loopFlingEnabled = v end)

-- Orbit & Annoy
local orbitEnabled = false local orbitRadius = 8 local orbitSpeed = 2 local orbitAngle = 0
targetOrbit:addSlider("Orbit Radius", orbitRadius, 3,  50, function(v) orbitRadius = v end)
targetOrbit:addSlider("Orbit Speed",  orbitSpeed,  1,  20, function(v) orbitSpeed  = v end)
targetOrbit:addToggle("Orbit Selected", false, function(v) orbitEnabled = v end)

local loopJumpEnabled = false
targetOrbit:addToggle("Loop Jump On Target", false, function(v) loopJumpEnabled = v end)

local spinTargetEnabled = false local spinTargetAngle = 0
targetOrbit:addToggle("Spin Around Target", false, function(v) spinTargetEnabled = v end)

-- Freeze
local frozenTargets = {}
targetFreeze:addButton("Freeze Selected", function()
    if not SelectedPlayerName then venyx:Notify("Freeze", "Select a player first") return end
    local target = GetPlayerByName(SelectedPlayerName)
    if not target or not target.Character then venyx:Notify("Freeze", "Target not found") return end
    local tRoot = target.Character:FindFirstChild("HumanoidRootPart") if not tRoot then return end
    if not frozenTargets[SelectedPlayerName] then
        local bg = Instance.new("BodyGyro") bg.MaxTorque = Vector3.new(math.huge,math.huge,math.huge)
        bg.D = 9e9 bg.CFrame = tRoot.CFrame bg.Parent = tRoot
        local bv2 = Instance.new("BodyVelocity") bv2.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
        bv2.Velocity = Vector3.new(0,0,0) bv2.Parent = tRoot
        frozenTargets[SelectedPlayerName] = {bg=bg, bv=bv2}
        venyx:Notify("Frozen", SelectedPlayerName)
    else venyx:Notify("Freeze", SelectedPlayerName .. " already frozen") end
end)

targetFreeze:addButton("Unfreeze Selected", function()
    if SelectedPlayerName and frozenTargets[SelectedPlayerName] then
        pcall(function() frozenTargets[SelectedPlayerName].bg:Destroy() end)
        pcall(function() frozenTargets[SelectedPlayerName].bv:Destroy() end)
        frozenTargets[SelectedPlayerName] = nil
        venyx:Notify("Unfrozen", SelectedPlayerName)
    else venyx:Notify("Unfreeze", "Target not frozen") end
end)

targetFreeze:addButton("Unfreeze All", function()
    local count = 0
    for name, data in pairs(frozenTargets) do
        pcall(function() data.bg:Destroy() end) pcall(function() data.bv:Destroy() end)
        frozenTargets[name] = nil count = count + 1
    end
    venyx:Notify("Unfreeze All", count .. " player(s) unfrozen")
end)

-- Info
targetInfo:addButton("Get Selected Player Info", function()
    if not SelectedPlayerName then venyx:Notify("Info", "Select a player first") return end
    local target = GetPlayerByName(SelectedPlayerName) if not target then venyx:Notify("Info", "Not found") return end
    local hum = target.Character and target.Character:FindFirstChildOfClass("Humanoid")
    local hp = hum and math.floor(hum.Health) or 0 local maxhp = hum and math.floor(hum.MaxHealth) or 0
    local myRoot = GetRootPart() local tRoot = target.Character and target.Character:FindFirstChild("HumanoidRootPart")
    local dist = (myRoot and tRoot) and math.floor((myRoot.Position - tRoot.Position).Magnitude) or 0
    venyx:Notify(target.DisplayName, ("HP:%d/%d | Dist:%d | Team:%s"):format(hp, maxhp, dist, tostring(target.Team and target.Team.Name or "None")))
end)

targetInfo:addButton("Get Aim Target Info", function()
    local state = getgenv().VoidAimState
    if not state.PlayerTarget then venyx:Notify("Info", "No aim target") return end
    local t = state.PlayerTarget local hum = t.model:FindFirstChildOfClass("Humanoid")
    local hp = hum and math.floor(hum.Health) or 0 local maxhp = hum and math.floor(hum.MaxHealth) or 0
    local myRoot = GetRootPart() local tRoot = t.model:FindFirstChild("HumanoidRootPart")
    local dist = (myRoot and tRoot) and math.floor((myRoot.Position - tRoot.Position).Magnitude) or 0
    venyx:Notify(t.name, ("HP:%d/%d | Dist:%d"):format(hp, maxhp, dist))
end)

-- ============================================================
--  VISUALS PAGE
-- ============================================================

espSec:addToggle("Enable ESP",         false, function(v) getgenv().VoidESPEnabled   = v end)
espSec:addToggle("Box ESP",            false, function(v) getgenv().VoidESPBoxEnabled = v end)
espSec:addToggle("Name ESP",           false, function(v) getgenv().VoidESPNameEnabled = v end)
espSec:addToggle("Health Bar",         false, function(v) getgenv().VoidESPHealthEnabled = v end)
espSec:addToggle("Distance",           false, function(v) getgenv().VoidESPDistEnabled = v end)
espSec:addToggle("Tracers",            false, function(v) getgenv().VoidESPTracers  = v end)
espSec:addToggle("Skeleton",           false, function(v) getgenv().VoidESPSkeleton = v end)
espSec:addToggle("Head Dot",           false, function(v) getgenv().VoidESPHeadDot  = v end)
espSec:addToggle("Look Direction",     false, function(v) getgenv().VoidESPLookDir  = v end)
espSec:addToggle("Team Check",         false, function(v) getgenv().VoidESPTeamCheck = v end)

espSetSec:addSlider("Max ESP Distance", getgenv().VoidESPMaxDist, 100, 2000, function(v) getgenv().VoidESPMaxDist = v end)
espSetSec:addColorPicker("ESP Color", getgenv().VoidESPColor, function(c) getgenv().VoidESPColor = c end)

chamsSec:addToggle("Chams (Highlight)", false, function(v) getgenv().VoidChamsEnabled = v end)
chamsSec:addColorPicker("Chams Fill",    getgenv().VoidChamsColor,   function(c) getgenv().VoidChamsColor   = c end)
chamsSec:addColorPicker("Chams Outline", getgenv().VoidChamsOutline, function(c) getgenv().VoidChamsOutline = c end)

camSec:addSlider("Camera Zoom Max", 400, 10, 500, function(v) LocalPlayer.CameraMaxZoomDistance = v end)
camSec:addButton("Reset Camera Zoom", function() LocalPlayer.CameraMaxZoomDistance = 400 end)
camSec:addButton("Reset Character",   function() LocalPlayer:LoadCharacter() end)

-- ============================================================
--  GRAPHICS PAGE
-- ============================================================

lightSec:addButton("Apply Custom Lighting", function()
    Lighting.FogEnd = 17000 Lighting.FogStart = 0 Lighting.FogColor = Color3.fromRGB(132,196,245)
    Lighting.GlobalShadows = true Lighting.Ambient = Color3.fromRGB(130,170,200) Lighting.Brightness = 2
    venyx:Notify("Lighting", "Custom preset applied")
end)
lightSec:addButton("Reset to Game Default", function()
    for k, v in pairs(DefaultLighting) do pcall(function() Lighting[k] = v end) end
    venyx:Notify("Lighting", "Reset to game default")
end)
lightSec:addToggle("Fullbright", false, function(v)
    getgenv().VoidFullbright = v
    if not v then
        Lighting.Ambient        = DefaultLighting.Ambient
        Lighting.OutdoorAmbient = DefaultLighting.OutdoorAmbient
        Lighting.Brightness     = DefaultLighting.Brightness
        Lighting.GlobalShadows  = DefaultLighting.GlobalShadows
    end
end)
lightSec:addSlider("Clock Time", math.floor(Lighting.ClockTime), 0, 24, function(v) Lighting.ClockTime = v end)
lightSec:addButton("Set Day (12:00)",   function() Lighting.ClockTime = 12 end)
lightSec:addButton("Set Night (0:00)",  function() Lighting.ClockTime = 0  end)

postFxSec:addToggle("RTX Mode", false, function(v)
    if v then
        Lighting.Brightness = 2.5 Lighting.Ambient = Color3.fromRGB(100,100,100)
        Lighting.ExposureCompensation = 0.2 Lighting.FogEnd = 100000
        local bloom = Lighting:FindFirstChildOfClass("BloomEffect") or Instance.new("BloomEffect", Lighting)
        bloom.Enabled = true bloom.Intensity = 0.4 bloom.Size = 24 bloom.Threshold = 0.8
        local sun = Lighting:FindFirstChildOfClass("SunRaysEffect") or Instance.new("SunRaysEffect", Lighting)
        sun.Enabled = true sun.Intensity = 0.15 sun.Spread = 0.8
        local cc = Lighting:FindFirstChildOfClass("ColorCorrectionEffect") or Instance.new("ColorCorrectionEffect", Lighting)
        cc.Enabled = true cc.Brightness = 0.05 cc.Contrast = 0.15 cc.Saturation = 0.1
    else
        for _, e in pairs(Lighting:GetChildren()) do
            if e:IsA("BloomEffect") or e:IsA("SunRaysEffect") or e:IsA("ColorCorrectionEffect") then e:Destroy() end
        end
        Lighting.Brightness = DefaultLighting.Brightness Lighting.Ambient = DefaultLighting.Ambient
        Lighting.ExposureCompensation = DefaultLighting.ExposureCompensation Lighting.FogEnd = DefaultLighting.FogEnd
    end
end)
postFxSec:addToggle("Bloom", false, function(v)
    local b = Lighting:FindFirstChildOfClass("BloomEffect")
    if v then if not b then b = Instance.new("BloomEffect", Lighting) end b.Enabled = true b.Intensity = 0.4 b.Size = 24 b.Threshold = 0.8
    else if b then b:Destroy() end end
end)
postFxSec:addToggle("Sun Rays", false, function(v)
    local s = Lighting:FindFirstChildOfClass("SunRaysEffect")
    if v then if not s then s = Instance.new("SunRaysEffect", Lighting) end s.Enabled = true s.Intensity = 0.15 s.Spread = 0.8
    else if s then s:Destroy() end end
end)
postFxSec:addToggle("Color Correction", false, function(v)
    local cc = Lighting:FindFirstChildOfClass("ColorCorrectionEffect")
    if v then if not cc then cc = Instance.new("ColorCorrectionEffect", Lighting) end cc.Enabled = true cc.Brightness = 0.05 cc.Contrast = 0.15 cc.Saturation = 0.1
    else if cc then cc:Destroy() end end
end)

perfSec:addToggle("Performance Mode", false, function(v)
    if v then
        settings().Rendering.QualityLevel = Enum.QualityLevel.Level01
        Lighting.GlobalShadows = false Lighting.FogEnd = 500
        for _, o in pairs(WS:GetDescendants()) do
            if o:IsA("BasePart") then o.CastShadow = false
                if o:IsA("MeshPart") then o.RenderFidelity = Enum.RenderFidelity.Performance end
            elseif o:IsA("ParticleEmitter") or o:IsA("Trail") or o:IsA("Smoke") or o:IsA("Fire") or o:IsA("Sparkles") then
                o.Enabled = false
            end
        end
    else
        settings().Rendering.QualityLevel = Enum.QualityLevel.Automatic
        Lighting.GlobalShadows = DefaultLighting.GlobalShadows Lighting.FogEnd = DefaultLighting.FogEnd
    end
end)
perfSec:addToggle("Remove Shadows", false, function(v)
    Lighting.GlobalShadows = not v
    for _, o in pairs(WS:GetDescendants()) do if o:IsA("BasePart") then o.CastShadow = not v end end
end)
perfSec:addToggle("Disable Particles", false, function(v)
    for _, o in pairs(WS:GetDescendants()) do
        if o:IsA("ParticleEmitter") or o:IsA("Trail") or o:IsA("Smoke") or o:IsA("Fire") or o:IsA("Sparkles") then
            o.Enabled = not v
        end
    end
end)
perfSec:addSlider("Render Distance (FogEnd)", math.min(DefaultLighting.FogEnd, 100000), 100, 100000, function(v)
    Lighting.FogEnd = v
end)
perfSec:addButton("Unlock FPS (999)",  function() pcall(function() setfpscap(999) end) venyx:Notify("FPS", "Unlocked") end)
perfSec:addButton("Reset FPS Cap (60)", function() pcall(function() setfpscap(60)  end) venyx:Notify("FPS", "Cap set to 60") end)
perfSec:addButton("Delete Terrain",    function() if WS.Terrain then WS.Terrain:Clear() end venyx:Notify("Terrain", "Cleared") end)
perfSec:addButton("Remove Textures",   function()
    for _, o in pairs(WS:GetDescendants()) do
        if o:IsA("Decal") or o:IsA("Texture") then o.Transparency = 1
        elseif o:IsA("BasePart") then o.Material = Enum.Material.SmoothPlastic end
    end
    venyx:Notify("Textures", "Removed")
end)

-- ============================================================
--  EXTRAS PAGE
-- ============================================================

-- Hitbox Expander
local hitboxExpandEnabled = false local hitboxSize = 10 local originalSizes = {}

local function ApplyHitboxes()
    for _, player in Players:GetPlayers() do
        if player ~= LocalPlayer and player.Character then
            local root = player.Character:FindFirstChild("HumanoidRootPart")
            if root then
                if not originalSizes[player] then originalSizes[player] = root.Size end
                root.Size = Vector3.new(hitboxSize,hitboxSize,hitboxSize) root.Transparency = 0.9 root.CanCollide = false
            end
        end
    end
end
local function ResetHitboxes()
    for player, origSize in pairs(originalSizes) do
        if player.Character then
            local root = player.Character:FindFirstChild("HumanoidRootPart")
            if root then root.Size = origSize root.Transparency = 1 end
        end
    end
    originalSizes = {}
end

hitboxSec:addToggle("Hitbox Expander", false, function(v)
    hitboxExpandEnabled = v if not v then ResetHitboxes() end
end)
hitboxSec:addSlider("Hitbox Size", hitboxSize, 4, 60, function(v) hitboxSize = v end)

-- Kill Aura
local killAuraEnabled = false local killAuraRange = 15
killAuraSec:addToggle("Kill Aura", false, function(v) killAuraEnabled = v end)
killAuraSec:addSlider("Kill Aura Range", killAuraRange, 5, 100, function(v) killAuraRange = v end)

-- Spin Bot
local spinBotEnabled = false local spinBotSpeed = 20 local spinBotAngle = 0
spinSec:addToggle("Spin Bot", false, function(v) spinBotEnabled = v end)
spinSec:addSlider("Spin Speed", spinBotSpeed, 1, 50, function(v) spinBotSpeed = v end)

-- Silent Aim
local silentAimEnabled = false
silentSec:addToggle("Silent Aim", false, function(v) silentAimEnabled = v end)

-- Crosshair
local drawingAvailable = pcall(function() local _ = Drawing end)
local crosshairLines = {} local crosshairVisible = false
local crosshairSize = 12 local crosshairGap = 4
local crosshairColor = Color3.fromRGB(255,255,255) local crosshairThick = 2

if drawingAvailable then
    for i = 1, 4 do
        local ok, line = pcall(function()
            local l = Drawing.new("Line") l.Thickness = 2
            l.Color = Color3.fromRGB(255,255,255) l.Transparency = 1 l.Visible = false return l
        end)
        if ok then table.insert(crosshairLines, line) end
    end
end

crosshairSec:addToggle("Show Crosshair", false, function(v) crosshairVisible = v end)
crosshairSec:addSlider("Crosshair Size",      crosshairSize,  4,  40, function(v) crosshairSize  = v end)
crosshairSec:addSlider("Crosshair Gap",       crosshairGap,   0,  20, function(v) crosshairGap   = v end)
crosshairSec:addSlider("Crosshair Thickness", crosshairThick, 1,   6, function(v) crosshairThick = v end)
crosshairSec:addDropdown("Crosshair Color", {"White","Red","Green","Blue","Yellow","Cyan","Magenta"}, function(opt)
    local colors = {
        White=Color3.fromRGB(255,255,255), Red=Color3.fromRGB(255,50,50), Green=Color3.fromRGB(50,255,50),
        Blue=Color3.fromRGB(50,100,255), Yellow=Color3.fromRGB(255,230,0), Cyan=Color3.fromRGB(0,200,255),
        Magenta=Color3.fromRGB(255,0,200)
    }
    crosshairColor = colors[opt] or Color3.fromRGB(255,255,255)
end)

-- Misc extras
local speedLinesEnabled = false local wallbangEnabled = false
local autoRespawnEnabled = false local fakeLagEnabled = false

miscSec:addToggle("Speed Lines (Cinematic)",        false, function(v) speedLinesEnabled  = v end)
miscSec:addToggle("Wallbang (Transparent Walls)",   false, function(v)
    wallbangEnabled = v
    for _, o in pairs(WS:GetDescendants()) do
        if o:IsA("BasePart") and not o:IsDescendantOf(LocalPlayer.Character or Instance.new("Folder")) then
            if v then
                if not o:GetAttribute("VoidOrigT") then o:SetAttribute("VoidOrigT", o.Transparency) end
                o.Transparency = math.max(o.Transparency, 0.85)
            else
                local orig = o:GetAttribute("VoidOrigT")
                if orig ~= nil then o.Transparency = orig o:SetAttribute("VoidOrigT", nil) end
            end
        end
    end
end)
miscSec:addToggle("Auto Respawn on Death", false, function(v) autoRespawnEnabled = v end)
miscSec:addToggle("Fake Lag", false, function(v)
    fakeLagEnabled = v
    if v then
        task.spawn(function()
            while fakeLagEnabled do
                local root = GetRootPart()
                if root then local saved = root.CFrame task.wait(0.05)
                    if fakeLagEnabled and root and root.Parent then root.CFrame = saved end
                else task.wait(0.1) end
            end
        end)
    end
end)
miscSec:addToggle("Anti-AFK", false, function(v)
    if v then
        TrackConnection(LocalPlayer.Idled:Connect(function()
            local VU = game:GetService("VirtualUser")
            pcall(function() VU:CaptureController() VU:ClickButton2(Vector2.new()) end)
        end))
    end
end)

-- Audio
local chatSpamEnabled = false local chatSpamMessage = "Hello!" local chatSpamDelay = 3
audioSec:addToggle("Mute All Sounds", false, function(v)
    for _, s in pairs(WS:GetDescendants()) do
        if s:IsA("Sound") then
            if v and not s:GetAttribute("VoidOrigVol") then s:SetAttribute("VoidOrigVol", s.Volume) end
            s.Volume = v and 0 or (s:GetAttribute("VoidOrigVol") or 0.5)
        end
    end
end)
audioSec:addSlider("Master Volume", 100, 0, 100, function(v)
    for _, s in pairs(WS:GetDescendants()) do if s:IsA("Sound") then s.Volume = v/100 end end
end)

-- Chat Spam
chatSec:addTextbox("Spam Message", chatSpamMessage, function(text, focusLost)
    if text and #text > 0 then chatSpamMessage = text end
end)
chatSec:addSlider("Interval (sec)", chatSpamDelay, 1, 30, function(v) chatSpamDelay = v end)
chatSec:addToggle("Enable Chat Spam", false, function(v)
    chatSpamEnabled = v
    if v then
        task.spawn(function()
            while chatSpamEnabled do
                pcall(function()
                    game:GetService("ReplicatedStorage"):FindFirstChild("DefaultChatSystemChatEvents")
                        :FindFirstChild("SayMessageRequest"):FireServer(chatSpamMessage, "All")
                end)
                task.wait(chatSpamDelay)
            end
        end)
    end
end)

-- Stats
statsSec:addButton("Show My Stats", function()
    local hum = GetHumanoid() local root = GetRootPart()
    if not hum or not root then venyx:Notify("Stats", "No character found") return end
    local pos = root.Position local ping = math.floor(LocalPlayer:GetNetworkPing() * 1000)
    venyx:Notify(LocalPlayer.DisplayName,
        ("HP:%d/%d | Spd:%d | Jmp:%d | Ping:%dms"):format(
            math.floor(hum.Health), math.floor(hum.MaxHealth),
            math.floor(hum.WalkSpeed), math.floor(hum.JumpPower), ping))
end)
statsSec:addButton("Copy My Position", function()
    local root = GetRootPart()
    if root then
        local pos = root.Position
        local str = ("Vector3.new(%.2f, %.2f, %.2f)"):format(pos.X, pos.Y, pos.Z)
        pcall(function() setclipboard(str) end)
        venyx:Notify("Position Copied", str)
    end
end)

-- ============================================================
--  RUNTIME LOGIC
-- ============================================================

-- Character reapply stats
TrackConnection(LocalPlayer.CharacterAdded:Connect(function()
    task.wait(0.5) ApplyStats()
    for _, player in Players:GetPlayers() do
        if player ~= LocalPlayer then AddDrawingESP(player) AddSkeleton(player) end
    end
end))

-- Camera FOV
TrackConnection(RunService.Heartbeat:Connect(function()
    camera.FieldOfView = getgenv().VoidFOV
end))

-- Aimbot
local function GetKeyCode(keyStr)
    local ok, result = pcall(function() return Enum.KeyCode[keyStr:upper()] end)
    return ok and result or nil
end

local function IsPlayerCharacter(model)
    for _, p in ipairs(Players:GetPlayers()) do if p.Character == model then return p end end
    return nil
end

local function GetClosestPlayerToMouse()
    local closestDist = math.huge local closest = nil
    local myRoot = GetRootPart() local myPos = myRoot and myRoot.Position local myChar = GetCharacter()
    local targetPos = IsMobile
        and Vector2.new(camera.ViewportSize.X/2, camera.ViewportSize.Y/2)
        or Vector2.new(Mouse.X, Mouse.Y)

    local function Evaluate(model, playerRef)
        if model == myChar or not model.Parent then return end
        local hum = model:FindFirstChildOfClass("Humanoid") local root = model:FindFirstChild("HumanoidRootPart")
        if not hum or not root or hum.Health <= 0 then return end
        if playerRef and getgenv().Aimbot.TeamCheck and SameTeam(playerRef) then return end
        local part = model:FindFirstChild(getgenv().Aimbot.Hitpart) or root
        if myPos and (myPos - part.Position).Magnitude > getgenv().Aimbot.MaxDistance then return end
        local screenPos, onScreen = camera:WorldToViewportPoint(part.Position)
        if not onScreen then return end
        local dist = (targetPos - Vector2.new(screenPos.X, screenPos.Y)).Magnitude
        if dist < closestDist and dist <= getgenv().Aimbot.FOVSize then
            if not getgenv().Aimbot.VisCheck or IsVisible(part) then
                closestDist = dist
                closest = { model=model, player=playerRef, name=(playerRef and (playerRef.DisplayName or playerRef.Name) or model.Name) }
            end
        end
    end

    if getgenv().Aimbot.LockNPC then
        for _, obj in ipairs(WS:GetDescendants()) do
            if obj:IsA("Model") then
                local playerRef = IsPlayerCharacter(obj)
                if playerRef ~= LocalPlayer then Evaluate(obj, playerRef or nil) end
            end
        end
    else
        for _, player in Players:GetPlayers() do
            if player ~= LocalPlayer and player.Character then Evaluate(player.Character, player) end
        end
    end
    return closest
end

local AIM_SETTLE_FRAMES = 3 local aimSettleCounter = 0 local aimLocked = false

local function LockOn()
    local target = GetClosestPlayerToMouse()
    if target then
        getgenv().VoidAimState.PlayerTarget = nil aimLocked = false
        task.defer(function()
            getgenv().VoidAimState.PlayerTarget = target
            aimSettleCounter = AIM_SETTLE_FRAMES aimLocked = true
        end)
    end
end

local function LockOff()
    aimLocked = false getgenv().VoidAimState.PlayerTarget = nil
    getgenv().VoidAimState.HoldActive = false aimSettleCounter = 0
end

TrackConnection(UserInputService.InputBegan:Connect(function(input, gpe)
    if gpe or not getgenv().Aimbot.Status or IsMobile then return end
    local key = GetKeyCode(getgenv().Aimbot.Keybind)
    if not key or input.KeyCode ~= key then return end
    if getgenv().Aimbot.LockMode == "Hold" then
        getgenv().VoidAimState.HoldActive = true LockOn()
    else
        if aimLocked then LockOff() else LockOn() end
    end
end))

TrackConnection(UserInputService.InputEnded:Connect(function(input)
    if IsMobile then return end
    local key = GetKeyCode(getgenv().Aimbot.Keybind)
    if not key or input.KeyCode ~= key then return end
    if getgenv().Aimbot.LockMode == "Hold" then LockOff() end
end))

local AIM_DEADZONE = 1.5 local AIM_MAX_STEP = 150

TrackConnection(RunService.RenderStepped:Connect(function()
    local state = getgenv().VoidAimState
    if not getgenv().Aimbot.Status or not state.PlayerTarget then return end
    if aimSettleCounter > 0 then aimSettleCounter -= 1 return end
    local td = state.PlayerTarget
    if not td or not td.model or not td.model.Parent then LockOff() return end
    local char = td.model local hum = char:FindFirstChildOfClass("Humanoid")
    if not hum or hum.Health <= 0 then LockOff() return end
    local partName = hum.FloorMaterial == Enum.Material.Air and getgenv().Aimbot.AirHitpart or getgenv().Aimbot.Hitpart
    local hitpart = char:FindFirstChild(partName) or char:FindFirstChild("HumanoidRootPart")
    if not hitpart then return end
    local predPos = hitpart.Position + hitpart.Velocity * Vector3.new(
        getgenv().Aimbot.Prediction.Horizontal, getgenv().Aimbot.Prediction.Vertical, getgenv().Aimbot.Prediction.Horizontal)
    if getgenv().Aimbot.ShakeIntensity > 0 then
        local s = getgenv().Aimbot.ShakeIntensity / 10
        predPos = predPos + Vector3.new(math.random()*s*2-s, math.random()*s*2-s, 0)
    end
    local screenPos, onScreen = camera:WorldToViewportPoint(predPos)
    if not onScreen or screenPos.Z <= 0 then return end
    local mousePos = UserInputService:GetMouseLocation()
    local rawDelta = Vector2.new(screenPos.X, screenPos.Y) - mousePos
    if rawDelta.Magnitude < AIM_DEADZONE then return end
    local delta = rawDelta / math.max(getgenv().Aimbot.Smoothness, 0.1)
    if delta.Magnitude > AIM_MAX_STEP then delta = delta.Unit * AIM_MAX_STEP end
    local ok = pcall(function() mousemoverel(delta.X, delta.Y) end)
    if not ok then
        local sf = math.min(1, 1/math.max(getgenv().Aimbot.Smoothness, 1))
        camera.CFrame = camera.CFrame:Lerp(CFrame.new(camera.CFrame.Position, predPos), sf)
    end
end))

-- Silent Aim
TrackConnection(RunService.RenderStepped:Connect(function()
    if not silentAimEnabled then return end
    local state = getgenv().VoidAimState if not state.PlayerTarget then return end
    local char = state.PlayerTarget.model if not char or not char.Parent then return end
    local hum = char:FindFirstChildOfClass("Humanoid") if not hum or hum.Health <= 0 then return end
    local hitpart = char:FindFirstChild(getgenv().Aimbot.Hitpart) or char:FindFirstChild("HumanoidRootPart")
    if not hitpart then return end
    local dir = (hitpart.Position - camera.CFrame.Position).Unit
    local angle = math.acos(math.clamp(camera.CFrame.LookVector:Dot(dir), -1, 1))
    if math.deg(angle) < 30 then camera.CFrame = CFrame.new(camera.CFrame.Position, hitpart.Position) end
end))

-- FOV Circle
local FOVCircleOk, FOVCircle = pcall(function()
    local c = Drawing.new("Circle") c.Visible = false c.Radius = 100
    c.Color = Color3.fromRGB(0,200,255) c.Thickness = 2 c.Filled = false c.Transparency = 1 c.NumSides = 64
    return c
end)
if not FOVCircleOk then FOVCircle = nil end
getgenv().VoidFOVCircle = FOVCircle

local fovHue = 0 local fovPulse = 0
TrackConnection(RunService.RenderStepped:Connect(function(dt)
    if not FOVCircle then return end
    FOVCircle.Position = IsMobile and Vector2.new(camera.ViewportSize.X/2, camera.ViewportSize.Y/2) or UserInputService:GetMouseLocation()
    if getgenv().Aimbot.RainbowFOV then fovHue = (fovHue+dt*0.5)%1 FOVCircle.Color = Color3.fromHSV(fovHue,1,1)
    else FOVCircle.Color = getgenv().VoidESPColor end
    FOVCircle.Radius    = getgenv().Aimbot.PulseFOV and (getgenv().Aimbot.FOVSize + math.sin(fovPulse)*20) or getgenv().Aimbot.FOVSize
    if getgenv().Aimbot.PulseFOV then fovPulse += dt*3 end
    FOVCircle.Thickness = getgenv().Aimbot.FOVThickness FOVCircle.Filled = getgenv().Aimbot.FOVFilled
    FOVCircle.Visible   = getgenv().Aimbot.ShowFOV and getgenv().Aimbot.Status FOVCircle.NumSides = getgenv().Aimbot.FOVSides
end))

-- Noclip
TrackConnection(RunService.Stepped:Connect(function()
    if getgenv().VoidNoclip then
        local char = GetCharacter()
        if char then for _, p in char:GetDescendants() do if p:IsA("BasePart") then p.CanCollide = false end end end
    end
end))

-- Infinite Jump
TrackConnection(UserInputService.JumpRequest:Connect(function()
    if getgenv().VoidInfJump then local hum = GetHumanoid() if hum then hum:ChangeState(Enum.HumanoidStateType.Jumping) end end
end))

-- Bunny Hop
TrackConnection(UserInputService.JumpRequest:Connect(function()
    if getgenv().VoidBHop then
        local hum = GetHumanoid()
        if hum and hum.FloorMaterial ~= Enum.Material.Air then
            task.defer(function() hum:ChangeState(Enum.HumanoidStateType.Jumping) end)
        end
    end
end))

-- Fullbright
TrackConnection(RunService.Heartbeat:Connect(function()
    if getgenv().VoidFullbright then
        Lighting.Ambient = Color3.fromRGB(255,255,255) Lighting.OutdoorAmbient = Color3.fromRGB(255,255,255)
        Lighting.Brightness = 2 Lighting.GlobalShadows = false
    end
end))

-- Fly
TrackConnection(RunService.RenderStepped:Connect(function()
    if not getgenv().VoidFlying then return end
    if not flyBodyVelocity or not flyBodyVelocity.Parent or not flyBodyGyro or not flyBodyGyro.Parent then
        getgenv().VoidFlying = false CleanupFlyObjects() return
    end
    local root = GetRootPart() if not root then StopFly() return end
    flyBodyGyro.CFrame = camera.CFrame
    local move = Vector3.new(0,0,0)
    if not IsMobile then
        if UserInputService:IsKeyDown(Enum.KeyCode.W)         then move += camera.CFrame.LookVector  end
        if UserInputService:IsKeyDown(Enum.KeyCode.S)         then move -= camera.CFrame.LookVector  end
        if UserInputService:IsKeyDown(Enum.KeyCode.A)         then move -= camera.CFrame.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.D)         then move += camera.CFrame.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.Space)     then move += Vector3.new(0,1,0) end
        if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then move -= Vector3.new(0,1,0) end
    else
        local hum = GetHumanoid()
        if hum then
            local md = hum.MoveDirection
            if md.Magnitude > 0.1 then
                local fwd   = Vector3.new(camera.CFrame.LookVector.X,  0, camera.CFrame.LookVector.Z)
                local right = Vector3.new(camera.CFrame.RightVector.X, 0, camera.CFrame.RightVector.Z)
                if fwd.Magnitude   > 0 then fwd   = fwd.Unit   end
                if right.Magnitude > 0 then right = right.Unit end
                move = fwd * -md.Z + right * md.X
            end
        end
        if getgenv().VoidMobileFlyUp   then move += Vector3.new(0,1,0) end
        if getgenv().VoidMobileFlyDown then move -= Vector3.new(0,1,0) end
    end
    flyBodyVelocity.Velocity = move * getgenv().VoidFlySpeed
end))

-- Safe Walk
TrackConnection(RunService.Heartbeat:Connect(function()
    if not getgenv().VoidSafeWalk then return end
    local hum = GetHumanoid() if hum then hum.AutoJumpEnabled = false end
    local root = GetRootPart()
    if root and root.Velocity.Y < -50 then
        local bv = root:FindFirstChild("VoidSafeWalkBV")
        if not bv then
            bv = Instance.new("BodyVelocity") bv.Name = "VoidSafeWalkBV"
            bv.MaxForce = Vector3.new(0,1e5,0) bv.Velocity = Vector3.new(0,0,0) bv.Parent = root
            task.delay(0.1, function() pcall(function() bv:Destroy() end) end)
        end
    end
end))

-- Loop Teleport
TrackConnection(RunService.Heartbeat:Connect(function()
    if not loopTeleportEnabled or not SelectedPlayerName then return end
    local target = GetPlayerByName(SelectedPlayerName) local myRoot = GetRootPart()
    if target and target.Character and myRoot then
        local root = target.Character:FindFirstChild("HumanoidRootPart")
        if root then myRoot.CFrame = root.CFrame + Vector3.new(3,0,0) end
    end
end))

-- Loop Fling
TrackConnection(RunService.Heartbeat:Connect(function()
    if not loopFlingEnabled or not SelectedPlayerName then return end
    local target = GetPlayerByName(SelectedPlayerName)
    if not target or not IsAlive(target) then return end
    local myRoot = GetRootPart() local tRoot = target.Character:FindFirstChild("HumanoidRootPart")
    if not myRoot or not tRoot then return end
    myRoot.CFrame = tRoot.CFrame
    local bv = Instance.new("BodyVelocity")
    bv.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
    bv.Velocity = Vector3.new(math.random(-1,1)*flingPower, flingPower, math.random(-1,1)*flingPower)
    bv.Parent = tRoot
    task.delay(0.05, function() pcall(function() bv:Destroy() end) end)
end))

-- Orbit
TrackConnection(RunService.Heartbeat:Connect(function(dt)
    if not orbitEnabled or not SelectedPlayerName then return end
    local target = GetPlayerByName(SelectedPlayerName) local myRoot = GetRootPart()
    if not target or not IsAlive(target) or not myRoot then return end
    local tRoot = target.Character:FindFirstChild("HumanoidRootPart") if not tRoot then return end
    orbitAngle += orbitSpeed * dt
    myRoot.CFrame = CFrame.new(
        tRoot.Position.X + math.cos(orbitAngle)*orbitRadius,
        tRoot.Position.Y,
        tRoot.Position.Z + math.sin(orbitAngle)*orbitRadius
    ) * CFrame.Angles(0, -orbitAngle - math.pi/2, 0)
end))

-- Loop Jump / Spin Target
TrackConnection(RunService.Heartbeat:Connect(function(dt)
    local myRoot = GetRootPart() if not myRoot then return end
    if loopJumpEnabled and SelectedPlayerName then
        local target = GetPlayerByName(SelectedPlayerName)
        if target and IsAlive(target) then
            local tRoot = target.Character:FindFirstChild("HumanoidRootPart")
            if tRoot then myRoot.CFrame = tRoot.CFrame + Vector3.new(0,3,0) end
        end
    end
    if spinTargetEnabled and SelectedPlayerName then
        local target = GetPlayerByName(SelectedPlayerName)
        if target and IsAlive(target) then
            local tRoot = target.Character:FindFirstChild("HumanoidRootPart")
            if tRoot then
                spinTargetAngle += 10 * dt
                myRoot.CFrame = CFrame.new(
                    tRoot.Position.X + math.cos(spinTargetAngle)*2,
                    tRoot.Position.Y,
                    tRoot.Position.Z + math.sin(spinTargetAngle)*2
                )
            end
        end
    end
end))

-- Spin Bot
TrackConnection(RunService.RenderStepped:Connect(function(dt)
    if not spinBotEnabled then return end
    local root = GetRootPart() if not root then return end
    spinBotAngle += spinBotSpeed * dt
    root.CFrame = CFrame.new(root.Position) * CFrame.Angles(0, math.rad(spinBotAngle*10), 0)
end))

-- Hitbox Expander
TrackConnection(RunService.Heartbeat:Connect(function()
    if hitboxExpandEnabled then ApplyHitboxes() end
end))

-- Kill Aura
TrackConnection(RunService.Heartbeat:Connect(function()
    if not killAuraEnabled then return end
    local myRoot = GetRootPart() if not myRoot then return end
    for _, player in Players:GetPlayers() do
        if player ~= LocalPlayer and IsAlive(player) then
            local tRoot = player.Character:FindFirstChild("HumanoidRootPart")
            if tRoot and (myRoot.Position - tRoot.Position).Magnitude <= killAuraRange then
                local bv = Instance.new("BodyVelocity")
                bv.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
                bv.Velocity = Vector3.new(0,9e9,0) bv.Parent = tRoot
                task.delay(0.05, function() pcall(function() bv:Destroy() end) end)
            end
        end
    end
end))

-- Crosshair
TrackConnection(RunService.RenderStepped:Connect(function()
    if not crosshairVisible or #crosshairLines < 4 then
        for _, l in ipairs(crosshairLines) do l.Visible = false end return
    end
    local cx = camera.ViewportSize.X/2 local cy = camera.ViewportSize.Y/2
    crosshairLines[1].From = Vector2.new(cx-crosshairSize-crosshairGap, cy)
    crosshairLines[1].To   = Vector2.new(cx-crosshairGap, cy)
    crosshairLines[2].From = Vector2.new(cx+crosshairGap, cy)
    crosshairLines[2].To   = Vector2.new(cx+crosshairSize+crosshairGap, cy)
    crosshairLines[3].From = Vector2.new(cx, cy-crosshairSize-crosshairGap)
    crosshairLines[3].To   = Vector2.new(cx, cy-crosshairGap)
    crosshairLines[4].From = Vector2.new(cx, cy+crosshairGap)
    crosshairLines[4].To   = Vector2.new(cx, cy+crosshairSize+crosshairGap)
    for _, l in ipairs(crosshairLines) do l.Color = crosshairColor l.Thickness = crosshairThick l.Visible = true end
end))

-- TP to Mouse
if IsMobile then
    UserInputService.TouchTap:Connect(function(touchPositions)
        if not tpToMouseEnabled then return end
        local root = GetRootPart() if not root then return end
        local tp = touchPositions[1]
        local unitRay = camera:ViewportPointToRay(tp.X, tp.Y)
        local params = RaycastParams.new()
        params.FilterDescendantsInstances = {GetCharacter()} params.FilterType = Enum.RaycastFilterType.Exclude
        local result = WS:Raycast(unitRay.Origin, unitRay.Direction*500, params)
        if result then root.CFrame = CFrame.new(result.Position + Vector3.new(0,3,0)) end
    end)
else
    Mouse.Button1Down:Connect(function()
        if tpToMouseEnabled and UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then
            local root = GetRootPart()
            if root then root.CFrame = CFrame.new(Mouse.Hit.Position + Vector3.new(0,3,0)) end
        end
    end)
end

-- Speed Lines
local speedLines = {} local NUM_SPEED_LINES = 30
if drawingAvailable then
    for i = 1, NUM_SPEED_LINES do
        local ok, line = pcall(function()
            local l = Drawing.new("Line") l.Thickness = 1 l.Transparency = 0.5
            l.Color = Color3.fromRGB(200,230,255) l.Visible = false return l
        end)
        if ok then table.insert(speedLines, line) end
    end
end
local speedLineAngle = {} local speedLineDist = {}
for i = 1, NUM_SPEED_LINES do
    speedLineAngle[i] = math.random()*math.pi*2 speedLineDist[i] = math.random(150,500)
end
TrackConnection(RunService.RenderStepped:Connect(function(dt)
    if not speedLinesEnabled or #speedLines == 0 then
        for _, l in ipairs(speedLines) do l.Visible = false end return
    end
    local cx = camera.ViewportSize.X/2 local cy = camera.ViewportSize.Y/2
    for i, line in ipairs(speedLines) do
        speedLineDist[i] += dt*600
        if speedLineDist[i] > 700 then speedLineDist[i] = math.random(50,150) speedLineAngle[i] = math.random()*math.pi*2 end
        local d1 = speedLineDist[i] local d2 = d1+60
        local cos, sin = math.cos(speedLineAngle[i]), math.sin(speedLineAngle[i])
        line.From = Vector2.new(cx+cos*d1, cy+sin*d1) line.To = Vector2.new(cx+cos*d2, cy+sin*d2)
        line.Transparency = math.clamp(1-(d1/700), 0.1, 1) line.Visible = true
    end
end))

-- Auto Respawn
TrackConnection(LocalPlayer.CharacterAdded:Connect(function(char)
    if not autoRespawnEnabled then return end
    local hum = char:WaitForChild("Humanoid", 5) if not hum then return end
    TrackConnection(hum.Died:Connect(function()
        if autoRespawnEnabled then task.wait(0.5) LocalPlayer:LoadCharacter() end
    end))
end))

-- ── Drawing ESP ───────────────────────────────────────────────
local DrawingESP    = getgenv().VoidDrawingESP
local TracerLines   = getgenv().VoidTracerLines
local SkeletonLines = getgenv().VoidSkeletonLines
local Highlights    = getgenv().VoidHighlights

function AddDrawingESP(player)
    if player == LocalPlayer or DrawingESP[player] or not drawingAvailable then return end
    local ok, result = pcall(function()
        return {
            Box=Drawing.new("Square"), Name=Drawing.new("Text"),
            Health=Drawing.new("Square"), HealthBG=Drawing.new("Square"),
            Distance=Drawing.new("Text"), HeadDot=Drawing.new("Circle"),
            LookLine=Drawing.new("Line"),
        }
    end)
    if not ok then return end
    local d = result
    d.Box.Thickness,d.Box.Filled,d.Box.Transparency,d.Box.Visible = 2,false,1,false
    d.Name.Size,d.Name.Center,d.Name.Outline,d.Name.Font,d.Name.Visible = 16,true,true,2,false
    d.HealthBG.Filled,d.HealthBG.Visible = true,false d.Health.Filled,d.Health.Visible = true,false
    d.Distance.Size,d.Distance.Center,d.Distance.Outline,d.Distance.Font,d.Distance.Visible = 14,true,true,2,false
    d.HeadDot.Radius,d.HeadDot.Filled,d.HeadDot.Visible = 4,true,false
    d.LookLine.Thickness,d.LookLine.Visible = 2,false
    DrawingESP[player] = d
end

local function RemoveDrawingESP(player)
    if DrawingESP[player] then
        for _, v in pairs(DrawingESP[player]) do pcall(v.Remove, v) end DrawingESP[player] = nil
    end
end

function AddSkeleton(player)
    if SkeletonLines[player] or not drawingAvailable then return end
    local lines = {}
    for i = 1, 6 do
        local ok, line = pcall(function()
            local l = Drawing.new("Line") l.Thickness=1 l.Visible=false l.Transparency=1 return l
        end)
        if ok then table.insert(lines, line) end
    end
    SkeletonLines[player] = lines
end

local function RemoveSkeleton(player)
    if SkeletonLines[player] then
        for _, l in ipairs(SkeletonLines[player]) do pcall(l.Remove, l) end SkeletonLines[player] = nil
    end
end

local function AddHighlight(player)
    if Highlights[player] or not player.Character then return end
    local h = Instance.new("Highlight")
    h.Adornee=player.Character h.FillColor=getgenv().VoidChamsColor
    h.OutlineColor=getgenv().VoidChamsOutline h.FillTransparency=0.5 h.Parent=player.Character
    Highlights[player] = h
end

local function RemoveHighlight(player)
    if Highlights[player] then pcall(function() Highlights[player]:Destroy() end) Highlights[player] = nil end
end

local function UpdateDrawingESP()
    for _, l in ipairs(TracerLines) do pcall(l.Remove, l) end
    TracerLines = {} getgenv().VoidTracerLines = TracerLines
    local myRoot = GetRootPart() local myPos = myRoot and myRoot.Position
    for player, d in pairs(DrawingESP) do
        local shouldShow = getgenv().VoidESPEnabled and IsAlive(player)
            and not (getgenv().VoidESPTeamCheck and SameTeam(player))
        if not shouldShow then
            for _, v in pairs(d) do v.Visible = false end
            if SkeletonLines[player] then for _, l in ipairs(SkeletonLines[player]) do l.Visible = false end end
            RemoveHighlight(player) continue
        end
        local char=player.Character local root=char:FindFirstChild("HumanoidRootPart")
        local head=char:FindFirstChild("Head") local hum=char:FindFirstChildOfClass("Humanoid")
        if not root or not head or not hum then for _,v in pairs(d) do v.Visible=false end continue end
        local dist3d = myPos and (myPos-root.Position).Magnitude or 0
        if dist3d > getgenv().VoidESPMaxDist then for _,v in pairs(d) do v.Visible=false end continue end
        local rPos,onScreen = camera:WorldToViewportPoint(root.Position)
        local hPos = camera:WorldToViewportPoint(head.Position+Vector3.new(0,0.5,0))
        local lPos = camera:WorldToViewportPoint(root.Position-Vector3.new(0,3,0))
        if not onScreen then
            for _,v in pairs(d) do v.Visible=false end
            if SkeletonLines[player] then for _,l in ipairs(SkeletonLines[player]) do l.Visible=false end end
            continue
        end
        local height=math.abs(hPos.Y-lPos.Y) local width=height/2 local col=getgenv().VoidESPColor
        d.Box.Color,d.Name.Color,d.Distance.Color = col,col,col
        d.HeadDot.Color,d.LookLine.Color = col,col
        d.Box.Visible = getgenv().VoidESPBoxEnabled
        if getgenv().VoidESPBoxEnabled then d.Box.Size=Vector2.new(width,height) d.Box.Position=Vector2.new(rPos.X-width/2,rPos.Y-height/2) end
        d.Name.Visible = getgenv().VoidESPNameEnabled
        if getgenv().VoidESPNameEnabled then d.Name.Text=player.DisplayName or player.Name d.Name.Position=Vector2.new(rPos.X,hPos.Y-30) end
        if getgenv().VoidESPHealthEnabled then
            local ratio=hum.Health/math.max(hum.MaxHealth,1)
            d.HealthBG.Size=Vector2.new(4,height) d.HealthBG.Position=Vector2.new(rPos.X-width/2-8,rPos.Y-height/2)
            d.HealthBG.Color,d.HealthBG.Transparency,d.HealthBG.Visible = Color3.new(0,0,0),0.5,true
            d.Health.Size=Vector2.new(4,height*ratio) d.Health.Position=d.HealthBG.Position+Vector2.new(0,height*(1-ratio))
            d.Health.Color,d.Health.Visible = Color3.fromHSV(ratio/3,1,1),true
        else d.Health.Visible,d.HealthBG.Visible=false,false end
        d.Distance.Visible = getgenv().VoidESPDistEnabled
        if getgenv().VoidESPDistEnabled then d.Distance.Text=math.floor(dist3d).." studs" d.Distance.Position=Vector2.new(rPos.X,lPos.Y+5) end
        d.HeadDot.Visible = getgenv().VoidESPHeadDot
        if getgenv().VoidESPHeadDot then d.HeadDot.Position=Vector2.new(hPos.X,hPos.Y) end
        if getgenv().VoidESPLookDir then
            local lw=camera:WorldToViewportPoint(head.Position+head.CFrame.LookVector*5)
            d.LookLine.From,d.LookLine.To,d.LookLine.Visible = Vector2.new(hPos.X,hPos.Y),Vector2.new(lw.X,lw.Y),true
        else d.LookLine.Visible=false end
        if getgenv().VoidESPTracers and drawingAvailable then
            local ok,tracer = pcall(function()
                local t=Drawing.new("Line")
                t.From=Vector2.new(camera.ViewportSize.X/2,camera.ViewportSize.Y)
                t.To=Vector2.new(rPos.X,rPos.Y) t.Color=col t.Thickness=1.5 t.Visible=true return t
            end)
            if ok then table.insert(TracerLines,tracer) end
        end
        if getgenv().VoidESPSkeleton and SkeletonLines[player] then
            local torso=char:FindFirstChild("UpperTorso") or char:FindFirstChild("Torso")
            local lower=char:FindFirstChild("LowerTorso") or torso
            local la=char:FindFirstChild("LeftUpperArm") or char:FindFirstChild("Left Arm")
            local ra=char:FindFirstChild("RightUpperArm") or char:FindFirstChild("Right Arm")
            local ll=char:FindFirstChild("LeftUpperLeg") or char:FindFirstChild("Left Leg")
            local rl=char:FindFirstChild("RightUpperLeg") or char:FindFirstChild("Right Leg")
            local bones={{head,torso},{torso,lower},{torso,la},{torso,ra},{lower,ll},{lower,rl}}
            for i,v in ipairs(bones) do
                local sl=SkeletonLines[player][i]
                if sl and v[1] and v[2] then
                    local a=camera:WorldToViewportPoint(v[1].Position)
                    local b=camera:WorldToViewportPoint(v[2].Position)
                    if a.Z>0 and b.Z>0 then sl.From,sl.To=Vector2.new(a.X,a.Y),Vector2.new(b.X,b.Y) sl.Color=col sl.Visible=true
                    else sl.Visible=false end
                elseif sl then sl.Visible=false end
            end
        elseif SkeletonLines[player] then
            for _,l in ipairs(SkeletonLines[player]) do l.Visible=false end
        end
        if getgenv().VoidChamsEnabled then
            if not Highlights[player] then AddHighlight(player) end
            if Highlights[player] then
                Highlights[player].FillColor=getgenv().VoidChamsColor
                Highlights[player].OutlineColor=getgenv().VoidChamsOutline
            end
        else RemoveHighlight(player) end
    end
end

for _, player in Players:GetPlayers() do
    if player ~= LocalPlayer then AddDrawingESP(player) AddSkeleton(player) end
end

TrackConnection(Players.PlayerAdded:Connect(function(player)
    AddDrawingESP(player) AddSkeleton(player)
    player.CharacterAdded:Connect(function()
        task.wait(0.2) AddDrawingESP(player) AddSkeleton(player)
    end)
end))

TrackConnection(Players.PlayerRemoving:Connect(function(player)
    RemoveDrawingESP(player) RemoveSkeleton(player) RemoveHighlight(player)
end))

TrackConnection(RunService.RenderStepped:Connect(function()
    if getgenv().VoidESPEnabled then UpdateDrawingESP() end
end))

-- ── Select & load first page ──────────────────────────────────
venyx:SelectPage(venyx.pages[1], true)

venyx:Notify("Void Universal", "Loaded! Use the UI to toggle features.")
print("[Void Universal] Loaded successfully with Venyx UI.")