V1rpSaken script but i change the library from WindUI into Orion Library (NOT MY SCRIPT)

print("v1prware loaded")

------------------------------------------------------------------------
-- services
------------------------------------------------------------------------
local svc = {
    Players      = game:GetService("Players"),
    Run          = game:GetService("RunService"),
    Input        = game:GetService("UserInputService"),
    RS           = game:GetService("ReplicatedStorage"),
    WS           = game:GetService("Workspace"),
    TweenService = game:GetService("TweenService"),
    TextChat     = game:GetService("TextChatService"),
    Http         = game:GetService("HttpService"),
}

local lp  = svc.Players.LocalPlayer
local gui = lp:WaitForChild("PlayerGui", 10)

------------------------------------------------------------------------
-- filesystem shims
------------------------------------------------------------------------
local fs = {
    hasFolder = isfolder   or function() return false end,
    makeFolder= makefolder or function() end,
    write     = writefile  or function() end,
    hasFile   = isfile     or function() return false end,
    read      = readfile   or function() return "" end,
    asset     = getcustomasset or function(p) return p end,
}

------------------------------------------------------------------------
-- config
------------------------------------------------------------------------
local cfg = {}
do
    local DIR  = "GlovSakenScript"
    local FILE = DIR .. "/config.json"
    local function prep()
        if not fs.hasFolder(DIR) then fs.makeFolder(DIR) end
    end
    function cfg.load()
        prep()
        if not fs.hasFile(FILE) then return end
        local ok, t = pcall(svc.Http.JSONDecode, svc.Http, fs.read(FILE))
        if ok and type(t) == "table" then cfg._data = t end
    end
    function cfg.save()
        prep()
        local ok, s = pcall(svc.Http.JSONEncode, svc.Http, cfg._data)
        if ok then fs.write(FILE, s) end
    end
    function cfg.get(k, default)
        local v = cfg._data[k]
        return v ~= nil and v or default
    end
    function cfg.set(k, v)
        cfg._data[k] = v
        cfg.save()
    end
    cfg._data = {}
    cfg.load()
end

------------------------------------------------------------------------
-- Orion Library
------------------------------------------------------------------------
local OrionLib = loadstring(game:HttpGet(('https://raw.githubusercontent.com/jensonhirst/Orion/main/source')))()

local win = OrionLib:MakeWindow({
    Name         = "V1PRWARE",
    HidePremium  = false,
    SaveConfig   = true,
    ConfigFolder = "GlovSakenScript",
    IntroEnabled = true,
    IntroText    = "V1PRWARE",
})

------------------------------------------------------------------------
-- helpers
------------------------------------------------------------------------
local function getTeamFolder(name)
    local root = svc.WS:FindFirstChild("Players")
    return root and root:FindFirstChild(name)
end
local function getIngame()
    local m = svc.WS:FindFirstChild("Map")
    return m and m:FindFirstChild("Ingame")
end
local function getMapContent()
    local ig = getIngame()
    return ig and ig:FindFirstChild("Map")
end

------------------------------------------------------------------------
-- TAB: SETTINGS
------------------------------------------------------------------------
local tabSettings = win:MakeTab({ Name = "Settings", Icon = "rbxassetid://7059346386", PremiumOnly = false })

tabSettings:AddLabel("Interface")

-- Username Spoof
local spoofActive = cfg.get("spoofActive", false)
local spoofText   = cfg.get("spoofText",   "V1PRWARE")
local spoofCache  = {}
local spoofConns  = {}

local function spoofApply(lbl)
    if not (lbl:IsA("TextLabel") or lbl:IsA("TextButton")) then return end
    if lbl.Name ~= "Username" then return end
    if not spoofCache[lbl] then spoofCache[lbl] = lbl.Text end
    if spoofActive then lbl.Text = spoofText end
end
local function spoofRevert()
    for lbl, orig in pairs(spoofCache) do
        if lbl and lbl.Parent then lbl.Text = orig end
    end
    spoofCache = {}
end
local function spoofScan()
    local pg = lp:FindFirstChild("PlayerGui"); if not pg then return end
    task.defer(function()
        for _, root in ipairs({ pg:FindFirstChild("MainUI"), pg:FindFirstChild("TemporaryUI") }) do
            if root then
                for _, obj in ipairs(root:GetDescendants()) do spoofApply(obj) end
            end
        end
    end)
end
local function spoofWatch(root)
    if not root then return end
    local c = root.DescendantAdded:Connect(function(obj)
        if spoofActive then task.defer(spoofApply, obj) end
    end)
    table.insert(spoofConns, c)
end
local function spoofStart()
    for _, c in ipairs(spoofConns) do if c.Connected then c:Disconnect() end end
    spoofConns = {}
    local pg = lp:FindFirstChild("PlayerGui"); if not pg then return end
    spoofScan()
    spoofWatch(pg:FindFirstChild("MainUI"))
    spoofWatch(pg:FindFirstChild("TemporaryUI"))
    table.insert(spoofConns, pg.ChildAdded:Connect(function(child)
        if (child.Name == "MainUI" or child.Name == "TemporaryUI") and spoofActive then
            task.delay(0.1, spoofScan)
            spoofWatch(child)
        end
    end))
end
local function spoofStop()
    for _, c in ipairs(spoofConns) do if c.Connected then c:Disconnect() end end
    spoofConns = {}
    spoofRevert()
end

tabSettings:AddToggle({
    Name    = "Spoof Usernames",
    Default = spoofActive,
    Callback = function(on)
        spoofActive = on; cfg.set("spoofActive", on)
        if on then spoofStart() else spoofStop() end
    end
})

-- Chat Force
local chatForceEnabled = cfg.get("chatForceEnabled", false)
local chatForceConn    = nil
local function enforceChatOn()
    if not chatForceEnabled then return end
    local cw = svc.TextChat:FindFirstChild("ChatWindowConfiguration")
    local ci = svc.TextChat:FindFirstChild("ChatInputBarConfiguration")
    if cw and not cw.Enabled then cw.Enabled = true end
    if ci and not ci.Enabled then ci.Enabled = true end
end

tabSettings:AddToggle({
    Name    = "Show Chat Logs",
    Default = chatForceEnabled,
    Callback = function(on)
        chatForceEnabled = on; cfg.set("chatForceEnabled", on)
        if chatForceConn then chatForceConn:Disconnect(); chatForceConn = nil end
        if on then
            enforceChatOn()
            chatForceConn = svc.Run.Heartbeat:Connect(enforceChatOn)
        end
    end
})

-- Timer Position
local timerSide = cfg.get("timerSide", "Middle")
local function applyTimerPos()
    local rt = lp.PlayerGui:FindFirstChild("RoundTimer")
    local m  = rt and rt:FindFirstChild("Main")
    if m then
        m.Position = UDim2.new(timerSide == "Middle" and 0.5 or 0.9, 0,
                               m.Position.Y.Scale, m.Position.Y.Offset)
    end
end
applyTimerPos()

tabSettings:AddDropdown({
    Name    = "Timer Position",
    Default = timerSide,
    Options = { "Middle", "Right" },
    Callback = function(v)
        timerSide = v; cfg.set("timerSide", v); applyTimerPos()
    end
})

tabSettings:AddLabel("Platform Spoofer")

local platEnabled = cfg.get("platEnabled", false)
local platDevice  = cfg.get("platDevice",  "Console")
local platLoop    = nil
local platConn    = nil

