-- =====================================================================
-- Fust Survival Fucker | Splix UI (Drawing-based)
-- =====================================================================
local Library, utility, pointers, theme = loadstring(game:HttpGet(
    "https://raw.githubusercontent.com/matas3535/PoopLibrary/main/Library.lua"
))()
-- Если URL недоступен: local Library, utility, pointers, theme = loadfile("Library.lua")()

local Players = game:GetService("Players")
local UIS     = game:GetService("UserInputService")
local CS      = game:GetService("CollectionService")
local RS      = game:GetService("RunService")
local WS      = game:GetService("Workspace")

local lp  = Players.LocalPlayer
local cam = WS.CurrentCamera
WS:GetPropertyChangedSignal("CurrentCamera"):Connect(function() cam = WS.CurrentCamera end)

local newc  = newcclosure or function(f) return f end
local check = checkcaller  or function() return false end

-- =====================================================================
-- STATE
-- =====================================================================
local state = {
    silentAim = false, silentAimFov = 250, silentAimHitPart = "Head",
    autoCross = false,
    aimbot = false, aimbotSmooth = 0.2, aimbotHitPart = "Head", aimbotFov = 150,
    aimAssist = false, aimAssistStrength = 0.08, aimAssistFovDeg = 10,

    playerEsp = false, npcEsp = false, entityEsp = false, tracers = false,
    longNeck = false, longNeckAmount = 5,
    espColor = Color3.fromRGB(255, 60, 60),
    entityColor = Color3.fromRGB(255, 200, 60),
    tracerColor = Color3.fromRGB(255, 60, 60),
    espRainbow = false, tracerRainbow = false,

    bulletTracers = false,
    bulletTracerColor = Color3.fromRGB(255, 200, 80),
    bulletTracerRainbow = false,
    bulletTracerLifetime = 0.4,

    fullbright = false,
    fovChanger = false, fovValue = 70,
    crosshair = false,
    crosshairColor = Color3.fromRGB(255, 255, 255),
    crosshairSize = 8,

    fovCircle = false,
    fovCircleColor = Color3.fromRGB(255, 60, 60),

    friendly = {},
}

local function rainbowColor(speed, offset)
    return Color3.fromHSV((tick() * (speed or 0.5) + (offset or 0)) % 1, 1, 1)
end
local function isFriendly(player)
    return player and state.friendly[player.Name] == true
end

-- =====================================================================
-- HELPERS
-- =====================================================================
local function getCharRoot()
    local c = lp.Character
    return c, c and c:FindFirstChild("HumanoidRootPart")
end
local function getCrosshair()
    local vp = cam and cam.ViewportSize or Vector2.new(800, 600)
    if UIS.TouchEnabled or not UIS.MouseEnabled or UIS.MouseBehavior == Enum.MouseBehavior.LockCenter then
        return Vector2.new(vp.X * 0.5, vp.Y * 0.5)
    end
    return UIS:GetMouseLocation()
end
local function getPartForModel(model, partName)
    if not model then return nil end
    if partName == "Head" then return model:FindFirstChild("Head") end
    if partName == "Torso" then return model:FindFirstChild("Torso") or model:FindFirstChild("UpperTorso") end
    return model:FindFirstChild("HumanoidRootPart") or model:FindFirstChild("Head")
end

local function getAllTargets()
    local list, seen = {}, {}
    local function add(m)
        if not m or m == lp.Character or seen[m] or not m:IsA("Model") then return end
        seen[m] = true
        local hum = m:FindFirstChildOfClass("Humanoid")
        local head = m:FindFirstChild("Head") or m:FindFirstChild("HumanoidRootPart")
            or m.PrimaryPart or m:FindFirstChildWhichIsA("BasePart")
        if hum and hum.Health > 0 and head then
            table.insert(list, { model = m, head = head, hum = hum })
        end
    end
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= lp and p.Character and not isFriendly(p) then add(p.Character) end
    end
    for _, fname in ipairs({ "Npcs", "Animals" }) do
        local f = WS:FindFirstChild(fname)
        if f then for _, m in ipairs(f:GetChildren()) do add(m) end end
    end
    for _, tag in ipairs({ "FustNpc", "FustAnimal", "FustDino" }) do
        for _, m in ipairs(CS:GetTagged(tag)) do add(m) end
    end
    return list
end

