Simple Open Source Esp

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")

local localPlayer = Players.LocalPlayer
local camera = workspace.CurrentCamera

local BOXES_ENABLED = true
local CHAMS_ENABLED = false
local TRACERS_ENABLED = false

local ESP_COLOR = Color3.fromRGB(0, 255, 100)
local BOX_THICKNESS = 2
local BOX_THICKNESS_MIN = 1
local BOX_THICKNESS_MAX = 12
local BOX_FILL_TRANSPARENCY = 1 -- 1 = hollow outline only

local CHAMS_FILL_TRANSPARENCY = 0.6
local CHAMS_OUTLINE_TRANSPARENCY = 0.2
local TRACER_THICKNESS = 1

local MENU_KEY = Enum.KeyCode.RightShift
local UI_VISIBLE = true

local currentHue = 0.4
local currentSat = 1
local currentVal = 1

local function getESPColor()
	return Color3.fromHSV(currentHue, currentSat, currentVal)
end

ESP_COLOR = getESPColor()

local screenGui = Instance.new("ScreenGui")
screenGui.Name = "PlayerESP"
screenGui.IgnoreGuiInset = true
screenGui.ResetOnSpawn = false
screenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
screenGui.Parent = localPlayer:WaitForChild("PlayerGui")

local BUTTON_HEIGHT = 34
local BUTTON_GAP = 8
local PANEL_PADDING = 12
local TITLE_BLOCK = 46
local BUTTON_COUNT = 4 
local WHEEL_SIZE = 140 
local VALUE_SLIDER_HEIGHT = 16
local COLOR_SECTION_GAP = 10
local THICKNESS_LABEL_HEIGHT = 18
local THICKNESS_SECTION_HEIGHT = THICKNESS_LABEL_HEIGHT + 6 + VALUE_SLIDER_HEIGHT + COLOR_SECTION_GAP
local THICKNESS_COLLAPSED_HEIGHT = THICKNESS_LABEL_HEIGHT + COLOR_SECTION_GAP
local COLOR_SECTION_HEIGHT = 22 + COLOR_SECTION_GAP + WHEEL_SIZE + 8 + VALUE_SLIDER_HEIGHT + 8 + 28

local PANEL_HEIGHT = TITLE_BLOCK
	+ PANEL_PADDING
	+ BUTTON_COUNT * BUTTON_HEIGHT
	+ (BUTTON_COUNT - 1) * BUTTON_GAP
	+ COLOR_SECTION_GAP
	+ THICKNESS_SECTION_HEIGHT
	+ COLOR_SECTION_HEIGHT
	+ PANEL_PADDING
local COLLAPSED_PANEL_HEIGHT = PANEL_HEIGHT - (COLOR_SECTION_HEIGHT - 22)

local panel = Instance.new("Frame")
panel.Name = "TogglePanel"
panel.AnchorPoint = Vector2.new(1, 0)
panel.Position = UDim2.new(1, -16, 0, 16)
panel.Size = UDim2.fromOffset(190, PANEL_HEIGHT)
panel.BackgroundColor3 = Color3.fromRGB(25, 25, 30)
panel.BackgroundTransparency = 0.15
panel.BorderSizePixel = 0
panel.Active = true
panel.ClipsDescendants = true
panel.ZIndex = 10
panel.Visible = UI_VISIBLE
panel.Parent = screenGui

local panelScale = Instance.new("UIScale")
panelScale.Scale = 1
panelScale.Parent = panel

local panelCorner = Instance.new("UICorner")
panelCorner.CornerRadius = UDim.new(0, 10)
panelCorner.Parent = panel

local panelStroke = Instance.new("UIStroke")
panelStroke.Color = Color3.fromRGB(70, 70, 80)
panelStroke.Thickness = 1
panelStroke.Parent = panel

local titleBar = Instance.new("Frame")
titleBar.Name = "TitleBar"
titleBar.Size = UDim2.new(1, 0, 0, TITLE_BLOCK)
titleBar.BackgroundColor3 = Color3.fromRGB(35, 35, 42)
titleBar.BackgroundTransparency = 0.05
titleBar.BorderSizePixel = 0
titleBar.Active = true
titleBar.ZIndex = 11
titleBar.Parent = panel

local titleBarCorner = Instance.new("UICorner")
titleBarCorner.CornerRadius = UDim.new(0, 10)
titleBarCorner.Parent = titleBar

local titleBarBottom = Instance.new("Frame")
titleBarBottom.Name = "TitleBarBottomFill"
titleBarBottom.AnchorPoint = Vector2.new(0, 1)
titleBarBottom.Position = UDim2.fromScale(0, 1)
titleBarBottom.Size = UDim2.new(1, 0, 0, 12)
titleBarBottom.BackgroundColor3 = titleBar.BackgroundColor3
titleBarBottom.BackgroundTransparency = titleBar.BackgroundTransparency
titleBarBottom.BorderSizePixel = 0
titleBarBottom.ZIndex = 11
titleBarBottom.Parent = titleBar

local title = Instance.new("TextLabel")
title.Name = "Title"
title.BackgroundTransparency = 1
title.Position = UDim2.fromOffset(12, 8)
title.Size = UDim2.new(1, -24, 0, 22)
title.Font = Enum.Font.GothamBold
title.Text = "Player ESP"
title.TextColor3 = Color3.fromRGB(240, 240, 245)
title.TextSize = 15
title.TextXAlignment = Enum.TextXAlignment.Left
title.Active = false
title.ZIndex = 12
title.Parent = titleBar

local dragHint = Instance.new("TextLabel")
dragHint.Name = "DragHint"
dragHint.BackgroundTransparency = 1
dragHint.Position = UDim2.fromOffset(12, 28)
dragHint.Size = UDim2.new(1, -24, 0, 14)
dragHint.Font = Enum.Font.Gotham
dragHint.Text = "Drag here to move"
dragHint.TextColor3 = Color3.fromRGB(150, 150, 160)
dragHint.TextSize = 11
dragHint.TextXAlignment = Enum.TextXAlignment.Left
dragHint.Active = false
dragHint.ZIndex = 12
dragHint.Parent = titleBar