local function platPush()
    if not platEnabled then return end
    local ok, net = pcall(function() return require(svc.RS.Modules.Network) end)
    if ok and net then
        pcall(function() net:FireServerConnection("SetDevice", "REMOTE_EVENT", platDevice) end)
    end
end
local function platStart()
    if platLoop then return end
    platPush()
    if platConn then platConn:Disconnect() end
    platConn = svc.Input.LastInputTypeChanged:Connect(function()
        if platEnabled then platPush() end
    end)
    platLoop = task.spawn(function()
        while platEnabled do platPush(); task.wait(1) end
        platLoop = nil
    end)
end
local function platStop()
    platEnabled = false
    if platLoop then task.cancel(platLoop); platLoop = nil end
    if platConn then platConn:Disconnect(); platConn = nil end
end

tabSettings:AddToggle({
    Name    = "Enable Platform Spoofer",
    Default = platEnabled,
    Callback = function(on)
        platEnabled = on; cfg.set("platEnabled", on)
        if on then platStart() else platStop() end
    end
})
tabSettings:AddDropdown({
    Name    = "Device",
    Default = platDevice,
    Options = { "PC", "Mobile", "Console" },
    Callback = function(v)
        platDevice = v; cfg.set("platDevice", v)
        if platEnabled then platPush() end
    end
})

lp.CharacterAdded:Connect(function()
    task.delay(1, function()
        if spoofActive then spoofStart() end
        applyTimerPos()
        if platEnabled then platPush() end
    end)
end)

------------------------------------------------------------------------
-- TAB: GLOBAL
------------------------------------------------------------------------
local tabGlobal = win:MakeTab({ Name = "Global", Icon = "rbxassetid://7706157525", PremiumOnly = false })

tabGlobal:AddLabel("Stamina")

local stam = {
    on      = cfg.get("stamOn",      false),
    loss    = cfg.get("stamLoss",    10),
    gain    = cfg.get("stamGain",    20),
    max     = cfg.get("stamMax",     100),
    current = cfg.get("stamCurrent", 100),
    noLoss  = cfg.get("stamNoLoss",  false),
    thread  = nil,
}
local function stamModule()
    local ok, m = pcall(function()
        return require(svc.RS.Systems.Character.Game.Sprinting)
    end)
    return ok and m or nil
end
local function stamApply()
    local m = stamModule(); if not m then return end
    if not m.DefaultsSet then pcall(function() m.Init() end) end
    m.StaminaLoss         = stam.loss
    m.StaminaGain         = stam.gain
    m.MaxStamina          = stam.max
    m.StaminaLossDisabled = stam.noLoss
    if m.Stamina and m.Stamina > stam.max then m.Stamina = stam.current end
    pcall(function()
        if m.__staminaChangedEvent then m.__staminaChangedEvent:Fire() end
    end)
end
local function stamStart()
    if stam.thread then return end
    stam.thread = task.spawn(function()
        while stam.on do
            if lp.Character and lp.Character:FindFirstChild("HumanoidRootPart") then
                stamApply()
            end
            task.wait(0.5)
        end
        stam.thread = nil
    end)
end
local function stamStop()
    stam.on = false
    if stam.thread then task.cancel(stam.thread); stam.thread = nil end
end

tabGlobal:AddToggle({
    Name    = "Custom Stamina",
    Default = stam.on,
    Callback = function(on)
        stam.on = on; cfg.set("stamOn", on)
        if on then stamStart() else stamStop() end
    end
})
tabGlobal:AddSlider({
    Name = "Loss Rate", Min = 0, Max = 50, Default = stam.loss,
    Callback = function(v) stam.loss = v; cfg.set("stamLoss", v) end
})
tabGlobal:AddSlider({
    Name = "Gain Rate", Min = 0, Max = 50, Default = stam.gain,
    Callback = function(v) stam.gain = v; cfg.set("stamGain", v) end
})
tabGlobal:AddSlider({
    Name = "Max Pool", Min = 50, Max = 500, Default = stam.max,
    Callback = function(v) stam.max = v; cfg.set("stamMax", v) end
})
tabGlobal:AddSlider({
    Name = "Current Value", Min = 0, Max = 500, Default = stam.current,
    Callback = function(v) stam.current = v; cfg.set("stamCurrent", v) end
})
tabGlobal:AddToggle({
    Name    = "Infinite Stamina",
    Default = stam.noLoss,
    Callback = function(on)
        stam.noLoss = on; cfg.set("stamNoLoss", on)
    end
})

if stam.on then stamStart() end

lp.CharacterAdded:Connect(function()
    task.delay(1.5, function()
        if stam.on then
            stamApply()
            if not stam.thread then stamStart() end
        end
    end)
end)

-- Status
tabGlobal:AddLabel("Status Effects")

local statusGroups = {
    Slowness      = { on = false, paths = { "Modules.StatusEffects.Slowness" } },
    Hallucination = { on = false, paths = { "Modules.StatusEffects.KillerExclusive.Hallucination" } },
    Visual        = { on = false, paths = {
        "Modules.StatusEffects.Blindness",
        "Modules.StatusEffects.KillerExclusive.Glitched",
        "Modules.StatusEffects.SurvivorExclusive.Subspaced",
    }},
}
local statusBackup = {}
local function statusResolve(path)
    local node = svc.RS
    for seg in path:gmatch("[^%.]+") do
        node = node:FindFirstChild(seg)
        if not node then return nil end
    end
    return node
end
local function statusBlock(path)
    if statusBackup[path] then return end
    local mod = statusResolve(path)
    if mod and mod:IsA("ModuleScript") then
        statusBackup[path] = { clone = mod:Clone(), src = mod.Source }
        mod:Destroy()
    end
end
local function statusRestore(path)
    local saved = statusBackup[path]; if not saved then return end
    local existing = statusResolve(path)
    if existing then existing:Destroy() end
    local parentPath = path:match("^(.-)%.?[^%.]+$")
    local parent = statusResolve(parentPath)
    if parent then
        saved.clone.Source = saved.src
        saved.clone.Parent = parent
    end
    statusBackup[path] = nil
end
local statusLoopThread = nil
local function statusTick()
    if statusLoopThread then return end
    statusLoopThread = task.spawn(function()
        while true do
            local any = false
            for _, g in pairs(statusGroups) do
                if g.on then
                    any = true
                    for _, p in ipairs(g.paths) do
                        local m = statusResolve(p)
                        if m then m:Destroy() end
                    end
                end
            end
            if not any then break end
            task.wait(0.8)
        end
        statusLoopThread = nil
    end)
end
local function statusToggle(name)
    local g = statusGroups[name]; if not g then return end
    g.on = not g.on
    for _, p in ipairs(g.paths) do
        if g.on then statusBlock(p) else statusRestore(p) end
    end
    local any = false
    for _, sg in pairs(statusGroups) do if sg.on then any = true; break end end
    if any then statusTick()
    elseif statusLoopThread then
        task.cancel(statusLoopThread); statusLoopThread = nil
    end
end

tabGlobal:AddButton({ Name = "Toggle: Slowness",       Callback = function() statusToggle("Slowness")      end })
tabGlobal:AddButton({ Name = "Toggle: Hallucination",  Callback = function() statusToggle("Hallucination") end })
tabGlobal:AddButton({ Name = "Toggle: Visual Effects", Callback = function() statusToggle("Visual")        end })

