HUSH: They can hear Script (Delta Mobile) – Mono Neon V8: Monster ESP, Auto Hotwire

--[[
    HUSH MONO NEON V8 + AUTO HOTWIRE

    RightShift — скрыть / показать меню
    F7 — включить / выключить автоугон

    Автоугон работает, когда открыта мини-игра
    «Горячая проводка».
]]

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

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")
local env = getgenv and getgenv() or _G

-- Выключение предыдущих версий и отдельного автоугона
for _, key in ipairs({
    "HushNeonCleanup",
    "HushNeonV2Cleanup",
    "HushNeonV3Cleanup",
    "HushNeonV4Cleanup",
    "HushNeonV5Cleanup",
    "HushMonoV6Cleanup",
    "HushMonoV7Cleanup",
    "HushMonoV8Cleanup",
    "HushCarTestCleanup",
    "HushCarBoostCleanup",
    "HushCarBoostV2Cleanup",
    "HushQuietTestCleanup",
    "HushHotwireCleanup"
}) do
    if type(env[key]) == "function" then
        local ok, err = pcall(env[key])
        if not ok then
            warn("[HUSH] Ошибка очистки " .. key .. ": " .. tostring(err))
        end
        env[key] = nil
    end
end

for _, name in ipairs({"HushMonoV8", "HushAutoHotwire"}) do
    local previous = playerGui:FindFirstChild(name)
    if previous then
        previous:Destroy()
    end
end

local alive = true
local connections = {}

local settings = {
    monsterESP = true,
    watcherESP = true,
    playerESP = true,
    motherESP = true,
    monsterLines = true,

    fullbright = true,
    noFog = true,

    carBoost = false,
    carNoclip = false,
    carAcceleration = 10,
    carSpeedLimit = 120,

    autoHotwire = false,

    range = 700,
    maxMonsters = 5
}

local colors = {
    background = Color3.fromRGB(10, 10, 12),
    panel = Color3.fromRGB(20, 20, 23),
    button = Color3.fromRGB(32, 32, 36),
    hover = Color3.fromRGB(52, 52, 57),
    white = Color3.fromRGB(245, 245, 245),
    muted = Color3.fromRGB(165, 165, 170),
    red = Color3.fromRGB(255, 145, 145),

    monster = Color3.fromRGB(235, 235, 235),
    nearest = Color3.fromRGB(255, 175, 175),
    watcher = Color3.fromRGB(160, 225, 255),
    player = Color3.fromRGB(175, 255, 195),
    mother = Color3.fromRGB(255, 85, 85)
}

local function connect(signal, callback)
    local connection = signal:Connect(callback)
    table.insert(connections, connection)
    return connection
end

local function corner(parent, radius)
    local item = Instance.new("UICorner")
    item.CornerRadius = UDim.new(0, radius or 8)
    item.Parent = parent
end

local function stroke(parent, color, transparency)
    local item = Instance.new("UIStroke")
    item.Color = color
    item.Transparency = transparency or 0
    item.Thickness = 1
    item.Parent = parent
end

-- ==========================================
-- FULLBRIGHT И NO FOG
-- ==========================================

local brightValues = {
    Ambient = Color3.fromRGB(180, 180, 180),
    OutdoorAmbient = Color3.fromRGB(180, 180, 180),
    Brightness = 2,
    ClockTime = 14,
    GlobalShadows = false,
    ExposureCompensation = 0
}

local fogValues = {
    FogStart = 0,
    FogEnd = 100000
}

local savedBright = {}
local savedFog = {}
local savedEffects = {}
local savedAtmospheres = {}

local function saveProperties(values, destination)
    table.clear(destination)

    for property in pairs(values) do
        local ok, value = pcall(function()
            return Lighting[property]
        end)

        if ok then
            destination[property] = value
        end
    end
end

local function setProperties(values)
    for property, value in pairs(values) do
        pcall(function()
            if Lighting[property] ~= value then
                Lighting[property] = value
            end
        end)
    end
end

local function restoreProperties(saved)
    for property, value in pairs(saved) do
        pcall(function()
            Lighting[property] = value
        end)
    end

    table.clear(saved)
end

local function disableEffect(object)
    if not object:IsA("PostEffect") then
        return
    end

    if savedEffects[object] == nil then
        savedEffects[object] = object.Enabled
    end

    pcall(function()
        object.Enabled = false
    end)
end

local function clearAtmosphere(object)
    if not object:IsA("Atmosphere") then
        return
    end

    if not savedAtmospheres[object] then
        savedAtmospheres[object] = {
            Density = object.Density,
            Haze = object.Haze,
            Glare = object.Glare
        }
    end

    pcall(function()
        object.Density = 0
        object.Haze = 0
        object.Glare = 0
    end)