local function getPlayersOnly()
    local out = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p == lp or isFriendly(p) then continue end
        local char = p.Character
        if not char then continue end
        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hum or hum.Health <= 0 then continue end
        local head = char:FindFirstChild("Head")
        if head then table.insert(out, { model = char, head = head, player = p }) end
    end
    return out
end

-- =====================================================================
-- ENTITY ESP
-- =====================================================================
local function isEntityName(name)
    local n = name:lower()
    return n:find("dead bag") or n:find("deadbag")
        or n:find("backpack") or n:find("back pack")
        or n:find("loot bag") or n:find("lootbag")
end
local function getEntities()
    local list, seen = {}, {}
    for _, obj in ipairs(WS:GetDescendants()) do
        if obj:IsA("Model") and isEntityName(obj.Name) and not seen[obj] then
            seen[obj] = true
            local part = obj.PrimaryPart or obj:FindFirstChildWhichIsA("BasePart")
            if part then table.insert(list, { model = obj, part = part }) end
        elseif obj:IsA("BasePart") and isEntityName(obj.Name) and not seen[obj.Parent] then
            seen[obj.Parent] = true
            table.insert(list, { model = obj.Parent, part = obj })
        end
    end
    return list
end

-- =====================================================================
-- WEAK SPOT / BALLISTICS
-- =====================================================================
local function getBestWeakSpot(hitPart)
    local _, root = getCharRoot()
    if not root then return nil, nil end
    local rPos = root.Position
    if hitPart and hitPart:IsA("BasePart") then
        local node = hitPart.Parent
        while node and node ~= WS do
            if CS:HasTag(node, "FustNode") or node:GetAttribute("NodeType") ~= nil then
                local wsSpot = node:GetAttribute("WeakSpot")
                if typeof(wsSpot) == "Vector3" then return hitPart, wsSpot end
                break
            end
            node = node.Parent
        end
    end
    local bestPart, bestSpot, minDistSq = nil, nil, 196
    for _, node in ipairs(CS:GetTagged("FustNode")) do
        if node:IsDescendantOf(WS) and node:GetAttribute("Depleted") ~= true then
            local wsSpot = node:GetAttribute("WeakSpot")
            if typeof(wsSpot) == "Vector3" then
                local d = rPos - wsSpot
                local dSq = d.X*d.X + d.Y*d.Y + d.Z*d.Z
                if dSq < minDistSq then
                    minDistSq = dSq
                    bestPart  = node:FindFirstChild("Rock") or node:FindFirstChild("Trunk")
                        or node:FindFirstChildWhichIsA("BasePart") or node.PrimaryPart
                    bestSpot  = wsSpot
                end
            end
        end
    end
    return bestPart, bestSpot
end

local function getWeaponStats()
    local char = lp.Character
    local tool = char and char:FindFirstChildWhichIsA("Tool")
    local name = tool and tool.Name:lower() or ""
    if name:find("bow") or name:find("crossbow")                   then return 260, 150 end
    if name:find("revolver") or name:find("pistol") or name:find("smg") then return 450, 110 end
    if name:find("sniper") or name:find("bolt")                    then return 800,  70 end
    if name:find("rifle") or name:find("sar") or name:find("ak")    then return 650,  90 end
    return 550, 100
end

local targetVelocities, lastTargetPositions, lastVelTime = {}, {}, os.clock()
RS.Heartbeat:Connect(function()
    local now = os.clock()
    local dt  = now - lastVelTime
    if dt < 0.05 then return end
    lastVelTime = now
    for _, t in ipairs(getAllTargets()) do
        local h    = t.head
        local last = lastTargetPositions[h]
        if last then targetVelocities[h] = (h.Position - last) / dt end
        lastTargetPositions[h] = h.Position
    end
end)

-- =====================================================================
-- TARGET FINDERS
-- =====================================================================
local function getSilentAimTarget()
    if not cam then return nil end
    local curPos, minDist, best = getCrosshair(), state.silentAimFov, nil
    for _, t in ipairs(getAllTargets()) do
        local part = getPartForModel(t.model, state.silentAimHitPart) or t.head
        local sPos = cam:WorldToViewportPoint(part.Position)
        if sPos.Z > 0 then
            local dx, dy = sPos.X - curPos.X, sPos.Y - curPos.Y
            local d = math.sqrt(dx*dx + dy*dy)
            if d < minDist then minDist = d; best = part end
        end
    end
    return best
end