lp.CharacterAdded:Connect(function()
    statusBackup = {}
    for _, g in pairs(statusGroups) do g.on = false end
    if statusLoopThread then task.cancel(statusLoopThread); statusLoopThread = nil end
end)

-- Network
tabGlobal:AddLabel("Network")

local net = { ghost = false, lag = false, block = false, lagRunning = false }
local function netGhostOn()  net.block = true end
local function netGhostOff() net.block = net.lag end
local function netLagOn()
    if net.lagRunning then return end
    net.lagRunning = true
    task.spawn(function()
        while net.lag do
            net.block = true;  task.wait(2)
            if not net.lag then break end
            net.block = false; task.wait(2)
        end
        net.lagRunning = false
    end)
end
local function netLagOff() net.lagRunning = false; net.block = net.ghost end

lp.CharacterAdded:Connect(function()
    net.ghost = false; net.lag = false; net.block = false; net.lagRunning = false
end)

task.spawn(function()
    local mods = svc.RS:FindFirstChild("Modules"); if not mods then return end
    local netf  = mods:FindFirstChild("Network");  if not netf  then return end
    local ure   = netf:FindFirstChild("UnreliableRemoteEvent"); if not ure then return end
    local old
    old = hookmetamethod(game, "__namecall", function(self, ...)
        if getnamecallmethod() == "FireServer" and self == ure then
            local a = {...}
            if #a > 0 and a[1] == "UpdCF" and net.block then return end
        end
        return old(self, ...)
    end)
end)

tabGlobal:AddToggle({
    Name = "Ghost Mode", Default = false,
    Callback = function(on)
        net.ghost = on
        if on then netGhostOn() else netGhostOff() end
    end
})
tabGlobal:AddToggle({
    Name = "Lag Mode", Default = false,
    Callback = function(on)
        net.lag = on
        if on then netLagOn() else netLagOff() end
    end
})

-- Hitbox
tabGlobal:AddLabel("Hitbox")

local hb = {
    on       = cfg.get("hbOn",       false),
    strength = cfg.get("hbStrength", 50),
    conn     = nil,
    active   = {},
}
local hbAbilities = {
    Slash=1,Swing=1,Dagger=1,Charge=1,Punch=1,PlasmaBeam=1,
    Shoot=1,Behead=1,GashingWound=1,CorruptNature=1,
    WalkspeedOverride=1,Stab=1,Nova=1,MassInfection=1,Entanglement=1,
}
local hbRemote = svc.RS
    :WaitForChild("Modules")
    :WaitForChild("Network")
    :WaitForChild("RemoteEvent")

local function hbReadName(raw)
    if typeof(raw) == "buffer" then
        local s = buffer.tostring(raw)
        return s:match("[%a]+") or s:gsub("[^%w]", "")
    end
    return tostring(raw):gsub("\"", "")
end
local function hbPush(dist)
    local ch = lp.Character; if not ch then return end
    local r  = ch:FindFirstChild("HumanoidRootPart"); if not r then return end
    local was = r.AssemblyLinearVelocity
    r.AssemblyLinearVelocity = was + r.CFrame.LookVector * dist
    svc.Run.RenderStepped:Wait()
    if ch and ch.Parent and r and r.Parent then
        r.AssemblyLinearVelocity = was
    end
end
local function hbStart()
    if hb.conn then return end
    hb.conn = hbRemote.OnClientEvent:Connect(function(action, data)
        if not hb.on then return end
        if action ~= "UseActorAbility" then return end
        if typeof(data) ~= "table" or not data[1] then return end
        local name = hbReadName(data[1])
        if not name or not hbAbilities[name] or hb.active[name] then return end
        hb.active[name] = true
        local t0 = tick()
        local c; c = svc.Run.Heartbeat:Connect(function()
            if tick() - t0 >= 1 then c:Disconnect(); hb.active[name] = nil; return end
            if hb.on then hbPush(hb.strength)
            else c:Disconnect(); hb.active[name] = nil end
        end)
    end)
end
local function hbStop()
    if hb.conn then hb.conn:Disconnect(); hb.conn = nil end
    for k in pairs(hb.active) do hb.active[k] = nil end
end

tabGlobal:AddToggle({
    Name = "Hitbox Expander", Default = hb.on,
    Callback = function(on)
        hb.on = on; cfg.set("hbOn", on)
        if on then hbStart() else hbStop() end
    end
})
tabGlobal:AddSlider({
    Name = "Hitbox Strength", Min = 5, Max = 100, Default = hb.strength,
    Callback = function(v) hb.strength = v; cfg.set("hbStrength", v) end
})

lp.CharacterAdded:Connect(function()
    for k in pairs(hb.active) do hb.active[k] = nil end
    task.delay(1, function() if hb.on then hbStop(); hbStart() end end)
end)
lp.CharacterRemoving:Connect(function()
    for k in pairs(hb.active) do hb.active[k] = nil end
end)

------------------------------------------------------------------------
-- TAB: GENERATOR
------------------------------------------------------------------------
local tabGen = win:MakeTab({ Name = "Generator", Icon = "rbxassetid://125543574844651", PremiumOnly = false })
tabGen:AddLabel("Auto Solve")

local flow = {
    on        = cfg.get("flowOn",        false),
    nodeDelay = cfg.get("flowNodeDelay", 0.04),
    lineDelay = cfg.get("flowLineDelay", 0.60),
}
local function flowKey(n) return n.row .. "-" .. n.col end
local function flowDir(r1,c1,r2,c2)
    if r2<r1 then return "up" end
    if r2>r1 then return "down" end
    if c2<c1 then return "left" end
    if c2>c1 then return "right" end
end
local function flowDirFlip(d)
    return ({up="down",down="up",left="right",right="left"})[d]
end
local function flowNeighbour(r1,c1,r2,c2)
    if r2==r1-1 and c2==c1 then return "up" end
    if r2==r1+1 and c2==c1 then return "down" end
    if r2==r1 and c2==c1-1 then return "left" end
    if r2==r1 and c2==c1+1 then return "right" end
    return false
end
local function flowConnections(prev,curr,nxt)
    local t={}
    if prev and curr then
        local d=flowDir(curr.row,curr.col,prev.row,prev.col)
        if d then t[flowDirFlip(d)]=true end
    end
    if nxt and curr then
        local d=flowDir(curr.row,curr.col,nxt.row,nxt.col)
        if d then t[d]=true end
    end
    return t
end
local function flowOrder(path,endpoints)
    if not path or #path==0 then return path end
    local lookup={}
    for _,n in ipairs(path) do lookup[flowKey(n)]=n end
    local start
    for _,ep in ipairs(endpoints or {}) do
        for _,n in ipairs(path) do
            if n.row==ep.row and n.col==ep.col then
                start={row=ep.row,col=ep.col}; break
            end
        end
        if start then break end
    end
    if not start then
        for _,n in ipairs(path) do
            local nb=0
            for _,d in ipairs({{-1,0},{1,0},{0,-1},{0,1}}) do
                if lookup[(n.row+d[1]).."-"..(n.col+d[2])] then nb+=1 end
            end
            if nb==1 then start={row=n.row,col=n.col}; break end
        end
    end
    if not start then start={row=path[1].row,col=path[1].col} end
    local pool={};local ordered={}
    for _,n in ipairs(path) do pool[flowKey(n)]={row=n.row,col=n.col} end
    local cur=start
    table.insert(ordered,{row=cur.row,col=cur.col})
    pool[flowKey(cur)]=nil
    while next(pool) do
        local moved=false
        for k,node in pairs(pool) do
            if flowNeighbour(cur.row,cur.col,node.row,node.col) then
                table.insert(ordered,{row=node.row,col=node.col})
                pool[k]=nil; cur=node; moved=true; break
            end
        end
        if not moved then break end
    end
    return ordered
