AI MADED Open source Esp and grab all loot

local Library = loadstring(game:HttpGet("https://raw.githubusercontent.com/riccohiyelo-alt/library/refs/heads/main/Library.lua"))()
if type(Library) ~= "table" then
	return
end

if type(Library.Folders) == "table" then
	Library.Folders.Directory = "NeverPaste"
	Library.Folders.Configs = "NeverPaste/Configs"
	Library.Folders.Themes = "NeverPaste/Themes"
	Library.Folders.Assets = "NeverPaste/Assets"
end

local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ReplicatedFirst = game:GetService("ReplicatedFirst")
local ScriptContext = game:GetService("ScriptContext")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local LocalPlayer = Players.LocalPlayer

local Window = Library:Window({
	Logo = "77218680285262",
	FadeTime = 0.3,
	Size = UDim2.new(0, 980, 0, 650),
	Draggable = true,
	Resizeable = true,
})

local Watermark = Library:Watermark("NeverPaste | Menu")
local KeybindList = Library:KeybindList()

Window:Page({ Name = "Rage", Columns = 2 })
Window:Page({ Name = "Aim", Columns = 2 })
local VisualPage = Window:Page({ Name = "Visual", Columns = 2 })
local ItemsPage = Window:Page({ Name = "Items", Columns = 1 })
Window:Page({ Name = "World", Columns = 2 })
Window:Page({ Name = "Misc", Columns = 2 })
Library:CreateSettingsPage(Window, Watermark, KeybindList)

local function num(v, fallback, minV, maxV)
	local n = tonumber(v)
	if type(n) ~= "number" or n ~= n or n == math.huge or n == -math.huge then
		n = fallback
	end
	if minV then
		n = math.max(minV, n)
	end
	if maxV then
		n = math.min(maxV, n)
	end
	return n
end

local CHAMS_MATERIAL_OPTIONS = { "ForceField", "SmoothPlastic", "Neon", "Glass" }
local CHAMS_MATERIAL_ENUM_BY_LABEL = {
	ForceField = Enum.Material.ForceField,
	SmoothPlastic = Enum.Material.SmoothPlastic,
	Neon = Enum.Material.Neon,
	Glass = Enum.Material.Glass,
}

local function getChamsMaterialFromLabel(label, fallback)
	return CHAMS_MATERIAL_ENUM_BY_LABEL[tostring(label or "")] or fallback or Enum.Material.ForceField
end

local function normalizeName(value)
	return string.lower((tostring(value or ""):gsub("%s+", "")))
end

local function findChildLoose(parent, wanted)
	if not parent then
		return nil
	end
	local wn = normalizeName(wanted)
	for _, child in ipairs(parent:GetChildren()) do
		if normalizeName(child.Name) == wn then
			return child
		end
	end
	return nil
end

local function getChunkDataFolder()
	local chunking = ReplicatedStorage:FindFirstChild("Chunking")
		or ReplicatedStorage:FindFirstChild("chunking")
		or findChildLoose(ReplicatedStorage, "Chunking")
	if not chunking then
		return nil
	end
	return chunking:FindFirstChild("chunk data")
		or chunking:FindFirstChild("ChunkData")
		or chunking:FindFirstChild("chunkdata")
		or findChildLoose(chunking, "chunk data")
			or findChildLoose(chunking, "chunkdata")
end

local FrameworkCache = {
	Entities = nil,
	Network = nil,
	Initialized = false,
}

local function getEntitiesLibrary()
	if FrameworkCache.Entities then
		return FrameworkCache.Entities
	end
	local frameworkModule = ReplicatedFirst:FindFirstChild("Framework")
	if not frameworkModule then
		return nil
	end
	local ok, framework = pcall(require, frameworkModule)
	if not ok or type(framework) ~= "table" then
		return nil
	end
	if not FrameworkCache.Initialized and type(framework.WaitForLoaded) == "function" then
		pcall(function()
			framework:WaitForLoaded()
		end)
	end
	FrameworkCache.Initialized = true
	local entities = framework.Libraries and framework.Libraries.Entities
	if entities then
		FrameworkCache.Entities = entities
	end
	return FrameworkCache.Entities
end

local function getNetworkLibrary()
	if FrameworkCache.Network then
		return FrameworkCache.Network
	end
	local frameworkModule = ReplicatedFirst:FindFirstChild("Framework")
	if not frameworkModule then
		return nil
	end
	local ok, framework = pcall(require, frameworkModule)
	if not ok or type(framework) ~= "table" then
		return nil
	end
	if not FrameworkCache.Initialized and type(framework.WaitForLoaded) == "function" then
		pcall(function()
			framework:WaitForLoaded()
		end)
	end
	FrameworkCache.Initialized = true
	local network = framework.Libraries and framework.Libraries.Network
	if network then
		FrameworkCache.Network = network
	end
	return FrameworkCache.Network
end

local function getCharsRoot()
	return Workspace:FindFirstChild("Characters") or Workspace:FindFirstChild("characters")
end

local function getCam()
	return Workspace.CurrentCamera
end

