-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]



local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Lighting = game:GetService("Lighting")
local VirtualInputManager = game:GetService("VirtualInputManager")
local ProximityPromptService = game:GetService("ProximityPromptService")
local TeleportService = game:GetService("TeleportService")
local CoreGui = game:GetService("CoreGui")

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

if getgenv().ForsakenCleanup then
    pcall(getgenv().ForsakenCleanup)
end

local Running = true
local Connections = {}
local Highlights = {}
local Billboards = {}
local GeneratorCache = {}
local GearCache = {}
local TrapCache = {}
local ItemCache = {}
local ActivePromptCache = {}

local OriginalLighting = {
    Ambient = Lighting.Ambient,
    OutdoorAmbient = Lighting.OutdoorAmbient,
    Brightness = Lighting.Brightness,
    ClockTime = Lighting.ClockTime,
    FogEnd = Lighting.FogEnd,
    GlobalShadows = Lighting.GlobalShadows,
}

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

local State = {
    -- Movement & Sprint
    AutoSprint = false,
    InfiniteStamina = false,
    ForcedJump = true,
    JumpPower = 50,
    InfiniteJump = false,
    AntiSlow = false,

    -- Combat & Defense
    AutoBlock = false,
    AutoBlockRange = 14,
    AutoAvoidKiller = false,
    AutoAvoidKillerRange = 16,
    AvoidRepelForce = 70,
    Triggerbot = false,
    TriggerbotRange = 14,
    TriggerbotCooldown = 0.35,

    -- Visuals / ESP
    ESPEnabled = true,
    SurvivorsESP = true,
    KillersESP = true,
    GeneratorsESP = true,
    GearsESP = true,
    TrapsESP = true,
    ItemsESP = true,
    ChamsEnabled = true,
    KillerAlert = true,
    KillerAlertDistance = 75,
    Fullbright = false,
    CustomFOV = 70,
    RemoveVFX = false,

    -- Automation & Interacts
    AutoAllPuzzles = true,
    InstantInteract = true,
    AutoProximityInteract = false,
    ProximitySpoofRange = false,
}

-- Pre-load and cache game modules once
local SprintingModule = nil
local GeneratorClientBinder = nil
local GearClientBinder = nil
local LockClientMinigame = nil
local FlowClientMinigame = nil
local ConnectClientMinigame = nil
local GearClientMinigame = nil
local MinigameController = nil
local FlowBoard = nil
local ConnectBoard = nil

local function LoadModules()
    pcall(function() SprintingModule = require(ReplicatedStorage.Systems.Character.Game.Sprinting) end)
    pcall(function() GeneratorClientBinder = require(ReplicatedStorage.Systems.Player.Game.Generators.GeneratorClientBinder) end)
    pcall(function() GearClientBinder = require(ReplicatedStorage.Systems.Player.Game.Spawners.GearClientBinder) end)
    pcall(function() LockClientMinigame = require(ReplicatedStorage.Systems.Player.Game.Minigames.LockClientMinigame) end)
    pcall(function() FlowClientMinigame = require(ReplicatedStorage.Systems.Player.Game.Minigames.FlowClientMinigame) end)
    pcall(function() ConnectClientMinigame = require(ReplicatedStorage.Systems.Player.Game.Minigames.ConnectClientMinigame) end)
    pcall(function() GearClientMinigame = require(ReplicatedStorage.Systems.Player.Game.Minigames.GearClientMinigame) end)
    pcall(function() MinigameController = require(ReplicatedStorage.Systems.Player.MinigameController) end)
    pcall(function() FlowBoard = require(ReplicatedStorage.Modules.Minigames.FlowBoard) end)
    pcall(function() ConnectBoard = require(ReplicatedStorage.Modules.Minigames.ConnectBoard) end)
end
LoadModules()

local GeneratorBinderRunning = nil
local function UpdateBinderRunningCache()
    if GeneratorClientBinder then
        for k, v in pairs(GeneratorClientBinder) do
            if tostring(k):find("Running") and type(v) == "table" then
                GeneratorBinderRunning = v
                break
            end
        end
    end
end
UpdateBinderRunningCache()

-- Load Rayfield UI Library
local Rayfield = loadstring(game:HttpGet("https://sirius.menu/rayfield"))()

local function Notify(title, content, duration)
    pcall(function()
        Rayfield:Notify({
            Title = title or "Forsaken",
            Content = content or "",
            Duration = duration or 3,
            Image = 4483362458,
        })
    end)
end

-- =========================================================================
-- MAP ELEMENT CACHES & PROGRESS HELPERS
-- =========================================================================
local GenBarCache = {}
local GenValCache = {}

local function GetGeneratorProgress(gen)
    if not gen then return 0 end

    if GeneratorBinderRunning then
        local obj = GeneratorBinderRunning[gen]
        if obj then
            if obj.__getFraction then
                local s, frac = pcall(function() return obj:__getFraction() end)
                if s and type(frac) == "number" then
                    return math.clamp(math.floor(frac * 100), 0, 100)
                end
            end
            if obj.Network and obj.Network.Properties then
                local props = obj.Network.Properties
                local s1, c = pcall(function() return props:Get("Counter") end)
                local s2, m = pcall(function() return props:Get("MaxCounter") end)
                if s1 and s2 and type(c) == "number" and type(m) == "number" and m > 0 then
                    return math.clamp(math.floor((c / m) * 100), 0, 100)
                end
            end
        end
    else
        UpdateBinderRunningCache()
    end

    local bar = GenBarCache[gen]
    if bar == nil then
        bar = gen:FindFirstChild("Bar", true) or false
        GenBarCache[gen] = bar
    end
    if bar and bar:IsA("GuiObject") then
        local scale = bar.Size.X.Scale
        if scale > 0 and scale <= 1 then
            return math.clamp(math.floor(scale * 100), 0, 100)
        end
    end

    local attrVal = gen:GetAttribute("Progress") or gen:GetAttribute("Counter") or gen:GetAttribute("RepairProgress")
    if type(attrVal) == "number" then
        if attrVal <= 1 then return math.clamp(math.floor(attrVal * 100), 0, 100) end
        return math.clamp(math.floor(attrVal), 0, 100)
    end

    local pv = GenValCache[gen]
    if pv == nil then
        pv = gen:FindFirstChild("Progress") or false
        GenValCache[gen] = pv
    end
    if pv and pv:IsA("NumberValue") then
        local v = pv.Value
        if v <= 1 and v > 0 then return math.clamp(math.floor(v * 100), 0, 100) end
        return math.clamp(math.floor(v), 0, 100)
    end

    return 0
end

local function IsObjectPresent(inst, part)
    if not inst or not inst.Parent or not part or not part.Parent then
        return false
    end
    if not inst:IsDescendantOf(workspace) or not part:IsDescendantOf(workspace) then
        return false
    end

    local playersFolder = workspace:FindFirstChild("Players")
    if playersFolder and (inst:IsDescendantOf(playersFolder) or inst:FindFirstAncestor("Players")) then
        return false
    end

    local lobby = workspace:FindFirstChild("Lobby")
    if lobby and (inst:IsDescendantOf(lobby) or part:IsDescendantOf(lobby)) then
        return false
    end
    local waitingRoom = workspace:FindFirstChild("WaitingRoom")
    if waitingRoom and (inst:IsDescendantOf(waitingRoom) or part:IsDescendantOf(waitingRoom)) then
        return false
    end

    local prompt = inst:FindFirstChildWhichIsA("ProximityPrompt") or inst:FindFirstChild("Prompt", true) or part:FindFirstChildWhichIsA("ProximityPrompt")
    if prompt and not prompt.Enabled then
        return false
    end

    if part:IsA("BasePart") and part.Transparency < 0.85 then
        return true
    end
    if inst:IsA("Model") then
        for _, child in ipairs(inst:GetChildren()) do
            if child:IsA("BasePart") and child.Transparency < 0.85 then
                return true
            end
        end
    end

    return false
end

local function RegisterGenerator(inst)
    if not inst or not inst:IsA("Model") then return end
    local n = inst.Name:lower()
    if not (n:find("generator") or inst:FindFirstChild("Progress")) then return end

    local parent = inst.Parent
    if parent and parent:IsA("Model") and (parent.Name:lower():find("generator") or parent:FindFirstChild("Progress")) then
        return
    end

    local lobby = workspace:FindFirstChild("Lobby")
    if lobby and inst:IsDescendantOf(lobby) then return end

    local main = inst:FindFirstChild("Main") or inst.PrimaryPart or inst:FindFirstChildWhichIsA("BasePart")
    if main then
        for existingGen, existingPart in pairs(GeneratorCache) do
            if existingGen == inst or existingPart == main or (existingPart.Position - main.Position).Magnitude < 8 then
                return
            end
        end
        GeneratorCache[inst] = main
    end
end

local function RegisterGear(inst)
    if not inst or (not inst:IsA("Model") and not inst:IsA("BasePart")) then return end
    local n = inst.Name:lower()
    if n:find("spawner") or n:find("spawn") or n:find("gearbox") or n:find("furniture") or n:find("mesh") or n:find("node") or n:find("point") then
        return
    end

    local lobby = workspace:FindFirstChild("Lobby")
    if lobby and inst:IsDescendantOf(lobby) then return end

    if n:find("gear") or n:find("cog") then
        local part = inst:IsA("BasePart") and inst or (inst.PrimaryPart or inst:FindFirstChildWhichIsA("BasePart"))
        if part then
            GearCache[inst] = part
        end
    end
end

local function RegisterTrap(inst)
    if not inst or (not inst:IsA("Model") and not inst:IsA("BasePart")) then return end

    local lobby = workspace:FindFirstChild("Lobby")
    if lobby and (inst:IsDescendantOf(lobby) or inst:FindFirstAncestor("Lobby")) then return end
    local waitingRoom = workspace:FindFirstChild("WaitingRoom")
    if waitingRoom and (inst:IsDescendantOf(waitingRoom) or inst:FindFirstAncestor("WaitingRoom")) then return end

    local n = inst.Name:lower()
    if n:find("trapezoid") or n:find("stud") or n:find("mesh") or n:find("wedge") or n:find("roof")
       or n:find("decor") or n:find("building") or n:find("furniture") or n:find("wall") or n:find("floor")
       or n:find("strap") or n:find("trapdoor") or n:find("scarybear") or n:find("happybear") or n:find("railing")
       or n:find("beam") or n:find("support") or n:find("tower") or n:find("wood") or n:find("plank") then
        return
    end

    local isTrap = false
    if n:find("beartrap") or n:find("tripwire") or n:find("tripmine") or n:find("snare") then
        isTrap = true
    elseif n == "trap" or n:find("^trap") or n:find("_trap") or n:find("trap_") or n:find(" killer trap") or n:find("killertrap") then
        isTrap = true
    elseif n:find("mine") and not n:find("minigame") and not n:find("reminis") and not n:find("mineral") and not n:find("determine") then
        isTrap = true
    end

    if isTrap then
        local part = inst:IsA("BasePart") and inst or (inst:FindFirstChildWhichIsA("BasePart") or inst.PrimaryPart)
        if part then
            TrapCache[inst] = part
        end
    end
