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

--[[
	Shevon Status GUI + Aim + Freeze + Custom Binds + Session Timer
	+ Ignore/Whitelist (player picker) + Visible Check + Foldable List + Radius Slider
	- Q    : аим
	- P    : lock
	- TAB  : freeze
	- RCTRL: открыть/закрыть GUI (стартует скрытым)
	- Колёсико по строке бинда : сменить бинд
	- Клик по IGNORE LIST / WHITELIST : открыть/закрыть список
	- Клик по кнопке справа : ignore/whitelist
	- Клик по игроку : добавить/убрать из списка
	- Тяни ползунок RADIUS : 0..100
	- Тяни плашку за заголовок
]]

local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Stats = game:GetService("Stats")
local VirtualInputManager = game:GetService("VirtualInputManager")
local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera

------------------------------------------------------------
-- Binds
------------------------------------------------------------
local function K(code) return {type = "key", value = Enum.KeyCode[code]} end

local Binds = {
	Aim    = K("Q"),
	Lock   = K("P"),
	Freeze = K("Tab"),
	Hide   = K("RightControl")
}

------------------------------------------------------------
-- Settings
------------------------------------------------------------
local Settings = {
	MaxAngle     = 90,
	MaxDistance  = 31,      -- стартовое значение, меняется ползунком
	TargetPart   = "Head",
	ClickDelay   = 0.08,
	ManualLock   = true,
	VisibleCheck = true,
	RadiusMin    = 0,
	RadiusMax    = 100
}

------------------------------------------------------------
-- State
------------------------------------------------------------
local isLocked      = false
local isGuiVisible  = false
local isFrozen      = false
local lastClick     = 0
local awaitingBind  = nil
local justBound     = false
local justOpenedBind = false
local isAimingSelf  = false

local selectedList  = {}
local listMode      = "ignore"
local listOpen      = false

local sessionStart  = tick()
local lastTimerTick = 0
local lastPlayerRefresh = 0

------------------------------------------------------------
-- matchBind / bindName
------------------------------------------------------------
local function matchBind(input, bind)
	if not bind then return false end
	if bind.type == "key" then
		return input.KeyCode == bind.value
	elseif bind.type == "mouse" then
		return input.UserInputType == bind.value
	end
	return false
end

local function bindName(bind)
	if not bind then return "?" end
	if bind.type == "key" then return bind.value.Name end
	if bind.type == "mouse" then
		local n = bind.value.Name
		if n == "MouseButton1" then return "ЛКМ" end
		if n == "MouseButton2" then return "ПКМ" end
		if n == "MouseButton3" then return "КОЛЁСИКО" end
		return n
	end
	return "?"
end

local function formatTime(sec)
	sec = math.floor(sec)
	local h = math.floor(sec / 3600)
	local m = math.floor((sec % 3600) / 60)
	local s = sec % 60
	if h > 0 then
		return string.format("%02d:%02d:%02d", h, m, s)
	end
	return string.format("%02d:%02d", m, s)
end

------------------------------------------------------------
-- UI
------------------------------------------------------------
local gui = Instance.new("ScreenGui")
gui.Name = "ShevonStatus"
gui.ResetOnSpawn = false
gui.IgnoreGuiInset = true
gui.Enabled = true
gui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
pcall(function() gui.Parent = game:GetService("CoreGui") end)
if not gui.Parent then gui.Parent = LocalPlayer:WaitForChild("PlayerGui") end

local frame = Instance.new("Frame")
frame.Size = UDim2.new(0, 290, 0, 260)
frame.Position = UDim2.new(0, 15, 0, 15)
frame.BackgroundColor3 = Color3.fromRGB(20, 20, 20)
frame.BackgroundTransparency = 0.4
frame.BorderSizePixel = 0
frame.Active = true
frame.Visible = false
frame.Parent = gui

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

local stroke = Instance.new("UIStroke")
stroke.Color = Color3.fromRGB(255, 255, 255)
stroke.Transparency = 0.7
stroke.Thickness = 1
stroke.Parent = frame

local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, -10, 0, 22)
title.Position = UDim2.new(0, 10, 0, 4)
title.BackgroundTransparency = 1
title.Font = Enum.Font.GothamBold
title.TextSize = 14
title.TextColor3 = Color3.fromRGB(255, 255, 255)
title.TextXAlignment = Enum.TextXAlignment.Left
title.Text = "Shevon  (drag me)"
title.Parent = frame