local function addClickAnimation(button)
	local scale = Instance.new("UIScale")
	scale.Parent = button

	local function tweenScale(value, duration)
		TweenService:Create(scale, TweenInfo.new(duration, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
			Scale = value,
		}):Play()
	end

	button.MouseButton1Down:Connect(function()
		tweenScale(0.94, 0.08)
	end)
	button.MouseButton1Up:Connect(function()
		tweenScale(1.03, 0.14)
	end)
	button.MouseEnter:Connect(function()
		tweenScale(1.03, 0.14)
	end)
	button.MouseLeave:Connect(function()
		tweenScale(1, 0.14)
	end)
end

local function createToggleButton(name, layoutIndex)
	local y = TITLE_BLOCK + PANEL_PADDING + (layoutIndex - 1) * (BUTTON_HEIGHT + BUTTON_GAP)
	local button = Instance.new("TextButton")
	button.Name = name
	button.Position = UDim2.fromOffset(PANEL_PADDING, y)
	button.Size = UDim2.new(1, -PANEL_PADDING * 2, 0, BUTTON_HEIGHT)
	button.BackgroundColor3 = Color3.fromRGB(160, 50, 50)
	button.BorderSizePixel = 0
	button.Font = Enum.Font.GothamMedium
	button.Text = ""
	button.TextColor3 = Color3.fromRGB(255, 255, 255)
	button.TextSize = 14
	button.AutoButtonColor = true
	button.ZIndex = 11
	button.Parent = panel

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

	return button
end

local boxesButton = createToggleButton("BoxesButton", 1)
local chamsButton = createToggleButton("ChamsButton", 2)
local tracersButton = createToggleButton("TracersButton", 3)
local keybindButton = createToggleButton("KeybindButton", 4)

local thicknessSectionTop = TITLE_BLOCK
	+ PANEL_PADDING
	+ BUTTON_HEIGHT
	+ BUTTON_GAP

chamsButton.Position = UDim2.fromOffset(PANEL_PADDING, thicknessSectionTop + THICKNESS_SECTION_HEIGHT)
tracersButton.Position = UDim2.fromOffset(PANEL_PADDING, thicknessSectionTop + THICKNESS_SECTION_HEIGHT + BUTTON_HEIGHT + BUTTON_GAP)
keybindButton.Position = UDim2.fromOffset(PANEL_PADDING, thicknessSectionTop + THICKNESS_SECTION_HEIGHT + (BUTTON_HEIGHT + BUTTON_GAP) * 2)

local thicknessLabel = Instance.new("TextLabel")
thicknessLabel.Name = "ThicknessLabel"
thicknessLabel.BackgroundTransparency = 1
thicknessLabel.Position = UDim2.fromOffset(PANEL_PADDING, thicknessSectionTop)
thicknessLabel.Size = UDim2.new(1, -PANEL_PADDING * 2, 0, THICKNESS_LABEL_HEIGHT)
thicknessLabel.Font = Enum.Font.GothamBold
thicknessLabel.Text = "Box Thickness: " .. BOX_THICKNESS
thicknessLabel.TextColor3 = Color3.fromRGB(240, 240, 245)
thicknessLabel.TextSize = 14
thicknessLabel.TextXAlignment = Enum.TextXAlignment.Left
thicknessLabel.ZIndex = 11
thicknessLabel.Parent = panel

local thicknessDropdownButton = Instance.new("TextButton")
thicknessDropdownButton.Name = "ThicknessDropdownButton"
thicknessDropdownButton.BackgroundTransparency = 1
thicknessDropdownButton.Position = UDim2.fromOffset(PANEL_PADDING, thicknessSectionTop)
thicknessDropdownButton.Size = UDim2.new(1, -PANEL_PADDING * 2, 0, THICKNESS_LABEL_HEIGHT)
thicknessDropdownButton.Text = ""
thicknessDropdownButton.ZIndex = 10
thicknessDropdownButton.Parent = panel
addClickAnimation(thicknessDropdownButton)

local thicknessDropdownArrow = Instance.new("TextLabel")
thicknessDropdownArrow.Name = "ThicknessDropdownArrow"
thicknessDropdownArrow.BackgroundTransparency = 1
thicknessDropdownArrow.AnchorPoint = Vector2.new(1, 0.5)
thicknessDropdownArrow.Position = UDim2.new(1, -PANEL_PADDING, 0, thicknessSectionTop + THICKNESS_LABEL_HEIGHT * 0.5)
thicknessDropdownArrow.Size = UDim2.fromOffset(16, 18)
thicknessDropdownArrow.Font = Enum.Font.GothamBold
thicknessDropdownArrow.Text = "^"
thicknessDropdownArrow.TextColor3 = Color3.fromRGB(190, 190, 200)
thicknessDropdownArrow.TextSize = 12
thicknessDropdownArrow.ZIndex = 12
thicknessDropdownArrow.Parent = panel

local thicknessSlider = Instance.new("Frame")
thicknessSlider.Name = "ThicknessSlider"
thicknessSlider.Position = UDim2.fromOffset(PANEL_PADDING, thicknessSectionTop + THICKNESS_LABEL_HEIGHT + 6)
thicknessSlider.Size = UDim2.new(1, -PANEL_PADDING * 2, 0, VALUE_SLIDER_HEIGHT)
thicknessSlider.BackgroundColor3 = Color3.fromRGB(45, 45, 55)
thicknessSlider.BorderSizePixel = 0
thicknessSlider.Active = true
thicknessSlider.ZIndex = 11
thicknessSlider.Parent = panel

