--[[
  NOVA MENU - LocalScript
  Place it in: StarterPlayer -> StarterPlayerScripts -> LocalScript
  Works only inside your own game (Roblox Studio).

  Controls
    CTRL ........ open / close the menu
    F ........... toggle Fly      (WASD + Space / Shift)
    N ........... toggle Noclip
    Hold RMB .... aimbot
]]

-- Everything below (up to the key gate at the bottom) only runs after
-- the correct key has been entered.
local function loadNova()

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

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

---------------------------------------------------------------------
-- Settings
---------------------------------------------------------------------
local settings = {
	-- Combat
	Aim = true,
	AutoShoot = false,
	TeamCheck = true,
	WallCheck = true,
	ShowFOV = true,
	FOV = 150,
	Smooth = 0.25,
	AimPart = "Head",
	MaxDistance = 1000,
	-- Visuals
	ESP = true,
	ShowNames = true,
	ShowHealth = true,
	ShowDistance = true,
	CameraFOV = 70,
	-- Movement
	Fly = false,
	FlySpeed = 60,
	Noclip = false,
}

---------------------------------------------------------------------
-- Theme + helpers
---------------------------------------------------------------------
local theme = {
	bg = Color3.fromRGB(16, 16, 22),
	side = Color3.fromRGB(21, 21, 29),
	row = Color3.fromRGB(28, 28, 38),
	off = Color3.fromRGB(58, 58, 72),
	accent = Color3.fromRGB(124, 92, 255),
	accent2 = Color3.fromRGB(64, 180, 255),
	text = Color3.fromRGB(236, 236, 244),
	sub = Color3.fromRGB(140, 140, 158),
	enemy = Color3.fromRGB(255, 70, 70),
	friend = Color3.fromRGB(70, 220, 120),
}

local function new(class, props, parent)
	local inst = Instance.new(class)
	for k, v in pairs(props or {}) do
		inst[k] = v
	end
	inst.Parent = parent
	return inst
end

local function corner(inst, radius)
	return new("UICorner", { CornerRadius = UDim.new(0, radius) }, inst)
end

local function tween(inst, time, props)
	TweenService:Create(inst, TweenInfo.new(time, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), props):Play()
end

local order = 0
local function nextOrder()
	order += 1
	return order
end

---------------------------------------------------------------------
-- ScreenGui
---------------------------------------------------------------------
local gui = new("ScreenGui", {
	Name = "NovaMenu",
	ResetOnSpawn = false,
	IgnoreGuiInset = true,
	ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
	DisplayOrder = 100,
}, player:WaitForChild("PlayerGui"))

-- invisible modal button: frees the mouse cursor while the menu is open
local modal = new("TextButton", {
	Size = UDim2.fromOffset(0, 0),
	BackgroundTransparency = 1,
	Text = "",
	Modal = false,
}, gui)

-- FOV circle
local fovCircle = new("Frame", {
	AnchorPoint = Vector2.new(0.5, 0.5),
	BackgroundTransparency = 1,
	Visible = false,
}, gui)
corner(fovCircle, 9999)
new("UIStroke", { Color = theme.accent, Thickness = 1.5, Transparency = 0.2 }, fovCircle)

-- bottom-left hint
new("TextLabel", {
	AnchorPoint = Vector2.new(0, 1),
	Position = UDim2.new(0, 14, 1, -12),
	Size = UDim2.fromOffset(420, 16),
	BackgroundTransparency = 1,
	Text = "CTRL  Menu     F  Fly     N  Noclip     RMB  Aim",
	TextColor3 = theme.text,
	TextTransparency = 0.5,
	TextXAlignment = Enum.TextXAlignment.Left,
	Font = Enum.Font.GothamMedium,
	TextSize = 12,
}, gui)

---------------------------------------------------------------------
-- Toast notifications
---------------------------------------------------------------------
local currentToast

