[OPENSEC DEMON] After 3 AM FreeBug Menu

Script source Luau

Copy Script

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

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6ab82dd665fb8f6406520730"))()
	end)
end)
--[[rscripts:analytics:end]]

-- ==============================================================================
--              AFTER 3 AM FREEBUG MENU V1
--              Author: SKIDGOD | Infinite Ammo Implementation by R-77
--              UI Framework: Obsidian
-- ==============================================================================

local repo = "https://raw.githubusercontent.com/deividcomsono/Obsidian/main/"
local Library = loadstring(game:HttpGet(repo .. "Library.lua"))()
local ThemeManager = loadstring(game:HttpGet(repo .. "addons/ThemeManager.lua"))()
local SaveManager = loadstring(game:HttpGet(repo .. "addons/SaveManager.lua"))()

local Options = Library.Options
local Toggles = Library.Toggles

-- Service References
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")
local Workspace = workspace
local LocalPlayer = Players.LocalPlayer
local Camera = Workspace.CurrentCamera

--------------------------------------------------------------------------------
-- Utility Functions & UI Container
--------------------------------------------------------------------------------
local function safeDestroy(instance)
    pcall(function()
        if instance and instance.Parent then
            instance:Destroy()
        end
    end)
end

local function findRootPart(model)
    if not model then return nil end
    return model:FindFirstChild("HumanoidRootPart")
        or model:FindFirstChild("Head")
        or model:FindFirstChild("Handle")
        or model:FindFirstChildWhichIsA("BasePart")
end

-- Dedicated Arrow UI Container
local ArrowGui = Instance.new("ScreenGui")
ArrowGui.Name = "SKIDGOD_ArrowTrackerGui"
ArrowGui.ResetOnSpawn = false
ArrowGui.Parent = LocalPlayer:WaitForChild("PlayerGui")

Library:OnUnload(function()
    safeDestroy(ArrowGui)
end)

--------------------------------------------------------------------------------
-- Main Window & Tabs Construction
--------------------------------------------------------------------------------
local Window = Library:CreateWindow({
	Title = "AFTER 3 AM FREEBUG MENU V1",
	Footer = "By SKIDGOD | Infinite Ammo by R-77",
	NotifySide = "Right",
	ShowCustomCursor = true,
})

local Tabs = {
	ESP      = Window:AddTab("ESP", "eye"),
	Arrow    = Window:AddTab("Arrow Tracker", "navigation"),
	Combat   = Window:AddTab("Combat & OP", "crosshair"),
	Ragdoll  = Window:AddTab("Ragdoll Physics", "shield"),
	Movement = Window:AddTab("Movement & TP", "map-pin"),
	["UI Settings"] = Window:AddTab("UI Settings", "settings"),
}

--------------------------------------------------------------------------------
-- 1. ESP System (Full Color, Transparency, Outline & Distance Customization)
--------------------------------------------------------------------------------

-- ESP Caches
local shadowManEspCache = {}
local playerEspCache = {}
local itemEspCache = {}

local function clearMapCache(cacheTable)
    for key, data in pairs(cacheTable) do
        safeDestroy(data.HL)
        safeDestroy(data.BB)
    end
    table.clear(cacheTable)
end

-- === ShadowMan ESP Groupbox ===
local ShadowManEspGroup = Tabs.ESP:AddGroupbox({
	Side = "Left",
	Name = "ShadowMan Monster ESP",
	IconName = "skull"
})

ShadowManEspGroup:AddToggle("ShadowManESP", {
	Text = "Enable ShadowMan ESP",
	Default = false,
}):AddKeyPicker("ShadowManESPBind", { Default = "None", SyncToggleState = true, Text = "ShadowMan ESP Keybind" })
  :AddColorPicker("ShadowManFillColor", { Default = Color3.fromRGB(255, 0, 0), Title = "Fill Color" })
  :AddColorPicker("ShadowManOutlineColor", { Default = Color3.fromRGB(255, 255, 255), Title = "Outline Color" })

ShadowManEspGroup:AddSlider("ShadowManFillTrans", {
	Text = "Fill Transparency",
	Default = 0.25,
	Min = 0,
	Max = 1,
	Rounding = 2,
})

ShadowManEspGroup:AddSlider("ShadowManOutlineTrans", {
	Text = "Outline Transparency",
	Default = 0,
	Min = 0,
	Max = 1,
	Rounding = 2,
})

-- === Player ESP Groupbox ===
local PlayerEspGroup = Tabs.ESP:AddGroupbox({
	Side = "Right",
	Name = "Player ESP",
	IconName = "user"
})

PlayerEspGroup:AddToggle("PlayersESP", {
	Text = "Enable Player ESP",
	Default = false,
}):AddKeyPicker("PlayersESPBind", { Default = "None", SyncToggleState = true, Text = "Player ESP Keybind" })
  :AddColorPicker("PlayerFillColor", { Default = Color3.fromRGB(0, 255, 255), Title = "Fill Color" })
  :AddColorPicker("PlayerOutlineColor", { Default = Color3.fromRGB(255, 255, 255), Title = "Outline Color" })