local hint = Instance.new("TextLabel")
hint.Size = UDim2.new(1, -10, 0, 14)
hint.Position = UDim2.new(0, 10, 0, 22)
hint.BackgroundTransparency = 1
hint.Font = Enum.Font.Gotham
hint.TextSize = 10
hint.TextColor3 = Color3.fromRGB(150, 150, 150)
hint.TextXAlignment = Enum.TextXAlignment.Left
hint.Text = "колёсико по строке = сменить бинд"
hint.Parent = frame

local function makeBindRow(y, key, text)
	local row = Instance.new("TextLabel")
	row.Size = UDim2.new(1, -20, 0, 18)
	row.Position = UDim2.new(0, 10, 0, y)
	row.BackgroundTransparency = 1
	row.Font = Enum.Font.Gotham
	row.TextSize = 13
	row.TextColor3 = Color3.fromRGB(180, 220, 255)
	row.TextXAlignment = Enum.TextXAlignment.Left
	row.Text = text .. ": " .. bindName(Binds[key])
	row.Name = key
	row.Parent = frame

	local btn = Instance.new("TextButton")
	btn.Size = UDim2.new(1, -20, 0, 18)
	btn.Position = UDim2.new(0, 10, 0, y)
	btn.BackgroundTransparency = 1
	btn.Text = ""
	btn.Name = key .. "_btn"
	btn.Parent = frame

	return row, btn
end

local lockRow,   lockBtn   = makeBindRow(40, "Lock",   "LOCK")
local freezeRow, freezeBtn = makeBindRow(58, "Freeze", "FREEZE")
local hideRow,   hideBtn   = makeBindRow(76, "Hide",   "HIDE GUI")
local aimRow,    aimBtn    = makeBindRow(94, "Aim",    "AIM")

local visLabel = Instance.new("TextLabel")
visLabel.Size = UDim2.new(1, -20, 0, 18)
visLabel.Position = UDim2.new(0, 10, 0, 116)
visLabel.BackgroundTransparency = 1
visLabel.Font = Enum.Font.Gotham
visLabel.TextSize = 13
visLabel.TextColor3 = Color3.fromRGB(180, 220, 255)
visLabel.TextXAlignment = Enum.TextXAlignment.Left
visLabel.Text = "VISIBLE CHECK: ON"
visLabel.Parent = frame

local visBtn = Instance.new("TextButton")
visBtn.Size = UDim2.new(1, -20, 0, 18)
visBtn.Position = UDim2.new(0, 10, 0, 116)
visBtn.BackgroundTransparency = 1
visBtn.Text = ""
visBtn.Parent = frame

-- === RADIUS label ===
local radiusLabel = Instance.new("TextLabel")
radiusLabel.Size = UDim2.new(1, -20, 0, 18)
radiusLabel.Position = UDim2.new(0, 10, 0, 138)
radiusLabel.BackgroundTransparency = 1
radiusLabel.Font = Enum.Font.Gotham
radiusLabel.TextSize = 13
radiusLabel.TextColor3 = Color3.fromRGB(180, 220, 255)
radiusLabel.TextXAlignment = Enum.TextXAlignment.Left
radiusLabel.Text = "RADIUS: " .. Settings.MaxDistance
radiusLabel.Parent = frame

-- === RADIUS slider ===
local sliderBg = Instance.new("Frame")
sliderBg.Size = UDim2.new(1, -20, 0, 10)
sliderBg.Position = UDim2.new(0, 10, 0, 158)
sliderBg.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
sliderBg.BorderSizePixel = 0
sliderBg.Parent = frame

local sliderBgCorner = Instance.new("UICorner")
sliderBgCorner.CornerRadius = UDim.new(1, 0)
sliderBgCorner.Parent = sliderBg

local sliderFill = Instance.new("Frame")
sliderFill.Size = UDim2.new(
	(Settings.MaxDistance - Settings.RadiusMin) / (Settings.RadiusMax - Settings.RadiusMin), 0, 1, 0)
sliderFill.BackgroundColor3 = Color3.fromRGB(120, 180, 255)
sliderFill.BorderSizePixel = 0
sliderFill.Parent = sliderBg