local function toast(text, on)
	if currentToast then
		currentToast:Destroy()
	end
	local t = new("CanvasGroup", {
		AnchorPoint = Vector2.new(0.5, 1),
		Position = UDim2.new(0.5, 0, 1, -50),
		Size = UDim2.fromOffset(220, 38),
		BackgroundColor3 = theme.bg,
		GroupTransparency = 1,
	}, gui)
	corner(t, 10)
	new("UIStroke", { Color = on == false and theme.off or theme.accent, Thickness = 1.5 }, t)
	new("TextLabel", {
		Size = UDim2.fromScale(1, 1),
		BackgroundTransparency = 1,
		Text = text,
		TextColor3 = theme.text,
		Font = Enum.Font.GothamBold,
		TextSize = 14,
	}, t)
	currentToast = t
	tween(t, 0.2, { GroupTransparency = 0, Position = UDim2.new(0.5, 0, 1, -60) })
	task.delay(1.6, function()
		if t.Parent then
			tween(t, 0.3, { GroupTransparency = 1 })
			task.delay(0.35, function()
				if t.Parent then
					t:Destroy()
				end
			end)
		end
	end)
end

---------------------------------------------------------------------
-- Main window
---------------------------------------------------------------------
local main = new("CanvasGroup", {
	Name = "Main",
	AnchorPoint = Vector2.new(0.5, 0.5),
	Position = UDim2.fromScale(0.5, 0.5),
	Size = UDim2.fromOffset(500, 390),
	BackgroundColor3 = theme.bg,
	BorderSizePixel = 0,
	GroupTransparency = 1,
	Visible = false,
}, gui)
corner(main, 14)
new("UIStroke", { Color = Color3.fromRGB(46, 46, 62), Thickness = 1.5 }, main)
local mainScale = new("UIScale", { Scale = 0.92 }, main)

-- header
local header = new("Frame", {
	Size = UDim2.new(1, 0, 0, 44),
	BackgroundTransparency = 1,
	Active = true,
}, main)

new("TextLabel", {
	Position = UDim2.fromOffset(16, 0),
	Size = UDim2.fromOffset(100, 44),
	BackgroundTransparency = 1,
	Text = "NOVA",
	TextColor3 = theme.text,
	TextXAlignment = Enum.TextXAlignment.Left,
	Font = Enum.Font.GothamBlack,
	TextSize = 20,
}, header)

new("TextLabel", {
	AnchorPoint = Vector2.new(1, 0),
	Position = UDim2.new(1, -16, 0, 0),
	Size = UDim2.fromOffset(200, 44),
	BackgroundTransparency = 1,
	Text = "CTRL to hide  -  drag to move",
	TextColor3 = theme.sub,
	TextXAlignment = Enum.TextXAlignment.Right,
	Font = Enum.Font.Gotham,
	TextSize = 12,
}, header)

local accentLine = new("Frame", {
	Position = UDim2.fromOffset(0, 44),
	Size = UDim2.new(1, 0, 0, 2),
	BackgroundColor3 = Color3.new(1, 1, 1),
	BorderSizePixel = 0,
}, main)
new("UIGradient", {
	Color = ColorSequence.new(theme.accent, theme.accent2),
}, accentLine)

-- window dragging
do
	local dragging, dragStart, startPos = false, nil, nil
	header.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
			dragging = true
			dragStart = input.Position
			startPos = main.Position
		end
	end)
	UserInputService.InputChanged:Connect(function(input)
		if dragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
			local delta = input.Position - dragStart
			main.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 or input.UserInputType == Enum.UserInputType.Touch then
			dragging = false
		end
	end)
end

-- sidebar + pages
local sidebar = new("Frame", {
	Position = UDim2.fromOffset(0, 46),
	Size = UDim2.new(0, 120, 1, -46),
	BackgroundColor3 = theme.side,
	BorderSizePixel = 0,
}, main)
new("UIListLayout", { Padding = UDim.new(0, 4), SortOrder = Enum.SortOrder.LayoutOrder }, sidebar)
new("UIPadding", {
	PaddingTop = UDim.new(0, 10), PaddingLeft = UDim.new(0, 8), PaddingRight = UDim.new(0, 8),
}, sidebar)

local pagesHolder = new("Frame", {
	Position = UDim2.fromOffset(128, 54),
	Size = UDim2.new(1, -136, 1, -62),
	BackgroundTransparency = 1,
}, main)

local pages, tabs = {}, {}

local function selectTab(name)
	for tabName, page in pairs(pages) do
		page.Visible = (tabName == name)
		local btn = tabs[tabName]
		tween(btn, 0.15, {
			BackgroundTransparency = tabName == name and 0.7 or 1,
			TextColor3 = tabName == name and theme.text or theme.sub,
		})
	end
end

