-- [[ 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 ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6ad965699f7399b1d88babfc"))()
	end)
end)
--[[rscripts:analytics:end]]

-- Luau | ZyonYBA.lua | Your Bizarre Adventure / Xeno
-- Versão 0.2: base local revisada + correções de runtime + refactor de UI
-- Sem remote loader e sem chamadas remotas de combate/progresso.
-- HUD local, sem libs externas.

local function create_hud()
	local players = game:GetService("Players")
	local input = game:GetService("UserInputService")
	local run = game:GetService("RunService")

	local ui = {
		Options = {},
		Connections = {},
		Open = true,
		Unloaded = false,
		Errors = {},
		ModuleStatus = {},
	}

	local colors = {
		bg = Color3.fromRGB(15, 17, 24),
		panel = Color3.fromRGB(23, 26, 36),
		raised = Color3.fromRGB(31, 35, 48),
		line = Color3.fromRGB(48, 53, 70),
		text = Color3.fromRGB(236, 239, 248),
		muted = Color3.fromRGB(147, 155, 177),
		accent = Color3.fromRGB(158, 132, 255),
		danger = Color3.fromRGB(255, 112, 133),
	}

	local function make(class, props, parent)
		local obj = Instance.new(class)
		for key, value in pairs(props or {}) do
			obj[key] = value
		end
		obj.Parent = parent
		return obj
	end

	local function round(obj, radius)
		make("UICorner", { CornerRadius = UDim.new(0, radius or 8) }, obj)
	end

	local function border(obj)
		make(
			"UIStroke",
			{
				Color = colors.line,
				Thickness = 1,
				ApplyStrokeMode = Enum.ApplyStrokeMode.Border,
			},
			obj
		)
	end

	local function label(parent, text, size)
		return make(
			"TextLabel",
			{
				BackgroundTransparency = 1,
				Text = text,
				TextColor3 = colors.text,
				Font = Enum.Font.Gotham,
				TextSize = size or 12,
				TextXAlignment = Enum.TextXAlignment.Left,
				TextTruncate = Enum.TextTruncate.AtEnd,
				Size = UDim2.new(1, 0, 0, 22),
			},
			parent
		)
	end

	local function make_button(parent, text)
		local obj = make(
			"TextButton",
			{
				BackgroundColor3 = colors.raised,
				BorderSizePixel = 0,
				AutoButtonColor = true,
				Text = text,
				TextColor3 = colors.text,
				TextSize = 12,
				Font = Enum.Font.GothamMedium,
				Size = UDim2.new(1, 0, 0, 32),
			},
			parent
		)
		round(obj, 7)
		return obj
	end

	function ui:Connect(signal, callback)
		local conn = signal:Connect(callback)
		table.insert(self.Connections, conn)
		return conn
	end

	function ui:RecordError(area, err)
		local entry = self.Errors[area] or { count = 0 }
		entry.count += 1
		entry.message = tostring(err)
		self.Errors[area] = entry
		if entry.count == 1 then
			warn("[Zyon / " .. area .. "] " .. entry.message)
		end
	end

	function ui:Run(area, callback, ...)
		if self.Unloaded then
			return false
		end
		local result = table.pack(pcall(callback, ...))
		if not result[1] then
			self:RecordError(area, result[2])
		end
		return table.unpack(result, 1, result.n)
	end

	local gui = make(
		"ScreenGui",
		{
			Name = "ZyonYBA",
			ResetOnSpawn = false,
			IgnoreGuiInset = true,
			ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
			DisplayOrder = 80,
		}
	)

	local parent_ok = false
	if type(gethui) == "function" then
		parent_ok = pcall(function()
			local container = gethui()
			assert(container, "gethui retornou nil")
			gui.Parent = container
		end)
	end

	if not parent_ok then
		parent_ok = pcall(function()
			gui.Parent = game:GetService("CoreGui")
		end)
	end

	if not parent_ok then
		gui.Parent = players.LocalPlayer:WaitForChild("PlayerGui")
	end

	ui.ScreenGui = gui

	local shell = make(
		"Frame",
		{
			Name = "Window",
			Size = UDim2.fromOffset(840, 580),
			AnchorPoint = Vector2.new(0.5, 0.5),
			Position = UDim2.fromScale(0.5, 0.5),
			BackgroundColor3 = colors.bg,
			BorderSizePixel = 0,
			Active = true,
			ZIndex = 10,
		},
		gui
	)

	round(shell, 12)
	border(shell)

	local scale = make("UIScale", { Scale = 1 }, shell)

	local function resize()
		local camera = workspace.CurrentCamera
		if camera then
			scale.Scale = math.clamp(
				math.min((camera.ViewportSize.X - 24) / 840, (camera.ViewportSize.Y - 32) / 580),
				0.45,
				1
			)
		end
	end

	resize()

	local titlebar = make(
		"Frame",
		{
			BackgroundTransparency = 1,
			Size = UDim2.new(1, 0, 0, 64),
			Active = true,
		},
		shell
	)

	local brand = label(titlebar, "ZYON", 20)
	brand.Font = Enum.Font.GothamBold
	brand.Position = UDim2.fromOffset(22, 12)
	brand.Size = UDim2.fromOffset(145, 25)

	local sub = label(titlebar, "YBA  /  0.2", 10)
	sub.TextColor3 = colors.muted
	sub.Position = UDim2.fromOffset(23, 37)
	sub.Size = UDim2.fromOffset(170, 18)

	local current = label(titlebar, "Combate", 17)
	current.Position = UDim2.fromOffset(205, 22)
	current.Size = UDim2.fromOffset(235, 24)

	local search = make(
		"TextBox",
		{
			Size = UDim2.fromOffset(210, 32),
			Position = UDim2.new(1, -310, 0, 18),
			BackgroundColor3 = colors.panel,
			BorderSizePixel = 0,
			Text = "",
			PlaceholderText = "Buscar nesta aba...",
			PlaceholderColor3 = colors.muted,
			TextColor3 = colors.text,
			TextSize = 11,
			Font = Enum.Font.Gotham,
			ClearTextOnFocus = false,
		},
		titlebar
	)

	round(search, 7)

	local minimize = make_button(titlebar, "—")
	minimize.Position = UDim2.new(1, -86, 0, 18)
	minimize.Size = UDim2.fromOffset(30, 30)

	local close = make_button(titlebar, "×")
	close.Position = UDim2.new(1, -47, 0, 18)
	close.Size = UDim2.fromOffset(30, 30)

	local cursor_gui = make(
		"ScreenGui",
		{
			Name = "ZyonCursorOverlay",
			ResetOnSpawn = false,
			IgnoreGuiInset = true,
			ScreenInsets = Enum.ScreenInsets.None,
			ClipToDeviceSafeArea = false,
			ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
			DisplayOrder = 2147483647,
		},
		gui.Parent
	)

	local cursor = make(
		"Frame",
		{
			Name = "Pointer",
			Size = UDim2.fromOffset(21, 29),
			BackgroundTransparency = 1,
			BorderSizePixel = 0,
			Active = false,
			Visible = false,
			ZIndex = 1,
		},
		cursor_gui
	)

	ui.CursorGui = cursor_gui
	ui.CursorRoot = cursor

	local polygon = {
		{ 0, 0 }, { 0, 22 }, { 5, 17 }, { 10, 28 }, { 15, 25 }, { 10, 16 }, { 20, 16 }
	}

	local function inside(x, y)
		local hit = false
		local previous = #polygon
		for index, point in ipairs(polygon) do
			local other = polygon[previous]
			if
				(point[2] > y) ~= (other[2] > y)
				and x < (other[1] - point[1]) * (y - point[2]) / (other[2] - point[2]) + point[1]
			then
				hit = not hit
			end
			previous = index
		end
		return hit
	end

	for y = 0, 28 do
		local left, right, inner_left, inner_right
		for x = 0, 20 do
			if inside(x + 0.5, y + 0.5) then
				left = left or x
				right = x
				if
					inside(x - 0.5, y + 0.5)
					and inside(x + 1.5, y + 0.5)
					and inside(x + 0.5, y - 0.5)
					and inside(x + 0.5, y + 1.5)
				then
					inner_left = inner_left or x
					inner_right = x
				end
			end
		end

		if left then
			make(
				"Frame",
				{
					BackgroundColor3 = Color3.fromRGB(20, 16, 32),
					BorderSizePixel = 0,
					Active = false,
					Position = UDim2.fromOffset(left, y),
					Size = UDim2.fromOffset(right - left + 1, 1),
					ZIndex = 1,
				},
				cursor
			)
		end

		if inner_left then
			make(
				"Frame",
				{
					BackgroundColor3 = Color3.fromRGB(248, 246, 255),
					BorderSizePixel = 0,
					Active = false,
					Position = UDim2.fromOffset(inner_left, y),
					Size = UDim2.fromOffset(inner_right - inner_left + 1, 1),
					ZIndex = 2,
				},
				cursor
			)
		end
	end

	local cursor_binding = "ZyonYBACursor"
	local cursor_active = false
	local previous_mouse_behavior, previous_mouse_icon

	local function update_cursor()
		if ui.Unloaded or not ui.Open then
			return
		end
		input.MouseBehavior = Enum.MouseBehavior.Default
		input.MouseIconEnabled = false
		local location = input:GetMouseLocation()
		cursor.Position = UDim2.fromOffset(location.X, location.Y)
		cursor.Visible = input.MouseEnabled
	end

	local function set_cursor_enabled(enabled)
		if enabled == cursor_active then
			return
		end
		cursor_active = enabled
		minimize.Modal = enabled
		if enabled then
			previous_mouse_behavior = input.MouseBehavior
			previous_mouse_icon = input.MouseIconEnabled
			run:BindToRenderStep(cursor_binding, Enum.RenderPriority.Last.Value + 1, update_cursor)
			update_cursor()
		else
			run:UnbindFromRenderStep(cursor_binding)
			cursor.Visible = false
			if previous_mouse_behavior ~= nil then
				input.MouseBehavior = previous_mouse_behavior
			end
			if previous_mouse_icon ~= nil then
				input.MouseIconEnabled = previous_mouse_icon
			end
			previous_mouse_behavior = nil
			previous_mouse_icon = nil
		end
	end

	set_cursor_enabled(true)

	local nav = make(
		"Frame",
		{
			BackgroundTransparency = 1,
			Size = UDim2.new(0, 174, 1, -128),
			Position = UDim2.fromOffset(14, 76),
		},
		shell
	)

	make("UIListLayout", { Padding = UDim.new(0, 7), SortOrder = Enum.SortOrder.LayoutOrder }, nav)

	local footer = label(shell, "RightCtrl · abrir/fechar   |   Painel pronto; integração em análise", 10)
	footer.TextColor3 = colors.muted
	footer.Position = UDim2.new(0, 22, 1, -29)
	footer.Size = UDim2.new(1, -44, 0, 20)
	ui.Footer = footer

	local toast = label(gui, "", 12)
	toast.AnchorPoint = Vector2.new(0.5, 1)
	toast.Position = UDim2.new(0.5, 0, 1, -24)
	toast.Size = UDim2.fromOffset(590, 58)
	toast.BackgroundTransparency = 0
	toast.BackgroundColor3 = colors.raised
	toast.TextWrapped = true
	toast.TextTruncate = Enum.TextTruncate.None
	toast.TextXAlignment = Enum.TextXAlignment.Center
	toast.Visible = false
	toast.ZIndex = 40
	round(toast)

	local toast_id = 0

	function ui:Notify(info)
		if self.Unloaded then
			return
		end
		toast_id += 1
		local id = toast_id
		toast.Text = tostring(info.Title or "Zyon") .. "  ·  " .. tostring(info.Content or "")
		toast.Visible = true
		task.delay(info.Duration or 4, function()
			if not self.Unloaded and toast_id == id then
				toast.Visible = false
			end
		end)
	end

	local floating = make_button(gui, "Z")
	floating.Size = UDim2.fromOffset(42, 42)
	floating.Position = UDim2.new(0, 16, 0.5, -21)
	floating.ZIndex = 30
	border(floating)

	local tabs = {}
	local active_tab
	local active_drag
	local drag_begin
	local drag_position
	local moving_slider = nil

	ui:Connect(titlebar.InputBegan, function(event)
		if
			event.UserInputType == Enum.UserInputType.MouseButton1
			or event.UserInputType == Enum.UserInputType.Touch
		then
			active_drag = event
			drag_begin = event.Position
			drag_position = shell.Position
		end
	end)

	ui:Connect(input.InputChanged, function(event)
		if
			moving_slider
			and (event.UserInputType == Enum.UserInputType.MouseMovement or event == moving_slider.touch)
		then
			moving_slider.move(event.Position.X)
		elseif active_drag and (event.UserInputType == Enum.UserInputType.MouseMovement or event == active_drag) then
			local delta = event.Position - drag_begin
			local viewport = workspace.CurrentCamera and workspace.CurrentCamera.ViewportSize or Vector2.new(1280, 720)
			local half = 420 * scale.Scale
			local x = math.clamp(
				viewport.X * drag_position.X.Scale + drag_position.X.Offset + delta.X,
				half,
				math.max(half, viewport.X - half)
			)
			local y = math.clamp(
				viewport.Y * drag_position.Y.Scale + drag_position.Y.Offset + delta.Y,
				290 * scale.Scale,
				math.max(290 * scale.Scale, viewport.Y - 290 * scale.Scale)
			)
			shell.Position = UDim2.fromOffset(x, y)
		end
	end)

	ui:Connect(input.InputEnded, function(event)
		if
			event.UserInputType == Enum.UserInputType.MouseButton1
			or event.UserInputType == Enum.UserInputType.Touch
		then
			active_drag = nil
			moving_slider = nil
		end
	end)

	local window = {}

	function window:SetOpen(value)
		ui.Open = value == true
		shell.Visible = ui.Open
		set_cursor_enabled(ui.Open)
	end

	function window:Toggle()
		self:SetOpen(not ui.Open)
	end

	ui:Connect(minimize.Activated, function()
		window:SetOpen(false)
	end)

	ui:Connect(floating.Activated, function()
		window:Toggle()
	end)

	ui:Connect(close.Activated, function()
		ui:Unload()
	end)

	ui:Connect(input.InputBegan, function(event)
		if ui.Unloaded then
			return
		end
		if event.KeyCode == Enum.KeyCode.RightControl or event.KeyCode == Enum.KeyCode.Insert then
			window:Toggle()
		end
	end)

	local translations = {
		["Farm / Items"] = "Itens",
		["Visuals / Players & Mobs"] = "ESP",
		["Player / Movement"] = "Movimento",
		["Visuals / World"] = "Mundo e câmera",
		["Travel"] = "Viagens",
		["Misc / Server"] = "Servidor",
		["Settings"] = "Configurações",
		["Combat"] = "Combate",
		["School & Clubs"] = "Escola e clubes",
		["World & Loot"] = "Itens e mundo",
		["Teleports"] = "Teletransportes",
		["Movement"] = "Movimento",
		["Visuals"] = "Visuais",
		["Codes & Config"] = "Configurações",
		["Defense & Parry"] = "Defesa e parry",
		["Offense & Finisher"] = "Ataques e finalização",
		["Class Exams & Quizzes"] = "Provas e perguntas",
		["Club QTEs & Music"] = "Clubes e música",
		["Class Mini-Games"] = "Minigames",
		["Pickup Aura & Spawns"] = "Coleta e avisos",
		["Item Teleport"] = "Ir até item",
		["School & Locations"] = "Locais da escola",
		["Players Teleport"] = "Jogadores",
		["Speed & Mobility"] = "Mobilidade",
		["Flight"] = "Voo",
		["Player ESP"] = "ESP de jogadores",
		["World & Environment"] = "Ambiente",
		["Promo Codes"] = "Códigos",
		["Presets & Session"] = "Perfis e sessão",
	}

	function ui:CreateWindow()
		return window
	end

	local function apply_filter()
		local query = search.Text:lower()
		for _, tab in ipairs(tabs) do
			for _, group in ipairs(tab.groups) do
				local found = false
				for _, row in ipairs(group.rows) do
					row.frame.Visible = query == "" or row.search:find(query, 1, true) ~= nil
					found = found or row.frame.Visible
				end
				group.frame.Visible = found
			end
		end
	end

	ui:Connect(search:GetPropertyChangedSignal("Text"), apply_filter)

	function window:AddTab(name)
		local tab = { groups = {} }

		local tab_button = make_button(nav, translations[name] or name)
		tab_button.Size = UDim2.new(1, 0, 0, 39)
		tab_button.LayoutOrder = #tabs
		tab_button.TextXAlignment = Enum.TextXAlignment.Left
		make("UIPadding", { PaddingLeft = UDim.new(0, 14) }, tab_button)

		local page = make(
			"ScrollingFrame",
			{
				Size = UDim2.new(1, -214, 1, -112),
				Position = UDim2.fromOffset(200, 72),
				BackgroundTransparency = 1,
				BorderSizePixel = 0,
				CanvasSize = UDim2.new(),
				AutomaticCanvasSize = Enum.AutomaticSize.Y,
				ScrollBarThickness = 3,
				ScrollBarImageColor3 = colors.accent,
				Visible = false,
			},
			shell
		)

		local columns = {}
		for index, side in ipairs({ "Left", "Right" }) do
			local col = make(
				"Frame",
				{
					BackgroundTransparency = 1,
					Size = UDim2.new(0.5, -9, 0, 0),
					AutomaticSize = Enum.AutomaticSize.Y,
					Position = UDim2.new((index - 1) * 0.5, index == 2 and 5 or 0, 0, 0),
				},
				page
			)
			make("UIListLayout", { Padding = UDim.new(0, 12), SortOrder = Enum.SortOrder.LayoutOrder }, col)
			make("UIPadding", { PaddingBottom = UDim.new(0, 14) }, col)
			columns[side] = col
		end

		tab.page = page
		tab.button = tab_button
		table.insert(tabs, tab)

		local function select()
			for _, other in ipairs(tabs) do
				other.page.Visible = other == tab
				other.button.BackgroundColor3 = other == tab and colors.raised or colors.bg
				other.button.TextColor3 = other == tab and colors.accent or colors.muted
			end
			active_tab = tab
			current.Text = translations[name] or name
			search.Text = ""
		end

		ui:Connect(tab_button.Activated, select)
		if not active_tab then
			select()
		end

		function tab:AddGroup(title, side)
			local group = { rows = {} }

			local card = make(
				"Frame",
				{
					BackgroundColor3 = colors.panel,
					BorderSizePixel = 0,
					Size = UDim2.new(1, 0, 0, 0),
					AutomaticSize = Enum.AutomaticSize.Y,
					LayoutOrder = #tab.groups,
				},
				columns[side or "Left"]
			)

			round(card, 9)
			border(card)
			make(
				"UIPadding",
				{
					PaddingLeft = UDim.new(0, 12),
					PaddingRight = UDim.new(0, 12),
					PaddingTop = UDim.new(0, 12),
					PaddingBottom = UDim.new(0, 12),
				},
				card
			)
			make("UIListLayout", { Padding = UDim.new(0, 8), SortOrder = Enum.SortOrder.LayoutOrder }, card)

			local heading = label(card, translations[title] or title, 12)
			heading.Font = Enum.Font.GothamBold
			heading.LayoutOrder = -1
			group.frame = card
			table.insert(tab.groups, group)

			local function row(text, height)
				local frame = make(
					"Frame",
					{ BackgroundTransparency = 1, Size = UDim2.new(1, 0, 0, height), LayoutOrder = #group.rows },
					card
				)
				table.insert(group.rows, { frame = frame, search = (text .. " " .. title):lower() })
				return frame
			end

			local function register(key, options, control)
				control.Callback = options.Callback
				control.Key = key
				if key then
					ui.Options[key] = control
				end
				return control
			end

			function group:AddToggle(key, options)
				local frame = row(options.Text or key, 35)
				local caption = label(frame, options.Text or key, 11)
				caption.Size = UDim2.new(1, -48, 1, 0)
				caption.TextWrapped = true
				caption.TextTruncate = Enum.TextTruncate.None

				local switch = make_button(frame, "")
				switch.Size = UDim2.fromOffset(34, 19)
				switch.Position = UDim2.new(1, -34, 0.5, -9)

				local dot = make(
					"Frame",
					{ Size = UDim2.fromOffset(13, 13), BackgroundColor3 = colors.text, BorderSizePixel = 0 },
					switch
				)
				round(dot, 20)

				local control = register(key, options, { Kind = "toggle" })

				function control:SetValue(value, silent)
					self.Value = value == true
					switch.BackgroundColor3 = self.Value and colors.accent or colors.line
					dot.Position = UDim2.fromOffset(self.Value and 18 or 3, 3)
					if not silent and self.Callback then
						ui:Run(key or "toggle", self.Callback, self.Value)
					end
				end

				ui:Connect(switch.Activated, function()
					control:SetValue(not control.Value)
				end)

				control:SetValue(options.Default, true)
				return control
			end

			function group:AddSlider(key, options)
				local frame = row(options.Text or key, 57)
				local caption = label(frame, options.Text or key, 11)
				caption.Size = UDim2.new(1, -80, 0, 25)

				local value = make(
					"TextBox",
					{
						BackgroundColor3 = colors.raised,
						BorderSizePixel = 0,
						Size = UDim2.fromOffset(77, 25),
						Position = UDim2.new(1, -77, 0, 0),
						TextColor3 = colors.text,
						TextSize = 11,
						Font = Enum.Font.Code,
						ClearTextOnFocus = false,
					},
					frame
				)
				round(value, 4)

				local track = make_button(frame, "")
				track.Size = UDim2.new(1, 0, 0, 18)
				track.Position = UDim2.fromOffset(0, 33)
				track.BackgroundTransparency = 1

				local rail = make(
					"Frame",
					{
						BackgroundColor3 = colors.line,
						BorderSizePixel = 0,
						Size = UDim2.new(1, 0, 0, 3),
						Position = UDim2.fromOffset(0, 7),
					},
					track
				)
				round(rail, 3)

				local fill = make(
					"Frame",
					{ BackgroundColor3 = colors.accent, BorderSizePixel = 0, Size = UDim2.fromScale(0, 1) },
					rail
				)
				round(fill, 3)

				local dot = make(
					"Frame",
					{
						BackgroundColor3 = colors.text,
						BorderSizePixel = 0,
						Size = UDim2.fromOffset(10, 10),
						AnchorPoint = Vector2.new(0.5, 0.5),
						Position = UDim2.fromScale(0, 0.5),
					},
					rail
				)
				round(dot, 10)

				local control = register(key, options, { Kind = "slider", Min = options.Min, Max = options.Max })

				function control:SetValue(v, silent)
					v = tonumber(v) or options.Default
					if v ~= v or math.abs(v) == math.huge then
						v = options.Default
					end

					local power = 10 ^ (options.Rounding or 0)
					self.Value = math.clamp(math.floor(v * power + 0.5) / power, self.Min, self.Max)

					local span = self.Max - self.Min
					local alpha = span == 0 and 0 or (self.Value - self.Min) / span

					fill.Size = UDim2.fromScale(alpha, 1)
					dot.Position = UDim2.fromScale(alpha, 0.5)
					value.Text = tostring(self.Value) .. (options.Suffix or "")

					if not silent and self.Callback then
						ui:Run(key, self.Callback, self.Value)
					end
				end

				local function move(x)
					local max_width = math.max(1, track.AbsoluteSize.X)
					local next_value =
						options.Min
						+ math.clamp((x - track.AbsolutePosition.X) / max_width, 0, 1) * (options.Max - options.Min)
					control:SetValue(next_value)
				end

				ui:Connect(track.InputBegan, function(event)
					if
						event.UserInputType == Enum.UserInputType.MouseButton1
						or event.UserInputType == Enum.UserInputType.Touch
					then
						moving_slider = { move = move, touch = event }
						move(event.Position.X)
					end
				end)

				ui:Connect(value.FocusLost, function()
					local parsed = value.Text:match("[-+]?%d*%.?%d+")
					control:SetValue(parsed)
				end)

				control:SetValue(options.Default, true)
				return control
			end

			function group:AddDropdown(key, options)
				local frame = row(options.Text or key, 61)
				local caption = label(frame, options.Text or key, 11)
				local choose = make_button(frame, "")
				choose.Position = UDim2.fromOffset(0, 26)
				choose.Size = UDim2.new(1, 0, 0, 32)
				choose.TextSize = 10

				local control = register(key, options, { Kind = "dropdown", Values = options.Values or {} })
				local popup

				function control:SetValue(value, silent)
					if not table.find(self.Values, value) then
						value = self.Values[1]
					end
					self.Value = value
					choose.Text = tostring(value or "Nenhum") .. "  ▾"
					if not silent and self.Callback then
						ui:Run(key or "dropdown", self.Callback, value)
					end
				end

				function control:SetValues(values)
					self.Values = values or {}
					self:SetValue(self.Value)
				end

				ui:Connect(choose.Activated, function()
					if popup then
						popup:Destroy()
						popup = nil
						return
					end

					popup = make(
						"Frame",
						{
							Size = UDim2.fromOffset(350, 330),
							AnchorPoint = Vector2.new(0.5, 0.5),
							Position = UDim2.fromScale(0.5, 0.5),
							BackgroundColor3 = colors.panel,
							BorderSizePixel = 0,
							ZIndex = 20,
						},
						shell
					)
					round(popup)
					border(popup)

					local dismiss = make_button(popup, "Fechar seleção")
					dismiss.Position = UDim2.fromOffset(10, 10)
					dismiss.Size = UDim2.new(1, -20, 0, 30)
					dismiss.ZIndex = 21

					ui:Connect(dismiss.Activated, function()
						if popup then
							popup:Destroy()
							popup = nil
						end
					end)

					local list = make(
						"ScrollingFrame",
						{
							Position = UDim2.fromOffset(10, 50),
							Size = UDim2.new(1, -20, 1, -60),
							BackgroundTransparency = 1,
							BorderSizePixel = 0,
							AutomaticCanvasSize = Enum.AutomaticSize.Y,
							CanvasSize = UDim2.new(),
							ScrollBarThickness = 3,
							ZIndex = 21,
						},
						popup
					)
					make("UIListLayout", { Padding = UDim.new(0, 5) }, list)

					for _, value in ipairs(control.Values) do
						local option = make_button(list, tostring(value))
						option.Size = UDim2.new(1, -8, 0, 30)
						option.ZIndex = 22
						option.Activated:Connect(function()
							control:SetValue(value)
							if popup then
								popup:Destroy()
								popup = nil
							end
						end)
					end
				end)

				control:SetValue(options.Default, true)
				return control
			end

			function group:AddButton(text, options)
				local frame = row(text, 34)
				local obj = make_button(frame, text)
				obj.TextSize = 11
				if options.Danger then
					obj.TextColor3 = colors.danger
				end

				local busy = false
				ui:Connect(obj.Activated, function()
					if busy then
						return
					end
					busy = true
					ui:Run(text, options.Callback or function() end)
					busy = false
					if ui.Sync then
						ui.Sync()
					end
				end)

				return obj
			end

			return group
		end

		return tab
	end

	function ui:Diagnostics()
		local lines = {
			"ZYON YBA / 0.2",
			"PlaceId: " .. tostring(game.PlaceId),
			"GameId: " .. tostring(game.GameId),
			"Validação em jogo: pendente de teste local",
		}

		for _, name in ipairs({ "getgc", "getupvalue", "getupvalues", "firesignal", "writefile", "readfile" }) do
			local available = self.Capabilities and self.Capabilities[name]
			table.insert(lines, name .. ": " .. (available and "disponível" or "indisponível"))
		end

		local names = {}
		for name in pairs(self.ModuleStatus) do
			table.insert(names, name)
		end
		table.sort(names)
		for _, name in ipairs(names) do
			table.insert(lines, "Módulo " .. name .. ": " .. self.ModuleStatus[name])
		end

		for area, entry in pairs(self.Errors) do
			table.insert(lines, "Erro " .. area .. " (" .. entry.count .. "): " .. entry.message)
		end

		local report = table.concat(lines, "\n")
		if type(setclipboard) == "function" then
			pcall(setclipboard, report)
		end
		if type(writefile) == "function" then
			pcall(writefile, "ZyonYBA-diagnostico.txt", report)
		end

		print(report)
		self:Notify({
			Title = "Diagnóstico",
			Content = "Relatório enviado ao console e, quando disponível, à área de transferência/arquivo.",
		})
		return report
	end

	function ui:Unload()
		if self.Unloaded then
			return
		end

		set_cursor_enabled(false)

		if self.OnUnload then
			local ok, err = pcall(self.OnUnload)
			if not ok then
				warn("[Zyon unload] " .. tostring(err))
			end
		end

		self.Unloaded = true
		for _, conn in ipairs(self.Connections) do
			if conn and conn.Connected then
				conn:Disconnect()
			end
		end

		cursor_gui:Destroy()
		gui:Destroy()
	end

	local frame_count = 0
	local elapsed = 0

	ui:Connect(run.RenderStepped, function(dt)
		frame_count += 1
		elapsed += dt
		if elapsed >= 1 then
			resize()
			local errors = 0
			for _ in pairs(ui.Errors) do
				errors += 1
			end

			footer.Text = string.format(
				"RightCtrl · painel   /   %d FPS   /   %s   /   %d alertas",
				math.floor(frame_count / elapsed),
				ui.Status or "carregando módulos",
				errors
			)
			elapsed = 0
			frame_count = 0
		end
	end)

	return ui
end

return (function()
	if not game:IsLoaded() then
		game.Loaded:Wait()
	end

	if game.GameId ~= 1016936714 then
		warn("[Zyon YBA] Experiência diferente do relatório recebido.")
		return nil
	end

	local environment = (type(getgenv) == "function" and getgenv()) or _G
	if environment.ZyonYBA then
		pcall(function()
			environment.ZyonYBA:Unload()
		end)
	end

	local app = create_hud()
	environment.ZyonYBA = app

	local players = game:GetService("Players")
	local local_player = players.LocalPlayer
	local run = game:GetService("RunService")
	local input = game:GetService("UserInputService")
	local storage = game:GetService("ReplicatedStorage")
	local lighting = game:GetService("Lighting")
	local http = game:GetService("HttpService")
	local teleport = game:GetService("TeleportService")
	local flags = {}
	app.Flags = flags

	local alive = true
	local root_gui = Instance.new("Folder")
	root_gui.Name = "YBAOverlays"
	root_gui.Parent = app.ScreenGui

	local world_overlays = Instance.new("Folder")
	world_overlays.Name = "ZyonYBAVisuals"
	world_overlays.Parent = workspace

	local window = app:CreateWindow()
	local bindings = {}

	local function connect(signal, fn)
		return app:Connect(signal, function(...)
			if alive then
				fn(...)
			end
		end)
	end

	local function character_parts()
		local char = local_player.Character
		return char, char and char:FindFirstChildOfClass("Humanoid"), char and char:FindFirstChild("HumanoidRootPart")
	end

	local function root_part(obj)
		if not obj then
			return nil
		end
		if obj:IsA("BasePart") then
			return obj
		end
		if obj:IsA("Model") then
			return obj.PrimaryPart
				or obj:FindFirstChild("HumanoidRootPart")
				or obj:FindFirstChildWhichIsA("BasePart", true)
		end
		return obj:FindFirstChildWhichIsA("BasePart", true)
	end

	local function exists(obj)
		return obj and obj.Parent ~= nil
	end

	local function group(tab, name, side)
		return tab:AddGroup(name, side)
	end

	local function toggle(card, key, title, default)
		flags[key] = default == true
		return card:AddToggle(key, {
			Text = title,
			Default = flags[key],
			Callback = function(value)
				flags[key] = value
			end,
		})
	end

	local function slider(card, key, title, min, max, default, rounding, suffix)
		flags[key] = default
		return card:AddSlider(key, {
			Text = title,
			Min = min,
			Max = max,
			Default = default,
			Rounding = rounding or 0,
			Suffix = suffix or "",
			Callback = function(value)
				flags[key] = value
			end,
		})
	end

	local function dropdown(card, key, title, values, default)
		flags[key] = default or values[1]
		return card:AddDropdown(key, {
			Text = title,
			Values = values,
			Default = flags[key],
			Callback = function(value)
				flags[key] = value
			end,
		})
	end

	local function bind_button(card, title, fn)
		return card:AddButton(title, { Callback = fn })
	end

	local function notice(text)
		app:Notify({ Title = "Zyon YBA", Content = text })
	end

	local colors = {
		Violeta = Color3.fromRGB(158, 132, 255),
		Verde = Color3.fromRGB(104, 227, 170),
		Azul = Color3.fromRGB(100, 186, 255),
		Dourado = Color3.fromRGB(255, 209, 104),
		Branco = Color3.fromRGB(240, 240, 250),
	}

	local function color(key)
		return colors[flags[key]] or colors.Violeta
	end

	local function value_text(owner, names)
		if not owner then
			return nil
		end

		for _, name in ipairs(names) do
			local attribute = owner:GetAttribute(name)
			if attribute ~= nil and tostring(attribute) ~= "" then
				return tostring(attribute)
			end

			local value = owner:FindFirstChild(name)
			if value and (value:IsA("StringValue") or value:IsA("NumberValue")) then
				return tostring(value.Value)
			end
		end

		return nil
	end

	local entities = { Players = {}, Mobs = {}, Items = {} }

	local function clear_entry(entry)
		if not entry then
			return
		end
		for _, obj in ipairs({ entry.box, entry.chams, entry.label, entry.health, entry.health_back }) do
			if obj then
				obj:Destroy()
			end
		end
		entry.box = nil
		entry.chams = nil
		entry.label = nil
		entry.health = nil
		entry.health_back = nil
	end

	local function add_entity(kind, object, owner)
		if entities[kind][object] then
			return
		end

		local adorn = root_part(object)
		if not adorn then
			return
		end

		local box = Instance.new("SelectionBox")
		box.Name = "ZyonBox"
		box.Adornee = object:IsA("Model") and object or adorn
		box.LineThickness = 0.025
		box.SurfaceTransparency = 1
		box.Visible = false
		box.Parent = world_overlays

		local chams = Instance.new("Highlight")
		chams.Name = "ZyonChams"
		chams.Adornee = object:IsA("Model") and object or adorn
		chams.Enabled = false
		chams.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
		chams.Parent = world_overlays

		local label = Instance.new("BillboardGui")
		label.Name = "ZyonLabel"
		label.Adornee = adorn
		label.AlwaysOnTop = true
		label.Size = UDim2.fromOffset(230, 58)
		label.StudsOffsetWorldSpace = Vector3.new(0, object:IsA("Model") and 4 or 2.5, 0)
		label.Enabled = false
		label.Parent = root_gui

		local text = Instance.new("TextLabel")
		text.Size = UDim2.new(1, 0, 1, -9)
		text.BackgroundTransparency = 1
		text.Font = Enum.Font.GothamMedium
		text.TextSize = 12
		text.TextColor3 = colors.Branco
		text.TextStrokeTransparency = 0.25
		text.Parent = label

		local health_back = Instance.new("Frame")
		health_back.Size = UDim2.new(0.6, 0, 0, 4)
		health_back.Position = UDim2.new(0.2, 0, 1, -6)
		health_back.BackgroundColor3 = Color3.fromRGB(34, 37, 48)
		health_back.BorderSizePixel = 0
		health_back.Parent = label

		local health = Instance.new("Frame")
		health.Size = UDim2.fromScale(1, 1)
		health.BackgroundColor3 = colors.Verde
		health.BorderSizePixel = 0
		health.Parent = health_back

		entities[kind][object] = {
			object = object,
			owner = owner,
			adorn = adorn,
			box = box,
			chams = chams,
			label = label,
			text = text,
			health = health,
			health_back = health_back,
		}
	end

	local item_root
	local item_names = {}

	local function read_item_name(item)
		return value_text(item, { "ItemName", "Item" }) or item.Name
	end

	local function refresh_entities()
		local spawns = workspace:FindFirstChild("Item_Spawns")
		item_root = spawns and spawns:FindFirstChild("Items")

		for kind, collection in pairs(entities) do
			for object, entry in pairs(collection) do
				if
					not exists(object)
					or not exists(entry.adorn)
					or (kind == "Items" and object.Parent ~= item_root)
					or (kind == "Players" and entry.owner.Character ~= object)
				then
					clear_entry(entry)
					collection[object] = nil
				end
			end
		end

		for _, player in ipairs(players:GetPlayers()) do
			if player.Character then
				add_entity("Players", player.Character, player)
			end
		end

		local living = workspace:FindFirstChild("Living")
		if living then
			for _, model in ipairs(living:GetChildren()) do
				if
					model:IsA("Model")
					and model:FindFirstChildOfClass("Humanoid")
					and not players:GetPlayerFromCharacter(model)
				then
					add_entity("Mobs", model)
				end
			end
		end

		if item_root then
			for _, item in ipairs(item_root:GetChildren()) do
				add_entity("Items", item, nil)
			end
		end
	end

	local known_items = setmetatable({}, { __mode = "k" })

	local function item_selected(name)
		return flags.ItemFilter == "Todos" or flags.ItemFilter == name
	end

	local function update_esp()
		local _, _, own_root = character_parts()
		if not own_root then
			return
		end

		local budget = 0
		for kind, collection in pairs(entities) do
			local nearest, nearest_distance = nil, math.huge

			if flags[kind .. "Nearest"] then
				for _, entry in pairs(collection) do
					if exists(entry.adorn) and entry.owner ~= local_player then
						local distance = (entry.adorn.Position - own_root.Position).Magnitude
						if distance < nearest_distance then
							nearest = entry
							nearest_distance = distance
						end
					end
				end
			end

			for _, entry in pairs(collection) do
				local root = entry.adorn
				local item_name = kind == "Items" and read_item_name(entry.object) or nil

				if kind == "Items" and not known_items[entry.object] then
					known_items[entry.object] = true
					if flags.SpawnAlerts and (not flags.SelectedAlertsOnly or item_selected(item_name)) then
						notice("Item detectado: " .. item_name)
					end
				end

				local distance = (root.Position - own_root.Position).Magnitude
				local humanoid = entry.object:FindFirstChildOfClass("Humanoid")
				local visible = flags[kind .. "ESP"]
					and distance <= flags[kind .. "Distance"]
					and (entry.owner ~= local_player or flags.ShowLocalPlayer)
					and (not nearest or nearest == entry)
					and (not humanoid or humanoid.Health > 0)
					and (kind ~= "Items" or item_selected(item_name))

				if visible then
					budget += 1
					visible = budget <= 160
				end

				entry.box.Visible = visible and flags[kind .. "Boxes"]
				entry.box.Color3 = color(kind .. "Color")
				entry.chams.Enabled = visible and flags[kind .. "Chams"]
				entry.chams.FillColor = color(kind .. "Color")
				entry.chams.OutlineColor = color(kind .. "Color")
				entry.chams.FillTransparency = flags.ChamsTransparency or 0.6

				entry.label.Enabled = visible
					and (flags[kind .. "Names"] or flags[kind .. "ShowDistance"] or flags[kind .. "Health"])

				if visible then
					local lines = {}
					local details = {}

					if flags[kind .. "Names"] then
						table.insert(lines, entry.owner and entry.owner.DisplayName or item_name or entry.object.Name)
					end

					if kind == "Players" and flags.ShowStand then
						local stand = value_text(entry.object, { "Stand", "StandName" })
							or value_text(entry.owner, { "Stand", "StandName" })
						if stand then
							table.insert(details, stand)
						end
					end

					if kind == "Players" and flags.ShowSpec then
						local spec = value_text(entry.object, { "Spec", "FightingStyle" })
							or value_text(entry.owner, { "Spec", "FightingStyle" })
						if spec then
							table.insert(details, spec)
						end
					end

					if flags[kind .. "ShowDistance"] then
						table.insert(details, string.format("%d studs", distance))
					end

					if flags[kind .. "Health"] and humanoid then
						table.insert(details, string.format("%d/%d HP", humanoid.Health, humanoid.MaxHealth))
					end

					if #details > 0 then
						table.insert(lines, table.concat(details, " · "))
					end

					entry.text.Text = table.concat(lines, "\n")
					entry.text.TextColor3 = color(kind .. "Color")

					entry.health_back.Visible = flags[kind .. "Health"] == true and humanoid ~= nil
					if humanoid then
						entry.health.Size = UDim2.fromScale(
							math.clamp(humanoid.Health / math.max(1, humanoid.MaxHealth), 0, 1),
							1
						)
					end
				else
					entry.text.Text = ""
					entry.health_back.Visible = false
				end
			end
		end
	end

	local collision = setmetatable({}, { __mode = "k" })
	local base_speed = setmetatable({}, { __mode = "k" })
	local base_jump = setmetatable({}, { __mode = "k" })
	local flight = {}
	local last_safe, last_safe_at = nil, 0
	local retreat_spot
	local retreat_last = 0

	local function stop_flight()
		for _, key in ipairs({ "velocity", "orientation", "attachment" }) do
			if flight[key] then
				flight[key]:Destroy()
				flight[key] = nil
			end
		end

		if exists(flight.humanoid) then
			flight.humanoid.AutoRotate = flight.auto_rotate
		end
		flight.humanoid = nil
	end

	local function restore_character()
		stop_flight()

		for part, value in pairs(collision) do
			if exists(part) then
				part.CanCollide = value
			end
			collision[part] = nil
		end

		for hum, value in pairs(base_speed) do
			if exists(hum) then
				hum.WalkSpeed = value
			end
			base_speed[hum] = nil
		end

		for hum, value in pairs(base_jump) do
			if exists(hum) then
				hum.JumpHeight = value.height
				hum.JumpPower = value.power
			end
			base_jump[hum] = nil
		end
	end

	local function update_movement()
		local char, hum, root = character_parts()
		if not hum or not root or hum.Health <= 0 then
			stop_flight()
			return
		end

		if flags.Speedhack then
			if base_speed[hum] == nil then
				base_speed[hum] = hum.WalkSpeed
			end
			hum.WalkSpeed = flags.Speed
		elseif base_speed[hum] ~= nil then
			hum.WalkSpeed = base_speed[hum]
			base_speed[hum] = nil
		end

		if flags.JumpOverride then
			if base_jump[hum] == nil then
				base_jump[hum] = { height = hum.JumpHeight, power = hum.JumpPower }
			end
			if hum.UseJumpPower then
				hum.JumpPower = math.sqrt(2 * workspace.Gravity * flags.JumpHeight)
			else
				hum.JumpHeight = flags.JumpHeight
			end
		elseif base_jump[hum] then
			hum.JumpHeight = base_jump[hum].height
			hum.JumpPower = base_jump[hum].power
			base_jump[hum] = nil
		end

		if flags.Noclip then
			for _, part in ipairs(char:GetDescendants()) do
				if part:IsA("BasePart") then
					if collision[part] == nil then
						collision[part] = part.CanCollide
					end
					part.CanCollide = false
				end
			end
		else
			for part, value in pairs(collision) do
				if exists(part) then
					part.CanCollide = value
				end
				collision[part] = nil
			end
		end

		if flags.AntiVoid and root.Position.Y < workspace.FallenPartsDestroyHeight + 45 and last_safe then
			root.CFrame = last_safe
			root.AssemblyLinearVelocity = Vector3.zero
			root.AssemblyAngularVelocity = Vector3.zero
		elseif not flags.Fly and hum.FloorMaterial ~= Enum.Material.Air and os.clock() - last_safe_at > 1 then
			last_safe = root.CFrame
			last_safe_at = os.clock()
		end

		if
			flags.AutoRetreat
			and retreat_spot
			and hum.Health / hum.MaxHealth * 100 <= flags.RetreatHP
			and os.clock() - retreat_last > 3
		then
			retreat_last = os.clock()
			root.CFrame = retreat_spot
			root.AssemblyLinearVelocity = Vector3.zero
		end

		if not flags.Fly then
			stop_flight()
			return
		end

		local camera = workspace.CurrentCamera
		if not camera then
			return
		end

		if flight.attachment and flight.attachment.Parent ~= root then
			stop_flight()
		end

		if not flight.attachment then
			flight.humanoid = hum
			flight.auto_rotate = hum.AutoRotate
			hum.AutoRotate = false

			flight.attachment = Instance.new("Attachment")
			flight.attachment.Name = "ZyonYBAFlight"
			flight.attachment.Parent = root

			flight.velocity = Instance.new("LinearVelocity")
			flight.velocity.Attachment0 = flight.attachment
			flight.velocity.RelativeTo = Enum.ActuatorRelativeTo.World
			flight.velocity.MaxForce = 1e9
			flight.velocity.Parent = root

			flight.orientation = Instance.new("AlignOrientation")
			flight.orientation.Attachment0 = flight.attachment
			flight.orientation.Mode = Enum.OrientationAlignmentMode.OneAttachment
			flight.orientation.MaxTorque = 1e9
			flight.orientation.Responsiveness = 25
			flight.orientation.Parent = root
		end

		local direction = Vector3.zero
		if not app.Open and not input:GetFocusedTextBox() then
			if input:IsKeyDown(Enum.KeyCode.W) then
				direction += camera.CFrame.LookVector
			end
			if input:IsKeyDown(Enum.KeyCode.S) then
				direction -= camera.CFrame.LookVector
			end
			if input:IsKeyDown(Enum.KeyCode.D) then
				direction += camera.CFrame.RightVector
			end
			if input:IsKeyDown(Enum.KeyCode.A) then
				direction -= camera.CFrame.RightVector
			end
			if input:IsKeyDown(Enum.KeyCode.Space) then
				direction += Vector3.yAxis
			end
			if input:IsKeyDown(Enum.KeyCode.LeftShift) then
				direction -= Vector3.yAxis
			end
		end

		flight.velocity.VectorVelocity = direction.Magnitude > 0 and direction.Unit * flags.FlySpeed or Vector3.zero
		flight.orientation.CFrame = camera.CFrame.Rotation
	end

	connect(input.JumpRequest, function()
		if flags.InfiniteJump and not app.Open and not input:GetFocusedTextBox() then
			local _, hum = character_parts()
			if hum and hum.Health > 0 then
				hum:ChangeState(Enum.HumanoidStateType.Jumping)
			end
		end
	end)

	connect(local_player.CharacterAdded, function()
		restore_character()
		last_safe = nil
	end)

	local changed_lighting = {}
	local atmosphere_original = setmetatable({}, { __mode = "k" })
	local original_fov = setmetatable({}, { __mode = "k" })

	local function set_light(key, value, enabled)
		if enabled then
			if changed_lighting[key] == nil then
				changed_lighting[key] = lighting[key]
			end
			lighting[key] = value
		elseif changed_lighting[key] ~= nil then
			lighting[key] = changed_lighting[key]
			changed_lighting[key] = nil
		end
	end

	local function update_world()
		set_light("Brightness", flags.Brightness, flags.Fullbright)
		set_light("GlobalShadows", false, flags.NoShadows)
		set_light("FogEnd", 1e6, flags.NoFog)
		set_light("FogStart", 1e6, flags.NoFog)
		set_light("ClockTime", flags.Hour, flags.FixedTime)
		set_light("Ambient", color("AmbientColor"), flags.WorldAmbient)
		set_light("OutdoorAmbient", color("AmbientColor"), flags.WorldAmbient)

		for _, obj in ipairs(lighting:GetChildren()) do
			if obj:IsA("Atmosphere") and flags.NoAtmosphere then
				if not atmosphere_original[obj] then
					atmosphere_original[obj] = { Density = obj.Density, Haze = obj.Haze, Glare = obj.Glare }
				end
				obj.Density = 0
				obj.Haze = 0
				obj.Glare = 0
			end
		end

		if not flags.NoAtmosphere then
			for obj, values in pairs(atmosphere_original) do
				if exists(obj) then
					for key, value in pairs(values) do
						obj[key] = value
					end
				end
				atmosphere_original[obj] = nil
			end
		end

		local camera = workspace.CurrentCamera
		if camera and flags.CustomFOV then
			if original_fov[camera] == nil then
				original_fov[camera] = camera.FieldOfView
			end
			camera.FieldOfView = flags.FieldOfView
		else
			for obj, value in pairs(original_fov) do
				if exists(obj) then
					obj.FieldOfView = value
				end
				original_fov[obj] = nil
			end
		end
	end

	local manual_tween

	local function cancel_tween()
		local tween = manual_tween
		manual_tween = nil
		if tween then
			tween:Cancel()
		end
	end

	local function travel(target)
		local _, hum, root = character_parts()
		if not root or not hum or hum.Health <= 0 then
			notice("Personagem indisponível.")
			return
		end

		cancel_tween()
		if flags.TravelMethod == "Instantâneo" then
			root.CFrame = target
			root.AssemblyLinearVelocity = Vector3.zero
			return
		end

		local tween = game:GetService("TweenService"):Create(
			root,
			TweenInfo.new(
				math.max(0.1, (target.Position - root.Position).Magnitude / flags.TravelSpeed),
				Enum.EasingStyle.Linear
			),
			{ CFrame = target }
		)
		manual_tween = tween

		local conn
		conn = tween.Completed:Connect(function()
			conn:Disconnect()
			if manual_tween == tween then
				manual_tween = nil
			end
		end)

		table.insert(app.Connections, conn)
		tween:Play()
	end

	local destination_objects = {}
	local destination_control

	local function refresh_destinations()
		table.clear(destination_objects)
		local list = {}
		local count = {}

		for _, folder_name in ipairs({ "Locations", "Dialogues", "Gates" }) do
			local folder = workspace:FindFirstChild(folder_name)
			if folder then
				for _, obj in ipairs(folder:GetChildren()) do
					if root_part(obj) or obj:IsA("CFrameValue") then
						local base = folder_name .. " / " .. obj.Name
						count[base] = (count[base] or 0) + 1
						local label = base .. (count[base] > 1 and " [" .. count[base] .. "]" or "")
						destination_objects[label] = obj
						table.insert(list, label)
					end
				end
			end
		end

		table.sort(list)
		if #list == 0 then
			list = { "Nenhum destino carregado" }
		end

		if destination_control then
			destination_control:SetValues(list)
		end

		return list
	end

	local function player_names()
		local names = {}
		for _, player in ipairs(players:GetPlayers()) do
			if player ~= local_player then
				table.insert(names, player.Name)
			end
		end
		table.sort(names)
		if #names == 0 then
			names = { "Nenhum jogador" }
		end
		return names
	end

	local spectated_camera, saved_subject

	local function stop_spectate()
		if spectated_camera and exists(spectated_camera) then
			local _, hum = character_parts()
			spectated_camera.CameraSubject = exists(saved_subject) and saved_subject or hum
		end
		spectated_camera = nil
		saved_subject = nil
	end

	local function spectate_player(name)
		local target = players:FindFirstChild(name)
		local hum = target and target.Character and target.Character:FindFirstChildOfClass("Humanoid")
		local camera = workspace.CurrentCamera
		if not hum or not camera then
			notice("Jogador indisponível.")
			return
		end
		if spectated_camera ~= camera then
			stop_spectate()
			spectated_camera = camera
			saved_subject = camera.CameraSubject
		end
		camera.CameraSubject = hum
	end

	local tab_items = window:AddTab("Farm / Items")
	local card_items = group(tab_items, "Itens observados", "Left")

	toggle(card_items, "ItemsESP", "Item ESP", false)
	toggle(card_items, "ItemsNames", "Nome dos itens", true)
	toggle(card_items, "ItemsShowDistance", "Distância dos itens", true)
	toggle(card_items, "ItemsBoxes", "Caixas 3D", false)
	dropdown(card_items, "ItemsColor", "Cor dos itens", { "Violeta", "Dourado", "Verde", "Azul", "Branco" }, "Dourado")
	slider(card_items, "ItemsDistance", "Distância máxima", 50, 5000, 1500, 0, " studs")

	item_names = { "Todos" }
	local replicas = storage:FindFirstChild("Tool_Replicas")
	if replicas then
		for _, obj in ipairs(replicas:GetChildren()) do
			table.insert(item_names, obj.Name)
		end
	end

	table.sort(item_names, function(a, b)
		if a == "Todos" then
			return b ~= "Todos"
		elseif b == "Todos" then
			return false
		end
		return a < b
	end)

	dropdown(card_items, "ItemFilter", "Filtrar item", item_names, "Todos")

	local alerts = group(tab_items, "Avisos e deslocamento", "Right")
	toggle(alerts, "SpawnAlerts", "Spawn Alerts", false)
	toggle(alerts, "SelectedAlertsOnly", "Selected Items Only", true)

	bind_button(alerts, "Ir até item mais próximo", function()
		local _, _, root = character_parts()
		if not root then
			return
		end
		refresh_entities()
		local nearest, dist = nil, math.huge
		for _, entry in pairs(entities.Items) do
			local d = (entry.adorn.Position - root.Position).Magnitude
			if item_selected(read_item_name(entry.object)) and d < dist then
				nearest = entry
				dist = d
			end
		end

		if nearest then
			travel(CFrame.new(nearest.adorn.Position + Vector3.new(0, 3, 0)))
		else
			notice("Nenhum item correspondente carregado.")
		end
	end)

	bind_button(alerts, "Reexaminar itens", refresh_entities)

	local visuals = window:AddTab("Visuals / Players & Mobs")
	for _, kind in ipairs({ "Players", "Mobs" }) do
		local card = group(
			visuals,
			kind == "Players" and "Jogadores" or "NPCs de combate",
			kind == "Players" and "Left" or "Right"
		)

		toggle(card, kind .. "ESP", kind == "Players" and "Player ESP" or "Mob ESP", false)
		toggle(card, kind .. "Boxes", "Boxes · 3D", false)
		toggle(card, kind .. "Names", "Name", true)
		toggle(card, kind .. "ShowDistance", "Distance", true)
		toggle(card, kind .. "Health", "Health Bar + HP", true)
		toggle(card, kind .. "Chams", "Chams", false)
		toggle(card, kind .. "Nearest", "Nearest Only", false)
		slider(card, kind .. "Distance", "Max Distance", 50, 5000, 1500, 0, " studs")
		dropdown(
			card,
			kind .. "Color",
			"ESP Colour",
			{ "Violeta", "Verde", "Azul", "Dourado", "Branco" },
			kind == "Players" and "Violeta" or "Verde"
		)
	end

	local esp_more = group(visuals, "Identificação disponível", "Left")
	toggle(esp_more, "ShowLocalPlayer", "Show Local Player", false)
	toggle(esp_more, "ShowStand", "Show Stand · se replicado", true)
	toggle(esp_more, "ShowSpec", "Show Spec · se replicado", true)
	slider(esp_more, "ChamsTransparency", "Chams Fill Trans", 0, 1, 0.6, 2)

	local movement = window:AddTab("Player / Movement")
	local mobility = group(movement, "Movimento", "Left")
	toggle(mobility, "Speedhack", "Speedhack", false)
	slider(mobility, "Speed", "Speed", 8, 120, 32, 0, " studs/s")
	toggle(mobility, "InfiniteJump", "Infinite Jump", false)
	toggle(mobility, "JumpOverride", "Alterar altura do salto", false)
	slider(mobility, "JumpHeight", "Jump Height", 4, 100, 12, 0, " studs")
	toggle(mobility, "Noclip", "Noclip", false)

	local flying = group(movement, "Fly", "Right")
	toggle(flying, "Fly", "Fly", false)
	slider(flying, "FlySpeed", "Fly Speed", 10, 180, 50, 0, " studs/s")

	local protection = group(movement, "Proteção e recuo", "Right")
	toggle(protection, "AntiVoid", "Anti Void · último chão", false)
	bind_button(protection, "Set Retreat Spot", function()
		local _, _, root = character_parts()
		if root then
			retreat_spot = root.CFrame
			notice("Ponto de recuo salvo.")
		end
	end)
	bind_button(protection, "Clear Retreat Spot", function()
		retreat_spot = nil
		notice("Ponto removido.")
	end)
	toggle(protection, "AutoRetreat", "Auto Retreat", false)
	slider(protection, "RetreatHP", "Retreat At HP", 5, 95, 25, 0, "%")

	local world = window:AddTab("Visuals / World")
	local illumination = group(world, "Iluminação local", "Left")
	toggle(illumination, "Fullbright", "Fullbright", false)
	slider(illumination, "Brightness", "Brightness", 0, 8, 2, 1)
	toggle(illumination, "NoShadows", "No Shadows", false)
	toggle(illumination, "NoFog", "No Fog", false)
	toggle(illumination, "NoAtmosphere", "No Atmosphere", false)
	toggle(illumination, "FixedTime", "Fixed Time Of Day", false)
	slider(illumination, "Hour", "Hour", 0, 24, 14, 1)
	toggle(illumination, "WorldAmbient", "World Ambient", false)
	dropdown(illumination, "AmbientColor", "Ambient Colour", { "Branco", "Azul", "Violeta", "Dourado" }, "Branco")

	local camera_card = group(world, "Câmera", "Right")
	toggle(camera_card, "CustomFOV", "Custom FOV", false)
	slider(camera_card, "FieldOfView", "Field Of View", 30, 120, 80, 0, "°")

	local spectate_control = dropdown(camera_card, "SpectatePlayer", "Spectate Player", player_names())
	bind_button(camera_card, "Refresh Players", function()
		spectate_control:SetValues(player_names())
	end)
	bind_button(camera_card, "Spectate", function()
		spectate_player(flags.SpectatePlayer)
	end)
	bind_button(camera_card, "Stop Spectate", stop_spectate)

	local travel_tab = window:AddTab("Travel")
	local locations = group(travel_tab, "Destinos reais do mapa", "Left")
	destination_control = dropdown(locations, "Destination", "Location", refresh_destinations())
	bind_button(locations, "Refresh Locations", refresh_destinations)
	bind_button(locations, "Teleport", function()
		local obj = destination_objects[flags.Destination]
		if not exists(obj) then
			notice("Atualize os destinos.")
			return
		end
		local part = root_part(obj)
		local target = obj:IsA("CFrameValue") and obj.Value or part and part.CFrame + Vector3.new(0, 4, 0)
		if target then
			travel(target)
		end
	end)

	dropdown(locations, "TravelMethod", "Método", { "Tween", "Instantâneo" }, "Tween")
	slider(locations, "TravelSpeed", "Velocidade do tween", 15, 150, 55, 0, " studs/s")
	bind_button(locations, "Interromper deslocamento", cancel_tween)
	bind_button(locations, "Teleport Up", function()
		local _, _, root = character_parts()
		if root then
			travel(root.CFrame + Vector3.new(0, 50, 0))
		end
	end)

	local travel_players = group(travel_tab, "Jogadores", "Right")
	local target_control = dropdown(travel_players, "TravelPlayer", "Player", player_names())
	bind_button(travel_players, "Refresh Players", function()
		target_control:SetValues(player_names())
	end)
	bind_button(travel_players, "Teleport Behind Player", function()
		local player = players:FindFirstChild(flags.TravelPlayer)
		local root = player and player.Character and player.Character:FindFirstChild("HumanoidRootPart")
		if root then
			travel(root.CFrame * CFrame.new(0, 0, 4))
		else
			notice("Jogador indisponível.")
		end
	end)

	local misc = window:AddTab("Misc / Server")
	local server = group(misc, "Servidor atual", "Left")
	bind_button(server, "This Server", function()
		local age = storage:FindFirstChild("ServerAge")
		local region = storage:FindFirstChild("ServerRegion")
		local weather = workspace:FindFirstChild("Weather")
		notice(
			"Place "
				.. game.PlaceId
				.. " · "
				.. #players:GetPlayers()
				.. " jogadores · região "
				.. tostring(region and region.Value or "?")
				.. " · idade "
				.. tostring(age and age.Value or "?")
				.. " · clima "
				.. tostring(weather and weather.Value or "?")
		)
	end)

	bind_button(server, "Copy Job ID", function()
		if type(setclipboard) == "function" then
			setclipboard(game.JobId)
			notice("Job ID copiado.")
		else
			notice("setclipboard indisponível.")
		end
	end)

	bind_button(server, "Rejoin", function()
		teleport:TeleportToPlaceInstance(game.PlaceId, game.JobId, local_player)
	end)

	local performance = group(misc, "Desempenho local", "Right")
	slider(performance, "ESPTick", "Intervalo de atualização ESP", 0.05, 0.5, 0.15, 2, " s")

	local render_disabled = false
	bind_button(performance, "Desativar/ativar renderização 3D", function()
		render_disabled = not render_disabled
		run:Set3dRenderingEnabled(not render_disabled)
		notice(
			render_disabled and "Renderização 3D desativada; o HUD permanece disponível."
				or "Renderização 3D ativada."
		)
	end)

	local settings = window:AddTab("Settings")
	local config = group(settings, "Configurações locais", "Left")
	bind_button(config, "Salvar configuração", function()
		if type(writefile) ~= "function" then
			notice("writefile indisponível.")
			return
		end
		writefile("ZyonYBA-config.json", http:JSONEncode(flags))
		notice("Salvo em ZyonYBA-config.json.")
	end)

	bind_button(config, "Carregar configuração", function()
		if type(readfile) ~= "function" then
			notice("readfile indisponível.")
			return
		end
		local values = http:JSONDecode(readfile("ZyonYBA-config.json"))
		for key, value in pairs(values) do
			local control = app.Options[key]
			if control and type(value) == type(control.Value) then
				control:SetValue(value)
			end
		end
		notice("Configuração carregada.")
	end)

	bind_button(config, "Copiar diagnóstico", function()
		app:Diagnostics()
	end)

	bind_button(config, "Copiar detalhes do personagem", function()
		local details = {
			"ZYON YBA / DETALHES 0.2",
			"Somente nomes, classes e valores públicos selecionados; nenhum evento é acionado.",
		}
		local inspected = 0

		for _, entry in ipairs({
			{ local_player, "LocalPlayer" },
			{ local_player.Character, "Character" },
			{ local_player:FindFirstChild("Backpack"), "Backpack" },
		}) do
			local root, label = entry[1], entry[2]
			if root then
				table.insert(details, "\n[" .. label .. "]")
				local queue = { { object = root, path = label, depth = 0 } }
				local cursor = 1
				local section = 0

				while cursor <= #queue and section < 500 and alive do
					local current = queue[cursor]
					cursor += 1
					for _, child in ipairs(current.object:GetChildren()) do
						section += 1
						inspected += 1
						if section > 500 then
							break
						end

						local path = current.path .. "/" .. child.Name:gsub("[\r\n]", " "):sub(1, 100)
						if
							current.depth == 0
							or child:IsA("RemoteEvent")
							or child:IsA("RemoteFunction")
							or child:IsA("ModuleScript")
							or child:IsA("LocalScript")
							or child:IsA("ValueBase")
						then
							local value = ""
							if
								child:IsA("StringValue")
								or child:IsA("NumberValue")
								or child:IsA("IntValue")
								or child:IsA("BoolValue")
							then
								local name = child.Name:lower()
								if not name:find("key") and not name:find("token") and not name:find("password") then
									value = " = " .. tostring(child.Value):sub(1, 100)
								end
							end
							table.insert(details, path .. " <" .. child.ClassName .. ">" .. value)
						end

						if
							current.depth < 3
							and (
								child:IsA("Folder")
								or child:IsA("Model")
								or child:IsA("Tool")
								or child:IsA("Configuration")
							)
						then
							table.insert(queue, { object = child, path = path, depth = current.depth + 1 })
						end

						if inspected % 25 == 0 then
							task.wait(0.03)
						end
					end
				end
			end
		end

		local report = table.concat(details, "\n")
		if type(setclipboard) == "function" then
			setclipboard(report)
		end
		if type(writefile) == "function" then
			writefile("ZyonYBA-personagem.txt", report)
		end
		print(report)
		notice("Detalhes enviados ao console e aos recursos de cópia/arquivo disponíveis.")
	end)

	local session = group(settings, "Sessão", "Right")
	bind_button(session, "Desativar recursos", function()
		for key, control in pairs(app.Options) do
			if
				control.Kind == "toggle"
				and (
					key:find("ESP")
					or key == "Speedhack"
					or key == "Noclip"
					or key == "Fly"
					or key == "InfiniteJump"
					or key == "JumpOverride"
					or key == "AntiVoid"
					or key == "AutoRetreat"
					or key == "Fullbright"
					or key == "NoShadows"
					or key == "NoFog"
					or key == "NoAtmosphere"
					or key == "FixedTime"
					or key == "WorldAmbient"
					or key == "CustomFOV"
					or key == "SpawnAlerts"
				)
			then
				control:SetValue(false)
			end
		end

		cancel_tween()
		restore_character()
		stop_spectate()
		update_world()
		update_esp()
	end)

	bind_button(session, "Unload", function()
		app:Unload()
	end)

	local last_scan, last_world, last_esp, last_move = 0, 0, 0, 0
	connect(run.Heartbeat, function()
		local now = os.clock()

		if now - last_scan >= 1 then
			last_scan = now
			app:Run("scan", refresh_entities)
		end

		if now - last_world >= 0.25 then
			last_world = now
			app:Run("world", update_world)
		end

		if now - last_esp >= flags.ESPTick then
			last_esp = now
			app:Run("esp", update_esp)
		end
	end)

	connect(run.Stepped, function()
		if os.clock() - last_move >= 1 / 30 then
			last_move = os.clock()
			app:Run("movement", update_movement)
		end
	end)

	app.OnUnload = function()
		alive = false
		cancel_tween()
		restore_character()
		stop_spectate()

		for key, value in pairs(changed_lighting) do
			lighting[key] = value
		end

		for obj, values in pairs(atmosphere_original) do
			if exists(obj) then
				for key, value in pairs(values) do
					obj[key] = value
				end
			end
		end

		for camera, value in pairs(original_fov) do
			if exists(camera) then
				camera.FieldOfView = value
			end
		end

		if render_disabled then
			pcall(function()
				run:Set3dRenderingEnabled(true)
			end)
		end

		root_gui:Destroy()
		world_overlays:Destroy()

		if environment.ZyonYBA == app then
			environment.ZyonYBA = nil
		end
	end

	for _, path in ipairs({ { "Item_Spawns", "Items" }, { "Living" }, { "Dialogues" }, { "Locations" } }) do
		local obj = workspace
		for _, name in ipairs(path) do
			obj = obj and obj:FindFirstChild(name)
		end
		app.ModuleStatus["Workspace/" .. table.concat(path, "/")] = obj and "encontrado" or "não carregado"
	end

	app.Capabilities = {
		getgc = type(getgc) == "function",
		getupvalue = type(getupvalue) == "function",
		getupvalues = type(getupvalues) == "function",
		firesignal = type(firesignal) == "function",
		writefile = type(writefile) == "function",
		readfile = type(readfile) == "function",
	}

	app.Status = "YBA 0.2 · base local · testar no jogo"
	refresh_entities()

	app:Notify({
		Title = "Zyon YBA 0.2",
		Content = "Base local carregada. RightCtrl/Insert alternam o painel; funções de farm/combate ainda pendentes.",
		Duration = 8,
	})

	return app

end)()