--[[
    Doors: The Archives Hub

    Features:
    - Noclip
    - Fullbright
    - WalkSpeed slider: 17-21
    - Entity warnings
    - Infinite jump (~25 studs vertical height)
    - Item ESP with distance
    - ESP refresh every 2 seconds
]]

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

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

----------------------------------------------------------------
-- CLEAN OLD GUI
----------------------------------------------------------------

local oldGui = playerGui:FindFirstChild("DoorsArchivesHub")
if oldGui then
	oldGui:Destroy()
end

----------------------------------------------------------------
-- SETTINGS
----------------------------------------------------------------

local settings = {
	Noclip = false,
	Fullbright = false,
	InfiniteJump = false,
	ItemESP = false,

	WalkSpeed = 17,
	JumpHeightStuds = 25,

	ESPUpdateRate = 2,
}

----------------------------------------------------------------
-- CHARACTER
----------------------------------------------------------------

local character
local humanoid
local rootPart

local function updateCharacter(char)
	character = char
	humanoid = char:WaitForChild("Humanoid")
	rootPart = char:WaitForChild("HumanoidRootPart")

	humanoid.WalkSpeed = settings.WalkSpeed
end

if player.Character then
	task.spawn(updateCharacter, player.Character)
end

player.CharacterAdded:Connect(updateCharacter)

----------------------------------------------------------------
-- GUI
----------------------------------------------------------------

local gui = Instance.new("ScreenGui")
gui.Name = "DoorsArchivesHub"
gui.ResetOnSpawn = false
gui.IgnoreGuiInset = false
gui.Parent = playerGui

local frame = Instance.new("Frame")
frame.Name = "Main"
frame.Size = UDim2.fromOffset(440, 570)
frame.Position = UDim2.new(0.5, -220, 0.1, 0)
frame.BackgroundColor3 = Color3.fromRGB(18, 15, 13)
frame.BorderSizePixel = 0
frame.Parent = gui

local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 12)
corner.Parent = frame

local stroke = Instance.new("UIStroke")
stroke.Color = Color3.fromRGB(175, 135, 85)
stroke.Thickness = 3
stroke.Parent = frame

local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, 0, 0, 65)
title.BackgroundTransparency = 1
title.Text = "Doors: The Archives Hub"
title.TextColor3 = Color3.fromRGB(235, 220, 190)
title.TextScaled = true
title.Font = Enum.Font.GothamBlack
title.Parent = frame

local titlePadding = Instance.new("UIPadding")
titlePadding.PaddingLeft = UDim.new(0, 18)
titlePadding.PaddingRight = UDim.new(0, 18)
titlePadding.PaddingTop = UDim.new(0, 10)
titlePadding.PaddingBottom = UDim.new(0, 10)
titlePadding.Parent = title

local container = Instance.new("Frame")
container.Size = UDim2.new(1, -30, 1, -80)
container.Position = UDim2.fromOffset(15, 70)
container.BackgroundTransparency = 1
container.Parent = frame

local layout = Instance.new("UIListLayout")
layout.Padding = UDim.new(0, 9)
layout.FillDirection = Enum.FillDirection.Vertical
layout.HorizontalAlignment = Enum.HorizontalAlignment.Center
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = container

----------------------------------------------------------------
-- GUI HELPERS
----------------------------------------------------------------

local function makeButton(text)
	local button = Instance.new("TextButton")

	button.Size = UDim2.new(1, 0, 0, 48)
	button.BackgroundColor3 = Color3.fromRGB(39, 33, 28)
	button.BorderSizePixel = 0

	button.Text = text
	button.TextColor3 = Color3.fromRGB(235, 220, 190)
	button.TextSize = 18
	button.Font = Enum.Font.GothamBold

	local buttonCorner = Instance.new("UICorner")
	buttonCorner.CornerRadius = UDim.new(0, 8)
	buttonCorner.Parent = button

	local buttonStroke = Instance.new("UIStroke")
	buttonStroke.Color = Color3.fromRGB(91, 72, 52)
	buttonStroke.Thickness = 1
	buttonStroke.Parent = button

	button.Parent = container

	return button
end

local function updateToggleButton(button, titleText, enabled)
	if enabled then
		button.Text = titleText .. ": ON"
		button.BackgroundColor3 = Color3.fromRGB(55, 72, 45)
	else
		button.Text = titleText .. ": OFF"
		button.BackgroundColor3 = Color3.fromRGB(39, 33, 28)
	end