end

local function RegisterItem(inst)
    if not inst or (not inst:IsA("Model") and not inst:IsA("BasePart")) then return end

    local playersFolder = workspace:FindFirstChild("Players")
    if playersFolder and (inst:IsDescendantOf(playersFolder) or inst:FindFirstAncestor("Players")) then
        return
    end

    local lobby = workspace:FindFirstChild("Lobby")
    if lobby and inst:IsDescendantOf(lobby) then return end
    local waitingRoom = workspace:FindFirstChild("WaitingRoom")
    if waitingRoom and inst:IsDescendantOf(waitingRoom) then return end

    local n = inst.Name:lower()
    if n:find("mesh") or n:find("crate_cube") or n:find("flatcrate") or n:find("furniture")
       or n:find("wall") or n:find("door") or n:find("floor") or n:find("light") or n:find("window")
       or n:find("shelf") or n:find("carpet") or n:find("table") or n:find("chair") or n:find("decor")
       or n:find("building") or n:find("prop") or n:find("spawner") or n:find("spawn") or n:find("point") or n:find("node") then
        return
    end

    if n:find("gear") or n:find("cog") or n:find("generator") or n:find("trap") then
        return
    end

    local prompt = inst:FindFirstChildWhichIsA("ProximityPrompt") or inst:FindFirstChild("Prompt", true) or (inst.Parent and inst.Parent:FindFirstChildWhichIsA("ProximityPrompt"))
    local isRealItem = false
    local itemName = inst.Name

    if prompt and prompt:IsA("ProximityPrompt") then
        local at = (prompt.ActionText or ""):lower()
        local ot = (prompt.ObjectText or ""):lower()

        if at:find("pick") or at:find("take") or at:find("grab") or at:find("collect") or at:find("loot") or at:find("search") or at:find("open") then
            if not ot:find("door") and not ot:find("generator") and not ot:find("locker") and not ot:find("gate") and not ot:find("puzzle") then
                isRealItem = true
                if prompt.ObjectText and prompt.ObjectText ~= "" then
                    itemName = prompt.ObjectText
                end
            end
        elseif ot:find("medkit") or ot:find("battery") or ot:find("key") or ot:find("flashlight") or ot:find("item") or ot:find("crowbar") then
            isRealItem = true
            itemName = prompt.ObjectText
        end
    end

    if not isRealItem and (inst:IsA("Tool") or (inst.Parent and inst.Parent:IsA("Tool"))) then
        isRealItem = true
        itemName = inst:IsA("Tool") and inst.Name or inst.Parent.Name
    end

    if isRealItem then
        local lowerName = itemName:lower()
        if lowerName:find("mesh") or lowerName:find("crate_cube") or lowerName:find("flatcrate") or lowerName:find("prop") then
            return
        end

        local part = inst:IsA("BasePart") and inst or (inst.PrimaryPart or inst:FindFirstChildWhichIsA("BasePart"))
        if part then
            ItemCache[inst] = { Part = part, Name = itemName }
        end
    end
end

local function UnregisterInstance(inst)
    GeneratorCache[inst] = nil
    GearCache[inst] = nil
    TrapCache[inst] = nil
    ItemCache[inst] = nil
    if Billboards[inst] then
        if Billboards[inst].Gui and Billboards[inst].Gui.Parent then
            Billboards[inst].Gui:Destroy()
        end
        Billboards[inst] = nil
    end
    if Highlights[inst] then
        if Highlights[inst].Parent then
            Highlights[inst]:Destroy()
        end
        Highlights[inst] = nil
    end
end

pcall(function()
    for _, child in ipairs(workspace:GetDescendants()) do
        RegisterGenerator(child)
        RegisterGear(child)
        RegisterTrap(child)
        RegisterItem(child)
    end
end)

local MapFolder = workspace:FindFirstChild("Map")
if MapFolder then
    TrackConnection(MapFolder.DescendantAdded:Connect(function(child)
        RegisterGenerator(child)
        RegisterGear(child)
        RegisterTrap(child)
        RegisterItem(child)
    end))
    TrackConnection(MapFolder.DescendantRemoving:Connect(function(child)
        UnregisterInstance(child)
    end))
end

TrackConnection(workspace.DescendantAdded:Connect(function(child)
    RegisterTrap(child)
    RegisterItem(child)
end))
TrackConnection(workspace.DescendantRemoving:Connect(function(child)
    if TrapCache[child] then
        UnregisterInstance(child)
    end
end))

-- =========================================================================
-- SMART AVOID VECTOR & MANUAL IMPULSE
-- =========================================================================
local AvoidRayParams = RaycastParams.new()
AvoidRayParams.FilterType = Enum.RaycastFilterType.Exclude
AvoidRayParams.IgnoreWater = true

local function GetSmartAvoidVector(myHRP, kHRP)
    local myPos = myHRP.Position
    local kPos = kHRP.Position
    local diff = myPos - kPos
    local awayFlat = Vector3.new(diff.X, 0, diff.Z)
    if awayFlat.Magnitude > 0.001 then
        awayFlat = awayFlat.Unit
    else
        local look = myHRP.CFrame.LookVector
        awayFlat = Vector3.new(-look.X, 0, -look.Z)
        awayFlat = (awayFlat.Magnitude > 0.001) and awayFlat.Unit or Vector3.new(0, 0, 1)
    end

    local myChar = LocalPlayer.Character
    local filterList = { myChar }
    local playersRoot = workspace:FindFirstChild("Players")
    if playersRoot then
        table.insert(filterList, playersRoot)
    end
    AvoidRayParams.FilterDescendantsInstances = filterList

    local rayOrigin = myPos + Vector3.new(0, -0.4, 0)
    local maxCheckDist = 12.0

    local directRay = workspace:Raycast(rayOrigin, awayFlat * maxCheckDist, AvoidRayParams)
    if not directRay or directRay.Distance >= 8.5 then
        return awayFlat, 1.5
    end

    local escapeAngles = { 40, -40, 75, -75, 105, -105, 135, -135 }
    local bestDir = awayFlat
    local directDist = directRay and directRay.Distance or maxCheckDist
    local bestScore = (directDist * 1.5) + 4.0
    local bestDist = directDist

    local ax, az = awayFlat.X, awayFlat.Z

    for _, deg in ipairs(escapeAngles) do
        local rad = math.rad(deg)
        local cosA, sinA = math.cos(rad), math.sin(rad)
        local candDir = Vector3.new(ax * cosA - az * sinA, 0, ax * sinA + az * cosA).Unit
        local ray = workspace:Raycast(rayOrigin, candDir * maxCheckDist, AvoidRayParams)
        local dist = ray and ray.Distance or maxCheckDist
        local dot = candDir.X * ax + candDir.Z * az

        local score = (dist * 1.8) + (dot * 5.0)
        if dist < 3.2 then
            score = score - 14.0
        end

        if score > bestScore then
            bestScore = score
            bestDir = candDir
            bestDist = dist
        end
    end

    local upBoost = (bestDist < 3.2) and 18 or 2.0
    return bestDir, upBoost
end

local function ExecuteAvoidImpulse()
    local myChar = LocalPlayer.Character
    local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
    if not myHRP then return end

    local killersFolder = workspace:FindFirstChild("Players") and workspace.Players:FindFirstChild("Killers")
    local closestDist, closestKiller = 999999, nil
    if killersFolder then
        for _, k in ipairs(killersFolder:GetChildren()) do
            local kHRP = k:FindFirstChild("HumanoidRootPart")
            if kHRP then
                local d = (kHRP.Position - myHRP.Position).Magnitude
                if d < closestDist then
                    closestDist = d
                    closestKiller = kHRP
                end
            end
        end
    end

    local avoidDir, upBoost
    if closestKiller then
        avoidDir, upBoost = GetSmartAvoidVector(myHRP, closestKiller)
    else
        local look = myHRP.CFrame.LookVector
        local awayFlat = Vector3.new(-look.X, 0, -look.Z)
        awayFlat = (awayFlat.Magnitude > 0.001) and awayFlat.Unit or Vector3.new(0, 0, 1)
        local fakeKiller = { Position = myHRP.Position - awayFlat * 10 }
        avoidDir, upBoost = GetSmartAvoidVector(myHRP, fakeKiller)
    end

    myHRP.AssemblyLinearVelocity = avoidDir * (State.AvoidRepelForce * 1.25) + Vector3.new(0, math.max(upBoost, 16), 0)
    Notify("Auto Avoid", "Импульс отскока активирован!", 1.5)
end

-- =========================================================================
-- PROXIMITY PROMPT & FAST INTERACTION SYSTEM
-- =========================================================================
local function ApplyPromptSettings(prompt)
    if not prompt or not prompt:IsA("ProximityPrompt") then return end
    if not prompt:GetAttribute("OrigHold") then
        prompt:SetAttribute("OrigHold", prompt.HoldDuration)
        prompt:SetAttribute("OrigDist", prompt.MaxActivationDistance)
        prompt:SetAttribute("OrigLOS", prompt.RequiresLineOfSight)
    end

    if State.InstantInteract then
        prompt.HoldDuration = 0
    else
        local orig = prompt:GetAttribute("OrigHold")
        if orig ~= nil then prompt.HoldDuration = orig end
    end

    if State.ProximitySpoofRange then
        prompt.MaxActivationDistance = 30
        prompt.RequiresLineOfSight = false
    else
        local origDist = prompt:GetAttribute("OrigDist")
        if origDist ~= nil then prompt.MaxActivationDistance = origDist end
        local origLOS = prompt:GetAttribute("OrigLOS")
        if origLOS ~= nil then prompt.RequiresLineOfSight = origLOS end
    end
end

local function RegisterPrompt(prompt)
    if prompt:IsA("ProximityPrompt") then
        ActivePromptCache[prompt] = true
        ApplyPromptSettings(prompt)
    end
end

local function UnregisterPrompt(prompt)
    ActivePromptCache[prompt] = nil
end