end
local function flowSolve(puzzle)
    if not puzzle or not puzzle.Solution then return end
    local indices={}
    for i=1,#puzzle.Solution do indices[i]=i end
    for i=#indices,2,-1 do
        local j=math.random(1,i); indices[i],indices[j]=indices[j],indices[i]
    end
    for _,ci in ipairs(indices) do
        local ordered=flowOrder(puzzle.Solution[ci],puzzle.targetPairs[ci])
        puzzle.paths[ci]={}
        for i,node in ipairs(ordered) do
            table.insert(puzzle.paths[ci],{row=node.row,col=node.col})
            puzzle.gridConnections=puzzle.gridConnections or {}
            puzzle.gridConnections[flowKey(node)]=flowConnections(ordered[i-1],node,ordered[i+1])
            puzzle:updateGui()
            task.wait(flow.nodeDelay)
        end
        task.wait(flow.lineDelay)
        puzzle:checkForWin()
    end
end

do
    local mod = svc.RS:FindFirstChild("Modules")
        and svc.RS.Modules:FindFirstChild("Misc")
        and svc.RS.Modules.Misc:FindFirstChild("FlowGameManager")
        and svc.RS.Modules.Misc.FlowGameManager:FindFirstChild("FlowGame")
    if mod then
        local FG = require(mod)
        local original = FG.new
        FG.new = function(...)
            local puzzle = original(...)
            if flow.on then
                task.spawn(function() task.wait(0.3); flowSolve(puzzle) end)
            end
            return puzzle
        end
    end
end

tabGen:AddToggle({
    Name = "Auto Solve", Default = flow.on,
    Callback = function(on) flow.on = on; cfg.set("flowOn", on) end
})
tabGen:AddSlider({
    Name = "Node Speed", Min = 0.01, Max = 0.50, Default = flow.nodeDelay,
    Callback = function(v) flow.nodeDelay = v; cfg.set("flowNodeDelay", v) end
})
tabGen:AddSlider({
    Name = "Line Pause", Min = 0.00, Max = 1.00, Default = flow.lineDelay,
    Callback = function(v) flow.lineDelay = v; cfg.set("flowLineDelay", v) end
})

------------------------------------------------------------------------
-- TAB: KILLER
------------------------------------------------------------------------
local tabKiller = win:MakeTab({ Name = "Killer", Icon = "rbxassetid://9583486354", PremiumOnly = false })

tabKiller:AddLabel("Aimbot")

local aim = {
    on         = cfg.get("aimOn",        false),
    cooldown   = cfg.get("aimCooldown",  0.3),
    lockTime   = cfg.get("aimLockTime",  0.4),
    maxDist    = cfg.get("aimMaxDist",   30),
    smooth     = cfg.get("aimSmooth",    0.35),
    targeting  = false,
    target     = nil,
    deathConn  = nil,
    autoRotate = nil,
    lastFired  = 0,
    hum        = nil,
    hrp        = nil,
    cache      = {},
    cacheTime  = 0,
    cacheLife  = 0.5,
}
local function aimAmIKiller()
    local ch = lp.Character; if not ch then return false end
    local kf = getTeamFolder("Killers")
    return kf and ch:IsDescendantOf(kf)
end
local function aimRefreshChar(ch)
    aim.hum = ch:FindFirstChildOfClass("Humanoid")
    aim.hrp = ch:FindFirstChild("HumanoidRootPart")
end
local function aimRefreshTargets()
    local now = tick()
    if now - aim.cacheTime < aim.cacheLife then return end
    aim.cacheTime = now; aim.cache = {}
    local sf = getTeamFolder("Survivors"); if not sf then return end
    for _, model in ipairs(sf:GetChildren()) do
        if model ~= lp.Character and model:IsA("Model") then
            local h = model:FindFirstChildOfClass("Humanoid")
            local r = model:FindFirstChild("HumanoidRootPart")
            if h and r and h.Health > 0 then
                table.insert(aim.cache, r)
            end
        end
    end
end
local function aimNearest()
    aimRefreshTargets()
    if not aim.hrp or #aim.cache == 0 then return nil end
    local best, bd = nil, math.huge
    for _, r in ipairs(aim.cache) do
        local d = (r.Position - aim.hrp.Position).Magnitude
        if d < bd and d <= aim.maxDist then bd = d; best = r end
    end
    return best
end
local function aimUnlock()
    if not aim.targeting then return end
    if aim.deathConn then aim.deathConn:Disconnect(); aim.deathConn = nil end
    if aim.autoRotate ~= nil and aim.hum then aim.hum.AutoRotate = aim.autoRotate end
    aim.targeting = false; aim.target = nil
end
local function aimLock(r)
    if not r or not r.Parent or not aim.hum or not aim.hrp then return end
    if aim.targeting and aim.target == r then return end
    aimUnlock()
    aim.target = r; aim.targeting = true
    aim.autoRotate = aim.hum.AutoRotate; aim.hum.AutoRotate = false
    local th = r.Parent:FindFirstChildOfClass("Humanoid")
    if th then aim.deathConn = th.Died:Connect(aimUnlock) end
    task.delay(aim.lockTime, function()
        if aim.target == r then aimUnlock() end
    end)
end

svc.Run.RenderStepped:Connect(function()
    if not aim.on or not aim.targeting or not aim.hrp or not aim.target then return end
    if not aim.target.Parent then aimUnlock(); return end
    local th = aim.target.Parent:FindFirstChildOfClass("Humanoid")
    if not th or th.Health <= 0 then aimUnlock(); return end
    local flat = Vector3.new(
        aim.target.Position.X - aim.hrp.Position.X, 0,
        aim.target.Position.Z - aim.hrp.Position.Z
    ).Unit
    if flat.Magnitude > 0 then
        aim.hrp.CFrame = aim.hrp.CFrame:Lerp(
            CFrame.new(aim.hrp.Position, aim.hrp.Position + flat), aim.smooth
        )
    end
end)

do
    local remote
    pcall(function()
        remote = svc.RS:WaitForChild("Modules",10):WaitForChild("Network",10):WaitForChild("RemoteEvent",10)
    end)
    if remote then
        remote.OnClientEvent:Connect(function(...)
            if not aim.on then return end
            local a = {...}
            if typeof(a[1]) ~= "string" then return end
            local n = a[1]
            if not (n:match("Ability") or n:match("[QER]") or n=="Slash" or n=="Dagger" or n=="Charge") then return end
            if tick() - aim.lastFired < aim.cooldown then return end
            aim.lastFired = tick()
            if aimAmIKiller() then
                local t = aimNearest()
                if t then aimLock(t) end
            end
        end)
    end
end

lp.CharacterAdded:Connect(function(ch) task.wait(0.5); aimRefreshChar(ch) end)
if lp.Character then aimRefreshChar(lp.Character) end