PlayerEspGroup:AddSlider("PlayerFillTrans", {
	Text = "Fill Transparency",
	Default = 0.3,
	Min = 0,
	Max = 1,
	Rounding = 2,
})

PlayerEspGroup:AddSlider("PlayerOutlineTrans", {
	Text = "Outline Transparency",
	Default = 0,
	Min = 0,
	Max = 1,
	Rounding = 2,
})

-- === Item ESP Groupbox ===
local ItemEspGroup = Tabs.ESP:AddGroupbox({
	Side = "Left",
	Name = "Item ESP",
	IconName = "package"
})

ItemEspGroup:AddToggle("ItemsESP", {
	Text = "Enable Item ESP",
	Default = false,
}):AddKeyPicker("ItemsESPBind", { Default = "None", SyncToggleState = true, Text = "Item ESP Keybind" })
  :AddColorPicker("ItemFillColor", { Default = Color3.fromRGB(0, 255, 0), Title = "Fill Color" })
  :AddColorPicker("ItemOutlineColor", { Default = Color3.fromRGB(255, 255, 0), Title = "Outline Color" })

ItemEspGroup:AddSlider("ItemFillTrans", {
	Text = "Fill Transparency",
	Default = 0.3,
	Min = 0,
	Max = 1,
	Rounding = 2,
})

ItemEspGroup:AddSlider("ItemMaxDist", {
	Text = "Item ESP Max Distance",
	Default = 1000,
	Min = 100,
	Max = 5000,
	Rounding = 0,
})

-- Unified ESP Render Loop
RunService.RenderStepped:Connect(function()
    local myRoot = LocalPlayer.Character and findRootPart(LocalPlayer.Character)

    -- 1. ShadowMan ESP
    if Toggles.ShadowManESP.Value then
        local monstersFolder = Workspace:FindFirstChild("CurrentMonsters")
        if monstersFolder then
            for _, monster in ipairs(monstersFolder:GetChildren()) do
                local root = findRootPart(monster)
                if root then
                    if not shadowManEspCache[monster] then
                        local hl = Instance.new("Highlight")
                        hl.Adornee = monster
                        hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                        hl.Parent = monster

                        local bb = Instance.new("BillboardGui")
                        bb.Adornee = root
                        bb.AlwaysOnTop = true
                        bb.Size = UDim2.new(0, 140, 0, 36)
                        bb.StudsOffset = Vector3.new(0, 2.8, 0)

                        local lbl = Instance.new("TextLabel")
                        lbl.BackgroundTransparency = 1
                        lbl.Size = UDim2.new(1, 0, 1, 0)
                        lbl.TextSize = 12
                        lbl.Font = Enum.Font.GothamBold
                        lbl.TextStrokeTransparency = 0
                        lbl.TextStrokeColor3 = Color3.new(0, 0, 0)
                        lbl.Parent = bb
                        bb.Parent = monster

                        shadowManEspCache[monster] = { HL = hl, BB = bb, Label = lbl }
                    end

                    local data = shadowManEspCache[monster]
                    data.HL.FillColor = Options.ShadowManFillColor.Value
                    data.HL.OutlineColor = Options.ShadowManOutlineColor.Value
                    data.HL.FillTransparency = Options.ShadowManFillTrans.Value
                    data.HL.OutlineTransparency = Options.ShadowManOutlineTrans.Value
                    data.Label.TextColor3 = Options.ShadowManFillColor.Value

                    local hum = monster:FindFirstChildOfClass("Humanoid")
                    local distStr = myRoot and string.format("Distance: %.0fm", (myRoot.Position - root.Position).Magnitude) or "Dist: ?"
                    local hpStr = hum and string.format("Health: %.0f", hum.Health) or "HP: ?"
                    data.Label.Text = monster.Name .. "\n" .. distStr .. "\n" .. hpStr
                end
            end
        end
    else
        if next(shadowManEspCache) then clearMapCache(shadowManEspCache) end
    end

    -- 2. Player ESP
    if Toggles.PlayersESP.Value then
        for _, player in ipairs(Players:GetPlayers()) do
            if player ~= LocalPlayer and player.Character then
                local char = player.Character
                local root = findRootPart(char)
                if root then
                    if not playerEspCache[char] then
                        local hl = Instance.new("Highlight")
                        hl.Adornee = char
                        hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                        hl.Parent = char

                        local bb = Instance.new("BillboardGui")
                        bb.Adornee = root
                        bb.AlwaysOnTop = true
                        bb.Size = UDim2.new(0, 140, 0, 30)
                        bb.StudsOffset = Vector3.new(0, 3, 0)

                        local lbl = Instance.new("TextLabel")
                        lbl.BackgroundTransparency = 1
                        lbl.Size = UDim2.new(1, 0, 1, 0)
                        lbl.TextSize = 12
                        lbl.Font = Enum.Font.GothamBold
                        lbl.TextStrokeTransparency = 0
                        lbl.Parent = bb
                        bb.Parent = char

                        playerEspCache[char] = { HL = hl, BB = bb, Label = lbl }
                    end

                    local data = playerEspCache[char]
                    data.HL.FillColor = Options.PlayerFillColor.Value
                    data.HL.OutlineColor = Options.PlayerOutlineColor.Value
                    data.HL.FillTransparency = Options.PlayerFillTrans.Value
                    data.HL.OutlineTransparency = Options.PlayerOutlineTrans.Value
                    data.Label.TextColor3 = Options.PlayerFillColor.Value

                    local distStr = myRoot and string.format("Distance: %.0fm", (myRoot.Position - root.Position).Magnitude) or "Dist: ?"
                    data.Label.Text = player.Name .. "\n" .. distStr
                end
            end
        end
    else
        if next(playerEspCache) then clearMapCache(playerEspCache) end
    end

    -- 3. Item ESP (With Distance Filter)
    if Toggles.ItemsESP.Value then
        local pickupsFolder = Workspace:FindFirstChild("Pickups")
        if pickupsFolder then
            for _, item in ipairs(pickupsFolder:GetChildren()) do
                local root = findRootPart(item)
                if root then
                    local dist = myRoot and (myRoot.Position - root.Position).Magnitude or 0
                    if dist <= Options.ItemMaxDist.Value then
                        if not itemEspCache[item] then
                            local hl = Instance.new("Highlight")
                            hl.Adornee = item
                            hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                            hl.Parent = item

                            local bb = Instance.new("BillboardGui")
                            bb.Adornee = root
                            bb.AlwaysOnTop = true
                            bb.Size = UDim2.new(0, 120, 0, 24)
                            bb.StudsOffset = Vector3.new(0, 1.8, 0)

                            local lbl = Instance.new("TextLabel")
                            lbl.BackgroundTransparency = 1
                            lbl.Size = UDim2.new(1, 0, 1, 0)
                            lbl.TextSize = 11
                            lbl.Font = Enum.Font.GothamBold
                            lbl.TextStrokeTransparency = 0
                            lbl.Parent = bb
                            bb.Parent = item

                            itemEspCache[item] = { HL = hl, BB = bb, Label = lbl }
                        end

                        local data = itemEspCache[item]
                        data.HL.FillColor = Options.ItemFillColor.Value
                        data.HL.OutlineColor = Options.ItemOutlineColor.Value
                        data.HL.FillTransparency = Options.ItemFillTrans.Value
                        data.HL.OutlineTransparency = 0
                        data.Label.TextColor3 = Options.ItemFillColor.Value
                        data.Label.Text = item.Name .. string.format(" [%.0fm]", dist)
                    else
                        if itemEspCache[item] then
                            safeDestroy(itemEspCache[item].HL)
                            safeDestroy(itemEspCache[item].BB)
                            itemEspCache[item] = nil
                        end
                    end
                end
            end
        end
    else
        if next(itemEspCache) then clearMapCache(itemEspCache) end
    end
end)