local function getAimbotTarget()
    if not cam then return nil end
    local vp = cam.ViewportSize
    local center = Vector2.new(vp.X / 2, vp.Y / 2)
    local best, bestDist = nil, state.aimbotFov
    for _, t in ipairs(getPlayersOnly()) do
        local part = getPartForModel(t.model, state.aimbotHitPart) or t.head
        local sPos = cam:WorldToViewportPoint(part.Position)
        if sPos.Z > 0 then
            local d = (Vector2.new(sPos.X, sPos.Y) - center).Magnitude
            if d <= bestDist then bestDist = d; best = part end
        end
    end
    return best
end

local function getAimAssistTarget()
    if not cam then return nil end
    local best = nil
    for _, t in ipairs(getPlayersOnly()) do
        local part = getPartForModel(t.model, "Head") or t.head
        local toTarget = (part.Position - cam.CFrame.Position).Unit
        if cam.CFrame.LookVector:Dot(toTarget) > math.cos(math.rad(state.aimAssistFovDeg)) then
            if not best or (part.Position - cam.CFrame.Position).Magnitude < (best.Position - cam.CFrame.Position).Magnitude then
                best = part
            end
        end
    end
    return best
end

-- =====================================================================
-- BULLET TRACERS
-- =====================================================================
local hasDrawing = (type(Drawing) == "table" and type(Drawing.new) == "function")
local bulletTracerPool = {}

local function spawnBulletTracer(fromPos, toPos)
    if not hasDrawing or not state.bulletTracers then return end
    local line = table.remove(bulletTracerPool) or Drawing.new("Line")
    line.From = fromPos; line.To = toPos
    line.Color = state.bulletTracerRainbow and rainbowColor() or state.bulletTracerColor
    line.Thickness = 2; line.Transparency = 1; line.Visible = true
    local startTime = tick()
    task.spawn(function()
        while tick() - startTime < state.bulletTracerLifetime do
            local elapsed = tick() - startTime
            line.Transparency = 1 - (elapsed / state.bulletTracerLifetime)
            task.wait(0.03)
        end
        line.Visible = false; line.Transparency = 1
        table.insert(bulletTracerPool, line)
    end)
end

-- =====================================================================
-- NAMECALL HOOK
-- =====================================================================
local oldNamecall
local function namecallHook(self, ...)
    if check() then return oldNamecall(self, ...) end
    local rawMethod = getnamecallmethod and getnamecallmethod()
    local method    = rawMethod and rawMethod:lower() or ""
    if method == "fireserver" then
        if self.Name == "Swing" and state.autoCross then
            local args = { ... }
            local payload = typeof(args[1]) == "table" and args[1] or {}
            local nodePart, weakSpot = getBestWeakSpot(payload.target)
            if weakSpot then
                payload.target = payload.target or nodePart
                payload.pos    = weakSpot
                if setnamecallmethod and rawMethod then setnamecallmethod(rawMethod) end
                return oldNamecall(self, payload)
            end
        elseif self.Name == "Shoot" then
            if state.bulletTracers and cam then
                local args = { ... }
                local payload = typeof(args[1]) == "table" and args[1] or {}
                local origin = typeof(payload.origin) == "Vector3" and payload.origin or cam.CFrame.Position
                local dir = typeof(payload.dir) == "Vector3" and payload.dir or cam.CFrame.LookVector
                local hitPos = origin + dir * 1000
                local sPos, onScreen = cam:WorldToViewportPoint(hitPos)
                if onScreen and sPos.Z > 0 then
                    spawnBulletTracer(Vector2.new(cam.ViewportSize.X / 2, cam.ViewportSize.Y),
                                      Vector2.new(sPos.X, sPos.Y))
                end
            end
            if state.silentAim then
                local target = getSilentAimTarget()
                if target then
                    local args    = { ... }
                    local payload = typeof(args[1]) == "table" and args[1] or {}
                    local origin  = typeof(payload.origin) == "Vector3" and payload.origin or (cam and cam.CFrame.Position)
                    if origin then
                        local speed, grav = getWeaponStats()
                        local vel = target.AssemblyLinearVelocity
                        if not vel or vel.Magnitude < 0.5 then vel = targetVelocities[target] or Vector3.zero end
                        local aimPos = target.Position
                        local t = (aimPos - origin).Magnitude / speed
                        aimPos = aimPos + vel * t + Vector3.new(0, 0.5 * grav * t * t, 0)
                        t = (aimPos - origin).Magnitude / speed
                        aimPos = target.Position + vel * t + Vector3.new(0, 0.5 * grav * t * t, 0)
                        payload.dir = (aimPos - origin).Unit
                        if setnamecallmethod and rawMethod then setnamecallmethod(rawMethod) end
                        return oldNamecall(self, payload)
                    end
                end
            end
        end
    end
    if setnamecallmethod and rawMethod then setnamecallmethod(rawMethod) end
    return oldNamecall(self, ...)