tabKiller:AddToggle({
    Name = "Enable Aimbot", Default = aim.on,
    Callback = function(on)
        aim.on = on; cfg.set("aimOn", on)
        if not on then aimUnlock() end
    end
})
tabKiller:AddSlider({
    Name = "Cooldown (s)", Min = 0.1, Max = 2.0, Default = aim.cooldown,
    Callback = function(v) aim.cooldown = v; cfg.set("aimCooldown", v) end
})
tabKiller:AddSlider({
    Name = "Lock Time (s)", Min = 0.1, Max = 3.0, Default = aim.lockTime,
    Callback = function(v) aim.lockTime = v; cfg.set("aimLockTime", v) end
})
tabKiller:AddSlider({
    Name = "Max Distance", Min = 5, Max = 100, Default = aim.maxDist,
    Callback = function(v) aim.maxDist = v; cfg.set("aimMaxDist", v) end
})
tabKiller:AddSlider({
    Name = "Rotation Smoothing", Min = 0.05, Max = 1.0, Default = aim.smooth,
    Callback = function(v) aim.smooth = v; cfg.set("aimSmooth", v) end
})

-- Anti-Backstab
tabKiller:AddLabel("Anti-Backstab")

local abs = {
    on       = cfg.get("absOn",    false),
    range    = cfg.get("absRange", 40),
    duration = cfg.get("absDur",   1.5),
    locked   = false,
    soundConn  = nil,
    scanThread = nil,
    rings      = {},
}
local absTriggerSounds = { ["86710781315432"]=true, ["99820161736138"]=true }
local absScreenGui = nil
local function absGui()
    if absScreenGui and absScreenGui.Parent then return absScreenGui end
    local pg = lp:FindFirstChild("PlayerGui"); if not pg then return nil end
    absScreenGui = Instance.new("ScreenGui")
    absScreenGui.Name = "AbsGui"
    absScreenGui.ResetOnSpawn = false
    absScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
    absScreenGui.Parent = pg
    return absScreenGui
end
local function absShowLabel(show)
    local g = absGui(); if not g then return end
    local lbl = g:FindFirstChild("AbsTaunt")
    if not lbl then
        lbl = Instance.new("TextLabel")
        lbl.Name = "AbsTaunt"
        lbl.Size = UDim2.new(0,500,0,50)
        lbl.Position = UDim2.new(0.5,-250,0.38,0)
        lbl.BackgroundTransparency = 1
        lbl.TextColor3 = Color3.new(1,1,1)
        lbl.TextStrokeTransparency = 0.4
        lbl.TextStrokeColor3 = Color3.new(0,0,0)
        lbl.Text = "At least they tried 😂"
        lbl.Font = Enum.Font.GothamBold
        lbl.TextSize = 36
        lbl.TextTransparency = 1
        lbl.Parent = g
    end
    local target = show and 0 or 1
    pcall(function()
        svc.TweenService:Create(lbl, TweenInfo.new(show and 0.15 or 0.5), {TextTransparency=target}):Play()
    end)
end
local function absAddRing(model)
    local hrp = model:FindFirstChild("HumanoidRootPart")
    if not hrp or abs.rings[model] then return end
    pcall(function()
        local ring = Instance.new("Part")
        ring.Name = "AbsRing"
        ring.Shape = Enum.PartType.Cylinder
        ring.Size = Vector3.new(0.1, abs.range*2, abs.range*2)
        ring.Color = Color3.fromRGB(220,50,50)
        ring.Material = Enum.Material.ForceField
        ring.Transparency = 0.5
        ring.CanCollide = false
        ring.CanTouch = false
        ring.CFrame = hrp.CFrame * CFrame.Angles(0,0,math.rad(90))
        ring.Parent = hrp
        local w = Instance.new("WeldConstraint")
        w.Part0=hrp; w.Part1=ring; w.Parent=ring
        abs.rings[model]=ring
    end)
end
local function absRemoveRing(model)
    local r = abs.rings[model]
    if r then pcall(function() r:Destroy() end); abs.rings[model]=nil end
end
local function absResizeRings()
    for _,r in pairs(abs.rings) do
        if r and r.Parent then r.Size=Vector3.new(0.1,abs.range*2,abs.range*2) end
    end
end
local function absCleanRings()
    for m in pairs(abs.rings) do absRemoveRing(m) end
end
local function absFindTwoTime()
    local players = svc.WS:FindFirstChild("Players"); if not players then return nil end
    for _,folder in ipairs(players:GetChildren()) do
        local tt = folder:FindFirstChild("TwoTime")
        if tt then return tt end
    end
    return nil
end
local function absTrigger()
    if abs.locked then return end
    local ch = lp.Character
    local myRoot = ch and ch:FindFirstChild("HumanoidRootPart")
    if not myRoot then return end
    local ttModel = absFindTwoTime(); if not ttModel then return end
    local ttRoot = ttModel:FindFirstChild("HumanoidRootPart"); if not ttRoot then return end
    if (myRoot.Position-ttRoot.Position).Magnitude > abs.range then return end
    abs.locked = true
    absShowLabel(true)
    task.spawn(function()
        local deadline = tick()+abs.duration
        while tick()<deadline do
            if not abs.on then break end
            local ch2 = lp.Character
            local r2 = ch2 and ch2:FindFirstChild("HumanoidRootPart")
            if not r2 or not ttRoot.Parent then break end
            r2.CFrame = CFrame.lookAt(r2.Position, Vector3.new(ttRoot.Position.X,r2.Position.Y,ttRoot.Position.Z))
            svc.Run.RenderStepped:Wait()
        end
        abs.locked = false
        absShowLabel(false)
    end)
end
local function absHookSounds()
    if abs.soundConn then abs.soundConn:Disconnect(); abs.soundConn=nil end
    abs.soundConn = svc.WS.DescendantAdded:Connect(function(obj)
        if not abs.on or not obj:IsA("Sound") then return end
        local id = obj.SoundId:match("%d+")
        if id and absTriggerSounds[id] then absTrigger() end
    end)
end
local function absStartScan()
    if abs.scanThread then return end
    abs.scanThread = task.spawn(function()
        while abs.on do
            local players = svc.WS:FindFirstChild("Players")
            if players then
                for _,folder in ipairs(players:GetChildren()) do
                    for _,model in ipairs(folder:GetChildren()) do
                        if model.Name=="TwoTime" then absAddRing(model) end
                    end
                end
            end
            for m in pairs(abs.rings) do
                if not m.Parent then absRemoveRing(m) end
            end
            task.wait(1)
        end
        abs.scanThread=nil
    end)
end
local function absStart() absHookSounds(); absStartScan() end
local function absStop()
    abs.on=false
    if abs.soundConn then abs.soundConn:Disconnect(); abs.soundConn=nil end
    if abs.scanThread then task.cancel(abs.scanThread); abs.scanThread=nil end
    absCleanRings(); abs.locked=false; absShowLabel(false)
end

lp.CharacterAdded:Connect(function()
    abs.locked=false
    if abs.on then absStart() end
end)

tabKiller:AddToggle({
    Name = "Enable Anti-Backstab", Default = abs.on,
    Callback = function(on)
        abs.on=on; cfg.set("absOn",on)
        if on then absStart() else absStop() end
    end
})
tabKiller:AddSlider({
    Name = "Detection Range", Min = 10, Max = 120, Default = abs.range,
    Callback = function(v) abs.range=v; cfg.set("absRange",v); absResizeRings() end
})
tabKiller:AddSlider({
    Name = "Look Duration (s)", Min = 0.3, Max = 5.0, Default = abs.duration,
    Callback = function(v) abs.duration=v; cfg.set("absDur",v) end
})