local sliderFillCorner = Instance.new("UICorner")
sliderFillCorner.CornerRadius = UDim.new(1, 0)
sliderFillCorner.Parent = sliderFill

local sliderKnob = Instance.new("Frame")
sliderKnob.Size = UDim2.new(0, 14, 0, 14)
sliderKnob.AnchorPoint = Vector2.new(0.5, 0.5)
sliderKnob.Position = UDim2.new(
	(Settings.MaxDistance - Settings.RadiusMin) / (Settings.RadiusMax - Settings.RadiusMin), 0, 0.5, 0)
sliderKnob.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
sliderKnob.BorderSizePixel = 0
sliderKnob.ZIndex = 2
sliderKnob.Parent = sliderBg

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

-- Прозрачная зона для кликов (шире самого слайдера)
local sliderHit = Instance.new("TextButton")
sliderHit.Size = UDim2.new(1, 0, 0, 20)
sliderHit.Position = UDim2.new(0, 0, 0.5, 0)
sliderHit.AnchorPoint = Vector2.new(0, 0.5)
sliderHit.BackgroundTransparency = 1
sliderHit.Text = ""
sliderHit.ZIndex = 3
sliderHit.Parent = sliderBg

-- Флаг перетаскивания
local sliderDragging = false

local function setRadiusFromX(mouseX)
	local absPos = sliderBg.AbsolutePosition
	local absSize = sliderBg.AbsoluteSize
	local rel = (mouseX - absPos.X) / absSize.X
	rel = math.clamp(rel, 0, 1)
	local value = math.floor(Settings.RadiusMin + rel * (Settings.RadiusMax - Settings.RadiusMin) + 0.5)
	Settings.MaxDistance = value
	radiusLabel.Text = "RADIUS: " .. value
	sliderFill.Size = UDim2.new(rel, 0, 1, 0)
	sliderKnob.Position = UDim2.new(rel, 0, 0.5, 0)
end

sliderHit.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1
		or input.UserInputType == Enum.UserInputType.Touch then
		sliderDragging = true
		setRadiusFromX(input.Position.X)
	end
end)

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

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

-- === Заголовок списка ===
local listHeader = Instance.new("TextButton")
listHeader.Size = UDim2.new(1, -80, 0, 18)
listHeader.Position = UDim2.new(0, 10, 0, 180)
listHeader.BackgroundTransparency = 1
listHeader.Font = Enum.Font.GothamBold
listHeader.TextSize = 12
listHeader.TextColor3 = Color3.fromRGB(255, 200, 120)
listHeader.TextXAlignment = Enum.TextXAlignment.Left
listHeader.Text = "IGNORE LIST  ▶"
listHeader.Parent = frame

local modeBtn = Instance.new("TextButton")
modeBtn.Size = UDim2.new(0, 70, 0, 18)
modeBtn.Position = UDim2.new(1, -80, 0, 180)
modeBtn.BackgroundColor3 = Color3.fromRGB(60, 60, 100)
modeBtn.BackgroundTransparency = 0.2
modeBtn.BorderSizePixel = 0
modeBtn.Font = Enum.Font.GothamBold
modeBtn.TextSize = 11
modeBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
modeBtn.Text = "IGNORE"
modeBtn.Parent = frame

local modeCorner = Instance.new("UICorner")
modeCorner.CornerRadius = UDim.new(0, 3)
modeCorner.Parent = modeBtn

-- Список игроков
local plrScroll = Instance.new("ScrollingFrame")
plrScroll.Size = UDim2.new(1, -20, 0, 130)
plrScroll.Position = UDim2.new(0, 10, 0, 202)
plrScroll.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
plrScroll.BackgroundTransparency = 0.4
plrScroll.BorderSizePixel = 0
plrScroll.ScrollBarThickness = 4
plrScroll.CanvasSize = UDim2.new(0, 0, 0, 0)
plrScroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
plrScroll.Visible = false
plrScroll.Parent = frame

local plrCorner = Instance.new("UICorner")
plrCorner.CornerRadius = UDim.new(0, 4)
plrCorner.Parent = plrScroll

local plrLayout = Instance.new("UIListLayout")
plrLayout.SortOrder = Enum.SortOrder.LayoutOrder
plrLayout.Padding = UDim.new(0, 2)
plrLayout.Parent = plrScroll