local function getHum(model)
	if not model then
		return nil
	end
	local hum = model:FindFirstChild("Humanoid")
	if hum and hum:IsA("Humanoid") then
		return hum
	end
	return model:FindFirstChildOfClass("Humanoid")
end

local function getRoot(model)
	if not model then
		return nil
	end
	return model:FindFirstChild("HumanoidRootPart")
		or model:FindFirstChild("UpperTorso")
		or model:FindFirstChild("Torso")
end

local function getWeaponName(model)
	if not model then
		return "-"
	end
	local animator = model:FindFirstChild("Animator") or model:FindFirstChild("animations") or model:FindFirstChild("Animations")
	if not animator then
		return "-"
	end
	local equipped = animator:FindFirstChild("EquippedItem") or animator:FindFirstChild("Equipeditem")
	if not (equipped and equipped:IsA("StringValue")) then
		return "-"
	end
	local raw = tostring(equipped.Value or "")
	if raw == "" then
		return "-"
	end
	local name = raw:match('"ItemName"%s*:%s*"([^"]+)"')
		or raw:match('"itemName"%s*:%s*"([^"]+)"')
		or raw:match('"WeaponName"%s*:%s*"([^"]+)"')
		or raw:match('"weaponName"%s*:%s*"([^"]+)"')
	if type(name) == "string" and name ~= "" then
		return name
	end
	return "-"
end

local BODY_PART_CORE = {
	Head = true,
	HumanoidRootPart = true,
	UpperTorso = true,
	LowerTorso = true,
	Torso = true,
	LeftUpperArm = true,
	LeftLowerArm = true,
	LeftHand = true,
	RightUpperArm = true,
	RightLowerArm = true,
	RightHand = true,
	LeftUpperLeg = true,
	LeftLowerLeg = true,
	LeftFoot = true,
	RightUpperLeg = true,
	RightLowerLeg = true,
	RightFoot = true,
	["Left Arm"] = true,
	["Right Arm"] = true,
	["Left Leg"] = true,
	["Right Leg"] = true,
}

local function collectTargets(config)
	local cam = getCam()
	if not cam then
		return {}
	end
	local camPos = cam.CFrame.Position
	local out = {}
	local root = getCharsRoot()
	if not root then
		return out
	end

	local localTeam = (LocalPlayer.Team and LocalPlayer.Team.Name) or LocalPlayer:GetAttribute("Team")
	for _, model in ipairs(root:GetChildren()) do
		if model:IsA("Model") and string.lower(model.Name) == "startercharacter" and model ~= LocalPlayer.Character then
			local hum = getHum(model)
			local rootPart = getRoot(model)
			if hum and rootPart then
				local team = model:GetAttribute("Team")
				if not (config.TeamCheck and localTeam and team and tostring(localTeam) == tostring(team)) then
					local distance = (camPos - rootPart.Position).Magnitude
					if distance <= config.ESPDistance then
						table.insert(out, {
							Key = model,
							Character = model,
							Humanoid = hum,
							Root = rootPart,
							Distance = distance,
							WeaponName = getWeaponName(model),
						})
					end
				end
			end
		end
	end
	return out
end

local ESP = {
	Config = {
		TeamCheck = false,
		ESPDistance = 1000,
		BoxColor = Color3.fromRGB(103, 89, 179),
		BoxGradientEnabled = false,
		BoxGradientColor1 = Color3.fromRGB(103, 89, 179),
		BoxGradientColor2 = Color3.fromRGB(204, 102, 255),
		BoxFillTransparency = 0.5,
		RotateSpeed = 120,
		BoxOutlineEnabled = true,
		BoxOutlineColor = Color3.new(0, 0, 0),
		SkeletonColor = Color3.fromRGB(103, 89, 179),
		TracerOrigin = "Bottom Screen",
		TracerColor = Color3.fromRGB(103, 89, 179),
		ChamsColor = Color3.fromRGB(103, 89, 179),
		ChamsFillTransparency = 0,
		ChamsMaterial = Enum.Material.ForceField,
		RingColor = Color3.new(1, 1, 1),
		ScanSpeed = 2.5,
		ScanHeight = 3.5,
		RingRadius = 2.5,
	},
	State = {
		BoxEnabled = false,
		WeaponEnabled = false,
		DistanceEnabled = false,
		SkeletonEnabled = false,
		TracerEnabled = false,
		ChamsEnabled = false,
		RingEnabled = false,
	},
	Caches = {
		Box = {},
		Skeleton = {},
		Tracer = {},
		Chams = {},
		Ring = {},
	},
}

local ItemESP = {
	State = {
		Enabled = false,
	},
	Config = {
		Distance = 250,
	},
	Caches = {
		Text = {},
	},
	Runtime = {
		Nodes = {},
		LastRefresh = 0,
	},
}

local LootBoxESP = {
	State = {
		Enabled = false,
	},
	Config = {
		Distance = 250,
	},
	Caches = {
		Text = {},
	},
	Runtime = {
		Entries = {},
		LastRefresh = 0,
	},
}

local function removeDrawing(obj)
	if not obj then
		return
	end
	if typeof(obj) == "Instance" then
		pcall(function()
			obj:Destroy()
		end)
		return
	end
	pcall(function()
		obj:Remove()
	end)