local function createPage(name)
	local btn = new("TextButton", {
		Size = UDim2.new(1, 0, 0, 36),
		BackgroundColor3 = theme.accent,
		BackgroundTransparency = 1,
		Text = "  " .. name,
		TextColor3 = theme.sub,
		TextXAlignment = Enum.TextXAlignment.Left,
		Font = Enum.Font.GothamMedium,
		TextSize = 14,
		AutoButtonColor = false,
		LayoutOrder = nextOrder(),
	}, sidebar)
	corner(btn, 8)
	btn.MouseButton1Click:Connect(function()
		selectTab(name)
	end)
	tabs[name] = btn

	local page = new("ScrollingFrame", {
		Size = UDim2.fromScale(1, 1),
		BackgroundTransparency = 1,
		BorderSizePixel = 0,
		ScrollBarThickness = 3,
		ScrollBarImageColor3 = theme.accent,
		CanvasSize = UDim2.new(),
		AutomaticCanvasSize = Enum.AutomaticSize.Y,
		Visible = false,
	}, pagesHolder)
	new("UIListLayout", { Padding = UDim.new(0, 6), SortOrder = Enum.SortOrder.LayoutOrder }, page)
	new("UIPadding", { PaddingRight = UDim.new(0, 8), PaddingBottom = UDim.new(0, 8) }, page)
	pages[name] = page
	return page
end

---------------------------------------------------------------------
-- UI widgets
---------------------------------------------------------------------
local toggleSetters = {}

local function makeRow(page, height)
	local f = new("Frame", {
		Size = UDim2.new(1, 0, 0, height),
		BackgroundColor3 = theme.row,
		BorderSizePixel = 0,
		LayoutOrder = nextOrder(),
	}, page)
	corner(f, 8)
	return f
end

local function addSection(page, text)
	new("TextLabel", {
		Size = UDim2.new(1, 0, 0, 20),
		BackgroundTransparency = 1,
		Text = string.upper(text),
		TextColor3 = theme.accent2,
		TextXAlignment = Enum.TextXAlignment.Left,
		Font = Enum.Font.GothamBold,
		TextSize = 11,
		LayoutOrder = nextOrder(),
	}, page)
end

local function addLabel(page, text)
	new("TextLabel", {
		Size = UDim2.new(1, 0, 0, 30),
		BackgroundTransparency = 1,
		Text = text,
		TextColor3 = theme.sub,
		TextWrapped = true,
		TextXAlignment = Enum.TextXAlignment.Left,
		TextYAlignment = Enum.TextYAlignment.Top,
		Font = Enum.Font.Gotham,
		TextSize = 12,
		LayoutOrder = nextOrder(),
	}, page)
end

local function addToggle(page, label, key, hotkey, callback)
	local f = makeRow(page, 38)
	new("TextLabel", {
		Position = UDim2.fromOffset(12, 0),
		Size = UDim2.new(1, -110, 1, 0),
		BackgroundTransparency = 1,
		Text = label,
		TextColor3 = theme.text,
		TextXAlignment = Enum.TextXAlignment.Left,
		Font = Enum.Font.GothamMedium,
		TextSize = 14,
	}, f)

	if hotkey then
		local chip = new("TextLabel", {
			AnchorPoint = Vector2.new(1, 0.5),
			Position = UDim2.new(1, -62, 0.5, 0),
			Size = UDim2.fromOffset(24, 20),
			BackgroundColor3 = theme.off,
			Text = hotkey,
			TextColor3 = theme.text,
			Font = Enum.Font.GothamBold,
			TextSize = 11,
		}, f)
		corner(chip, 5)
	end

	local sw = new("Frame", {
		AnchorPoint = Vector2.new(1, 0.5),
		Position = UDim2.new(1, -12, 0.5, 0),
		Size = UDim2.fromOffset(42, 22),
		BackgroundColor3 = theme.off,
	}, f)
	corner(sw, 11)
	local knob = new("Frame", {
		AnchorPoint = Vector2.new(0, 0.5),
		Position = UDim2.new(0, 3, 0.5, 0),
		Size = UDim2.fromOffset(16, 16),
		BackgroundColor3 = Color3.new(1, 1, 1),
	}, sw)
	corner(knob, 8)

	local btn = new("TextButton", {
		Size = UDim2.fromScale(1, 1),
		BackgroundTransparency = 1,
		Text = "",
	}, f)

	local function render()
		local on = settings[key]
		tween(sw, 0.15, { BackgroundColor3 = on and theme.accent or theme.off })
		tween(knob, 0.15, { Position = on and UDim2.new(1, -19, 0.5, 0) or UDim2.new(0, 3, 0.5, 0) })
	end

	local function set(value)
		settings[key] = value
		render()
		if callback then
			callback(value)
		end
	end

	btn.MouseButton1Click:Connect(function()
		set(not settings[key])
	end)
	toggleSetters[key] = set
	render()