local plrPadding = Instance.new("UIPadding")
plrPadding.PaddingTop = UDim.new(0, 4)
plrPadding.PaddingLeft = UDim.new(0, 4)
plrPadding.PaddingRight = UDim.new(0, 4)
plrPadding.PaddingBottom = UDim.new(0, 4)
plrPadding.Parent = plrScroll

-- Session
local sessionLabel = Instance.new("TextLabel")
sessionLabel.Size = UDim2.new(1, -20, 0, 16)
sessionLabel.Position = UDim2.new(0, 10, 0, 198)
sessionLabel.BackgroundTransparency = 1
sessionLabel.Font = Enum.Font.Gotham
sessionLabel.TextSize = 12
sessionLabel.TextColor3 = Color3.fromRGB(200, 180, 255)
sessionLabel.TextXAlignment = Enum.TextXAlignment.Left
sessionLabel.Text = "SESSION: 00:00"
sessionLabel.Parent = frame

local targetLabel = Instance.new("TextLabel")
targetLabel.Size = UDim2.new(1, -10, 0, 16)
targetLabel.Position = UDim2.new(0, 10, 0, 218)
targetLabel.BackgroundTransparency = 1
targetLabel.Font = Enum.Font.Gotham
targetLabel.TextSize = 12
targetLabel.TextColor3 = Color3.fromRGB(200, 200, 200)
targetLabel.TextXAlignment = Enum.TextXAlignment.Left
targetLabel.Text = "target: —"
targetLabel.Parent = frame

local statsLabel = Instance.new("TextLabel")
statsLabel.Size = UDim2.new(1, -10, 0, 16)
statsLabel.Position = UDim2.new(0, 10, 0, 236)
statsLabel.BackgroundTransparency = 1
statsLabel.Font = Enum.Font.Gotham
statsLabel.TextSize = 12
statsLabel.TextColor3 = Color3.fromRGB(180, 220, 255)
statsLabel.TextXAlignment = Enum.TextXAlignment.Left
statsLabel.Text = "FPS: --   PING: -- ms"
statsLabel.Parent = frame

local COLLAPSED = {
	frame     = UDim2.new(0, 290, 0, 260),
	session   = UDim2.new(0, 10, 0, 198),
	target    = UDim2.new(0, 10, 0, 218),
	stats     = UDim2.new(0, 10, 0, 236),
}

local EXPANDED = {
	frame     = UDim2.new(0, 290, 0, 410),
	session   = UDim2.new(0, 10, 0, 346),
	target    = UDim2.new(0, 10, 0, 366),
	stats     = UDim2.new(0, 10, 0, 384),
}

local function applyListLayout()
	if listOpen then
		frame.Size = EXPANDED.frame
		plrScroll.Visible = true
		sessionLabel.Position = EXPANDED.session
		targetLabel.Position = EXPANDED.target
		statsLabel.Position = EXPANDED.stats
	else
		frame.Size = COLLAPSED.frame
		plrScroll.Visible = false
		sessionLabel.Position = COLLAPSED.session
		targetLabel.Position = COLLAPSED.target
		statsLabel.Position = COLLAPSED.stats
	end
	local label = (listMode == "ignore") and "IGNORE LIST" or "WHITELIST"
	listHeader.Text = label .. (listOpen and "  ▼" or "  ▶")
	modeBtn.Text = (listMode == "ignore") and "IGNORE" or "WHITELIST"
	modeBtn.BackgroundColor3 = (listMode == "ignore")
		and Color3.fromRGB(100, 60, 60)
		or Color3.fromRGB(60, 100, 60)
end

local rows = { Lock = lockRow, Freeze = freezeRow, Hide = hideRow, Aim = aimRow }
local rowNames = { Lock = "LOCK", Freeze = "FREEZE", Hide = "HIDE GUI", Aim = "AIM" }

local function refreshRow(key)
	local r = rows[key]
	if not r then return end
	if awaitingBind == key then
		r.TextColor3 = Color3.fromRGB(255, 220, 100)
		r.Text = rowNames[key] .. ": [нажми клавишу/мышь...]"
	else
		r.TextColor3 = Color3.fromRGB(180, 220, 255)
		r.Text = rowNames[key] .. ": " .. bindName(Binds[key])
	end