end

local function restoreEffects()
    for object, enabled in pairs(savedEffects) do
        pcall(function()
            if object.Parent then
                object.Enabled = enabled
            end
        end)
    end

    table.clear(savedEffects)
end

local function restoreAtmospheres()
    for object, saved in pairs(savedAtmospheres) do
        pcall(function()
            if object.Parent then
                object.Density = saved.Density
                object.Haze = saved.Haze
                object.Glare = saved.Glare
            end
        end)
    end

    table.clear(savedAtmospheres)
end

local function inspectLightingObject(object)
    if settings.fullbright and object:IsA("PostEffect") then
        disableEffect(object)
    end

    if settings.noFog and object:IsA("Atmosphere") then
        clearAtmosphere(object)
    end
end

local function inspectLighting()
    for _, object in ipairs(Lighting:GetDescendants()) do
        inspectLightingObject(object)
    end

    local camera = Workspace.CurrentCamera
    if camera then
        for _, object in ipairs(camera:GetDescendants()) do
            inspectLightingObject(object)
        end
    end
end

local function applyLighting()
    if settings.fullbright then
        setProperties(brightValues)

        for object in pairs(savedEffects) do
            pcall(function()
                if object.Parent then
                    object.Enabled = false
                end
            end)
        end
    end

    if settings.noFog then
        setProperties(fogValues)

        for object in pairs(savedAtmospheres) do
            pcall(function()
                if object.Parent then
                    object.Density = 0
                    object.Haze = 0
                    object.Glare = 0
                end
            end)
        end
    end
end

local function setFullbright(enabled)
    if settings.fullbright == enabled then
        return
    end

    settings.fullbright = enabled

    if enabled then
        saveProperties(brightValues, savedBright)
        inspectLighting()
        applyLighting()
    else
        restoreProperties(savedBright)
        restoreEffects()
    end
end

local function setNoFog(enabled)
    if settings.noFog == enabled then
        return
    end

    settings.noFog = enabled

    if enabled then
        saveProperties(fogValues, savedFog)
        inspectLighting()
        applyLighting()
    else
        restoreProperties(savedFog)
        restoreAtmospheres()
    end
end

saveProperties(brightValues, savedBright)
saveProperties(fogValues, savedFog)
inspectLighting()
applyLighting()

connect(Lighting.DescendantAdded, function(object)
    if alive then
        inspectLightingObject(object)
    end
end)

-- ==========================================
-- GUI
-- ==========================================

local screen = Instance.new("ScreenGui")
screen.Name = "HushMonoV8"
screen.ResetOnSpawn = false
screen.IgnoreGuiInset = true
screen.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
screen.Parent = playerGui

local linesFolder = Instance.new("Folder")
linesFolder.Name = "Lines"
linesFolder.Parent = screen

local main = Instance.new("Frame")
main.Name = "Main"
main.Size = UDim2.fromOffset(330, 510)
main.Position = UDim2.new(0, 35, 0.5, -255)
main.BackgroundColor3 = colors.background
main.BorderSizePixel = 0
main.ClipsDescendants = true
main.Parent = screen
corner(main, 14)
stroke(main, colors.white, 0.28)

local header = Instance.new("Frame")
header.Size = UDim2.new(1, 0, 0, 58)
header.BackgroundColor3 = colors.panel
header.BorderSizePixel = 0
header.Active = true
header.Parent = main

local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, -24, 0, 25)
title.Position = UDim2.fromOffset(12, 5)
title.BackgroundTransparency = 1
title.Text = "HUSH  /  MONO NEON"
title.TextColor3 = colors.white
title.TextSize = 16
title.Font = Enum.Font.GothamBold
title.TextXAlignment = Enum.TextXAlignment.Left
title.Parent = header

local subtitle = Instance.new("TextLabel")
subtitle.Size = UDim2.new(1, -24, 0, 18)
subtitle.Position = UDim2.fromOffset(12, 30)
subtitle.BackgroundTransparency = 1
subtitle.Text = "V8 + AUTO HOTWIRE  •  RightShift"
subtitle.TextColor3 = colors.muted
subtitle.TextSize = 11
subtitle.Font = Enum.Font.Gotham
subtitle.TextXAlignment = Enum.TextXAlignment.Left
subtitle.Parent = header

local scroll = Instance.new("ScrollingFrame")
scroll.Name = "Content"
scroll.Position = UDim2.fromOffset(10, 65)
scroll.Size = UDim2.new(1, -20, 1, -75)
scroll.BackgroundTransparency = 1
scroll.BorderSizePixel = 0
scroll.ScrollBarThickness = 3
scroll.ScrollBarImageColor3 = colors.white
scroll.CanvasSize = UDim2.fromOffset(0, 0)
scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
scroll.Parent = main