end

local function createBoxCache()
	local t = {
		Box = Drawing.new("Square"),
		Outline = Drawing.new("Square"),
		Fill = Drawing.new("Square"),
		Weapon = Drawing.new("Text"),
		Distance = Drawing.new("Text"),
	}
	t.Box.Filled = false
	t.Box.Thickness = 1
	t.Box.Transparency = 1
	t.Outline.Filled = false
	t.Outline.Thickness = 3
	t.Outline.Transparency = 0.95
	t.Fill.Filled = true
	t.Fill.Thickness = 0
	t.Distance.Size = 13
	t.Distance.Font = 2
	t.Distance.Outline = true
	t.Distance.Center = true
	t.Weapon.Size = 13
	t.Weapon.Font = 2
	t.Weapon.Outline = true
	t.Weapon.Center = true
	return t
end

local function clearBoxCache(c)
	removeDrawing(c.Box)
	removeDrawing(c.Outline)
	removeDrawing(c.Fill)
	removeDrawing(c.Weapon)
	removeDrawing(c.Distance)
end

local function hideBox(c)
	c.Box.Visible = false
	c.Outline.Visible = false
	c.Fill.Visible = false
	c.Weapon.Visible = false
	c.Distance.Visible = false
end

local function createSkeletonCache(model)
	local isR6 = model:FindFirstChild("Torso") and not model:FindFirstChild("UpperTorso")
	local lines = {}
	if isR6 then
		lines.Map = {
			{ "Head", "Torso" },
			{ "Torso", "Left Arm" },
			{ "Torso", "Right Arm" },
			{ "Torso", "Left Leg" },
			{ "Torso", "Right Leg" },
		}
	else
		lines.Map = {
			{ "Head", "UpperTorso" },
			{ "UpperTorso", "LowerTorso" },
			{ "UpperTorso", "LeftUpperArm" },
			{ "LeftUpperArm", "LeftLowerArm" },
			{ "LeftLowerArm", "LeftHand" },
			{ "UpperTorso", "RightUpperArm" },
			{ "RightUpperArm", "RightLowerArm" },
			{ "RightLowerArm", "RightHand" },
			{ "LowerTorso", "LeftUpperLeg" },
			{ "LeftUpperLeg", "LeftLowerLeg" },
			{ "LeftLowerLeg", "LeftFoot" },
			{ "LowerTorso", "RightUpperLeg" },
			{ "RightUpperLeg", "RightLowerLeg" },
			{ "RightLowerLeg", "RightFoot" },
		}
	end
	lines.Draw = {}
	for i = 1, #lines.Map do
		local l = Drawing.new("Line")
		l.Thickness = 1.5
		l.Visible = false
		lines.Draw[i] = l
	end
	return lines
end

local function createTracerCache()
	local l = Drawing.new("Line")
	l.Thickness = 1
	l.Visible = false
	return l
end

local function createItemTextCache()
	local t = Drawing.new("Text")
	t.Size = 13
	t.Font = 2
	t.Outline = true
	t.Center = true
	t.Color = Color3.new(1, 1, 1)
	t.Visible = false
	return t
end

local function refreshItemNodeCache()
	if tick() - ItemESP.Runtime.LastRefresh < 0.35 then
		return
	end
	ItemESP.Runtime.LastRefresh = tick()
	local chunkData = getChunkDataFolder()
	local nodes = {}
	if chunkData then
		for _, obj in ipairs(chunkData:GetDescendants()) do
			if obj.Name == "ItemNodeBin" and obj:IsA("CFrameValue") then
				nodes[obj] = "NodeBin"
			end
		end
	end
	local map = Workspace:FindFirstChild("Map")
	local elements = map and map:FindFirstChild("Elements")
	if elements then
		for _, element in ipairs(elements:GetChildren()) do
			local detail = element:FindFirstChild("Detail", true)
			if detail then
				for _, instance in ipairs(detail:GetChildren()) do
					if instance:IsA("Model") and instance.Name == "Model" then
						nodes[instance] = "DetailModel"
					end
				end
			end
		end
	end
	ItemESP.Runtime.Nodes = nodes
end

local function getItemEspWorldPosition(instance, sourceType)
	if not (instance and instance.Parent) then
		return nil
	end
	if sourceType == "NodeBin" then
		if instance:IsA("CFrameValue") and typeof(instance.Value) == "CFrame" then
			return instance.Value.Position
		end
		return nil
	end
	if sourceType == "DetailModel" then
		if instance:IsA("Model") then
			local okPivot, pivot = pcall(function()
				return instance:GetPivot()
			end)
			if okPivot and typeof(pivot) == "CFrame" then
				return pivot.Position
			end
		end
		return nil
	end
	return nil
end