end

----------------------------------------------------------------
-- NOCLIP
----------------------------------------------------------------

local noclipButton = makeButton("Noclip: OFF")

noclipButton.MouseButton1Click:Connect(function()
	settings.Noclip = not settings.Noclip

	updateToggleButton(
		noclipButton,
		"Noclip",
		settings.Noclip
	)
end)

RunService.Stepped:Connect(function()
	if not settings.Noclip then
		return
	end

	if not character then
		return
	end

	for _, object in ipairs(character:GetDescendants()) do
		if object:IsA("BasePart") then
			object.CanCollide = false
		end
	end
end)

----------------------------------------------------------------
-- FULLBRIGHT
----------------------------------------------------------------

local oldLighting = {
	Brightness = Lighting.Brightness,
	ClockTime = Lighting.ClockTime,
	FogEnd = Lighting.FogEnd,
	GlobalShadows = Lighting.GlobalShadows,
	Ambient = Lighting.Ambient,
	OutdoorAmbient = Lighting.OutdoorAmbient,
}

local fullbrightButton = makeButton("Fullbright: OFF")

local function enableFullbright()
	Lighting.Brightness = 3
	Lighting.ClockTime = 14
	Lighting.FogEnd = 100000
	Lighting.GlobalShadows = false

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

	Lighting.OutdoorAmbient = Color3.fromRGB(
		255,
		255,
		255
	)
end

local function disableFullbright()
	Lighting.Brightness = oldLighting.Brightness
	Lighting.ClockTime = oldLighting.ClockTime
	Lighting.FogEnd = oldLighting.FogEnd
	Lighting.GlobalShadows = oldLighting.GlobalShadows
	Lighting.Ambient = oldLighting.Ambient
	Lighting.OutdoorAmbient = oldLighting.OutdoorAmbient
end

fullbrightButton.MouseButton1Click:Connect(function()
	settings.Fullbright = not settings.Fullbright

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

	updateToggleButton(
		fullbrightButton,
		"Fullbright",
		settings.Fullbright
	)
end)

----------------------------------------------------------------
-- SPEED SLIDER
----------------------------------------------------------------

local speedFrame = Instance.new("Frame")
speedFrame.Size = UDim2.new(1, 0, 0, 75)
speedFrame.BackgroundColor3 = Color3.fromRGB(39, 33, 28)
speedFrame.BorderSizePixel = 0
speedFrame.Parent = container

local speedCorner = Instance.new("UICorner")
speedCorner.CornerRadius = UDim.new(0, 8)
speedCorner.Parent = speedFrame

local speedLabel = Instance.new("TextLabel")
speedLabel.Size = UDim2.new(1, 0, 0, 32)
speedLabel.BackgroundTransparency = 1
speedLabel.Text = "Speed: 17 studs/sec"
speedLabel.TextColor3 = Color3.fromRGB(235, 220, 190)
speedLabel.Font = Enum.Font.GothamBold
speedLabel.TextSize = 17
speedLabel.Parent = speedFrame

local sliderBar = Instance.new("Frame")
sliderBar.Size = UDim2.new(1, -40, 0, 10)
sliderBar.Position = UDim2.new(0, 20, 0, 49)
sliderBar.BackgroundColor3 = Color3.fromRGB(82, 68, 54)
sliderBar.BorderSizePixel = 0
sliderBar.Parent = speedFrame

local sliderCorner = Instance.new("UICorner")
sliderCorner.CornerRadius = UDim.new(1, 0)
sliderCorner.Parent = sliderBar

local sliderKnob = Instance.new("TextButton")
sliderKnob.Size = UDim2.fromOffset(22, 22)
sliderKnob.AnchorPoint = Vector2.new(0.5, 0.5)
sliderKnob.Position = UDim2.new(0, 0, 0.5, 0)

sliderKnob.BackgroundColor3 = Color3.fromRGB(
	235,
	220,
	190
)

sliderKnob.BorderSizePixel = 0
sliderKnob.Text = ""
sliderKnob.Parent = sliderBar

local knobCorner = Instance.new("UICorner")
knobCorner.CornerRadius = UDim.new(1, 0)
knobCorner.Parent = sliderKnob