local function UpdateAllPrompts()
    for prompt in pairs(ActivePromptCache) do
        if prompt and prompt.Parent then
            ApplyPromptSettings(prompt)
        else
            ActivePromptCache[prompt] = nil
        end
    end
end

TrackConnection(workspace.DescendantAdded:Connect(function(desc)
    if desc:IsA("ProximityPrompt") then
        RegisterPrompt(desc)
    end
end))

TrackConnection(workspace.DescendantRemoving:Connect(function(desc)
    if desc:IsA("ProximityPrompt") then
        UnregisterPrompt(desc)
    end
end))

task.spawn(function()
    for _, desc in ipairs(workspace:GetDescendants()) do
        if desc:IsA("ProximityPrompt") then
            RegisterPrompt(desc)
        end
    end
end)

TrackConnection(ProximityPromptService.PromptButtonHoldBegan:Connect(function(prompt)
    if State.InstantInteract then
        prompt.HoldDuration = 0
        if fireproximityprompt then
            fireproximityprompt(prompt)
        end
    end
end))

local function IsItemOrGearPrompt(prompt)
    if not prompt or not prompt:IsA("ProximityPrompt") then return false end
    local parent = prompt.Parent
    if not parent then return false end

    local playersFolder = workspace:FindFirstChild("Players")
    if playersFolder and (parent:IsDescendantOf(playersFolder) or parent:FindFirstAncestor("Players")) then
        return false
    end

    local pn = parent.Name:lower()
    if pn:find("generator") or pn:find("lockbox") or pn:find("locker") or pn:find("door") or pn:find("gate") or pn:find("exit") or pn:find("puzzle") then
        return false
    end

    local at = (prompt.ActionText or ""):lower()
    local ot = (prompt.ObjectText or ""):lower()

    if at:find("pick") or at:find("take") or at:find("grab") or at:find("collect") or at:find("loot") or at:find("equip") or at:find("search") or at:find("open") then
        return true
    end
    if ot:find("gear") or ot:find("cog") or ot:find("item") or ot:find("medkit") or ot:find("battery") or ot:find("flashlight") or ot:find("chest") or ot:find("crate") or ot:find("tool") or ot:find("key") or ot:find("soda") or ot:find("drink") or ot:find("bandage") then
        return true
    end
    if pn:find("gear") or pn:find("cog") or pn:find("item") or pn:find("medkit") or pn:find("battery") or pn:find("flashlight") or pn:find("chest") or pn:find("crate") or pn:find("tool") or pn:find("key") or pn:find("pickup") or pn:find("drop") then
        return true
    end

    local pParentName = parent.Parent and parent.Parent.Name:lower() or ""
    if pParentName:find("item") or pParentName:find("spawner") or pParentName:find("gear") or pParentName:find("loot") or pParentName:find("pickup") then
        return true
    end

    if GearCache[parent] or ItemCache[parent] or (parent.Parent and (GearCache[parent.Parent] or ItemCache[parent.Parent])) then
        return true
    end

    return false
end

task.spawn(function()
    while Running do
        task.wait(0.2)
        if State.AutoProximityInteract and fireproximityprompt then
            local myChar = LocalPlayer.Character
            local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
            if myHRP then
                local myPos = myHRP.Position
                for prompt in pairs(ActivePromptCache) do
                    if prompt and prompt.Parent and prompt.Enabled then
                        if IsItemOrGearPrompt(prompt) then
                            local parentPart = prompt.Parent:IsA("BasePart") and prompt.Parent or prompt.Parent:FindFirstChildWhichIsA("BasePart")
                            if parentPart then
                                local dist = (parentPart.Position - myPos).Magnitude
                                if dist <= (prompt.MaxActivationDistance + 4) then
                                    fireproximityprompt(prompt)
                                    task.wait(0.08)
                                end
                            end
                        end
                    else
                        ActivePromptCache[prompt] = nil
                    end
                end
            end
        end
    end
end)

-- =========================================================================
-- ALERT BANNER & ESP FACTORY
-- =========================================================================
local AlertGui = Instance.new("ScreenGui")
AlertGui.Name = "ForsakenAlertGui"
AlertGui.ResetOnSpawn = false
pcall(function() AlertGui.Parent = CoreGui end)
if not AlertGui.Parent then AlertGui.Parent = LocalPlayer:WaitForChild("PlayerGui") end

local AlertLabel = Instance.new("TextLabel")
AlertLabel.Name = "AlertLabel"
AlertLabel.Size = UDim2.new(0, 360, 0, 42)
AlertLabel.Position = UDim2.new(0.5, -180, 0.12, 0)
AlertLabel.BackgroundColor3 = Color3.fromRGB(220, 20, 40)
AlertLabel.BackgroundTransparency = 0.2
AlertLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
AlertLabel.Font = Enum.Font.GothamBold
AlertLabel.TextSize = 16
AlertLabel.Text = "[!] KILLER NEARBY [!]"
AlertLabel.Visible = false
AlertLabel.BorderSizePixel = 0
AlertLabel.Parent = AlertGui

local AlertCorner = Instance.new("UICorner")
AlertCorner.CornerRadius = UDim.new(0, 8)
AlertCorner.Parent = AlertLabel

local AlertStroke = Instance.new("UIStroke")
AlertStroke.Color = Color3.fromRGB(255, 255, 255)
AlertStroke.Thickness = 1.5
AlertStroke.Transparency = 0.3
AlertStroke.Parent = AlertLabel

local ESPFolder = Instance.new("Folder")
ESPFolder.Name = "ForsakenESP"
pcall(function() ESPFolder.Parent = CoreGui end)
if not ESPFolder.Parent then ESPFolder.Parent = workspace end

local function CreateHighlight(adornee, color)
    local hl = Instance.new("Highlight")
    hl.Name = "ForsakenHighlight_" .. adornee.Name
    hl.Adornee = adornee
    hl.FillColor = color
    hl.FillTransparency = 0.55
    hl.OutlineColor = Color3.fromRGB(255, 255, 255)
    hl.OutlineTransparency = 0.1
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Parent = ESPFolder
    return hl
end

local function CreateBillboard(adornee, text, color)
    local bb = Instance.new("BillboardGui")
    bb.Name = "ForsakenBillboard_" .. adornee.Name
    bb.Adornee = adornee
    bb.Size = UDim2.new(0, 160, 0, 40)
    bb.StudsOffset = Vector3.new(0, 3.2, 0)
    bb.AlwaysOnTop = true
    bb.ResetOnSpawn = false
    bb.MaxDistance = 400

    local label = Instance.new("TextLabel")
    label.Name = "Label"
    label.Size = UDim2.new(1, 0, 1, 0)
    label.BackgroundTransparency = 1
    label.Font = Enum.Font.GothamBold
    label.TextSize = 13
    label.TextColor3 = color
    label.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    label.TextStrokeTransparency = 0.2
    label.Text = text
    label.Parent = bb

    bb.Parent = ESPFolder
    return bb, label
end

local function ClearESP()
    for _, item in pairs(Highlights) do
        if item and item.Parent then item:Destroy() end
    end
    table.clear(Highlights)

    for _, item in pairs(Billboards) do
        if item and item.Gui and item.Gui.Parent then item.Gui:Destroy() end
    end
    table.clear(Billboards)
end

-- =========================================================================
-- UNIVERSAL AUTO-SOLVER HOOKS FOR ALL 4 GENERATOR PUZZLES
-- =========================================================================
getgenv()._ForsakenCleanOriginals = getgenv()._ForsakenCleanOriginals or {}

local function GetClassValues(mod)
    if not mod then return nil end
    for k, v in pairs(mod) do
        if tostring(k):find("ClassValues") then
            return v
        end
    end
    return nil
end

