NightFall

--========================================================--
-- SERVICES
--========================================================--

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Lighting = game:GetService("Lighting")
local Workspace = game:GetService("Workspace")

local LocalPlayer = Players.LocalPlayer

--========================================================--
-- WINDUI
--========================================================--

local WindUI = loadstring(game:HttpGet(
    "https://raw.githubusercontent.com/Footagesus/WindUI/main/dist/main.lua"
))()

--========================================================--
-- SETTINGS
--========================================================--

local Settings = {

    AntiJump = false,
    AutoSprint = false,

    Underground = false,
    UndergroundDepth = 8,
    UndergroundSpeed = 20,

    QuickRespawn = false,

    ESP = false,
    TeamColors = true,

    Highlight = true,
    HighlightColor = Color3.fromRGB(255, 70, 70),
    HighlightTransparency = 0.5,
	FireRateMultiplier = 1.0,

    Fullbright = false,

    TargetTeam = false,
    RapidFire = false,
    FireRate = 0.05,

    Hitbox = false,
    HitboxSize = 6,
}

--========================================================--
-- STATE
--========================================================--

local UndergroundConnection = nil
local UndergroundSavedCFrame = nil

local CharacterConnection = nil
local DeathConnection = nil
local CharacterTrackConnection = nil

local LastAliveCFrame = nil
local LastDeathCFrame = nil

local ESPObjects = {}
local HitboxObjects = {}

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

--========================================================--
-- CHARACTER
--========================================================--

local function getCharacter()
    local Character = LocalPlayer.Character

    if not Character then
        return nil, nil, nil
    end

    local Humanoid = Character:FindFirstChildOfClass("Humanoid")
    local Root = Character:FindFirstChild("HumanoidRootPart")

    return Character, Humanoid, Root
end

--========================================================--
-- ESP
--========================================================--

local function removeESP(Player)

    local Object = ESPObjects[Player]

    if Object then

        if Object.Highlight then
            Object.Highlight:Destroy()
        end

        if Object.Billboard then
            Object.Billboard:Destroy()
        end

        ESPObjects[Player] = nil
    end
end

local function getPlayerColor(Player)

    if Settings.TeamColors
        and Player.Team
        and Player.Team.TeamColor then

        return Player.Team.TeamColor.Color
    end

    return Settings.HighlightColor
end

local function createESP(Player)

    if Player == LocalPlayer then
        return
    end

    removeESP(Player)

    local Character = Player.Character

    if not Character then
        return
    end

    local Root =
        Character:FindFirstChild("HumanoidRootPart")

    if not Root then
        return
    end

    local HighlightObject = nil

    if Settings.Highlight then

        HighlightObject =
            Instance.new("Highlight")

        HighlightObject.Name =
            "NightfallHighlight"

        HighlightObject.Adornee =
            Character

        HighlightObject.DepthMode =
            Enum.HighlightDepthMode.AlwaysOnTop

        HighlightObject.FillTransparency =
            Settings.HighlightTransparency

        HighlightObject.OutlineTransparency = 0

        HighlightObject.FillColor =
            getPlayerColor(Player)

        HighlightObject.OutlineColor =
            getPlayerColor(Player)

        HighlightObject.Parent =
            Character
    end

    local Billboard =
        Instance.new("BillboardGui")

    Billboard.Name =
        "NightfallESP"

    Billboard.Adornee =
        Root

    Billboard.Size =
        UDim2.fromOffset(220, 55)

    Billboard.StudsOffset =
        Vector3.new(0, 3.2, 0)

    Billboard.AlwaysOnTop = true

    Billboard.Active = true

    local Label =
        Instance.new("TextButton")

    Label.BackgroundTransparency = 1
    Label.Size = UDim2.fromScale(1, 1)

    Label.Font =
        Enum.Font.GothamSemibold

    Label.TextSize = 13
    Label.TextStrokeTransparency = 0.5

    Label.TextColor3 =
        getPlayerColor(Player)

    Label.Text = Player.DisplayName

    Label.AutoButtonColor = false
    Label.Active = true
    Label.Selectable = false

    Label.Parent = Billboard
    Label:SetAttribute("NF_Owner", Player.UserId)
    Billboard.Parent = Root

    ESPObjects[Player] = {
        Highlight = HighlightObject,
        Billboard = Billboard,
        Label = Label
    }
end

local function updateESP()

    for _, Player in ipairs(Players:GetPlayers()) do

        if Player ~= LocalPlayer then

            if Settings.ESP then

                if not ESPObjects[Player]
                    and Player.Character then

                    createESP(Player)
                end

                local Object =
                    ESPObjects[Player]

                if Object
                    and Object.Label then

                    local Character =
                        Player.Character

                    local Humanoid =
                        Character
                        and Character:FindFirstChildOfClass(
                            "Humanoid"
                        )

                    local Root =
                        Character
                        and Character:FindFirstChild(
                            "HumanoidRootPart"
                        )

                    local _, _, MyRoot =
                        getCharacter()

                    local DistanceText = ""

                    if Root and MyRoot then

                        local Distance =
                            math.floor(
                                (
                                    Root.Position
                                    - MyRoot.Position
                                ).Magnitude
                            )

                        DistanceText =
                            " [" .. Distance .. "m]"
                    end

                    local HealthText = ""

                    if Humanoid then

                        HealthText =
                            " | "
                            .. math.floor(
                                Humanoid.Health
                            )
                            .. " HP"
                    end

                    Object.Label.Text =
                        Player.DisplayName
                        .. DistanceText
                        .. HealthText

                    Object.Label.TextColor3 =
                        getPlayerColor(Player)
                end

            else
                removeESP(Player)
            end
        end
    end
end

--========================================================--
-- CLICK HOTKEY TP
--========================================================--

local ESP_CLICK_RADIUS = 60
local ESP_CLICK_COOLDOWN = 0.3
local _lastTeleportTime = 0

local TP_MODIFIER_KEY = Enum.KeyCode.LeftShift

local _tpKeyHeld = false

UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if input.UserInputType == Enum.UserInputType.Keyboard
       and (input.KeyCode == Enum.KeyCode.LeftShift
         or input.KeyCode == Enum.KeyCode.RightShift) then
        _tpKeyHeld = true
    end
end)

UserInputService.InputEnded:Connect(function(input, gameProcessed)
    if input.UserInputType == Enum.UserInputType.Keyboard
       and (input.KeyCode == Enum.KeyCode.LeftShift
         or input.KeyCode == Enum.KeyCode.RightShift) then
        _tpKeyHeld = false
    end
end)

local function teleportToRoot(targetRoot)
    local myChar = LocalPlayer.Character
    local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
    if not myRoot or not targetRoot then return end

    local targetLook = targetRoot.CFrame.LookVector
    local newPos = targetRoot.Position - targetLook * 3

    myRoot.CFrame = CFrame.new(newPos, targetRoot.Position)
    myRoot.AssemblyLinearVelocity = Vector3.zero
    myRoot.AssemblyAngularVelocity = Vector3.zero
end

UserInputService.InputBegan:Connect(function(input, gameProcessed)

    if gameProcessed then return end

    if not _tpKeyHeld then return end

    local isClick = input.UserInputType == Enum.UserInputType.MouseButton1
                 or input.UserInputType == Enum.UserInputType.Touch
    if not isClick then return end

    if os.clock() - _lastTeleportTime < ESP_CLICK_COOLDOWN then return end

    local clickPos
    if input.UserInputType == Enum.UserInputType.Touch then
        clickPos = Vector2.new(input.Position.X, input.Position.Y)
    else
        clickPos = Vector2.new(
            UserInputService:GetMouseLocation().X,
            UserInputService:GetMouseLocation().Y
        )
    end

    local cam = workspace.CurrentCamera
    if not cam then return end

    local bestPlayer = nil
    local bestDist = ESP_CLICK_RADIUS

    for player, object in pairs(ESPObjects) do
        local billboard = object.Billboard
        if billboard and billboard.Adornee and billboard.Parent then

            local worldPos = billboard.Adornee.Position + billboard.StudsOffset
            local screenPos, onScreen = cam:WorldToViewportPoint(worldPos)

            if onScreen then
                local d = (Vector2.new(screenPos.X, screenPos.Y) - clickPos).Magnitude

                if d < bestDist then
                    bestDist = d
                    bestPlayer = player
                end
            end
        end
    end

    if not bestPlayer then return end

    local targetChar = bestPlayer.Character
    local targetRoot = targetChar and targetChar:FindFirstChild("HumanoidRootPart")
    if not targetRoot then return end

    _lastTeleportTime = os.clock()
    teleportToRoot(targetRoot)
end)