--------------------------------------------------------------------------------
-- 2. Arrow Tracker (Mathematical Vector Direction Algorithm)
--------------------------------------------------------------------------------
local ArrowGroup = Tabs.Arrow:AddGroupbox({
	Side = "Left",
	Name = "Arrow Indicator Controls",
	IconName = "navigation"
})

ArrowGroup:AddToggle("ArrowTrack", {
	Text = "Enable ShadowMan Arrow Tracker",
	Default = false,
}):AddKeyPicker("ArrowTrackBind", { Default = "None", SyncToggleState = true, Text = "Arrow Tracker Keybind" })

ArrowGroup:AddToggle("MultiArrow", {
	Text = "Multi-Target Arrow Display",
	Default = false,
})

ArrowGroup:AddDropdown("ArrowMode", {
	Values = { "ScreenCenter", "FixedTop" },
	Default = 1,
	Multi = false,
	Text = "Arrow Alignment Mode",
})

ArrowGroup:AddSlider("ArrowRadius", {
	Text = "Crosshair Radius",
	Default = 140,
	Min = 50,
	Max = 350,
	Rounding = 0,
})

ArrowGroup:AddSlider("ArrowSize", {
	Text = "Arrow Size",
	Default = 36,
	Min = 16,
	Max = 80,
	Rounding = 0,
})

local arrowPool = {}

local function getArrowInstance(index)
    if not arrowPool[index] then
        local img = Instance.new("ImageLabel")
        img.Name = "ShadowManArrow_" .. index
        img.BackgroundTransparency = 1
        img.Image = "rbxassetid://15000587389"
        img.AnchorPoint = Vector2.new(0.5, 0.5)
        img.ZIndex = 10

        local distLabel = Instance.new("TextLabel")
        distLabel.Name = "DistLabel"
        distLabel.Size = UDim2.new(0, 80, 0, 18)
        distLabel.Position = UDim2.new(0.5, -40, 1, 2)
        distLabel.BackgroundTransparency = 1
        distLabel.Font = Enum.Font.SourceSansBold
        distLabel.TextSize = 13
        distLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
        distLabel.TextStrokeTransparency = 0
        distLabel.Parent = img

        img.Parent = ArrowGui
        arrowPool[index] = img
    end
    return arrowPool[index]
end

