Notoriety script Remastered Keyless

--made by me feel free to edit

-- Garfield UI
local Library = loadstring(game:HttpGet("https://raw.githubusercontent.com/xHeptc/Kavo-UI-Library/main/source.lua"))()
local Window = Library.CreateLib("Garfield", "DarkTheme")

-- Tabs
local MainTab = Window:NewTab("Main")
local MainSection = MainTab:NewSection("Main")

local MiscTab = Window:NewTab("Misc")
local MiscSection = MiscTab:NewSection("Misc")

local NotorietyTab = Window:NewTab("Notoriety")
local ESPSection = NotorietyTab:NewSection("ESPs")

-- Fling Toggles
local flingPolice = false
local flingCitizens = false
local FLING_DIST = 20000   -- horizontal distance
local FLING_HEIGHT = 5000  -- vertical offset

------------------------------------------------------------------------
-- Fling Police  (guards that DO NOT hold any map-key are flung)
------------------------------------------------------------------------
MainSection:NewToggle("Fling Police", "Instant fling for Police (skips keycard & map-key holders)", function(state)
    flingPolice = state
    if flingPolice then
        task.spawn(function()
            ----------------------------------------------------------------
            -- Build a fast Set of all key-holding guards
            ----------------------------------------------------------------
            local function getGuardsWithKeys()
                local keyHolders = {}          -- [guard-model] = true
                -- 1. Map keys
                local map = workspace:FindFirstChild("Map")
                if map then
                    for _, f in ipairs(map:GetDescendants()) do
                        if f.Name == "Keys" and f:IsA("Folder") then
                            for _, k in ipairs(f:GetDescendants()) do
                                if k:IsA("BasePart") then
                                    -- Key part is usually parented under the guard
                                    local g = k:FindFirstAncestorOfClass("Model")
                                    if g and g.Parent == workspace.Police then
                                        keyHolders[g] = true
                                    end
                                end
                            end
                        end
                    end
                end
                -- 2. Keycards (your old check)
                for _, g in ipairs(workspace.Police:GetChildren()) do
                    local lanyard = g:FindFirstChild("Lanyard")
                    if lanyard and lanyard:FindFirstChild("PickpocketKeycard") then
                        keyHolders[g] = true
                    end
                end
                return keyHolders
            end
            ----------------------------------------------------------------

            while flingPolice do
                local player = game.Players.LocalPlayer
                local char = player and player.Character
                if char and char:FindFirstChild("HumanoidRootPart") then
                    local root = char.HumanoidRootPart
                    local skip = getGuardsWithKeys()   -- refresh every cycle

                    for _, guard in ipairs(workspace.Police:GetChildren()) do
                        if guard:IsA("Model") and guard:FindFirstChild("HumanoidRootPart") then
                            if not skip[guard] then              -- <-- NEW: no key → fair game
                                local hrp = guard.HumanoidRootPart
                                local dir
                                local ok, err = pcall(function()
                                    dir = (hrp.Position - root.Position).Unit
                                end)
                                if not ok or not dir or dir.Magnitude == 0 then
                                    dir = Vector3.new(1,0,0)
                                end
                              hrp.CFrame = CFrame.new(root.Position + Vector3.new(999999, -999999, 0))
                            end
                        end
                    end
                end
                task.wait()
            end
        end)
    end
end)
------------------------------------------------------------------------


-- Citizens Fling Toggle
MainSection:NewToggle("Fling Citizens", "Instant fling for Citizens", function(state)
    flingCitizens = state
    if flingCitizens then
        task.spawn(function()
            while flingCitizens do
                local player = game.Players.LocalPlayer
                local char = player and player.Character
                if char and char:FindFirstChild("HumanoidRootPart") then
                    local root = char.HumanoidRootPart
                    for _, citizen in pairs(workspace:WaitForChild("Citizens"):GetChildren()) do
                        if citizen:IsA("Model") and citizen:FindFirstChild("HumanoidRootPart") then
                            local hrp = citizen.HumanoidRootPart
                            local success, dir = pcall(function()
                                return (hrp.Position - root.Position).Unit
                            end)
                            if not success or not dir or dir.Magnitude == 0 then
                                dir = Vector3.new(1,0,0)
                            end
                          hrp.CFrame = CFrame.new(root.Position + Vector3.new(999999, -999999, 0))
                        end
                    end
                end
                task.wait()
            end
        end)
    end
end)