--========================================================--
-- CUSTOM WEAPON VISUAL
--========================================================--

local CustomWeapon = (function()
    local state = {
        Enabled = false,
        Saved   = {},
        Applied = {},
    }

    local CUSTOM_MESHES = {
        ["AK-47"]         = "rbxassetid://96327891060480",
        ["M4A1"]          = "rbxassetid://96327891060480",
        ["M9"]            = "rbxassetid://96327891060480",
        ["MP5"]           = "rbxassetid://96327891060480",
        ["Taser"]         = "rbxassetid://96327891060480",
        ["Remington 870"] = "rbxassetid://96327891060480",
        ["Revolver"]      = "rbxassetid://96327891060480",
    }

    local CUSTOM_TEXTURES = {
        ["AK-47"]         = "rbxassetid://128702198330575",
        ["M4A1"]          = "rbxassetid://128702198330575",
        ["M9"]            = "rbxassetid://128702198330575",
        ["MP5"]           = "rbxassetid://128702198330575",
        ["Taser"]         = "rbxassetid://128702198330575",
        ["Remington 870"] = "rbxassetid://128702198330575",
        ["Revolver"]      = "rbxassetid://128702198330575",
    }

    local function findOriginalVisuals(tool)
        local list = {}
        for _, d in ipairs(tool:GetDescendants()) do
            if d:IsA("MeshPart") and d.Name ~= "NF_CustomWeapon" then
                table.insert(list, d)
            end
        end
        return list
    end

    local function createCustomMeshPart(original, meshId, textureId)
        local custom = Instance.new("MeshPart")
        custom.Name         = "NF_CustomWeapon"
        custom.MeshId       = meshId
        custom.TextureID    = textureId or original.TextureID or ""
        custom.Size         = original.Size
        custom.Anchored     = false
        custom.CanCollide   = false
        custom.CanQuery     = false
        custom.CanTouch     = false
        custom.Massless     = true
        custom.Transparency = 0
        custom.CFrame       = original.CFrame
        custom.Parent       = original.Parent

        local weld = Instance.new("WeldConstraint")
        weld.Part0 = custom
        weld.Part1 = original
        weld.Parent = custom

        return custom
    end

    local function apply(tool)
        if not tool or not tool:IsA("Tool") then return end
        local meshId = CUSTOM_MESHES[tool.Name]
        if not meshId then return end

        if state.Applied[tool] then return end

        local originals = findOriginalVisuals(tool)
        if #originals == 0 then return end

        local textureId = CUSTOM_TEXTURES[tool.Name]
        state.Saved[tool] = {}

        for _, orig in ipairs(originals) do
            state.Saved[tool][orig] = orig.Transparency
            orig.Transparency = 1

            pcall(function()
                createCustomMeshPart(orig, meshId, textureId)
            end)
        end

        state.Applied[tool] = true
    end

    local function remove(tool)
        if not state.Applied[tool] then return end

        for _, d in ipairs(tool:GetDescendants()) do
            if d.Name == "NF_CustomWeapon" then
                pcall(function() d:Destroy() end)
            end
        end

        local saved = state.Saved[tool]
        if saved then
            for orig, val in pairs(saved) do
                if orig and orig.Parent then
                    pcall(function() orig.Transparency = val end)
                end
            end
        end

        state.Applied[tool] = nil
        state.Saved[tool]   = nil
    end

    local function hookTool(tool)
        if not tool:IsA("Tool") then return end

        tool.Equipped:Connect(function()
            if state.Enabled then apply(tool) end
        end)

        tool.Unequipped:Connect(function()
            remove(tool)
        end)

        if state.Enabled then apply(tool) end
    end

    local function hookCharacter(char)
        for _, child in ipairs(char:GetChildren()) do
            if child:IsA("Tool") then hookTool(child) end
        end

        char.ChildAdded:Connect(function(child)
            if child:IsA("Tool") then
                task.wait(0.2)
                hookTool(child)
            end
        end)

        char.ChildRemoved:Connect(function(child)
            if child:IsA("Tool") then remove(child) end
        end)
    end

    local function enable()
        if state.Enabled then return end
        state.Enabled = true

        local char = LocalPlayer.Character
        if char then hookCharacter(char) end

        LocalPlayer.CharacterAdded:Connect(function(c)
            if state.Enabled then hookCharacter(c) end
        end)
    end

    local function disable()
        if not state.Enabled then return end
        state.Enabled = false

        for tool in pairs(state.Applied) do
            remove(tool)
        end
        state.Applied = {}
        state.Saved   = {}
    end

    return {
        Set = function(v) if v then enable() else disable() end return state.Enabled end,
        Get = function() return state.Enabled end,
        SetMeshes = function(tbl)
            table.clear(CUSTOM_MESHES)
            for k, v in pairs(tbl) do CUSTOM_MESHES[k] = v end
        end,
        SetTextures = function(tbl)
            table.clear(CUSTOM_TEXTURES)
            for k, v in pairs(tbl) do CUSTOM_TEXTURES[k] = v end
        end,
    }
end)()

--========================================================--
-- HITBOX
--========================================================--

local HitboxObjects = HitboxObjects or {}

local function removeHitbox(Player)
    local data = HitboxObjects[Player]
    if not data then return end

    local head = data.Head
    if head and head.Parent and data.OriginalSize then
        pcall(function()
            head.Size = data.OriginalSize
        end)
    end

    HitboxObjects[Player] = nil
end

local function isAlive(Player)
    local Character = Player.Character
    if not Character then return false end
    local Humanoid = Character:FindFirstChildOfClass("Humanoid")
    return Humanoid ~= nil and Humanoid.Health > 0
end

local function createHitbox(Player)
    removeHitbox(Player)

    local Character = Player.Character
    if not Character then return end

    local Head = Character:FindFirstChild("Head")
    if not Head then
        task.spawn(function()
            Head = Character:WaitForChild("Head", 5)
            if not Head then return end
            if not Settings.Hitbox then return end
            if not isAlive(Player) then return end
            if HitboxObjects[Player] then return end

            local s = Settings.HitboxSize or 6
            local original = Head.Size

            pcall(function() Head.Size = Vector3.new(s, s, s) end)

            HitboxObjects[Player] = {
                Head = Head,
                OriginalSize = original,
                Player = Player,
            }
        end)
        return
    end

    local s = Settings.HitboxSize or 6
    local original = Head.Size

    pcall(function()
        Head.Size = Vector3.new(s, s, s)
    end)

    HitboxObjects[Player] = {
        Head = Head,
        OriginalSize = original,
        Player = Player,
    }
end

local _hbQueue = {}
local _hbRunning = false

local function processQueue()
    if _hbRunning then return end
    _hbRunning = true

    task.spawn(function()
        while #_hbQueue > 0 do
            local job = table.remove(_hbQueue, 1)
            if job
                and job.Player
                and job.Player.Parent
                and Settings.Hitbox
                and isAlive(job.Player) then
                createHitbox(job.Player)
            end
            task.wait(0.15)
        end
        _hbRunning = false
    end)
end

local function queueHitbox(Player)
    for _, job in ipairs(_hbQueue) do
        if job.Player == Player then return end
    end
    table.insert(_hbQueue, { Player = Player })
    processQueue()
end

local function updateHitboxes()
    for _, Player in ipairs(Players:GetPlayers()) do
        if Player ~= LocalPlayer then
            if Settings.Hitbox and isAlive(Player) then
                local data = HitboxObjects[Player]
                if not data
                    or not data.Head
                    or not data.Head.Parent
                    or data.Head ~= Player.Character:FindFirstChild("Head") then
                    queueHitbox(Player)
                end
            else
                removeHitbox(Player)
            end
        end
    end
end

local HitboxVisualObjects = HitboxVisualObjects or {}

local function removeHitboxVisual(Player)
    local part = HitboxVisualObjects[Player]
    if not part then return end
    if part.Parent then
        pcall(function() part:Destroy() end)
    end
    HitboxVisualObjects[Player] = nil
end