end

local function addSlider(page, label, key, min, max, decimals, suffix)
	local f = makeRow(page, 52)
	new("TextLabel", {
		Position = UDim2.fromOffset(12, 6),
		Size = UDim2.new(1, -90, 0, 18),
		BackgroundTransparency = 1,
		Text = label,
		TextColor3 = theme.text,
		TextXAlignment = Enum.TextXAlignment.Left,
		Font = Enum.Font.GothamMedium,
		TextSize = 14,
	}, f)
	local valueLabel = new("TextLabel", {
		AnchorPoint = Vector2.new(1, 0),
		Position = UDim2.new(1, -12, 0, 6),
		Size = UDim2.fromOffset(80, 18),
		BackgroundTransparency = 1,
		TextColor3 = theme.accent2,
		TextXAlignment = Enum.TextXAlignment.Right,
		Font = Enum.Font.GothamBold,
		TextSize = 13,
	}, f)

	local bar = new("Frame", {
		Position = UDim2.fromOffset(12, 36),
		Size = UDim2.new(1, -24, 0, 6),
		BackgroundColor3 = theme.off,
		BorderSizePixel = 0,
	}, f)
	corner(bar, 3)
	local fill = new("Frame", {
		Size = UDim2.fromScale(0, 1),
		BackgroundColor3 = theme.accent,
		BorderSizePixel = 0,
	}, bar)
	corner(fill, 3)
	new("UIGradient", { Color = ColorSequence.new(theme.accent, theme.accent2) }, fill)
	local knob = new("Frame", {
		AnchorPoint = Vector2.new(0.5, 0.5),
		Position = UDim2.fromScale(0, 0.5),
		Size = UDim2.fromOffset(14, 14),
		BackgroundColor3 = Color3.new(1, 1, 1),
	}, bar)
	corner(knob, 7)

	local function update(value)
		local mult = 10 ^ decimals
		value = math.floor(math.clamp(value, min, max) * mult + 0.5) / mult
		settings[key] = value
		local alpha = (value - min) / (max - min)
		fill.Size = UDim2.fromScale(alpha, 1)
		knob.Position = UDim2.fromScale(alpha, 0.5)
		valueLabel.Text = tostring(value) .. (suffix or "")
	end
	update(settings[key])

	local dragging = false
	local function fromX(x)
		local alpha = math.clamp((x - bar.AbsolutePosition.X) / bar.AbsoluteSize.X, 0, 1)
		update(min + (max - min) * alpha)
	end
	bar.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
			dragging = true
			fromX(input.Position.X)
		end
	end)
	UserInputService.InputChanged:Connect(function(input)
		if dragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
			fromX(input.Position.X)
		end
	end)
	UserInputService.InputEnded:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
			dragging = false
		end
	end)
end

local function addCycle(page, label, key, options)
	local f = makeRow(page, 38)
	new("TextLabel", {
		Position = UDim2.fromOffset(12, 0),
		Size = UDim2.new(1, -110, 1, 0),
		BackgroundTransparency = 1,
		Text = label,
		TextColor3 = theme.text,
		TextXAlignment = Enum.TextXAlignment.Left,
		Font = Enum.Font.GothamMedium,
		TextSize = 14,
	}, f)
	local btn = new("TextButton", {
		AnchorPoint = Vector2.new(1, 0.5),
		Position = UDim2.new(1, -12, 0.5, 0),
		Size = UDim2.fromOffset(80, 24),
		BackgroundColor3 = theme.accent,
		Text = settings[key],
		TextColor3 = Color3.new(1, 1, 1),
		Font = Enum.Font.GothamBold,
		TextSize = 12,
		AutoButtonColor = true,
	}, f)
	corner(btn, 6)
	btn.MouseButton1Click:Connect(function()
		local index = table.find(options, settings[key]) or 1
		index = index % #options + 1
		settings[key] = options[index]
		btn.Text = options[index]
	end)
end

---------------------------------------------------------------------
-- Toast helper for state changes
---------------------------------------------------------------------
local function stateToast(name)
	return function(on)
		toast(name .. ": " .. (on and "ON" or "OFF"), on)
	end