local function hideUnusedArrows(startIdx)
    for i = startIdx, #arrowPool do
        if arrowPool[i] then arrowPool[i].Visible = false end
    end
end

local function getDistanceColor(dist)
    if dist > 500 then
        return Color3.fromRGB(255, 255, 255)
    elseif dist > 100 then
        return Color3.fromRGB(255, 230, 0)
    else
        return Color3.fromRGB(255, 30, 30)
    end
end

RunService.RenderStepped:Connect(function()
    if not Toggles.ArrowTrack.Value then
        hideUnusedArrows(1)
        return
    end

    local monstersFolder = Workspace:FindFirstChild("CurrentMonsters")
    local myRoot = LocalPlayer.Character and findRootPart(LocalPlayer.Character)

    if not monstersFolder or not myRoot then
        hideUnusedArrows(1)
        return
    end

    local targets = {}
    for _, monster in ipairs(monstersFolder:GetChildren()) do
        local mRoot = findRootPart(monster)
        if mRoot then
            local dist = (myRoot.Position - mRoot.Position).Magnitude
            table.insert(targets, {Root = mRoot, Dist = dist})
        end
    end

    if #targets == 0 then
        hideUnusedArrows(1)
        return
    end

    table.sort(targets, function(a, b) return a.Dist < b.Dist end)

    local activeTargets = Toggles.MultiArrow.Value and targets or {targets[1]}
    local screenCenter = Camera.ViewportSize / 2
    local currentSize = Options.ArrowSize.Value
    local currentRadius = Options.ArrowRadius.Value
    local currentMode = Options.ArrowMode.Value

    for idx, targetData in ipairs(activeTargets) do
        local arrow = getArrowInstance(idx)
        arrow.Visible = true
        arrow.Size = UDim2.new(0, currentSize, 0, currentSize)

        local mPos = targetData.Root.Position
        local dist = math.floor(targetData.Dist)
        local color = getDistanceColor(dist)

        arrow.ImageColor3 = color
        local label = arrow:FindFirstChild("DistLabel")
        if label then
            label.Text = dist .. "m"
            label.TextColor3 = color
        end

        if currentMode == "ScreenCenter" then
            -- 3D -> 2D Directional Calculation
            local camCF = Camera.CFrame
            local localPos = camCF:PointToObjectSpace(mPos)

            local dirX = localPos.X
            local dirY = -localPos.Y

            if localPos.Z > 0 then
                dirX = -dirX
                dirY = -dirY
            end

            local dir2D = Vector2.new(dirX, dirY)
            if dir2D.Magnitude > 0 then
                dir2D = dir2D.Unit
            else
                dir2D = Vector2.new(0, -1)
            end

            local arrowPos = screenCenter + dir2D * currentRadius
            arrow.Position = UDim2.new(0, arrowPos.X, 0, arrowPos.Y)

            local rotAngle = math.deg(math.atan2(dir2D.Y, dir2D.X)) + 90
            arrow.Rotation = rotAngle

        elseif currentMode == "FixedTop" then
            local offsetY = (idx - 1) * (currentSize + 15)
            arrow.Position = UDim2.new(0.5, 0, 0.12, offsetY)

            local camCF = Camera.CFrame
            local dir = (mPos - camCF.Position).Unit
            local angle = math.atan2(dir:Dot(camCF.RightVector), dir:Dot(camCF.LookVector))
            arrow.Rotation = math.deg(angle)
        end
    end

    hideUnusedArrows(#activeTargets + 1)
end)

--------------------------------------------------------------------------------
-- 3. Combat & OP Features
--------------------------------------------------------------------------------
local CombatGroup = Tabs.Combat:AddGroupbox({
	Side = "Left",
	Name = "Auto Attack & Insta-Kill",
	IconName = "swords"
})

CombatGroup:AddDropdown("KillModeWeapon", {
	Values = { "Shotgun", "Handgun" },
	Default = 1,
	Multi = false,
	Text = "Select Weapon",
})

local function fireDamageEvent(toolName)
    local monstersFolder = Workspace:FindFirstChild("CurrentMonsters")
    local shadowMan = monstersFolder and monstersFolder:FindFirstChild("ShadowMan")
    local head = shadowMan and shadowMan:FindFirstChild("Head")
    if not head then return end

    local tool = LocalPlayer:FindFirstChild("Backpack") and LocalPlayer.Backpack:FindFirstChild(toolName)
    if not tool and LocalPlayer.Character then
        tool = LocalPlayer.Character:FindFirstChild(toolName)
    end
    if not tool then return end

    local event = tool:FindFirstChild("DamageTargetEvent")
    if event then
        pcall(function()
            event:FireServer(head, Vector3.new(56.75, 45.88, -343.36))
        end)
    end
end

CombatGroup:AddToggle("KillShadowMan", {
	Text = "Kill ShadowMan (Auto Attack)",
	Default = false,
}):AddKeyPicker("KillShadowManBind", { Default = "None", SyncToggleState = true, Text = "Auto Attack Keybind" })

task.spawn(function()
    while task.wait(0.15) do
        if Toggles.KillShadowMan and Toggles.KillShadowMan.Value then
            fireDamageEvent(Options.KillModeWeapon.Value)
        end
    end
end)

-- Infinite Ammo Refill Implementation (By R-77)
local function refillShotgun()
    pcall(function()
        local args = { "Shotgun", LocalPlayer.Character:WaitForChild("Shotgun"), 1000000 }
        ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RefillGun"):FireServer(unpack(args))
        Library:Notify({ Title = "Ammo Refill", Description = "Shotgun ammo restored! (By R-77)", Time = 2 })
    end)
end

local function refillHandgun()
    pcall(function()
        local args = { "Handgun", LocalPlayer.Character:WaitForChild("Handgun"), 1000000 }
        ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RefillGun"):FireServer(unpack(args))
        Library:Notify({ Title = "Ammo Refill", Description = "Handgun ammo restored! (By R-77)", Time = 2 })
    end)
end

CombatGroup:AddButton({ Text = "Refill Shotgun (Infinite Ammo by R-77)", Func = refillShotgun })
CombatGroup:AddLabel("Refill Shotgun"):AddKeyPicker("RefillShotgunBind", { Default = "None", Mode = "Press", Text = "Refill Shotgun", Callback = refillShotgun })

CombatGroup:AddButton({ Text = "Refill Handgun (Infinite Ammo by R-77)", Func = refillHandgun })
CombatGroup:AddLabel("Refill Handgun"):AddKeyPicker("RefillHandgunBind", { Default = "None", Mode = "Press", Text = "Refill Handgun", Callback = refillHandgun })

-- Camera Controls
local CameraGroup = Tabs.Combat:AddGroupbox({
	Side = "Right",
	Name = "Camera Controls",
	IconName = "camera"
})

local spectateConnection = nil
local defaultSubject = nil
local defaultCameraType = nil

local function stopSpectate()
    if spectateConnection then spectateConnection:Disconnect() spectateConnection = nil end
    if Camera then
        if defaultSubject then
            Camera.CameraType = defaultCameraType or Enum.CameraType.Custom
            Camera.CameraSubject = defaultSubject
        elseif LocalPlayer.Character and LocalPlayer.Character:FindFirstChildOfClass("Humanoid") then
            Camera.CameraType = Enum.CameraType.Custom
            Camera.CameraSubject = LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
        end
    end
end

local function startSpectate()
    if not Camera then return end
    defaultSubject = Camera.CameraSubject
    defaultCameraType = Camera.CameraType

    if spectateConnection then spectateConnection:Disconnect() end
    spectateConnection = RunService.RenderStepped:Connect(function()
        if not Toggles.SpectateShadowMan.Value then return end
        local monstersFolder = Workspace:FindFirstChild("CurrentMonsters")
        local shadowMan = monstersFolder and monstersFolder:FindFirstChild("ShadowMan")
        local head = shadowMan and shadowMan:FindFirstChild("Head")

        if head then
            Camera.CameraType = Enum.CameraType.Custom
            Camera.CameraSubject = head
        else
            stopSpectate()
        end
    end)
end

CameraGroup:AddToggle("SpectateShadowMan", {
	Text = "Spectate ShadowMan",
	Default = false,
	Callback = function(Value)
		if Value then pcall(startSpectate) else pcall(stopSpectate) end
	end
}):AddKeyPicker("SpectateShadowManBind", { Default = "None", SyncToggleState = true, Text = "Spectate ShadowMan Keybind" })

--------------------------------------------------------------------------------
-- 4. Advanced Ragdoll Physics Controller
--------------------------------------------------------------------------------
local SelfRagdollGroup = Tabs.Ragdoll:AddGroupbox({
	Side = "Left",
	Name = "Self Protection & Control",
	IconName = "user-check"
})

SelfRagdollGroup:AddToggle("AntiRagdoll", {
	Text = "Anti-Ragdoll / Anti-Fling",
	Default = false,
}):AddKeyPicker("AntiRagdollBind", { Default = "None", SyncToggleState = true, Text = "Anti-Ragdoll Keybind" })

SelfRagdollGroup:AddToggle("SelfRagdoll", {
	Text = "Self-Ragdoll Mode",
	Default = false,
}):AddKeyPicker("SelfRagdollBind", { Default = "None", SyncToggleState = true, Text = "Self-Ragdoll Keybind" })

local TargetRagdollGroup = Tabs.Ragdoll:AddGroupbox({
	Side = "Right",
	Name = "Target Ragdoll Control",
	IconName = "crosshair"
})

TargetRagdollGroup:AddToggle("TargetRagdoll", {
	Text = "Apply Target Ragdoll",
	Default = false,
}):AddKeyPicker("TargetRagdollBind", { Default = "None", SyncToggleState = true, Text = "Target Ragdoll Keybind" })

TargetRagdollGroup:AddSlider("RagdollImpulseForce", {
	Text = "Impulse Fling Force",
	Default = 50,
	Min = 0,
	Max = 500,
	Rounding = 0,
})

TargetRagdollGroup:AddDropdown("RagdollTargetScope", {
	Values = { "All Monsters", "All Players", "Specific Player", "Specific Monster" },
	Default = 1,
	Multi = false,
	Text = "Target Scope Category",
})

-- Dynamic Specific Player Dropdown
TargetRagdollGroup:AddDropdown("RagdollSpecificPlayer", {
	SpecialType = "Player",
	Text = "Select Specific Player",
})

-- Dynamic Specific Monster Dropdown
local function getMonsterNamesList()
    local list = {}
    local monstersFolder = Workspace:FindFirstChild("CurrentMonsters")
    if monstersFolder then
        for _, m in ipairs(monstersFolder:GetChildren()) do
            table.insert(list, m.Name)
        end
    end
    if #list == 0 then list = { "No Monsters Found" } end
    return list
end

TargetRagdollGroup:AddDropdown("RagdollSpecificMonster", {
	Values = getMonsterNamesList(),
	Default = 1,
	Multi = false,
	Searchable = true,
	Text = "Select Specific Monster",
})

TargetRagdollGroup:AddButton({
	Text = "Refresh Monster List",
	Func = function()
		Options.RagdollSpecificMonster:SetValues(getMonsterNamesList())
		Options.RagdollSpecificMonster:SetValue(getMonsterNamesList()[1])
	end
})

-- Ragdoll Physics Stepped Loop
RunService.Stepped:Connect(function()
    -- 1. Self Anti-Ragdoll / Self-Ragdoll
    local char = LocalPlayer.Character
    if char then
        local hum = char:FindFirstChildOfClass("Humanoid")
        local hrp = char:FindFirstChild("HumanoidRootPart")
        local ragdollClient = char:FindFirstChild("RagdollClient")

        if Toggles.AntiRagdoll.Value then
            if ragdollClient and ragdollClient:IsA("LocalScript") then ragdollClient.Disabled = true end
            if hum then
                hum:SetStateEnabled(Enum.HumanoidStateType.Ragdoll, false)
                hum:SetStateEnabled(Enum.HumanoidStateType.FallingDown, false)
                if hum.PlatformStand then hum.PlatformStand = false end
            end
            if hrp and hrp.AssemblyLinearVelocity.Magnitude > 120 then
                hrp.AssemblyLinearVelocity = Vector3.zero
            end
        else
            if ragdollClient and ragdollClient:IsA("LocalScript") and not Toggles.SelfRagdoll.Value then
                ragdollClient.Disabled = false
            end
        end

        if Toggles.SelfRagdoll.Value and hum then
            hum:ChangeState(Enum.HumanoidStateType.Ragdoll)
            hum.PlatformStand = true
        end
    end

    -- 2. Target Ragdoll Enforcement & Fling Force
    if not Toggles.TargetRagdoll.Value then return end

    local scope = Options.RagdollTargetScope.Value
    local force = Options.RagdollImpulseForce.Value

    local function applyRagdollToChar(targetChar)
        if not targetChar then return end
        local hum = targetChar:FindFirstChildOfClass("Humanoid")
        local hrp = targetChar:FindFirstChild("HumanoidRootPart")
        if hum then
            hum:ChangeState(Enum.HumanoidStateType.Ragdoll)
            hum.PlatformStand = true
        end
        if hrp and force > 0 then
            hrp.AssemblyLinearVelocity = Vector3.new(
                math.random(-force, force),
                force,
                math.random(-force, force)
            )
        end
    end

    if scope == "All Monsters" then
        local monstersFolder = Workspace:FindFirstChild("CurrentMonsters")
        if monstersFolder then
            for _, m in ipairs(monstersFolder:GetChildren()) do applyRagdollToChar(m) end
        end
    elseif scope == "All Players" then
        for _, plr in ipairs(Players:GetPlayers()) do
            if plr ~= LocalPlayer then applyRagdollToChar(plr.Character) end
        end
    elseif scope == "Specific Player" then
        local targetName = Options.RagdollSpecificPlayer.Value
        if targetName then
            local targetPlr = Players:FindFirstChild(targetName)
            if targetPlr then applyRagdollToChar(targetPlr.Character) end
        end
    elseif scope == "Specific Monster" then
        local targetMonsterName = Options.RagdollSpecificMonster.Value
        local monstersFolder = Workspace:FindFirstChild("CurrentMonsters")
        if monstersFolder and targetMonsterName then
            local monster = monstersFolder:FindFirstChild(targetMonsterName)
            if monster then applyRagdollToChar(monster) end
        end
    end
end)

--------------------------------------------------------------------------------
-- 5. Movement & Teleportation
--------------------------------------------------------------------------------
local MoveGroup = Tabs.Movement:AddGroupbox({
	Side = "Left",
	Name = "Movement Controls",
	IconName = "zap"
})

MoveGroup:AddToggle("SpeedHack", {
	Text = "Enable Speed Hack",
	Default = false,
}):AddKeyPicker("SpeedHackBind", { Default = "None", SyncToggleState = true, Text = "Speed Hack Keybind" })

MoveGroup:AddSlider("SpeedValue", {
	Text = "WalkSpeed",
	Default = 32,
	Min = 16,
	Max = 200,
	Rounding = 0,
})

MoveGroup:AddToggle("FlyEnable", {
	Text = "Enable Fly",
	Default = false,
}):AddKeyPicker("FlyBind", { Default = "F", SyncToggleState = true, Text = "Fly Keybind" })

MoveGroup:AddSlider("FlySpeed", {
	Text = "Fly Speed",
	Default = 50,
	Min = 10,
	Max = 300,
	Rounding = 0,
})

MoveGroup:AddToggle("Noclip", {
	Text = "Enable Noclip",
	Default = false,
}):AddKeyPicker("NoclipBind", { Default = "N", SyncToggleState = true, Text = "Noclip Keybind" })

MoveGroup:AddToggle("CtrlClickTP", {
	Text = "Ctrl + Click Teleport",
	Default = true,
})

-- Movement Loop
RunService.Stepped:Connect(function()
    local char = LocalPlayer.Character
    if not char then return end

    if Toggles.Noclip.Value then
        for _, part in ipairs(char:GetDescendants()) do
            if part:IsA("BasePart") then part.CanCollide = false end
        end
    end

    local hum = char:FindFirstChildOfClass("Humanoid")
    if Toggles.SpeedHack.Value and hum then
        hum.WalkSpeed = Options.SpeedValue.Value
    end
end)

-- Fly Loop
local flyBV, flyBG
RunService.RenderStepped:Connect(function()
    local char = LocalPlayer.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")

    if Toggles.FlyEnable.Value and hrp then
        if not flyBV then
            flyBV = Instance.new("BodyVelocity")
            flyBV.MaxForce = Vector3.new(1e9, 1e9, 1e9)
            flyBV.Parent = hrp
        end
        if not flyBG then
            flyBG = Instance.new("BodyGyro")
            flyBG.MaxTorque = Vector3.new(1e9, 1e9, 1e9)
            flyBG.Parent = hrp
        end

        flyBG.CFrame = Camera.CFrame
        local moveDir = Vector3.zero

        if UserInputService:IsKeyDown(Enum.KeyCode.W) then moveDir = moveDir + Camera.CFrame.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.S) then moveDir = moveDir - Camera.CFrame.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.A) then moveDir = moveDir - Camera.CFrame.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.D) then moveDir = moveDir + Camera.CFrame.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.Space) then moveDir = moveDir + Vector3.new(0, 1, 0) end
        if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then moveDir = moveDir - Vector3.new(0, 1, 0) end

        flyBV.Velocity = moveDir * Options.FlySpeed.Value
    else
        if flyBV then flyBV:Destroy() flyBV = nil end
        if flyBG then flyBG:Destroy() flyBG = nil end
    end