local MIN_SPEED = 17
local MAX_SPEED = 21

local draggingSlider = false

local function setSpeedFromX(mouseX)
	local left = sliderBar.AbsolutePosition.X
	local width = sliderBar.AbsoluteSize.X

	if width <= 0 then
		return
	end

	local alpha = math.clamp(
		(mouseX - left) / width,
		0,
		1
	)

	local rawSpeed =
		MIN_SPEED
		+
		(MAX_SPEED - MIN_SPEED)
		* alpha

	local speed = math.round(rawSpeed)

	settings.WalkSpeed = speed

	local normalized =
		(speed - MIN_SPEED)
		/
		(MAX_SPEED - MIN_SPEED)

	sliderKnob.Position =
		UDim2.new(
			normalized,
			0,
			0.5,
			0
		)

	speedLabel.Text =
		"Speed: "
		.. tostring(speed)
		.. " studs/sec"

	if humanoid then
		humanoid.WalkSpeed = speed
	end
end

sliderKnob.MouseButton1Down:Connect(function()
	draggingSlider = true
end)

sliderBar.InputBegan:Connect(function(input)
	if
		input.UserInputType
		== Enum.UserInputType.MouseButton1
	then
		draggingSlider = true
		setSpeedFromX(input.Position.X)
	end
end)

UserInputService.InputChanged:Connect(function(input)
	if not draggingSlider then
		return
	end

	if
		input.UserInputType
		== Enum.UserInputType.MouseMovement
	then
		setSpeedFromX(input.Position.X)
	end
end)

UserInputService.InputEnded:Connect(function(input)
	if
		input.UserInputType
		== Enum.UserInputType.MouseButton1
	then
		draggingSlider = false
	end
end)

----------------------------------------------------------------
-- ENTITY WARNING
----------------------------------------------------------------

local entityWarningButton =
	makeButton("Entity Warning: ON")

local entityWarningsEnabled = true

updateToggleButton(
	entityWarningButton,
	"Entity Warning",
	true
)

entityWarningButton.MouseButton1Click:Connect(function()
	entityWarningsEnabled =
		not entityWarningsEnabled

	updateToggleButton(
		entityWarningButton,
		"Entity Warning",
		entityWarningsEnabled
	)
end)

----------------------------------------------------------------
-- ENTITY NAME NORMALIZER
----------------------------------------------------------------

local function normalizeName(name)
	name = string.lower(name)

	-- Remove spaces, punctuation, underscores, etc.
	name = string.gsub(
		name,
		"[^%w]",
		""
	)

	return name
end

----------------------------------------------------------------
-- LEVENSHTEIN DISTANCE
--
-- Allows small spelling mistakes:
--
-- AmbushMoving
-- AmbshMoving
-- AmbushMovin
-- ambush_moving
-- Ambush-Moving
-- etc.
----------------------------------------------------------------

local function levenshtein(a, b)
	local lenA = #a
	local lenB = #b

	local matrix = {}

	for i = 0, lenA do
		matrix[i] = {}
		matrix[i][0] = i
	end

	for j = 0, lenB do
		matrix[0][j] = j
	end

	for i = 1, lenA do
		for j = 1, lenB do
			local cost

			if
				string.sub(a, i, i)
				==
				string.sub(b, j, j)
			then
				cost = 0
			else
				cost = 1
			end

			matrix[i][j] =
				math.min(
					matrix[i - 1][j] + 1,
					matrix[i][j - 1] + 1,
					matrix[i - 1][j - 1] + cost
				)
		end
	end

	return matrix[lenA][lenB]
end

----------------------------------------------------------------
-- ENTITY DATABASE
----------------------------------------------------------------

local entities = {
	{
		Display = "Ambush",
		Aliases = {
			"AmbushMoving",
			"Ambush Move",
			"AmbushMover",
			"Ambush",
		},
	},

	{
		Display = "Rush",
		Aliases = {
			"RushMoving",
			"Rush Move",
			"RushMover",
			"Rush",
		},
	},

	{
		Display = "A-60",
		Aliases = {
			"A60Moving",
			"A-60Moving",
			"A_60Moving",
			"A60 Moving",
			"A60",
		},
	},

	{
		Display = "A-120",
		Aliases = {
			"A120Moving",
			"A-120Moving",
			"A_120Moving",
			"A120 Moving",
			"A120",
		},
	},

	{
		Display = "Bash",
		Aliases = {
			"BashMoving",
			"Bash Move",
			"BashMover",
			"Bash",
		},
	},

	{
		Display = "Scribbles",
		Aliases = {
			"ScribblesMoving",
			"ScribbleMoving",
			"SrcibblesMoving",
			"ScrriblesMoving",
			"Scribbles Move",
			"Scribbles",
		},
	},
}