end

---------------------------------------------------------------------
-- Build pages
---------------------------------------------------------------------
local combat = createPage("Combat")
local visuals = createPage("Visuals")
local movement = createPage("Movement")

addSection(combat, "Aimbot")
addToggle(combat, "Aimbot (hold RMB)", "Aim")
addToggle(combat, "Auto shoot", "AutoShoot")
addToggle(combat, "Team check", "TeamCheck")
addToggle(combat, "Wall check", "WallCheck")
addCycle(combat, "Aim part", "AimPart", { "Head", "Body" })
addSection(combat, "Tuning")
addToggle(combat, "Show FOV circle", "ShowFOV")
addSlider(combat, "Aim FOV", "FOV", 30, 600, 0, " px")
addSlider(combat, "Smoothness", "Smooth", 0.05, 1, 2, "")
addSlider(combat, "Max distance", "MaxDistance", 50, 3000, 0, " st")

addSection(visuals, "ESP")
addToggle(visuals, "ESP (through walls)", "ESP")
addToggle(visuals, "Names", "ShowNames")
addToggle(visuals, "Health bars", "ShowHealth")
addToggle(visuals, "Distance", "ShowDistance")
addSection(visuals, "Camera")
addSlider(visuals, "Camera FOV", "CameraFOV", 40, 120, 0, "°")

addSection(movement, "Fly")
addToggle(movement, "Fly", "Fly", "F", stateToast("Fly"))
addSlider(movement, "Fly speed", "FlySpeed", 10, 300, 0, "")
addLabel(movement, "WASD to move, Space to go up, Shift to go down.")
addSection(movement, "Collision")
addToggle(movement, "Noclip", "Noclip", "N", stateToast("Noclip"))

selectTab("Combat")

---------------------------------------------------------------------
-- Open / close menu (CTRL)
---------------------------------------------------------------------
local menuOpen = false

local function setMenu(open)
	menuOpen = open
	modal.Modal = open
	if open then
		main.Visible = true
		tween(main, 0.2, { GroupTransparency = 0 })
		tween(mainScale, 0.2, { Scale = 1 })
	else
		tween(main, 0.15, { GroupTransparency = 1 })
		tween(mainScale, 0.15, { Scale = 0.92 })
		task.delay(0.17, function()
			if not menuOpen then
				main.Visible = false
			end
		end)
	end
end

UserInputService.InputBegan:Connect(function(input, processed)
	if input.KeyCode == Enum.KeyCode.LeftControl or input.KeyCode == Enum.KeyCode.RightControl then
		setMenu(not menuOpen)
		return
	end
	if processed then
		return
	end
	if input.KeyCode == Enum.KeyCode.F then
		toggleSetters.Fly(not settings.Fly)
	elseif input.KeyCode == Enum.KeyCode.N then
		toggleSetters.Noclip(not settings.Noclip)
	end
end)

---------------------------------------------------------------------
-- ESP
---------------------------------------------------------------------
local espObjects = {}

local function destroyEsp(plr)
	local o = espObjects[plr]
	if o then
		o.Highlight:Destroy()
		o.Billboard:Destroy()
		espObjects[plr] = nil
	end
end

local function createEsp(plr, char)
	local head = char:FindFirstChild("Head")
	if not head then
		return nil
	end

	local highlight = new("Highlight", {
		Name = "NovaHighlight",
		Adornee = char,
		DepthMode = Enum.HighlightDepthMode.AlwaysOnTop,
		FillTransparency = 0.65,
		OutlineTransparency = 0,
		OutlineColor = Color3.new(1, 1, 1),
	}, char)

	local billboard = new("BillboardGui", {
		Name = "NovaBillboard",
		Adornee = head,
		AlwaysOnTop = true,
		Size = UDim2.fromOffset(150, 48),
		StudsOffset = Vector3.new(0, 2.8, 0),
	}, char)

	local nameLabel = new("TextLabel", {
		Size = UDim2.new(1, 0, 0, 18),
		BackgroundTransparency = 1,
		TextColor3 = Color3.new(1, 1, 1),
		TextStrokeTransparency = 0.4,
		Font = Enum.Font.GothamBold,
		TextSize = 14,
	}, billboard)

	local healthBg = new("Frame", {
		Position = UDim2.new(0.2, 0, 0, 22),
		Size = UDim2.new(0.6, 0, 0, 5),
		BackgroundColor3 = Color3.fromRGB(20, 20, 20),
		BorderSizePixel = 0,
	}, billboard)
	corner(healthBg, 3)
	local healthFill = new("Frame", {
		Size = UDim2.fromScale(1, 1),
		BackgroundColor3 = theme.friend,
		BorderSizePixel = 0,
	}, healthBg)
	corner(healthFill, 3)

	local distLabel = new("TextLabel", {
		Position = UDim2.fromOffset(0, 30),
		Size = UDim2.new(1, 0, 0, 16),
		BackgroundTransparency = 1,
		TextColor3 = Color3.fromRGB(220, 220, 230),
		TextStrokeTransparency = 0.5,
		Font = Enum.Font.Gotham,
		TextSize = 12,
	}, billboard)

	local o = {
		Char = char,
		Highlight = highlight,
		Billboard = billboard,
		Name = nameLabel,
		HealthBg = healthBg,
		HealthFill = healthFill,
		Dist = distLabel,
	}
	espObjects[plr] = o
	return o