local layout = Instance.new("UIListLayout")
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Padding = UDim.new(0, 6)
layout.Parent = scroll

local padding = Instance.new("UIPadding")
padding.PaddingRight = UDim.new(0, 5)
padding.PaddingBottom = UDim.new(0, 8)
padding.Parent = scroll

local order = 0

local function nextOrder()
    order += 1
    return order
end

local function makeLabel(text, height, color)
    local label = Instance.new("TextLabel")
    label.LayoutOrder = nextOrder()
    label.Size = UDim2.new(1, 0, 0, height or 26)
    label.BackgroundColor3 = colors.panel
    label.BorderSizePixel = 0
    label.Text = text
    label.TextColor3 = color or colors.white
    label.TextSize = 12
    label.Font = Enum.Font.GothamMedium
    label.Parent = scroll
    corner(label, 7)
    return label
end

local function makeButton(text, callback)
    local button = Instance.new("TextButton")
    button.LayoutOrder = nextOrder()
    button.Size = UDim2.new(1, 0, 0, 30)
    button.BackgroundColor3 = colors.button
    button.BorderSizePixel = 0
    button.Text = text
    button.TextColor3 = colors.white
    button.TextSize = 12
    button.Font = Enum.Font.GothamMedium
    button.AutoButtonColor = false
    button.Parent = scroll
    corner(button, 7)

    connect(button.MouseEnter, function()
        button.BackgroundColor3 = colors.hover
    end)

    connect(button.MouseLeave, function()
        button.BackgroundColor3 = colors.button
    end)

    connect(button.MouseButton1Click, function()
        if alive then
            callback(button)
        end
    end)

    return button
end

local function toggleText(name, enabled)
    return name .. ": " .. (enabled and "ВКЛ" or "ВЫКЛ")
end

local noiseLabel = makeLabel("Шум: поиск индикатора...", 28)
local statusLabel = makeLabel("Игроки: 0 | Монстры: 0 | Глаза: 0", 26, colors.muted)
local motherStatus = makeLabel("Мать: поиск...", 26, colors.muted)

makeButton(toggleText("ESP монстров", settings.monsterESP), function(button)
    settings.monsterESP = not settings.monsterESP
    button.Text = toggleText("ESP монстров", settings.monsterESP)
end)

makeButton(toggleText("ESP глазиков", settings.watcherESP), function(button)
    settings.watcherESP = not settings.watcherESP
    button.Text = toggleText("ESP глазиков", settings.watcherESP)
end)

makeButton(toggleText("ESP игроков", settings.playerESP), function(button)
    settings.playerESP = not settings.playerESP
    button.Text = toggleText("ESP игроков", settings.playerESP)
end)

makeButton(toggleText("ESP Матери", settings.motherESP), function(button)
    settings.motherESP = not settings.motherESP
    button.Text = toggleText("ESP Матери", settings.motherESP)
end)

makeButton(toggleText("Линии к монстрам", settings.monsterLines), function(button)
    settings.monsterLines = not settings.monsterLines
    button.Text = toggleText("Линии к монстрам", settings.monsterLines)
end)

makeButton(toggleText("Fullbright", settings.fullbright), function(button)
    setFullbright(not settings.fullbright)
    button.Text = toggleText("Fullbright", settings.fullbright)
end)

makeButton(toggleText("No Fog", settings.noFog), function(button)
    setNoFog(not settings.noFog)
    button.Text = toggleText("No Fog", settings.noFog)
end)

local hotwireSection = makeLabel("──  AUTO HOTWIRE  ──", 24, colors.muted)
hotwireSection.TextSize = 11

local hotwireButton
local hotwireStatus = makeLabel("Автоугон: выключен", 26, colors.muted)
hotwireStatus.TextSize = 11

local previousHotwireAngle = nil
local lastHotwirePress = 0

local okVim, vim = pcall(function()
    return game:GetService("VirtualInputManager")
end)

local function setAutoHotwire(enabled)
    settings.autoHotwire = enabled
    previousHotwireAngle = nil

    if hotwireButton then
        hotwireButton.Text = toggleText("Автоугон [F7]", enabled)
    end

    if not enabled then
        hotwireStatus.Text = "Автоугон: выключен"
    elseif not okVim or not vim then
        hotwireStatus.Text = "Автоугон: VirtualInputManager недоступен"
    else
        hotwireStatus.Text = "Автоугон: ожидание мини-игры"
    end
end

hotwireButton = makeButton(
    toggleText("Автоугон [F7]", settings.autoHotwire),
    function()
        setAutoHotwire(not settings.autoHotwire)
    end
)