end)

-- Ctrl + Click Teleport Listener
UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if Toggles.CtrlClickTP.Value and input.UserInputType == Enum.UserInputType.MouseButton1 then
        if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) or UserInputService:IsKeyDown(Enum.KeyCode.RightControl) then
            local mouse = LocalPlayer:GetMouse()
            local hrp = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            if mouse and mouse.Hit and hrp then
                hrp.CFrame = mouse.Hit * CFrame.new(0, 3, 0)
            end
        end
    end
end)

-- === Teleportation Groupbox ===
local TeleportGroup = Tabs.Movement:AddGroupbox({
	Side = "Right",
	Name = "Item & Vehicle Teleport",
	IconName = "map-pin"
})

local function getPickupItemsList()
    local list = {}
    local pickups = Workspace:FindFirstChild("Pickups")
    local myRoot = LocalPlayer.Character and findRootPart(LocalPlayer.Character)

    if pickups then
        for _, child in ipairs(pickups:GetChildren()) do
            local part = findRootPart(child)
            if part then
                local dist = myRoot and (myRoot.Position - part.Position).Magnitude or 0
                table.insert(list, child.Name .. string.format(" [%.0fm]", dist))
            else
                table.insert(list, child.Name)
            end
        end
    end
    if #list == 0 then list = { "No Teleportable Items Found" } end
    return list