local function SolveFlowGrid(size, pairsList)
    local numPairs = #pairsList
    local totalCells = size * size

    local function getNeighbors(cell)
        local r = math.floor((cell - 1) / size) + 1
        local c = ((cell - 1) % size) + 1
        local n = {}
        if r > 1 then table.insert(n, cell - size) end
        if r < size then table.insert(n, cell + size) end
        if c > 1 then table.insert(n, cell - 1) end
        if c < size then table.insert(n, cell + 1) end
        return n
    end

    local endpoints = {}
    for pIdx, p in ipairs(pairsList) do
        endpoints[p[1]] = pIdx
        endpoints[p[2]] = pIdx
    end

    local FlowBoardMod = FlowBoard or require(ReplicatedStorage.Modules.Minigames.FlowBoard)

    local adj = {}
    for i = 1, totalCells do adj[i] = getNeighbors(i) end

    local pairOrder = {}
    for i = 1, numPairs do table.insert(pairOrder, i) end
    table.sort(pairOrder, function(a, b)
        local pa, pb = pairsList[a], pairsList[b]
        local ra1, ca1 = math.floor((pa[1] - 1) / size) + 1, ((pa[1] - 1) % size) + 1
        local ra2, ca2 = math.floor((pa[2] - 1) / size) + 1, ((pa[2] - 1) % size) + 1
        local rb1, cb1 = math.floor((pb[1] - 1) / size) + 1, ((pb[1] - 1) % size) + 1
        local rb2, cb2 = math.floor((pb[2] - 1) / size) + 1, ((pb[2] - 1) % size) + 1
        local da = math.abs(ra1 - ra2) + math.abs(ca1 - ca2)
        local db = math.abs(rb1 - rb2) + math.abs(cb1 - cb2)
        return da < db
    end)

    local visited = {}
    local dfsPaths = {}

    local function canReach(startOrderIdx)
        for k = startOrderIdx, numPairs do
            local pidx = pairOrder[k]
            local s, t = pairsList[pidx][1], pairsList[pidx][2]
            local q = { s }
            local seen = { [s] = true }
            local found = false
            local qHead = 1
            while qHead <= #q do
                local curr = q[qHead]
                qHead = qHead + 1
                if curr == t then found = true break end
                for _, nxt in ipairs(adj[curr]) do
                    if not seen[nxt] and (not visited[nxt] or nxt == t) then
                        seen[nxt] = true
                        table.insert(q, nxt)
                    end
                end
            end
            if not found then return false end
        end
        return true
    end

    local maxDfsSteps = 45000
    local dfsStepCount = 0

    local function dfsPath(orderIdx, curr, target, currentPath)
        dfsStepCount = dfsStepCount + 1
        if dfsStepCount > maxDfsSteps then return false end

        if curr == target then
            local copied = {}
            for i, v in ipairs(currentPath) do copied[i] = v end
            dfsPaths[pairOrder[orderIdx]] = copied
            if orderIdx == numPairs then return true end
            if not canReach(orderIdx + 1) then return false end
            local nextP = pairOrder[orderIdx + 1]
            local ns, nt = pairsList[nextP][1], pairsList[nextP][2]
            visited[ns] = true
            local ok = dfsPath(orderIdx + 1, ns, nt, { ns })
            visited[ns] = false
            return ok
        end

        local tr = math.floor((target - 1) / size) + 1
        local tc = ((target - 1) % size) + 1

        local nbrs = {}
        for _, nxt in ipairs(adj[curr]) do
            if nxt == target then
                table.insert(nbrs, { dist = 0, cell = nxt })
            elseif not visited[nxt] and not endpoints[nxt] then
                local nr = math.floor((nxt - 1) / size) + 1
                local nc = ((nxt - 1) % size) + 1
                local d = math.abs(nr - tr) + math.abs(nc - tc)
                table.insert(nbrs, { dist = d, cell = nxt })
            end
        end
        table.sort(nbrs, function(a, b) return a.dist < b.dist end)

        for _, nInfo in ipairs(nbrs) do
            local nxt = nInfo.cell
            visited[nxt] = true
            table.insert(currentPath, nxt)
            if dfsPath(orderIdx, nxt, target, currentPath) then return true end
            table.remove(currentPath)
            visited[nxt] = false
        end
        return false
    end

    local firstP = pairOrder[1]
    local s1, t1 = pairsList[firstP][1], pairsList[firstP][2]
    visited[s1] = true
    local dfsSuccess = dfsPath(1, s1, t1, { s1 })
    visited[s1] = false

    if dfsSuccess and FlowBoardMod and FlowBoardMod.Validate then
        local valid = FlowBoardMod.Validate(size, pairsList, dfsPaths)
        if valid then return dfsPaths end
    elseif dfsSuccess then
        return dfsPaths
    end

    local cellOcc = {}
    local cellCost = {}
    for i = 1, totalCells do
        cellOcc[i] = 0
        cellCost[i] = 1
    end
    local paths = {}

    local function routePair(pIdx, presMult)
        local start = pairsList[pIdx][1]
        local target = pairsList[pIdx][2]
        local tr = math.floor((target - 1) / size) + 1
        local tc = ((target - 1) % size) + 1

        local openSet = { start }
        local cameFrom = {}
        local gScore = { [start] = 0 }
        local fScore = { [start] = math.abs(math.floor((start-1)/size)+1 - tr) + math.abs(((start-1)%size)+1 - tc) }
        local inOpen = { [start] = true }

        while #openSet > 0 do
            local bestIdx = 1
            for i = 2, #openSet do
                if fScore[openSet[i]] < fScore[openSet[bestIdx]] then bestIdx = i end
            end
            local current = table.remove(openSet, bestIdx)
            inOpen[current] = nil

            if current == target then
                local path = {}
                local curr = target
                while curr do
                    table.insert(path, 1, curr)
                    curr = cameFrom[curr]
                end
                return path
            end

            for _, nxt in ipairs(getNeighbors(current)) do
                local ep = endpoints[nxt]
                if ep == nil or nxt == target then
                    local cong = cellOcc[nxt]
                    local stepCost = cellCost[nxt] + (cong * presMult)
                    local tentG = gScore[current] + stepCost

                    if not gScore[nxt] or tentG < gScore[nxt] then
                        cameFrom[nxt] = current
                        gScore[nxt] = tentG
                        local nr = math.floor((nxt - 1) / size) + 1
                        local nc = ((nxt - 1) % size) + 1
                        local h = math.abs(nr - tr) + math.abs(nc - tc)
                        fScore[nxt] = tentG + h
                        if not inOpen[nxt] then
                            table.insert(openSet, nxt)
                            inOpen[nxt] = true
                        end
                    end
                end
            end
        end
        return nil
    end

    for pIdx = 1, numPairs do
        local p = routePair(pIdx, 0)
        paths[pIdx] = p
        if p then
            for i = 2, #p - 1 do cellOcc[p[i]] = cellOcc[p[i]] + 1 end
        end
    end

    local presMult = 2.0
    for _ = 1, 60 do
        local conflicts = 0
        for i = 1, totalCells do
            if cellOcc[i] > 1 then
                conflicts = conflicts + (cellOcc[i] - 1)
                cellCost[i] = cellCost[i] + (cellOcc[i] * 1.5)
            end
        end
        if conflicts == 0 then
            if FlowBoardMod and FlowBoardMod.Validate then
                local valid = FlowBoardMod.Validate(size, pairsList, paths)
                if valid then return paths end
            else
                return paths
            end
        end
        presMult = presMult + 2.5
        for pIdx = 1, numPairs do
            local p = paths[pIdx]
            local hasConflict = false
            if p then
                for i = 2, #p - 1 do
                    if cellOcc[p[i]] > 1 then hasConflict = true break end
                end
            else
                hasConflict = true
            end
            if hasConflict then
                if p then
                    for i = 2, #p - 1 do cellOcc[p[i]] = math.max(0, cellOcc[p[i]] - 1) end
                end
                local np = routePair(pIdx, presMult)
                paths[pIdx] = np
                if np then
                    for i = 2, #np - 1 do cellOcc[np[i]] = cellOcc[np[i]] + 1 end
                end
            end
        end
    end

    return nil
end