end

local function refreshAllRows()
	for key, _ in pairs(rows) do refreshRow(key) end
	visLabel.Text = "VISIBLE CHECK: " .. (Settings.VisibleCheck and "ON" or "OFF")
	radiusLabel.Text = "RADIUS: " .. Settings.MaxDistance
	applyListLayout()
end

------------------------------------------------------------
-- Список игроков
------------------------------------------------------------
local function refreshPlayerList()
	for _, child in pairs(plrScroll:GetChildren()) do
		if child:IsA("TextButton") then child:Destroy() end
	end

	for _, plr in pairs(Players:GetPlayers()) do
		if plr ~= LocalPlayer then
			local marked = selectedList[plr.Name] == true

			local row = Instance.new("TextButton")
			row.Size = UDim2.new(1, -8, 0, 22)
			row.BackgroundColor3 = marked
				and (listMode == "ignore" and Color3.fromRGB(80, 30, 30) or Color3.fromRGB(30, 80, 30))
				or Color3.fromRGB(45, 45, 45)
			row.BackgroundTransparency = 0.2
			row.BorderSizePixel = 0
			row.Font = Enum.Font.Gotham
			row.TextSize = 12
			row.TextColor3 = marked
				and (listMode == "ignore" and Color3.fromRGB(255, 120, 120) or Color3.fromRGB(120, 255, 120))
				or Color3.fromRGB(220, 220, 220)
			row.TextXAlignment = Enum.TextXAlignment.Left
			row.Text = (marked and "[X] " or "[  ] ") .. plr.Name
			row.AutoButtonColor = false
			row.Parent = plrScroll

			local rowCorner = Instance.new("UICorner")
			rowCorner.CornerRadius = UDim.new(0, 3)
			rowCorner.Parent = row

			local plrName = plr.Name
			row.MouseButton1Click:Connect(function()
				if selectedList[plrName] then
					selectedList[plrName] = nil
				else
					selectedList[plrName] = true
				end
				refreshPlayerList()
			end)
		end
	end

	if #Players:GetPlayers() <= 1 then
		local empty = Instance.new("TextButton")
		empty.Size = UDim2.new(1, -8, 0, 22)
		empty.BackgroundTransparency = 1
		empty.Font = Enum.Font.Gotham
		empty.TextSize = 11
		empty.TextColor3 = Color3.fromRGB(120, 120, 120)
		empty.TextXAlignment = Enum.TextXAlignment.Left
		empty.Text = "  на сервере никого нет"
		empty.AutoButtonColor = false
		empty.Parent = plrScroll
	end
end

refreshAllRows()
refreshPlayerList()

------------------------------------------------------------
-- Перетаскивание GUI
------------------------------------------------------------
local dragging, dragStart, startPos

title.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		dragging = true
		dragStart = input.Position
		startPos = frame.Position
		input.Changed:Connect(function()
			if input.UserInputState == Enum.UserInputState.End then
				dragging = false
			end
		end)
	end
end)

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

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

------------------------------------------------------------
-- Смена бинда
------------------------------------------------------------
local function bindRowClick(key)
	return function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton3 then
			awaitingBind = key
			justOpenedBind = true
			refreshAllRows()
			task.spawn(function()
				task.wait(0.05)
				justOpenedBind = false
			end)
		end
	end
end

lockBtn.InputBegan:Connect(bindRowClick("Lock"))
freezeBtn.InputBegan:Connect(bindRowClick("Freeze"))
hideBtn.InputBegan:Connect(bindRowClick("Hide"))
aimBtn.InputBegan:Connect(bindRowClick("Aim"))

visBtn.MouseButton1Click:Connect(function()
	Settings.VisibleCheck = not Settings.VisibleCheck
	refreshAllRows()
end)

listHeader.MouseButton1Click:Connect(function()
	listOpen = not listOpen
	applyListLayout()
	if listOpen then
		refreshPlayerList()
	end
end)

modeBtn.MouseButton1Click:Connect(function()
	if listMode == "ignore" then
		listMode = "whitelist"
	else
		listMode = "ignore"
	end
	refreshAllRows()
	refreshPlayerList()
end)

------------------------------------------------------------
-- Фриз
------------------------------------------------------------
local function getHumanoid()
	local char = LocalPlayer.Character
	if not char then return nil, nil end
	return char:FindFirstChildOfClass("Humanoid"), char:FindFirstChild("HumanoidRootPart")
