random

-- WARNING! Dont use get all exits if baldi still doing intro thing or he will
-- be super fast
local repo = 'https://raw.githubusercontent.com/violin-suzutsuki/LinoriaLib/main/'
local Lib = loadstring(game:HttpGet(repo .. 'Library.lua'))()
local Theme = loadstring(game:HttpGet(repo .. 'addons/ThemeManager.lua'))()
local Save = loadstring(game:HttpGet(repo .. 'addons/SaveManager.lua'))()

-- ==========================================
-- ESP SYSTEM
-- ==========================================
local ESP = (function()
    local self = {
        Font = Enum.Font.RobotoCondensed,
        Rainbow = false, Tracers = false, Unloaded = false,
        ShowDistance = false, MatchColors = true, Arrows = false,
        TextTransparency = 0, TracerOrigin = "Bottom",
        FillTransparency = 0.75, OutlineTransparency = 0,
        TextOutlineTransparency = 0, FadeTime = 0.2, RenderLimit = 240,
        TracerSize = 0.5, ArrowRadius = 200, TextSize = 18, DistanceSizeRatio = 0.8,
        OutlineColor = Color3.fromRGB(255, 255, 255),
        RainbowColor = Color3.fromRGB(255, 255, 255),
        ElementsEnabled = {}, TransparencyEnabled = {},
        Highlights = {}, Labels = {}, Frames = {}, Lines = {},
        ArrowsTable = {}, ColorTable = {}, TextTable = {},
        ConnectionsTable = {}, Objects = {}, TotalObjects = {},
        NotebookObjects = {}
    }

    local rs = {h = 0, hue = 0, step = 0, color = Color3.new()}
    local rbConn, camConn

    local cloneref = cloneref or function(o) return o end
    local Players = cloneref(game:GetService("Players"))
    local coregui = getgenv and cloneref(game:GetService("CoreGui")) or Players.LocalPlayer.PlayerGui
    local ws = cloneref(workspace)
    local runsvc = cloneref(game:GetService("RunService"))
    local tween = cloneref(game:GetService("TweenService"))
    local uis = cloneref(game:GetService("UserInputService"))
    local lp = Players.LocalPlayer

    local function getHiddenUI()
        if gethui then return gethui() end
        local f = Instance.new("Folder", coregui)
        f.Name = ("%032x"):format(math.random(0, 2^31))
        return f
    end

    function self:randstr()
        local s = {}
        local pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        for i = 1, 24 do s[i] = pool:sub(math.random(1, #pool)) end
        return table.concat(s)
    end

    local hiddenUI = getHiddenUI()
    local cam = ws.CurrentCamera

    local sg = Instance.new("ScreenGui")
    sg.ResetOnSpawn = false
    sg.IgnoreGuiInset = true
    sg.Name = self:randstr()
    sg.Parent = hiddenUI

    local hlFolder = Instance.new("Folder")
    hlFolder.Name = self:randstr()
    hlFolder.Parent = sg

    local bbFolder = Instance.new("Folder")
    bbFolder.Name = self:randstr()
    bbFolder.Parent = sg

    local trFrame = Instance.new("Frame")
    trFrame.Size = UDim2.new(1, 0, 1, 0)
    trFrame.BackgroundTransparency = 1
    trFrame.Visible = false
    trFrame.Name = self:randstr()
    trFrame.Parent = sg

    local arFrame = Instance.new("Frame")
    arFrame.Size = UDim2.new(1, 0, 1, 0)
    arFrame.BackgroundTransparency = 1
    arFrame.Visible = false
    arFrame.Name = self:randstr()
    arFrame.Parent = sg

    local arrowTpl = Instance.new("ImageLabel")
    arrowTpl.Image = "rbxassetid://16368985219"
    arrowTpl.Size = UDim2.new(0, 50, 0, 50)
    arrowTpl.AnchorPoint = Vector2.new(0.5, 0.5)
    arrowTpl.BackgroundTransparency = 1
    arrowTpl.ImageTransparency = 1
    local arCon = Instance.new("UIAspectRatioConstraint")
    arCon.AspectRatio = 1
    arCon.Name = self:randstr()
    arCon.Parent = arrowTpl

    local function mkTween(obj, props)
        if not obj or not obj.Parent then return nil end
        return tween:Create(obj, TweenInfo.new(self.FadeTime, Enum.EasingStyle.Quad), props)
    end
    local function playTween(obj, props)
        if not obj or not obj.Parent then return end
        local t = mkTween(obj, props)
        if t then t:Play() end
    end

    local function destroyData(obj)
        if self.Highlights[obj] then self.Highlights[obj]:Destroy() self.Highlights[obj] = nil end
        if self.Frames[obj] then self.Frames[obj]:Destroy() self.Frames[obj] = nil end
        if self.Lines[obj] then
            if self.Lines[obj][1] then self.Lines[obj][1]:Destroy() end
            self.Lines[obj] = nil
        end
        if self.ArrowsTable[obj] then self.ArrowsTable[obj]:Destroy() self.ArrowsTable[obj] = nil end
        if self.ConnectionsTable[obj] then
            for _, c in ipairs(self.ConnectionsTable[obj]) do c:Disconnect() end
            self.ConnectionsTable[obj] = nil
        end
        self.Labels[obj] = nil
        self.ColorTable[obj] = nil
        self.TextTable[obj] = nil
        self.ElementsEnabled[obj] = nil
        self.TransparencyEnabled[obj] = nil
        self.Objects[obj] = nil
        self.NotebookObjects[obj] = nil
        for i = #self.TotalObjects, 1, -1 do
            if self.TotalObjects[i] == obj then table.remove(self.TotalObjects, i) break end
        end
    end

    function self:AddESP(params)
        local obj = params.Object
        if self.ElementsEnabled[obj] == true or self.Unloaded then return end
        if not obj:IsA("BasePart") and not obj:IsA("Model") then return end

        self.ElementsEnabled[obj] = true
        self.TransparencyEnabled[obj] = false
        self.ConnectionsTable[obj] = self.ConnectionsTable[obj] or {}

        if params.IsNotebook then
            self.NotebookObjects[obj] = true
        end

        local hl = Instance.new("Highlight")
        hl.FillTransparency = 1
        hl.OutlineTransparency = 1
        hl.Name = self:randstr()
        hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
        hl.Adornee = obj
        hl.Parent = hlFolder
        self.Highlights[obj] = hl

        local tf = Instance.new("Frame")
        tf.Visible = false
        tf.Name = self:randstr()
        tf.Size = UDim2.fromScale(1, 1)
        tf.BackgroundTransparency = 1
        tf.AnchorPoint = Vector2.new(0.5, 0.5)
        tf.Parent = bbFolder

        local tl = Instance.new("TextLabel")
        tl.Name = self:randstr()
        tl.BackgroundTransparency = 1
        tl.Text = params.Text
        tl.TextTransparency = 1
        tl.TextStrokeTransparency = self.TextOutlineTransparency
        tl.Size = UDim2.new(1, 0, 1, 0)
        tl.Font = self.Font
        tl.TextSize = self.TextSize
        tl.RichText = true
        tl.TextColor3 = params.Color
        tl.Parent = tf

        self.Frames[obj] = tf
        self.Labels[obj] = tl
        self.ColorTable[obj] = params.Color
        self.TextTable[obj] = params.Text
        self.Objects[obj] = obj
        table.insert(self.TotalObjects, obj)

        playTween(hl, {FillTransparency = self.FillTransparency})
        playTween(hl, {OutlineTransparency = self.OutlineTransparency})

        local fade = mkTween(tl, {TextTransparency = self.TextTransparency})
        if fade then
            fade.Completed:Once(function() self.TransparencyEnabled[obj] = true end)
            fade:Play()
        end
        playTween(tl, {TextStrokeTransparency = self.TextOutlineTransparency})

        local lf = Instance.new("Frame")
        lf.Size = UDim2.new(0, 0, 0, 0)
        lf.BackgroundTransparency = 1
        lf.AnchorPoint = Vector2.new(0.5, 0.5)
        lf.Name = self:randstr()
        lf.Parent = trFrame

        local sk = Instance.new("UIStroke")
        sk.Thickness = self.TracerSize
        sk.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
        sk.Transparency = 1
        sk.Name = self:randstr()
        sk.Parent = lf

        playTween(lf, {BackgroundTransparency = 0})
        playTween(sk, {Transparency = 0})
        self.Lines[obj] = {lf, sk}

        task.spawn(function()
            local last = 0
            local function render()
                if not obj or not obj:IsDescendantOf(game) then
                    self:RemoveESP(obj)
                    return
                end

                if self.NotebookObjects[obj] then
                    local bbg = obj:FindFirstChildWhichIsA("BillboardGui")
                    if bbg and not bbg.Enabled then
                        self:RemoveESP(obj)
                        return
                    end
                end

                local pos = obj:GetPivot().Position
                local sp, onScreen = cam:WorldToViewportPoint(pos)
                local frame = self.Frames[obj]
                local label = self.Labels[obj]
                local ch = self.Highlights[obj]
                local ld = self.Lines[obj]

                if ld and ld[1] then ld[1].Visible = onScreen end
                if frame then
                    frame.Visible = onScreen
                    if onScreen then frame.Position = UDim2.new(0, sp.X, 0, sp.Y) end
                end
                if not onScreen then
                    if ch then ch:Destroy() self.Highlights[obj] = nil ch = nil end
                elseif self.ElementsEnabled[obj] == true and not ch then
                    ch = Instance.new("Highlight")
                    ch.FillTransparency = 1
                    ch.OutlineTransparency = 1
                    ch.Name = self:randstr()
                    ch.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                    ch.Adornee = obj
                    ch.Parent = hlFolder
                    self.Highlights[obj] = ch
                end

                local color = self.Rainbow and rs.color or self.ColorTable[obj] or Color3.fromRGB(255, 255, 255)
                if label then label.TextColor3 = color end
                if ch then
                    local dist = math.floor((cam.CFrame.Position - pos).Magnitude)
                    local distText = self.ShowDistance and ("\n" .. '<font size="' .. math.round(self.TextSize * self.DistanceSizeRatio) .. '">[' .. dist .. ']</font>') or ""
                    if label then label.Text = self.TextTable[obj] .. distText end
                    ch.Enabled = true
                    ch.FillColor = color
                    ch.OutlineColor = self.MatchColors and color or self.OutlineColor
                    if self.TransparencyEnabled[obj] == true then
                        ch.FillTransparency = self.FillTransparency
                        ch.OutlineTransparency = self.OutlineTransparency
                        if label then
                            label.TextTransparency = self.TextTransparency
                            label.TextStrokeTransparency = self.TextOutlineTransparency
                        end
                    end
                end

                if ld and ch and self.Tracers and onScreen then
                    local ss = cam.ViewportSize
                    local origin
                    if self.TracerOrigin == "Center" then origin = Vector2.new(ss.X / 2, ss.Y / 2)
                    elseif self.TracerOrigin == "Top" then origin = Vector2.new(ss.X / 2, 0)
                    elseif self.TracerOrigin == "Mouse" then origin = Vector2.new(lp:GetMouse().X, uis:GetMouseLocation().Y)
                    else origin = Vector2.new(ss.X / 2, ss.Y) end

                    local dest = Vector2.new(sp.X, sp.Y)
                    local mid = (origin + dest) / 2
                    local rot = math.deg(math.atan2(dest.Y - origin.Y, dest.X - origin.X))
                    local len = (origin - dest).Magnitude
                    ld[1].Position = UDim2.new(0, mid.X, 0, mid.Y)
                    ld[1].Size = UDim2.new(0, len, 0, 1)
                    ld[1].Rotation = rot
                    ld[1].BackgroundColor3 = color
                    ld[1].BorderSizePixel = 0
                    ld[1].Visible = true
                    ld[2].Color = color
                    ld[2].Thickness = self.TracerSize
                end

                if self.Arrows then
                    local ar = self.ArrowsTable[obj]
                    if ar == nil and self.ElementsEnabled[obj] == true then
                        ar = arrowTpl:Clone()
                        ar.Name = self:randstr()
                        ar:WaitForChild(arCon.Name, 5)
                        ar.Parent = arFrame
                        self.ArrowsTable[obj] = ar
                        playTween(ar, {ImageTransparency = 0})
                    elseif ar and self.ElementsEnabled[obj] == true then
                        if onScreen and sp.Z > 0 then ar.Visible = false
                        else
                            local ss = cam.ViewportSize
                            local sc = Vector2.new(ss.X / 2, ss.Y / 2)
                            local toObj = (pos - cam.CFrame.Position).Unit
                            local dir = Vector2.new(sp.X, sp.Y) - sc
                            if cam.CFrame.LookVector:Dot(toObj) < 0 then dir = -dir end
                            local angle = math.atan2(dir.Y, dir.X)
                            local radius = math.min(ss.X, ss.Y) / 2 - (400 - self.ArrowRadius)
                            local ap = sc + dir.Unit * radius
                            ar.Position = UDim2.new(0, ap.X, 0, ap.Y)
                            ar.Rotation = math.deg(angle) - 90
                            ar.Visible = true
                            ar.ImageColor3 = self.Rainbow and self.RainbowColor or self.ColorTable[obj]
                        end
                    end
                end
            end

            local conn
            conn = runsvc.Heartbeat:Connect(function(dt)
                last = last + dt
                if last >= 1 / self.RenderLimit then
                    last = 0
                    if self.ElementsEnabled[obj] ~= true then conn:Disconnect() return end
                    render()
                end
            end)
            table.insert(self.ConnectionsTable[obj], conn)
        end)
    end

    function self:RemoveESP(obj)
        if self.Unloaded or self.ElementsEnabled[obj] ~= true then return end
        self.ElementsEnabled[obj] = false
        self.TransparencyEnabled[obj] = false

        if self.Labels[obj] and self.Labels[obj].Parent then
            playTween(self.Labels[obj], {TextTransparency = 1})
        end
        if self.Lines[obj] then
            if self.Lines[obj][1] and self.Lines[obj][1].Parent then
                playTween(self.Lines[obj][1], {BackgroundTransparency = 1})
            end
            if self.Lines[obj][2] and self.Lines[obj][2].Parent then
                playTween(self.Lines[obj][2], {Transparency = 1})
            end
        end
        if self.Highlights[obj] and self.Highlights[obj].Parent then
            playTween(self.Highlights[obj], {FillTransparency = 1})
            playTween(self.Highlights[obj], {OutlineTransparency = 1})
        end
        if self.ArrowsTable[obj] and self.ArrowsTable[obj].Parent then
            playTween(self.ArrowsTable[obj], {ImageTransparency = 1})
        end

        task.delay(self.FadeTime + 0.05, function()
            if self.ElementsEnabled[obj] == false then
                destroyData(obj)
            else
                if self.Highlights[obj] and self.Highlights[obj].Parent then
                    playTween(self.Highlights[obj], {FillTransparency = self.FillTransparency})
                    playTween(self.Highlights[obj], {OutlineTransparency = self.OutlineTransparency})
                end
            end
        end)
    end

    function self:UpdateText(obj, text)
        if self.TextTable[obj] then self.TextTable[obj] = text end
    end

    function self:UpdateColor(obj, color)
        self.ColorTable[obj] = color
        if self.Labels[obj] and not self.Rainbow then self.Labels[obj].TextColor3 = color end
    end

    function self:Unload()
        if self.Unloaded then return end
        self.Unloaded = true
        for _, o in pairs(self.Objects) do self:RemoveESP(o) end
        for _, conns in pairs(self.ConnectionsTable) do
            for _, c in ipairs(conns) do c:Disconnect() end
        end
        if rbConn then rbConn:Disconnect() end
        if camConn then camConn:Disconnect() end
        sg.Enabled = false
    end

    rbConn = runsvc.RenderStepped:Connect(function(dt)
        rs.step = rs.step + dt
        if rs.step >= (1 / 60) then
            rs.step = 0
            rs.h = rs.h + (1 / 400)
            if rs.h > 1 then rs.h = 0 end
            rs.hue = rs.h
            rs.color = Color3.fromHSV(rs.hue, 0.8, 1)
            self.RainbowColor = rs.color
        end
    end)

    camConn = ws:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
        cam = ws.CurrentCamera
    end)

    return self
end)()

-- ==========================================
-- MAIN MENU
-- ==========================================
local Window = Lib:CreateWindow({
    Title = 'Lighting + ESP + Speed + Game',
    Center = true, AutoShow = true, TabPadding = 8, MenuFadeTime = 0.2
})

local Tabs = {
    Main = Window:AddTab('Main'),
    Game = Window:AddTab('Game'),
    Speed = Window:AddTab('Speed'),
    ESP = Window:AddTab('ESP'),
    ['UI Settings'] = Window:AddTab('UI Settings'),
}

-- ==========================================
-- VARIABLES
-- ==========================================
local lp = game:GetService('Players').LocalPlayer
local Lighting = game:GetService('Lighting')

local fogOn = false
local fogSaved = {}
local fogConns = {}
local fogSelfChange = false
local ccOff = false
local fireOff = false
local cinOff = false
local walkSpd = 16
local runSpd = 24
local pColor = Color3.fromRGB(0, 255, 0)
local bColor = Color3.fromRGB(255, 0, 0)
local tColor = Color3.fromRGB(255, 255, 0)
local nColor = Color3.fromRGB(0, 255, 255)
local pEsp = false
local bEsp = false
local tEsp = false
local nEsp = false

local function getNum(obj, fb)
    if typeof(obj) == "number" then return obj end
    if typeof(obj) == "Instance" and obj:IsA("ValueBase") then return obj.Value end
    return fb
end

-- ==========================================
-- TAB: MAIN (Lighting & UI)
-- ==========================================
local lgMain = Tabs.Main:AddLeftGroupbox('Lighting')

lgMain:AddToggle('FogToggle', {
    Text = 'Remove Fog',
    Default = false,
    Callback = function(v)
        fogOn = v
        if v then
            fogSaved.FogEnd = Lighting.FogEnd
            fogSaved.FogStart = Lighting.FogStart or 0
            fogSelfChange = true
            Lighting.FogEnd = 9999
            fogSelfChange = false
            fogConns[#fogConns + 1] = Lighting:GetPropertyChangedSignal("FogEnd"):Connect(function()
                if not fogSelfChange and fogOn then
                    fogSaved.FogEnd = Lighting.FogEnd
                    fogSelfChange = true
                    Lighting.FogEnd = 9999
                    fogSelfChange = false
                end
            end)
            fogConns[#fogConns + 1] = Lighting:GetPropertyChangedSignal("FogStart"):Connect(function()
                if not fogSelfChange and fogOn then
                    fogSaved.FogStart = Lighting.FogStart
                end
            end)
        else
            for _, conn in ipairs(fogConns) do conn:Disconnect() end
            fogConns = {}
            fogSelfChange = true
            if fogSaved.FogEnd then Lighting.FogEnd = fogSaved.FogEnd end
            if fogSaved.FogStart then Lighting.FogStart = fogSaved.FogStart end
            fogSelfChange = false
        end
    end
})

lgMain:AddToggle('ColorCorrectionToggle', {
    Text = 'Disable ColorCorrection',
    Default = false,
    Callback = function(v)
        ccOff = v
        local cc = Lighting:FindFirstChildOfClass('ColorCorrectionEffect')
        if cc then cc.Enabled = not v end
    end
})

lgMain:AddDivider()

lgMain:AddToggle('FireUIToggle', {
    Text = 'Hide Fire UI',
    Default = false,
    Callback = function(v)
        fireOff = v
        local g = lp.PlayerGui:FindFirstChild('Fire')
        if g then g.Enabled = not v end
    end
})

lgMain:AddToggle('CinematicUIToggle', {
    Text = 'Hide Cinematic UI',
    Default = false,
    Callback = function(v)
        cinOff = v
        local g = lp.PlayerGui:FindFirstChild('Cinematic')
        if g then g.Enabled = not v end
    end
})

-- ==========================================
-- TAB: GAME
-- ==========================================
local lgGame = Tabs.Game:AddLeftGroupbox('Game Actions')

lgGame:AddButton('Collect All Notebooks', function()
    local map = workspace:FindFirstChild("Map")
    if not map then return end
    local notebooksFolder = map:FindFirstChild("Notebooks")
    if not notebooksFolder then return end

    local char = lp.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    local origCFrame = root.CFrame
    local collected = 0

    for _, book in ipairs(notebooksFolder:GetChildren()) do
        if book:IsA("Model") or book:IsA("BasePart") then
            root.CFrame = book:GetPivot() + Vector3.new(0, 3, 0)
            task.wait(0.1)

            local cd = book:FindFirstChildWhichIsA("ClickDetector")
            if cd then
                if fireclickdetector then
                    pcall(function() fireclickdetector(cd) end)
                end
            end

            if firetouchinterest then
                pcall(function()
                    local part = book:IsA("BasePart") and book or book:FindFirstChildWhichIsA("BasePart")
                    if part then firetouchinterest(part, root, 0) end
                end)
            end

            task.wait(0.1)
            collected = collected + 1
        end
    end

    root.CFrame = origCFrame
    print("Collected " .. collected .. " notebooks, teleported back")
end)

lgGame:AddButton('Get All Exits', function()
    local map = workspace:FindFirstChild("Map")
    if not map then return end
    local exitsFolder = map:FindFirstChild("Exit")
    if not exitsFolder then return end

    local char = lp.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    local origCFrame = root.CFrame
    local touched = 0

    for _, exitObj in ipairs(exitsFolder:GetChildren()) do
        root.CFrame = exitObj:GetPivot() + Vector3.new(0, 3, 0)
        task.wait(0.1)

        if firetouchinterest then
            pcall(function()
                local part = exitObj:IsA("BasePart") and exitObj or exitObj:FindFirstChildWhichIsA("BasePart")
                if part then firetouchinterest(part, root, 0) end
            end)
        end

        local ti = exitObj:FindFirstChildWhichIsA("TouchInterest")
        if not ti then ti = exitObj:FindFirstChildWhichIsA("TouchInterest", true) end
        if ti then
            pcall(function() ti.Touched:Fire(root) end)
        end

        task.wait(0.1)
        touched = touched + 1
    end

    root.CFrame = origCFrame
    print("Triggered " .. touched .. " exits, teleported back")
end)

lgGame:AddDivider()

lgGame:AddButton('Delete All Blocks', function()
    local map = workspace:FindFirstChild("Map")
    if not map then return end

    local blocksFolder = map:FindFirstChild("BlockWall")
    if not blocksFolder then return end

    local children = {}
    for _, obj in ipairs(blocksFolder:GetChildren()) do
        table.insert(children, obj)
    end

    local count = 0
    for _, obj in ipairs(children) do
        if obj:IsA("BasePart") or obj:IsA("Model") then
            obj:Destroy()
            count = count + 1
        end
    end

    print("Deleted " .. count .. " blocks from BlockWall")
end)

lgGame:AddDivider()

-- See Baldi (Through Walls) — проверка раз в 1 секунду
local baldiCheckConnection = nil
local baldiSeeEnabled = false

lgGame:AddToggle('SeeBaldiToggle', {
    Text = 'See Baldi (Through Walls)',
    Default = false,
    Callback = function(v)
        baldiSeeEnabled = v

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

        if not v then
            local map = workspace:FindFirstChild("Map")
            if map then
                local npcFolder = map:FindFirstChild("Npc")
                if npcFolder then
                    local baldi = npcFolder:FindFirstChild("Baldi")
                    if baldi then
                        local root = baldi:FindFirstChild("HumanoidRootPart")
                        if root then
                            local billboard = root:FindFirstChildWhichIsA("BillboardGui")
                            if billboard then
                                billboard.AlwaysOnTop = false
                                billboard.Enabled = true
                            end
                        end
                    end
                end
            end
            print("Baldi visibility disabled")
            return
        end

        local lastCheck = 0
        baldiCheckConnection = game:GetService("RunService").Heartbeat:Connect(function()
            lastCheck = lastCheck + 1
            if lastCheck < 60 then return end
            lastCheck = 0

            if not baldiSeeEnabled then return end

            local map = workspace:FindFirstChild("Map")
            if not map then return end

            local npcFolder = map:FindFirstChild("Npc")
            if not npcFolder then return end

            local baldi = npcFolder:FindFirstChild("Baldi")
            if not baldi then return end

            local root = baldi:FindFirstChild("HumanoidRootPart")
            if not root then return end

            local billboard = root:FindFirstChildWhichIsA("BillboardGui")
            if billboard then
                billboard.AlwaysOnTop = true
                billboard.Enabled = true
            else
                for _, obj in ipairs(root:GetDescendants()) do
                    if obj:IsA("BillboardGui") then
                        obj.AlwaysOnTop = true
                        obj.Enabled = true
                        break
                    end
                end
            end
        end)

        print("Baldi visibility enabled. Auto-check running every 1 second.")
    end
})

-- Click Aura
lgGame:AddDivider()

local clickAuraOn = false
local notebookAuraDist = 15
local doorAuraDist = 15

lgGame:AddToggle('ClickAuraToggle', {
    Text = 'Click Aura',
    Default = false,
    Callback = function(v)
        clickAuraOn = v
    end
})

lgGame:AddSlider('NotebookAuraDist', {
    Text = 'Notebook Aura Distance',
    Default = 15,
    Min = 5, Max = 200, Rounding = 0,
    Callback = function(v)
        notebookAuraDist = v
    end
})

lgGame:AddSlider('DoorAuraDist', {
    Text = 'Door Aura Distance',
    Default = 15,
    Min = 5, Max = 200, Rounding = 0,
    Callback = function(v)
        doorAuraDist = v
    end
})

task.spawn(function()
    while true do
        task.wait(0.1)
        if not clickAuraOn then continue end

        local char = lp.Character
        if not char then continue end
        local root = char:FindFirstChild("HumanoidRootPart")
        if not root then continue end
        local rootPos = root.Position

        local map = workspace:FindFirstChild("Map")
        if not map then continue end

        local notebooksFolder = map:FindFirstChild("Notebooks")
        if notebooksFolder then
            for _, book in ipairs(notebooksFolder:GetChildren()) do
                local cd = book:FindFirstChildWhichIsA("ClickDetector")
                if cd then
                    local bookPos = book:GetPivot().Position
                    local dist = (rootPos - bookPos).Magnitude
                    if dist <= notebookAuraDist then
                        if fireclickdetector then
                            pcall(function() fireclickdetector(cd) end)
                        end
                    end
                end
            end
        end

        local doorFolder = map:FindFirstChild("Door")
        if doorFolder then
            for _, door in ipairs(doorFolder:GetChildren()) do
                local clickDoor = door:FindFirstChild("ClickDoor")
                if clickDoor then
                    local cd = clickDoor:FindFirstChildWhichIsA("ClickDetector")
                    if cd then
                        local doorPos = clickDoor:GetPivot().Position
                        local dist = (rootPos - doorPos).Magnitude
                        if dist <= doorAuraDist then
                            if fireclickdetector then
                                pcall(function() fireclickdetector(cd) end)
                            end
                        end
                    end
                end
            end
        end
    end
end)

-- ==========================================
-- TAB: SPEED
-- ==========================================
local sg = Tabs.Speed:AddLeftGroupbox('Speed Settings')
local cWalk = getNum(lp.WalkSpeed, 16)
local cRun = getNum(lp.RunSpeed, 24)
walkSpd = cWalk
runSpd = cRun

sg:AddSlider('WalkSpeedSlider', {
    Text = 'WalkSpeed',
    Default = cWalk,
    Min = 0, Max = 500, Rounding = 0,
    Callback = function(v)
        walkSpd = v
        local w = lp.WalkSpeed
        if typeof(w) == "Instance" and w:IsA("ValueBase") then w.Value = v else lp.WalkSpeed = v end
    end
})

sg:AddSlider('RunSpeedSlider', {
    Text = 'RunSpeed',
    Default = cRun,
    Min = 0, Max = 500, Rounding = 0,
    Callback = function(v)
        runSpd = v
        local r = lp.RunSpeed
        if typeof(r) == "Instance" and r:IsA("ValueBase") then r.Value = v else lp.RunSpeed = v end
    end
})

sg:AddDivider()

local noAccel = false
local noAccelConn
sg:AddToggle('RemoveAcceleration', {
    Text = 'Remove Acceleration',
    Default = false,
    Callback = function(v)
        noAccel = v
        if v then
            noAccelConn = game:GetService('RunService').Heartbeat:Connect(function()
                local root, hum = lp.Character and lp.Character:FindFirstChild('HumanoidRootPart'), lp.Character and lp.Character:FindFirstChildOfClass('Humanoid')
                if not root or not hum or hum.Health <= 0 then return end
                local spd = walkSpd
                local dir = hum.MoveDirection
                if dir.Magnitude > 0 then
                    root.AssemblyLinearVelocity = Vector3.new(dir.X * spd, root.AssemblyLinearVelocity.Y, dir.Z * spd)
                else
                    root.AssemblyLinearVelocity = Vector3.new(0, root.AssemblyLinearVelocity.Y, 0)
                end
            end)
        else
            if noAccelConn then noAccelConn:Disconnect() noAccelConn = nil end
        end
    end
})

-- ==========================================
-- TAB: ESP
-- ==========================================
local function refreshPlayer(p)
    if not pEsp or p == lp then return end
    local c = p.Character
    if not c or ESP.ElementsEnabled[c] == true then return end
    if c:FindFirstChild('HumanoidRootPart') then
        ESP:AddESP({Object = c, Text = p.DisplayName or p.Name, Color = pColor})
    end
end

local function refreshAllPlayers()
    if not pEsp then return end
    for _, p in ipairs(game:GetService('Players'):GetPlayers()) do
        if p ~= lp then refreshPlayer(p) end
    end
end

local function refreshBaldi()
    if not bEsp then return end
    local b = workspace:FindFirstChild("Map")
    if b then b = b:FindFirstChild("Npc") end
    if b then b = b:FindFirstChild("Baldi") end
    if b and ESP.ElementsEnabled[b] ~= true then
        ESP:AddESP({Object = b, Text = 'Baldi', Color = bColor})
    end
end

local function refreshTiles()
    if not tEsp then return end
    local m = workspace:FindFirstChild("Map")
    if not m then return end
    local f = m:FindFirstChild("ProjectTile")
    if not f then return end
    for _, item in ipairs(f:GetChildren()) do
        if not ESP.ElementsEnabled[item] and (item:IsA("BasePart") or item:IsA("Model")) then
            ESP:AddESP({Object = item, Text = item.Name, Color = tColor})
        end
    end
end

local function refreshNotebooks()
    if not nEsp then return end
    local map = workspace:FindFirstChild("Map")
    if not map then return end
    local notebooksFolder = map:FindFirstChild("Notebooks")
    if not notebooksFolder then return end
    for _, book in ipairs(notebooksFolder:GetChildren()) do
        if (book:IsA("Model") or book:IsA("BasePart")) and not ESP.ElementsEnabled[book] then
            local bbg = book:FindFirstChildWhichIsA("BillboardGui")
            if bbg and not bbg.Enabled then continue end
            ESP:AddESP({Object = book, Text = "Book", Color = nColor, IsNotebook = true})
        end
    end
end

local eg = Tabs.ESP:AddLeftGroupbox('ESP Settings')

eg:AddToggle('PlayerESPToggle', {
    Text = 'Player ESP',
    Default = false,
    Callback = function(v)
        pEsp = v
        if v then
            for _, p in ipairs(game:GetService('Players'):GetPlayers()) do
                if p ~= lp and p.Character and p.Character:FindFirstChild('HumanoidRootPart') then
                    ESP:AddESP({Object = p.Character, Text = p.DisplayName or p.Name, Color = pColor})
                end
            end
        else
            for _, p in ipairs(game:GetService('Players'):GetPlayers()) do
                if p ~= lp and p.Character then ESP:RemoveESP(p.Character) end
            end
        end
    end
})

eg:AddToggle('NpcESPToggle', {
    Text = 'Baldi ESP',
    Default = false,
    Callback = function(v)
        bEsp = v
        local b = workspace:FindFirstChild("Map")
        if b then b = b:FindFirstChild("Npc"); if b then b = b:FindFirstChild("Baldi") end end
        if v and b then ESP:AddESP({Object = b, Text = 'Baldi', Color = bColor})
        elseif not v and b then ESP:RemoveESP(b) end
    end
})

eg:AddToggle('ProjectTileESPToggle', {
    Text = 'ProjectTile ESP',
    Default = false,
    Callback = function(v)
        tEsp = v
        local m = workspace:FindFirstChild("Map")
        if not m then return end
        local f = m:FindFirstChild("ProjectTile")
        if not f then return end
        if v then
            for _, item in ipairs(f:GetChildren()) do
                if item:IsA("BasePart") or item:IsA("Model") then
                    ESP:AddESP({Object = item, Text = item.Name, Color = tColor})
                end
            end
        else
            for _, item in ipairs(f:GetChildren()) do ESP:RemoveESP(item) end
        end
    end
})

eg:AddToggle('NotebookESPToggle', {
    Text = 'Notebook ESP',
    Default = false,
    Callback = function(v)
        nEsp = v
        if v then
            refreshNotebooks()
        else
            local map = workspace:FindFirstChild("Map")
            if map then
                local f = map:FindFirstChild("Notebooks")
                if f then
                    for _, item in ipairs(f:GetChildren()) do ESP:RemoveESP(item) end
                end
            end
        end
    end
})

eg:AddDivider()

eg:AddLabel('Player Color'):AddColorPicker('PlayerColor', {
    Default = pColor,
    Title = 'Player ESP Color',
    Callback = function(c)
        pColor = c
        for _, p in ipairs(game:GetService('Players'):GetPlayers()) do
            if p ~= lp and p.Character then ESP:UpdateColor(p.Character, c) end
        end
    end
})

eg:AddLabel('Baldi Color'):AddColorPicker('NpcColor', {
    Default = bColor,
    Title = 'Baldi ESP Color',
    Callback = function(c)
        bColor = c
        local b = workspace:FindFirstChild("Map")
        if b then b = b:FindFirstChild("Npc"); if b then b = b:FindFirstChild("Baldi") end end
        if b then ESP:UpdateColor(b, c) end
    end
})

eg:AddLabel('ProjectTile Color'):AddColorPicker('ProjectTileColor', {
    Default = tColor,
    Title = 'ProjectTile ESP Color',
    Callback = function(c)
        tColor = c
        local m = workspace:FindFirstChild("Map")
        if not m then return end
        local f = m:FindFirstChild("ProjectTile")
        if not f then return end
        for _, item in ipairs(f:GetChildren()) do ESP:UpdateColor(item, c) end
    end
})

eg:AddLabel('Notebook Color'):AddColorPicker('NotebookColor', {
    Default = nColor,
    Title = 'Notebook ESP Color',
    Callback = function(c)
        nColor = c
        local map = workspace:FindFirstChild("Map")
        if not map then return end
        local f = map:FindFirstChild("Notebooks")
        if not f then return end
        for _, item in ipairs(f:GetChildren()) do ESP:UpdateColor(item, c) end
    end
})

local eo = Tabs.ESP:AddRightGroupbox('ESP Options')

eo:AddToggle('ShowDistance', {
    Text = 'Show Distance',
    Default = false,
    Callback = function(v) ESP.ShowDistance = v end
})

eo:AddToggle('Tracers', {
    Text = 'Tracers',
    Default = false,
    Callback = function(v) ESP.Tracers = v end
})

eo:AddDropdown('TracerOrigin', {
    Values = {'Bottom', 'Center', 'Top', 'Mouse'},
    Default = 1,
    Text = 'Tracer Origin',
    Callback = function(v) ESP.TracerOrigin = v end
})

eo:AddSlider('TracerSize', {
    Text = 'Tracer Thickness',
    Default = 1, Min = 1, Max = 5, Rounding = 0,
    Callback = function(v) ESP.TracerSize = v end
})

eo:AddToggle('Rainbow', {
    Text = 'Rainbow Color',
    Default = false,
    Callback = function(v) ESP.Rainbow = v end
})

eo:AddToggle('Arrows', {
    Text = 'Off-screen Arrows',
    Default = false,
    Callback = function(v) ESP.Arrows = v end
})

eo:AddSlider('TextSize', {
    Text = 'Text Size',
    Default = 18, Min = 8, Max = 40, Rounding = 0,
    Callback = function(v) ESP.TextSize = v end
})

eo:AddSlider('FillTransparency', {
    Text = 'Fill Transparency',
    Default = 0.75, Min = 0, Max = 1, Rounding = 2,
    Callback = function(v) ESP.FillTransparency = v end
})

-- ==========================================
-- ENFORCE LOOP
-- ==========================================
task.spawn(function()
    while true do
        task.wait(1)
        local cc = Lighting:FindFirstChildOfClass('ColorCorrectionEffect')
        if cc then
            if ccOff and cc.Enabled ~= false then cc.Enabled = false
            elseif not ccOff and cc.Enabled ~= true then cc.Enabled = true end
        end

        local fg = lp.PlayerGui:FindFirstChild('Fire')
        if fg then
            if fireOff and fg.Enabled ~= false then fg.Enabled = false
            elseif not fireOff and fg.Enabled ~= true then fg.Enabled = true end
        end

        local cg = lp.PlayerGui:FindFirstChild('Cinematic')
        if cg then
            if cinOff and cg.Enabled ~= false then cg.Enabled = false
            elseif not cinOff and cg.Enabled ~= true then cg.Enabled = true end
        end

        local wRaw = lp.WalkSpeed
        local wCur = getNum(wRaw, 16)
        if wCur ~= walkSpd then
            if typeof(wRaw) == "Instance" and wRaw:IsA("ValueBase") then wRaw.Value = walkSpd
            else pcall(function() lp.WalkSpeed = walkSpd end) end
        end

        local rRaw = lp.RunSpeed
        local rCur = getNum(rRaw, 24)
        if rCur ~= runSpd then
            if typeof(rRaw) == "Instance" and rRaw:IsA("ValueBase") then rRaw.Value = runSpd
            else pcall(function() lp.RunSpeed = runSpd end) end
        end
    end
end)

-- ==========================================
-- ESP REFRESH LOOP
-- ==========================================
local plrs = game:GetService('Players')
task.spawn(function()
    while true do
        task.wait(5)
        if pEsp then refreshAllPlayers() end
        if bEsp then refreshBaldi() end
        if tEsp then refreshTiles() end
        if nEsp then refreshNotebooks() end
    end
end)

-- ==========================================
-- PLAYER EVENTS
-- ==========================================
plrs.PlayerAdded:Connect(function(p)
    p.CharacterAdded:Connect(function(c)
        task.wait(0.5)
        if pEsp and c:FindFirstChild('HumanoidRootPart') then
            ESP:AddESP({Object = c, Text = p.DisplayName or p.Name, Color = pColor})
        end
    end)
end)

plrs.PlayerRemoving:Connect(function(p)
    if not pEsp then return end
    if p.Character then ESP:RemoveESP(p.Character) end
end)

for _, p in ipairs(plrs:GetPlayers()) do
    if p ~= lp then
        p.CharacterAdded:Connect(function(c)
            task.wait(0.5)
            if pEsp and c:FindFirstChild('HumanoidRootPart') then
                ESP:AddESP({Object = c, Text = p.DisplayName or p.Name, Color = pColor})
            end
        end)
    end
end

-- ==========================================
-- CHILDADDED EVENTS
-- ==========================================
task.spawn(function()
    local m = workspace:FindFirstChild("Map")
    if not m then
        local conn = workspace.ChildAdded:Connect(function(child)
            if child.Name == "Map" then
                conn:Disconnect()
                local f = child:FindFirstChild("ProjectTile")
                if f then
                    f.ChildAdded:Connect(function(item)
                        if tEsp and (item:IsA("BasePart") or item:IsA("Model")) then
                            task.wait(0.1)
                            ESP:AddESP({Object = item, Text = item.Name, Color = tColor})
                        end
                    end)
                end
            end
        end)
    else
        local f = m:FindFirstChild("ProjectTile")
        if f then
            f.ChildAdded:Connect(function(item)
                if tEsp and (item:IsA("BasePart") or item:IsA("Model")) then
                    task.wait(0.1)
                    ESP:AddESP({Object = item, Text = item.Name, Color = tColor})
                end
            end)
        end
    end
end)

task.spawn(function()
    local m = workspace:FindFirstChild("Map")
    if not m then
        local conn = workspace.ChildAdded:Connect(function(child)
            if child.Name == "Map" then
                conn:Disconnect()
                local f = child:FindFirstChild("Notebooks")
                if f then
                    f.ChildAdded:Connect(function(item)
                        if nEsp and (item:IsA("BasePart") or item:IsA("Model")) then
                            task.wait(0.1)
                            ESP:AddESP({Object = item, Text = "Book", Color = nColor, IsNotebook = true})
                        end
                    end)
                end
            end
        end)
    else
        local f = m:FindFirstChild("Notebooks")
        if f then
            f.ChildAdded:Connect(function(item)
                if nEsp and (item:IsA("BasePart") or item:IsA("Model")) then
                    task.wait(0.1)
                    ESP:AddESP({Object = item, Text = "Book", Color = nColor, IsNotebook = true})
                end
            end)
        end
    end
end)

-- ==========================================
-- TAB: UI SETTINGS
-- ==========================================
local mg = Tabs['UI Settings']:AddLeftGroupbox('Menu')
mg:AddButton('Unload', function() ESP:Unload(); Lib:Unload() end)
mg:AddLabel('Menu bind'):AddKeyPicker('MenuKeybind', {Default = 'End', NoUI = true, Text = 'Menu keybind'})
Lib.ToggleKeybind = Options.MenuKeybind

Theme:SetLibrary(Lib)
Save:SetLibrary(Lib)
Save:IgnoreThemeSettings()
Save:SetIgnoreIndexes({'MenuKeybind'})
Theme:SetFolder('MyScriptHub')
Save:SetFolder('MyScriptHub/lighting-esp-speed')
Save:BuildConfigSection(Tabs['UI Settings'])
Theme:ApplyToTab(Tabs['UI Settings'])
Save:LoadAutoloadConfig()