local flowCV = GetClassValues(FlowClientMinigame)
if flowCV and flowCV.Start then
    if not getgenv()._ForsakenCleanOriginals.FlowStart then
        getgenv()._ForsakenCleanOriginals.FlowStart = flowCV.Start
    end
    local cleanFlowStart = getgenv()._ForsakenCleanOriginals.FlowStart

    flowCV.Start = function(self, ...)
        cleanFlowStart(self, ...)
        if State.AutoAllPuzzles and self.Network then
            task.spawn(function()
                local tStart = os.clock()
                task.wait(0.15)

                pcall(function()
                    local props = self.Network.Properties
                    local size = props:Get("GridSize")
                    local pairsList = props:Get("Pairs")
                    if size and pairsList then
                        local sol = SolveFlowGrid(size, pairsList)
                        if sol and #sol == #pairsList then
                            local renderer = self.__renderer
                            local board = renderer and renderer.Board

                            local totalSteps = 0
                            for _, path in ipairs(sol) do
                                totalSteps = totalSteps + math.max(1, #path - 1)
                            end
                            local stepDelay = math.clamp(1.70 / math.max(1, totalSteps), 0.015, 0.06)

                            for pIdx, path in ipairs(sol) do
                                if not self or not self.Network then break end
                                if board then
                                    board.Paths[pIdx] = { path[1] }
                                end

                                for step = 2, #path do
                                    if not self or not self.Network then break end
                                    if board then
                                        table.insert(board.Paths[pIdx], path[step])
                                        pcall(function() renderer:Render() end)
                                    end
                                    task.wait(stepDelay)
                                end

                                if board and renderer then
                                    pcall(function() renderer:Render() end)
                                end
                            end

                            if board then
                                pcall(function()
                                    board:__rebuild()
                                    if renderer then renderer:Render() end
                                end)
                            end

                            local elapsed = os.clock() - tStart
                            if elapsed < 1.95 then
                                task.wait(2.0 - elapsed)
                            end

                            if self and self.Network then
                                if self.__input then
                                    pcall(function() self.__input:__finish() end)
                                end
                                self.Network:FireServer("Submit", sol)
                                pcall(function()
                                    local Sounds = require(ReplicatedStorage.Modules.Rendering.Sounds)
                                    Sounds:Play("puzzleDone")
                                end)
                                Notify("Flow Solved", string.format("Сетка %dx%d решена (%d проводов)", size, size, #pairsList), 2.0)
                            end
                        end
                    end
                end)
            end)
        end
    end
end

local connectCV = GetClassValues(ConnectClientMinigame)
if connectCV and connectCV.Start then
    if not getgenv()._ForsakenCleanOriginals.ConnectStart then
        getgenv()._ForsakenCleanOriginals.ConnectStart = connectCV.Start
    end
    local cleanConnectStart = getgenv()._ForsakenCleanOriginals.ConnectStart

    connectCV.Start = function(self, ...)
        cleanConnectStart(self, ...)
        if State.AutoAllPuzzles and self.Network then
            task.spawn(function()
                task.wait(math.random(400, 600) / 1000)
                pcall(function()
                    local props = self.Network.Properties
                    local blobs = props:Get("Blobs")
                    if blobs and ConnectBoard then
                        local b = ConnectBoard.new(blobs)
                        local renderer = self.__renderer

                        for i = 1, #b.Blobs do
                            if not self or not self.Network then break end
                            local mate = b.Mates[i]
                            if mate and not b.Links[i] then
                                b:Connect(i, mate)
                                if renderer then
                                    pcall(function() renderer:Render() end)
                                end
                                task.wait(math.random(420, 650) / 1000)
                            end
                        end

                        task.wait(math.random(220, 350) / 1000)
                        if self and self.Network then
                            self.Network:FireServer("Submit", b:Export())
                            pcall(function() self:Finish() end)
                            Notify("Connect Solved", "Головоломка Connect решена!", 2.5)
                        end
                    end
                end)
            end)
        end
    end
end

local lockCV = GetClassValues(LockClientMinigame)
if lockCV and lockCV.Start then
    if not getgenv()._ForsakenCleanOriginals.LockStart then
        getgenv()._ForsakenCleanOriginals.LockStart = lockCV.Start
    end
    local cleanLockStart = getgenv()._ForsakenCleanOriginals.LockStart

    lockCV.Start = function(self, ...)
        cleanLockStart(self, ...)
        if State.AutoAllPuzzles and self.Network then
            task.spawn(function()
                task.wait(0.12)

                local board = nil
                local onPress = nil

                for _ = 1, 15 do
                    if self.__renderer and self.__renderer.Board then
                        board = self.__renderer.Board
                    end
                    if self.__input and self.__input.Callbacks and self.__input.Callbacks.OnPress then
                        onPress = self.__input.Callbacks.OnPress
                    end
                    if board then break end
                    task.wait(0.04)
                end

                if not board and self.__input and self.__input.Board then
                    board = self.__input.Board
                end

                local startTime = os.clock()
                local lastPressTime = 0

                while self and self.Network and (os.clock() - startTime < 45) do
                    RunService.Heartbeat:Wait()
                    if not self or not self.Network then break end

                    if board and board.State and board.State.Remaining and board.State.Remaining <= 0 then
                        break
                    end
                    if board and board.IsBroken and board:IsBroken() then
                        break
                    end

                    local stNow = workspace:GetServerTimeNow()
                    local shouldPress = false

                    if board and board.AngleAt and board.State and board.State.Target then
                        local currentAngle = board:AngleAt(stNow)
                        local targetAngle = board.State.Target
                        local targetSize = (board.Config and board.Config.TargetSize) or 35
                        local diff = math.abs((currentAngle - targetAngle + 180) % 360 - 180)
                        if diff <= (targetSize * 0.30) then
                            shouldPress = true
                        end
                    elseif board and board.AngleAt and board.IsOnTarget then
                        local currentAngle = board:AngleAt(stNow)
                        if board:IsOnTarget(currentAngle) then
                            shouldPress = true
                        end
                    elseif self.__renderer and self.__renderer.Line and self.__renderer.__target then
                        local lineRot = self.__renderer.Line.Rotation % 360
                        local targetRot = self.__renderer.__target.Rotation % 360
                        local diff = math.abs((lineRot - targetRot + 180) % 360 - 180)
                        if diff <= 12 then
                            shouldPress = true
                        end
                    end

                    if shouldPress and (os.clock() - lastPressTime > 0.38) then
                        lastPressTime = os.clock()
                        local pressTime = workspace:GetServerTimeNow()
                        if onPress then
                            pcall(onPress)
                        elseif self.Network then
                            self.Network:FireServer("Press", pressTime)
                        end
                        task.wait(0.32)
                    end
                end

                Notify("Lock Solved", "Замок успешно открыт!", 2.5)
            end)
        end
    end
end

local gearCV = GetClassValues(GearClientMinigame)
if gearCV and gearCV.Start then
    if not getgenv()._ForsakenCleanOriginals.GearStart then
        getgenv()._ForsakenCleanOriginals.GearStart = gearCV.Start
    end
    local cleanGearStart = getgenv()._ForsakenCleanOriginals.GearStart

    gearCV.Start = function(self, ...)
        cleanGearStart(self, ...)
        if State.AutoAllPuzzles and self.Network then
            task.spawn(function()
                task.wait(math.random(400, 600) / 1000)
                pcall(function()
                    local turns = self.Network.Properties:Get("Turns") or 5
                    for _ = 1, turns do
                        if not self or not self.Network then break end
                        task.wait(math.random(750, 920) / 1000)
                        self.Network:FireServer("Screwed")
                    end
                    task.wait(0.25)
                    Notify("Gear Solved", "Шестерёнки закручены!", 2.5)
                end)
            end)
        end
    end
end

-- =========================================================================
-- TRIGGERBOT & KILLER AIM ENGINE
-- =========================================================================
local CachedIsKiller = nil
local LastRoleCheckTime = 0

local function IsLocalPlayerKiller()
    local now = os.clock()
    if CachedIsKiller ~= nil and (now - LastRoleCheckTime) < 2.0 then
        return CachedIsKiller
    end
    LastRoleCheckTime = now

    local myChar = LocalPlayer.Character
    if not myChar then
        CachedIsKiller = false
        return false
    end
    local playersRoot = workspace:FindFirstChild("Players")
    if playersRoot then
        local killersFolder = playersRoot:FindFirstChild("Killers")
        if killersFolder and killersFolder:FindFirstChild(myChar.Name) then
            CachedIsKiller = true
            return true
        end
    end
    local role = myChar:GetAttribute("Role") or (LocalPlayer.Team and LocalPlayer.Team.Name) or ""
    if tostring(role):lower():find("killer") then
        CachedIsKiller = true
        return true
    end
    CachedIsKiller = false
    return false
end

local LastTriggerbotTime = 0
local function RunTriggerbot()
    if not State.Triggerbot or not IsLocalPlayerKiller() then return end

    local myChar = LocalPlayer.Character
    local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
    if not myHRP then return end

    local playersRoot = workspace:FindFirstChild("Players")
    local survivorsFolder = playersRoot and playersRoot:FindFirstChild("Survivors")
    if not survivorsFolder then return end

    local myPos = myHRP.Position
    local closestDist = 999999
    local closestHRP = nil

    for _, surv in ipairs(survivorsFolder:GetChildren()) do
        if surv:IsA("Model") and surv ~= myChar then
            local sHRP = surv:FindFirstChild("HumanoidRootPart")
            local hum = surv:FindFirstChildOfClass("Humanoid")
            if sHRP and (not hum or hum.Health > 0) then
                local dist = (sHRP.Position - myPos).Magnitude
                if dist < closestDist then
                    closestDist = dist
                    closestHRP = sHRP
                end
            end
        end
    end

    if closestHRP then
        local flatTarget = Vector3.new(closestHRP.Position.X, myHRP.Position.Y, closestHRP.Position.Z)
        myHRP.CFrame = CFrame.lookAt(myHRP.Position, flatTarget)

        local now = os.clock()
        if closestDist <= State.TriggerbotRange and (now - LastTriggerbotTime) >= State.TriggerbotCooldown then
            LastTriggerbotTime = now
            if mouse1click then
                mouse1click()
            else
                VirtualInputManager:SendMouseButtonEvent(0, 0, 0, true, game, 1)
                task.delay(0.04, function()
                    VirtualInputManager:SendMouseButtonEvent(0, 0, 0, false, game, 1)
                end)
            end
            local tool = myChar:FindFirstChildWhichIsA("Tool")
            if tool then
                pcall(function() tool:Activate() end)
            end
        end
    end
end

-- =========================================================================
-- RUNTIME LOOPS (MOVEMENT, COMBAT, LIGHTING, FOV)
-- =========================================================================
local IsShiftEmulated = false
local LastMoveTime = 0
local LastBlockTime = 0
local LastAntiSlowCheck = 0
local LastVFXCheck = 0

TrackConnection(RunService.Stepped:Connect(function()
    if not Running then return end
    local myChar = LocalPlayer.Character
    if not myChar then return end

    local hum = myChar:FindFirstChildOfClass("Humanoid")
    if hum and State.ForcedJump then
        hum.UseJumpPower = true
        hum.JumpPower = State.JumpPower
        hum.JumpHeight = State.JumpPower / 7
        hum:SetStateEnabled(Enum.HumanoidStateType.Jumping, true)
    end

    local now = os.clock()
    if State.AntiSlow and (now - LastAntiSlowCheck) > 0.12 then
        LastAntiSlowCheck = now
        local sm = myChar:FindFirstChild("SpeedMultipliers")
        if sm then
            for _, val in ipairs(sm:GetChildren()) do
                if val:IsA("NumberValue") and val.Value < 1 and val.Name ~= "DirectionalMovement" then
                    val.Value = 1
                end
            end
        end
        local scm = myChar:FindFirstChild("SpeedCapMultipliers")
        if scm then
            for _, val in ipairs(scm:GetChildren()) do
                if val:IsA("NumberValue") and val.Value < 1 then
                    val.Value = 1
                end
            end
        end
    end
end))

TrackConnection(RunService.Heartbeat:Connect(function()
    if not Running then return end
    local now = os.clock()
    local myChar = LocalPlayer.Character
    local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
    local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")

    if State.InfiniteStamina and SprintingModule then
        SprintingModule.StaminaLossDisabled = true
        SprintingModule.Stamina = SprintingModule.MaxStamina or 110
    end

    if State.AutoSprint and hum then
        local isMoving = hum.MoveDirection.Magnitude > 0.05
        if isMoving then
            LastMoveTime = now
        end

        if (now - LastMoveTime) < 0.30 then
            if SprintingModule then
                SprintingModule.IsSprinting = true
                if SprintingModule.StartSprinting and not SprintingModule.IsSprinting then
                    pcall(function() SprintingModule:StartSprinting() end)
                end
            end

            local targetSpeed = (SprintingModule and SprintingModule.SprintSpeed) or 26
            if hum.WalkSpeed < targetSpeed then
                hum.WalkSpeed = targetSpeed
            end

            local sm = myChar:FindFirstChild("SpeedMultipliers")
            if sm then
                local spVal = sm:FindFirstChild("Sprint")
                if spVal and spVal:IsA("NumberValue") and spVal.Value < 1.6 then
                    spVal.Value = 1.65
                end
            end

            if not IsShiftEmulated then
                IsShiftEmulated = true
                VirtualInputManager:SendKeyEvent(true, Enum.KeyCode.LeftShift, false, game)
            end
        elseif IsShiftEmulated then
            IsShiftEmulated = false
            VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.LeftShift, false, game)
            if SprintingModule and SprintingModule.StopSprinting then
                pcall(function() SprintingModule:StopSprinting() end)
            end
        end
    elseif IsShiftEmulated then
        IsShiftEmulated = false
        VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.LeftShift, false, game)
    end

    if State.Fullbright then
        Lighting.Ambient = Color3.fromRGB(255, 255, 255)
        Lighting.OutdoorAmbient = Color3.fromRGB(255, 255, 255)
        Lighting.Brightness = 2
        Lighting.ClockTime = 14
        Lighting.FogEnd = 100000
        Lighting.GlobalShadows = false
    end

    if Camera and State.CustomFOV ~= 70 and math.abs(Camera.FieldOfView - State.CustomFOV) > 0.5 then
        Camera.FieldOfView = State.CustomFOV
    end

    if State.RemoveVFX and (now - LastVFXCheck) > 0.5 then
        LastVFXCheck = now
        local pg = LocalPlayer:FindFirstChild("PlayerGui")
        local mainUI = pg and pg:FindFirstChild("MainUI")
        local vig = mainUI and mainUI:FindFirstChild("InsaneVignette")
        if vig and vig.Visible then vig.Visible = false end
    end

    if myHRP and (State.AutoBlock or State.AutoAvoidKiller) then
        local killersFolder = workspace:FindFirstChild("Players") and workspace.Players:FindFirstChild("Killers")
        if killersFolder then
            for _, killer in ipairs(killersFolder:GetChildren()) do
                local kHRP = killer:FindFirstChild("HumanoidRootPart")
                if kHRP then
                    local dist = (kHRP.Position - myHRP.Position).Magnitude

                    if State.AutoBlock and dist <= State.AutoBlockRange and (now - LastBlockTime) > 2.5 then
                        LastBlockTime = now
                        local flatTarget = Vector3.new(kHRP.Position.X, myHRP.Position.Y, kHRP.Position.Z)
                        myHRP.CFrame = CFrame.lookAt(myHRP.Position, flatTarget)
                        VirtualInputManager:SendKeyEvent(true, Enum.KeyCode.Q, false, game)
                        task.delay(0.06, function()
                            VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.Q, false, game)
                        end)
                    end

                    if State.AutoAvoidKiller and dist <= State.AutoAvoidKillerRange then
                        local avoidDir, upBoost = GetSmartAvoidVector(myHRP, kHRP)
                        local curY = myHRP.AssemblyLinearVelocity.Y
                        myHRP.AssemblyLinearVelocity = Vector3.new(
                            avoidDir.X * State.AvoidRepelForce,
                            math.max(curY, upBoost),
                            avoidDir.Z * State.AvoidRepelForce
                        )
                    end
                end
            end
        end
    end

    if State.Triggerbot then
        RunTriggerbot()
    end
end))