local normalizedEntityAliases = {}

for _, entity in ipairs(entities) do
	for _, alias in ipairs(entity.Aliases) do
		table.insert(
			normalizedEntityAliases,
			{
				Name = entity.Display,
				Alias = normalizeName(alias),
			}
		)
	end
end

local function identifyEntity(name)
	local normalized =
		normalizeName(name)

	for _, entry in ipairs(
		normalizedEntityAliases
	) do

		if normalized == entry.Alias then
			return entry.Name
		end

		-- Only fuzzy-match reasonably similar
		-- length names to reduce false warnings.

		if
			math.abs(
				#normalized - #entry.Alias
			)
			<= 2
		then
			local distance =
				levenshtein(
					normalized,
					entry.Alias
				)

			if distance <= 2 then
				return entry.Name
			end
		end
	end

	return nil
end

----------------------------------------------------------------
-- WARNING GUI
----------------------------------------------------------------

local warningFrame = Instance.new("Frame")
warningFrame.Size = UDim2.fromOffset(500, 75)

warningFrame.Position =
	UDim2.new(
		0.5,
		-250,
		0.02,
		0
	)

warningFrame.BackgroundColor3 =
	Color3.fromRGB(
		100,
		20,
		20
	)

warningFrame.BorderSizePixel = 0
warningFrame.Visible = false
warningFrame.Parent = gui

local warningCorner =
	Instance.new("UICorner")

warningCorner.CornerRadius =
	UDim.new(0, 10)

warningCorner.Parent =
	warningFrame

local warningStroke =
	Instance.new("UIStroke")

warningStroke.Color =
	Color3.fromRGB(
		255,
		90,
		90
	)

warningStroke.Thickness = 3
warningStroke.Parent = warningFrame

local warningText =
	Instance.new("TextLabel")

warningText.Size =
	UDim2.fromScale(1, 1)

warningText.BackgroundTransparency = 1

warningText.TextColor3 =
	Color3.fromRGB(
		255,
		230,
		220
	)

warningText.TextScaled = true
warningText.Font =
	Enum.Font.GothamBlack

warningText.Parent =
	warningFrame

local warningID = 0

local function showWarning(entityName)
	if not entityWarningsEnabled then
		return
	end

	warningID += 1

	local thisWarning =
		warningID

	warningText.Text =
		entityName
		.. " is moving!"

	warningFrame.Visible = true

	task.delay(4, function()
		if
			thisWarning
			==
			warningID
		then
			warningFrame.Visible = false
		end
	end)
end

----------------------------------------------------------------
-- WATCH FOR ENTITIES
----------------------------------------------------------------

local warnedInstances = {}

local function inspectEntityObject(object)
	if warnedInstances[object] then
		return
	end

	local entity =
		identifyEntity(object.Name)

	if entity then
		warnedInstances[object] = true
		showWarning(entity)
	end
end

for _, object in ipairs(
	Workspace:GetDescendants()
) do
	inspectEntityObject(object)
end

Workspace.DescendantAdded:Connect(
	function(object)

		task.defer(function()
			inspectEntityObject(object)
		end)

	end
)

Workspace.DescendantRemoving:Connect(
	function(object)

		warnedInstances[object] = nil

	end
)

----------------------------------------------------------------
-- INFINITE JUMP
----------------------------------------------------------------

local jumpButton =
	makeButton("Infinite Jump: OFF")

jumpButton.MouseButton1Click:Connect(function()
	settings.InfiniteJump =
		not settings.InfiniteJump

	updateToggleButton(
		jumpButton,
		"Infinite Jump",
		settings.InfiniteJump
	)
end)

----------------------------------------------------------------
-- Calculate velocity required to rise ~25 studs.
--
-- v = sqrt(2gh)
--
-- Roblox default gravity is usually 196.2,
-- but using Workspace.Gravity makes it work
-- with custom gravity too.
----------------------------------------------------------------