end

local savedWalk, savedJump
local function freezeCharacter()
	local hum, hrp = getHumanoid()
	if not hum or not hrp then return end
	isFrozen = true
	savedWalk, savedJump = hum.WalkSpeed, hum.JumpPower
	hum.WalkSpeed = 0
	hum.JumpPower = 0
	pcall(function() hum.JumpHeight = 0 end)
	hrp.Anchored = true
end

local function unfreezeCharacter()
	local hum, hrp = getHumanoid()
	if hum then
		hum.WalkSpeed = savedWalk or 16
		hum.JumpPower = savedJump or 50
		pcall(function() hum.JumpHeight = 7.2 end)
	end
	if hrp then hrp.Anchored = false end
	isFrozen = false
end

------------------------------------------------------------
-- Visible-check
------------------------------------------------------------
local function isVisible(targetPart)
	if not Settings.VisibleCheck then return true end

	local origin = Camera.CFrame.Position
	local dir = targetPart.Position - origin
	local dist = dir.Magnitude
	if dist < 0.01 then return true end
	dir = dir.Unit

	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = {
		LocalPlayer.Character,
		targetPart.Parent
	}
	params.IgnoreWater = true

	local result = workspace:Raycast(origin, dir * dist, params)
	return result == nil
end

------------------------------------------------------------
-- Аим
------------------------------------------------------------
local function isInFront(targetPart)
	local camPos = Camera.CFrame.Position
	local lookVec = Camera.CFrame.LookVector
	local toTarget = (targetPart.Position - camPos)
	if toTarget.Magnitude < 0.001 then return true end
	toTarget = toTarget.Unit
	local dot = lookVec:Dot(toTarget)
	local angle = math.deg(math.acos(math.clamp(dot, -1, 1)))
	return angle <= Settings.MaxAngle
end

local function isAllowedPlayer(playerName)
	if listMode == "ignore" then
		return not selectedList[playerName]
	else
		return selectedList[playerName] == true
	end
end

local function getClosestPlayer()
	if not LocalPlayer.Character or not LocalPlayer.Character:FindFirstChild("HumanoidRootPart") then
		return nil
	end
	local closestPlayer, shortestDistance = nil, math.huge
	local myPos = LocalPlayer.Character.HumanoidRootPart.Position

	for _, player in pairs(Players:GetPlayers()) do
		if player ~= LocalPlayer
			and isAllowedPlayer(player.Name)
			and player.Character
			and player.Character:FindFirstChild("HumanoidRootPart")
			and player.Character:FindFirstChildOfClass("Humanoid")
			and player.Character:FindFirstChildOfClass("Humanoid").Health > 0
		then
			local targetPart = player.Character:FindFirstChild(Settings.TargetPart)
				or player.Character:FindFirstChild("HumanoidRootPart")
			local dist = (targetPart.Position - myPos).magnitude

			if Settings.MaxDistance > 0 and dist > Settings.MaxDistance then
				continue
			end

			if isInFront(targetPart) and isVisible(targetPart) then
				if dist < shortestDistance then
					closestPlayer, shortestDistance = player, dist
				end
			end
		end
	end
	return closestPlayer
end

local function leftClick()
	pcall(function()
		VirtualInputManager:SendMouseButtonEvent(0, 0, 0, true, game, 1)
		VirtualInputManager:SendMouseButtonEvent(0, 0, 0, false, game, 1)
	end)
	pcall(function() mouse1click() end)
end

local function aimAt(target)
	local part = target
		and target.Character
		and (target.Character:FindFirstChild(Settings.TargetPart)
			or target.Character:FindFirstChild("HumanoidRootPart"))
	if not part then return false end

	Camera.CFrame = CFrame.new(Camera.CFrame.Position, part.Position)
	pcall(function()
		if mouse then mouse.Hit = CFrame.new(Camera.CFrame.Position, part.Position) end
	end)

	local now = tick()
	if now - lastClick >= Settings.ClickDelay then
		lastClick = now
		isAimingSelf = true
		task.spawn(function()
			RunService.RenderStepped:Wait()
			leftClick()
			task.wait(0.05)
			isAimingSelf = false
		end)
	end
	return true