-- Stamina Buttons
MainSection:NewButton("Stamina Increase", "Increase your stamina", function()
    local plr = game.Players.LocalPlayer.Name
    local v = game:GetService("Workspace").Criminals[plr]
    v.MaxStamina.Value = 10000
end)

MainSection:NewButton("Fill Stamina", "Fills Stamina", function()
    local plr = game.Players.LocalPlayer.Name
    local v = game:GetService("Workspace").Criminals[plr]
    v.Stamina.Value = 10000
end)

-- ESP Variables
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local itemEspParts = {}
local guardEspParts = {}
local cameraEspParts = {}

local function clearESP(list)
    for _, objects in pairs(list) do
        for _, obj in pairs(objects) do
            if obj and obj.Parent then
                obj:Destroy()
            end
        end
    end
    table.clear(list)
end

local function createESP(part, labelText, color)
    local elements = {}

    if labelText then
        local billboard = Instance.new("BillboardGui")
        billboard.Name = "ESP"
        billboard.Adornee = part
        billboard.Size = UDim2.new(0, 60, 0, 20)
        billboard.StudsOffset = Vector3.new(0, 3, 0)
        billboard.AlwaysOnTop = true

        local label = Instance.new("TextLabel", billboard)
        label.Size = UDim2.new(1, 0, 1, 0)
        label.BackgroundTransparency = 1
        label.TextColor3 = color
        label.Text = labelText
        label.TextScaled = true
        label.Font = Enum.Font.SourceSansBold

        billboard.Parent = part
        table.insert(elements, billboard)
    end

    local highlight = Instance.new("Highlight")
    highlight.Name = "ESP_Highlight"
    highlight.Adornee = part:IsA("Model") and part or part:FindFirstAncestorOfClass("Model")
    highlight.FillColor = color
    highlight.OutlineColor = color
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.Parent = part
    table.insert(elements, highlight)

    return elements
end

-- Guard ESP
ESPSection:NewToggle("Guard ESP", false, function(state)
    clearESP(guardEspParts)
    if state then
        for _, guard in pairs(Workspace:WaitForChild("Police"):GetChildren()) do
            if guard:IsA("Model") and guard:FindFirstChild("HumanoidRootPart") then
                local label = "Guard"
                local typeVal = guard:FindFirstChild("Type")
                if typeVal and typeVal:IsA("StringValue") then
                    label = typeVal.Value
                end
                local esp = createESP(guard, label, Color3.fromRGB(0, 255, 0))
                table.insert(guardEspParts, esp)
            end
        end
    end
end)

-- Camera ESP
ESPSection:NewToggle("Camera ESP", false, function(state)
    clearESP(cameraEspParts)
    if state then
        for _, cam in pairs(Workspace:WaitForChild("Cameras"):GetChildren()) do
            if cam:IsA("Model") then
                local part = cam.PrimaryPart or cam:FindFirstChild("Handle") or cam:FindFirstChildWhichIsA("BasePart")
                if part then
                    local esp = createESP(cam, "Camera", Color3.fromRGB(255, 255, 0))
                    table.insert(cameraEspParts, esp)
                end
            end
        end
    end
end)

-- Item ESP  (Lootables only, blue label)
ESPSection:NewToggle("Item ESP", "Shows lootable items", function(state)
    clearESP(itemEspParts)

    if not state then return end

    local lootablesFolder = Workspace:WaitForChild("Lootables")
    for _, model in pairs(lootablesFolder:GetChildren()) do
        if model:IsA("Model") then
            ------------------------------------------------------------------
            -- pick the model we actually want to label
            ------------------------------------------------------------------
            local targetModel = nil
            local childrenModels = {}

            for _, ch in pairs(model:GetChildren()) do
                if ch:IsA("Model") then table.insert(childrenModels, ch) end
            end

            if #childrenModels == 0 then
                targetModel = model
            elseif #childrenModels == 1 then
                targetModel = (childrenModels[1].Name == "Model") and model or childrenModels[1]
            else
                for _, m in pairs(childrenModels) do
                    if m.Name ~= "Model" then targetModel = m break end
                end
                if not targetModel then targetModel = model end
            end
            ------------------------------------------------------------------

            local part = targetModel.PrimaryPart or targetModel:FindFirstChildWhichIsA("BasePart")
            if part then
                local bill = Instance.new("BillboardGui")
                bill.Name  = "ESP_Item"
                bill.Adornee = part
                bill.Size    = UDim2.new(0, 120, 0, 30)
                bill.StudsOffset = Vector3.new(0, 2, 0)
                bill.AlwaysOnTop = true
                bill.Parent  = part

                local lbl = Instance.new("TextLabel")
                lbl.Size = UDim2.new(1, 0, 1, 0)
                lbl.BackgroundTransparency = 1
                lbl.TextColor3 = Color3.fromRGB(0, 170, 255)
                lbl.TextStrokeTransparency = 0
                lbl.Font = Enum.Font.Code
                lbl.TextSize = 16
                lbl.Text = targetModel.Name
                lbl.Parent = bill

                table.insert(itemEspParts, {bill})
            end
        end
    end
end)