local function getJumpVelocity()
	local height =
		settings.JumpHeightStuds

	local gravity =
		Workspace.Gravity

	return math.sqrt(
		2
		*
		gravity
		*
		height
	)
end

UserInputService.JumpRequest:Connect(function()
	if not settings.InfiniteJump then
		return
	end

	if
		not rootPart
		or not humanoid
		or humanoid.Health <= 0
	then
		return
	end

	local currentVelocity =
		rootPart.AssemblyLinearVelocity

	rootPart.AssemblyLinearVelocity =
		Vector3.new(
			currentVelocity.X,
			getJumpVelocity(),
			currentVelocity.Z
		)

	humanoid:ChangeState(
		Enum.HumanoidStateType.Jumping
	)
end)

----------------------------------------------------------------
-- ITEM ESP
----------------------------------------------------------------

local itemESPButton =
	makeButton("Item ESP: OFF")

----------------------------------------------------------------
-- ITEM DATABASE
----------------------------------------------------------------

local itemNames = {
	"STARLIGHT BOTTLE",
	"BATTERY PACK",
	"STRAPLIGHT",
	"SKELETON KEY",
	"LOCKPICK",
	"LASER POINTER",
	"SHEARS",
	"FLASHLIGHT",
	"SMOOTHIE",
	"MULTITOOL",
	"CRUCIFIX",
	"VITAMINS",
	"PIZZA",
	"MINI-SHIELD POTION",
	"SHIELD POTION",
	"BATTERIES",
	"BANDAGES",
	"GREEN HERB",
	"GLITCH FRAGMENT",
	"ELECTRICAL ROOM KEY",
	"BOOK",
	"HOTEL KEY",
	"BREAKER POLE",
	"FUSE",
	"DONUT",
	"GWEEN SODA",
	"BREAD",
	"CHEESE",
	"BANDAGE PACK",
	"STARLIGHT VIAL",
	"ALARM CLOCK",
	"BULKLIGHT",
	"CANDLE",
	"GLOWSTICK",
	"RETRO KEY",
	"HOLY HAND GRENADE",
	"LIGHTER",
}

----------------------------------------------------------------
-- EXTRA ALIASES / MISSPELLINGS
----------------------------------------------------------------

local extraItemAliases = {

	-- LIGHTER
	["LITER"] = "LIGHTER",
	["LIGTER"] = "LIGHTER",
	["LIGHER"] = "LIGHTER",
	["LIGHTER"] = "LIGHTER",
	["LIGHHTER"] = "LIGHTER",
	["LIGTHER"] = "LIGHTER",
	["LIGHETR"] = "LIGHTER",

	-- SCRATCH/FORMAT VARIANTS
	["STARLIGHTBOTTLE"] =
		"STARLIGHT BOTTLE",

	["BATTERYPACK"] =
		"BATTERY PACK",

	["SKELETONKEY"] =
		"SKELETON KEY",

	["LASERPOINTER"] =
		"LASER POINTER",

	["MINISHIELDPOTION"] =
		"MINI-SHIELD POTION",

	["SHIELDPOTION"] =
		"SHIELD POTION",

	["GREENHERB"] =
		"GREEN HERB",

	["GLITCHFRAGMENT"] =
		"GLITCH FRAGMENT",

	["ELECTRICALROOMKEY"] =
		"ELECTRICAL ROOM KEY",

	["HOTELKEY"] =
		"HOTEL KEY",

	["BREAKERPOLE"] =
		"BREAKER POLE",

	["BANDAGEPACK"] =
		"BANDAGE PACK",

	["STARLIGHTVIAL"] =
		"STARLIGHT VIAL",

	["ALARMCLOCK"] =
		"ALARM CLOCK",

	["RETROKEY"] =
		"RETRO KEY",

	["HOLYHANDGRENADE"] =
		"HOLY HAND GRENADE",

	["GWEENSODA"] =
		"GWEEN SODA",

	-- common "green soda" variation
	["GREENSODA"] =
		"GWEEN SODA",
}

----------------------------------------------------------------
-- NORMALIZED ITEM LOOKUP
----------------------------------------------------------------

local itemLookup = {}

for _, itemName in ipairs(itemNames) do
	itemLookup[
		normalizeName(itemName)
	] = itemName
end