end
if hookmetamethod then
    oldNamecall = hookmetamethod(game, "__namecall", newc(namecallHook))
else
    local mt = getrawmetatable(game)
    oldNamecall = mt.__namecall
    setreadonly(mt, false)
    mt.__namecall = newc(namecallHook)
    setreadonly(mt, true)
end

-- =====================================================================
-- AIMBOT / AIM ASSIST / LONG NECK
-- =====================================================================
local longNeckOriginals = {}
RS.RenderStepped:Connect(function()
    if not cam then return end
    if state.aimbot then
        local target = getAimbotTarget()
        if target then
            local newCF = CFrame.lookAt(cam.CFrame.Position, target.Position)
            if state.aimbotSmooth > 0 then
                cam.CFrame = cam.CFrame:Lerp(newCF, 1 - math.clamp(state.aimbotSmooth, 0, 0.99))
            else
                cam.CFrame = newCF
            end
        end
    elseif state.aimAssist then
        local target = getAimAssistTarget()
        if target then
            cam.CFrame = cam.CFrame:Lerp(CFrame.lookAt(cam.CFrame.Position, target.Position), state.aimAssistStrength)
        end
    end
end)

task.spawn(function()
    while true do
        task.wait(0.05)
        local char = lp.Character
        local head = char and char:FindFirstChild("Head")
        local neck = head and head:FindFirstChild("Neck")
        if neck then
            if not state.longNeck then
                if longNeckOriginals[neck] then
                    neck.C0 = longNeckOriginals[neck]; longNeckOriginals[neck] = nil
                end
            else
                if not longNeckOriginals[neck] then longNeckOriginals[neck] = neck.C0 end
                local orig = longNeckOriginals[neck]
                neck.C0 = CFrame.new(orig.X, orig.Y + state.longNeckAmount, orig.Z) * orig.Rotation
            end
        end
    end
end)

-- =====================================================================
-- FULLBRIGHT / FOV / CROSSHAIR / FOV CIRCLE
-- =====================================================================
local originalLighting = {}
RS.Heartbeat:Connect(function()
    local lighting = game:GetService("Lighting")
    if state.fullbright then
        if not originalLighting.Brightness then
            originalLighting.Brightness = lighting.Brightness
            originalLighting.ClockTime = lighting.ClockTime
            originalLighting.FogEnd = lighting.FogEnd
        end
        lighting.Brightness = 2; lighting.ClockTime = 12; lighting.FogEnd = 100000
    else
        if originalLighting.Brightness then
            lighting.Brightness = originalLighting.Brightness
            lighting.ClockTime = originalLighting.ClockTime
            lighting.FogEnd = originalLighting.FogEnd
            originalLighting = {}
        end
    end
end)

RS.RenderStepped:Connect(function()
    if not cam then return end
    if state.fovChanger then cam.FieldOfView = state.fovValue end
end)

local crosshairLines = {}
if hasDrawing then
    for i = 1, 4 do
        crosshairLines[i] = Drawing.new("Line")
        crosshairLines[i].Visible = false
        crosshairLines[i].Thickness = 1.5
    end
end
RS.RenderStepped:Connect(function()
    if not hasDrawing then return end
    local vp = cam and cam.ViewportSize or Vector2.new(800, 600)
    local cx, cy = vp.X / 2, vp.Y / 2
    local s = state.crosshairSize
    for i = 1, 4 do
        local l = crosshairLines[i]
        if state.crosshair then
            l.Visible = true; l.Color = state.crosshairColor
            if i == 1 then l.From = Vector2.new(cx - s, cy); l.To = Vector2.new(cx - 2, cy)
            elseif i == 2 then l.From = Vector2.new(cx + 2, cy); l.To = Vector2.new(cx + s, cy)
            elseif i == 3 then l.From = Vector2.new(cx, cy - s); l.To = Vector2.new(cx, cy - 2)
            elseif i == 4 then l.From = Vector2.new(cx, cy + 2); l.To = Vector2.new(cx, cy + s)
            end
        else l.Visible = false end
    end
end)