local section = makeLabel("──  CAR BOOST  ──", 24, colors.muted)
section.TextSize = 11

local carStatus = makeLabel("Авто: сядь за руль", 26, colors.muted)
carStatus.TextSize = 11

makeButton(toggleText("Ускорение машины", settings.carBoost), function(button)
    settings.carBoost = not settings.carBoost
    button.Text = toggleText("Ускорение машины", settings.carBoost)
end)

makeButton(toggleText("Ноуклип машины", settings.carNoclip), function(button)
    settings.carNoclip = not settings.carNoclip
    button.Text = toggleText("Ноуклип машины", settings.carNoclip)
end)

local function makeAdjuster(titleText, getValue, setValue, step, minimum, maximum, suffix)
    local row = Instance.new("Frame")
    row.LayoutOrder = nextOrder()
    row.Size = UDim2.new(1, 0, 0, 30)
    row.BackgroundTransparency = 1
    row.Parent = scroll

    local function sideButton(text, position)
        local button = Instance.new("TextButton")
        button.Size = UDim2.fromOffset(38, 30)
        button.Position = position
        button.BackgroundColor3 = colors.button
        button.BorderSizePixel = 0
        button.Text = text
        button.TextColor3 = colors.white
        button.TextSize = 16
        button.Font = Enum.Font.GothamBold
        button.Parent = row
        corner(button, 7)
        return button
    end

    local minus = sideButton("−", UDim2.fromOffset(0, 0))
    local plus = sideButton("+", UDim2.new(1, -38, 0, 0))

    local label = Instance.new("TextLabel")
    label.Position = UDim2.fromOffset(44, 0)
    label.Size = UDim2.new(1, -88, 1, 0)
    label.BackgroundColor3 = colors.panel
    label.BorderSizePixel = 0
    label.TextColor3 = colors.white
    label.TextSize = 11
    label.Font = Enum.Font.GothamMedium
    label.Parent = row
    corner(label, 7)

    local function refresh()
        label.Text = titleText .. ": " .. getValue() .. (suffix or "")
    end

    connect(minus.MouseButton1Click, function()
        setValue(math.clamp(getValue() - step, minimum, maximum))
        refresh()
    end)

    connect(plus.MouseButton1Click, function()
        setValue(math.clamp(getValue() + step, minimum, maximum))
        refresh()
    end)

    refresh()
end

makeAdjuster(
    "Ускорение",
    function() return settings.carAcceleration end,
    function(value) settings.carAcceleration = value end,
    5, 0, 55, ""
)

makeAdjuster(
    "Предел буста",
    function() return settings.carSpeedLimit end,
    function(value) settings.carSpeedLimit = value end,
    5, 50, 135, " studs/с"
)

local hint = makeLabel("Ноуклип может провалить авто сквозь дорогу", 26, colors.red)
hint.TextSize = 10

local cleanup
local stopButton = makeButton("ВЫКЛЮЧИТЬ СКРИПТ", function()
    cleanup()
end)
stopButton.TextColor3 = colors.red

-- Перетаскивание
local dragging = false
local dragInput
local dragStart
local startPosition

connect(header.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then

        dragging = true
        dragInput = input
        dragStart = input.Position
        startPosition = main.Position
    end
end)

connect(header.InputChanged, function(input)
    if input.UserInputType == Enum.UserInputType.MouseMovement then
        dragInput = input
    end
end)

connect(UIS.InputChanged, function(input)
    if dragging and input == dragInput and dragStart and startPosition then
        local delta = input.Position - dragStart
        main.Position = UDim2.new(
            startPosition.X.Scale,
            startPosition.X.Offset + delta.X,
            startPosition.Y.Scale,
            startPosition.Y.Offset + delta.Y
        )
    end
end)

connect(UIS.InputEnded, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        dragging = false
    end
end)

connect(UIS.InputBegan, function(input, processed)
    if processed or UIS:GetFocusedTextBox() then
        return
    end

    if input.KeyCode == Enum.KeyCode.RightShift then
        main.Visible = not main.Visible
    elseif input.KeyCode == Enum.KeyCode.F7 then
        setAutoHotwire(not settings.autoHotwire)
    end
end)

-- ==========================================
-- АВТОУГОН
-- ==========================================

local function signedDifference(a, b)
    return (a - b + 180) % 360 - 180
end