local function getLootWorldPosition(instance)
	if not (instance and instance.Parent) then
		return nil
	end
	if instance:IsA("BasePart") then
		return instance.Position
	end
	if instance:IsA("Attachment") then
		return instance.WorldPosition
	end
	if instance:IsA("CFrameValue") then
		return instance.Value.Position
	end
	if instance:IsA("Model") then
		local primary = instance.PrimaryPart or instance:FindFirstChildWhichIsA("BasePart", true)
		if primary then
			return primary.Position
		end
		local okPivot, pivot = pcall(function()
			return instance:GetPivot()
		end)
		if okPivot and typeof(pivot) == "CFrame" then
			return pivot.Position
		end
	end
	local ancestorPart = instance:FindFirstAncestorWhichIsA("BasePart")
	if ancestorPart then
		return ancestorPart.Position
	end
	local ancestorModel = instance:FindFirstAncestorOfClass("Model")
	if ancestorModel then
		local primary = ancestorModel.PrimaryPart or ancestorModel:FindFirstChildWhichIsA("BasePart", true)
		if primary then
			return primary.Position
		end
		local okPivot, pivot = pcall(function()
			return ancestorModel:GetPivot()
		end)
		if okPivot and typeof(pivot) == "CFrame" then
			return pivot.Position
		end
	end
	return nil
end

local function refreshLootBoxCache()
	if tick() - LootBoxESP.Runtime.LastRefresh < 0.35 then
		return
	end
	LootBoxESP.Runtime.LastRefresh = tick()
	local entries = {}
	local entities = getEntitiesLibrary()
	local map = Workspace:FindFirstChild("Map")
	local elements = map and map:FindFirstChild("Elements")
	if not (entities and type(entities.Search) == "function" and elements) then
		LootBoxESP.Runtime.Entries = entries
		return
	end
	for _, element in ipairs(elements:GetChildren()) do
		local detail = element:FindFirstChild("Detail", true)
		if detail then
			for _, instance in ipairs(detail:GetChildren()) do
				local ok, entity = pcall(function()
					return entities:Search(instance)
				end)
				if ok and entity and entity.Type == "Loot Group" then
					entries[instance] = {
						Instance = instance,
						Id = entity.Id,
					}
				end
			end
		end
	end
	LootBoxESP.Runtime.Entries = entries
end

local GrabAllRuntime = {
	Running = false,
	HoldActive = false,
	LastRunAt = 0,
	MinInterval = 0.35,
	ErrorHooksSuppressed = false,
}

local function suppressScriptContextErrorHooksOnce()
	if GrabAllRuntime.ErrorHooksSuppressed then
		return
	end
	GrabAllRuntime.ErrorHooksSuppressed = true
	task.spawn(function()
		local ok, err = pcall(function()
			if type(getconnections) ~= "function" then
				return
			end
			local connections = getconnections(ScriptContext.Error)
			if type(connections) ~= "table" then
				return
			end
			for _, connection in ipairs(connections) do
				if connection and type(connection.Disconnect) == "function" then
					connection:Disconnect()
				end
			end
		end)
		if not ok then
			warn(err)
		end
	end)
end

local function runGrabAllInteractOnce()
	local now = tick()
	if GrabAllRuntime.Running then
		return
	end
	if (now - GrabAllRuntime.LastRunAt) < GrabAllRuntime.MinInterval then
		return
	end
	GrabAllRuntime.Running = true
	GrabAllRuntime.LastRunAt = now
	task.spawn(function()
		local ok, err = pcall(function()
			suppressScriptContextErrorHooksOnce()
			local entities = getEntitiesLibrary()
			local network = getNetworkLibrary()
			local map = Workspace:FindFirstChild("Map")
			local elements = map and map:FindFirstChild("Elements")
			if not (entities and network and elements) then
				return
			end
			if type(entities.Search) ~= "function" or type(network.Send) ~= "function" then
				return
			end
			local sentIds = {}
			local ops = 0
			for _, element in pairs(elements:GetChildren()) do
				local detail = element:FindFirstChild("Detail", true)
				if detail then
					for _, instance in pairs(detail:GetChildren()) do
						local okSearch, entity = pcall(function()
							return entities:Search(instance)
						end)
						if okSearch and entity and entity.Type == "Loot Group" and entity.Id and not sentIds[entity.Id] then
							sentIds[entity.Id] = true
							pcall(function()
								network:Send("Client Interacted", entity.Id)
							end)
						end
						ops = ops + 1
						if ops % 40 == 0 then
							task.wait()
						end
					end
				end
			end
		end)
		GrabAllRuntime.Running = false
		if not ok then
			warn(err)
		end
	end)
end

local function createRingCache()
	local holder = Instance.new("Part")
	holder.Transparency = 1
	holder.Anchored = true
	holder.CanCollide = false
	holder.CanTouch = false
	holder.CanQuery = false
	holder.Parent = Workspace
	local ring = Instance.new("CylinderHandleAdornment")
	ring.Adornee = holder
	ring.AlwaysOnTop = true
	ring.ZIndex = 10
	ring.Height = 0.08
	ring.CFrame = CFrame.Angles(math.rad(90), 0, 0)
	ring.Parent = holder
	ring.Visible = false
	return { Holder = holder, Ring = ring, Root = nil }
end