end

TeleportGroup:AddDropdown("ItemTpDropdown", {
	Values = getPickupItemsList(),
	Default = 1,
	Multi = false,
	Searchable = true,
	MaxVisibleDropdownItems = 12,
	Text = "Select Teleport Item",
})

TeleportGroup:AddButton({
	Text = "Refresh Item List",
	Func = function()
		local newList = getPickupItemsList()
		Options.ItemTpDropdown:SetValues(newList)
		Options.ItemTpDropdown:SetValue(newList[1])
		Library:Notify({ Title = "Refreshed", Description = "Pickups item list updated!", Time = 2 })
	end
})

local function tpToSelectedItem()
    local rawValue = Options.ItemTpDropdown.Value
    if not rawValue or rawValue == "No Teleportable Items Found" then return end

    local itemName = rawValue:gsub("%s%[.*%]", "")
    local pickups = Workspace:FindFirstChild("Pickups")
    local hrp = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")

    if pickups and hrp then
        local targetItem = pickups:FindFirstChild(itemName)
        if targetItem then
            local part = findRootPart(targetItem)
            if part then
                hrp.CFrame = part.CFrame * CFrame.new(0, 3, 0)
                Library:Notify({ Title = "Item Teleport", Description = "Teleported to: " .. itemName, Time = 3 })
            end
        end
    end