local function createHitboxVisual(Player)
    removeHitboxVisual(Player)

    local Character = Player.Character
    if not Character then return end

    local Head = Character:FindFirstChild("Head")
    if not Head then return end

    local s = Settings.HitboxSize or 6

    local Part = Instance.new("Part")
    Part.Name         = "NightfallHitboxVisual"
    Part.Size         = Vector3.new(s, s, s)
    Part.Transparency = 0.7
    Part.Material     = Enum.Material.ForceField
    Part.Color        = Settings.HitboxVisualColor or Color3.fromRGB(255, 0, 0)
    Part.CastShadow   = false
    Part.CanCollide   = false
    Part.CanTouch     = false
    Part.CanQuery     = false
    Part.Massless     = true
    Part.Anchored     = false
    Part.CFrame       = Head.CFrame
    Part.Parent       = Head

    local Weld = Instance.new("WeldConstraint")
    Weld.Part0 = Part
    Weld.Part1 = Head
    Weld.Parent = Part

    HitboxVisualObjects[Player] = Part
end

local function updateHitboxVisuals()
    for _, Player in ipairs(Players:GetPlayers()) do
        if Player ~= LocalPlayer then
            if Settings.Hitbox and Settings.HitboxVisual and isAlive(Player) then
                local part = HitboxVisualObjects[Player]
                local needRecreate = false

                if not part or not part.Parent then
                    needRecreate = true
                elseif part.Size.X ~= (Settings.HitboxSize or 6) then
                    needRecreate = true
                end

                if needRecreate then
                    createHitboxVisual(Player)
                end
            else
                removeHitboxVisual(Player)
            end
        end
    end
end

local DamageNumbers = (function()
    local state = {
        Enabled = false,
        Conn    = nil,
        LastHP  = {},
        Pool    = {},
    }

    local function spawnNumber(worldPosition, amount)
        local bb = Instance.new("BillboardGui")
        bb.Name             = "NF_DamageNumber"
        bb.Size             = UDim2.fromOffset(120, 50)
        bb.StudsOffset      = Vector3.new(0, 0, 0)
        bb.AlwaysOnTop      = true
        bb.LightInfluence   = 0
        bb.MaxDistance      = 300
        bb.Adornee          = nil
        bb.Parent           = Workspace.CurrentCamera
        bb.Enabled          = true

        local anchor = Instance.new("Part")
        anchor.Name           = "NF_DamageAnchor"
        anchor.Size           = Vector3.new(0.1, 0.1, 0.1)
        anchor.Transparency   = 1
        anchor.CanCollide     = false
        anchor.CanQuery       = false
        anchor.CanTouch       = false
        anchor.Anchored       = true
        anchor.Massless       = true
        anchor.CFrame         = CFrame.new(worldPosition)
        anchor.Parent         = Workspace.CurrentCamera

        bb.Adornee = anchor

        local label = Instance.new("TextLabel")
        label.BackgroundTransparency = 1
        label.Size                   = UDim2.fromScale(1, 1)
        label.Font                   = Enum.Font.GothamBold
        label.TextScaled             = true
        label.TextColor3             = Color3.fromRGB(255, 60, 60)
        label.TextStrokeTransparency = 0
        label.TextStrokeColor3       = Color3.fromRGB(0, 0, 0)
        label.Text                   = "-" .. tostring(amount)
        label.Parent                 = bb

        task.spawn(function()
            local startTime = os.clock()
            local duration  = 1.0
            local startPos  = worldPosition
            local riseY     = 4

            while os.clock() - startTime < duration do
                local t = (os.clock() - startTime) / duration

                if anchor and anchor.Parent then
                    anchor.CFrame = CFrame.new(
                        startPos + Vector3.new(0, riseY * t, 0)
                    )
                end

                if label then
                    label.TextTransparency = t
                    label.TextStrokeTransparency = t
                end

                task.wait(0.03)
            end

            if bb and bb.Parent then bb:Destroy() end
            if anchor and anchor.Parent then anchor:Destroy() end
        end)
    end

    local function hookPlayer(Player)
        local char = Player.Character
        if not char then return end

        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hum then return end

        state.LastHP[Player] = hum.Health

        local conn
        conn = hum.HealthChanged:Connect(function(newHealth)
            if not state.Enabled then return end

            local oldHealth = state.LastHP[Player] or newHealth
            state.LastHP[Player] = newHealth

            local delta = oldHealth - newHealth
            if delta > 0 then

                local head = char:FindFirstChild("Head")
                local root = char:FindFirstChild("HumanoidRootPart")
                local pos

                if head then
                    pos = head.Position + Vector3.new(0, 2, 0)
                elseif root then
                    pos = root.Position + Vector3.new(0, 2, 0)
                else
                    pos = Vector3.new(0, 0, 0)
                end

                spawnNumber(pos, math.floor(delta + 0.5))
            end
        end)

        state.Conn = state.Conn
    end


    local function setupPlayer(Player)
        if Player == LocalPlayer then return end

        if Player.Character then
            hookPlayer(Player)
        end

        Player.CharacterAdded:Connect(function()
            task.wait(0.3)
            if state.Enabled then
                hookPlayer(Player)
            end
        end)
    end

    local function enable()
        if state.Enabled then return end
        state.Enabled = true
        state.LastHP  = {}

        for _, Player in ipairs(Players:GetPlayers()) do
            setupPlayer(Player)
        end
    end

    local function disable()
        if not state.Enabled then return end
        state.Enabled = false
        state.LastHP  = {}

        for _, obj in ipairs(Workspace.CurrentCamera:GetChildren()) do
            if obj.Name == "NF_DamageNumber"
                or obj.Name == "NF_DamageAnchor" then
                obj:Destroy()
            end
        end
    end

    Players.PlayerAdded:Connect(function(Player)
        if state.Enabled then
            setupPlayer(Player)
        end
    end)

    return {
        Set = function(v)
            if v then enable() else disable() end
            return state.Enabled
        end,
        Get = function() return state.Enabled end,
    }
end)()

--========================================================--
-- FULLBRIGHT
--========================================================--

local function enableFullbright()

    Lighting.Brightness = 1
    Lighting.ClockTime = 14

    Lighting.FogStart = 100
    Lighting.FogEnd = 10000

    Lighting.Ambient =
        Color3.fromRGB(140, 140, 140)

    Lighting.OutdoorAmbient =
        Color3.fromRGB(160, 160, 160)

    Lighting.GlobalShadows = true

    Lighting.ExposureCompensation = 0

    for _, Object in ipairs(Lighting:GetChildren()) do

        if Object:IsA("Atmosphere") then

            pcall(function()
                Object.Density = 0.1
            end)
        end

    end
end

local function disableFullbright()

    Lighting.Brightness =
        OriginalLighting.Brightness

    Lighting.ClockTime =
        OriginalLighting.ClockTime

    Lighting.FogStart =
        OriginalLighting.FogStart

    Lighting.FogEnd =
        OriginalLighting.FogEnd

    Lighting.Ambient =
        OriginalLighting.Ambient

    Lighting.OutdoorAmbient =
        OriginalLighting.OutdoorAmbient

    Lighting.GlobalShadows =
        OriginalLighting.GlobalShadows

    Lighting.ExposureCompensation =
        OriginalLighting.ExposureCompensation

end

local function updateFullbright()

    if Settings.Fullbright then
        enableFullbright()
    else
        disableFullbright()
    end
end

--========================================================--
-- RapidFire 
--========================================================--

local function patchTool(tool)
    if not tool or not tool:IsA("Tool") then return end
    if tool:GetAttribute("ToolType") ~= "Gun" then return end
    if not Settings.RapidFire then return end

    local newRate = tonumber(Settings.FireRate) or 0.05
    if newRate < 0.01 then newRate = 0.01 end

    pcall(function()
        tool:SetAttribute("FireRate", newRate)
    end)
end

LocalPlayer.CharacterAdded:Connect(function(char)
    task.wait(0.2)
    for _, child in ipairs(char:GetChildren()) do
        if child:IsA("Tool") then patchTool(child) end
    end
    char.ChildAdded:Connect(function(child)
        if child:IsA("Tool") then
            task.wait(0.3)
            patchTool(child)
        end
    end)
end)

if LocalPlayer.Character then
    for _, child in ipairs(LocalPlayer.Character:GetChildren()) do
        if child:IsA("Tool") then patchTool(child) end
    end
    LocalPlayer.Character.ChildAdded:Connect(function(child)
        if child:IsA("Tool") then
            task.wait(0.3)
            patchTool(child)
        end
    end)
end

--========================================================--
-- AUTO CRIMINAL
--========================================================--