local function getYellowCenter(zone)
    local x, y, count = 0, 0, 0

    for _, segment in ipairs(zone:GetChildren()) do
        if segment:IsA("GuiObject") and segment.Visible then
            for _, inner in ipairs(segment:GetChildren()) do
                if inner:IsA("GuiObject") and inner.Visible then
                    local color = inner.BackgroundColor3

                    if color.R > 0.85
                        and color.G > 0.55
                        and color.G < 0.88
                        and color.B < 0.5 then

                        local angle = math.rad(segment.Rotation + zone.Rotation)
                        x += math.cos(angle)
                        y += math.sin(angle)
                        count += 1
                        break
                    end
                end
            end
        end
    end

    if count == 0 then
        return nil
    end

    return math.deg(math.atan2(y, x)) % 360
end

local function pressHotwireSpace()
    if not okVim or not vim then
        setAutoHotwire(false)
        hotwireStatus.Text = "Автоугон: VirtualInputManager недоступен"
        return
    end

    local success, err = pcall(function()
        vim:SendKeyEvent(true, Enum.KeyCode.Space, false, game)
    end)

    if not success then
        setAutoHotwire(false)
        hotwireStatus.Text = "Автоугон: ошибка ввода, смотри консоль"
        warn("[HUSH] Ошибка автоугона:", err)
        return
    end

    task.delay(0.04, function()
        pcall(function()
            vim:SendKeyEvent(false, Enum.KeyCode.Space, false, game)
        end)
    end)

    hotwireStatus.Text = "Автоугон: пробел отправлен"
end

local function updateHotwire()
    if not settings.autoHotwire then
        return
    end

    if UIS:GetFocusedTextBox() then
        previousHotwireAngle = nil
        hotwireStatus.Text = "Автоугон: пауза, открыт ввод текста"
        return
    end

    local hotwire = playerGui:FindFirstChild("HotwireGui")
    local holder = hotwire and hotwire:FindFirstChild("Holder")
    local dial = holder and holder:FindFirstChild("Dial")
    local needle = dial and dial:FindFirstChild("Needle")
    local zone = dial and dial:FindFirstChild("Zone")

    if not hotwire or not hotwire.Enabled
        or not holder or not holder.Visible
        or not dial or not dial.Visible
        or not needle or not needle.Visible
        or not zone or not zone.Visible then

        previousHotwireAngle = nil
        hotwireStatus.Text = "Автоугон: ожидание мини-игры"
        return
    end

    local target = getYellowCenter(zone)

    if not target then
        previousHotwireAngle = nil
        hotwireStatus.Text = "Автоугон: жёлтый сектор не найден"
        return
    end

    local angle = needle.Rotation % 360
    local difference = signedDifference(angle, target)
    local shouldPress = math.abs(difference) <= 3

    if previousHotwireAngle then
        local movement = signedDifference(angle, previousHotwireAngle)
        local fromPreviousToTarget = signedDifference(target, previousHotwireAngle)

        if math.abs(movement) < 60
            and movement ~= 0
            and fromPreviousToTarget * movement > 0
            and math.abs(fromPreviousToTarget) <= math.abs(movement) then

            shouldPress = true
        end
    end

    previousHotwireAngle = angle

    if shouldPress and os.clock() - lastHotwirePress >= 1 then
        lastHotwirePress = os.clock()
        pressHotwireSpace()
    elseif os.clock() - lastHotwirePress >= 1 then
        hotwireStatus.Text = "Автоугон: ожидание стрелки"
    end
end

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

local monsterVisuals = {}
local watcherVisuals = {}
local playerVisuals = {}
local motherVisuals = {}

local function getRoot(model)
    if not model or not model:IsA("Model") then
        return nil
    end

    local root = model:FindFirstChild("HumanoidRootPart")
        or model:FindFirstChild("Core")
        or model.PrimaryPart
        or model:FindFirstChildWhichIsA("BasePart", true)

    if root and root:IsA("BasePart") then
        return root
    end

    return nil
end

local function destroyVisual(visual)
    if not visual then return end
    if visual.highlight then visual.highlight:Destroy() end
    if visual.billboard then visual.billboard:Destroy() end
    if visual.line then visual.line:Destroy() end
end

local function makeVisual(model, root, color, withLine, maxDistance)
    local highlight = Instance.new("Highlight")
    highlight.Name = "HushHighlight"
    highlight.Adornee = model
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.FillColor = color
    highlight.FillTransparency = 0.75
    highlight.OutlineColor = color
    highlight.OutlineTransparency = 0
    highlight.Parent = screen

    local billboard = Instance.new("BillboardGui")
    billboard.Name = "HushBillboard"
    billboard.Adornee = root
    billboard.Size = UDim2.fromOffset(180, 42)
    billboard.StudsOffset = Vector3.new(0, 3, 0)
    billboard.AlwaysOnTop = true
    billboard.MaxDistance = maxDistance or settings.range
    billboard.Parent = screen

    local label = Instance.new("TextLabel")
    label.Size = UDim2.fromScale(1, 1)
    label.BackgroundTransparency = 1
    label.TextColor3 = color
    label.TextStrokeColor3 = Color3.new(0, 0, 0)
    label.TextStrokeTransparency = 0
    label.TextSize = 13
    label.Font = Enum.Font.GothamBold
    label.TextWrapped = true
    label.Parent = billboard

    local line

    if withLine then
        line = Instance.new("Frame")
        line.Name = "TrackerLine"
        line.AnchorPoint = Vector2.new(0.5, 0.5)
        line.BorderSizePixel = 0
        line.BackgroundColor3 = color
        line.Visible = false
        line.Parent = linesFolder
    end

    return {
        model = model,
        root = root,
        highlight = highlight,
        billboard = billboard,
        label = label,
        line = line
    }