local thicknessSliderCorner = Instance.new("UICorner")
thicknessSliderCorner.CornerRadius = UDim.new(0, 6)
thicknessSliderCorner.Parent = thicknessSlider

local thicknessFill = Instance.new("Frame")
thicknessFill.Name = "Fill"
thicknessFill.Size = UDim2.fromScale(
	(BOX_THICKNESS - BOX_THICKNESS_MIN) / (BOX_THICKNESS_MAX - BOX_THICKNESS_MIN),
	1
)
thicknessFill.BackgroundColor3 = Color3.fromRGB(0, 170, 80)
thicknessFill.BorderSizePixel = 0
thicknessFill.ZIndex = 12
thicknessFill.Parent = thicknessSlider

local thicknessFillCorner = Instance.new("UICorner")
thicknessFillCorner.CornerRadius = UDim.new(0, 6)
thicknessFillCorner.Parent = thicknessFill

local thicknessKnob = Instance.new("Frame")
thicknessKnob.Name = "ThicknessKnob"
thicknessKnob.AnchorPoint = Vector2.new(0.5, 0.5)
thicknessKnob.Position = UDim2.fromScale(
	(BOX_THICKNESS - BOX_THICKNESS_MIN) / (BOX_THICKNESS_MAX - BOX_THICKNESS_MIN),
	0.5
)
thicknessKnob.Size = UDim2.fromOffset(10, VALUE_SLIDER_HEIGHT + 4)
thicknessKnob.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
thicknessKnob.BorderSizePixel = 0
thicknessKnob.ZIndex = 13
thicknessKnob.Parent = thicknessSlider

local thicknessKnobCorner = Instance.new("UICorner")
thicknessKnobCorner.CornerRadius = UDim.new(0, 4)
thicknessKnobCorner.Parent = thicknessKnob

local thicknessKnobStroke = Instance.new("UIStroke")
thicknessKnobStroke.Color = Color3.fromRGB(40, 40, 45)
thicknessKnobStroke.Thickness = 1
thicknessKnobStroke.Parent = thicknessKnob

local colorSectionTop = keybindButton.Position.Y.Offset + BUTTON_HEIGHT + COLOR_SECTION_GAP

local colorLabel = Instance.new("TextLabel")
colorLabel.Name = "ColorLabel"
colorLabel.BackgroundTransparency = 1
colorLabel.Position = UDim2.fromOffset(PANEL_PADDING, colorSectionTop)
colorLabel.Size = UDim2.new(1, -PANEL_PADDING * 2 - 36, 0, 22)
colorLabel.Font = Enum.Font.GothamBold
colorLabel.Text = "Color"
colorLabel.TextColor3 = Color3.fromRGB(240, 240, 245)
colorLabel.TextSize = 14
colorLabel.TextXAlignment = Enum.TextXAlignment.Left
colorLabel.ZIndex = 12
colorLabel.Parent = panel

local colorPreview = Instance.new("Frame")
colorPreview.Name = "ColorPreview"
colorPreview.AnchorPoint = Vector2.new(1, 0)
colorPreview.Position = UDim2.new(1, -PANEL_PADDING, 0, colorSectionTop)
colorPreview.Size = UDim2.fromOffset(28, 22)
colorPreview.BackgroundColor3 = ESP_COLOR
colorPreview.BorderSizePixel = 0
colorPreview.ZIndex = 12
colorPreview.Parent = panel

local previewCorner = Instance.new("UICorner")
previewCorner.CornerRadius = UDim.new(0, 6)
previewCorner.Parent = colorPreview

local previewStroke = Instance.new("UIStroke")
previewStroke.Color = Color3.fromRGB(200, 200, 210)
previewStroke.Thickness = 1
previewStroke.Parent = colorPreview

local colorDropdownButton = Instance.new("TextButton")
colorDropdownButton.Name = "ColorDropdownButton"
colorDropdownButton.BackgroundTransparency = 1
colorDropdownButton.Position = UDim2.fromOffset(PANEL_PADDING, colorSectionTop)
colorDropdownButton.Size = UDim2.new(1, -PANEL_PADDING * 2, 0, 22)
colorDropdownButton.Text = ""
colorDropdownButton.ZIndex = 11
colorDropdownButton.Parent = panel
addClickAnimation(colorDropdownButton)

local colorDropdownArrow = Instance.new("TextLabel")
colorDropdownArrow.Name = "DropdownArrow"
colorDropdownArrow.BackgroundTransparency = 1
colorDropdownArrow.AnchorPoint = Vector2.new(1, 0.5)
colorDropdownArrow.Position = UDim2.new(1, -PANEL_PADDING - 34, 0, colorSectionTop + 11)
colorDropdownArrow.Size = UDim2.fromOffset(16, 18)
colorDropdownArrow.Font = Enum.Font.GothamBold
colorDropdownArrow.Text = "^"
colorDropdownArrow.TextColor3 = Color3.fromRGB(190, 190, 200)
colorDropdownArrow.TextSize = 12
colorDropdownArrow.ZIndex = 13
colorDropdownArrow.Parent = panel

local wheelTop = colorSectionTop + 22 + COLOR_SECTION_GAP
local wheelLeft = math.floor((190 - WHEEL_SIZE) / 2)

local wheelHolder = Instance.new("Frame")
wheelHolder.Name = "ColorWheel"
wheelHolder.Position = UDim2.fromOffset(wheelLeft, wheelTop)
wheelHolder.Size = UDim2.fromOffset(WHEEL_SIZE, WHEEL_SIZE)
wheelHolder.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
wheelHolder.BorderSizePixel = 0
wheelHolder.Active = true
wheelHolder.ZIndex = 11
wheelHolder.ClipsDescendants = true
wheelHolder.Parent = panel

local wheelHolderCorner = Instance.new("UICorner")
wheelHolderCorner.CornerRadius = UDim.new(0, 6)
wheelHolderCorner.Parent = wheelHolder