local AutoCriminal = (function()
    local state = {
        Enabled   = false,
        Conn      = nil,
        LastCF    = nil,
        Teleporting = false,
    }

    local CRIMINAL_COLOR = Color3.fromRGB(218, 133, 65)
    local POLICE_COLOR   = Color3.fromRGB(13, 105, 172)

    local CRIMINAL_SPAWN_CFRAME = CFrame.new(
        -948.203491, 99.2255402, 2094.7876,
        0, 0, -1,
        0, 1, 0,
        1, 0, 0
    )

    local function getIndicatorColor()
        local ti = workspace:FindFirstChild("TeamIndicators")
        if not ti then return nil end

        local lp = ti:FindFirstChild("LocalPlayer")
        if lp then
            local frame = lp:FindFirstChild("Frame")
            if frame and frame:IsA("GuiObject") then
                return frame.BackgroundColor3
            end
        end

        local byName = ti:FindFirstChild(LocalPlayer.Name)
        if byName then
            local frame = byName:FindFirstChild("Frame")
            if frame and frame:IsA("GuiObject") then
                return frame.BackgroundColor3
            end
        end

        for _, v in ipairs(ti:GetChildren()) do
            if v:IsA("Folder") or v:IsA("Model") then
                if v.Name == LocalPlayer.Name then
                    local frame = v:FindFirstChild("Frame")
                    if frame and frame:IsA("GuiObject") then
                        return frame.BackgroundColor3
                    end
                end
            end
        end

        return nil
    end

    local function colorMatches(c, target, tolerance)
        tolerance = tolerance or 0.02
        return math.abs(c.R - target.R) < tolerance
           and math.abs(c.G - target.G) < tolerance
           and math.abs(c.B - target.B) < tolerance
    end

    local function teleportToSpawn()
        local char = LocalPlayer.Character
        local root = char and char:FindFirstChild("HumanoidRootPart")
        if not root then return end

        state.LastCF = root.CFrame

        root.CFrame = CRIMINAL_SPAWN_CFRAME
        root.AssemblyLinearVelocity  = Vector3.zero
        root.AssemblyAngularVelocity = Vector3.zero

        task.delay(0.4, function()
            local char2 = LocalPlayer.Character
            local root2 = char2 and char2:FindFirstChild("HumanoidRootPart")
            if root2 and state.LastCF then
                root2.CFrame = state.LastCF
                root2.AssemblyLinearVelocity  = Vector3.zero
                root2.AssemblyAngularVelocity = Vector3.zero
            end
            state.Teleporting = false
        end)
    end

    local function tick()
        if not state.Enabled then return end
        if state.Teleporting then return end

        local color = getIndicatorColor()
        if not color then return end

        if colorMatches(color, POLICE_COLOR) then
            return
        end

        if colorMatches(color, CRIMINAL_COLOR) then
            local char = LocalPlayer.Character
            local root = char and char:FindFirstChild("HumanoidRootPart")
            if not root then return end

            local dist = (root.Position - CRIMINAL_SPAWN_CFRAME.Position).Magnitude
            if dist < 5 then return end

            state.Teleporting = true
            teleportToSpawn()
        end
    end

    local function enable()
        if state.Enabled then return end
        state.Enabled = true

        if state.Conn then state.Conn:Disconnect() end
        state.Conn = task.spawn(function()
            while state.Enabled do
                pcall(tick)
                task.wait(0.42)
            end
        end)
    end

    local function disable()
        state.Enabled = false
        if state.Conn then
            task.cancel(state.Conn)
            state.Conn = nil
        end
        state.Teleporting = false
    end

    return {
        Set = function(v) if v then enable() else disable() end return state.Enabled end,
        Get = function() return state.Enabled end,
    }
end)()

--========================================================--
-- ANTI-FLING + BLOCK CAR SEATS
--========================================================--

local AntiFling = (function()
    local state = {
        Enabled    = false,
        Conn1      = nil,
        Conn2      = nil,
        Conn3      = nil,
        MaxSpeed   = 50,
        SeatHooks  = {},
    }

    local function disableCollisions()

        for _, player in ipairs(Players:GetPlayers()) do
            if player ~= LocalPlayer and player.Character then
                for _, v in ipairs(player.Character:GetDescendants()) do
                    if v:IsA("BasePart") then
                        v.CanCollide = false
                    end
                end
            end
        end

        local carContainer = workspace:FindFirstChild("CarContainer")
        if carContainer then
            for _, v in ipairs(carContainer:GetDescendants()) do
                if v:IsA("BasePart") then
                    v.CanCollide = false
                end
            end
        end

        for _, v in ipairs(workspace:GetChildren()) do
            if v.Name:lower():find("car") and v ~= LocalPlayer.Character then
                for _, p in ipairs(v:GetDescendants()) do
                    if p:IsA("BasePart") then
                        p.CanCollide = false
                    end
                end
            end
        end
    end

    local function clampVelocity()
        local char = LocalPlayer.Character
        local root = char and char:FindFirstChild("HumanoidRootPart")
        if not root then return end

        local v = root.AssemblyLinearVelocity
        if v.Magnitude > state.MaxSpeed then
            root.AssemblyLinearVelocity  = Vector3.zero
            root.AssemblyAngularVelocity = Vector3.zero
        end
    end

    local function blockSeat(seat)
        if not seat:IsA("VehicleSeat") and not seat:IsA("Seat") then return end
        if state.SeatHooks[seat] then return end

        local conn = seat:GetPropertyChangedSignal("Occupant"):Connect(function()
            if not state.Enabled then return end

            local occupant = seat.Occupant
            if occupant then
                local char = occupant.Parent
                if char == LocalPlayer.Character then
                    pcall(function()
                        occupant.Sit = false
                        occupant:ChangeState(Enum.HumanoidStateType.GettingUp)
                    end)
                end
            end
        end)

        state.SeatHooks[seat] = conn
    end

    local function unblockAllSeats()
        for seat, conn in pairs(state.SeatHooks) do
            if conn then
                pcall(function() conn:Disconnect() end)
            end
        end
        state.SeatHooks = {}
    end

    local function scanSeats()
        local carContainer = workspace:FindFirstChild("CarContainer")
        if carContainer then
            for _, v in ipairs(carContainer:GetDescendants()) do
                if v:IsA("VehicleSeat") or v:IsA("Seat") then
                    blockSeat(v)
                end
            end
        end

        for _, v in ipairs(workspace:GetChildren()) do
            if v.Name:lower():find("car") then
                for _, s in ipairs(v:GetDescendants()) do
                    if s:IsA("VehicleSeat") or s:IsA("Seat") then
                        blockSeat(s)
                    end
                end
            end
        end
    end

    local function enable()
        if state.Enabled then return end
        state.Enabled = true

        state.Conn1 = RunService.Stepped:Connect(disableCollisions)

        state.Conn2 = RunService.Heartbeat:Connect(clampVelocity)

        scanSeats()

        state.Conn3 = workspace.DescendantAdded:Connect(function(obj)
            if not state.Enabled then return end
            if obj:IsA("VehicleSeat") or obj:IsA("Seat") then
                blockSeat(obj)
            end
        end)
    end

    local function disable()
        if not state.Enabled then return end
        state.Enabled = false

        if state.Conn1 then state.Conn1:Disconnect(); state.Conn1 = nil end
        if state.Conn2 then state.Conn2:Disconnect(); state.Conn2 = nil end
        if state.Conn3 then state.Conn3:Disconnect(); state.Conn3 = nil end

        unblockAllSeats()
    end

    return {
        Set = function(v)
            if v then enable() else disable() end
            return state.Enabled
        end,
        Get = function() return state.Enabled end,
    }
end)()

--========================================================--
-- UNDERGROUND
--========================================================--

local function startUnderground()

    if UndergroundConnection then
        UndergroundConnection:Disconnect()
        UndergroundConnection = nil
    end
    UndergroundSavedCFrame = nil

    local Character, Humanoid, Root = getCharacter()
    if not Root or not Humanoid then return end

    UndergroundSavedCFrame = Root.CFrame

    UndergroundConnection = RunService.RenderStepped:Connect(function()

        if not Settings.Underground then return end

        local Character2, Humanoid2, Root2 = getCharacter()
        if not Root2 or not Humanoid2 then return end
        if not UndergroundSavedCFrame then return end

        local Current = Root2.CFrame
        local Rotation = Current - Current.Position
        local NewY = UndergroundSavedCFrame.Position.Y - Settings.UndergroundDepth

        Root2.CFrame = CFrame.new(
            Current.Position.X,
            NewY,
            Current.Position.Z
        ) * Rotation

        Root2.AssemblyLinearVelocity = Vector3.new(
            Root2.AssemblyLinearVelocity.X,
            0,
            Root2.AssemblyLinearVelocity.Z
        )
        Root2.AssemblyAngularVelocity = Vector3.zero

    end)
end