end

local function ensureVisual(collection, key, model, root, color, withLine, maxDistance)
    local visual = collection[key]

    if visual and (visual.model ~= model or visual.root ~= root) then
        destroyVisual(visual)
        collection[key] = nil
        visual = nil
    end

    if not visual then
        visual = makeVisual(model, root, color, withLine, maxDistance)
        collection[key] = visual
    end

    visual.highlight.FillColor = color
    visual.highlight.OutlineColor = color
    visual.label.TextColor3 = color

    if visual.line then
        visual.line.BackgroundColor3 = color
    end

    return visual
end

local function removeMissing(collection, wanted)
    for key, visual in pairs(collection) do
        if not wanted[key] then
            destroyVisual(visual)
            collection[key] = nil
        end
    end
end

local function updatePlayers(myRoot)
    local wanted = {}
    local count = 0

    if settings.playerESP and myRoot then
        for _, other in ipairs(Players:GetPlayers()) do
            if other ~= player then
                local character = other.Character
                local root = getRoot(character)
                local humanoid = character and character:FindFirstChildOfClass("Humanoid")

                if character and root and (not humanoid or humanoid.Health > 0) then
                    local distance = (root.Position - myRoot.Position).Magnitude

                    if distance <= settings.range then
                        wanted[other] = true
                        count += 1

                        local visual = ensureVisual(
                            playerVisuals, other, character, root,
                            colors.player, false
                        )

                        visual.label.Text = other.DisplayName
                            .. "\n" .. math.floor(distance) .. " studs"
                    end
                end
            end
        end
    end

    removeMissing(playerVisuals, wanted)
    return count
end