local function ensureProjectionBounds(model, rootPart, cam)
	local minX, minY = math.huge, math.huge
	local maxX, maxY = -math.huge, -math.huge
	local any = false
	for _, part in ipairs(model:GetDescendants()) do
		if part:IsA("BasePart") and BODY_PART_CORE[part.Name] then
			local p, on = cam:WorldToViewportPoint(part.Position)
			if p.Z > 0 then
				minX = math.min(minX, p.X)
				maxX = math.max(maxX, p.X)
				minY = math.min(minY, p.Y)
				maxY = math.max(maxY, p.Y)
				if on then
					any = true
				end
			end
		end
	end
	if minX == math.huge then
		local p, on = cam:WorldToViewportPoint(rootPart.Position)
		if p.Z <= 0 then
			return nil
		end
		minX, maxX, minY, maxY, any = p.X - 20, p.X + 20, p.Y - 45, p.Y + 45, on
	end
	if (maxX - minX) < 2 or (maxY - minY) < 2 then
		return nil
	end
	return minX, minY, maxX, maxY, any
end

local function createChamsCache()
	return { Parts = {} }
end

local function applyChamsToPart(cache, part, mat, col, alpha)
	if not cache.Parts[part] then
		cache.Parts[part] = {
			Material = part.Material,
			Color = part.Color,
			LocalTransparencyModifier = part.LocalTransparencyModifier,
			Reflectance = part.Reflectance,
		}
	end
	part.Material = mat
	part.Color = col
	part.Reflectance = 0
	part.LocalTransparencyModifier = alpha
end

local function restoreChamsPart(cache, part)
	local prev = cache.Parts[part]
	if prev and part and part.Parent then
		part.Material = prev.Material
		part.Color = prev.Color
		part.LocalTransparencyModifier = prev.LocalTransparencyModifier
		part.Reflectance = prev.Reflectance
	end
	cache.Parts[part] = nil
end