local wheelOutline = Instance.new("UIStroke")
wheelOutline.Color = Color3.fromRGB(90, 90, 100)
wheelOutline.Thickness = 1
wheelOutline.Parent = wheelHolder

local saturationGradient = Instance.new("UIGradient")
saturationGradient.Color = ColorSequence.new({
	ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 255, 255)),
	ColorSequenceKeypoint.new(1, Color3.fromHSV(currentHue, 1, 1)),
})
saturationGradient.Parent = wheelHolder

local brightnessOverlay = Instance.new("Frame")
brightnessOverlay.Name = "BrightnessOverlay"
brightnessOverlay.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
brightnessOverlay.BorderSizePixel = 0
brightnessOverlay.Size = UDim2.fromScale(1, 1)
brightnessOverlay.ZIndex = 13
brightnessOverlay.Parent = wheelHolder

local brightnessGradient = Instance.new("UIGradient")
brightnessGradient.Rotation = 90
brightnessGradient.Transparency = NumberSequence.new({
	NumberSequenceKeypoint.new(0, 1),
	NumberSequenceKeypoint.new(1, 0),
})
brightnessGradient.Parent = brightnessOverlay

local wheelSelector = Instance.new("Frame")
wheelSelector.Name = "WheelSelector"
wheelSelector.AnchorPoint = Vector2.new(0.5, 0.5)
wheelSelector.Size = UDim2.fromOffset(12, 12)
wheelSelector.BackgroundTransparency = 1
wheelSelector.BorderSizePixel = 0
wheelSelector.ZIndex = 20
wheelSelector.Parent = wheelHolder

local selectorStroke = Instance.new("UIStroke")
selectorStroke.Color = Color3.fromRGB(255, 255, 255)
selectorStroke.Thickness = 2
selectorStroke.Parent = wheelSelector

local selectorCorner = Instance.new("UICorner")
selectorCorner.CornerRadius = UDim.new(1, 0)
selectorCorner.Parent = wheelSelector

local selectorFill = Instance.new("Frame")
selectorFill.Name = "SelectorCore"
selectorFill.AnchorPoint = Vector2.new(0.5, 0.5)
selectorFill.Position = UDim2.fromScale(0.5, 0.5)
selectorFill.Size = UDim2.fromOffset(4, 4)
selectorFill.BackgroundColor3 = Color3.fromRGB(30, 30, 35)
selectorFill.BorderSizePixel = 0
selectorFill.ZIndex = 21
selectorFill.Parent = wheelSelector

local selectorFillCorner = Instance.new("UICorner")
selectorFillCorner.CornerRadius = UDim.new(1, 0)
selectorFillCorner.Parent = selectorFill

local valueTop = wheelTop + WHEEL_SIZE + 8
local valueSlider = Instance.new("Frame")
valueSlider.Name = "ValueSlider"
valueSlider.Position = UDim2.fromOffset(PANEL_PADDING, valueTop)
valueSlider.Size = UDim2.new(1, -PANEL_PADDING * 2, 0, VALUE_SLIDER_HEIGHT)
valueSlider.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
valueSlider.BorderSizePixel = 0
valueSlider.Active = true
valueSlider.ZIndex = 11
valueSlider.Parent = panel

local valueCorner = Instance.new("UICorner")
valueCorner.CornerRadius = UDim.new(0, 6)
valueCorner.Parent = valueSlider

local valueGradient = Instance.new("UIGradient")
valueGradient.Color = ColorSequence.new({
	ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 0, 0)),
	ColorSequenceKeypoint.new(0.17, Color3.fromRGB(255, 255, 0)),
	ColorSequenceKeypoint.new(0.33, Color3.fromRGB(0, 255, 0)),
	ColorSequenceKeypoint.new(0.5, Color3.fromRGB(0, 255, 255)),
	ColorSequenceKeypoint.new(0.67, Color3.fromRGB(0, 0, 255)),
	ColorSequenceKeypoint.new(0.83, Color3.fromRGB(255, 0, 255)),
	ColorSequenceKeypoint.new(1, Color3.fromRGB(255, 0, 0)),
})
valueGradient.Parent = valueSlider

local valueKnob = Instance.new("Frame")
valueKnob.Name = "ValueKnob"
valueKnob.AnchorPoint = Vector2.new(0.5, 0.5)
valueKnob.Position = UDim2.fromScale(currentHue, 0.5)
valueKnob.Size = UDim2.fromOffset(10, VALUE_SLIDER_HEIGHT + 4)
valueKnob.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
valueKnob.BorderSizePixel = 0
valueKnob.ZIndex = 12
valueKnob.Parent = valueSlider

local valueKnobCorner = Instance.new("UICorner")
valueKnobCorner.CornerRadius = UDim.new(0, 4)
valueKnobCorner.Parent = valueKnob

local valueKnobStroke = Instance.new("UIStroke")
valueKnobStroke.Color = Color3.fromRGB(40, 40, 45)
valueKnobStroke.Thickness = 1
valueKnobStroke.Parent = valueKnob

local hexLabel = Instance.new("TextLabel")
hexLabel.Name = "HexLabel"
hexLabel.BackgroundTransparency = 1
hexLabel.Position = UDim2.fromOffset(PANEL_PADDING, valueTop + VALUE_SLIDER_HEIGHT + 6)
hexLabel.Size = UDim2.new(1, -PANEL_PADDING * 2, 0, 18)
hexLabel.Font = Enum.Font.GothamMedium
hexLabel.Text = ""
hexLabel.TextColor3 = Color3.fromRGB(180, 180, 190)
hexLabel.TextSize = 12
hexLabel.TextXAlignment = Enum.TextXAlignment.Center
hexLabel.ZIndex = 11
hexLabel.Parent = panel