end

TeleportGroup:AddButton({ Text = "Teleport to Selected Item", Func = tpToSelectedItem })
TeleportGroup:AddLabel("Teleport Keybind"):AddKeyPicker("TPItemBind", { Default = "None", Mode = "Press", Text = "Teleport Selected Item", Callback = tpToSelectedItem })

TeleportGroup:AddDivider()

-- Boot Interaction & Vehicle Teleportation
local function openTrunkCar()
    pcall(function()
        Workspace:WaitForChild("Vehicles")
            :WaitForChild("ChryslerValiant")
            :WaitForChild("BodyWork")
            :WaitForChild("Boot")
            :WaitForChild("InteractRemote")
            :FireServer()
        Library:Notify({ Title = "Vehicle Action", Description = "Attempted to open car boot!", Time = 3 })
    end)
end

local function tpToVehicle()
    local hrp = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
    local vehicleSeat = Workspace:FindFirstChild("Vehicles") 
        and Workspace.Vehicles:FindFirstChild("ChryslerValiant")
        and Workspace.Vehicles.ChryslerValiant:FindFirstChild("CarBase")
        and Workspace.Vehicles.ChryslerValiant.CarBase:FindFirstChild("VehicleSeat")

    if hrp and vehicleSeat then
        hrp.CFrame = vehicleSeat.CFrame * CFrame.new(0, 3, 0)
        Library:Notify({ Title = "Teleport Success", Description = "Teleported to ChryslerValiant Vehicle!", Time = 3 })
    else
        Library:Notify({ Title = "Teleport Failed", Description = "Vehicle Seat not found!", Time = 3 })
    end