local fovCircleObj = nil
if hasDrawing then
    fovCircleObj = Drawing.new("Circle")
    fovCircleObj.Visible = false
    fovCircleObj.Thickness = 1.5
    fovCircleObj.Filled = false
    fovCircleObj.Transparency = 1
    fovCircleObj.NumSides = 60
end
RS.RenderStepped:Connect(function()
    if not fovCircleObj or not cam then return end
    if state.fovCircle and state.aimbot then
        local vp = cam.ViewportSize
        fovCircleObj.Position = Vector2.new(vp.X / 2, vp.Y / 2)
        fovCircleObj.Radius = state.aimbotFov
        fovCircleObj.Color = state.fovCircleColor
        fovCircleObj.Visible = true
    else fovCircleObj.Visible = false end
end)

-- =====================================================================
-- ESP + ENTITY ESP + TRACERS
-- =====================================================================
local guiParent = (gethui and gethui())
if not guiParent then
    local ok, cg = pcall(function() return game:GetService("CoreGui") end)
    guiParent = (ok and cg) or lp:WaitForChild("PlayerGui")
end
local espFolder = Instance.new("Folder")
espFolder.Name = "ESPFolder_" .. tostring(math.random(1000, 9999))
espFolder.Parent = guiParent
local espCache = {}

local function removeEsp(model)
    local hl = espCache[model]
    if hl then hl:Destroy(); espCache[model] = nil end
end
local function applyEspToModel(model, color)
    if not model then return end
    local hl = espCache[model]
    if hl and hl.Parent == espFolder then
        hl.Adornee = model; hl.FillColor = color; hl.OutlineColor = color; return
    end
    hl = Instance.new("Highlight")
    hl.Adornee = model; hl.FillColor = color; hl.FillTransparency = 0.5
    hl.OutlineColor = color; hl.OutlineTransparency = 0
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Parent = espFolder; espCache[model] = hl
end

RS.Heartbeat:Connect(function()
    local rainbow = state.espRainbow
    if state.playerEsp then
        local col = rainbow and rainbowColor() or state.espColor
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= lp and not isFriendly(p) then
                local char = p.Character
                local hum = char and char:FindFirstChildOfClass("Humanoid")
                if hum and hum.Health > 0 then applyEspToModel(char, col) else removeEsp(char) end
            end
        end
    else
        for m in pairs(espCache) do
            if Players:GetPlayerFromCharacter(m) then removeEsp(m) end
        end
    end
    if state.npcEsp then
        local col = rainbow and rainbowColor(0.5, 0.5) or Color3.fromRGB(80, 200, 255)
        for _, t in ipairs(getAllTargets()) do
            if not Players:GetPlayerFromCharacter(t.model) then applyEspToModel(t.model, col) end
        end
    else
        for m in pairs(espCache) do
            if not Players:GetPlayerFromCharacter(m) and not isEntityName(m.Name) then removeEsp(m) end
        end
    end
    if state.entityEsp then
        for _, e in ipairs(getEntities()) do applyEspToModel(e.model, state.entityColor) end
    else
        for m in pairs(espCache) do
            if isEntityName(m.Name) then removeEsp(m) end
        end
    end
end)
Players.PlayerRemoving:Connect(removeEsp)

local tracerPool = {}
if hasDrawing then
    RS.RenderStepped:Connect(function()
        if not cam then return end
        local valid = {}
        if state.tracers then
            for _, t in ipairs(getPlayersOnly()) do
                local hum = t.model:FindFirstChildOfClass("Humanoid")
                if hum and hum.Health > 0 and t.player.Parent then
                    local sPos, onScreen = cam:WorldToViewportPoint(t.head.Position)
                    if onScreen and sPos.Z > 0 then valid[t.player] = Vector2.new(sPos.X, sPos.Y) end
                end
            end
        end
        local vp = cam.ViewportSize
        local from = Vector2.new(vp.X/2, vp.Y)
        local col  = state.tracerRainbow and rainbowColor() or state.tracerColor
        for p, line in pairs(tracerPool) do
            local target = valid[p]
            if target then
                line.From = from; line.To = target; line.Color = col; line.Visible = true
            else line.Visible = false end
        end
        for p, target in pairs(valid) do
            if not tracerPool[p] then
                local line = Drawing.new("Line")
                line.Thickness = 1.5; line.Transparency = 1
                line.From = from; line.To = target; line.Color = col; line.Visible = true
                tracerPool[p] = line
            end
        end
        for p, line in pairs(tracerPool) do
            if not p.Parent then line:Remove(); tracerPool[p] = nil end
        end
    end)
    Players.PlayerRemoving:Connect(function(p)
        local l = tracerPool[p]; if l then l:Remove(); tracerPool[p] = nil end
    end)