------------------------------------------------------------------------
-- TAB: VISUAL (ESP)
------------------------------------------------------------------------
local tabVisual = win:MakeTab({ Name = "Visual (ESP)", Icon = "rbxassetid://524302419", PremiumOnly = false })
tabVisual:AddLabel("ESP")

local esp = {
    killers=cfg.get("espKillers",false), survivors=cfg.get("espSurvivors",false),
    generators=cfg.get("espGenerators",false), items=cfg.get("espItems",false),
    buildings=cfg.get("espBuildings",false), shadows=cfg.get("espShadows",false),
    killerFolder=nil, survivorFolder=nil, mapFolder=nil,
    playerConns={}, mapConns={}, shadowConns={}, healthConns={}, progConns={},
    shadowSet={}, guardConns={}, ready=false,
}
local function espItemColor(name)
    local n=name:lower()
    if n:find("medkit") then return Color3.fromRGB(0,255,200) end
    if n:find("bloxycola") then return Color3.fromRGB(0,200,255) end
    return Color3.fromRGB(0,230,230)
end
local espAttach, espDetach
espAttach = function(obj,tag,color,isChar)
    if not obj or not obj.Parent then return end
    if obj:FindFirstChild(tag) then return end
    local root = obj:FindFirstChild("HumanoidRootPart") or obj.PrimaryPart
        or obj:FindFirstChildWhichIsA("BasePart")
        or obj:FindFirstChild("Base") or obj:FindFirstChild("Main")
    if not root then
        for _,d in ipairs(obj:GetDescendants()) do
            if d:IsA("BasePart") then root=d; break end
        end
    end
    if not root then return end
    pcall(function()
        local hl = Instance.new("Highlight")
        hl.Name="esp_hl_"..tag; hl.FillColor=color; hl.FillTransparency=0.8
        hl.OutlineColor=color; hl.OutlineTransparency=0
        hl.DepthMode=Enum.HighlightDepthMode.AlwaysOnTop
        hl.Adornee=obj; hl.Parent=obj
        local bb=Instance.new("BillboardGui")
        bb.Name=tag.."_bb"; bb.Adornee=root
        bb.Size=UDim2.new(0,100,0,20); bb.StudsOffset=Vector3.new(0,isChar and 3.5 or 3.8,0)
        bb.AlwaysOnTop=true; bb.MaxDistance=1000; bb.Parent=obj
        local lbl=Instance.new("TextLabel")
        lbl.Size=UDim2.new(1,0,1,0); lbl.BackgroundTransparency=1
        lbl.TextColor3=color; lbl.TextStrokeTransparency=0.5
        lbl.TextStrokeColor3=Color3.new(0,0,0); lbl.TextSize=15
        lbl.FontFace=Font.new("rbxasset://fonts/families/AccanthisADFStd.json")
        lbl.Parent=bb
        if isChar then
            local hum=obj:FindFirstChildOfClass("Humanoid")
            if hum then
                lbl.Text=obj.Name.." (100%)"
                local c=hum.HealthChanged:Connect(function()
                    if lbl.Parent then
                        lbl.Text=obj.Name.." ("..math.floor(hum.Health/hum.MaxHealth*100).."%)"
                    end
                end)
                esp.healthConns[obj]=c
            else lbl.Text=obj.Name end
        else
            local prog=obj:FindFirstChild("Progress")
            if prog and prog:IsA("NumberValue") then
                lbl.Text=math.floor(prog.Value).."%"
                local c=prog.Changed:Connect(function()
                    if lbl.Parent then lbl.Text=math.floor(prog.Value).."%" end
                end)
                esp.progConns[obj]=c
            else lbl.Text=obj.Name end
        end
    end)
    if esp.guardConns[obj] then pcall(function() esp.guardConns[obj]:Disconnect() end) end
    esp.guardConns[obj]=obj.ChildRemoved:Connect(function(removed)
        if removed.Name~=tag and removed.Name~=(tag.."_bb") then return end
        task.defer(function()
            if obj.Parent then espAttach(obj,tag,color,isChar) end
        end)
    end)
end
espDetach = function(obj,tag)
    if not obj then return end
    if esp.guardConns[obj] then
        pcall(function() esp.guardConns[obj]:Disconnect() end)
        esp.guardConns[obj]=nil
    end
    pcall(function()
        for _,name in ipairs({tag,tag.."_bb"}) do
            local c=obj:FindFirstChild(name); if c then c:Destroy() end
        end
        if esp.healthConns[obj] then esp.healthConns[obj]:Disconnect(); esp.healthConns[obj]=nil end
        if esp.progConns[obj]   then esp.progConns[obj]:Disconnect();   esp.progConns[obj]=nil end
    end)
end
local function espDoKillers(on)
    if not esp.killerFolder then return end
    for _,k in ipairs(esp.killerFolder:GetChildren()) do
        if k:IsA("Model") then
            if on then espAttach(k,"esp_k",Color3.fromRGB(255,0,0),true)
            else espDetach(k,"esp_k") end
        end
    end
end
local function espDoSurvivors(on)
    if not esp.survivorFolder then return end
    for _,s in ipairs(esp.survivorFolder:GetChildren()) do
        if s:IsA("Model") then
            if on then espAttach(s,"esp_s",Color3.fromRGB(255,255,0),true)
            else espDetach(s,"esp_s") end
        end
    end
end
local function espDoGenerators(on)
    local map=getMapContent(); if not map then return end
    for _,obj in ipairs(map:GetChildren()) do
        if obj.Name=="Generator" then
            if on then espAttach(obj,"esp_g",Color3.fromRGB(255,105,180),false)
            else espDetach(obj,"esp_g") end
        end
    end
end
local function espDoItems(on)
    local map=getMapContent(); if not map then return end
    for _,obj in ipairs(map:GetChildren()) do
        if obj.Name=="BloxyCola" or obj.Name=="Medkit" then
            if on then espAttach(obj,"esp_i",espItemColor(obj.Name),false)
            else espDetach(obj,"esp_i") end
        end
    end
end
local function espDoBuildings(on)
    local ig=getIngame(); if not ig then return end
    for _,obj in ipairs(ig:GetChildren()) do
        if obj.Name=="BuildermanSentry" or obj.Name=="SubspaceTripmine" or obj.Name=="BuildermanDispenser" then
            if on then espAttach(obj,"esp_b",Color3.fromRGB(255,80,0),false)
            else espDetach(obj,"esp_b") end
        end
    end
end
local function espShadowAdd(part)
    if not part or esp.shadowSet[part] or not part:IsA("BasePart") then return end
    pcall(function()
        local hl=Instance.new("Highlight")
        hl.Name="esp_sh"; hl.FillColor=Color3.fromRGB(255,230,0); hl.FillTransparency=0.3
        hl.OutlineColor=Color3.fromRGB(255,230,0); hl.OutlineTransparency=0
        hl.DepthMode=Enum.HighlightDepthMode.AlwaysOnTop
        hl.Adornee=part; hl.Parent=part
        esp.shadowSet[part]=true
    end)