end

TeleportGroup:AddButton({ Text = "Open Car Boot", Func = openTrunkCar })
TeleportGroup:AddLabel("Open Boot Keybind"):AddKeyPicker("OpenTrunkBind", { Default = "B", Mode = "Press", Text = "Open Car Boot", Callback = openTrunkCar })

TeleportGroup:AddButton({ Text = "Teleport to ChryslerValiant", Func = tpToVehicle })
TeleportGroup:AddLabel("Vehicle TP Keybind"):AddKeyPicker("TPVehicleBind", { Default = "None", Mode = "Press", Text = "Teleport to Vehicle", Callback = tpToVehicle })

--------------------------------------------------------------------------------
-- 6. UI Settings & Config Management
--------------------------------------------------------------------------------
local MenuGroup = Tabs["UI Settings"]:AddGroupbox({
	Side = "Left",
	Name = "Menu Settings",
	IconName = "wrench"
})

MenuGroup:AddToggle("KeybindMenuOpen", {
	Default = Library.KeybindFrame.Visible,
	Text = "Show Keybind List",
	Callback = function(value)
		Library.KeybindFrame.Visible = value
	end,
})

MenuGroup:AddToggle("ShowCustomCursor", {
	Text = "Custom Cursor",
	Default = Library.ShowCustomCursor,
	Callback = function(Value)
		Library.ShowCustomCursor = Value
	end,
})

MenuGroup:AddDropdown("NotificationSide", {
	Values = { "Left", "Right" },
	Default = "Right",
	Text = "Notification Side",
	Callback = function(Value)
		Library:SetNotifySide(Value)
	end,
})

MenuGroup:AddDropdown("DPIDropdown", {
	Values = { "50%", "75%", "100%", "125%", "150%" },
	Default = "100%",
	Text = "DPI Scaling",
	Callback = function(Value)
		local DPI = tonumber(Value:gsub("%%", ""))
		Library:SetDPIScale(DPI)
	end,
})

MenuGroup:AddSlider("UICornerSlider", {
	Text = "UI Corner Radius",
	Default = Library.CornerRadius,
	Min = 0,
	Max = 20,
	Rounding = 0,
	Callback = function(value)
		Window:SetCornerRadius(value)
	end
})

MenuGroup:AddDivider()
MenuGroup:AddLabel("Hide Menu Keybind")
	:AddKeyPicker("MenuKeybind", { Default = "RightShift", NoUI = true, Text = "Menu Keybind" })

MenuGroup:AddButton({
	Text = "Unload UI",
	Func = function()
		Library:Unload()
	end
})

Library.ToggleKeybind = Options.MenuKeybind

-- Theme & Save Manager Initialization
ThemeManager:SetLibrary(Library)
SaveManager:SetLibrary(Library)

SaveManager:IgnoreThemeSettings()
SaveManager:SetIgnoreIndexes({ "MenuKeybind" })

ThemeManager:SetFolder("SKIDGODHub")
SaveManager:SetFolder("SKIDGODHub/After3AM")

SaveManager:BuildConfigSection(Tabs["UI Settings"])
ThemeManager:ApplyToTab(Tabs["UI Settings"])

SaveManager:LoadAutoloadConfig()

Library:Notify({
	Title = "AFTER 3 AM FREEBUG MENU V1",
	Description = "Loaded successfully! Press RightShift to hide UI.",
	Time = 5,
})

Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.