end

-- =====================================================================
-- UI
-- =====================================================================
local Window = Library:New({
    name = "Fust Survival Fucker",
    size = Vector2.new(560, 620),
    accent = Color3.fromRGB(120, 80, 200),
})
Window.uibind = Enum.KeyCode.RightShift

local PvPPage    = Window:Page({name = "PVP"})
local VisPage    = Window:Page({name = "Visuals"})
local UtilPage   = Window:Page({name = "Utility"})
local FriendPage = Window:Page({name = "Friendly"})
local ConfigPage = Window:Page({name = "Config"})

local PvP_Main   = PvPPage:Section({name = "Aim",  side = "left"})
local PvP_Aux    = PvPPage:Section({name = "Aux",  side = "right"})
local Vis_Players = VisPage:Section({name = "Players", side = "left"})
local Vis_Misc    = VisPage:Section({name = "Misc",    side = "right"})
local Util_Main   = UtilPage:Section({name = "World",  side = "left"})
local Friend_Main = FriendPage:Section({name = "Friendly List", side = "left"})
local Config_Main = ConfigPage:Section({name = "Config", side = "left"})

-- =====================================================================
-- PVP
-- =====================================================================
PvP_Main:Toggle({
    name = "Silent Aim", def = false, pointer = "silentAim",
    callback = function(v) state.silentAim = v end,
}):Keybind({
    keybindname = "Silent Aim", mode = "Toggle",
    callback = function(_, active) state.silentAim = active end,
})

PvP_Main:Slider({
    name = "Silent Aim FOV", min = 25, max = 1000, def = 250, suffix = "px",
    pointer = "silentAimFov",
    callback = function(v) state.silentAimFov = v end,
})

PvP_Main:Dropdown({
    name = "Silent Aim Hit Part", options = { "Head", "Torso", "HumanoidRootPart" },
    def = "Head", pointer = "silentAimHitPart",
    callback = function(v) state.silentAimHitPart = v end,
})

PvP_Aux:Toggle({
    name = "Aimbot", def = false, pointer = "aimbot",
    callback = function(v) state.aimbot = v end,
}):Keybind({
    keybindname = "Aimbot", mode = "Toggle",
    callback = function(_, active) state.aimbot = active end,
})

PvP_Aux:Slider({
    name = "Aimbot FOV (circle)", min = 50, max = 250, def = 150, suffix = "px",
    pointer = "aimbotFov",
    callback = function(v) state.aimbotFov = v end,
})

PvP_Aux:Toggle({
    name = "Show Aimbot FOV Circle", def = false, pointer = "fovCircle",
    callback = function(v) state.fovCircle = v end,
})

PvP_Aux:Colorpicker({
    name = "FOV Circle Color", info = "FOV Circle Color", def = Color3.fromRGB(255, 60, 60),
    pointer = "fovCircleColor",
    callback = function(c) state.fovCircleColor = c end,
})

PvP_Aux:Slider({
    name = "Aimbot Smoothness", min = 0, max = 1, def = 0.2, decimals = 100,
    pointer = "aimbotSmooth",
    callback = function(v) state.aimbotSmooth = v end,
})

PvP_Aux:Dropdown({
    name = "Aimbot Hit Part", options = { "Head", "Torso", "HumanoidRootPart" },
    def = "Head", pointer = "aimbotHitPart",
    callback = function(v) state.aimbotHitPart = v end,
})

PvP_Aux:Toggle({
    name = "Aim Assist", def = false, pointer = "aimAssist",
    callback = function(v) state.aimAssist = v end,
}):Keybind({
    keybindname = "Aim Assist", mode = "Toggle",
    callback = function(_, active) state.aimAssist = active end,
})