for alias, realName in pairs(
	extraItemAliases
) do
	itemLookup[
		normalizeName(alias)
	] = realName
end

----------------------------------------------------------------
-- FUZZY ITEM MATCHING
----------------------------------------------------------------

local function identifyItem(name)
	local normalized =
		normalizeName(name)

	local exact =
		itemLookup[normalized]

	if exact then
		return exact
	end

	-- Use fuzzy spelling matching,
	-- but only for sufficiently long names.
	if #normalized < 5 then
		return nil
	end

	local bestMatch = nil
	local bestDistance = math.huge

	for alias, displayName in pairs(
		itemLookup
	) do

		if
			math.abs(
				#normalized - #alias
			)
			<= 2
		then

			local distance =
				levenshtein(
					normalized,
					alias
				)

			if distance < bestDistance then
				bestDistance = distance
				bestMatch = displayName
			end
		end
	end

	if bestDistance <= 2 then
		return bestMatch
	end

	return nil
end

----------------------------------------------------------------
-- ESP STORAGE
----------------------------------------------------------------

local activeESP = {}

local function getObjectPart(object)
	if object:IsA("BasePart") then
		return object
	end

	if object:IsA("Tool") then
		return object:FindFirstChildWhichIsA(
			"BasePart",
			true
		)
	end

	if object:IsA("Model") then
		if object.PrimaryPart then
			return object.PrimaryPart
		end

		return object:FindFirstChildWhichIsA(
			"BasePart",
			true
		)
	end

	return nil
end

----------------------------------------------------------------
-- CREATE ESP
----------------------------------------------------------------

local function createESP(
	object,
	displayName
)

	if activeESP[object] then
		return
	end

	local part =
		getObjectPart(object)

	if not part then
		return
	end

	------------------------------------------------------------
	-- HIGHLIGHT
	------------------------------------------------------------

	local highlight =
		Instance.new("Highlight")

	highlight.Name =
		"ArchivesItemESP"

	highlight.Adornee =
		object

	highlight.DepthMode =
		Enum.HighlightDepthMode.AlwaysOnTop

	highlight.FillTransparency = 0.65
	highlight.OutlineTransparency = 0

	highlight.Parent = gui

	------------------------------------------------------------
	-- BILLBOARD
	------------------------------------------------------------

	local billboard =
		Instance.new("BillboardGui")

	billboard.Name =
		"ArchivesItemLabel"

	billboard.Adornee = part

	billboard.Size =
		UDim2.fromOffset(
			230,
			55
		)

	billboard.StudsOffset =
		Vector3.new(
			0,
			2.5,
			0
		)

	billboard.AlwaysOnTop = true
	billboard.Parent = gui

	local label =
		Instance.new("TextLabel")

	label.Size =
		UDim2.fromScale(1, 1)

	label.BackgroundColor3 =
		Color3.fromRGB(
			20,
			17,
			14
		)

	label.BackgroundTransparency =
		0.2

	label.TextColor3 =
		Color3.fromRGB(
			255,
			233,
			176
		)

	label.TextStrokeTransparency =
		0.4

	label.TextScaled = true

	label.Font =
		Enum.Font.GothamBold

	label.Parent =
		billboard

	local labelCorner =
		Instance.new("UICorner")

	labelCorner.CornerRadius =
		UDim.new(0, 6)

	labelCorner.Parent =
		label

	activeESP[object] = {
		Highlight = highlight,
		Billboard = billboard,
		Label = label,
		Part = part,
		DisplayName = displayName,
	}
end

----------------------------------------------------------------
-- REMOVE ESP
----------------------------------------------------------------

local function removeESP(object)
	local data =
		activeESP[object]

	if not data then
		return
	end

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

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

	activeESP[object] = nil
end

local function clearAllESP()
	local objects = {}

	for object in pairs(activeESP) do
		table.insert(objects, object)
	end

	for _, object in ipairs(objects) do
		removeESP(object)
	end
end

----------------------------------------------------------------
-- DETERMINE WHICH INSTANCE COUNTS AS ITEM
----------------------------------------------------------------