TrackConnection(UserInputService.JumpRequest:Connect(function()
    if not Running then return end
    local myChar = LocalPlayer.Character
    local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
    local hrp = myChar and myChar:FindFirstChild("HumanoidRootPart")

    if State.ForcedJump or State.InfiniteJump then
        if hum then
            hum:ChangeState(Enum.HumanoidStateType.Jumping)
        end
        if hrp and State.InfiniteJump then
            hrp.AssemblyLinearVelocity = Vector3.new(hrp.AssemblyLinearVelocity.X, State.JumpPower, hrp.AssemblyLinearVelocity.Z)
        end
    end
end))

-- =========================================================================
-- PROXIMITY-PRIORITIZED HIGHLIGHTS & ESP LOOP
-- =========================================================================
local MAX_ACTIVE_HIGHLIGHTS = 28
local MAX_ESP_DISTANCE = 400

local function UpdateHighlightsPriority(candidates)
    if not State.ChamsEnabled then
        for _, hl in pairs(Highlights) do
            if hl and hl.Parent then hl:Destroy() end
        end
        table.clear(Highlights)
        return
    end

    table.sort(candidates, function(a, b) return a.Score < b.Score end)

    local activeSet = {}
    local count = 0

    for _, c in ipairs(candidates) do
        if c.Dist and c.Dist > MAX_ESP_DISTANCE then
            continue
        end
        count = count + 1
        if count <= MAX_ACTIVE_HIGHLIGHTS then
            activeSet[c.Object] = true
            local hl = Highlights[c.Object]
            if not hl then
                Highlights[c.Object] = CreateHighlight(c.Object, c.Color)
            elseif hl.FillColor ~= c.Color then
                hl.FillColor = c.Color
            end
        else
            break
        end
    end

    for obj, hl in pairs(Highlights) do
        if not activeSet[obj] then
            if hl and hl.Parent then hl:Destroy() end
            Highlights[obj] = nil
        end
    end
end

task.spawn(function()
    while Running do
        task.wait(0.25)
        if not Running then break end
        if not State.ESPEnabled then
            ClearESP()
            AlertLabel.Visible = false
        else
            local myChar = LocalPlayer.Character
            local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
            local myPos = myHRP and myHRP.Position or Camera.CFrame.Position

            local closestKillerDist = 999999
            local closestKillerName = ""
            local highlightCandidates = {}

            local playersRoot = workspace:FindFirstChild("Players")
            if playersRoot then
                if State.SurvivorsESP then
                    local sFolder = playersRoot:FindFirstChild("Survivors")
                    if sFolder then
                        for _, char in ipairs(sFolder:GetChildren()) do
                            if char ~= myChar and char:IsA("Model") then
                                local hrp = char:FindFirstChild("HumanoidRootPart")
                                local hum = char:FindFirstChildOfClass("Humanoid")
                                if hrp then
                                    local dist = math.floor((hrp.Position - myPos).Magnitude)
                                    if dist <= MAX_ESP_DISTANCE then
                                        local hp = hum and math.floor(hum.Health) or 0
                                        local rec = Billboards[char]

                                        if not rec then
                                            local role = char:GetAttribute("ActorDisplayName") or char.Name
                                            local user = char:GetAttribute("Username") or ""
                                            local maxHp = hum and math.floor(hum.MaxHealth) or 100
                                            local text = string.format("[SURVIVOR] %s (%s)\nHP: %d/%d | %dm", role, user ~= "" and user or char.Name, hp, maxHp, dist)
                                            local bb, lbl = CreateBillboard(hrp, text, Color3.fromRGB(0, 255, 140))
                                            Billboards[char] = { Gui = bb, Label = lbl, LastDist = dist, LastHp = hp, Role = role, User = user, MaxHp = maxHp }
                                        elseif math.abs((rec.LastDist or 0) - dist) >= 2 or rec.LastHp ~= hp then
                                            rec.LastDist = dist
                                            rec.LastHp = hp
                                            rec.Label.Text = string.format("[SURVIVOR] %s (%s)\nHP: %d/%d | %dm", rec.Role, rec.User ~= "" and rec.User or char.Name, hp, rec.MaxHp, dist)
                                        end

                                        if State.ChamsEnabled then
                                            table.insert(highlightCandidates, { Object = char, Color = Color3.fromRGB(0, 255, 140), Score = dist - 1000, Dist = dist })
                                        end
                                    elseif Billboards[char] then
                                        if Billboards[char].Gui and Billboards[char].Gui.Parent then Billboards[char].Gui:Destroy() end
                                        Billboards[char] = nil
                                    end
                                end
                            end
                        end
                    end
                end

                if State.KillersESP then
                    local kFolder = playersRoot:FindFirstChild("Killers")
                    if kFolder then
                        for _, char in ipairs(kFolder:GetChildren()) do
                            if char ~= myChar and char:IsA("Model") then
                                local hrp = char:FindFirstChild("HumanoidRootPart")
                                local hum = char:FindFirstChildOfClass("Humanoid")
                                if hrp then
                                    local dist = math.floor((hrp.Position - myPos).Magnitude)
                                    local role = char:GetAttribute("ActorDisplayName") or char.Name
                                    local user = char:GetAttribute("Username") or ""

                                    if dist < closestKillerDist then
                                        closestKillerDist = dist
                                        closestKillerName = role ~= "" and role or user
                                    end

                                    if dist <= MAX_ESP_DISTANCE then
                                        local hp = hum and math.floor(hum.Health) or 0
                                        local rec = Billboards[char]
                                        if not rec then
                                            local text = string.format("[KILLER] %s (%s)\nHP: %d | %dm", role, user ~= "" and user or char.Name, hp, dist)
                                            local bb, lbl = CreateBillboard(hrp, text, Color3.fromRGB(255, 45, 45))
                                            Billboards[char] = { Gui = bb, Label = lbl, LastDist = dist, LastHp = hp, Role = role, User = user }
                                        elseif math.abs((rec.LastDist or 0) - dist) >= 2 or rec.LastHp ~= hp then
                                            rec.LastDist = dist
                                            rec.LastHp = hp
                                            rec.Label.Text = string.format("[KILLER] %s (%s)\nHP: %d | %dm", rec.Role, rec.User ~= "" and rec.User or char.Name, hp, dist)
                                        end

                                        if State.ChamsEnabled then
                                            table.insert(highlightCandidates, { Object = char, Color = Color3.fromRGB(255, 45, 45), Score = dist - 2500, Dist = dist })
                                        end
                                    elseif Billboards[char] then
                                        if Billboards[char].Gui and Billboards[char].Gui.Parent then Billboards[char].Gui:Destroy() end
                                        Billboards[char] = nil
                                    end
                                end
                            end
                        end
                    end
                end
            end

            if State.KillerAlert and closestKillerDist <= State.KillerAlertDistance then
                AlertLabel.Text = string.format("[!] KILLER ALERT: %s (%dm) [!]", closestKillerName, closestKillerDist)
                AlertLabel.Visible = true
            else
                AlertLabel.Visible = false
            end

            if State.GeneratorsESP then
                local seenGens = {}
                for gen, mainPart in pairs(GeneratorCache) do
                    if gen and gen.Parent and mainPart and mainPart.Parent and mainPart:IsDescendantOf(workspace) then
                        local posKey = string.format("%d_%d_%d", math.floor(mainPart.Position.X / 6), math.floor(mainPart.Position.Y / 6), math.floor(mainPart.Position.Z / 6))
                        if seenGens[posKey] then
                            if Billboards[gen] then
                                if Billboards[gen].Gui and Billboards[gen].Gui.Parent then Billboards[gen].Gui:Destroy() end
                                Billboards[gen] = nil
                            end
                        else
                            seenGens[posKey] = true
                            local dist = math.floor((mainPart.Position - myPos).Magnitude)
                            if dist <= MAX_ESP_DISTANCE then
                                local prog = GetGeneratorProgress(gen)
                                local isDone = prog >= 100
                                local col = isDone and Color3.fromRGB(110, 255, 130) or Color3.fromRGB(255, 215, 0)
                                local rec = Billboards[gen]

                                if not rec then
                                    local text = string.format("[GEN] %d%% | %dm", prog, dist)
                                    local bb, lbl = CreateBillboard(mainPart, text, col)
                                    Billboards[gen] = { Gui = bb, Label = lbl, LastDist = dist, LastProg = prog }
                                elseif math.abs((rec.LastDist or 0) - dist) >= 2 or rec.LastProg ~= prog then
                                    rec.LastDist = dist
                                    rec.LastProg = prog
                                    rec.Label.Text = string.format("[GEN] %d%% | %dm", prog, dist)
                                    rec.Label.TextColor3 = col
                                end

                                if State.ChamsEnabled then
                                    table.insert(highlightCandidates, { Object = gen, Color = col, Score = dist, Dist = dist })
                                end
                            elseif Billboards[gen] then
                                if Billboards[gen].Gui and Billboards[gen].Gui.Parent then Billboards[gen].Gui:Destroy() end
                                Billboards[gen] = nil
                            end
                        end
                    else
                        UnregisterInstance(gen)
                    end
                end
            end

            if State.GearsESP then
                for gear, part in pairs(GearCache) do
                    if IsObjectPresent(gear, part) then
                        local dist = math.floor((part.Position - myPos).Magnitude)
                        if dist <= MAX_ESP_DISTANCE then
                            local col = Color3.fromRGB(0, 210, 255)
                            local rec = Billboards[gear]
                            if not rec then
                                local text = string.format("[GEAR] %dm", dist)
                                local bb, lbl = CreateBillboard(part, text, col)
                                Billboards[gear] = { Gui = bb, Label = lbl, LastDist = dist }
                            elseif math.abs((rec.LastDist or 0) - dist) >= 2 then
                                rec.LastDist = dist
                                rec.Label.Text = string.format("[GEAR] %dm", dist)
                            end

                            if State.ChamsEnabled then
                                table.insert(highlightCandidates, { Object = gear, Color = col, Score = dist - 200, Dist = dist })
                            end
                        elseif Billboards[gear] then
                            if Billboards[gear].Gui and Billboards[gear].Gui.Parent then Billboards[gear].Gui:Destroy() end
                            Billboards[gear] = nil
                        end
                    else
                        if Billboards[gear] then
                            if Billboards[gear].Gui and Billboards[gear].Gui.Parent then Billboards[gear].Gui:Destroy() end
                            Billboards[gear] = nil
                        end
                        if not gear or not gear.Parent then
                            GearCache[gear] = nil
                        end
                    end
                end
            end

            if State.TrapsESP then
                for trap, part in pairs(TrapCache) do
                    if trap and trap.Parent and part and part.Parent and part:IsDescendantOf(workspace) then
                        local dist = math.floor((part.Position - myPos).Magnitude)
                        if dist <= MAX_ESP_DISTANCE then
                            local col = Color3.fromRGB(255, 120, 0)
                            local trapName = trap.Name or "Trap"
                            local rec = Billboards[trap]
                            if not rec then
                                local text = string.format("[TRAP] %s\n%dm", trapName, dist)
                                local bb, lbl = CreateBillboard(part, text, col)
                                Billboards[trap] = { Gui = bb, Label = lbl, LastDist = dist }
                            elseif math.abs((rec.LastDist or 0) - dist) >= 2 then
                                rec.LastDist = dist
                                rec.Label.Text = string.format("[TRAP] %s\n%dm", trapName, dist)
                            end

                            if State.ChamsEnabled then
                                table.insert(highlightCandidates, { Object = trap, Color = col, Score = dist, Dist = dist })
                            end
                        elseif Billboards[trap] then
                            if Billboards[trap].Gui and Billboards[trap].Gui.Parent then Billboards[trap].Gui:Destroy() end
                            Billboards[trap] = nil
                        end
                    else
                        UnregisterInstance(trap)
                    end
                end
            end

            if State.ItemsESP then
                for item, data in pairs(ItemCache) do
                    local part = data.Part
                    if IsObjectPresent(item, part) then
                        local dist = math.floor((part.Position - myPos).Magnitude)
                        if dist <= MAX_ESP_DISTANCE then
                            local col = Color3.fromRGB(130, 255, 140)
                            local itemName = data.Name or "Item"
                            local rec = Billboards[item]
                            if not rec then
                                local text = string.format("[ITEM] %s\n%dm", itemName, dist)
                                local bb, lbl = CreateBillboard(part, text, col)
                                Billboards[item] = { Gui = bb, Label = lbl, LastDist = dist }
                            elseif math.abs((rec.LastDist or 0) - dist) >= 2 then
                                rec.LastDist = dist
                                rec.Label.Text = string.format("[ITEM] %s\n%dm", itemName, dist)
                            end

                            if State.ChamsEnabled then
                                table.insert(highlightCandidates, { Object = item, Color = col, Score = dist - 150, Dist = dist })
                            end
                        elseif Billboards[item] then
                            if Billboards[item].Gui and Billboards[item].Gui.Parent then Billboards[item].Gui:Destroy() end
                            Billboards[item] = nil
                        end
                    else
                        if Billboards[item] then
                            if Billboards[item].Gui and Billboards[item].Gui.Parent then Billboards[item].Gui:Destroy() end
                            Billboards[item] = nil
                        end
                        if not item or not item.Parent then
                            ItemCache[item] = nil
                        end
                    end
                end
            end

            UpdateHighlightsPriority(highlightCandidates)
        end
    end
end)