local function stopUnderground()

    if UndergroundConnection then
        UndergroundConnection:Disconnect()
        UndergroundConnection = nil
    end

    local _, Humanoid, Root = getCharacter()

    if Root then

        local CurrentPos = Root.Position
        local NewY = CurrentPos.Y + Settings.UndergroundDepth + 4

        Root.CFrame = CFrame.new(
            CurrentPos.X,
            NewY,
            CurrentPos.Z
        ) * (Root.CFrame - Root.CFrame.Position)

        Root.AssemblyLinearVelocity = Vector3.zero
        Root.AssemblyAngularVelocity = Vector3.zero
    end

    UndergroundSavedCFrame = nil
end

local function setUnderground(State)

    Settings.Underground = State

    if State then
        startUnderground()
    else
        stopUnderground()
    end
end

LocalPlayer.CharacterAdded:Connect(function(Character)

    local Humanoid = Character:WaitForChild("Humanoid", 10)
    local Root = Character:WaitForChild("HumanoidRootPart", 10)
    if not Humanoid or not Root then return end

    task.wait(0.5)

    if Settings.Underground then

        if UndergroundConnection then
            UndergroundConnection:Disconnect()
            UndergroundConnection = nil
        end
        UndergroundSavedCFrame = nil

        startUnderground()

    else
        if UndergroundConnection then
            UndergroundConnection:Disconnect()
            UndergroundConnection = nil
        end
        UndergroundSavedCFrame = nil
    end
end)

--========================================================--
-- TASE BYPASS
--========================================================--