local thicknessDropdownOpen = true
local colorDropdownOpen = true
local panelResizeTween = nil
local colorDropdownRequest = 0

local thicknessShiftedItems = {
	chamsButton,
	tracersButton,
	keybindButton,
	colorLabel,
	colorPreview,
	colorDropdownButton,
	colorDropdownArrow,
	wheelHolder,
	valueSlider,
	hexLabel,
}
local thicknessItemPositions = {}
for _, gui in ipairs(thicknessShiftedItems) do
	thicknessItemPositions[gui] = gui.Position
end

local function getPanelTargetHeight()
	local height = PANEL_HEIGHT
	if not thicknessDropdownOpen then
		height = height - (THICKNESS_SECTION_HEIGHT - THICKNESS_COLLAPSED_HEIGHT)
	end
	if not colorDropdownOpen then
		height = height - (COLOR_SECTION_HEIGHT - 22)
	end
	return height
end

local function resizePanel()
	if panelResizeTween then
		panelResizeTween:Cancel()
	end
	panelResizeTween = TweenService:Create(
		panel,
		TweenInfo.new(0.22, Enum.EasingStyle.Quart, Enum.EasingDirection.Out),
		{ Size = UDim2.fromOffset(190, getPanelTargetHeight()) }
	)
	panelResizeTween:Play()
	return panelResizeTween
end

local function setThicknessDropdown(open)
	if thicknessDropdownOpen == open then
		return
	end

	thicknessDropdownOpen = open
	thicknessDropdownArrow.Text = open and "^" or "v"
	thicknessSlider.Visible = open

	local shift = open and 0 or -(THICKNESS_SECTION_HEIGHT - THICKNESS_COLLAPSED_HEIGHT)
	for _, gui in ipairs(thicknessShiftedItems) do
		local originalPosition = thicknessItemPositions[gui]
		TweenService:Create(
			gui,
			TweenInfo.new(0.22, Enum.EasingStyle.Quart, Enum.EasingDirection.Out),
			{
				Position = UDim2.new(
					originalPosition.X.Scale,
					originalPosition.X.Offset,
					originalPosition.Y.Scale,
					originalPosition.Y.Offset + shift
				),
			}
		):Play()
	end
	resizePanel()
end

thicknessDropdownButton.MouseButton1Click:Connect(function()
	setThicknessDropdown(not thicknessDropdownOpen)
end)

local function setColorDropdown(open)
	if colorDropdownOpen == open then
		return
	end

	colorDropdownOpen = open
	colorDropdownRequest = colorDropdownRequest + 1
	local request = colorDropdownRequest
	colorDropdownArrow.Text = open and "^" or "v"

	if open then
		wheelHolder.Visible = true
		valueSlider.Visible = true
		hexLabel.Visible = true
	end

	local resizeTween = resizePanel()

	if not open then
		resizeTween.Completed:Connect(function(playbackState)
			if request == colorDropdownRequest and playbackState == Enum.PlaybackState.Completed then
				wheelHolder.Visible = false
				valueSlider.Visible = false
				hexLabel.Visible = false
			end
		end)
	end
end

colorDropdownButton.MouseButton1Click:Connect(function()
	setColorDropdown(not colorDropdownOpen)
end)

local function colorToHex(color)
	local r = math.floor(color.R * 255 + 0.5)
	local g = math.floor(color.G * 255 + 0.5)
	local b = math.floor(color.B * 255 + 0.5)
	return string.format("#%02X%02X%02X", r, g, b)
end

local dragging = false
local dragStart = nil
local startPos = nil

titleBar.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1
		or input.UserInputType == Enum.UserInputType.Touch
	then
		dragging = true
		dragStart = input.Position
		startPos = panel.Position

		local endedConn
		endedConn = input.Changed:Connect(function()
			if input.UserInputState == Enum.UserInputState.End then
				dragging = false
				dragStart = nil
				startPos = nil
				endedConn:Disconnect()
			end
		end)
	end
end)

UserInputService.InputChanged:Connect(function(input)
	if not dragging or not dragStart or not startPos then
		return
	end
	if input.UserInputType == Enum.UserInputType.MouseMovement
		or input.UserInputType == Enum.UserInputType.Touch
	then
		local delta = input.Position - dragStart
		panel.Position = UDim2.new(
			startPos.X.Scale,
			startPos.X.Offset + delta.X,
			startPos.Y.Scale,
			startPos.Y.Offset + delta.Y
		)
	end
end)

local listeningForKeybind = false

local function refreshKeybindButton()
	if listeningForKeybind then
		keybindButton.Text = "Press any key..."
		keybindButton.BackgroundColor3 = Color3.fromRGB(70, 90, 180)
	else
		keybindButton.Text = "Menu Key: " .. MENU_KEY.Name
		keybindButton.BackgroundColor3 = Color3.fromRGB(55, 55, 70)
	end
end

local function setUiVisible(visible)
	UI_VISIBLE = visible
	if visible then
		panel.Visible = true
		panelScale.Scale = 0.88
		TweenService:Create(
			panelScale,
			TweenInfo.new(0.2, Enum.EasingStyle.Back, Enum.EasingDirection.Out),
			{ Scale = 1 }
		):Play()
	else
		local closeTween = TweenService:Create(
			panelScale,
			TweenInfo.new(0.14, Enum.EasingStyle.Quad, Enum.EasingDirection.In),
			{ Scale = 0.88 }
		)
		closeTween:Play()
		closeTween.Completed:Once(function(playbackState)
			if playbackState == Enum.PlaybackState.Completed and not UI_VISIBLE then
				panel.Visible = false
			end
		end)
	end
end

keybindButton.MouseButton1Click:Connect(function()
	listeningForKeybind = true
	refreshKeybindButton()
end)