PvP_Aux:Slider({
    name = "Aim Assist Strength", min = 0.01, max = 0.5, def = 0.08, decimals = 100,
    pointer = "aimAssistStrength",
    callback = function(v) state.aimAssistStrength = v end,
})

PvP_Aux:Slider({
    name = "Aim Assist FOV", min = 1, max = 45, def = 10, suffix = "°",
    pointer = "aimAssistFov",
    callback = function(v) state.aimAssistFovDeg = v end,
})

PvP_Aux:Toggle({
    name = "Auto Cross", def = false, pointer = "autoCross",
    callback = function(v) state.autoCross = v end,
}):Keybind({
    keybindname = "Auto Cross", mode = "Toggle",
    callback = function(_, active) state.autoCross = active end,
})

-- =====================================================================
-- VISUALS
-- =====================================================================
Vis_Players:Toggle({
    name = "Player ESP", def = false, pointer = "playerEsp",
    callback = function(v) state.playerEsp = v end,
}):Keybind({
    keybindname = "Player ESP", mode = "Toggle",
    callback = function(_, active) state.playerEsp = active end,
})

Vis_Players:Toggle({
    name = "NPC ESP", def = false, pointer = "npcEsp",
    callback = function(v) state.npcEsp = v end,
}):Keybind({
    keybindname = "NPC ESP", mode = "Toggle",
    callback = function(_, active) state.npcEsp = active end,
})

Vis_Players:Toggle({
    name = "Entity ESP (dead bag / backpack)", def = false, pointer = "entityEsp",
    callback = function(v) state.entityEsp = v end,
}):Keybind({
    keybindname = "Entity ESP", mode = "Toggle",
    callback = function(_, active) state.entityEsp = active end,
})

Vis_Players:Toggle({
    name = "Tracers", def = false, pointer = "tracers",
    callback = function(v) state.tracers = v end,
}):Keybind({
    keybindname = "Tracers", mode = "Toggle",
    callback = function(_, active) state.tracers = active end,
})

Vis_Misc:Toggle({
    name = "Bullet Tracers", def = false, pointer = "bulletTracers",
    callback = function(v) state.bulletTracers = v end,
}):Keybind({
    keybindname = "Bullet Tracers", mode = "Toggle",
    callback = function(_, active) state.bulletTracers = active end,
})

Vis_Misc:Colorpicker({
    name = "Bullet Tracer Color", info = "Bullet Tracer Color", def = Color3.fromRGB(255, 200, 80),
    pointer = "bulletTracerColor",
    callback = function(c) state.bulletTracerColor = c; state.bulletTracerRainbow = false end,
})

Vis_Misc:Toggle({
    name = "Bullet Tracer Rainbow", def = false, pointer = "bulletTracerRainbow",
    callback = function(v) state.bulletTracerRainbow = v end,
})

Vis_Misc:Slider({
    name = "Bullet Tracer Lifetime", min = 0.1, max = 2, def = 0.4, suffix = "s",
    pointer = "bulletTracerLifetime",
    callback = function(v) state.bulletTracerLifetime = v end,
})

Vis_Misc:Toggle({
    name = "Long Neck", def = false, pointer = "longNeck",
    callback = function(v) state.longNeck = v end,
}):Keybind({
    keybindname = "Long Neck", mode = "Toggle",
    callback = function(_, active) state.longNeck = active end,
})

Vis_Misc:Slider({
    name = "Long Neck Amount", min = 1, max = 30, def = 5,
    pointer = "longNeckAmount",
    callback = function(v) state.longNeckAmount = v end,
})

Vis_Misc:Toggle({
    name = "Custom Crosshair", def = false, pointer = "crosshair",
    callback = function(v) state.crosshair = v end,
}):Keybind({
    keybindname = "Crosshair", mode = "Toggle",
    callback = function(_, active) state.crosshair = active end,
})

Vis_Misc:Colorpicker({
    name = "Crosshair Color", info = "Crosshair Color", def = Color3.fromRGB(255, 255, 255),
    pointer = "crosshairColor",
    callback = function(c) state.crosshairColor = c end,
})

Vis_Misc:Slider({
    name = "Crosshair Size", min = 2, max = 20, def = 8,
    pointer = "crosshairSize",
    callback = function(v) state.crosshairSize = v end,
})