local rotation = 0
RunService.RenderStepped:Connect(function(dt)
	local cam = getCam()
	if not cam then
		return
	end
	local targets = collectTargets(ESP.Config)
	local active = {}
	for i = 1, #targets do
		active[targets[i].Key] = targets[i]
	end

	for key, cache in pairs(ESP.Caches.Box) do
		if not active[key] then
			clearBoxCache(cache)
			ESP.Caches.Box[key] = nil
		end
	end
	for key, cache in pairs(ESP.Caches.Skeleton) do
		if not active[key] then
			for _, ln in ipairs(cache.Draw) do
				removeDrawing(ln)
			end
			ESP.Caches.Skeleton[key] = nil
		end
	end
	for key, cache in pairs(ESP.Caches.Tracer) do
		if not active[key] then
			removeDrawing(cache)
			ESP.Caches.Tracer[key] = nil
		end
	end
	for key, cache in pairs(ESP.Caches.Chams) do
		if not active[key] then
			for part, _ in pairs(cache.Parts) do
				restoreChamsPart(cache, part)
			end
			ESP.Caches.Chams[key] = nil
		end
	end
		for key, cache in pairs(ESP.Caches.Ring) do
			if not active[key] then
				removeDrawing(cache.Ring)
				removeDrawing(cache.Holder)
				ESP.Caches.Ring[key] = nil
			end
		end
		if not ItemESP.State.Enabled then
			for key, text in pairs(ItemESP.Caches.Text) do
				if text then
					text.Visible = false
				end
				if not key or not key.Parent then
					removeDrawing(text)
					ItemESP.Caches.Text[key] = nil
				end
			end
		end
		if not LootBoxESP.State.Enabled then
			for key, text in pairs(LootBoxESP.Caches.Text) do
				if text then
					text.Visible = false
				end
				if not key or not key.Parent then
					removeDrawing(text)
					LootBoxESP.Caches.Text[key] = nil
				end
			end
		end

		rotation = (rotation - ESP.Config.RotateSpeed * dt) % 360

	for i = 1, #targets do
		local t = targets[i]
		local key, model, root, dist = t.Key, t.Character, t.Root, t.Distance
		local minX, minY, maxX, maxY = ensureProjectionBounds(model, root, cam)
		local boundsOk = (minX ~= nil)

		local box = ESP.Caches.Box[key]
		if not box then
			box = createBoxCache()
			ESP.Caches.Box[key] = box
		end

		if not boundsOk then
			hideBox(box)
		else
			local w, h = (maxX - minX), (maxY - minY)
			local cx = (minX + maxX) * 0.5
			if ESP.State.BoxEnabled then
				box.Box.Position = Vector2.new(minX, minY)
				box.Box.Size = Vector2.new(w, h)
				box.Box.Color = ESP.Config.BoxColor
				box.Box.Visible = true
				box.Outline.Position = Vector2.new(minX, minY)
				box.Outline.Size = Vector2.new(w, h)
				box.Outline.Color = ESP.Config.BoxOutlineColor
				box.Outline.Visible = ESP.Config.BoxOutlineEnabled
				if ESP.Config.BoxGradientEnabled then
					local blend = (math.sin(math.rad(rotation)) + 1) * 0.5
					box.Fill.Position = Vector2.new(minX, minY)
					box.Fill.Size = Vector2.new(w, h)
					box.Fill.Color = ESP.Config.BoxGradientColor1:Lerp(ESP.Config.BoxGradientColor2, blend)
					box.Fill.Transparency = math.clamp(1 - num(ESP.Config.BoxFillTransparency, 0.5, 0, 1), 0, 1)
					box.Fill.Visible = true
				else
					box.Fill.Visible = false
				end
			else
				box.Box.Visible = false
				box.Outline.Visible = false
				box.Fill.Visible = false
			end

			local textOffset = 4
			if ESP.State.WeaponEnabled then
				box.Weapon.Position = Vector2.new(cx, maxY + textOffset)
				box.Weapon.Text = tostring(t.WeaponName or "-")
				box.Weapon.Color = Color3.new(1, 1, 1)
				box.Weapon.Visible = true
				textOffset = textOffset + 14
			else
				box.Weapon.Visible = false
			end

			if ESP.State.DistanceEnabled then
				box.Distance.Position = Vector2.new(cx, maxY + textOffset)
				box.Distance.Text = tostring(math.floor(dist)) .. " studs"
				box.Distance.Color = Color3.new(1, 1, 1)
				box.Distance.Visible = true
			else
				box.Distance.Visible = false
			end
		end

		if ESP.State.SkeletonEnabled then
			local sk = ESP.Caches.Skeleton[key]
			if not sk then
				sk = createSkeletonCache(model)
				ESP.Caches.Skeleton[key] = sk
			end
			for idx = 1, #sk.Map do
				local seg = sk.Map[idx]
				local a = model:FindFirstChild(seg[1])
				local b = model:FindFirstChild(seg[2])
				local line = sk.Draw[idx]
				if a and b then
					local ap, aon = cam:WorldToViewportPoint(a.Position)
					local bp, bon = cam:WorldToViewportPoint(b.Position)
					if aon and bon and ap.Z > 0 and bp.Z > 0 then
						line.From = Vector2.new(ap.X, ap.Y)
						line.To = Vector2.new(bp.X, bp.Y)
						line.Color = ESP.Config.SkeletonColor
						line.Visible = true
					else
						line.Visible = false
					end
				else
					line.Visible = false
				end
			end
		elseif ESP.Caches.Skeleton[key] then
			for _, line in ipairs(ESP.Caches.Skeleton[key].Draw) do
				line.Visible = false
			end
		end

		if ESP.State.TracerEnabled then
			local tr = ESP.Caches.Tracer[key]
			if not tr then
				tr = createTracerCache()
				ESP.Caches.Tracer[key] = tr
			end
			local target = model:FindFirstChild("Head") or root
			local tp, on = cam:WorldToViewportPoint(target.Position)
			local vps = cam.ViewportSize
			local origin = Vector2.new(vps.X * 0.5, vps.Y)
			if ESP.Config.TracerOrigin == "Cursor" then
				origin = UserInputService:GetMouseLocation()
			elseif ESP.Config.TracerOrigin == "Top Screen" then
				origin = Vector2.new(vps.X * 0.5, 0)
			end
			tr.From = origin
			tr.To = Vector2.new(tp.X, tp.Y)
			tr.Color = ESP.Config.TracerColor
			tr.Visible = on
		elseif ESP.Caches.Tracer[key] then
			ESP.Caches.Tracer[key].Visible = false
		end

		if ESP.State.ChamsEnabled then
			local cc = ESP.Caches.Chams[key]
			if not cc then
				cc = createChamsCache()
				ESP.Caches.Chams[key] = cc
			end
			local touched = {}
			local mat = ESP.Config.ChamsMaterial
			local col = ESP.Config.ChamsColor
			local alpha = num(ESP.Config.ChamsFillTransparency, 0, 0, 0.9)
			for _, part in ipairs(model:GetDescendants()) do
				if part:IsA("BasePart") and not (part.Parent and part.Parent:IsA("Tool")) then
					applyChamsToPart(cc, part, mat, col, alpha)
					touched[part] = true
				end
			end
			for part, _ in pairs(cc.Parts) do
				if not touched[part] or not part.Parent or not part:IsDescendantOf(model) then
					restoreChamsPart(cc, part)
				end
			end
		elseif ESP.Caches.Chams[key] then
			for part, _ in pairs(ESP.Caches.Chams[key].Parts) do
				restoreChamsPart(ESP.Caches.Chams[key], part)
			end
		end

		if ESP.State.RingEnabled then
			local rc = ESP.Caches.Ring[key]
			if not rc then
				rc = createRingCache()
				ESP.Caches.Ring[key] = rc
			end
			rc.Root = root
			rc.Ring.Color3 = ESP.Config.RingColor
			rc.Ring.InnerRadius = ESP.Config.RingRadius - 0.1
			rc.Ring.Radius = ESP.Config.RingRadius
			rc.Ring.Visible = true
			local bob = math.sin(tick() * ESP.Config.ScanSpeed) * ESP.Config.ScanHeight
			rc.Holder.CFrame = root.CFrame * CFrame.new(0, bob, 0)
			rc.Ring.Transparency = 0.2 + (math.abs(math.sin(tick() * ESP.Config.ScanSpeed)) * 0.4)
			elseif ESP.Caches.Ring[key] then
				ESP.Caches.Ring[key].Ring.Visible = false
			end
		end

		if ItemESP.State.Enabled then
			refreshItemNodeCache()
			local itemActive = {}
			local camPos = cam.CFrame.Position
			for node, sourceType in pairs(ItemESP.Runtime.Nodes) do
				if node and node.Parent then
					local worldPos = getItemEspWorldPosition(node, sourceType)
					if worldPos then
						local dist = (camPos - worldPos).Magnitude
						local text = ItemESP.Caches.Text[node]
						if not text then
							text = createItemTextCache()
							ItemESP.Caches.Text[node] = text
						end
						if dist <= ItemESP.Config.Distance then
							local vp, onScreen = cam:WorldToViewportPoint(worldPos)
							if onScreen and vp.Z > 0 then
								text.Text = "Item"
								text.Position = Vector2.new(vp.X, vp.Y)
								text.Visible = true
								itemActive[node] = true
							else
								text.Visible = false
							end
						else
							text.Visible = false
						end
					end
				end
			end
			for node, text in pairs(ItemESP.Caches.Text) do
				if not itemActive[node] then
					text.Visible = false
				end
				if not node or not node.Parent then
					removeDrawing(text)
					ItemESP.Caches.Text[node] = nil
				end
			end
		end
		if LootBoxESP.State.Enabled then
			refreshLootBoxCache()
			local lootActive = {}
			local camPos = cam.CFrame.Position
			for key, entry in pairs(LootBoxESP.Runtime.Entries) do
				local instance = entry and entry.Instance
				if instance and instance.Parent then
					local worldPos = getLootWorldPosition(instance)
					if worldPos then
						local dist = (camPos - worldPos).Magnitude
						local text = LootBoxESP.Caches.Text[key]
						if not text then
							text = createItemTextCache()
							LootBoxESP.Caches.Text[key] = text
						end
						if dist <= LootBoxESP.Config.Distance then
							local vp, onScreen = cam:WorldToViewportPoint(worldPos)
							if onScreen and vp.Z > 0 then
								text.Text = "LootBox"
								text.Position = Vector2.new(vp.X, vp.Y)
								text.Visible = true
								lootActive[key] = true
							else
								text.Visible = false
							end
						else
							text.Visible = false
						end
					end
				end
			end
			for key, text in pairs(LootBoxESP.Caches.Text) do
				if not lootActive[key] then
					text.Visible = false
				end
				if not key or not key.Parent then
					removeDrawing(text)
					LootBoxESP.Caches.Text[key] = nil
				end
			end
		end
	end)