local function updateMonsters(myRoot)
    local wanted = {}
    local candidates = {}
    local folder = Workspace:FindFirstChild("Monsters")

    if settings.monsterESP and folder and myRoot then
        for _, model in ipairs(folder:GetChildren()) do
            if model:IsA("Model") then
                local root = getRoot(model)
                local humanoid = model:FindFirstChildOfClass("Humanoid")

                if root and (not humanoid or humanoid.Health > 0) then
                    local distance = (root.Position - myRoot.Position).Magnitude

                    if distance <= settings.range then
                        table.insert(candidates, {
                            model = model,
                            root = root,
                            distance = distance
                        })
                    end
                end
            end
        end

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

        for i = 1, math.min(settings.maxMonsters, #candidates) do
            local item = candidates[i]
            local color = i == 1 and colors.nearest or colors.monster

            wanted[item.model] = true

            local visual = ensureVisual(
                monsterVisuals, item.model, item.model, item.root,
                color, true
            )

            visual.label.Text = item.model.Name
                .. "\n" .. math.floor(item.distance) .. " studs"
        end
    end

    removeMissing(monsterVisuals, wanted)
    return math.min(#candidates, settings.maxMonsters)
end

local function updateWatchers(myRoot)
    local wanted = {}
    local count = 0
    local folder = Workspace:FindFirstChild("Watchers")

    if settings.watcherESP and folder and myRoot then
        for _, model in ipairs(folder:GetChildren()) do
            if model:IsA("Model") then
                local root = model:FindFirstChild("Core") or getRoot(model)

                if root and root:IsA("BasePart") then
                    local distance = (root.Position - myRoot.Position).Magnitude

                    if distance <= settings.range then
                        wanted[model] = true
                        count += 1

                        local visual = ensureVisual(
                            watcherVisuals, model, model, root,
                            colors.watcher, false
                        )

                        visual.label.Text = "ГЛАЗИК"
                            .. "\n" .. math.floor(distance) .. " studs"
                    end
                end
            end
        end
    end

    removeMissing(watcherVisuals, wanted)
    return count
end

local function updateMother(myRoot)
    local wanted = {}
    local model = Workspace:FindFirstChild("Mother")

    if not settings.motherESP then
        motherStatus.Text = "Мать: ESP выключен"
    elseif not model or not model:IsA("Model") then
        motherStatus.Text = "Мать: модель не найдена"
    else
        local root = getRoot(model)

        if not root then
            motherStatus.Text = "Мать: модель есть, деталь не найдена"
        else
            wanted[model] = true

            local visual = ensureVisual(
                motherVisuals, model, model, root,
                colors.mother, false, 100000
            )

            if myRoot then
                local distance = (root.Position - myRoot.Position).Magnitude
                visual.label.Text = "МАТЬ\n" .. math.floor(distance) .. " studs"
                motherStatus.Text = "Мать: " .. math.floor(distance) .. " studs"
            else
                visual.label.Text = "МАТЬ"
                motherStatus.Text = "Мать: найдена"
            end
        end
    end

    removeMissing(motherVisuals, wanted)
end

local function updateLines()
    local camera = Workspace.CurrentCamera

    for _, visual in pairs(monsterVisuals) do
        local line = visual.line

        if line then
            line.Visible = false

            if settings.monsterESP
                and settings.monsterLines
                and camera
                and visual.root
                and visual.root.Parent then

                local point, onScreen = camera:WorldToViewportPoint(
                    visual.root.Position
                )

                if onScreen and point.Z > 0 then
                    local viewport = camera.ViewportSize
                    local startPoint = Vector2.new(viewport.X / 2, viewport.Y - 20)
                    local targetPoint = Vector2.new(point.X, point.Y)
                    local delta = targetPoint - startPoint
                    local midpoint = (startPoint + targetPoint) / 2

                    line.Size = UDim2.fromOffset(delta.Magnitude, 2)
                    line.Position = UDim2.fromOffset(midpoint.X, midpoint.Y)
                    line.Rotation = math.deg(math.atan2(delta.Y, delta.X))
                    line.Visible = true
                end
            end
        end
    end
end

local function updateNoise()
    local hud = playerGui:FindFirstChild("HudGui")
    local sway = hud and hud:FindFirstChild("Sway")
    local noise = sway and sway:FindFirstChild("Noise")
    local label = noise and noise:FindFirstChild("TextLabel")

    if label and label:IsA("TextLabel") then
        noiseLabel.Text = "Шум: " .. label.Text
    else
        noiseLabel.Text = "Шум: индикатор не найден"
    end
end

-- ==========================================
-- МАШИНА
-- ==========================================

local function getCarParts()
    local character = player.Character
    local humanoid = character and character:FindFirstChildOfClass("Humanoid")
    local seat = humanoid and humanoid.SeatPart

    if not seat or seat.Name ~= "DriverSeat" then
        return nil
    end

    local car = seat:FindFirstAncestorOfClass("Model")
    if not car then
        return nil
    end

    local body = seat.AssemblyRootPart
    if not body or body.Anchored then
        return nil
    end

    return body, seat, car
end

local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Exclude

local collisionSaved = {}
local collisionCar
local collisionAddedConnection

local function restoreCarCollision()
    if collisionAddedConnection then
        collisionAddedConnection:Disconnect()
        collisionAddedConnection = nil
    end

    for part, original in pairs(collisionSaved) do
        pcall(function()
            if part.Parent then
                part.CanCollide = original
            end
        end)
    end

    table.clear(collisionSaved)
    collisionCar = nil
end

local function trackCollisionPart(part)
    if not part:IsA("BasePart") then
        return
    end

    if collisionSaved[part] == nil then
        collisionSaved[part] = part.CanCollide
    end

    pcall(function()
        part.CanCollide = false
    end)
end

local function startCarNoclip(car)
    restoreCarCollision()
    collisionCar = car

    for _, object in ipairs(car:GetDescendants()) do
        trackCollisionPart(object)
    end

    collisionAddedConnection = car.DescendantAdded:Connect(function(object)
        if alive and settings.carNoclip and collisionCar == car then
            trackCollisionPart(object)
        end
    end)
end

local function updateCarNoclip(car)
    if not settings.carNoclip or not car then
        if collisionCar then
            restoreCarCollision()
        end
        return
    end

    if collisionCar ~= car then
        startCarNoclip(car)
    end

    for part in pairs(collisionSaved) do
        pcall(function()
            if part.Parent and part.CanCollide then
                part.CanCollide = false
            end
        end)
    end
end

-- ==========================================
-- ОБНОВЛЕНИЕ
-- ==========================================

local espElapsed = 0
local lightingScanElapsed = 0
local carStatusElapsed = 0

connect(RunService.Heartbeat, function(dt)
    if not alive then return end

    local body, seat, car = getCarParts()
    updateCarNoclip(car)

    local holdingW = UIS:IsKeyDown(Enum.KeyCode.W)
    local holdingS = UIS:IsKeyDown(Enum.KeyCode.S)
    local typing = UIS:GetFocusedTextBox() ~= nil

    if body and seat and car then
        local velocity = body.AssemblyLinearVelocity
        local horizontal = Vector3.new(velocity.X, 0, velocity.Z)
        local speed = horizontal.Magnitude

        local upright = seat.CFrame.UpVector:Dot(Vector3.yAxis) > 0.65

        local character = player.Character
        rayParams.FilterDescendantsInstances = character and {car, character} or {car}

        local ground = Workspace:Raycast(
            body.Position,
            Vector3.new(0, -9, 0),
            rayParams
        )

        local grounded = ground ~= nil

        local forward = seat.CFrame.LookVector
        local flatForward = Vector3.new(forward.X, 0, forward.Z)
        local movingForward = false

        if flatForward.Magnitude > 0.01 and speed > 5 then
            movingForward = horizontal.Unit:Dot(flatForward.Unit) > 0.2
        end

        local canBoost =
            settings.carBoost
            and holdingW
            and not holdingS
            and not typing
            and upright
            and grounded
            and movingForward
            and speed < settings.carSpeedLimit

        if canBoost then
            local addition = math.min(
                settings.carAcceleration * math.min(dt, 0.05),
                settings.carSpeedLimit - speed
            )

            body.AssemblyLinearVelocity = velocity + horizontal.Unit * addition
        end

        carStatusElapsed += dt
        if carStatusElapsed >= 0.2 then
            carStatusElapsed = 0

            local reason

            if not settings.carBoost then
                reason = "буст выкл"
            elseif not upright then
                reason = "переворот"
            elseif not grounded then
                reason = "нет земли"
            elseif typing then
                reason = "ввод текста"
            elseif not holdingW or holdingS then
                reason = "ожидание W"
            elseif not movingForward then
                reason = "нет движения вперёд"
            elseif speed >= settings.carSpeedLimit then
                reason = "предел"
            else
                reason = "буст"
            end

            carStatus.Text = string.format(
                "Авто: %.1f studs/с | %s",
                speed,
                reason
            )
        end
    else
        carStatusElapsed += dt
        if carStatusElapsed >= 0.2 then
            carStatusElapsed = 0
            carStatus.Text = "Авто: сядь за руль"
        end
    end

    espElapsed += dt

    if espElapsed >= 0.25 then
        espElapsed = 0

        local myRoot = getRoot(player.Character)
        local playerCount = updatePlayers(myRoot)
        local monsterCount = updateMonsters(myRoot)
        local watcherCount = updateWatchers(myRoot)

        statusLabel.Text = "Игроки: " .. playerCount
            .. " | Монстры: " .. monsterCount
            .. " | Глаза: " .. watcherCount

        updateMother(myRoot)
        updateNoise()
    end

    lightingScanElapsed += dt

    if lightingScanElapsed >= 0.5 then
        lightingScanElapsed = 0

        if settings.fullbright or settings.noFog then
            inspectLighting()
        end
    end
end)

local renderName = "HushMonoV8Lighting"
RunService:UnbindFromRenderStep(renderName)

RunService:BindToRenderStep(
    renderName,
    Enum.RenderPriority.Last.Value,
    function()
        if not alive then return end
        applyLighting()
        updateLines()
        updateHotwire()
    end
)

-- ==========================================
-- ОЧИСТКА
-- ==========================================

cleanup = function()
    if not alive then return end

    alive = false
    settings.carBoost = false
    settings.carNoclip = false
    settings.autoHotwire = false

    RunService:UnbindFromRenderStep(renderName)

    for _, connection in ipairs(connections) do
        connection:Disconnect()
    end

    pcall(function()
        if vim then
            vim:SendKeyEvent(false, Enum.KeyCode.Space, false, game)
        end
    end)

    restoreCarCollision()

    if settings.fullbright then
        settings.fullbright = false
        restoreProperties(savedBright)
        restoreEffects()
    end

    if settings.noFog then
        settings.noFog = false
        restoreProperties(savedFog)
        restoreAtmospheres()
    end

    for _, collection in ipairs({
        monsterVisuals,
        watcherVisuals,
        playerVisuals,
        motherVisuals
    }) do
        for _, visual in pairs(collection) do
            destroyVisual(visual)
        end

        table.clear(collection)
    end

    screen:Destroy()

    if env.HushMonoV8Cleanup == cleanup then
        env.HushMonoV8Cleanup = nil
    end

    print("[HUSH V8] Скрипт выключен.")
end

env.HushMonoV8Cleanup = cleanup

print("[HUSH V8] Загружен. RightShift — меню, F7 — автоугон.")