-- Keycards ESP (orange, independent list)
local keycardEspParts = {}

ESPSection:NewToggle("Keycards ESP", false, function(state)
    clearESP(keycardEspParts)
    if state then
        task.spawn(function()
            while state do
                clearESP(keycardEspParts)
                for _, guard in pairs(workspace:WaitForChild("Police"):GetChildren()) do
                    if guard:IsA("Model") then
                        local lanyard = guard:FindFirstChild("Lanyard")
                        if lanyard then
                            local keycard = lanyard:FindFirstChild("PickpocketKeycard")
                            if keycard then
                                local model = keycard:FindFirstChild("Model")
                                if model then
                                    local part = model.PrimaryPart or model:FindFirstChildWhichIsA("BasePart")
                                    if part then
                                        local esp = createESP(model, "Keycard", Color3.fromRGB(255, 128, 0)) -- orange
                                        table.insert(keycardEspParts, esp)
                                    end
                                end
                            end
                        end
                    end
                end
                task.wait(2) -- refresh every 2 seconds
            end
        end)
    else
        clearESP(keycardEspParts)
    end
end)

--- Special Key ESP (Guard 14 + All Map Keys)
ESPSection:NewToggle("Special Key ESP", false, function(state)
    -- cleanup old
    if _G.specialKeyESP then
        for _, v in pairs(_G.specialKeyESP) do
            if v and v.Parent then v:Destroy() end
        end
        _G.specialKeyESP = nil
    end

    if state then
        _G.specialKeyESP = {}
        local yellow = Color3.fromRGB(255, 255, 0)

        local function makeESP(part, name)
            if not part then return end
            local billboard = Instance.new("BillboardGui")
            billboard.Name = "ESP"
            billboard.Adornee = part
            billboard.Size = UDim2.new(0, 80, 0, 20)
            billboard.StudsOffset = Vector3.new(0, 2, 0)
            billboard.AlwaysOnTop = true

            local label = Instance.new("TextLabel", billboard)
            label.Size = UDim2.new(1, 0, 1, 0)
            label.BackgroundTransparency = 1
            label.TextColor3 = yellow
            label.Text = name
            label.TextScaled = true
            label.Font = Enum.Font.SourceSansBold
            billboard.Parent = part
            table.insert(_G.specialKeyESP, billboard)

            local hl = Instance.new("Highlight")
            hl.Name = name .. "_Highlight"
            hl.Adornee = part
            hl.FillColor = yellow
            hl.OutlineColor = Color3.fromRGB(255, 180, 0)
            hl.FillTransparency = 0.35
            hl.OutlineTransparency = 0
            hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
            hl.Parent = part
            table.insert(_G.specialKeyESP, hl)
        end

        -- Guard 14 KeyAccessory.Handle
        local policeFolder = workspace:FindFirstChild("Police")
        if policeFolder then
            local guard = policeFolder:GetChildren()[14]
            if guard then
                local keyAcc = guard:FindFirstChild("KeyAccessory")
                local handle = keyAcc and keyAcc:FindFirstChild("Handle")
                makeESP(handle, "Guard Key")
            end
        end

        -- All Map Keys (any "Keys" folder under workspace.Map)
        local map = workspace:FindFirstChild("Map")
        if map then
            for _, subFolder in pairs(map:GetChildren()) do
                if subFolder:IsA("Folder") and subFolder.Name == "Keys" then
                    for _, key in pairs(subFolder:GetChildren()) do
                        if key:IsA("Model") or key:IsA("Part") then
                            local handle = key:FindFirstChild("Handle") or key
                            makeESP(handle, "Map Key")
                        end
                    end
                end
            end
        end
    end
end)