local function withEsp(callback)
	local ok = pcall(callback, ESP)
	return ok
end

local espSection = VisualPage:Section({ Name = "ESP", Side = 1 })
espSection:Label("ESP loaded")
local chamsSection = VisualPage:Section({ Name = "Chams", Side = 2 })
local itemsSection = ItemsPage:Section({ Name = "Items ESP", Side = 1 })

espSection:Toggle({
	Name = "Box ESP",
	Flag = "EspBox",
	Default = false,
	Callback = function(v)
		withEsp(function(esp)
			esp.State.BoxEnabled = (v == true)
		end)
	end,
})

espSection:Toggle({
	Name = "Team Check",
	Flag = "EspTeamCheck",
	Default = false,
	Callback = function(v)
		withEsp(function(esp)
			esp.Config.TeamCheck = (v == true)
		end)
	end,
})

espSection:Toggle({
	Name = "ESP VSync",
	Flag = "EspVSync",
	Default = true,
	Callback = function(_)
	end,
})

espSection:Label("Box Color"):Colorpicker({
	Name = "Box Color",
	Flag = "EspBoxColor",
	Default = Color3.fromRGB(103, 89, 179),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.BoxColor = v
	end,
})

espSection:Toggle({
	Name = "Box Gradient",
	Flag = "EspBoxGradient",
	Default = false,
	Callback = function(v)
		ESP.Config.BoxGradientEnabled = (v == true)
	end,
})

espSection:Label("Gradient Color 1"):Colorpicker({
	Name = "Gradient Color 1",
	Flag = "EspBoxGrad1",
	Default = Color3.fromRGB(103, 89, 179),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.BoxGradientColor1 = v
	end,
})

espSection:Label("Gradient Color 2"):Colorpicker({
	Name = "Gradient Color 2",
	Flag = "EspBoxGrad2",
	Default = Color3.fromRGB(204, 102, 255),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.BoxGradientColor2 = v
	end,
})

espSection:Slider({
	Name = "Box Fill Transparency",
	Flag = "EspBoxFillTransparency",
	Min = 0,
	Max = 1,
	Default = 0.5,
	Decimals = 0.01,
	Callback = function(v)
		ESP.Config.BoxFillTransparency = num(v, 0.5, 0, 1)
	end,
})

espSection:Toggle({
	Name = "Box Outline",
	Flag = "EspBoxOutline",
	Default = true,
	Callback = function(v)
		ESP.Config.BoxOutlineEnabled = (v == true)
	end,
})

espSection:Label("Box Outline Color"):Colorpicker({
	Name = "Outline Color",
	Flag = "EspBoxOutlineColor",
	Default = Color3.new(0, 0, 0),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.BoxOutlineColor = v
	end,
})