UserInputService.InputBegan:Connect(function(input, _gameProcessed)
	if listeningForKeybind then
		if input.UserInputType == Enum.UserInputType.Keyboard then
			if input.KeyCode == Enum.KeyCode.Escape then
				listeningForKeybind = false
				refreshKeybindButton()
				return
			end
			MENU_KEY = input.KeyCode
			listeningForKeybind = false
			refreshKeybindButton()
		end
		return
	end

	if input.UserInputType == Enum.UserInputType.Keyboard and input.KeyCode == MENU_KEY then
		setUiVisible(not UI_VISIBLE)
	end
end)

refreshKeybindButton()

local boxes = {}
local chams = {}
local tracers = {}

local function setToggleLook(button, label, enabled)
	if enabled then
		button.Text = label .. ": ON"
		button.BackgroundColor3 = Color3.fromRGB(0, 170, 80)
	else
		button.Text = label .. ": OFF"
		button.BackgroundColor3 = Color3.fromRGB(160, 50, 50)
	end
end

local function applyColorToVisuals(color)
	ESP_COLOR = color
	colorPreview.BackgroundColor3 = color
	hexLabel.Text = colorToHex(color)

	saturationGradient.Color = ColorSequence.new({
		ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 255, 255)),
		ColorSequenceKeypoint.new(1, Color3.fromHSV(currentHue, 1, 1)),
	})

	for _, container in pairs(boxes) do
		local fill = container:FindFirstChild("Fill")
		if fill and fill:IsA("Frame") then
			fill.BackgroundColor3 = color
		end
		for _, child in container:GetChildren() do
			if child:IsA("Frame") and child.Name ~= "Fill" then
				child.BackgroundColor3 = color
			end
		end
	end

	for _, highlight in pairs(chams) do
		highlight.FillColor = color
		highlight.OutlineColor = color
	end

	for _, line in pairs(tracers) do
		line.BackgroundColor3 = color
	end
end

local function updateWheelSelector()
	wheelSelector.Position = UDim2.fromScale(currentSat, 1 - currentVal)
	valueKnob.Position = UDim2.fromScale(currentHue, 0.5)
end

local function setColorFromHSV(h, s, v)
	currentHue = math.clamp(h, 0, 1)
	currentSat = math.clamp(s, 0, 1)
	currentVal = math.clamp(v, 0, 1)
	updateWheelSelector()
	applyColorToVisuals(getESPColor())
end

local function pickFromWheel(mouseX, mouseY)
	local abs = wheelHolder.AbsolutePosition
	local size = wheelHolder.AbsoluteSize
	local saturation = math.clamp((mouseX - abs.X) / math.max(size.X, 1), 0, 1)
	local value = 1 - math.clamp((mouseY - abs.Y) / math.max(size.Y, 1), 0, 1)
	setColorFromHSV(currentHue, saturation, value)
end

local function pickFromValueSlider(mouseX)
	local abs = valueSlider.AbsolutePosition
	local size = valueSlider.AbsoluteSize
	local t = math.clamp((mouseX - abs.X) / math.max(size.X, 1), 0, 1)
	setColorFromHSV(t, currentSat, currentVal)
end

local pickingWheel = false
local pickingValue = false

local function bindPicker(gui, onBegin, onMove)
	gui.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch
		then
			onBegin(input)
			local conn
			conn = input.Changed:Connect(function()
				if input.UserInputState == Enum.UserInputState.End then
					pickingWheel = false
					pickingValue = false
					conn:Disconnect()
				end
			end)
		end
	end)
end

bindPicker(wheelHolder, function()
	pickingWheel = true
	local mouse = UserInputService:GetMouseLocation()
	pickFromWheel(mouse.X, mouse.Y)
end, function() end)

bindPicker(valueSlider, function()
	pickingValue = true
	local mouse = UserInputService:GetMouseLocation()
	pickFromValueSlider(mouse.X)
end, function() end)

UserInputService.InputChanged:Connect(function(input)
	if input.UserInputType ~= Enum.UserInputType.MouseMovement
		and input.UserInputType ~= Enum.UserInputType.Touch
	then
		return
	end
	if pickingWheel then
		pickFromWheel(input.Position.X, input.Position.Y)
	elseif pickingValue then
		pickFromValueSlider(input.Position.X)
	end
end)

local function createBoxFrame()
	local container = Instance.new("Frame")
	container.Name = "PlayerBox2D"
	container.BackgroundTransparency = 1
	container.BorderSizePixel = 0
	container.Visible = false
	container.ZIndex = 1
	container.Parent = screenGui

	if BOX_FILL_TRANSPARENCY < 1 then
		local fill = Instance.new("Frame")
		fill.Name = "Fill"
		fill.BackgroundColor3 = ESP_COLOR
		fill.BackgroundTransparency = BOX_FILL_TRANSPARENCY
		fill.BorderSizePixel = 0
		fill.Size = UDim2.fromScale(1, 1)
		fill.ZIndex = 1
		fill.Parent = container
	end

	local function makeEdge(name, position, size)
		local edge = Instance.new("Frame")
		edge.Name = name
		edge.BackgroundColor3 = ESP_COLOR
		edge.BackgroundTransparency = 0
		edge.BorderSizePixel = 0
		edge.Position = position
		edge.Size = size
		edge.ZIndex = 2
		edge.Parent = container
	end

	local t = BOX_THICKNESS
	makeEdge("Top", UDim2.fromOffset(0, 0), UDim2.new(1, 0, 0, t))
	makeEdge("Bottom", UDim2.new(0, 0, 1, -t), UDim2.new(1, 0, 0, t))
	makeEdge("Left", UDim2.fromOffset(0, 0), UDim2.new(0, t, 1, 0))
	makeEdge("Right", UDim2.new(1, -t, 0, 0), UDim2.new(0, t, 1, 0))

	return container
end