-- =====================================================================
-- UTILITY
-- =====================================================================
Util_Main:Toggle({
    name = "Fullbright", def = false, pointer = "fullbright",
    callback = function(v) state.fullbright = v end,
}):Keybind({
    keybindname = "Fullbright", mode = "Toggle",
    callback = function(_, active) state.fullbright = active end,
})

Util_Main:Toggle({
    name = "FOV Changer", def = false, pointer = "fovChanger",
    callback = function(v) state.fovChanger = v end,
}):Keybind({
    keybindname = "FOV", mode = "Toggle",
    callback = function(_, active) state.fovChanger = active end,
})

Util_Main:Slider({
    name = "FOV Value", min = 30, max = 120, def = 70,
    pointer = "fovValue",
    callback = function(v) state.fovValue = v end,
})


local friendlyButtons = {}  -- [playerName] = {toggleObj, removeBtn}
local friendlySection = Friend_Main

local function buildFriendlyButtons()
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= lp and not friendlyButtons[p.Name] then
            local name = p.Name
            local added = false
            
            local addBtn = friendlySection:Button({
                name = "Add " .. name,
                callback = function()
                    state.friendly[name] = true
                    added = true
                    print("[FSF] Friendly +", name)
                end,
            })
        
            local remBtn = friendlySection:Button({
                name = "Remove " .. name,
                callback = function()
                    state.friendly[name] = nil
                    print("[FSF] Friendly -", name)
                end,
            })
            friendlyButtons[p.Name] = { add = addBtn, rem = remBtn }
        end
    end
end

friendlySection:Label({
    name = "Add/Remove button for each player.\n(No text input in Splix UI)",
    middle = false,
})

friendlySection:Button({
    name = "Refresh player list",
    callback = function()
        buildFriendlyButtons()
        print("[FSF] Friendly list refreshed")
    end,
})

friendlySection:Button({
    name = "Clear friendly list",
    callback = function()
        state.friendly = {}
        print("[FSF] Friendly list cleared")
    end,
})


task.spawn(function()
    task.wait(1)
    buildFriendlyButtons()
end)


local CONFIG_FOLDER = "splix/configs"
if isfolder and makefolder and not isfolder(CONFIG_FOLDER) then pcall(makefolder, CONFIG_FOLDER) end

local currentSlot = 1
local function cfgPath(slot) return CONFIG_FOLDER .. "/fsf_slot_" .. tostring(slot) .. ".json" end

local cfgBox = Config_Main:ConfigBox({})
if cfgBox and cfgBox.Set then
    local origSet = cfgBox.Set
    cfgBox.Set = function(self, slot)
        origSet(self, slot)
        currentSlot = slot or 1
    end
end

Config_Main:ButtonHolder({buttons = {
    { "Save", function()
        local path = cfgPath(currentSlot)
        local ok, data = pcall(function() return Window:GetConfig() end)
        if not ok or not data then return print("[FSF] GetConfig failed") end
        local ok2, err = pcall(writefile, path, data)
        print(ok2 and ("[FSF] Saved slot " .. currentSlot) or ("[FSF] Save failed: " .. tostring(err)))
    end },
    { "Load", function()
        local path = cfgPath(currentSlot)
        if not (isfile and isfile(path)) then return print("[FSF] No config") end
        local ok, data = pcall(readfile, path)
        if not ok or not data then return print("[FSF] Read failed") end
        local ok2, err = pcall(function() Window:LoadConfig(data) end)
        print(ok2 and ("[FSF] Loaded slot " .. currentSlot) or ("[FSF] Load failed: " .. tostring(err)))
    end },
}})

Config_Main:Button({ name = "Unload", callback = function()
    for p, l in pairs(tracerPool) do if l.Remove then l:Remove() end; tracerPool[p] = nil end
    for _, l in pairs(bulletTracerPool) do if l and l.Remove then l:Remove() end end
    for _, l in pairs(crosshairLines) do if l and l.Remove then l:Remove() end end
    if fovCircleObj and fovCircleObj.Remove then fovCircleObj:Remove() end
    for m in pairs(espCache) do removeEsp(m) end
    local char = lp.Character
    local head = char and char:FindFirstChild("Head")
    local neck = head and head:FindFirstChild("Neck")
    if neck and longNeckOriginals[neck] then
        neck.C0 = longNeckOriginals[neck]; longNeckOriginals[neck] = nil
    end
    for k in pairs(state) do
        if type(state[k]) == "boolean" then state[k] = false end
    end
    Window:Unload()
end })


Window:Initialize()