end
local function espShadowRemove(part)
    if not part then return end
    pcall(function()
        local h=part:FindFirstChild("esp_sh"); if h then h:Destroy() end
        esp.shadowSet[part]=nil
    end)
end
local function espShadowClear()
    for p in pairs(esp.shadowSet) do espShadowRemove(p) end
    esp.shadowSet={}
end
local function espShadowScan()
    local ig=getIngame(); if not ig then return end
    for _,folder in ipairs(ig:GetChildren()) do
        if folder.Name:lower():find("shadow") then
            for _,d in ipairs(folder:GetDescendants()) do
                if d:IsA("BasePart") then espShadowAdd(d) end
            end
        end
    end
end
local function espWatchShadows()
    for _,c in pairs(esp.shadowConns) do if c.Connected then c:Disconnect() end end
    esp.shadowConns={}
    local ig=getIngame(); if not ig then return end
    local function watchFolder(folder)
        local c=folder.DescendantAdded:Connect(function(d)
            if esp.shadows and d:IsA("BasePart") then task.wait(0.05); espShadowAdd(d) end
        end)
        table.insert(esp.shadowConns,c)
    end
    table.insert(esp.shadowConns,ig.ChildAdded:Connect(function(child)
        if not esp.shadows then return end
        if child.Name:lower():find("shadow") then
            task.wait(0.1)
            for _,d in ipairs(child:GetDescendants()) do
                if d:IsA("BasePart") then espShadowAdd(d) end
            end
            watchFolder(child)
        end
    end))
    table.insert(esp.shadowConns,ig.ChildRemoved:Connect(function(child)
        if child.Name:lower():find("shadow") then
            for _,d in ipairs(child:GetDescendants()) do espShadowRemove(d) end
        end
    end))
    for _,folder in ipairs(ig:GetChildren()) do
        if folder.Name:lower():find("shadow") then watchFolder(folder) end
    end
end
local function espBindPlayers()
    for _,c in pairs(esp.playerConns) do if c.Connected then c:Disconnect() end end
    esp.playerConns={}
    if esp.killerFolder then
        table.insert(esp.playerConns,esp.killerFolder.ChildAdded:Connect(function(ch)
            task.wait(0.2)
            if esp.killers and ch:IsA("Model") then espAttach(ch,"esp_k",Color3.fromRGB(255,0,0),true) end
        end))
        table.insert(esp.playerConns,esp.killerFolder.ChildRemoved:Connect(function(ch)
            espDetach(ch,"esp_k")
        end))
    end
    if esp.survivorFolder then
        table.insert(esp.playerConns,esp.survivorFolder.ChildAdded:Connect(function(ch)
            task.wait(0.2)
            if esp.survivors and ch:IsA("Model") then espAttach(ch,"esp_s",Color3.fromRGB(255,255,0),true) end
        end))
        table.insert(esp.playerConns,esp.survivorFolder.ChildRemoved:Connect(function(ch)
            espDetach(ch,"esp_s")
        end))
    end
end
local function espBindWorld()
    for _,c in pairs(esp.mapConns) do if c.Connected then c:Disconnect() end end
    esp.mapConns={}
    local ig=getIngame(); if not ig then return end
    table.insert(esp.mapConns,ig.ChildAdded:Connect(function(obj)
        task.wait(0.2)
        if esp.buildings and (obj.Name=="BuildermanSentry" or obj.Name=="SubspaceTripmine" or obj.Name=="BuildermanDispenser") then
            espAttach(obj,"esp_b",Color3.fromRGB(255,80,0),false)
        end
        if esp.shadows and obj.Name:lower():find("shadow") then
            task.wait(0.1)
            for _,d in ipairs(obj:GetDescendants()) do
                if d:IsA("BasePart") then espShadowAdd(d) end
            end
        end
        if obj.Name=="Map" then
            task.wait(1); esp.mapFolder=obj
            obj.ChildAdded:Connect(function(child)
                task.wait(0.2)
                if esp.generators and child.Name=="Generator" then espAttach(child,"esp_g",Color3.fromRGB(255,105,180),false) end
                if esp.items and (child.Name=="BloxyCola" or child.Name=="Medkit") then espAttach(child,"esp_i",espItemColor(child.Name),false) end
            end)
            obj.ChildRemoved:Connect(function(child)
                if child.Name=="Generator" then espDetach(child,"esp_g") end
                if child.Name=="BloxyCola" or child.Name=="Medkit" then espDetach(child,"esp_i") end
            end)
            if esp.generators then task.spawn(function() espDoGenerators(true) end) end
            if esp.items then task.spawn(function() espDoItems(true) end) end
        end
    end))
    table.insert(esp.mapConns,ig.ChildRemoved:Connect(function(obj)
        if obj.Name=="BuildermanSentry" or obj.Name=="SubspaceTripmine" then espDetach(obj,"esp_b") end
        if obj.Name=="Map" then esp.mapFolder=nil end
    end))
    local existing=getMapContent()
    if existing then
        esp.mapFolder=existing
        task.spawn(function()
            task.wait(2)
            if esp.generators then espDoGenerators(true) end
            if esp.items then espDoItems(true) end
        end)
    end
end

task.spawn(function()
    while true do
        task.wait(3)
        if esp.killers    then task.spawn(function() espDoKillers(true)    end) end
        if esp.survivors  then task.spawn(function() espDoSurvivors(true)  end) end
        if esp.generators then task.spawn(function() espDoGenerators(true) end) end
        if esp.items      then task.spawn(function() espDoItems(true)      end) end
        if esp.buildings  then task.spawn(function() espDoBuildings(true)  end) end
        if esp.shadows    then task.spawn(espShadowScan)                        end
    end
end)

task.spawn(function()
    task.wait(3)
    local pf=svc.WS:FindFirstChild("Players")
    if pf then
        esp.killerFolder=pf:FindFirstChild("Killers")
        esp.survivorFolder=pf:FindFirstChild("Survivors")
        espBindPlayers()
        if esp.killers   then task.spawn(function() espDoKillers(true)   end) end
        if esp.survivors then task.spawn(function() espDoSurvivors(true) end) end
    end
    espBindWorld()
    if esp.buildings then task.spawn(function() espDoBuildings(true) end) end
    if esp.shadows   then espWatchShadows(); task.spawn(espShadowScan) end
    esp.ready=true
end)

lp.CharacterAdded:Connect(function()
    task.wait(4)
    espBindPlayers(); espBindWorld()
    if esp.killers    then task.spawn(function() espDoKillers(true)    end) end
    if esp.survivors  then task.spawn(function() espDoSurvivors(true)  end) end
    if esp.generators then task.spawn(function() espDoGenerators(true) end) end
    if esp.items      then task.spawn(function() espDoItems(true)      end) end
    if esp.buildings  then task.spawn(function() espDoBuildings(true)  end) end
    if esp.shadows    then espWatchShadows(); task.spawn(espShadowScan) end
end)