local function setBoxThickness(thickness)
	BOX_THICKNESS = math.clamp(thickness, BOX_THICKNESS_MIN, BOX_THICKNESS_MAX)

	local range = BOX_THICKNESS_MAX - BOX_THICKNESS_MIN
	local percentage = range > 0 and (BOX_THICKNESS - BOX_THICKNESS_MIN) / range or 0
	thicknessLabel.Text = string.format("Box Thickness: %.1f", BOX_THICKNESS)
	thicknessFill.Size = UDim2.fromScale(percentage, 1)
	thicknessKnob.Position = UDim2.fromScale(percentage, 0.5)

	for _, container in pairs(boxes) do
		local top = container:FindFirstChild("Top")
		local bottom = container:FindFirstChild("Bottom")
		local left = container:FindFirstChild("Left")
		local right = container:FindFirstChild("Right")

		if top and top:IsA("Frame") then
			top.Size = UDim2.new(1, 0, 0, BOX_THICKNESS)
		end
		if bottom and bottom:IsA("Frame") then
			bottom.Position = UDim2.new(0, 0, 1, -BOX_THICKNESS)
			bottom.Size = UDim2.new(1, 0, 0, BOX_THICKNESS)
		end
		if left and left:IsA("Frame") then
			left.Size = UDim2.new(0, BOX_THICKNESS, 1, 0)
		end
		if right and right:IsA("Frame") then
			right.Position = UDim2.new(1, -BOX_THICKNESS, 0, 0)
			right.Size = UDim2.new(0, BOX_THICKNESS, 1, 0)
		end
	end
end

local function pickFromThicknessSlider(mouseX)
	local absolutePosition = thicknessSlider.AbsolutePosition
	local absoluteSize = thicknessSlider.AbsoluteSize
	local percentage = math.clamp((mouseX - absolutePosition.X) / math.max(absoluteSize.X, 1), 0, 1)
	setBoxThickness(BOX_THICKNESS_MIN + percentage * (BOX_THICKNESS_MAX - BOX_THICKNESS_MIN))
end

local pickingThickness = false

thicknessSlider.InputBegan:Connect(function(input)
	if input.UserInputType ~= Enum.UserInputType.MouseButton1
		and input.UserInputType ~= Enum.UserInputType.Touch
	then
		return
	end

	pickingThickness = true
	pickFromThicknessSlider(input.Position.X)

	local connection
	connection = input.Changed:Connect(function()
		if input.UserInputState == Enum.UserInputState.End then
			pickingThickness = false
			connection:Disconnect()
		end
	end)
end)

UserInputService.InputChanged:Connect(function(input)
	if pickingThickness and (input.UserInputType == Enum.UserInputType.MouseMovement
		or input.UserInputType == Enum.UserInputType.Touch) then
		pickFromThicknessSlider(input.Position.X)
	end
end)

local function clearBox(character)
	local frame = boxes[character]
	if frame then
		frame:Destroy()
		boxes[character] = nil
	end
end

local function hideAllBoxes()
	for _, frame in pairs(boxes) do
		frame.Visible = false
	end
end

local function ensureBox(character)
	local frame = boxes[character]
	if not frame then
		frame = createBoxFrame()
		boxes[character] = frame
	end
	return frame
end

local function clearCham(character)
	local highlight = chams[character]
	if highlight then
		highlight:Destroy()
		chams[character] = nil
	end
end

local function clearAllChams()
	for character in pairs(chams) do
		clearCham(character)
	end
end

local function ensureCham(character)
	local highlight = chams[character]
	if not highlight then
		highlight = Instance.new("Highlight")
		highlight.Name = "PlayerChams"
		highlight.Adornee = character
		highlight.FillColor = ESP_COLOR
		highlight.FillTransparency = CHAMS_FILL_TRANSPARENCY
		highlight.OutlineColor = ESP_COLOR
		highlight.OutlineTransparency = CHAMS_OUTLINE_TRANSPARENCY
		highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
		highlight.Parent = character
		chams[character] = highlight
	else
		highlight.FillColor = ESP_COLOR
		highlight.OutlineColor = ESP_COLOR
	end
	return highlight
end

local function createTracerFrame()
	local line = Instance.new("Frame")
	line.Name = "PlayerTracer"
	line.AnchorPoint = Vector2.new(0.5, 0.5)
	line.BackgroundColor3 = ESP_COLOR
	line.BackgroundTransparency = 0
	line.BorderSizePixel = 0
	line.Visible = false
	line.ZIndex = 1
	line.Parent = screenGui
	return line
end

local function clearTracer(character)
	local line = tracers[character]
	if line then
		line:Destroy()
		tracers[character] = nil
	end
end

local function hideAllTracers()
	for _, line in pairs(tracers) do
		line.Visible = false
	end
end

local function ensureTracer(character)
	local line = tracers[character]
	if not line then
		line = createTracerFrame()
		tracers[character] = line
	else
		line.BackgroundColor3 = ESP_COLOR
	end
	return line
end

local function updateTracerLine(line, fromX, fromY, toX, toY)
	local dx = toX - fromX
	local dy = toY - fromY
	local length = math.sqrt(dx * dx + dy * dy)
	if length < 1 then
		line.Visible = false
		return
	end

	line.Visible = true
	line.BackgroundColor3 = ESP_COLOR
	line.Size = UDim2.fromOffset(length, TRACER_THICKNESS)
	line.Position = UDim2.fromOffset((fromX + toX) * 0.5, (fromY + toY) * 0.5)
	line.Rotation = math.deg(math.atan2(dy, dx))
end

local function clearAllVisuals(character)
	clearBox(character)
	clearCham(character)
	clearTracer(character)
end

local function refreshToggleUI()
	setToggleLook(boxesButton, "Boxes", BOXES_ENABLED)
	setToggleLook(chamsButton, "Chams", CHAMS_ENABLED)
	setToggleLook(tracersButton, "Tracers", TRACERS_ENABLED)

	if not BOXES_ENABLED then
		hideAllBoxes()
	end
	if not CHAMS_ENABLED then
		clearAllChams()
	end
	if not TRACERS_ENABLED then
		hideAllTracers()
	end