end

------------------------------------------------------------
-- FPS/PING
------------------------------------------------------------
local fps = 0
local frameCount = 0
local lastFpsUpdate = tick()

local function getPing()
	local ok, result = pcall(function() return LocalPlayer:GetNetworkPing() end)
	if ok and type(result) == "number" and result > 0 then
		return math.floor(result * 1000)
	end
	local ok2, ping = pcall(function()
		return Stats.Network.ServerStatsItem["Data Ping"]:GetValue()
	end)
	if ok2 and type(ping) == "number" then return math.floor(ping) end
	return nil
end

------------------------------------------------------------
-- Ввод
------------------------------------------------------------
UserInputService.InputBegan:Connect(function(input, gameProcessed)
	if awaitingBind then
		if justOpenedBind then return end

		if input.KeyCode == Enum.KeyCode.Escape then
			local prev = awaitingBind
			awaitingBind = nil
			refreshRow(prev)
			return
		end

		if input.KeyCode ~= Enum.KeyCode.Unknown then
			Binds[awaitingBind] = {type = "key", value = input.KeyCode}
			local prev = awaitingBind
			awaitingBind = nil
			justBound = true
			refreshRow(prev)
			task.delay(0.25, function() justBound = false end)
			return
		end

		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.MouseButton2
			or input.UserInputType == Enum.UserInputType.MouseButton3 then
			Binds[awaitingBind] = {type = "mouse", value = input.UserInputType}
			local prev = awaitingBind
			awaitingBind = nil
			justBound = true
			refreshRow(prev)
			task.delay(0.25, function() justBound = false end)
			return
		end
		return
	end

	if isAimingSelf then return end

	if not justBound then
		if matchBind(input, Binds.Hide) then
			isGuiVisible = not isGuiVisible
			frame.Visible = isGuiVisible
			return
		end

		if matchBind(input, Binds.Lock) then
			if Settings.ManualLock then
				isLocked = not isLocked
				refreshRow("Lock")
			end
			return
		end

		if matchBind(input, Binds.Freeze) then
			freezeCharacter()
			if isGuiVisible then
				freezeRow.TextColor3 = Color3.fromRGB(255, 180, 90)
				freezeRow.Text = "FREEZE: ON [" .. bindName(Binds.Freeze) .. "]"
			end
			return
		end

		if matchBind(input, Binds.Aim) then
			if isLocked then return end
			local target = getClosestPlayer()
			if target then aimAt(target) end
			return
		end
	end
end)

UserInputService.InputEnded:Connect(function(input)
	if isAimingSelf then return end

	if matchBind(input, Binds.Freeze) then
		if isFrozen then
			unfreezeCharacter()
			refreshRow("Freeze")
		end
	end
end)

------------------------------------------------------------
-- Основной цикл
------------------------------------------------------------
RunService.RenderStepped:Connect(function(dt)
	frameCount = frameCount + 1
	local now = tick()
	if now - lastFpsUpdate >= 0.5 then
		fps = math.floor(frameCount / (now - lastFpsUpdate) + 0.5)
		frameCount = 0
		lastFpsUpdate = now
		if isGuiVisible then
			local ping = getPing()
			statsLabel.Text = string.format(
				"FPS: %d   PING: %s",
				fps,
				ping and (tostring(ping) .. " ms") or "--"
			)
		end
	end

	if now - lastTimerTick >= 1 then
		lastTimerTick = now
		if isGuiVisible then
			sessionLabel.Text = "SESSION: " .. formatTime(now - sessionStart)
		end
	end

	if now - lastPlayerRefresh >= 0.5 then
		lastPlayerRefresh = now
		if isGuiVisible and listOpen then
			refreshPlayerList()
		end
	end

	if not isGuiVisible then return end

	if isLocked then
		targetLabel.Text = "target: locked"
		targetLabel.TextColor3 = Color3.fromRGB(255, 90, 90)
	else
		local t = getClosestPlayer()
		if t then
			targetLabel.Text = (listMode == "whitelist" and "target (wl): " or "target: ") .. t.Name
			targetLabel.TextColor3 = Color3.fromRGB(255, 200, 120)
		else
			targetLabel.Text = "target: —"
			targetLabel.TextColor3 = Color3.fromRGB(200, 200, 200)
		end
	end
end)