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

-- FIXED & CLOSED FUNCTION PLACEHOLDER
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

------------------------------------------------------------------------
-- TAB: MUSIC (ADDED MISSING TAB DEFINITION)
------------------------------------------------------------------------
local tabMusic = win:MakeTab({ Name = "Music", Icon = "rbxassetid://6756417870", PremiumOnly = false })

local music = { on = false, thread = nil }
local musicTracks = {}
local function musicReset() end
local function musicFetch() end
local function musicMonitor() 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()