local TaseBypass = (function()
    local TASE_ANIMS = {
        ["rbxassetid://279227693"] = true,
        ["rbxassetid://279229192"] = true,
    }

    local DEFAULT_SPEED = 16
    local DEFAULT_JUMP  = 7.2

    local Enabled = false

    local humanoid  = nil
    local lastSpeed = DEFAULT_SPEED
    local lastJump  = DEFAULT_JUMP

    local eventConns    = {}
    local humanoidConns = {}
    local charAddedConn = nil

    local PlayerTased = nil
    do
        local GunRemotes = ReplicatedStorage:FindFirstChild("GunRemotes")
        if GunRemotes then
            PlayerTased = GunRemotes:FindFirstChild("PlayerTased")
        end
    end

    local function clearTable(t)
        for _, c in ipairs(t) do
            if c and type(c.Disconnect) == "function" then
                pcall(function() c:Disconnect() end)
            end
        end
        table.clear(t)
    end

    local function enableBackpack()
        if LocalPlayer:GetAttribute("BackpackEnabled") ~= true then
            LocalPlayer:SetAttribute("BackpackEnabled", true)
        end
    end

    local function setupCharacter(character)
        if not character or not Enabled then return end

        local hum = character:FindFirstChildOfClass("Humanoid")
            or character:WaitForChild("Humanoid", 5)
        if not hum then return end
        if not Enabled then return end

        humanoid = hum

        if hum.WalkSpeed > 0 then lastSpeed = hum.WalkSpeed end
        if hum.JumpHeight > 0 then lastJump  = hum.JumpHeight end

        clearTable(humanoidConns)

        humanoidConns[#humanoidConns + 1] =
            hum:GetPropertyChangedSignal("WalkSpeed"):Connect(function()
                if hum.WalkSpeed > 0 then lastSpeed = hum.WalkSpeed end
            end)

        humanoidConns[#humanoidConns + 1] =
            hum:GetPropertyChangedSignal("JumpHeight"):Connect(function()
                if hum.JumpHeight > 0 then lastJump = hum.JumpHeight end
            end)
    end

    local function fixTase()
        if not Enabled then return end
        local hum = humanoid
        if not hum or not hum.Parent or hum.Health <= 0 then return end

        if hum.WalkSpeed == 0 and hum.JumpHeight == 0 then
            hum.WalkSpeed  = lastSpeed
            hum.JumpHeight = lastJump
        end

        for _, track in ipairs(hum:GetPlayingAnimationTracks()) do
            local anim = track.Animation
            if anim and TASE_ANIMS[anim.AnimationId] then
                track:Stop(0)
            end
        end

        enableBackpack()
    end

    local function enable()
        if Enabled then return end
        Enabled = true

        humanoid  = nil
        lastSpeed = DEFAULT_SPEED
        lastJump  = DEFAULT_JUMP
        clearTable(humanoidConns)

        if PlayerTased then
            eventConns[#eventConns + 1] = PlayerTased.OnClientEvent:Connect(function()
                task.defer(fixTase)
            end)
        end

        eventConns[#eventConns + 1] =
            LocalPlayer:GetAttributeChangedSignal("BackpackEnabled"):Connect(function()
                if Enabled and LocalPlayer:GetAttribute("BackpackEnabled") ~= true then
                    enableBackpack()
                end
            end)

        charAddedConn = LocalPlayer.CharacterAdded:Connect(function(c)
            humanoid = nil
            task.spawn(function()
                setupCharacter(c)
                enableBackpack()
            end)
        end)

        if LocalPlayer.Character then
            task.spawn(function()
                setupCharacter(LocalPlayer.Character)
                enableBackpack()
            end)
        end
    end

    local function disable()
        if not Enabled then return end
        Enabled = false

        clearTable(eventConns)
        clearTable(humanoidConns)

        if charAddedConn then
            charAddedConn:Disconnect()
            charAddedConn = nil
        end

        humanoid = nil
    end

    return {
        Set = function(v)
            if v == true then enable() else disable() end
            return Enabled
        end,
        Get = function() return Enabled end,
    }
end)()

--========================================================--
-- FE INVISIBLE
--========================================================--

local TweenService = game:GetService("TweenService")

local FEInvisible = (function()
    local state = {
        Enabled       = false,
        AnimTrack     = nil,
        HeartbeatConn = nil,
        Highlight     = nil,
        Saved         = {},
        RenderKey     = "FEInvisibleRenderStep",
    }

    local function getCharacter()
        return LocalPlayer.Character
    end

    local function isAlive()
        local char = getCharacter()
        local hum = char and char:FindFirstChildOfClass("Humanoid")
        return hum ~= nil and hum.Health > 0
    end

    local function getOffsets(char)
        local hum = char and char:FindFirstChildOfClass("Humanoid")
        local root = char and char:FindFirstChild("HumanoidRootPart")
        if not hum or not root then return nil end
        local isR15 = (hum.RigType == Enum.HumanoidRigType.R15)
        local offsetY = hum.HipHeight + root.Size.Y / 2 - 1
        return isR15, offsetY
    end

    local function tweenTransparency(inst, target)
        TweenService:Create(
            inst,
            TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            { Transparency = target }
        ):Play()
    end

    local function applyGhostTransparency()
        local char = getCharacter()
        if not char then return end
        for _, d in ipairs(char:GetDescendants()) do
            if d:IsA("BasePart") or d:IsA("Decal") or d:IsA("Texture") then
                state.Saved[d] = state.Saved[d] or d.Transparency
                tweenTransparency(d, 0.99)
            end
        end
    end

    local function restoreTransparency()
        for inst, val in pairs(state.Saved) do
            if inst and inst.Parent then
                tweenTransparency(inst, val)
            end
        end
        state.Saved = {}
    end

    local function createGhostHighlight()
        local char = getCharacter()
        if not char or state.Highlight then return end

        local h = Instance.new("Highlight")
        h.Name = "FEInvisibleGhostOutline"
        h.FillTransparency = 1
        h.OutlineColor = Color3.fromRGB(255, 255, 255)
        h.OutlineTransparency = 1
        h.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
        h.Adornee = char
        h.Parent = char

        TweenService:Create(
            h,
            TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            { OutlineTransparency = 0.1 }
        ):Play()

        state.Highlight = h
    end

    local function removeGhostHighlight()
        if not state.Highlight then return end
        local h = state.Highlight
        state.Highlight = nil

        TweenService:Create(
            h,
            TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
            { OutlineTransparency = 1 }
        ):Play()

        task.delay(0.35, function()
            pcall(function() h:Destroy() end)
        end)
    end

    local function playInvisAnimation()
        if not isAlive() then return end

        local char = getCharacter()
        local hum = char and char:FindFirstChildOfClass("Humanoid")
        if not hum then return end

        local isR15 = (hum.RigType == Enum.HumanoidRigType.R15)
        local animId = isR15 and "18665825805" or "215384594"

        local anim = Instance.new("Animation")
        anim.AnimationId = "rbxassetid://" .. animId

        local animator = hum:FindFirstChildOfClass("Animator")
        if not animator then
            animator = Instance.new("Animator")
            animator.Parent = hum
        end

        state.AnimTrack = animator:LoadAnimation(anim)
        state.AnimTrack.Priority = Enum.AnimationPriority.Action4
        state.AnimTrack:Play(0, 0.001, 0)
        anim:Destroy()

        task.delay(0, function()
            if state.AnimTrack then
                state.AnimTrack.TimePosition = isR15 and 1.95 or 0.4
            end
        end)
    end

    local function cleanup()
        if state.HeartbeatConn then
            state.HeartbeatConn:Disconnect()
            state.HeartbeatConn = nil
        end

        pcall(function()
            RunService:UnbindFromRenderStep(state.RenderKey)
        end)

        if state.AnimTrack then
            pcall(function() state.AnimTrack:Stop(0) end)
            pcall(function() state.AnimTrack:Destroy() end)
            state.AnimTrack = nil
        end

        state.Saved = {}
        removeGhostHighlight()
    end

    local function enable()
        if state.Enabled or not isAlive() then return end
        state.Enabled = true

        applyGhostTransparency()
        createGhostHighlight()
        playInvisAnimation()

        pcall(function()
            RunService:UnbindFromRenderStep(state.RenderKey)
        end)

        RunService:BindToRenderStep(
            state.RenderKey,
            Enum.RenderPriority.Camera.Value - 1,
            function()
                if not state.Enabled or not isAlive() then return end

                local char = getCharacter()
                local isR15, offsetY = getOffsets(char)
                local root = char and char:FindFirstChild("HumanoidRootPart")
                if not root or not offsetY then return end

                root.CFrame = root.CFrame
                    * CFrame.new(0, offsetY, 0)
                    * CFrame.Angles(math.rad(isR15 and -180 or -90), 0, 0)

                if state.AnimTrack then
                    state.AnimTrack:AdjustWeight(0.001)
                end
            end
        )

        state.HeartbeatConn = RunService.Heartbeat:Connect(function()
            if not state.Enabled or not isAlive() then return end

            local char = getCharacter()
            local isR15, offsetY = getOffsets(char)
            local root = char and char:FindFirstChild("HumanoidRootPart")
            if not root or not offsetY then return end

            root.CFrame = root.CFrame
                * CFrame.new(0, -offsetY, 0)
                * CFrame.Angles(math.rad(isR15 and 180 or 90), 0, 0)

            if state.AnimTrack then
                state.AnimTrack:AdjustWeight(100)
            end
        end)
    end

    local function disable()
        if not state.Enabled then return end
        state.Enabled = false

        restoreTransparency()
        cleanup()
    end

    LocalPlayer.CharacterAdded:Connect(function()
        if not state.Enabled then return end
        state.Enabled = false
        cleanup()
        task.wait(0.2)
        enable()
    end)

    return {
        Set = function(v)
            if v then enable() else disable() end
            return state.Enabled
        end,
        Get = function() return state.Enabled end,
    }
end)()

--========================================================--
-- ANTI-INVIS
--========================================================--

local AntiInvis = (function()
    local state = {
        Enabled = false,
        Conn    = nil,
        Markers = {},
    }

    local FE_ANIM_IDS = {
        ["rbxassetid://18665825805"] = true,
        ["rbxassetid://215384594"]   = true,
        ["18665825805"] = true,
        ["215384594"]   = true,
    }

    local function removeMarker(Player)
        local m = state.Markers[Player]
        if m and m.Parent then
            m:Destroy()
        end
        state.Markers[Player] = nil
    end

    local function createMarker(Player)
        removeMarker(Player)

        local char = Player.Character
        if not char then return end

        local head = char:FindFirstChild("Head")
        if not head then return end

        local billboard = Instance.new("BillboardGui")
        billboard.Name = "AntiInvisMarker"
        billboard.Size = UDim2.fromOffset(200, 50)
        billboard.StudsOffset = Vector3.new(0, 3, 0)
        billboard.AlwaysOnTop = true
        billboard.Adornee = head
        billboard.Parent = head

        local label = Instance.new("TextLabel")
        label.Size = UDim2.fromScale(1, 1)
        label.BackgroundTransparency = 1
        label.Text = "↓ " .. Player.DisplayName .. " ↓"
        label.TextColor3 = Color3.fromRGB(255, 0, 0)
        label.TextStrokeTransparency = 0
        label.TextScaled = true
        label.Font = Enum.Font.GothamBold
        label.Parent = billboard

        state.Markers[Player] = billboard
    end

    local function isUnder(Player)
        local char = Player.Character
        if not char then return false end

        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hum then return false end

        local animator = hum:FindFirstChildOfClass("Animator")
        if animator then
            for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
                local anim = track.Animation
                if anim
                    and FE_ANIM_IDS[anim.AnimationId]
                    and track.WeightCurrent > 0.1 then
                    return true
                end
            end
        end

        local root = char:FindFirstChild("HumanoidRootPart")
        if root and root.Position.Y < -50 then
            return true
        end

        return false
    end

    local function update()
        for _, Player in ipairs(Players:GetPlayers()) do
            if Player ~= LocalPlayer then
                if Player.Character and isUnder(Player) then
                    if not state.Markers[Player] or not state.Markers[Player].Parent then
                        createMarker(Player)
                    end
                else
                    removeMarker(Player)
                end
            end
        end
    end

    local function enable()
        if state.Enabled then return end
        state.Enabled = true

        if state.Conn then state.Conn:Disconnect() end
        state.Conn = RunService.Heartbeat:Connect(update)
    end

    local function disable()
        if not state.Enabled then return end
        state.Enabled = false

        if state.Conn then
            state.Conn:Disconnect()
            state.Conn = nil
        end

        for Player in pairs(state.Markers) do
            removeMarker(Player)
        end
    end

    return {
        Set = function(v) if v then enable() else disable() end return state.Enabled end,
        Get = function() return state.Enabled end,
    }
end)()

--========================================================--
-- AUTO SPRINT
--========================================================--

local SprintState = {
    ShiftHeld = false,
}

UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if input.UserInputType == Enum.UserInputType.Keyboard
       and (input.KeyCode == Enum.KeyCode.LeftShift
         or input.KeyCode == Enum.KeyCode.RightShift) then
        SprintState.ShiftHeld = true
    end
end)

UserInputService.InputEnded:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.Keyboard
       and (input.KeyCode == Enum.KeyCode.LeftShift
         or input.KeyCode == Enum.KeyCode.RightShift) then
        SprintState.ShiftHeld = false
    end
end)

local function updateSprint()
    local Character, Humanoid = getCharacter()
    if not Humanoid then return end

    if Settings.Underground then
        if Humanoid.WalkSpeed ~= Settings.UndergroundSpeed then
            Humanoid.WalkSpeed = Settings.UndergroundSpeed
        end
        return
    end

    if SprintState.ShiftHeld then
        if Humanoid.WalkSpeed ~= 24 then
            Humanoid.WalkSpeed = 24
        end
        return
    end

    if Settings.AutoSprint then
        if Humanoid.WalkSpeed ~= 24 then
            Humanoid.WalkSpeed = 24
        end
    else
        if Humanoid.WalkSpeed ~= 16 then
            Humanoid.WalkSpeed = 16
        end
    end
end

--========================================================--
-- BYPASS ANTIJUMP
--========================================================--

local function updateJump()
    local StarterPlayer = game:GetService("StarterPlayer")
    local StarterScripts = StarterPlayer:FindFirstChild("StarterCharacterScripts")
    if not StarterScripts then return end

    local shouldDisable = Settings.AntiJump

    local starterAntiJump = StarterScripts:FindFirstChild("AntiJump")
    if starterAntiJump then
        starterAntiJump.Disabled = shouldDisable
    end

    local char = LocalPlayer.Character
    if char then
        local activeAntiJump = char:FindFirstChild("AntiJump")
        if activeAntiJump then
            activeAntiJump.Disabled = shouldDisable
        end
    end
end

LocalPlayer.CharacterAdded:Connect(function(char)
    task.wait(0.1)
    local activeAntiJump = char:FindFirstChild("AntiJump")
    if activeAntiJump then
        activeAntiJump.Disabled = Settings.AntiJump
    end
end)

--========================================================--
-- CHARACTER TRACKING / QUICK RESPAWN
--========================================================--

local function disconnectCharacterConnections()

    if CharacterTrackConnection then
        CharacterTrackConnection:Disconnect()
        CharacterTrackConnection = nil
    end

    if DeathConnection then
        DeathConnection:Disconnect()
        DeathConnection = nil
    end
end

local function trackCharacter(Character)

    disconnectCharacterConnections()

    local Humanoid =
        Character:WaitForChild(
            "Humanoid",
            10
        )

    local Root =
        Character:WaitForChild(
            "HumanoidRootPart",
            10
        )

    if not Humanoid or not Root then
        return
    end

    LastAliveCFrame =
        Root.CFrame

    CharacterTrackConnection =
        RunService.Heartbeat:Connect(function()

            if not Character.Parent then

                if CharacterTrackConnection then
                    CharacterTrackConnection:Disconnect()
                    CharacterTrackConnection = nil
                end

                return
            end

            if Humanoid.Health > 0
                and Root.Parent then

                LastAliveCFrame =
                    Root.CFrame
            end
        end)

    DeathConnection =
        Humanoid.Died:Connect(function()

            if LastAliveCFrame then

                LastDeathCFrame =
                    LastAliveCFrame

            elseif Root then

                LastDeathCFrame =
                    Root.CFrame
            end

            if CharacterTrackConnection then

                CharacterTrackConnection:Disconnect()
                CharacterTrackConnection = nil
            end
        end)

    updateSprint()
    updateJump()
end

LocalPlayer.CharacterAdded:Connect(function(Character)

    task.wait()

    trackCharacter(Character)

    if Settings.QuickRespawn
        and LastDeathCFrame then

        local Root =
            Character:WaitForChild(
                "HumanoidRootPart",
                10
            )

        if Root then

            task.wait(0.15)

            if Character.Parent
                and Settings.QuickRespawn then

                Root.CFrame =
                    LastDeathCFrame
            end
        end
    end

    if Settings.Underground then

        task.wait(0.1)

        UndergroundSavedCFrame =
            nil

        startUnderground()
    end
end)

if LocalPlayer.Character then
    task.spawn(function()
        trackCharacter(
            LocalPlayer.Character
        )
    end)
end

--========================================================--
-- KILLFEED NOTIFICATIONS
--========================================================--

local KillfeedNotify = true

local KillfeedFolder = ReplicatedStorage:WaitForChild("Killfeed", 10)

if KillfeedFolder and KillfeedFolder:IsA("Folder") then

    KillfeedFolder.ChildAdded:Connect(function(child)

        if not KillfeedNotify then return end

        local text = child.Name
        if not text or #text < 5 or text == "#" then return end

        local icon = "skull"
        local tcolor = child:FindFirstChild("TColor")
        if tcolor and tcolor:IsA("Color3Value") then
            local c = tcolor.Value
            if c.R > c.B then
                icon = "sword"      
            elseif c.B > c.R then
                icon = "shield"     
            end
        end

        WindUI:Notify({
            Title = "Убийство",
            Content = text,
            Icon = icon,
            Image = nil,
            Duration = 5,
            Buttons = {
                {
                    Title = "ОК",
                    Callback = function()
                    end
                }
            }
        })
    end)
end

--========================================================--
-- CLOSEST PLAYER TRACKER
--========================================================--

local TrackerGui =
    Instance.new("ScreenGui")

TrackerGui.Name =
    "NightfallTracker"

TrackerGui.ResetOnSpawn = false
TrackerGui.IgnoreGuiInset = true
TrackerGui.Parent =
    LocalPlayer:WaitForChild("PlayerGui")

local TrackerLabel =
    Instance.new("TextLabel")

TrackerLabel.BackgroundTransparency = 1

TrackerLabel.Position =
    UDim2.fromOffset(15, 15)

TrackerLabel.Size =
    UDim2.fromOffset(350, 30)

TrackerLabel.Font =
    Enum.Font.GothamSemibold

TrackerLabel.TextSize = 13

TrackerLabel.TextXAlignment =
    Enum.TextXAlignment.Left

TrackerLabel.TextColor3 =
    Color3.fromRGB(255, 255, 255)

TrackerLabel.TextStrokeTransparency =
    0.5

TrackerLabel.Visible =
    Settings.ClosestTracker

TrackerLabel.Parent =
    TrackerGui

local function updateTracker()

    if not Settings.ClosestTracker then

        TrackerLabel.Visible = false
        return
    end

    TrackerLabel.Visible = true

    local Player, Part, Distance =
        getClosestTarget()

    if not Player then

        TrackerLabel.Text =
            "Target: none"

        return
    end

    local Character =
        Player.Character

    local Humanoid =
        Character
        and Character:FindFirstChildOfClass(
            "Humanoid"
        )

    local Health =
        Humanoid
        and math.floor(Humanoid.Health)
        or 0

    TrackerLabel.Text =
        string.format(
            "Target: %s | %.0f px | %d HP",
            Player.DisplayName,
            Distance or 0,
            Health
        )
end

--========================================================--
-- PLAYER CONNECTIONS
--========================================================--

local function setupPlayer(Player)

    if Player == LocalPlayer then
        return
    end

    Player.CharacterAdded:Connect(function()

        task.wait(0.2)

        if Settings.ESP then
            createESP(Player)
        end

        if Settings.Hitbox then
            createHitbox(Player)
        end
    end)

    Player.CharacterRemoving:Connect(function()

        removeESP(Player)
        removeHitbox(Player)
    end)
end

for _, Player in ipairs(Players:GetPlayers()) do
    setupPlayer(Player)
end

Players.PlayerAdded:Connect(setupPlayer)

Players.PlayerRemoving:Connect(function(Player)

    removeESP(Player)
    removeHitbox(Player)
end)

--========================================================--
-- MAIN LOOP
--========================================================--

RunService.RenderStepped:Connect(function()

    if Settings.ESP then
        updateESP()
    end

    
    updateHitboxVisuals()
    updateHitboxes()

    if Settings.Underground then
        updateSprint()
    end
end)

--========================================================--
-- WINDUI WINDOW
--========================================================--

local Window =
    WindUI:CreateWindow({
        Title = "Nightfall",
        Icon = "moon",
        Author = "Entervalov",
        Folder = "Nightfall",
        Size = UDim2.fromOffset(580, 460),
        Transparent = true,
        Theme = "Dark",
        SideBarWidth = 170,
        HasOutline = true
    })

--========================================================--
-- TABS
--========================================================--

local MovementTab =
    Window:Tab({
        Title = "Movement",
        Icon = "move"
    })

local CombatTab =
    Window:Tab({
        Title = "Fight",
        Icon = "crosshair"
    })

local VisualsTab =
    Window:Tab({
        Title = "Visual",
        Icon = "eye"
    })

local SettingsTab =
    Window:Tab({
        Title = "Settings",
        Icon = "settings"
    })

--========================================================--
-- MOVEMENT
--========================================================--

MovementTab:Section({
    Title = "Движение"
})

MovementTab:Toggle({
    Title = "Anti-Jump",
    Desc = "Disables the jump limit",
    Value = false,
    Callback = function(State)
        Settings.AntiJump = State
        updateJump()
    end,
})

MovementTab:Toggle({
    Title = "AutoSprint",
    Desc = "Autosprint",
    Value = false,

    Callback = function(State)

        Settings.AutoSprint = State

        updateSprint()
    end
})

MovementTab:Section({
    Title = "Подземщик"
})

MovementTab:Toggle({
    Title = "Подземщик",
    Desc = "It saves the startup point and returns to it when turned off",
    Value = false,

    Callback = function(State)

        setUnderground(State)
    end
})

MovementTab:Keybind({
    Title = "Подземщик (клавиша)",
    Desc = "Press to assign the on/off key for the undergrounder",
    Value = Enum.KeyCode.V,
    Callback = function()
        local Character, Humanoid = getCharacter()
        if not Character or not Humanoid then return end

        local newState = not Settings.Underground
        setUnderground(newState)

        print("[Underground]", newState and "ON" or "OFF")
    end,
})

MovementTab:Slider({
    Title = "Глубина",
    Desc = "It makes you an undergrounder btw",
    Value = {
        Min = 2,
        Max = 30,
        Default = 8
    },

    Callback = function(Value)

        Settings.UndergroundDepth =
            tonumber(Value) or 8
    end
})

MovementTab:Slider({
    Title = "Скорость",
    Desc = "Running speed underground",
    Value = {
        Min = 16,
        Max = 150,
        Default = 20
    },

    Callback = function(Value)

        Settings.UndergroundSpeed =
            tonumber(Value) or 20

        if Settings.Underground then
            updateSprint()
        end
    end
})

MovementTab:Section({
    Title = "Respawn"
})

MovementTab:Toggle({
    Title = "Quick Respawn",
    Desc = "Brings you back to the point where you died (if u have sheid ",
    Value = false,

    Callback = function(State)

        Settings.QuickRespawn = State
    end
})

MovementTab:Section({ Title = "Auto Criminal" })

MovementTab:Toggle({
    Title = "Auto Criminal",
    Desc = "Automatically becomes a criminal",
    Value = false,
    Callback = function(State)
        AutoCriminal.Set(State)
    end,
})

--========================================================--
-- COMBAT
--========================================================--

CombatTab:Section({
    Title = "Hitbox Visualizer"
})

CombatTab:Toggle({
    Title = "Hitbox",
    Desc = "Increases the player’s head size so that it’s easier to deal critical damage (Silent Aim btw)",
    Value = false,
    Callback = function(State)
        Settings.Hitbox = State
        if State then
            for _, Player in ipairs(Players:GetPlayers()) do
                if Player ~= LocalPlayer and isAlive(Player) then
                    createHitbox(Player)
                end
            end
        else
            for Player in pairs(HitboxObjects) do
                removeHitbox(Player)
            end
        end
    end,
})

CombatTab:Slider({
    Title = "Hitbox Size",
    Desc = "Increase the hitbox of players’ heads (Visual)",
    Value = { Min = 2, Max = 10, Default = 6 },
    Callback = function(Value)
        Settings.HitboxSize = tonumber(Value) or 6
        if Settings.Hitbox then
            for _, Player in ipairs(Players:GetPlayers()) do
                if Player ~= LocalPlayer and isAlive(Player) then
                    createHitbox(Player)
                end
            end
        end
    end,
})

CombatTab:Section({ Title = "Anti-Fling" })

CombatTab:Toggle({
    Title = "Anti-Fling",
    Desc = "It prevents you from flying off the map and stops the anti‑cheat from kicking you. Fucking FFling!",
    Value = false,
    Callback = function(State)
        AntiFling.Set(State)
    end,
})

CombatTab:Section({
    Title = "Rage"
})

CombatTab:Toggle({
    Title = "Rapid Fire",
    Desc = "Reduces the FireRate of the weapon when equipped (requires taking the weapon twice to use)",
    Value = false,
    Callback = function(State)
        Settings.RapidFire = State
        if State and LocalPlayer.Character then
            for _, child in ipairs(LocalPlayer.Character:GetChildren()) do
                if child:IsA("Tool") then patchTool(child) end
            end
        end
    end
})

CombatTab:Slider({
    Title = "Fire Rate",
    Desc = "Increases the firing speed",
    Value = { Min = 0.01, Max = 0.5, Default = 0.05 },
    Callback = function(Value)
        Settings.FireRate = tonumber(Value) or 0.05
        if Settings.RapidFire and LocalPlayer.Character then
            for _, child in ipairs(LocalPlayer.Character:GetChildren()) do
                if child:IsA("Tool") then patchTool(child) end
            end
        end
    end
})

CombatTab:Toggle({
    Title = "Tase Bypass",
    Desc = "Bypass Taser",
    Value = false,
    Callback = function(State)
        TaseBypass.Set(State)
    end,
})

--========================================================--
-- VISUALS
--========================================================--

VisualsTab:Section({
    Title = "XRAY"
})

VisualsTab:Toggle({
    Title = "ESP",
    Desc = "Shows players through walls",
    Value = false,

    Callback = function(State)

        Settings.ESP = State

        if not State then

            for Player in pairs(ESPObjects) do
                removeESP(Player)
            end
        end
    end
})

VisualsTab:Toggle({
    Title = "Team Colors",
    Desc = "The ESP color depends on the command",
    Value = true,

    Callback = function(State)

        Settings.TeamColors =
            State
    end
})

VisualsTab:Toggle({
    Title = "Highlight",
    Desc = "Player highlighting",
    Value = true,

    Callback = function(State)

        Settings.Highlight =
            State

        if Settings.ESP then

            for Player in ipairs(Players:GetPlayers()) do

                if Player ~= LocalPlayer then
                    createESP(Player)
                end
            end
        end
    end
})

VisualsTab:Section({ Title = "Custom Weapon" })

VisualsTab:Toggle({
    Title = "Custom Weapon Visual",
    Desc = "Replaces the weapon model with a custom one",
    Value = false,
    Callback = function(State)
        CustomWeapon.Set(State)
    end,
})

VisualsTab:Section({ Title = "Damage Visible" })

VisualsTab:Toggle({
    Title = "Damage Visible",
    Desc = "Shows the damage dealt to the player",
    Value = false,
    Callback = function(State)
        DamageNumbers.Set(State)
    end,
})

VisualsTab:Section({ Title = "Custom Weapon" })

VisualsTab:Toggle({
    Title = "Custom Weapon Visual",
    Desc = "Replaces the weapon model with a custom one (Visual)",
    Value = false,
    Callback = function(State)
        CustomWeapon.Set(State)
    end,
})

VisualsTab:Section({
    Title = "World"
})

VisualsTab:Toggle({
    Title = "Fullbright",
    Desc = "It removes darkness, fog, and shadows",
    Value = false,

    Callback = function(State)

        Settings.Fullbright =
            State

        updateFullbright()
    end
})

VisualsTab:Section({ Title = "Invisible" })

VisualsTab:Toggle({
    Title = "Invisible (FE)",
    Desc = "Invisibility",
    Value = false,
    Callback = function(State)
        FEInvisible.Set(State)
    end,
})

VisualsTab:Section({ Title = "Anti-Invis" })

VisualsTab:Toggle({
    Title = "Anti-Invis",
    Desc = "It tries to make invisible players visible so they can be killed.",
    Value = false,
    Callback = function(State)
        AntiInvis.Set(State)
    end,
})

--========================================================--
-- SETTINGS
--========================================================--

SettingsTab:Section({ Title = "Killfeed" })

SettingsTab:Toggle({
    Title = "Killfeed Notifications",
    Desc = "Shows notifications about who killed whom.",
    Value = true,
    Callback = function(State)
        KillfeedNotify = State
    end
})

SettingsTab:Section({
    Title = "Interface"
})

SettingsTab:Toggle({
    Title = "Closest Player Tracker",
    Desc = "Displays the selected closest target",
    Value = true,

    Callback = function(State)

        Settings.ClosestTracker =
            State

        TrackerLabel.Visible =
            State
    end
})

SettingsTab:Button({
    Title = "Reset Lighting",

    Callback = function()

        Settings.Fullbright = false

        disableFullbright()
    end
})

SettingsTab:Button({
    Title = "Unload Nightfall",

    Callback = function()

        Settings.ESP = false
        Settings.Hitbox = false
        Settings.RapidFire = false
        Settings.AntiJump = false
        Settings.AutoSprint = false

        if Settings.Underground then
            setUnderground(false)
        end

        pcall(function() FEInvisible.Set(false) end)

        pcall(function()
            if TaseBypass then TaseBypass.Set(false) end
        end)

        pcall(function() AutoCriminal.Set(false) end)
        	
        pcall(function() DamageNumbers.Set(false) end)
        
        pcall(function() CustomWeapon.Set(false) end)

        disableFullbright()

        pcall(function()
            local StarterScripts = game:GetService("StarterPlayer"):FindFirstChild("StarterCharacterScripts")
            if StarterScripts then
                local AntiJump = StarterScripts:FindFirstChild("AntiJump")
                if AntiJump then AntiJump.Disabled = false end
            end
            local char = LocalPlayer.Character
            if char then
                local activeAJ = char:FindFirstChild("AntiJump")
                if activeAJ then activeAJ.Disabled = false end
            end
        end)

        for Player in pairs(ESPObjects) do
            removeESP(Player)
        end

        for Player in pairs(HitboxObjects) do
            removeHitbox(Player)
        end

        if TrackerGui then
            TrackerGui:Destroy()
        end

        if CharacterTrackConnection then
            CharacterTrackConnection:Disconnect()
            CharacterTrackConnection = nil
        end

        if DeathConnection then
            DeathConnection:Disconnect()
            DeathConnection = nil
        end

        if UndergroundConnection then
            UndergroundConnection:Disconnect()
            UndergroundConnection = nil
        end

        UndergroundSavedCFrame = nil

        print("[Nightfall] All functions unloaded.")
    end
})

--========================================================--
-- INITIALIZATION
--========================================================--

task.spawn(function()

    task.wait(1)

    updateFullbright()
    updateJump()
    updateSprint()

    if Settings.ESP then
        updateESP()
    end

    if Settings.Hitbox then
        updateHitboxes()
    end

end)

print("[Nightfall] Loaded.")