tabVisual:AddToggle({ Name="Killers ESP",    Default=esp.killers,    Callback=function(on) esp.killers=on;    cfg.set("espKillers",on);    task.spawn(function() espDoKillers(on)    end) end })
tabVisual:AddToggle({ Name="Survivors ESP",  Default=esp.survivors,  Callback=function(on) esp.survivors=on;  cfg.set("espSurvivors",on);  task.spawn(function() espDoSurvivors(on)  end) end })
tabVisual:AddToggle({ Name="Generators ESP", Default=esp.generators, Callback=function(on) esp.generators=on; cfg.set("espGenerators",on); task.spawn(function() espDoGenerators(on) end) end })
tabVisual:AddToggle({ Name="Items ESP",      Default=esp.items,      Callback=function(on) esp.items=on;      cfg.set("espItems",on);      task.spawn(function() espDoItems(on)      end) end })
tabVisual:AddToggle({ Name="Buildings ESP",  Default=esp.buildings,  Callback=function(on) esp.buildings=on;  cfg.set("espBuildings",on);  task.spawn(function() espDoBuildings(on)  end) end })
tabVisual:AddToggle({
    Name="JD Footprints", Default=esp.shadows,
    Callback=function(on)
        esp.shadows=on; cfg.set("espShadows",on)
        if on then espWatchShadows(); task.spawn(espShadowScan)
        else
            espShadowClear()
            for _,c in pairs(esp.shadowConns) do if c.Connected then c:Disconnect() end end
            esp.shadowConns={}
        end
    end
})

------------------------------------------------------------------------
-- TAB: MUSIC
------------------------------------------------------------------------
local tabMusic = win:MakeTab({ Name = "Music", Icon = "rbxassetid://7059338419", PremiumOnly = false })
tabMusic:AddLabel("LMS Music")

local music = {
    on=cfg.get("musicOn",false), selected=cfg.get("musicSel","CondemnedLMS"),
    cached={}, origId=nil, thread=nil,
}
local musicDir="GlovSakenScript/LMS_Songs"
if not fs.hasFolder("GlovSakenScript") then fs.makeFolder("GlovSakenScript") end
if not fs.hasFolder(musicDir) then fs.makeFolder(musicDir) end

local musicTracks = {
    ["AbberantLMS"]  ="https://files.catbox.moe/4bb0g9.mp3",
    ["OvertimeLMS"]  ="https://files.catbox.moe/puf7xu.mp3",
    ["PhotoshopLMS"] ="https://files.catbox.moe/yui8km.mp3",
    ["JX1DX1LMS"]   ="https://files.catbox.moe/52p5yh.mp3",
    ["CondemnedLMS"] ="https://files.catbox.moe/l470am.mp3",
    ["GeometryLMS"]  ="https://files.catbox.moe/bqzc7u.mp3",
    ["Milestone4LMS"]="https://files.catbox.moe/z68ns9.mp3",
}
local musicList={}
for k in pairs(musicTracks) do table.insert(musicList,k) end
table.sort(musicList)

local function musicFetch(name)
    if music.cached[name] then return music.cached[name] end
    local url=musicTracks[name]; if not url then return nil end
    local path=musicDir.."/"..name:gsub("[^%w]","_")..".mp3"
    if not fs.hasFile(path) then
        local ok,data=pcall(function() return game:HttpGet(url) end)
        if not ok or not data or #data==0 then return nil end
        fs.write(path,data)
    end
    music.cached[name]=fs.asset(path)
    return music.cached[name]
end
local function musicGetSound()
    local t=svc.WS:FindFirstChild("Themes")
    return t and t:FindFirstChild("LastSurvivor")
end
local function musicPlay(name)
    local snd=musicGetSound(); if not snd then return false end
    if not music.origId then music.origId=snd.SoundId end
    local asset=musicFetch(name)
    if asset then snd.SoundId=asset; snd:Play(); return true end
    return false
end
local function musicReset()
    local snd=musicGetSound()
    if snd and music.origId then snd.SoundId=music.origId; snd:Play() end
end
local function musicIsLMS()
    local sf=getTeamFolder("Survivors")
    if sf then
        local alive=0
        for _,s in ipairs(sf:GetChildren()) do
            local h=s:FindFirstChildOfClass("Humanoid")
            if h and h.Health>0 then alive+=1 end
        end
        if alive==1 then return true end
    end
    local snd=musicGetSound()
    return snd and snd.IsPlaying
end
local function musicMonitor()
    local i=0
    while music.on and i<1000 do
        i+=1
        if musicIsLMS() then
            local snd=musicGetSound()
            if not snd or snd.SoundId~=music.cached[music.selected] then musicPlay(music.selected) end
            task.wait(5)
        else task.wait(1) end
    end
end

tabMusic:AddToggle({
    Name="Auto-Play on LMS", Default=music.on,
    Callback=function(on)
        music.on=on; cfg.set("musicOn",on)
        if on then music.thread=task.spawn(musicMonitor)
        else
            if music.thread then task.cancel(music.thread); music.thread=nil end
            musicReset()
        end
    end
})
tabMusic:AddDropdown({
    Name="Track", Default=music.selected, Options=musicList,
    Callback=function(sel)
        music.selected=type(sel)=="table" and sel[1] or sel
        cfg.set("musicSel",music.selected)
        task.spawn(function() musicFetch(music.selected) end)
    end
})
tabMusic:AddButton({ Name="▶ Play",        Callback=function() musicPlay(music.selected) end })
tabMusic:AddButton({ Name="■ Stop",        Callback=function() musicReset() end })
tabMusic:AddButton({ Name="↓ Preload All", Callback=function()
    for name in pairs(musicTracks) do task.spawn(function() musicFetch(name) end); task.wait(0.1) end
end })

lp.CharacterAdded:Connect(function()
    task.wait(3)
    if music.on then
        if music.thread then task.cancel(music.thread) end
        music.thread=task.spawn(musicMonitor)
    end
end)

------------------------------------------------------------------------
-- TAB: CHARACTER
------------------------------------------------------------------------
local tabChar = win:MakeTab({ Name = "Character", Icon = "rbxassetid://96856417870846", PremiumOnly = false })

tabChar:AddLabel("Killers")
tabChar:AddButton({ Name="Slasher (Locked)", Callback=function() end })

tabChar:AddLabel("Survivors")
tabChar:AddButton({ Name="Veeronica (Locked)", Callback=function() end })

tabChar:AddLabel("Sentinels")
tabChar:AddButton({ Name="Guest1337",    Callback=function() loadstring(game:HttpGet("https://pastebin.com/raw/cDpDF3z4"))() end })
tabChar:AddButton({ Name="Shedletsky (use hitbox)", Callback=function() end })
tabChar:AddButton({ Name="Chance",       Callback=function() loadstring(game:HttpGet("https://pastebin.com/raw/x0ECfJqN"))() end })
tabChar:AddButton({ Name="TwoTime",      Callback=function() loadstring(game:HttpGet("https://pastebin.com/raw/6QiUWVMp"))() end })

tabChar:AddLabel("Supports")
tabChar:AddButton({ Name="Dusekkar (Locked)", Callback=function() end })
tabChar:AddButton({ Name="Elliot", Callback=function() loadstring(game:HttpGet("https://pastebin.com/raw/wDaKAwvD"))() end })

------------------------------------------------------------------------
-- TAB: INTERFACE
------------------------------------------------------------------------
local tabInterface = win:MakeTab({ Name = "Interface", Icon = "rbxassetid://117931171948240", PremiumOnly = false })
tabInterface:AddLabel("UI Functions")
tabInterface:AddButton({ Name="Close UI", Callback=function() OrionLib:Destroy() end })

------------------------------------------------------------------------
-- Init
------------------------------------------------------------------------
OrionLib:Init()