-- =========================================================================
-- GLOBAL CLEANUP
-- =========================================================================
getgenv().ForsakenCleanup = function()
    Running = false

    for _, conn in ipairs(Connections) do
        pcall(function() conn:Disconnect() end)
    end
    table.clear(Connections)

    ClearESP()
    table.clear(GeneratorCache)
    table.clear(GearCache)
    table.clear(TrapCache)
    table.clear(ItemCache)
    table.clear(ActivePromptCache)

    if ESPFolder and ESPFolder.Parent then ESPFolder:Destroy() end
    if AlertGui and AlertGui.Parent then AlertGui:Destroy() end

    if IsShiftEmulated then
        VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.LeftShift, false, game)
        IsShiftEmulated = false
    end

    for _, prompt in ipairs(workspace:GetDescendants()) do
        if prompt:IsA("ProximityPrompt") then
            local orig = prompt:GetAttribute("OrigHold")
            if orig ~= nil then prompt.HoldDuration = orig end
            local origDist = prompt:GetAttribute("OrigDist")
            if origDist ~= nil then prompt.MaxActivationDistance = origDist end
            local origLOS = prompt:GetAttribute("OrigLOS")
            if origLOS ~= nil then prompt.RequiresLineOfSight = origLOS end
        end
    end

    Lighting.Ambient = OriginalLighting.Ambient
    Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
    Lighting.Brightness = OriginalLighting.Brightness
    Lighting.ClockTime = OriginalLighting.ClockTime
    Lighting.FogEnd = OriginalLighting.FogEnd
    Lighting.GlobalShadows = OriginalLighting.GlobalShadows

    if SprintingModule then
        SprintingModule.StaminaLossDisabled = false
        SprintingModule.SprintSpeed = 28
    end

    if getgenv()._ForsakenCleanOriginals then
        if flowCV and getgenv()._ForsakenCleanOriginals.FlowStart then
            flowCV.Start = getgenv()._ForsakenCleanOriginals.FlowStart
        end
        if connectCV and getgenv()._ForsakenCleanOriginals.ConnectStart then
            connectCV.Start = getgenv()._ForsakenCleanOriginals.ConnectStart
        end
        if lockCV and getgenv()._ForsakenCleanOriginals.LockStart then
            lockCV.Start = getgenv()._ForsakenCleanOriginals.LockStart
        end
        if gearCV and getgenv()._ForsakenCleanOriginals.GearStart then
            gearCV.Start = getgenv()._ForsakenCleanOriginals.GearStart
        end
    end

    pcall(function() Rayfield:Destroy() end)
end

-- =========================================================================
-- RAYFIELD UI WINDOW & TABS
-- =========================================================================
local Window = Rayfield:CreateWindow({
    Name = "Forsaken",
    Icon = 0,
    LoadingTitle = "Forsaken",
    LoadingSubtitle = "Loading script...",
    Theme = "Default",
    DisableRayfieldPrompts = true,
    DisableBuildWarnings = true,
    ConfigurationSaving = {
        Enabled = false,
    },
    KeySystem = false,
    ToggleUIKeybind = "F1",
})

-- 1. MOVEMENT
local TabMovement = Window:CreateTab("Movement", "footprints")
TabMovement:CreateSection("Jump & Movement")

TabMovement:CreateToggle({
    Name = "Forced Jump (Разблокировать прыжок)",
    CurrentValue = State.ForcedJump,
    Flag = "ForcedJump",
    Callback = function(val)
        State.ForcedJump = val
        local myChar = LocalPlayer.Character
        local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
        if hum then
            hum.UseJumpPower = true
            hum.JumpPower = val and State.JumpPower or 0
            hum.JumpHeight = val and (State.JumpPower / 7) or 0
            hum:SetStateEnabled(Enum.HumanoidStateType.Jumping, val)
        end
    end,
})

TabMovement:CreateToggle({
    Name = "Infinite Stamina (Бесконечная выносливость)",
    CurrentValue = State.InfiniteStamina,
    Flag = "InfiniteStamina",
    Callback = function(val)
        State.InfiniteStamina = val
        if SprintingModule then
            SprintingModule.StaminaLossDisabled = val
            if val then SprintingModule.Stamina = SprintingModule.MaxStamina or 110 end
        end
    end,
})

TabMovement:CreateToggle({
    Name = "Infinite Jump (Бесконечный прыжок)",
    CurrentValue = State.InfiniteJump,
    Flag = "InfiniteJump",
    Callback = function(val)
        State.InfiniteJump = val
    end,
})

TabMovement:CreateToggle({
    Name = "Anti-Slow (Снятие замедлений)",
    CurrentValue = State.AntiSlow,
    Flag = "AntiSlow",
    Callback = function(val)
        State.AntiSlow = val
    end,
})

TabMovement:CreateToggle({
    Name = "Auto-Sprint (Бег без Shift)",
    CurrentValue = State.AutoSprint,
    Flag = "AutoSprint",
    Callback = function(val)
        State.AutoSprint = val
    end,
})

TabMovement:CreateSection("Values")

TabMovement:CreateSlider({
    Name = "Jump Power",
    Range = { 20, 120 },
    Increment = 5,
    CurrentValue = State.JumpPower,
    Flag = "JumpPower",
    Callback = function(val)
        State.JumpPower = val
        local myChar = LocalPlayer.Character
        local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
        if hum and State.ForcedJump then
            hum.UseJumpPower = true
            hum.JumpPower = val
            hum.JumpHeight = val / 7
        end
    end,
})

-- 2. COMBAT
local TabCombat = Window:CreateTab("Combat", "sword")
TabCombat:CreateSection("Auto Defense")

TabCombat:CreateToggle({
    Name = "Auto-Block (Парирование Q)",
    CurrentValue = State.AutoBlock,
    Flag = "AutoBlock",
    Callback = function(val)
        State.AutoBlock = val
    end,
})

TabCombat:CreateToggle({
    Name = "Auto-Avoid Killer (Авто-отталкивание)",
    CurrentValue = State.AutoAvoidKiller,
    Flag = "AutoAvoidKiller",
    Callback = function(val)
        State.AutoAvoidKiller = val
    end,
})

TabCombat:CreateSlider({
    Name = "Auto-Block Distance",
    Range = { 8, 22 },
    Increment = 1,
    Suffix = "m",
    CurrentValue = State.AutoBlockRange,
    Flag = "AutoBlockRange",
    Callback = function(val)
        State.AutoBlockRange = val
    end,
})

TabCombat:CreateSlider({
    Name = "Avoid Distance",
    Range = { 8, 30 },
    Increment = 1,
    Suffix = "m",
    CurrentValue = State.AutoAvoidKillerRange,
    Flag = "AutoAvoidKillerRange",
    Callback = function(val)
        State.AutoAvoidKillerRange = val
    end,
})

TabCombat:CreateSlider({
    Name = "Repel Force (Сила отталкивания)",
    Range = { 30, 140 },
    Increment = 5,
    CurrentValue = State.AvoidRepelForce,
    Flag = "AvoidRepelForce",
    Callback = function(val)
        State.AvoidRepelForce = val
    end,
})

TabCombat:CreateSection("Manual Avoid")