-------------------------------------------------------------------------
-- Garfield Flight (original full noclip + hitbox restore)
------------------------------------------------------------------------
MiscSection:NewButton("🐱 Load Garfield Flight", "Click to load flight + get notified", function()

    -- 5-second banner
    local gui = Instance.new("ScreenGui")
    gui.Name = "GarfieldNotify"
    gui.Parent = game:GetService("CoreGui")

    local label = Instance.new("TextLabel")
    label.Size = UDim2.new(0, 300, 0, 50)
    label.Position = UDim2.new(0.5, -150, 0, 50)
    label.BackgroundTransparency = 1
    label.Text = "Press Y to use"
    label.TextColor3 = Color3.fromRGB(255, 255, 255)
    label.TextScaled = true
    label.Font = Enum.Font.GothamBold
    label.Parent = gui

    game:GetService("TweenService"):Create(
        label,
        TweenInfo.new(1, Enum.EasingStyle.Quad, Enum.EasingDirection.Out, 0, false, 4),
        {TextTransparency = 1}
    ):Play()

    task.spawn(function() task.wait(5) if gui then gui:Destroy() end end)

    -- ======  ORIGINAL FULL-CLIP STYLE  ======
    local Players = game:GetService("Players")
    local UserInputService = game:GetService("UserInputService")
    local RunService = game:GetService("RunService")
    local player = Players.LocalPlayer

    local character = player.Character or player.CharacterAdded:Wait()
    local HRP = character:WaitForChild("HumanoidRootPart")

    local flying = false
    local BodyGyro, BodyVelocity
    local speed = 75

    local noclipConn
    local oldCollide = {}          -- [part] = original CanCollide

    local function startFlying()
        if flying then return end
        flying = true

        -- store & ghost every BasePart
        for _, part in pairs(character:GetDescendants()) do
            if part:IsA("BasePart") then
                oldCollide[part] = part.CanCollide
                part.CanCollide = false
            end
        end

        -- continuous noclip (original style)
        noclipConn = RunService.Stepped:Connect(function()
            for _, part in pairs(character:GetDescendants()) do
                if part:IsA("BasePart") then
                    part.CanCollide = false
                end
            end
        end)

        BodyGyro = Instance.new("BodyGyro")
        BodyGyro.P = 9e4
        BodyGyro.MaxTorque = Vector3.new(9e4, 9e4, 9e4)
        BodyGyro.CFrame = HRP.CFrame
        BodyGyro.Parent = HRP

        BodyVelocity = Instance.new("BodyVelocity")
        BodyVelocity.MaxForce = Vector3.new(9e9, 9e9, 9e9)
        BodyVelocity.Velocity = Vector3.zero
        BodyVelocity.Parent = HRP

        RunService:BindToRenderStep("FlyStep", Enum.RenderPriority.Character.Value, function()
            local cam = workspace.CurrentCamera
            local look = cam.CFrame.LookVector
            local forward = Vector3.new(look.X, 0, look.Z).Unit
            local right = cam.CFrame.RightVector
            local up = Vector3.new(0, 1, 0)

            local move = Vector3.zero
            if UserInputService:IsKeyDown(Enum.KeyCode.W) then move += forward end
            if UserInputService:IsKeyDown(Enum.KeyCode.S) then move -= forward end
            if UserInputService:IsKeyDown(Enum.KeyCode.A) then move -= right end
            if UserInputService:IsKeyDown(Enum.KeyCode.D) then move += right end
            if UserInputService:IsKeyDown(Enum.KeyCode.Space) then move += up end
            if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then move -= up end

            if move.Magnitude > 0 then move = move.Unit * speed else move = Vector3.zero end
            BodyGyro.CFrame = CFrame.new(Vector3.zero, Vector3.new(look.X, 0, look.Z))
            BodyVelocity.Velocity = move
        end)
    end

    local function stopFlying()
        if not flying then return end
        flying = false

        -- kill fliers
        if BodyGyro then BodyGyro:Destroy() end
        if BodyVelocity then BodyVelocity:Destroy() end
        RunService:UnbindFromRenderStep("FlyStep")

        -- stop noclip loop
        if noclipConn then noclipConn:Disconnect() end

        -- restore exact original CanCollide values
        for part, wasColliding in pairs(oldCollide) do
            if part and part.Parent then part.CanCollide = wasColliding end
        end
        table.clear(oldCollide)
    end

    UserInputService.InputBegan:Connect(function(input, gP)
        if gP then return end
        if input.KeyCode == Enum.KeyCode.Y then
            if flying then stopFlying() else startFlying() end
        end
    end)
    -- ======  END  ======
end)