end

boxesButton.MouseButton1Click:Connect(function()
	BOXES_ENABLED = not BOXES_ENABLED
	refreshToggleUI()
end)

chamsButton.MouseButton1Click:Connect(function()
	CHAMS_ENABLED = not CHAMS_ENABLED
	refreshToggleUI()
end)

tracersButton.MouseButton1Click:Connect(function()
	TRACERS_ENABLED = not TRACERS_ENABLED
	refreshToggleUI()
end)

refreshToggleUI()
setColorFromHSV(currentHue, currentSat, currentVal)

local function getCorners(cf, size)
	local half = size * 0.5
	local x, y, z = half.X, half.Y, half.Z
	return {
		cf:PointToWorldSpace(Vector3.new(-x, -y, -z)),
		cf:PointToWorldSpace(Vector3.new(x, -y, -z)),
		cf:PointToWorldSpace(Vector3.new(-x, y, -z)),
		cf:PointToWorldSpace(Vector3.new(x, y, -z)),
		cf:PointToWorldSpace(Vector3.new(-x, -y, z)),
		cf:PointToWorldSpace(Vector3.new(x, -y, z)),
		cf:PointToWorldSpace(Vector3.new(-x, y, z)),
		cf:PointToWorldSpace(Vector3.new(x, y, z)),
	}
end

local function worldBoxToScreen(cf, size)
	local minX, minY = math.huge, math.huge
	local maxX, maxY = -math.huge, -math.huge
	local anyInFront = false

	for _, corner in getCorners(cf, size) do
		local screenPos = camera:WorldToViewportPoint(corner)
		if screenPos.Z > 0 then
			anyInFront = true
			minX = math.min(minX, screenPos.X)
			minY = math.min(minY, screenPos.Y)
			maxX = math.max(maxX, screenPos.X)
			maxY = math.max(maxY, screenPos.Y)
		end
	end

	if not anyInFront then
		return nil
	end

	local width = maxX - minX
	local height = maxY - minY
	if width < 1 or height < 1 then
		return nil
	end

	return minX, minY, width, height
end

local function getRootPart(character)
	local root = character:FindFirstChild("HumanoidRootPart")
		or character:FindFirstChild("UpperTorso")
		or character:FindFirstChild("Torso")
		or character.PrimaryPart
	if root and root:IsA("BasePart") then
		return root
	end
	return nil
end

local function onCharacterAdded(player, character)
	if player == localPlayer then
		return
	end

	local humanoid = character:WaitForChild("Humanoid", 10)
	if not humanoid then
		return
	end

	humanoid.Died:Connect(function()
		clearAllVisuals(character)
	end)
end

local function hookPlayer(player)
	if player.Character then
		task.spawn(onCharacterAdded, player, player.Character)
	end
	player.CharacterAdded:Connect(function(character)
		onCharacterAdded(player, character)
	end)
	player.CharacterRemoving:Connect(function(character)
		clearAllVisuals(character)
	end)
end

for _, player in Players:GetPlayers() do
	hookPlayer(player)
end
Players.PlayerAdded:Connect(hookPlayer)

Players.PlayerRemoving:Connect(function(player)
	if player.Character then
		clearAllVisuals(player.Character)
	end
end)

RunService.RenderStepped:Connect(function()
	camera = workspace.CurrentCamera
	if not camera then
		return
	end

	local anyFeature = BOXES_ENABLED or CHAMS_ENABLED or TRACERS_ENABLED
	if not anyFeature then
		hideAllBoxes()
		clearAllChams()
		hideAllTracers()
		return
	end

	local viewport = camera.ViewportSize
	local tracerOriginX = viewport.X * 0.5
	local tracerOriginY = viewport.Y

	for _, player in Players:GetPlayers() do
		if player == localPlayer then
			continue
		end

		local character = player.Character
		if not character or not character.Parent then
			if character then
				clearAllVisuals(character)
			end
			continue
		end

		local humanoid = character:FindFirstChildOfClass("Humanoid")
		if not humanoid or humanoid.Health <= 0 then
			clearAllVisuals(character)
			continue
		end

		if CHAMS_ENABLED then
			ensureCham(character)
		else
			clearCham(character)
		end

		local ok, cf, size = pcall(function()
			return character:GetBoundingBox()
		end)
		local hasBounds = ok and typeof(cf) == "CFrame"

		if BOXES_ENABLED and hasBounds then
			local x, y, w, h = worldBoxToScreen(cf, size)
			local frame = ensureBox(character)
			if not x then
				frame.Visible = false
			else
				frame.Visible = true
				frame.Position = UDim2.fromOffset(x, y)
				frame.Size = UDim2.fromOffset(w, h)
			end
		else
			local frame = boxes[character]
			if frame then
				frame.Visible = false
			end
		end

		if TRACERS_ENABLED then
			local root = getRootPart(character)
			local line = ensureTracer(character)
			if root then
				local target = root.Position - Vector3.new(0, root.Size.Y * 0.5, 0)
				local screenPos = camera:WorldToViewportPoint(target)
				if screenPos.Z > 0 then
					updateTracerLine(line, tracerOriginX, tracerOriginY, screenPos.X, screenPos.Y)
				else
					line.Visible = false
				end
			else
				line.Visible = false
			end
		else
			local line = tracers[character]
			if line then
				line.Visible = false
			end
		end
	end

	for character in pairs(boxes) do
		if not character.Parent then
			clearAllVisuals(character)
		end
	end
	for character in pairs(chams) do
		if not character.Parent then
			clearAllVisuals(character)
		end
	end
	for character in pairs(tracers) do
		if not character.Parent then
			clearAllVisuals(character)
		end
	end
end)