local function inspectItem(object)
	if activeESP[object] then
		return
	end

	-- Prefer Tools and Models because otherwise every
	-- child part of a model could get its own label.

	if
		not object:IsA("Tool")
		and not object:IsA("Model")
		and not object:IsA("BasePart")
	then
		return
	end

	-- Don't tag pieces nested inside a Tool/Model that is
	-- already recognized as the actual item.

	local parent =
		object.Parent

	if parent then
		if
			parent:IsA("Tool")
			or parent:IsA("Model")
		then

			if identifyItem(parent.Name) then
				return
			end
		end
	end

	local itemName =
		identifyItem(object.Name)

	if itemName then
		createESP(
			object,
			itemName
		)
	end
end

----------------------------------------------------------------
-- SCAN ITEMS
----------------------------------------------------------------

local function scanItems()
	if not settings.ItemESP then
		return
	end

	for _, object in ipairs(
		Workspace:GetDescendants()
	) do
		inspectItem(object)
	end
end

----------------------------------------------------------------
-- UPDATE DISTANCES
----------------------------------------------------------------

local function updateESPDistances()
	if not rootPart then
		return
	end

	local removeList = {}

	for object, data in pairs(
		activeESP
	) do

		if
			not object.Parent
			or not data.Part
			or not data.Part.Parent
		then
			table.insert(
				removeList,
				object
			)
		else
			local distance =
				(
					rootPart.Position
					-
					data.Part.Position
				).Magnitude

			data.Label.Text =
				data.DisplayName
				.. "\n"
				.. tostring(
					math.floor(
						distance + 0.5
					)
				)
				.. " studs"
		end
	end

	for _, object in ipairs(removeList) do
		removeESP(object)
	end
end

----------------------------------------------------------------
-- ESP BUTTON
----------------------------------------------------------------

itemESPButton.MouseButton1Click:Connect(function()
	settings.ItemESP =
		not settings.ItemESP

	updateToggleButton(
		itemESPButton,
		"Item ESP",
		settings.ItemESP
	)

	if settings.ItemESP then
		scanItems()
		updateESPDistances()
	else
		clearAllESP()
	end
end)

----------------------------------------------------------------
-- WATCH FOR NEW ITEMS
----------------------------------------------------------------

Workspace.DescendantAdded:Connect(function(object)
	if not settings.ItemESP then
		return
	end

	task.defer(function()
		inspectItem(object)
	end)
end)

Workspace.DescendantRemoving:Connect(
	function(object)

		if activeESP[object] then
			removeESP(object)
		end

	end
)

----------------------------------------------------------------
-- UPDATE ESP EVERY 2 SECONDS
----------------------------------------------------------------

task.spawn(function()
	while gui.Parent do
		if settings.ItemESP then
			scanItems()
			updateESPDistances()
		end

		task.wait(
			settings.ESPUpdateRate
		)
	end
end)

----------------------------------------------------------------
-- KEEP SPEED APPLIED
----------------------------------------------------------------

task.spawn(function()
	while gui.Parent do
		if
			humanoid
			and humanoid.Parent
			and humanoid.WalkSpeed
				~= settings.WalkSpeed
		then
			humanoid.WalkSpeed =
				settings.WalkSpeed
		end

		task.wait(0.5)
	end
end)

----------------------------------------------------------------
-- INITIAL SLIDER LOCATION
----------------------------------------------------------------

task.defer(function()
	setSpeedFromX(
		sliderBar.AbsolutePosition.X
	)
end)

----------------------------------------------------------------
-- OPTIONAL GUI DRAGGING
----------------------------------------------------------------

local draggingWindow = false
local dragStart
local startPosition

title.InputBegan:Connect(function(input)
	if
		input.UserInputType
		== Enum.UserInputType.MouseButton1
	then
		draggingWindow = true
		dragStart = input.Position
		startPosition = frame.Position
	end
end)

UserInputService.InputChanged:Connect(function(input)
	if not draggingWindow then
		return
	end

	if
		input.UserInputType
		~= Enum.UserInputType.MouseMovement
	then
		return
	end

	local delta =
		input.Position - dragStart

	frame.Position =
		UDim2.new(
			startPosition.X.Scale,
			startPosition.X.Offset
				+ delta.X,

			startPosition.Y.Scale,
			startPosition.Y.Offset
				+ delta.Y
		)
end)

UserInputService.InputEnded:Connect(function(input)
	if
		input.UserInputType
		== Enum.UserInputType.MouseButton1
	then
		draggingWindow = false
	end
end)

print(
	"[Doors Archives Hub] Loaded successfully."
)