end

local function isEnemy(plr)
	return plr.Team == nil or plr.Team ~= player.Team
end

local function updateEsp()
	local myChar = player.Character
	local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")

	for _, plr in ipairs(Players:GetPlayers()) do
		if plr ~= player then
			local char = plr.Character
			local hum = char and char:FindFirstChildOfClass("Humanoid")
			local root = char and char:FindFirstChild("HumanoidRootPart")
			local dist = (root and myRoot) and (root.Position - myRoot.Position).Magnitude or 0

			local show = settings.ESP
				and hum ~= nil
				and root ~= nil
				and hum.Health > 0
				and dist <= settings.MaxDistance
				and (not settings.TeamCheck or isEnemy(plr))

			if show then
				local o = espObjects[plr]
				if o and o.Char ~= char then
					destroyEsp(plr)
					o = nil
				end
				if not o then
					o = createEsp(plr, char)
				end
				if o then
					local color = isEnemy(plr) and theme.enemy or theme.friend
					o.Highlight.FillColor = color
					o.Name.Visible = settings.ShowNames
					o.Name.Text = plr.DisplayName
					o.HealthBg.Visible = settings.ShowHealth
					local hp = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
					o.HealthFill.Size = UDim2.fromScale(hp, 1)
					o.HealthFill.BackgroundColor3 = theme.enemy:Lerp(theme.friend, hp)
					o.Dist.Visible = settings.ShowDistance
					o.Dist.Text = string.format("%d studs", dist)
				end
			else
				destroyEsp(plr)
			end
		end
	end
end

Players.PlayerRemoving:Connect(destroyEsp)

---------------------------------------------------------------------
-- Aimbot
---------------------------------------------------------------------
local function isVisible(char, part)
	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { player.Character }
	local origin = camera.CFrame.Position
	local result = workspace:Raycast(origin, part.Position - origin, params)
	return result == nil or result.Instance:IsDescendantOf(char)
end

local function getTarget()
	local center = camera.ViewportSize / 2
	local myRoot = player.Character and player.Character:FindFirstChild("HumanoidRootPart")
	local partName = settings.AimPart == "Head" and "Head" or "HumanoidRootPart"
	local best, bestDist = nil, settings.FOV

	for _, plr in ipairs(Players:GetPlayers()) do
		if plr ~= player and (not settings.TeamCheck or isEnemy(plr)) then
			local char = plr.Character
			local part = char and (char:FindFirstChild(partName) or char:FindFirstChild("HumanoidRootPart"))
			local hum = char and char:FindFirstChildOfClass("Humanoid")
			if part and hum and hum.Health > 0 then
				local inRange = not myRoot or (part.Position - myRoot.Position).Magnitude <= settings.MaxDistance
				if inRange then
					local screenPos, onScreen = camera:WorldToViewportPoint(part.Position)
					if onScreen then
						local d = (Vector2.new(screenPos.X, screenPos.Y) - center).Magnitude
						if d < bestDist and (not settings.WallCheck or isVisible(char, part)) then
							best, bestDist = part, d
						end
					end
				end
			end
		end
	end
	return best
end

local lastShot = 0

local function updateAim()
	if not settings.Aim or menuOpen then
		return
	end
	if not UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2) then
		return
	end

	local target = getTarget()
	if target then
		local goal = CFrame.new(camera.CFrame.Position, target.Position)
		camera.CFrame = camera.CFrame:Lerp(goal, settings.Smooth)

		if settings.AutoShoot and os.clock() - lastShot > 0.1 then
			local tool = player.Character and player.Character:FindFirstChildOfClass("Tool")
			if tool then
				lastShot = os.clock()
				tool:Activate()
			end
		end
	end