TabCombat:CreateKeybind({
    Name = "Avoid Impulse Keybind",
    CurrentKeybind = "V",
    HoldToInteract = false,
    Flag = "AvoidKeybind",
    Callback = function()
        ExecuteAvoidImpulse()
    end,
})

TabCombat:CreateButton({
    Name = "Manual Avoid Impulse (Рывок от маньяка)",
    Callback = function()
        ExecuteAvoidImpulse()
    end,
})

TabCombat:CreateSection("Triggerbot (Killer)")

TabCombat:CreateToggle({
    Name = "Triggerbot (Авто-аим и M1 маньяка)",
    CurrentValue = State.Triggerbot,
    Flag = "Triggerbot",
    Callback = function(val)
        State.Triggerbot = val
    end,
})

TabCombat:CreateSlider({
    Name = "Triggerbot Range",
    Range = { 6, 25 },
    Increment = 1,
    Suffix = "m",
    CurrentValue = State.TriggerbotRange,
    Flag = "TriggerbotRange",
    Callback = function(val)
        State.TriggerbotRange = val
    end,
})

TabCombat:CreateSlider({
    Name = "Triggerbot Cooldown",
    Range = { 0.1, 1.0 },
    Increment = 0.05,
    Suffix = "s",
    CurrentValue = State.TriggerbotCooldown,
    Flag = "TriggerbotCooldown",
    Callback = function(val)
        State.TriggerbotCooldown = val
    end,
})

-- 3. VISUALS
local TabVisuals = Window:CreateTab("Visuals", "eye")
TabVisuals:CreateSection("ESP")

TabVisuals:CreateToggle({
    Name = "Master ESP",
    CurrentValue = State.ESPEnabled,
    Flag = "ESPEnabled",
    Callback = function(val) State.ESPEnabled = val end,
})

TabVisuals:CreateToggle({
    Name = "Generators ESP",
    CurrentValue = State.GeneratorsESP,
    Flag = "GeneratorsESP",
    Callback = function(val) State.GeneratorsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Gears ESP",
    CurrentValue = State.GearsESP,
    Flag = "GearsESP",
    Callback = function(val) State.GearsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Traps ESP",
    CurrentValue = State.TrapsESP,
    Flag = "TrapsESP",
    Callback = function(val) State.TrapsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Items ESP",
    CurrentValue = State.ItemsESP,
    Flag = "ItemsESP",
    Callback = function(val) State.ItemsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Survivors ESP",
    CurrentValue = State.SurvivorsESP,
    Flag = "SurvivorsESP",
    Callback = function(val) State.SurvivorsESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Killers ESP",
    CurrentValue = State.KillersESP,
    Flag = "KillersESP",
    Callback = function(val) State.KillersESP = val end,
})

TabVisuals:CreateToggle({
    Name = "Chams (Highlight)",
    CurrentValue = State.ChamsEnabled,
    Flag = "ChamsEnabled",
    Callback = function(val) State.ChamsEnabled = val end,
})

TabVisuals:CreateSection("Alerts & Camera")

TabVisuals:CreateToggle({
    Name = "Killer Proximity Alert",
    CurrentValue = State.KillerAlert,
    Flag = "KillerAlert",
    Callback = function(val) State.KillerAlert = val end,
})

TabVisuals:CreateSlider({
    Name = "Alert Distance",
    Range = { 30, 150 },
    Increment = 5,
    Suffix = "m",
    CurrentValue = State.KillerAlertDistance,
    Flag = "KillerAlertDistance",
    Callback = function(val) State.KillerAlertDistance = val end,
})

TabVisuals:CreateToggle({
    Name = "Fullbright & Anti-Fog",
    CurrentValue = State.Fullbright,
    Flag = "Fullbright",
    Callback = function(val)
        State.Fullbright = val
        if not val then
            Lighting.Ambient = OriginalLighting.Ambient
            Lighting.OutdoorAmbient = OriginalLighting.OutdoorAmbient
            Lighting.Brightness = OriginalLighting.Brightness
            Lighting.ClockTime = OriginalLighting.ClockTime
            Lighting.FogEnd = OriginalLighting.FogEnd
            Lighting.GlobalShadows = OriginalLighting.GlobalShadows
        end
    end,
})

TabVisuals:CreateToggle({
    Name = "Remove Dark Screen VFX",
    CurrentValue = State.RemoveVFX,
    Flag = "RemoveVFX",
    Callback = function(val) State.RemoveVFX = val end,
})

TabVisuals:CreateSlider({
    Name = "Field Of View (FOV)",
    Range = { 70, 120 },
    Increment = 1,
    CurrentValue = State.CustomFOV,
    Flag = "CustomFOV",
    Callback = function(val)
        State.CustomFOV = val
        if Camera then Camera.FieldOfView = val end
    end,
})

-- 4. PUZZLES & INTERACT
local TabPuzzles = Window:CreateTab("Puzzles", "puzzle")
TabPuzzles:CreateSection("Automation & Interact")

TabPuzzles:CreateToggle({
    Name = "Auto-Puzzle Solver (Все миниигры)",
    CurrentValue = State.AutoAllPuzzles,
    Flag = "AutoAllPuzzles",
    Callback = function(val) State.AutoAllPuzzles = val end,
})

TabPuzzles:CreateToggle({
    Name = "Instant Interact (0s Hold)",
    CurrentValue = State.InstantInteract,
    Flag = "InstantInteract",
    Callback = function(val)
        State.InstantInteract = val
        UpdateAllPrompts()
    end,
})

TabPuzzles:CreateToggle({
    Name = "Auto-Collect Items & Gears",
    CurrentValue = State.AutoProximityInteract,
    Flag = "AutoProximityInteract",
    Callback = function(val) State.AutoProximityInteract = val end,
})

TabPuzzles:CreateToggle({
    Name = "Proximity Range Spoof (30m)",
    CurrentValue = State.ProximitySpoofRange,
    Flag = "ProximitySpoofRange",
    Callback = function(val)
        State.ProximitySpoofRange = val
        UpdateAllPrompts()
    end,
})

TabPuzzles:CreateSection("Objective Teleports")

TabPuzzles:CreateButton({
    Name = "Teleport to Unfinished Generator",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local bestPart, minDist = nil, 999999
        local myPos = myHRP.Position

        for gen, part in pairs(GeneratorCache) do
            if gen and gen.Parent and part and part.Parent then
                if GetGeneratorProgress(gen) < 100 then
                    local dist = (part.Position - myPos).Magnitude
                    if dist < minDist then
                        minDist = dist
                        bestPart = part
                    end
                end
            end
        end

        if bestPart then
            myChar:PivotTo(bestPart.CFrame + Vector3.new(0, 3, 0))
            Notify("Generator", string.format("Телепортирован к генератору (%dм)", math.floor(minDist)), 2.5)
        else
            Notify("Generator", "Незавершенных генераторов поблизости нет.", 2.5)
        end
    end,
})

TabPuzzles:CreateButton({
    Name = "Teleport to Nearest Gear",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local bestPart, minDist = nil, 999999
        local myPos = myHRP.Position

        for gear, part in pairs(GearCache) do
            if gear and gear.Parent and part and part.Parent then
                local dist = (part.Position - myPos).Magnitude
                if dist < minDist then
                    minDist = dist
                    bestPart = part
                end
            end
        end

        if bestPart then
            myChar:PivotTo(bestPart.CFrame + Vector3.new(0, 3, 0))
            Notify("Gear", string.format("Телепортирован к гиру (%dм)", math.floor(minDist)), 2.5)
        else
            Notify("Gear", "Шестерёнки не найдены на текущей карте.", 2.5)
        end
    end,
})

-- 5. TELEPORT
local TabTeleport = Window:CreateTab("Teleport", "navigation")
TabTeleport:CreateSection("Players & Lobby")

TabTeleport:CreateButton({
    Name = "Teleport Behind Killer",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local killersFolder = workspace:FindFirstChild("Players") and workspace.Players:FindFirstChild("Killers")
        if killersFolder and #killersFolder:GetChildren() > 0 then
            local killer = killersFolder:GetChildren()[1]
            local hrp = killer:FindFirstChild("HumanoidRootPart")
            if hrp then
                myChar:PivotTo(hrp.CFrame * CFrame.new(0, 0, 5))
                Notify("Teleport", "Телепортирован к Killer: " .. killer.Name, 2.5)
                return
            end
        end
        Notify("Teleport", "Маньяк не найден.", 2.5)
    end,
})

TabTeleport:CreateButton({
    Name = "Teleport to Random Survivor",
    Callback = function()
        local myChar = LocalPlayer.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        if not myHRP then return end

        local survivorsFolder = workspace:FindFirstChild("Players") and workspace.Players:FindFirstChild("Survivors")
        if survivorsFolder then
            local list = {}
            for _, s in ipairs(survivorsFolder:GetChildren()) do
                if s ~= myChar and s:FindFirstChild("HumanoidRootPart") then
                    table.insert(list, s)
                end
            end
            if #list > 0 then
                local chosen = list[math.random(1, #list)]
                myChar:PivotTo(chosen.HumanoidRootPart.CFrame * CFrame.new(0, 0, 4))
                Notify("Teleport", "Телепортирован к Survivor: " .. chosen.Name, 2.5)
                return
            end
        end
        Notify("Teleport", "Живых выживших не найдено.", 2.5)
    end,
})

TabTeleport:CreateButton({
    Name = "Teleport to Lobby Spawn",
    Callback = function()
        local myChar = LocalPlayer.Character
        if not myChar then return end

        local spawnLoc = workspace:FindFirstChild("Map") and workspace.Map:FindFirstChild("Lobby") and workspace.Map.Lobby:FindFirstChild("Spawn")
        if spawnLoc then
            myChar:PivotTo(spawnLoc.CFrame + Vector3.new(0, 4, 0))
        else
            myChar:PivotTo(CFrame.new(-5742, 305, -2130))
        end
        Notify("Teleport", "Телепортирован в лобби.", 2.5)
    end,
})

-- 6. SETTINGS
local TabSettings = Window:CreateTab("Settings", "settings")
TabSettings:CreateSection("Script Actions")

TabSettings:CreateButton({
    Name = "Rejoin Server",
    Callback = function()
        TeleportService:TeleportToPlaceInstance(game.PlaceId, game.JobId, LocalPlayer)
    end,
})

TabSettings:CreateButton({
    Name = "Unload Script",
    Callback = function()
        if getgenv().ForsakenCleanup then
            getgenv().ForsakenCleanup()
        end
    end,
})

Notify("Forsaken Loaded", "Нажми F1 чтобы скрыть/открыть меню", 4.0)