espSection:Toggle({
	Name = "Ring ESP",
	Flag = "EspRing",
	Default = false,
	Callback = function(v)
		ESP.State.RingEnabled = (v == true)
	end,
})

espSection:Label("Ring Color"):Colorpicker({
	Name = "Ring Color",
	Flag = "EspRingColor",
	Default = Color3.new(1, 1, 1),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.RingColor = v
	end,
})

espSection:Toggle({
	Name = "Weapon ESP",
	Flag = "EspWeapon",
	Default = false,
	Callback = function(v)
		ESP.State.WeaponEnabled = (v == true)
	end,
})

espSection:Toggle({
	Name = "Distance ESP",
	Flag = "EspDistance",
	Default = false,
	Callback = function(v)
		ESP.State.DistanceEnabled = (v == true)
	end,
})

espSection:Toggle({
	Name = "Skeleton ESP",
	Flag = "EspSkeleton",
	Default = false,
	Callback = function(v)
		ESP.State.SkeletonEnabled = (v == true)
	end,
})

espSection:Label("Skeleton Color"):Colorpicker({
	Name = "Skeleton Color",
	Flag = "EspSkeletonColor",
	Default = Color3.fromRGB(103, 89, 179),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.SkeletonColor = v
	end,
})

espSection:Toggle({
	Name = "Tracer ESP",
	Flag = "EspTracer",
	Default = false,
	Callback = function(v)
		ESP.State.TracerEnabled = (v == true)
	end,
})

espSection:Label("Tracer ESP Color"):Colorpicker({
	Name = "Tracer ESP Color",
	Flag = "EspTracerColor",
	Default = Color3.fromRGB(103, 89, 179),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.TracerColor = v
	end,
})

espSection:Dropdown({
	Name = "Tracer Origin",
	Flag = "EspTracerOrigin",
	Items = { "Bottom Screen", "Cursor", "Top Screen" },
	Default = "Bottom Screen",
	Multi = false,
	Callback = function(v)
		ESP.Config.TracerOrigin = tostring(v or "Bottom Screen")
	end,
})

chamsSection:Toggle({
	Name = "Chams",
	Flag = "EspChams",
	Default = false,
	Callback = function(v)
		ESP.State.ChamsEnabled = (v == true)
	end,
})

chamsSection:Label("Chams Color"):Colorpicker({
	Name = "Chams Color",
	Flag = "EspChamsFillColor",
	Default = Color3.fromRGB(103, 89, 179),
	Alpha = 0,
	Callback = function(v)
		ESP.Config.ChamsColor = v
	end,
})

chamsSection:Dropdown({
	Name = "Chams Material",
	Flag = "EspChamsMaterial",
	Items = CHAMS_MATERIAL_OPTIONS,
	Default = "ForceField",
	Multi = false,
	Callback = function(v)
		ESP.Config.ChamsMaterial = getChamsMaterialFromLabel(v, Enum.Material.ForceField)
	end,
})

chamsSection:Slider({
	Name = "Extra Transparency",
	Flag = "EspChamsTransparency",
	Min = 0,
	Max = 1,
	Default = 0,
	Decimals = 0.01,
	Callback = function(v)
		ESP.Config.ChamsFillTransparency = num(v, 0, 0, 1)
	end,
})

espSection:Slider({
	Name = "ESP Distance",
	Flag = "EspDistanceLimit",
	Min = 100,
	Max = 1000,
	Default = 1000,
	Decimals = 1,
	Callback = function(v)
		ESP.Config.ESPDistance = num(v, 1000, 100, 1000)
	end,
})

itemsSection:Toggle({
	Name = "Item ESP",
	Flag = "ItemEspEnabled",
	Default = false,
	Callback = function(v)
		ItemESP.State.Enabled = (v == true)
	end,
})

itemsSection:Slider({
	Name = "Item Distance",
	Flag = "ItemEspDistance",
	Min = 1,
	Max = 500,
	Default = 250,
	Decimals = 1,
	Callback = function(v)
		ItemESP.Config.Distance = num(v, 250, 1, 500)
	end,
})

itemsSection:Toggle({
	Name = "LootBox ESP",
	Flag = "LootBoxEspEnabled",
	Default = false,
	Callback = function(v)
		LootBoxESP.State.Enabled = (v == true)
	end,
})

itemsSection:Slider({
	Name = "LootBox Distance",
	Flag = "LootBoxEspDistance",
	Min = 1,
	Max = 500,
	Default = 250,
	Decimals = 1,
	Callback = function(v)
		LootBoxESP.Config.Distance = num(v, 250, 1, 500)
	end,
})

itemsSection:Label("GrabAll Action"):Keybind({
	Name = "GrabAll Action",
	Flag = "GrabAllActionBind",
	Default = Enum.KeyCode.H,
	Mode = "Hold",
	Callback = function(active)
		if active == true then
			if GrabAllRuntime.HoldActive then
				return
			end
			GrabAllRuntime.HoldActive = true
			runGrabAllInteractOnce()
		else
			GrabAllRuntime.HoldActive = false
		end
	end,
})