end

---------------------------------------------------------------------
-- Per-frame update (runs right after the default camera script)
---------------------------------------------------------------------
RunService:BindToRenderStep("NovaUpdate", Enum.RenderPriority.Camera.Value + 1, function()
	camera = workspace.CurrentCamera
	camera.FieldOfView = settings.CameraFOV

	fovCircle.Visible = settings.Aim and settings.ShowFOV
	fovCircle.Size = UDim2.fromOffset(settings.FOV * 2, settings.FOV * 2)
	fovCircle.Position = UDim2.fromOffset(camera.ViewportSize.X / 2, camera.ViewportSize.Y / 2)

	updateEsp()
	updateAim()
end)

---------------------------------------------------------------------
-- Fly
---------------------------------------------------------------------
local flyWasActive = false

RunService.Heartbeat:Connect(function()
	local char = player.Character
	local root = char and char:FindFirstChild("HumanoidRootPart")
	local hum = char and char:FindFirstChildOfClass("Humanoid")
	if not (root and hum) then
		return
	end

	if settings.Fly then
		flyWasActive = true
		hum.PlatformStand = true

		local cf = camera.CFrame
		local dir = Vector3.zero
		if not UserInputService:GetFocusedTextBox() then
			if UserInputService:IsKeyDown(Enum.KeyCode.W) then dir += cf.LookVector end
			if UserInputService:IsKeyDown(Enum.KeyCode.S) then dir -= cf.LookVector end
			if UserInputService:IsKeyDown(Enum.KeyCode.D) then dir += cf.RightVector end
			if UserInputService:IsKeyDown(Enum.KeyCode.A) then dir -= cf.RightVector end
			if UserInputService:IsKeyDown(Enum.KeyCode.Space) then dir += Vector3.yAxis end
			if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then dir -= Vector3.yAxis end
		end
		if dir.Magnitude > 0 then
			dir = dir.Unit
		end

		root.AssemblyLinearVelocity = dir * settings.FlySpeed
		root.AssemblyAngularVelocity = Vector3.zero

		local flat = Vector3.new(cf.LookVector.X, 0, cf.LookVector.Z)
		if flat.Magnitude > 0.001 then
			root.CFrame = CFrame.lookAt(root.Position, root.Position + flat)
		end
	elseif flyWasActive then
		flyWasActive = false
		hum.PlatformStand = false
		root.AssemblyLinearVelocity = Vector3.zero
	end
end)

---------------------------------------------------------------------
-- Noclip
---------------------------------------------------------------------
local noclipWasActive = false
local collidableParts = { "HumanoidRootPart", "Head", "Torso", "UpperTorso", "LowerTorso" }

RunService.Stepped:Connect(function()
	local char = player.Character
	if not char then
		return
	end

	if settings.Noclip then
		noclipWasActive = true
		for _, part in ipairs(char:GetDescendants()) do
			if part:IsA("BasePart") then
				part.CanCollide = false
			end
		end
	elseif noclipWasActive then
		noclipWasActive = false
		for _, name in ipairs(collidableParts) do
			local part = char:FindFirstChild(name)
			if part and part:IsA("BasePart") then
				part.CanCollide = true
			end
		end
	end
end)

---------------------------------------------------------------------
toast("Press CTRL to open the menu")

end -- loadNova

---------------------------------------------------------------------
-- Key gate: the menu does NOT start without the correct key
---------------------------------------------------------------------
local KEY = "trolisgoat"

do
	local Players = game:GetService("Players")
	local TweenService = game:GetService("TweenService")
	local plr = Players.LocalPlayer

	local C = {
		bg = Color3.fromRGB(16, 16, 22),
		row = Color3.fromRGB(28, 28, 38),
		accent = Color3.fromRGB(124, 92, 255),
		accent2 = Color3.fromRGB(64, 180, 255),
		text = Color3.fromRGB(236, 236, 244),
		sub = Color3.fromRGB(140, 140, 158),
		bad = Color3.fromRGB(255, 80, 80),
		good = Color3.fromRGB(70, 220, 120),
	}

	local function make(class, props, parent)
		local inst = Instance.new(class)
		for k, v in pairs(props) do
			inst[k] = v
		end
		inst.Parent = parent
		return inst
	end
	local function round(inst, r)
		make("UICorner", { CornerRadius = UDim.new(0, r) }, inst)
	end

	local keyGui = make("ScreenGui", {
		Name = "NovaKey",
		ResetOnSpawn = false,
		IgnoreGuiInset = true,
		DisplayOrder = 200,
	}, plr:WaitForChild("PlayerGui"))

	-- frees the mouse cursor while the key window is open
	make("TextButton", {
		Size = UDim2.fromOffset(0, 0),
		BackgroundTransparency = 1,
		Text = "",
		Modal = true,
	}, keyGui)

	local card = make("CanvasGroup", {
		AnchorPoint = Vector2.new(0.5, 0.5),
		Position = UDim2.fromScale(0.5, 0.5),
		Size = UDim2.fromOffset(340, 200),
		BackgroundColor3 = C.bg,
		BorderSizePixel = 0,
	}, keyGui)
	round(card, 14)
	make("UIStroke", { Color = Color3.fromRGB(46, 46, 62), Thickness = 1.5 }, card)

	make("TextLabel", {
		Position = UDim2.fromOffset(0, 14),
		Size = UDim2.new(1, 0, 0, 30),
		BackgroundTransparency = 1,
		Text = "NOVA",
		TextColor3 = C.text,
		Font = Enum.Font.GothamBlack,
		TextSize = 24,
	}, card)
	make("TextLabel", {
		Position = UDim2.fromOffset(0, 44),
		Size = UDim2.new(1, 0, 0, 18),
		BackgroundTransparency = 1,
		Text = "Enter your key to continue",
		TextColor3 = C.sub,
		Font = Enum.Font.Gotham,
		TextSize = 13,
	}, card)

	local line = make("Frame", {
		Position = UDim2.fromOffset(0, 0),
		Size = UDim2.new(1, 0, 0, 3),
		BackgroundColor3 = Color3.new(1, 1, 1),
		BorderSizePixel = 0,
	}, card)
	make("UIGradient", { Color = ColorSequence.new(C.accent, C.accent2) }, line)

	local box = make("TextBox", {
		Position = UDim2.fromOffset(20, 78),
		Size = UDim2.new(1, -40, 0, 36),
		BackgroundColor3 = C.row,
		PlaceholderText = "Key",
		PlaceholderColor3 = C.sub,
		Text = "",
		TextColor3 = C.text,
		Font = Enum.Font.GothamMedium,
		TextSize = 15,
		ClearTextOnFocus = false,
	}, card)
	round(box, 8)

	local status = make("TextLabel", {
		Position = UDim2.fromOffset(20, 118),
		Size = UDim2.new(1, -40, 0, 16),
		BackgroundTransparency = 1,
		Text = "",
		TextColor3 = C.bad,
		Font = Enum.Font.GothamMedium,
		TextSize = 12,
	}, card)

	local button = make("TextButton", {
		Position = UDim2.fromOffset(20, 142),
		Size = UDim2.new(1, -40, 0, 38),
		BackgroundColor3 = C.accent,
		Text = "Unlock",
		TextColor3 = Color3.new(1, 1, 1),
		Font = Enum.Font.GothamBold,
		TextSize = 15,
	}, card)
	round(button, 8)

	local unlocked = false

	local function shake()
		local base = card.Position
		for _, dx in ipairs({ 10, -10, 6, -6, 0 }) do
			TweenService:Create(card, TweenInfo.new(0.05), {
				Position = UDim2.new(base.X.Scale, base.X.Offset + dx, base.Y.Scale, base.Y.Offset),
			}):Play()
			task.wait(0.05)
		end
	end

	local function submit()
		if unlocked then
			return
		end
		local entered = string.lower((box.Text:gsub("%s+", "")))
		if entered == KEY then
			unlocked = true
			status.TextColor3 = C.good
			status.Text = "Access granted"
			task.wait(0.4)
			TweenService:Create(card, TweenInfo.new(0.25), { GroupTransparency = 1 }):Play()
			task.wait(0.3)
			keyGui:Destroy()
			loadNova()
		else
			status.TextColor3 = C.bad
			status.Text = "Wrong key"
			box.Text = ""
			shake()
		end
	end

	button.MouseButton1Click:Connect(submit)
	box.FocusLost:Connect(function(enterPressed)
		if enterPressed then
			submit()
		end
	end)
end