--// Erius Hub
--// Made by Marius und Erik

local Players = game:GetService("Players")
local UIS = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local GuiService = game:GetService("GuiService")
local CoreGui = game:GetService("CoreGui")
local TweenService = game:GetService("TweenService")
local Lighting = game:GetService("Lighting")

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

--------------------------------------------------
-- STATE
--------------------------------------------------

local running = true
local connections = {}

local flying = false
local flySpeed = 60

_G.__EriusFlyHoldCFrame = nil

local speedEnabled = false
local runSpeed = 50
local normalSpeed = 16

local invisible = false
local noclip = false
local minimized = false

_G.__EriusInfiniteJump = false

_G.__EriusInstantInteract = false
_G.__EriusPromptDurations = {}

local originalCollisions = {}

-- Aimbot
local aimbotEnabled = false
local fovSize = 150
local fovMode = "Crosshair"

local ignoreFriends = false
local ignoreNeutral = false
local ignoreTeam = false
local ignoreNPC = true
local showFOV = true
local targetSwitching = true

local currentTarget = nil
local rightMouseHeld = false

_G.__EriusAimLastLook = nil
_G.__EriusAimWasAutoRotate = nil

-- Trigger Aim
local triggerAimEnabled = false
local triggerAimDelay = 0.16
local triggerAimReadyAt = 0

_G.__EriusAimbotRange = {
    Value = 1000,
    Min = 25,
    Max = 5000,
    Sliding = false
}

-- Erius Clicker
local clickerOpen = false
local clickerEnabled = false
local clickerCPS = 10
local clickerAccumulator = 0
local clickerKey = nil
local waitingForClickerKey = false
local clickerMinimized = false
local clickerDragging = false
local clickerDragStart = nil
local clickerStartPosition = nil
local clickerMoved = false
local clickerDragSource = nil
local refreshClickerVisual

_G.__EriusClickerMode = "Toggle"
_G.__EriusClickerKeyHeld = false

-- ESP
local espSettings = {
    PlayerESP = false,
    Nicknames = true,
    HP = true,
    TeamESP = false,
    FriendESP = false,
    NPCESP = false,
    Box = true
}

local espRange = 1000
local minESPRange = 25
local maxESPRange = 5000
local espObjects = {}

-- Teleport
local selectedTeleportPlayer = nil
local teleportSearch = ""

_G.__EriusFollow = {
    Enabled = false,
    Mode = "Float Behind",
    ModeIndex = 1,
    Modes = {"Float Behind", "Shoulder", "Head Sit", "Doggy"}
}

--------------------------------------------------
-- SETTINGS STATE
--------------------------------------------------

local language = "EN"
local currentTheme = "Erius"
local customColor = Color3.fromHSV(0.48, 0.8, 1)

local animationsEnabled = true
local backgroundBlurEnabled = false
local hubScale = 1

local currentPage = nil
local currentTab = nil

local themeRefreshers = {}
local languageObjects = {}

--------------------------------------------------
-- CONNECTION HELPER
--------------------------------------------------

local function connect(signal, fn)
    local connection = signal:Connect(fn)
    table.insert(connections, connection)
    return connection
end

--------------------------------------------------
-- REMOVE OLD HUB
--------------------------------------------------

pcall(function()
    local old = CoreGui:FindFirstChild("EriusHub")

    if old then
        old:Destroy()
    end
end)

pcall(function()
    local oldBlur = Lighting:FindFirstChild("EriusHubBlur")

    if oldBlur then
        oldBlur:Destroy()
    end
end)

--------------------------------------------------
-- THEMES
--------------------------------------------------

local themes = {
    Black = {
        Main = Color3.fromRGB(20, 20, 24),
        Panel = Color3.fromRGB(45, 45, 55),
        Control = Color3.fromRGB(55, 55, 65),
        DarkPanel = Color3.fromRGB(35, 35, 42),
        Text = Color3.fromRGB(255, 255, 255),
        Muted = Color3.fromRGB(205, 205, 215),
        Accent = Color3.fromRGB(95, 50, 255)
    },

    White = {
        Main = Color3.fromRGB(242, 244, 248),
        Panel = Color3.fromRGB(220, 224, 232),
        Control = Color3.fromRGB(203, 209, 220),
        DarkPanel = Color3.fromRGB(230, 233, 239),
        Text = Color3.fromRGB(25, 28, 34),
        Muted = Color3.fromRGB(85, 90, 100),
        Accent = Color3.fromRGB(95, 50, 255)
    }
}

local function getTheme()
    if currentTheme == "White" then
        return themes.White
    end

    local theme = {}

    for key, value in pairs(themes.Black) do
        theme[key] = value
    end

    if currentTheme == "Custom" then
        theme.Accent = customColor
        theme.Main = customColor:Lerp(Color3.fromRGB(8, 8, 12), 0.78)
        theme.Panel = customColor:Lerp(Color3.fromRGB(28, 28, 35), 0.72)
        theme.Control = customColor:Lerp(Color3.fromRGB(42, 42, 50), 0.68)
        theme.DarkPanel = customColor:Lerp(Color3.fromRGB(18, 18, 24), 0.75)
        theme.Text = Color3.fromRGB(255, 255, 255)
        theme.Muted = Color3.fromRGB(215, 215, 225)
    end

    return theme
end

local function getAccent()
    if currentTheme == "Rainbow" then
        return Color3.fromHSV((tick() * 0.35) % 1, 0.8, 1)
    end

    return getTheme().Accent
end

--------------------------------------------------
-- LANGUAGE
--------------------------------------------------

local translations = {
    DE = {
        ["Main"] = "Main",
        ["Aimbot"] = "Aimbot",
        ["ESP"] = "ESP",
        ["Teleport"] = "Teleport",
        ["Settings"] = "Einstellungen",
        ["Creators"] = "Ersteller",
        ["Built by creators for a better experience"] = "Von Creatorn für ein besseres Erlebnis",
        ["THE CREATOR"] = "DER CREATOR",
        ["Fly: OFF"] = "Fliegen: AUS",
        ["Fly: ON"] = "Fliegen: AN",
        ["Fly Speed"] = "Fluggeschwindigkeit",
        ["Run Speed: OFF"] = "Laufen: AUS",
        ["Run Speed: ON"] = "Laufen: AN",
        ["Run Speed"] = "Laufgeschwindigkeit",
        ["Invisible: OFF"] = "Unsichtbar: AUS",
        ["Invisible: ON"] = "Unsichtbar: AN",
        ["NoClip: OFF"] = "NoClip: AUS",
        ["NoClip: ON"] = "NoClip: AN",
        ["Infinity Jump: OFF"] = "Infinity Jump: AUS",
        ["Infinity Jump: ON"] = "Infinity Jump: AN",
        ["Instant Interact: OFF"] = "Sofort-Interaktion: AUS",
        ["Instant Interact: ON"] = "Sofort-Interaktion: AN",
        ["Open Erius Clicker"] = "Erius Clicker öffnen",
        ["Autoclicker: OFF"] = "Autoklicker: AUS",
        ["Autoclicker: ON"] = "Autoklicker: AN",
        ["Clicks / sec"] = "Klicks / Sek.",
        ["Keybind"] = "Taste",
        ["Click Mode"] = "Tastenmodus",
        ["Toggle"] = "Umschalten",
        ["Hold"] = "Halten",
        ["Press a key..."] = "Taste drücken...",
        ["No key"] = "Keine Taste",
        ["Leave Clicker"] = "Clicker verlassen",
        ["Reset Character"] = "Charakter respawnen",
        ["Leave Script"] = "Script verlassen",
        ["Aimbot: OFF"] = "Aimbot: AUS",
        ["Aimbot: ON"] = "Aimbot: AN",
        ["Circle Size"] = "Kreisgröße",
        ["Aimbot Range"] = "Aimbot Reichweite",
        ["FOV Mode: Crosshair"] = "FOV-Modus: Fadenkreuz",
        ["FOV Mode: Mouse"] = "FOV-Modus: Maus",
        ["Ignore Friends"] = "Freunde ignorieren",
        ["Ignore Neutral"] = "Neutrale ignorieren",
        ["Ignore Team"] = "Team ignorieren",
        ["Ignore NPC"] = "NPCs ignorieren",
        ["Show FOV"] = "FOV anzeigen",
        ["Target Switching"] = "Zielwechsel",
        ["Trigger Aim"] = "Trigger Aim",
        ["Player ESP"] = "Spieler ESP",
        ["Nicknames"] = "Namen",
        ["HP"] = "Leben",
        ["Team ESP"] = "Team ESP",
        ["Friend ESP"] = "Freunde ESP",
        ["NPC ESP"] = "NPC ESP",
        ["Box"] = "Box",
        ["ESP Range"] = "ESP Reichweite",
        ["Search username or display name..."] = "Benutzername oder Anzeigename suchen...",
        ["Selected: Nobody"] = "Ausgewählt: Niemand",
        ["Selected"] = "Ausgewählt",
        ["Refresh Player List"] = "Spielerliste aktualisieren",
        ["Teleport to Player"] = "Zum Spieler teleportieren",
        ["Follow Player: OFF"] = "Spieler folgen: AUS",
        ["Follow Player: ON"] = "Spieler folgen: AN",
        ["Mode"] = "Modus",
        ["Float Behind"] = "Hinterher schweben",
        ["Shoulder"] = "Schulter",
        ["Head Sit"] = "Auf Kopf sitzen",
        ["Doggy"] = "Doggy",
        ["Hub Settings"] = "Hub Einstellungen",
        ["Language"] = "Sprache",
        ["Theme"] = "Design",
        ["Erius"] = "Erius",
        ["Black"] = "Schwarz",
        ["White"] = "Weiß",
        ["Rainbow"] = "Rainbow",
        ["Custom"] = "Eigene Farbe",
        ["Custom Color"] = "Eigene Farbe",
        ["Interface Scale"] = "Hub Größe",
        ["Background Blur"] = "Hintergrund-Unschärfe",
        ["Animations"] = "Animationen",
        ["Made by Marius and Erik"] = "Erstellt von Marius und Erik"
    },

    ES = {
        ["Main"] = "Principal",
        ["Aimbot"] = "Aimbot",
        ["ESP"] = "ESP",
        ["Teleport"] = "Teletransporte",
        ["Settings"] = "Ajustes",
        ["Creators"] = "Creadores",
        ["Built by creators for a better experience"] = "Creado por creadores para una mejor experiencia",
        ["THE CREATOR"] = "EL CREADOR",
        ["Fly: OFF"] = "Volar: DES",
        ["Fly: ON"] = "Volar: ACT",
        ["Fly Speed"] = "Velocidad de vuelo",
        ["Run Speed: OFF"] = "Velocidad: DES",
        ["Run Speed: ON"] = "Velocidad: ACT",
        ["Run Speed"] = "Velocidad al correr",
        ["Invisible: OFF"] = "Invisible: DES",
        ["Invisible: ON"] = "Invisible: ACT",
        ["NoClip: OFF"] = "NoClip: DES",
        ["NoClip: ON"] = "NoClip: ACT",
        ["Infinity Jump: OFF"] = "Salto infinito: DES",
        ["Infinity Jump: ON"] = "Salto infinito: ACT",
        ["Instant Interact: OFF"] = "Interacción instantánea: DES",
        ["Instant Interact: ON"] = "Interacción instantánea: ACT",
        ["Open Erius Clicker"] = "Abrir Erius Clicker",
        ["Autoclicker: OFF"] = "Autoclicker: DES",
        ["Autoclicker: ON"] = "Autoclicker: ACT",
        ["Clicks / sec"] = "Clics / seg",
        ["Keybind"] = "Tecla",
        ["Click Mode"] = "Modo de tecla",
        ["Toggle"] = "Alternar",
        ["Hold"] = "Mantener",
        ["Press a key..."] = "Pulsa una tecla...",
        ["No key"] = "Sin tecla",
        ["Leave Clicker"] = "Cerrar Clicker",
        ["Reset Character"] = "Reiniciar personaje",
        ["Leave Script"] = "Cerrar script",
        ["Aimbot: OFF"] = "Aimbot: DES",
        ["Aimbot: ON"] = "Aimbot: ACT",
        ["Circle Size"] = "Tamaño del círculo",
        ["Aimbot Range"] = "Rango del Aimbot",
        ["FOV Mode: Crosshair"] = "Modo FOV: Mira",
        ["FOV Mode: Mouse"] = "Modo FOV: Ratón",
        ["Ignore Friends"] = "Ignorar amigos",
        ["Ignore Neutral"] = "Ignorar neutrales",
        ["Ignore Team"] = "Ignorar equipo",
        ["Ignore NPC"] = "Ignorar NPC",
        ["Show FOV"] = "Mostrar FOV",
        ["Target Switching"] = "Cambio de objetivo",
        ["Trigger Aim"] = "Disparo automático",
        ["Player ESP"] = "ESP de jugadores",
        ["Nicknames"] = "Nombres",
        ["HP"] = "Vida",
        ["Team ESP"] = "ESP de equipo",
        ["Friend ESP"] = "ESP de amigos",
        ["NPC ESP"] = "ESP de NPC",
        ["Box"] = "Caja",
        ["ESP Range"] = "Rango ESP",
        ["Search username or display name..."] = "Buscar usuario o nombre visible...",
        ["Selected: Nobody"] = "Seleccionado: Nadie",
        ["Selected"] = "Seleccionado",
        ["Refresh Player List"] = "Actualizar jugadores",
        ["Teleport to Player"] = "Teletransportar al jugador",
        ["Follow Player: OFF"] = "Seguir jugador: DES",
        ["Follow Player: ON"] = "Seguir jugador: ACT",
        ["Mode"] = "Modo",
        ["Float Behind"] = "Flotar detrás",
        ["Shoulder"] = "Hombro",
        ["Head Sit"] = "Sentarse en la cabeza",
        ["Doggy"] = "Doggy",
        ["Hub Settings"] = "Ajustes del Hub",
        ["Language"] = "Idioma",
        ["Theme"] = "Tema",
        ["Erius"] = "Erius",
        ["Erius"] = "Erius",
        ["Black"] = "Negro",
        ["White"] = "Blanco",
        ["Rainbow"] = "Arcoíris",
        ["Custom"] = "Personalizado",
        ["Custom Color"] = "Color personalizado",
        ["Interface Scale"] = "Tamaño de interfaz",
        ["Background Blur"] = "Desenfoque de fondo",
        ["Animations"] = "Animaciones",
        ["Made by Marius and Erik"] = "Hecho por Marius y Erik"
    },

    RU = {
        ["Main"] = "Главная",
        ["Aimbot"] = "Аимбот",
        ["ESP"] = "ESP",
        ["Teleport"] = "Телепорт",
        ["Settings"] = "Настройки",
        ["Creators"] = "Создатели",
        ["Built by creators for a better experience"] = "Создано авторами для лучшего опыта",
        ["THE CREATOR"] = "СОЗДАТЕЛЬ",
        ["Fly: OFF"] = "Полёт: ВЫКЛ",
        ["Fly: ON"] = "Полёт: ВКЛ",
        ["Fly Speed"] = "Скорость полёта",
        ["Run Speed: OFF"] = "Скорость: ВЫКЛ",
        ["Run Speed: ON"] = "Скорость: ВКЛ",
        ["Run Speed"] = "Скорость бега",
        ["Invisible: OFF"] = "Невидимость: ВЫКЛ",
        ["Invisible: ON"] = "Невидимость: ВКЛ",
        ["NoClip: OFF"] = "NoClip: ВЫКЛ",
        ["NoClip: ON"] = "NoClip: ВКЛ",
        ["Infinity Jump: OFF"] = "Бесконечный прыжок: ВЫКЛ",
        ["Infinity Jump: ON"] = "Бесконечный прыжок: ВКЛ",
        ["Instant Interact: OFF"] = "Мгновенное взаимодействие: ВЫКЛ",
        ["Instant Interact: ON"] = "Мгновенное взаимодействие: ВКЛ",
        ["Open Erius Clicker"] = "Открыть Erius Clicker",
        ["Autoclicker: OFF"] = "Автокликер: ВЫКЛ",
        ["Autoclicker: ON"] = "Автокликер: ВКЛ",
        ["Clicks / sec"] = "Кликов / сек",
        ["Keybind"] = "Клавиша",
        ["Click Mode"] = "Режим клавиши",
        ["Toggle"] = "Переключение",
        ["Hold"] = "Удержание",
        ["Press a key..."] = "Нажмите клавишу...",
        ["No key"] = "Нет клавиши",
        ["Leave Clicker"] = "Закрыть Clicker",
        ["Reset Character"] = "Сбросить персонажа",
        ["Leave Script"] = "Закрыть скрипт",
        ["Aimbot: OFF"] = "Аимбот: ВЫКЛ",
        ["Aimbot: ON"] = "Аимбот: ВКЛ",
        ["Circle Size"] = "Размер круга",
        ["Aimbot Range"] = "Дальность Aimbot",
        ["FOV Mode: Crosshair"] = "Режим FOV: Прицел",
        ["FOV Mode: Mouse"] = "Режим FOV: Мышь",
        ["Ignore Friends"] = "Игнорировать друзей",
        ["Ignore Neutral"] = "Игнорировать нейтральных",
        ["Ignore Team"] = "Игнорировать команду",
        ["Ignore NPC"] = "Игнорировать NPC",
        ["Show FOV"] = "Показывать FOV",
        ["Target Switching"] = "Смена цели",
        ["Trigger Aim"] = "Автовыстрел",
        ["Player ESP"] = "ESP игроков",
        ["Nicknames"] = "Имена",
        ["HP"] = "Здоровье",
        ["Team ESP"] = "ESP команды",
        ["Friend ESP"] = "ESP друзей",
        ["NPC ESP"] = "ESP NPC",
        ["Box"] = "Рамка",
        ["ESP Range"] = "Дальность ESP",
        ["Search username or display name..."] = "Поиск имени пользователя...",
        ["Selected: Nobody"] = "Выбрано: Никого",
        ["Selected"] = "Выбрано",
        ["Refresh Player List"] = "Обновить список игроков",
        ["Teleport to Player"] = "Телепорт к игроку",
        ["Follow Player: OFF"] = "Следовать: ВЫКЛ",
        ["Follow Player: ON"] = "Следовать: ВКЛ",
        ["Mode"] = "Режим",
        ["Float Behind"] = "Парить сзади",
        ["Shoulder"] = "Плечо",
        ["Head Sit"] = "Сидеть на голове",
        ["Doggy"] = "Doggy",
        ["Hub Settings"] = "Настройки Hub",
        ["Language"] = "Язык",
        ["Theme"] = "Тема",
        ["Erius"] = "Erius",
        ["Black"] = "Чёрный",
        ["White"] = "Белый",
        ["Rainbow"] = "Радуга",
        ["Custom"] = "Свой",
        ["Custom Color"] = "Свой цвет",
        ["Interface Scale"] = "Размер интерфейса",
        ["Background Blur"] = "Размытие фона",
        ["Animations"] = "Анимации",
        ["Made by Marius and Erik"] = "Создано Мариусом и Эриком"
    },

    FR = {
        ["Main"] = "Principal",
        ["Aimbot"] = "Aimbot",
        ["ESP"] = "ESP",
        ["Teleport"] = "Téléportation",
        ["Settings"] = "Paramètres",
        ["Creators"] = "Créateurs",
        ["Built by creators for a better experience"] = "Créé par des créateurs pour une meilleure expérience",
        ["THE CREATOR"] = "LE CRÉATEUR",
        ["Fly: OFF"] = "Vol: OFF",
        ["Fly: ON"] = "Vol: ON",
        ["Fly Speed"] = "Vitesse de vol",
        ["Run Speed: OFF"] = "Vitesse: OFF",
        ["Run Speed: ON"] = "Vitesse: ON",
        ["Run Speed"] = "Vitesse de course",
        ["Invisible: OFF"] = "Invisible: OFF",
        ["Invisible: ON"] = "Invisible: ON",
        ["NoClip: OFF"] = "NoClip: OFF",
        ["NoClip: ON"] = "NoClip: ON",
        ["Infinity Jump: OFF"] = "Saut infini: OFF",
        ["Infinity Jump: ON"] = "Saut infini: ON",
        ["Instant Interact: OFF"] = "Interaction instantanée: OFF",
        ["Instant Interact: ON"] = "Interaction instantanée: ON",
        ["Open Erius Clicker"] = "Ouvrir Erius Clicker",
        ["Autoclicker: OFF"] = "Autoclicker: OFF",
        ["Autoclicker: ON"] = "Autoclicker: ON",
        ["Clicks / sec"] = "Clics / sec",
        ["Keybind"] = "Touche",
        ["Click Mode"] = "Mode de touche",
        ["Toggle"] = "Basculer",
        ["Hold"] = "Maintenir",
        ["Press a key..."] = "Appuyez sur une touche...",
        ["No key"] = "Aucune touche",
        ["Leave Clicker"] = "Fermer Clicker",
        ["Reset Character"] = "Réinitialiser le personnage",
        ["Leave Script"] = "Fermer le script",
        ["Aimbot: OFF"] = "Aimbot: OFF",
        ["Aimbot: ON"] = "Aimbot: ON",
        ["Circle Size"] = "Taille du cercle",
        ["Aimbot Range"] = "Portée Aimbot",
        ["FOV Mode: Crosshair"] = "Mode FOV: Viseur",
        ["FOV Mode: Mouse"] = "Mode FOV: Souris",
        ["Ignore Friends"] = "Ignorer les amis",
        ["Ignore Neutral"] = "Ignorer les neutres",
        ["Ignore Team"] = "Ignorer l'équipe",
        ["Ignore NPC"] = "Ignorer les NPC",
        ["Show FOV"] = "Afficher FOV",
        ["Target Switching"] = "Changement de cible",
        ["Trigger Aim"] = "Tir automatique",
        ["Player ESP"] = "ESP joueurs",
        ["Nicknames"] = "Noms",
        ["HP"] = "Vie",
        ["Team ESP"] = "ESP équipe",
        ["Friend ESP"] = "ESP amis",
        ["NPC ESP"] = "ESP NPC",
        ["Box"] = "Boîte",
        ["ESP Range"] = "Portée ESP",
        ["Search username or display name..."] = "Rechercher un utilisateur...",
        ["Selected: Nobody"] = "Sélectionné: Personne",
        ["Selected"] = "Sélectionné",
        ["Refresh Player List"] = "Actualiser les joueurs",
        ["Teleport to Player"] = "Se téléporter au joueur",
        ["Follow Player: OFF"] = "Suivre joueur: OFF",
        ["Follow Player: ON"] = "Suivre joueur: ON",
        ["Mode"] = "Mode",
        ["Float Behind"] = "Flotter derrière",
        ["Shoulder"] = "Épaule",
        ["Head Sit"] = "Assis sur la tête",
        ["Doggy"] = "Doggy",
        ["Hub Settings"] = "Paramètres du Hub",
        ["Language"] = "Langue",
        ["Theme"] = "Thème",
        ["Erius"] = "Erius",
        ["Black"] = "Noir",
        ["White"] = "Blanc",
        ["Rainbow"] = "Arc-en-ciel",
        ["Custom"] = "Personnalisé",
        ["Custom Color"] = "Couleur personnalisée",
        ["Interface Scale"] = "Taille de l'interface",
        ["Background Blur"] = "Flou d'arrière-plan",
        ["Animations"] = "Animations",
        ["Made by Marius and Erik"] = "Créé par Marius et Erik"
    },

    TR = {
        ["Main"] = "Ana Sayfa",
        ["Aimbot"] = "Aimbot",
        ["ESP"] = "ESP",
        ["Teleport"] = "Işınlanma",
        ["Settings"] = "Ayarlar",
        ["Creators"] = "Yapımcılar",
        ["Built by creators for a better experience"] = "Daha iyi bir deneyim için yapımcılar tarafından geliştirildi",
        ["THE CREATOR"] = "YAPIMCI",
        ["Fly: OFF"] = "Uçuş: KAPALI",
        ["Fly: ON"] = "Uçuş: AÇIK",
        ["Fly Speed"] = "Uçuş hızı",
        ["Run Speed: OFF"] = "Hız: KAPALI",
        ["Run Speed: ON"] = "Hız: AÇIK",
        ["Run Speed"] = "Koşu hızı",
        ["Invisible: OFF"] = "Görünmez: KAPALI",
        ["Invisible: ON"] = "Görünmez: AÇIK",
        ["NoClip: OFF"] = "NoClip: KAPALI",
        ["NoClip: ON"] = "NoClip: AÇIK",
        ["Infinity Jump: OFF"] = "Sonsuz zıplama: KAPALI",
        ["Infinity Jump: ON"] = "Sonsuz zıplama: AÇIK",
        ["Instant Interact: OFF"] = "Anında etkileşim: KAPALI",
        ["Instant Interact: ON"] = "Anında etkileşim: AÇIK",
        ["Open Erius Clicker"] = "Erius Clicker aç",
        ["Autoclicker: OFF"] = "Otomatik tıklama: KAPALI",
        ["Autoclicker: ON"] = "Otomatik tıklama: AÇIK",
        ["Clicks / sec"] = "Tıklama / sn",
        ["Keybind"] = "Tuş",
        ["Click Mode"] = "Tuş modu",
        ["Toggle"] = "Aç/Kapat",
        ["Hold"] = "Basılı tut",
        ["Press a key..."] = "Bir tuşa bas...",
        ["No key"] = "Tuş yok",
        ["Leave Clicker"] = "Clicker'ı kapat",
        ["Reset Character"] = "Karakteri sıfırla",
        ["Leave Script"] = "Script'i kapat",
        ["Aimbot: OFF"] = "Aimbot: KAPALI",
        ["Aimbot: ON"] = "Aimbot: AÇIK",
        ["Circle Size"] = "Daire boyutu",
        ["Aimbot Range"] = "Aimbot mesafesi",
        ["FOV Mode: Crosshair"] = "FOV Modu: Nişangâh",
        ["FOV Mode: Mouse"] = "FOV Modu: Fare",
        ["Ignore Friends"] = "Arkadaşları yok say",
        ["Ignore Neutral"] = "Tarafsızları yok say",
        ["Ignore Team"] = "Takımı yok say",
        ["Ignore NPC"] = "NPC'leri yok say",
        ["Show FOV"] = "FOV göster",
        ["Target Switching"] = "Hedef değiştirme",
        ["Trigger Aim"] = "Otomatik ateş",
        ["Player ESP"] = "Oyuncu ESP",
        ["Nicknames"] = "İsimler",
        ["HP"] = "Can",
        ["Team ESP"] = "Takım ESP",
        ["Friend ESP"] = "Arkadaş ESP",
        ["NPC ESP"] = "NPC ESP",
        ["Box"] = "Kutu",
        ["ESP Range"] = "ESP mesafesi",
        ["Search username or display name..."] = "Kullanıcı adı ara...",
        ["Selected: Nobody"] = "Seçilen: Hiç kimse",
        ["Selected"] = "Seçilen",
        ["Refresh Player List"] = "Oyuncu listesini yenile",
        ["Teleport to Player"] = "Oyuncuya ışınlan",
        ["Follow Player: OFF"] = "Oyuncuyu takip et: KAPALI",
        ["Follow Player: ON"] = "Oyuncuyu takip et: AÇIK",
        ["Mode"] = "Mod",
        ["Float Behind"] = "Arkada süzül",
        ["Shoulder"] = "Omuz",
        ["Head Sit"] = "Kafada otur",
        ["Doggy"] = "Doggy",
        ["Hub Settings"] = "Hub Ayarları",
        ["Language"] = "Dil",
        ["Theme"] = "Tema",
        ["Black"] = "Siyah",
        ["White"] = "Beyaz",
        ["Rainbow"] = "Gökkuşağı",
        ["Custom"] = "Özel",
        ["Custom Color"] = "Özel renk",
        ["Interface Scale"] = "Arayüz boyutu",
        ["Background Blur"] = "Arka plan bulanıklığı",
        ["Animations"] = "Animasyonlar",
        ["Made by Marius and Erik"] = "Marius ve Erik tarafından yapıldı"
    }
}

local function T(text)
    if language == "EN" then
        return text
    end

    local languageTable = translations[language]

    if languageTable then
        return languageTable[text] or text
    end

    return text
end

local function registerLanguageObject(object, englishText)
    table.insert(languageObjects, {
        Object = object,
        Text = englishText
    })

    object.Text = T(englishText)
end

--------------------------------------------------
-- HELPERS
--------------------------------------------------

local function round(object, radius)
    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(0, radius or 9)
    corner.Parent = object
end

local function getCharacter()
    local character = player.Character

    if not character then
        return nil, nil, nil
    end

    return character,
        character:FindFirstChild("HumanoidRootPart"),
        character:FindFirstChildOfClass("Humanoid")
end

local function setButtonState(button, state, onText, offText)
    button.Text = T(state and onText or offText)
    button.BackgroundColor3 = state and getAccent() or getTheme().Control
end

--------------------------------------------------
-- GUI
--------------------------------------------------

local gui = Instance.new("ScreenGui")
gui.Name = "EriusHub"
gui.ResetOnSpawn = false
gui.IgnoreGuiInset = true
gui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
gui.Parent = CoreGui

--------------------------------------------------
-- MAIN WINDOW
--------------------------------------------------

local main = Instance.new("Frame")
main.Size = UDim2.fromOffset(430, 650)
main.Position = UDim2.new(0.5, -215, 0.5, -325)
main.BackgroundColor3 = getTheme().Main
main.BorderSizePixel = 0
main.ZIndex = 10
main.Active = true
main.Parent = gui

round(main, 14)

connect(main.InputBegan, function(input)
    if input.UserInputType
        == Enum.UserInputType.MouseButton1
        or input.UserInputType
        == Enum.UserInputType.Touch then

        if _G.__EriusBringWindowToFront then
            _G.__EriusBringWindowToFront("Hub")
        end
    end
end)

--------------------------------------------------
-- ERIUS HUB BACKGROUND
--------------------------------------------------

_G.__EriusHubBackground = Instance.new("ImageLabel")
_G.__EriusHubBackground.Name = "EriusHubBackground"
_G.__EriusHubBackground.Size = UDim2.fromScale(1, 1)
_G.__EriusHubBackground.Position = UDim2.fromScale(0, 0)
_G.__EriusHubBackground.BackgroundTransparency = 1
_G.__EriusHubBackground.Image = "rbxassetid://98830209894912"
_G.__EriusHubBackground.ImageTransparency = 0
_G.__EriusHubBackground.ScaleType = Enum.ScaleType.Crop
_G.__EriusHubBackground.ZIndex = 0
_G.__EriusHubBackground.Parent = main

round(_G.__EriusHubBackground, 14)

_G.__EriusHubBackgroundShade = Instance.new("Frame")
_G.__EriusHubBackgroundShade.Name = "EriusHubBackgroundShade"
_G.__EriusHubBackgroundShade.Size = UDim2.fromScale(1, 1)
_G.__EriusHubBackgroundShade.Position = UDim2.fromScale(0, 0)
_G.__EriusHubBackgroundShade.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
_G.__EriusHubBackgroundShade.BackgroundTransparency = 0.52
_G.__EriusHubBackgroundShade.BorderSizePixel = 0
_G.__EriusHubBackgroundShade.ZIndex = 0
_G.__EriusHubBackgroundShade.Parent = main

round(_G.__EriusHubBackgroundShade, 14)

local mainScale = Instance.new("UIScale")
mainScale.Scale = hubScale
mainScale.Parent = main

--------------------------------------------------
-- TITLE
--------------------------------------------------

local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, -100, 0, 45)
title.Position = UDim2.fromOffset(15, 0)
title.BackgroundTransparency = 1
title.Text = "Erius Hub"
title.TextColor3 = getTheme().Text
title.Font = Enum.Font.GothamBold
title.TextSize = 22
title.TextXAlignment = Enum.TextXAlignment.Left
title.Active = true
title.ZIndex = 5
title.Parent = main

--------------------------------------------------
-- MINIMIZE
--------------------------------------------------

local minimize = Instance.new("TextButton")
minimize.Size = UDim2.fromOffset(38, 32)
minimize.Position = UDim2.new(1, -45, 0, 7)
minimize.BackgroundColor3 = getTheme().Panel
minimize.TextColor3 = getTheme().Text
minimize.Text = "—"
minimize.TextSize = 20
minimize.ZIndex = 6
minimize.Parent = main

round(minimize, 8)

--------------------------------------------------
-- TABS
--------------------------------------------------

local tabs = Instance.new("Frame")
tabs.Size = UDim2.new(1, -30, 0, 42)
tabs.Position = UDim2.fromOffset(15, 50)
tabs.BackgroundTransparency = 1
tabs.Parent = main

local function makeTab(name, x, width)
    local button = Instance.new("TextButton")
    button.Size = UDim2.fromOffset(width, 36)
    button.Position = UDim2.fromOffset(x, 0)
    button.BackgroundColor3 = getTheme().Panel
    button.TextColor3 = getTheme().Text
    button.Text = T(name)
    button.Font = Enum.Font.GothamBold
    button.TextSize = 12
    button.TextScaled = true
    button.Parent = tabs

    local textConstraint = Instance.new("UITextSizeConstraint")
    textConstraint.MinTextSize = 9
    textConstraint.MaxTextSize = 12
    textConstraint.Parent = button

    round(button, 8)
    registerLanguageObject(button, name)

    return button
end

local mainTab = makeTab("Main", 0, 60)
local aimbotTab = makeTab("Aimbot", 64, 65)
local espTab = makeTab("ESP", 133, 48)
local teleportTab = makeTab("Teleport", 185, 68)
local settingsTab = makeTab("Settings", 257, 67)

_G.__EriusCreators = _G.__EriusCreators or {}
_G.__EriusCreators.Tab = makeTab("Creators", 328, 71)

--------------------------------------------------
-- PAGES
--------------------------------------------------

local pages = Instance.new("Frame")
pages.Size = UDim2.new(1, -30, 0, 475)
pages.Position = UDim2.fromOffset(15, 100)
pages.BackgroundTransparency = 1
pages.Parent = main

local function createPage()
    local page = Instance.new("Frame")
    page.Size = UDim2.fromScale(1, 1)
    page.BackgroundTransparency = 1
    page.Visible = false
    page.Parent = pages

    local scale = Instance.new("UIScale")
    scale.Name = "PageAnimationScale"
    scale.Scale = 1
    scale.Parent = page

    return page
end

local mainPage = createPage()
local aimbotPage = createPage()
local espPage = createPage()
local teleportPage = createPage()
local settingsPage = createPage()
_G.__EriusCreators.Page = createPage()

--------------------------------------------------
-- TAB SWITCH
--------------------------------------------------

local function resetTabs()
    mainTab.BackgroundColor3 = getTheme().Panel
    aimbotTab.BackgroundColor3 = getTheme().Panel
    espTab.BackgroundColor3 = getTheme().Panel
    teleportTab.BackgroundColor3 = getTheme().Panel
    settingsTab.BackgroundColor3 = getTheme().Panel

    if _G.__EriusCreators and _G.__EriusCreators.Tab then
        _G.__EriusCreators.Tab.BackgroundColor3 = getTheme().Panel
    end
end

local function showPage(page, button)
    mainPage.Visible = false
    aimbotPage.Visible = false
    espPage.Visible = false
    teleportPage.Visible = false
    settingsPage.Visible = false

    if _G.__EriusCreators and _G.__EriusCreators.Page then
        _G.__EriusCreators.Page.Visible = false
    end

    resetTabs()

    page.Visible = true
    button.BackgroundColor3 = getAccent()

    currentPage = page
    currentTab = button

    if animationsEnabled then
        local scale = page:FindFirstChild("PageAnimationScale")

        if scale then
            scale.Scale = 0.96

            TweenService:Create(
                scale,
                TweenInfo.new(
                    0.18,
                    Enum.EasingStyle.Quint,
                    Enum.EasingDirection.Out
                ),
                {Scale = 1}
            ):Play()
        end
    end
end

connect(mainTab.MouseButton1Click, function()
    showPage(mainPage, mainTab)
end)

connect(aimbotTab.MouseButton1Click, function()
    showPage(aimbotPage, aimbotTab)
end)

connect(espTab.MouseButton1Click, function()
    showPage(espPage, espTab)
end)

connect(teleportTab.MouseButton1Click, function()
    showPage(teleportPage, teleportTab)
end)

connect(settingsTab.MouseButton1Click, function()
    showPage(settingsPage, settingsTab)
end)

connect(_G.__EriusCreators.Tab.MouseButton1Click, function()
    showPage(
        _G.__EriusCreators.Page,
        _G.__EriusCreators.Tab
    )

    if _G.__EriusCreators.PlayIntro then
        _G.__EriusCreators.PlayIntro()
    end
end)

--------------------------------------------------
-- BUTTON CREATOR
--------------------------------------------------

local function makeButton(parent, text, y)
    local button = Instance.new("TextButton")
    button.Size = UDim2.new(1, 0, 0, 45)
    button.Position = UDim2.fromOffset(0, y)
    button.BackgroundColor3 = getTheme().Control
    button.TextColor3 = getTheme().Text
    button.Text = T(text)
    button.Font = Enum.Font.GothamBold
    button.TextSize = 16
    button.Parent = parent

    round(button, 9)
    registerLanguageObject(button, text)

    return button
end

--------------------------------------------------
-- TOGGLE CREATOR
--------------------------------------------------

local function makeToggle(parent, text, y, getState, setState)
    local row = Instance.new("Frame")
    row.Size = UDim2.new(1, 0, 0, 40)
    row.Position = UDim2.fromOffset(0, y)
    row.BackgroundColor3 = getTheme().Panel
    row.Parent = parent

    round(row, 8)

    local label = Instance.new("TextLabel")
    label.Size = UDim2.new(1, -80, 1, 0)
    label.Position = UDim2.fromOffset(12, 0)
    label.BackgroundTransparency = 1
    label.Text = T(text)
    label.TextColor3 = getTheme().Text
    label.Font = Enum.Font.GothamSemibold
    label.TextSize = 14
    label.TextXAlignment = Enum.TextXAlignment.Left
    label.Parent = row

    registerLanguageObject(label, text)

    local toggle = Instance.new("TextButton")
    toggle.Size = UDim2.fromOffset(60, 28)
    toggle.Position = UDim2.new(1, -70, 0.5, -14)
    toggle.Text = ""
    toggle.Parent = row

    round(toggle, 14)

    local knob = Instance.new("Frame")
    knob.Size = UDim2.fromOffset(24, 24)
    knob.BackgroundColor3 = Color3.new(1, 1, 1)
    knob.Parent = toggle

    round(knob, 12)

    local function refresh()
        local state = getState()

        toggle.BackgroundColor3 =
            state and getAccent() or Color3.fromRGB(80, 80, 90)

        knob.Position =
            state and UDim2.fromOffset(34, 2) or UDim2.fromOffset(2, 2)
    end

    table.insert(themeRefreshers, refresh)

    connect(toggle.MouseButton1Click, function()
        setState(not getState())
        refresh()
    end)

    refresh()

    return refresh
end

--------------------------------------------------
-- MAIN PAGE
--------------------------------------------------

local flyButton = Instance.new("TextButton")
flyButton.Size = UDim2.new(0.48, 0, 0, 45)
flyButton.Position = UDim2.fromOffset(0, 0)
flyButton.BackgroundColor3 = getTheme().Control
flyButton.TextColor3 = getTheme().Text
flyButton.Text = T("Fly: OFF")
flyButton.Font = Enum.Font.GothamBold
flyButton.TextSize = 16
flyButton.Parent = mainPage

round(flyButton)

local flyBox = Instance.new("TextBox")
flyBox.Size = UDim2.new(0.48, 0, 0, 45)
flyBox.Position = UDim2.new(0.52, 0, 0, 0)
flyBox.BackgroundColor3 = getTheme().Control
flyBox.TextColor3 = getTheme().Text
flyBox.Text = "60"
flyBox.PlaceholderText = T("Fly Speed")
flyBox.ClearTextOnFocus = false
flyBox.Font = Enum.Font.Gotham
flyBox.TextSize = 16
flyBox.Parent = mainPage

round(flyBox)

local speedButton = Instance.new("TextButton")
speedButton.Size = UDim2.new(0.48, 0, 0, 45)
speedButton.Position = UDim2.fromOffset(0, 60)
speedButton.BackgroundColor3 = getTheme().Control
speedButton.TextColor3 = getTheme().Text
speedButton.Text = T("Run Speed: OFF")
speedButton.Font = Enum.Font.GothamBold
speedButton.TextSize = 16
speedButton.Parent = mainPage

round(speedButton)

local speedBox = Instance.new("TextBox")
speedBox.Size = UDim2.new(0.48, 0, 0, 45)
speedBox.Position = UDim2.new(0.52, 0, 0, 60)
speedBox.BackgroundColor3 = getTheme().Control
speedBox.TextColor3 = getTheme().Text
speedBox.Text = "50"
speedBox.PlaceholderText = T("Run Speed")
speedBox.ClearTextOnFocus = false
speedBox.Font = Enum.Font.Gotham
speedBox.TextSize = 16
speedBox.Parent = mainPage

round(speedBox)

local invisibleButton = makeButton(mainPage, "Invisible: OFF", 120)
local noclipButton = makeButton(mainPage, "NoClip: OFF", 180)
_G.__EriusInfiniteJumpButton = makeButton(mainPage, "Infinity Jump: OFF", 240)
local openClickerButton = makeButton(mainPage, "Open Erius Clicker", 300)
local resetCharacterButton = makeButton(mainPage, "Reset Character", 360)

--------------------------------------------------
-- LEAVE SCRIPT
--------------------------------------------------

local leaveButton = makeButton(mainPage, "Leave Script", 420)
leaveButton.BackgroundColor3 = Color3.fromRGB(170, 55, 55)

--------------------------------------------------
-- MAIN INPUTS
--------------------------------------------------

connect(flyBox.FocusLost, function()
    local value = tonumber(flyBox.Text)

    if value then
        flySpeed = math.clamp(value, 1, 2000)
    end

    flyBox.Text = tostring(flySpeed)
end)

connect(speedBox.FocusLost, function()
    local value = tonumber(speedBox.Text)

    if value then
        runSpeed = math.clamp(value, 1, 2000)
    end

    speedBox.Text = tostring(runSpeed)

    if speedEnabled then
        local _, _, humanoid = getCharacter()

        if humanoid then
            humanoid.WalkSpeed = runSpeed
        end
    end
end)

--------------------------------------------------
-- INVISIBLE
--------------------------------------------------

local function setInvisible(state)
    local character = player.Character

    if not character then
        return
    end

    invisible = state

    for _, object in ipairs(character:GetDescendants()) do
        if object:IsA("BasePart") then
            if object.Name ~= "HumanoidRootPart" then
                object.LocalTransparencyModifier = invisible and 1 or 0
            end
        elseif object:IsA("Decal") then
            object.Transparency = invisible and 1 or 0
        end
    end

    setButtonState(
        invisibleButton,
        invisible,
        "Invisible: ON",
        "Invisible: OFF"
    )
end

--------------------------------------------------
-- NOCLIP
--------------------------------------------------

local function enableNoclip()
    local character = player.Character

    if not character then
        return
    end

    for _, object in ipairs(character:GetDescendants()) do
        if object:IsA("BasePart") then
            if originalCollisions[object] == nil then
                originalCollisions[object] = object.CanCollide
            end

            object.CanCollide = false
        end
    end
end

local function disableNoclip()
    for object, state in pairs(originalCollisions) do
        if object and object.Parent then
            object.CanCollide = state
        end
    end

    originalCollisions = {}
end

--------------------------------------------------
-- MAIN EVENTS
--------------------------------------------------

connect(flyButton.MouseButton1Click, function()
    flying = not flying
    _G.__EriusFlyHoldCFrame = nil

    setButtonState(flyButton, flying, "Fly: ON", "Fly: OFF")

    if not flying then
        local _, root = getCharacter()

        if root then
            root.AssemblyLinearVelocity = Vector3.zero
            root.AssemblyAngularVelocity = Vector3.zero
        end
    end
end)

connect(speedButton.MouseButton1Click, function()
    speedEnabled = not speedEnabled

    setButtonState(
        speedButton,
        speedEnabled,
        "Run Speed: ON",
        "Run Speed: OFF"
    )

    local _, _, humanoid = getCharacter()

    if humanoid then
        humanoid.WalkSpeed = speedEnabled and runSpeed or normalSpeed
    end
end)

connect(invisibleButton.MouseButton1Click, function()
    setInvisible(not invisible)
end)

connect(noclipButton.MouseButton1Click, function()
    noclip = not noclip

    setButtonState(noclipButton, noclip, "NoClip: ON", "NoClip: OFF")

    if not noclip then
        disableNoclip()
    end
end)


connect(_G.__EriusInfiniteJumpButton.MouseButton1Click, function()
    _G.__EriusInfiniteJump = not _G.__EriusInfiniteJump

    setButtonState(
        _G.__EriusInfiniteJumpButton,
        _G.__EriusInfiniteJump,
        "Infinity Jump: ON",
        "Infinity Jump: OFF"
    )
end)

connect(UIS.JumpRequest, function()
    if not running or not _G.__EriusInfiniteJump then
        return
    end

    local _, _, humanoid = getCharacter()

    if humanoid and humanoid.Health > 0 then
        humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
    end
end)


--------------------------------------------------
-- INSTANT INTERACT
--------------------------------------------------

_G.__EriusApplyInstantPrompt = function(prompt)
    if not prompt or not prompt:IsA("ProximityPrompt") then
        return
    end

    if _G.__EriusPromptDurations[prompt] == nil then
        _G.__EriusPromptDurations[prompt] = prompt.HoldDuration
    end

    if _G.__EriusInstantInteract then
        prompt.HoldDuration = 0
    end
end

_G.__EriusRestoreInstantPrompts = function()
    for prompt, duration in pairs(_G.__EriusPromptDurations) do
        if prompt and prompt.Parent then
            prompt.HoldDuration = duration
        end
    end
end

_G.__EriusRefreshInstantInteract = function()
    if _G.__EriusInstantInteract then
        for _, object in ipairs(workspace:GetDescendants()) do
            if object:IsA("ProximityPrompt") then
                _G.__EriusApplyInstantPrompt(object)
            end
        end
    else
        _G.__EriusRestoreInstantPrompts()
    end

    if _G.__EriusSteelInteractButton then
        setButtonState(
            _G.__EriusSteelInteractButton,
            _G.__EriusInstantInteract,
            "Instant Interact: ON",
            "Instant Interact: OFF"
        )
    end
end

connect(workspace.DescendantAdded, function(object)
    if _G.__EriusInstantInteract
        and object:IsA("ProximityPrompt") then

        _G.__EriusApplyInstantPrompt(object)
    end
end)

connect(resetCharacterButton.MouseButton1Click, function()
    local character, _, humanoid = getCharacter()

    if character and humanoid then
        humanoid.Health = 0
    end
end)

--------------------------------------------------
-- AIMBOT PAGE
--------------------------------------------------

local aimbotButton = makeButton(aimbotPage, "Aimbot: OFF", 0)

local fovLabel = Instance.new("TextLabel")
fovLabel.Size = UDim2.new(0.55, 0, 0, 45)
fovLabel.Position = UDim2.fromOffset(0, 60)
fovLabel.BackgroundColor3 = getTheme().Panel
fovLabel.TextColor3 = getTheme().Text
fovLabel.Text = T("Circle Size")
fovLabel.Font = Enum.Font.GothamBold
fovLabel.TextSize = 15
fovLabel.Parent = aimbotPage

round(fovLabel)
registerLanguageObject(fovLabel, "Circle Size")

local fovBox = Instance.new("TextBox")
fovBox.Size = UDim2.new(0.41, 0, 0, 45)
fovBox.Position = UDim2.new(0.59, 0, 0, 60)
fovBox.BackgroundColor3 = getTheme().Control
fovBox.TextColor3 = getTheme().Text
fovBox.Text = "150"
fovBox.ClearTextOnFocus = false
fovBox.Font = Enum.Font.GothamBold
fovBox.TextSize = 15
fovBox.Parent = aimbotPage

round(fovBox)

local fovModeButton = makeButton(aimbotPage, "FOV Mode: Crosshair", 120)

connect(fovModeButton.MouseButton1Click, function()
    if fovMode == "Crosshair" then
        fovMode = "Mouse"
    else
        fovMode = "Crosshair"
    end

    fovModeButton.Text = T(
        fovMode == "Crosshair"
        and "FOV Mode: Crosshair"
        or "FOV Mode: Mouse"
    )
end)

makeToggle(
    aimbotPage,
    "Ignore Friends",
    180,
    function()
        return ignoreFriends
    end,
    function(v)
        ignoreFriends = v
    end
)

makeToggle(
    aimbotPage,
    "Ignore Neutral",
    225,
    function()
        return ignoreNeutral
    end,
    function(v)
        ignoreNeutral = v
    end
)

makeToggle(
    aimbotPage,
    "Ignore Team",
    270,
    function()
        return ignoreTeam
    end,
    function(v)
        ignoreTeam = v
    end
)

makeToggle(
    aimbotPage,
    "Ignore NPC",
    315,
    function()
        return ignoreNPC
    end,
    function(v)
        ignoreNPC = v
    end
)

makeToggle(
    aimbotPage,
    "Show FOV",
    360,
    function()
        return showFOV
    end,
    function(v)
        showFOV = v
    end
)

makeToggle(
    aimbotPage,
    "Target Switching",
    360,
    function()
        return targetSwitching
    end,
    function(v)
        targetSwitching = v
    end
)

makeToggle(
    aimbotPage,
    "Trigger Aim",
    405,
    function()
        return triggerAimEnabled
    end,
    function(v)
        triggerAimEnabled = v
        triggerAimReadyAt = 0
    end
)


--------------------------------------------------
-- AIMBOT RANGE
--------------------------------------------------

_G.__EriusAimbotRange.Title = Instance.new("TextLabel")
_G.__EriusAimbotRange.Title.Size = UDim2.new(1, 0, 0, 26)
_G.__EriusAimbotRange.Title.Position = UDim2.fromOffset(0, 452)
_G.__EriusAimbotRange.Title.BackgroundTransparency = 1
_G.__EriusAimbotRange.Title.Text = T("Aimbot Range")
_G.__EriusAimbotRange.Title.TextColor3 = getTheme().Text
_G.__EriusAimbotRange.Title.Font = Enum.Font.GothamBold
_G.__EriusAimbotRange.Title.TextSize = 13
_G.__EriusAimbotRange.Title.TextXAlignment = Enum.TextXAlignment.Left
_G.__EriusAimbotRange.Title.Parent = aimbotPage

registerLanguageObject(
    _G.__EriusAimbotRange.Title,
    "Aimbot Range"
)

_G.__EriusAimbotRange.Background = Instance.new("Frame")
_G.__EriusAimbotRange.Background.Size = UDim2.new(1, -100, 0, 10)
_G.__EriusAimbotRange.Background.Position = UDim2.fromOffset(0, 490)
_G.__EriusAimbotRange.Background.BackgroundColor3 = Color3.fromRGB(65, 65, 75)
_G.__EriusAimbotRange.Background.Parent = aimbotPage

round(_G.__EriusAimbotRange.Background, 5)

_G.__EriusAimbotRange.Fill = Instance.new("Frame")
_G.__EriusAimbotRange.Fill.BackgroundColor3 = getAccent()
_G.__EriusAimbotRange.Fill.Parent = _G.__EriusAimbotRange.Background

round(_G.__EriusAimbotRange.Fill, 5)

_G.__EriusAimbotRange.Knob = Instance.new("Frame")
_G.__EriusAimbotRange.Knob.AnchorPoint = Vector2.new(0.5, 0.5)
_G.__EriusAimbotRange.Knob.Size = UDim2.fromOffset(20, 20)
_G.__EriusAimbotRange.Knob.BackgroundColor3 = Color3.new(1, 1, 1)
_G.__EriusAimbotRange.Knob.Parent = _G.__EriusAimbotRange.Background

round(_G.__EriusAimbotRange.Knob, 10)

_G.__EriusAimbotRange.Box = Instance.new("TextBox")
_G.__EriusAimbotRange.Box.Size = UDim2.fromOffset(85, 35)
_G.__EriusAimbotRange.Box.Position = UDim2.new(1, -85, 0, 477)
_G.__EriusAimbotRange.Box.BackgroundColor3 = getTheme().Control
_G.__EriusAimbotRange.Box.TextColor3 = getTheme().Text
_G.__EriusAimbotRange.Box.Text = tostring(_G.__EriusAimbotRange.Value)
_G.__EriusAimbotRange.Box.ClearTextOnFocus = false
_G.__EriusAimbotRange.Box.Font = Enum.Font.GothamBold
_G.__EriusAimbotRange.Box.TextSize = 14
_G.__EriusAimbotRange.Box.Parent = aimbotPage

round(_G.__EriusAimbotRange.Box, 8)

_G.__EriusAimbotRange.Refresh = function()
    local percent =
        (_G.__EriusAimbotRange.Value - _G.__EriusAimbotRange.Min)
        /
        (_G.__EriusAimbotRange.Max - _G.__EriusAimbotRange.Min)

    percent = math.clamp(percent, 0, 1)

    _G.__EriusAimbotRange.Fill.Size =
        UDim2.fromScale(percent, 1)

    _G.__EriusAimbotRange.Knob.Position =
        UDim2.new(percent, 0, 0.5, 0)

    _G.__EriusAimbotRange.Box.Text =
        tostring(math.floor(_G.__EriusAimbotRange.Value))
end

_G.__EriusAimbotRange.SetFromX = function(x)
    local startX =
        _G.__EriusAimbotRange.Background.AbsolutePosition.X

    local width =
        _G.__EriusAimbotRange.Background.AbsoluteSize.X

    if width <= 0 then
        return
    end

    local percent =
        math.clamp(
            (x - startX) / width,
            0,
            1
        )

    _G.__EriusAimbotRange.Value =
        math.floor(
            _G.__EriusAimbotRange.Min
            +
            percent
            *
            (_G.__EriusAimbotRange.Max - _G.__EriusAimbotRange.Min)
        )

    _G.__EriusAimbotRange.Refresh()
end

connect(
    _G.__EriusAimbotRange.Background.InputBegan,
    function(input)
        if input.UserInputType
            == Enum.UserInputType.MouseButton1
            or input.UserInputType
            == Enum.UserInputType.Touch then

            _G.__EriusAimbotRange.Sliding = true
            _G.__EriusAimbotRange.SetFromX(input.Position.X)
        end
    end
)

connect(
    _G.__EriusAimbotRange.Knob.InputBegan,
    function(input)
        if input.UserInputType
            == Enum.UserInputType.MouseButton1
            or input.UserInputType
            == Enum.UserInputType.Touch then

            _G.__EriusAimbotRange.Sliding = true
        end
    end
)

connect(
    _G.__EriusAimbotRange.Box.FocusLost,
    function()
        local value =
            tonumber(_G.__EriusAimbotRange.Box.Text)

        if value then
            _G.__EriusAimbotRange.Value =
                math.clamp(
                    value,
                    _G.__EriusAimbotRange.Min,
                    _G.__EriusAimbotRange.Max
                )
        end

        _G.__EriusAimbotRange.Refresh()
    end
)

_G.__EriusAimbotRange.Refresh()

--------------------------------------------------
-- FOV
--------------------------------------------------

local fovCircle = Instance.new("Frame")
fovCircle.AnchorPoint = Vector2.new(0.5, 0.5)
fovCircle.BackgroundTransparency = 1
fovCircle.Size = UDim2.fromOffset(fovSize * 2, fovSize * 2)
fovCircle.Visible = false
fovCircle.Parent = gui

round(fovCircle, 999)

local fovStroke = Instance.new("UIStroke")
fovStroke.Thickness = 2
fovStroke.Transparency = 0.15
fovStroke.Color = getTheme().Text
fovStroke.Parent = fovCircle

connect(fovBox.FocusLost, function()
    local value = tonumber(fovBox.Text)

    if value then
        fovSize = math.clamp(value, 25, 600)
    end

    fovBox.Text = tostring(fovSize)
    fovCircle.Size = UDim2.fromOffset(fovSize * 2, fovSize * 2)
end)

connect(aimbotButton.MouseButton1Click, function()
    aimbotEnabled = not aimbotEnabled

    setButtonState(
        aimbotButton,
        aimbotEnabled,
        "Aimbot: ON",
        "Aimbot: OFF"
    )

    setButtonState(
        _G.__EriusInfiniteJumpButton,
        _G.__EriusInfiniteJump,
        "Infinity Jump: ON",
        "Infinity Jump: OFF"
    )



    if not aimbotEnabled then
        currentTarget = nil
        _G.__EriusAimLastLook = nil

        local _, _, humanoid =
            getCharacter()

        if humanoid and _G.__EriusAimWasAutoRotate ~= nil then
            humanoid.AutoRotate =
                _G.__EriusAimWasAutoRotate
        end

        _G.__EriusAimWasAutoRotate = nil
    end
end)

local function getFOVCenter()
    if fovMode == "Crosshair" then
        local size = camera.ViewportSize
        return Vector2.new(size.X / 2, size.Y / 2)
    else
        local mouse = UIS:GetMouseLocation()
        local inset = GuiService:GetGuiInset()

        return Vector2.new(mouse.X, mouse.Y - inset.Y)
    end
end

local function validTarget(targetPlayer)
    if not targetPlayer
        or targetPlayer == player
        or not targetPlayer.Parent
        or not targetPlayer.Character then
        return false
    end

    local humanoid = targetPlayer.Character:FindFirstChildOfClass("Humanoid")
    local head = targetPlayer.Character:FindFirstChild("Head")
    local targetRoot = targetPlayer.Character:FindFirstChild("HumanoidRootPart")
    local _, myRoot = getCharacter()

    if not humanoid or humanoid.Health <= 0 or not head then
        return false
    end

    if myRoot
        and targetRoot
        and _G.__EriusAimbotRange then

        local distance =
            (myRoot.Position - targetRoot.Position).Magnitude

        if distance > _G.__EriusAimbotRange.Value then
            return false
        end
    end

    if ignoreNeutral and targetPlayer.Neutral then
        return false
    end

    if ignoreTeam
        and player.Team ~= nil
        and targetPlayer.Team ~= nil
        and targetPlayer.Team == player.Team then
        return false
    end

    if ignoreFriends then
        local ok, isFriend = pcall(function()
            return player:IsFriendsWith(targetPlayer.UserId)
        end)

        if ok and isFriend then
            return false
        end
    end

    return true
end

local function findClosestTarget()
    local center = getFOVCenter()
    local closest = nil
    local closestDistance = fovSize

    for _, targetPlayer in ipairs(Players:GetPlayers()) do
        if validTarget(targetPlayer) then
            local head = targetPlayer.Character:FindFirstChild("Head")

            if head then
                local screenPos, onScreen =
                    camera:WorldToViewportPoint(head.Position)

                if onScreen then
                    local distance =
                        (Vector2.new(screenPos.X, screenPos.Y) - center).Magnitude

                    if distance < closestDistance then
                        closestDistance = distance
                        closest = targetPlayer
                    end
                end
            end
        end
    end

    return closest
end

connect(UIS.InputBegan, function(input, gpe)
    if waitingForClickerKey and clickerOpen then
        if input.KeyCode ~= Enum.KeyCode.Unknown then
            clickerKey = input.KeyCode
            waitingForClickerKey = false
            refreshClickerVisual()
        end

        return
    end

    if clickerOpen
        and clickerKey
        and not gpe
        and not UIS:GetFocusedTextBox()
        and input.KeyCode == clickerKey then

        if _G.__EriusClickerMode == "Hold" then
            _G.__EriusClickerKeyHeld = true
            clickerEnabled = true
        else
            clickerEnabled = not clickerEnabled
        end

        clickerAccumulator = 0
        refreshClickerVisual()
    end

    if gpe then
        return
    end

    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        rightMouseHeld = true

        if aimbotEnabled then
            currentTarget = findClosestTarget()
        end
    end
end)

--------------------------------------------------
-- ESP PAGE
--------------------------------------------------

local function espToggle(text, y, key)
    makeToggle(
        espPage,
        text,
        y,
        function()
            return espSettings[key]
        end,
        function(v)
            espSettings[key] = v
        end
    )
end

espToggle("Player ESP", 0, "PlayerESP")
espToggle("Nicknames", 45, "Nicknames")
espToggle("HP", 90, "HP")
espToggle("Team ESP", 135, "TeamESP")
espToggle("Friend ESP", 180, "FriendESP")
espToggle("NPC ESP", 225, "NPCESP")
espToggle("Box", 270, "Box")

--------------------------------------------------
-- ESP RANGE
--------------------------------------------------

local rangeTitle = Instance.new("TextLabel")
rangeTitle.Size = UDim2.new(1, 0, 0, 30)
rangeTitle.Position = UDim2.fromOffset(0, 320)
rangeTitle.BackgroundTransparency = 1
rangeTitle.Text = T("ESP Range")
rangeTitle.TextColor3 = getTheme().Text
rangeTitle.Font = Enum.Font.GothamBold
rangeTitle.TextSize = 14
rangeTitle.TextXAlignment = Enum.TextXAlignment.Left
rangeTitle.Parent = espPage

registerLanguageObject(rangeTitle, "ESP Range")

local sliderBackground = Instance.new("Frame")
sliderBackground.Size = UDim2.new(1, -100, 0, 10)
sliderBackground.Position = UDim2.fromOffset(0, 365)
sliderBackground.BackgroundColor3 = Color3.fromRGB(65, 65, 75)
sliderBackground.Parent = espPage

round(sliderBackground, 5)

local sliderFill = Instance.new("Frame")
sliderFill.BackgroundColor3 = getAccent()
sliderFill.Parent = sliderBackground

round(sliderFill, 5)

local sliderKnob = Instance.new("Frame")
sliderKnob.AnchorPoint = Vector2.new(0.5, 0.5)
sliderKnob.Size = UDim2.fromOffset(20, 20)
sliderKnob.BackgroundColor3 = Color3.new(1, 1, 1)
sliderKnob.Parent = sliderBackground

round(sliderKnob, 10)

local rangeBox = Instance.new("TextBox")
rangeBox.Size = UDim2.fromOffset(85, 35)
rangeBox.Position = UDim2.new(1, -85, 0, 352)
rangeBox.BackgroundColor3 = getTheme().Control
rangeBox.TextColor3 = getTheme().Text
rangeBox.Text = tostring(espRange)
rangeBox.ClearTextOnFocus = false
rangeBox.Font = Enum.Font.GothamBold
rangeBox.TextSize = 14
rangeBox.Parent = espPage

round(rangeBox, 8)

local function updateRangeVisual()
    local percent = (espRange - minESPRange) / (maxESPRange - minESPRange)
    percent = math.clamp(percent, 0, 1)

    sliderFill.Size = UDim2.fromScale(percent, 1)
    sliderKnob.Position = UDim2.new(percent, 0, 0.5, 0)
    rangeBox.Text = tostring(math.floor(espRange))
end

local slidingRange = false

local function setRangeFromMouse(x)
    local startX = sliderBackground.AbsolutePosition.X
    local width = sliderBackground.AbsoluteSize.X

    if width <= 0 then
        return
    end

    local percent = math.clamp((x - startX) / width, 0, 1)

    espRange = math.floor(
        minESPRange + percent * (maxESPRange - minESPRange)
    )

    updateRangeVisual()
end

connect(sliderBackground.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        slidingRange = true
        setRangeFromMouse(input.Position.X)
    end
end)

connect(sliderKnob.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        slidingRange = true
    end
end)

connect(rangeBox.FocusLost, function()
    local value = tonumber(rangeBox.Text)

    if value then
        espRange = math.clamp(value, minESPRange, maxESPRange)
    end

    updateRangeVisual()
end)

updateRangeVisual()

--------------------------------------------------
-- ESP FUNCTIONS
--------------------------------------------------

local function clearESP(model)
    local data = espObjects[model]

    if data then
        for _, object in pairs(data) do
            pcall(function()
                object:Destroy()
            end)
        end

        espObjects[model] = nil
    end
end

local function clearAllESP()
    local models = {}

    for model in pairs(espObjects) do
        table.insert(models, model)
    end

    for _, model in ipairs(models) do
        clearESP(model)
    end
end

local function createESP(model)
    if espObjects[model] then
        return
    end

    local head = model:FindFirstChild("Head")
    local humanoid = model:FindFirstChildOfClass("Humanoid")

    if not head or not humanoid then
        return
    end

    local highlight = Instance.new("Highlight")
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.FillTransparency = 0.85
    highlight.OutlineTransparency = 0
    highlight.Adornee = model
    highlight.Parent = gui

    local billboard = Instance.new("BillboardGui")
    billboard.Adornee = head
    billboard.Size = UDim2.fromOffset(180, 45)
    billboard.StudsOffset = Vector3.new(0, 2.5, 0)
    billboard.AlwaysOnTop = true
    billboard.Parent = gui

    local text = Instance.new("TextLabel")
    text.Size = UDim2.fromScale(1, 1)
    text.BackgroundTransparency = 1
    text.TextColor3 = Color3.new(1, 1, 1)
    text.TextStrokeTransparency = 0
    text.Font = Enum.Font.GothamBold
    text.TextSize = 13
    text.Parent = billboard

    espObjects[model] = {
        Highlight = highlight,
        Billboard = billboard,
        Text = text
    }
end

local function inESPRange(model)
    local _, myRoot = getCharacter()

    if not myRoot then
        return false
    end

    local targetRoot = model:FindFirstChild("HumanoidRootPart")

    if not targetRoot then
        return false
    end

    return (myRoot.Position - targetRoot.Position).Magnitude <= espRange
end

--------------------------------------------------
-- TELEPORT
--------------------------------------------------

local searchBox = Instance.new("TextBox")
searchBox.Size = UDim2.new(1, 0, 0, 42)
searchBox.Position = UDim2.fromOffset(0, 0)
searchBox.BackgroundColor3 = getTheme().Panel
searchBox.TextColor3 = getTheme().Text
searchBox.PlaceholderColor3 = getTheme().Muted
searchBox.Text = ""
searchBox.PlaceholderText = T("Search username or display name...")
searchBox.ClearTextOnFocus = false
searchBox.Font = Enum.Font.GothamSemibold
searchBox.TextSize = 14
searchBox.Parent = teleportPage

round(searchBox, 8)

local selectedLabel = Instance.new("TextLabel")
selectedLabel.Size = UDim2.new(1, 0, 0, 42)
selectedLabel.Position = UDim2.fromOffset(0, 52)
selectedLabel.BackgroundColor3 = getTheme().Panel
selectedLabel.TextColor3 = getTheme().Text
selectedLabel.Text = T("Selected: Nobody")
selectedLabel.Font = Enum.Font.GothamBold
selectedLabel.TextSize = 15
selectedLabel.Parent = teleportPage

round(selectedLabel, 8)

local refreshPlayers = makeButton(
    teleportPage,
    "Refresh Player List",
    104
)

local playerList = Instance.new("ScrollingFrame")
playerList.Size = UDim2.new(1, 0, 0, 100)
playerList.Position = UDim2.fromOffset(0, 160)
playerList.BackgroundColor3 = getTheme().DarkPanel
playerList.BorderSizePixel = 0
playerList.ScrollBarThickness = 5
playerList.CanvasSize = UDim2.fromOffset(0, 0)
playerList.Parent = teleportPage

round(playerList)

local listLayout = Instance.new("UIListLayout")
listLayout.Padding = UDim.new(0, 5)
listLayout.Parent = playerList

local teleportButton = makeButton(
    teleportPage,
    "Teleport to Player",
    275
)

_G.__EriusFollow.FollowButton = makeButton(
    teleportPage,
    "Follow Player: OFF",
    330
)

_G.__EriusFollow.ModeButton = makeButton(
    teleportPage,
    "Mode: Float Behind",
    385
)

local function refreshSelectedLabel()
    if selectedTeleportPlayer then
        selectedLabel.Text =
            T("Selected")
            .. ": "
            .. selectedTeleportPlayer.DisplayName
    else
        selectedLabel.Text = T("Selected: Nobody")
    end
end

local function updatePlayerList()
    for _, child in ipairs(playerList:GetChildren()) do
        if child:IsA("TextButton") then
            child:Destroy()
        end
    end

    local search = string.lower(teleportSearch or "")

    for _, targetPlayer in ipairs(Players:GetPlayers()) do
        if targetPlayer ~= player then
            local username = string.lower(targetPlayer.Name)
            local displayName = string.lower(targetPlayer.DisplayName)

            local matches =
                search == ""
                or string.find(username, search, 1, true)
                or string.find(displayName, search, 1, true)

            if matches then
                local button = Instance.new("TextButton")
                button.Size = UDim2.new(1, -10, 0, 35)
                button.BackgroundColor3 = getTheme().Control
                button.TextColor3 = getTheme().Text
                button.Text =
                    targetPlayer.DisplayName .. " (@" .. targetPlayer.Name .. ")"
                button.Font = Enum.Font.GothamSemibold
                button.TextSize = 13
                button.Parent = playerList

                round(button, 7)

                connect(button.MouseButton1Click, function()
                    selectedTeleportPlayer = targetPlayer
                    refreshSelectedLabel()
                end)
            end
        end
    end

    task.wait()

    playerList.CanvasSize = UDim2.fromOffset(
        0,
        listLayout.AbsoluteContentSize.Y + 10
    )
end

connect(searchBox:GetPropertyChangedSignal("Text"), function()
    teleportSearch = searchBox.Text
    updatePlayerList()
end)

connect(refreshPlayers.MouseButton1Click, updatePlayerList)

connect(teleportButton.MouseButton1Click, function()
    if not selectedTeleportPlayer then
        return
    end

    local _, root = getCharacter()
    local targetCharacter = selectedTeleportPlayer.Character

    if root and targetCharacter then
        local targetRoot = targetCharacter:FindFirstChild("HumanoidRootPart")

        if targetRoot then
            root.CFrame = targetRoot.CFrame * CFrame.new(3, 0, 0)
        end
    end
end)


--------------------------------------------------
-- FOLLOW PLAYER (XENO-SAFE / NO EXTRA TOP-LEVEL LOCALS)
--------------------------------------------------

_G.__EriusFollow.Refresh = function()
    if not _G.__EriusFollow
        or not _G.__EriusFollow.FollowButton
        or not _G.__EriusFollow.ModeButton then
        return
    end

    _G.__EriusFollow.FollowButton.Text =
        T(
            _G.__EriusFollow.Enabled
            and "Follow Player: ON"
            or "Follow Player: OFF"
        )

    _G.__EriusFollow.FollowButton.BackgroundColor3 =
        _G.__EriusFollow.Enabled
        and getAccent()
        or getTheme().Control

    _G.__EriusFollow.ModeButton.Text =
        T("Mode")
        .. ": "
        .. T(tostring(_G.__EriusFollow.Mode))
end

_G.__EriusFollow.Stop = function(clearPlayer)
    _G.__EriusFollow.Enabled = false

    local _, root, humanoid = getCharacter()

    if root then
        root.AssemblyLinearVelocity = Vector3.zero
    end

    if humanoid then
        humanoid.Sit = false
        humanoid.AutoRotate = true
    end

    if clearPlayer then
        selectedTeleportPlayer = nil
        refreshSelectedLabel()
    end

    _G.__EriusFollow.Refresh()
end

connect(_G.__EriusFollow.FollowButton.MouseButton1Click, function()
    if _G.__EriusFollow.Enabled then
        _G.__EriusFollow.Stop(false)
        return
    end

    if not selectedTeleportPlayer
        or selectedTeleportPlayer == player
        or not selectedTeleportPlayer.Parent
        or not selectedTeleportPlayer.Character then
        return
    end

    local targetRoot =
        selectedTeleportPlayer.Character:FindFirstChild("HumanoidRootPart")

    local targetHumanoid =
        selectedTeleportPlayer.Character:FindFirstChildOfClass("Humanoid")

    if not targetRoot
        or not targetHumanoid
        or targetHumanoid.Health <= 0 then
        return
    end

    _G.__EriusFollow.Enabled = true
    _G.__EriusFollow.Refresh()
end)

connect(_G.__EriusFollow.ModeButton.MouseButton1Click, function()
    _G.__EriusFollow.ModeIndex = _G.__EriusFollow.ModeIndex + 1

    if _G.__EriusFollow.ModeIndex > #_G.__EriusFollow.Modes then
        _G.__EriusFollow.ModeIndex = 1
    end

    _G.__EriusFollow.Mode =
        _G.__EriusFollow.Modes[_G.__EriusFollow.ModeIndex]

    _G.__EriusFollow.Refresh()
end)

connect(RunService.Heartbeat, function()
    if not running
        or not _G.__EriusFollow
        or not _G.__EriusFollow.Enabled then
        return
    end

    if not selectedTeleportPlayer
        or selectedTeleportPlayer == player
        or not selectedTeleportPlayer.Parent then

        _G.__EriusFollow.Stop(true)
        return
    end

    local _, root, humanoid = getCharacter()
    local targetCharacter = selectedTeleportPlayer.Character

    if not root or not humanoid or not targetCharacter then
        return
    end

    local targetRoot =
        targetCharacter:FindFirstChild("HumanoidRootPart")

    local targetHumanoid =
        targetCharacter:FindFirstChildOfClass("Humanoid")

    if not targetRoot
        or not targetHumanoid
        or targetHumanoid.Health <= 0 then

        _G.__EriusFollow.Stop(false)
        return
    end

    root.AssemblyLinearVelocity = Vector3.zero

    if _G.__EriusFollow.Mode == "Float Behind" then
        humanoid.Sit = false
        humanoid.AutoRotate = false
        root.CFrame = targetRoot.CFrame * CFrame.new(0, 0.35, 4.5)

    elseif _G.__EriusFollow.Mode == "Shoulder" then
        humanoid.Sit = true
        humanoid.AutoRotate = false
        root.CFrame = targetRoot.CFrame * CFrame.new(1.6, 2.8, 0)

    elseif _G.__EriusFollow.Mode == "Head Sit" then
        humanoid.Sit = true
        humanoid.AutoRotate = false
        root.CFrame = targetRoot.CFrame * CFrame.new(0, 4.2, 0)

    elseif _G.__EriusFollow.Mode == "Doggy" then
        humanoid.Sit = false
        humanoid.AutoRotate = false
        root.CFrame =
            targetRoot.CFrame
            * CFrame.new(0, -1.4, 3.2)
            * CFrame.Angles(math.rad(72), 0, 0)
    end
end)

connect(Players.PlayerRemoving, function(leavingPlayer)
    if selectedTeleportPlayer == leavingPlayer
        and _G.__EriusFollow then

        _G.__EriusFollow.Stop(true)
    end
end)

_G.__EriusFollow.Refresh()

--------------------------------------------------
-- ERIKUS CLICKER
--------------------------------------------------

local clickerFrame = Instance.new("Frame")
clickerFrame.Name = "EriusClicker"
clickerFrame.Size = UDim2.fromOffset(320, 375)
clickerFrame.Position = UDim2.new(0.5, 230, 0.5, -160)
clickerFrame.BackgroundColor3 = getTheme().Main
clickerFrame.BorderSizePixel = 0
clickerFrame.Active = true
clickerFrame.Visible = false
clickerFrame.ZIndex = 20
clickerFrame.Parent = gui
round(clickerFrame, 14)

_G.__EriusWindowLayer = 20

_G.__EriusBringWindowToFront = function(target)
    _G.__EriusWindowLayer =
        (_G.__EriusWindowLayer or 20)
        + 1

    if target == "Hub" then
        main.ZIndex = _G.__EriusWindowLayer
    elseif target == "Clicker" then
        clickerFrame.ZIndex = _G.__EriusWindowLayer
    elseif target == "Steel" and _G.__EriusSteelFrame then
        _G.__EriusSteelFrame.ZIndex = _G.__EriusWindowLayer
    end
end

_G.__EriusPlaceClickerBesideHub = function()
    local cameraNow = workspace.CurrentCamera

    if not cameraNow then
        return
    end

    local viewport = cameraNow.ViewportSize
    local gap = 14

    local hubX = main.AbsolutePosition.X
    local hubY = main.AbsolutePosition.Y
    local hubW = main.AbsoluteSize.X

    local clickerW =
        clickerMinimized
        and 150
        or 320

    local clickerH =
        clickerMinimized
        and 75
        or 375

    local rightX = hubX + hubW + gap
    local leftX = hubX - clickerW - gap

    local targetX

    if rightX + clickerW <= viewport.X - 8 then
        targetX = rightX
    elseif leftX >= 8 then
        targetX = leftX
    else
        if (viewport.X - (hubX + hubW)) >= hubX then
            targetX =
                math.clamp(
                    rightX,
                    8,
                    math.max(8, viewport.X - clickerW - 8)
                )
        else
            targetX =
                math.clamp(
                    leftX,
                    8,
                    math.max(8, viewport.X - clickerW - 8)
                )
        end
    end

    local targetY =
        math.clamp(
            hubY,
            8,
            math.max(8, viewport.Y - clickerH - 8)
        )

    clickerFrame.Position =
        UDim2.fromOffset(
            targetX,
            targetY
        )
end

connect(clickerFrame.InputBegan, function(input)
    if input.UserInputType
        == Enum.UserInputType.MouseButton1
        or input.UserInputType
        == Enum.UserInputType.Touch then

        _G.__EriusBringWindowToFront("Clicker")
    end
end)

_G.__EriusClickerBackground = Instance.new("ImageLabel")
_G.__EriusClickerBackground.Name = "EriusClickerBackground"
_G.__EriusClickerBackground.Size = UDim2.fromScale(1, 1)
_G.__EriusClickerBackground.Position = UDim2.fromScale(0, 0)
_G.__EriusClickerBackground.BackgroundTransparency = 1
_G.__EriusClickerBackground.Image = "rbxassetid://98830209894912"
_G.__EriusClickerBackground.ImageTransparency = 0
_G.__EriusClickerBackground.ScaleType = Enum.ScaleType.Crop
_G.__EriusClickerBackground.ZIndex = 0
_G.__EriusClickerBackground.Visible = currentTheme == "Erius"
_G.__EriusClickerBackground.Parent = clickerFrame
round(_G.__EriusClickerBackground, 14)

_G.__EriusClickerShade = Instance.new("Frame")
_G.__EriusClickerShade.Name = "EriusClickerShade"
_G.__EriusClickerShade.Size = UDim2.fromScale(1, 1)
_G.__EriusClickerShade.Position = UDim2.fromScale(0, 0)
_G.__EriusClickerShade.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
_G.__EriusClickerShade.BackgroundTransparency = 0.72
_G.__EriusClickerShade.BorderSizePixel = 0
_G.__EriusClickerShade.ZIndex = 0
_G.__EriusClickerShade.Visible = currentTheme == "Erius"
_G.__EriusClickerShade.Parent = clickerFrame
round(_G.__EriusClickerShade, 14)

local clickerTitle = Instance.new("TextLabel")
clickerTitle.Size = UDim2.new(1, -55, 0, 45)
clickerTitle.Position = UDim2.fromOffset(15, 0)
clickerTitle.BackgroundTransparency = 1
clickerTitle.Text = "Erius Clicker"
clickerTitle.TextColor3 = getTheme().Text
clickerTitle.Font = Enum.Font.GothamBold
clickerTitle.TextSize = 19
clickerTitle.TextXAlignment = Enum.TextXAlignment.Left
clickerTitle.TextYAlignment = Enum.TextYAlignment.Center
clickerTitle.Active = true
clickerTitle.Parent = clickerFrame

local clickerMinimize = Instance.new("TextButton")
clickerMinimize.Size = UDim2.fromOffset(38, 32)
clickerMinimize.Position = UDim2.new(1, -45, 0, 7)
clickerMinimize.BackgroundColor3 = getTheme().Panel
clickerMinimize.TextColor3 = getTheme().Text
clickerMinimize.Text = "—"
clickerMinimize.TextSize = 20
clickerMinimize.ZIndex = 8
clickerMinimize.Parent = clickerFrame
round(clickerMinimize, 8)

local clickerToggleButton = Instance.new("TextButton")
clickerToggleButton.Size = UDim2.new(1, -30, 0, 45)
clickerToggleButton.Position = UDim2.fromOffset(15, 55)
clickerToggleButton.BackgroundColor3 = getTheme().Control
clickerToggleButton.TextColor3 = getTheme().Text
clickerToggleButton.Text = T("Autoclicker: OFF")
clickerToggleButton.Font = Enum.Font.GothamBold
clickerToggleButton.TextSize = 15
clickerToggleButton.Parent = clickerFrame
round(clickerToggleButton, 8)

local clickerCPSLabel = Instance.new("TextLabel")
clickerCPSLabel.Size = UDim2.new(0.55, -5, 0, 45)
clickerCPSLabel.Position = UDim2.fromOffset(15, 110)
clickerCPSLabel.BackgroundColor3 = getTheme().Panel
clickerCPSLabel.TextColor3 = getTheme().Text
clickerCPSLabel.Text = T("Clicks / sec")
clickerCPSLabel.Font = Enum.Font.GothamBold
clickerCPSLabel.TextSize = 14
clickerCPSLabel.Parent = clickerFrame
round(clickerCPSLabel, 8)
registerLanguageObject(clickerCPSLabel, "Clicks / sec")

local clickerCPSBox = Instance.new("TextBox")
clickerCPSBox.Size = UDim2.new(0.45, -10, 0, 45)
clickerCPSBox.Position = UDim2.new(0.55, 5, 0, 110)
clickerCPSBox.BackgroundColor3 = getTheme().Control
clickerCPSBox.TextColor3 = getTheme().Text
clickerCPSBox.Text = tostring(clickerCPS)
clickerCPSBox.ClearTextOnFocus = false
clickerCPSBox.Font = Enum.Font.GothamBold
clickerCPSBox.TextSize = 14
clickerCPSBox.Parent = clickerFrame
round(clickerCPSBox, 8)

local clickerKeyButton = Instance.new("TextButton")
clickerKeyButton.Size = UDim2.new(1, -30, 0, 45)
clickerKeyButton.Position = UDim2.fromOffset(15, 165)
clickerKeyButton.BackgroundColor3 = getTheme().Control
clickerKeyButton.TextColor3 = getTheme().Text
clickerKeyButton.Text = T("Keybind") .. ": " .. T("No key")
clickerKeyButton.Font = Enum.Font.GothamBold
clickerKeyButton.TextSize = 14
clickerKeyButton.Parent = clickerFrame
round(clickerKeyButton, 8)


_G.__EriusClickerModeButton = Instance.new("TextButton")
_G.__EriusClickerModeButton.Size = UDim2.new(1, -30, 0, 45)
_G.__EriusClickerModeButton.Position = UDim2.fromOffset(15, 220)
_G.__EriusClickerModeButton.BackgroundColor3 = getTheme().Control
_G.__EriusClickerModeButton.TextColor3 = getTheme().Text
_G.__EriusClickerModeButton.Font = Enum.Font.GothamBold
_G.__EriusClickerModeButton.TextSize = 14
_G.__EriusClickerModeButton.Parent = clickerFrame
round(_G.__EriusClickerModeButton, 8)

local clickerLeaveButton = Instance.new("TextButton")
clickerLeaveButton.Size = UDim2.new(1, -30, 0, 45)
clickerLeaveButton.Position = UDim2.fromOffset(15, 275)
clickerLeaveButton.BackgroundColor3 = Color3.fromRGB(170, 55, 55)
clickerLeaveButton.TextColor3 = getTheme().Text
clickerLeaveButton.Text = T("Leave Clicker")
clickerLeaveButton.Font = Enum.Font.GothamBold
clickerLeaveButton.TextSize = 14
clickerLeaveButton.Parent = clickerFrame
round(clickerLeaveButton, 8)
registerLanguageObject(clickerLeaveButton, "Leave Clicker")

local clickerStatus = Instance.new("TextLabel")
clickerStatus.Size = UDim2.new(1, -30, 0, 28)
clickerStatus.Position = UDim2.fromOffset(15, 330)
clickerStatus.BackgroundTransparency = 1
clickerStatus.TextColor3 = getTheme().Muted
clickerStatus.Font = Enum.Font.GothamSemibold
clickerStatus.TextSize = 13
clickerStatus.Text = "OFF"
clickerStatus.Parent = clickerFrame

local function performClickerClick()
    local didClick = false

    pcall(function()
        if type(mouse1click) == "function" then
            mouse1click()
            didClick = true
        elseif type(mouse1press) == "function"
            and type(mouse1release) == "function" then

            mouse1press()
            mouse1release()
            didClick = true
        end
    end)

    if didClick then
        return
    end

    pcall(function()
        local virtualInput = game:GetService("VirtualInputManager")
        local pos = UIS:GetMouseLocation()

        virtualInput:SendMouseButtonEvent(
            pos.X,
            pos.Y,
            0,
            true,
            game,
            0
        )

        virtualInput:SendMouseButtonEvent(
            pos.X,
            pos.Y,
            0,
            false,
            game,
            0
        )
    end)
end

refreshClickerVisual = function()
    if not clickerOpen then
        clickerEnabled = false
    end

    clickerToggleButton.Text =
        T(
            clickerEnabled
            and "Autoclicker: ON"
            or "Autoclicker: OFF"
        )

    clickerToggleButton.BackgroundColor3 =
        clickerEnabled
        and getAccent()
        or getTheme().Control

    if waitingForClickerKey then
        clickerKeyButton.Text =
            T("Press a key...")
    elseif clickerKey then
        clickerKeyButton.Text =
            T("Keybind")
            .. ": "
            .. clickerKey.Name
    else
        clickerKeyButton.Text =
            T("Keybind")
            .. ": "
            .. T("No key")
    end

    if _G.__EriusClickerModeButton then
        _G.__EriusClickerModeButton.Text =
            T("Click Mode")
            .. ": "
            .. T(_G.__EriusClickerMode)
    end

    clickerStatus.Text =
        clickerEnabled
        and "ON"
        or "OFF"

    clickerStatus.TextColor3 =
        clickerEnabled
        and getAccent()
        or getTheme().Muted

    if clickerMinimized then
        clickerTitle.Text =
            clickerEnabled
            and "Erius Clicker [ON]"
            or "Erius Clicker"
    else
        clickerTitle.Text =
            "Erius Clicker"
    end

    if currentTheme == "Erius" then
        clickerFrame.BackgroundTransparency = 1

        if _G.__EriusClickerBackground then
            _G.__EriusClickerBackground.Visible = true
        end

        if _G.__EriusClickerShade then
            _G.__EriusClickerShade.Visible = true
        end

    elseif currentTheme == "Rainbow" then
        clickerFrame.BackgroundTransparency = 0
        clickerFrame.BackgroundColor3 =
            getAccent():Lerp(
                Color3.fromRGB(8, 8, 12),
                0.58
            )

        if _G.__EriusClickerBackground then
            _G.__EriusClickerBackground.Visible = false
        end

        if _G.__EriusClickerShade then
            _G.__EriusClickerShade.Visible = false
        end

    else
        clickerFrame.BackgroundTransparency = 0

        if clickerMinimized and clickerEnabled then
            clickerFrame.BackgroundColor3 =
                getAccent():Lerp(
                    Color3.fromRGB(8, 8, 12),
                    0.35
                )
        else
            clickerFrame.BackgroundColor3 =
                getTheme().Main
        end

        if _G.__EriusClickerBackground then
            _G.__EriusClickerBackground.Visible = false
        end

        if _G.__EriusClickerShade then
            _G.__EriusClickerShade.Visible = false
        end
    end
end

local function setClickerMinimized(state)
    clickerMinimized = state

    clickerToggleButton.Visible = not state
    clickerCPSLabel.Visible = not state
    clickerCPSBox.Visible = not state
    clickerKeyButton.Visible = not state

    if _G.__EriusClickerModeButton then
        _G.__EriusClickerModeButton.Visible = not state
    end

    clickerLeaveButton.Visible = not state
    clickerStatus.Visible = not state

    if state then
        clickerFrame.Size = UDim2.fromOffset(150, 75)

        clickerTitle.Size = UDim2.fromScale(1, 1)
        clickerTitle.Position = UDim2.fromOffset(0, 0)
        clickerTitle.TextSize = 15
        clickerTitle.TextXAlignment = Enum.TextXAlignment.Center
        clickerTitle.TextYAlignment = Enum.TextYAlignment.Center

        clickerMinimize.Size = UDim2.fromScale(1, 1)
        clickerMinimize.Position = UDim2.fromOffset(0, 0)
        clickerMinimize.BackgroundTransparency = 1
        clickerMinimize.Text = ""
    else
        clickerFrame.Size = UDim2.fromOffset(320, 375)

        clickerTitle.Size = UDim2.new(1, -55, 0, 45)
        clickerTitle.Position = UDim2.fromOffset(15, 0)
        clickerTitle.TextSize = 19
        clickerTitle.TextXAlignment = Enum.TextXAlignment.Left
        clickerTitle.TextYAlignment = Enum.TextYAlignment.Center

        clickerMinimize.Size = UDim2.fromOffset(38, 32)
        clickerMinimize.Position = UDim2.new(1, -45, 0, 7)
        clickerMinimize.BackgroundTransparency = 0
        clickerMinimize.BackgroundColor3 = getTheme().Panel
        clickerMinimize.Text = "—"

        if clickerOpen
            and _G.__EriusPlaceClickerBesideHub then

            _G.__EriusPlaceClickerBesideHub()
        end
    end

    refreshClickerVisual()
end

local function closeClicker()
    clickerEnabled = false
    clickerOpen = false

    _G.__EriusSteelOpen = false

    if _G.__EriusSteelFrame then
        _G.__EriusSteelFrame.Visible = false
    end

    _G.__EriusSteelOpen = false

    if _G.__EriusSteelFrame then
        _G.__EriusSteelFrame.Visible = false
    end
    waitingForClickerKey = false
    _G.__EriusClickerKeyHeld = false
    clickerKey = nil
    clickerAccumulator = 0
    clickerDragging = false
    clickerDragSource = nil
    clickerMoved = false

    if clickerMinimized then
        setClickerMinimized(false)
    end

    clickerFrame.Visible = false
    refreshClickerVisual()
end

connect(openClickerButton.MouseButton1Click, function()
    clickerOpen = true
    clickerFrame.Visible = true

    _G.__EriusPlaceClickerBesideHub()
    _G.__EriusBringWindowToFront("Clicker")

    refreshClickerVisual()
end)

connect(clickerToggleButton.MouseButton1Click, function()
    if not clickerOpen then
        return
    end

    clickerEnabled = not clickerEnabled
    clickerAccumulator = 0
    refreshClickerVisual()
end)

connect(clickerCPSBox.FocusLost, function()
    local value = tonumber(clickerCPSBox.Text)

    if value then
        clickerCPS = math.clamp(
            math.floor(value),
            1,
            1000
        )
    end

    clickerCPSBox.Text =
        tostring(clickerCPS)
end)

connect(clickerKeyButton.MouseButton1Click, function()
    if not clickerOpen then
        return
    end

    waitingForClickerKey = true
    refreshClickerVisual()
end)


connect(_G.__EriusClickerModeButton.MouseButton1Click, function()
    if not clickerOpen then
        return
    end

    if _G.__EriusClickerMode == "Toggle" then
        _G.__EriusClickerMode = "Hold"
    else
        _G.__EriusClickerMode = "Toggle"
    end

    _G.__EriusClickerKeyHeld = false
    clickerEnabled = false
    clickerAccumulator = 0
    refreshClickerVisual()
end)

connect(
    clickerLeaveButton.MouseButton1Click,
    closeClicker
)

local function startClickerDrag(input, source)
    _G.__EriusBringWindowToFront("Clicker")

    clickerDragging = true
    clickerMoved = false
    clickerDragSource = source
    clickerDragStart = input.Position
    clickerStartPosition = clickerFrame.Position
end

local function updateClickerDrag(input)
    if not clickerDragging
        or not clickerDragStart
        or not clickerStartPosition then

        return
    end

    local delta =
        input.Position
        -
        clickerDragStart

    if math.abs(delta.X) > 5
        or math.abs(delta.Y) > 5 then

        clickerMoved = true
    end

    clickerFrame.Position =
        UDim2.new(
            clickerStartPosition.X.Scale,
            clickerStartPosition.X.Offset + delta.X,
            clickerStartPosition.Y.Scale,
            clickerStartPosition.Y.Offset + delta.Y
        )
end

connect(clickerTitle.InputBegan, function(input)
    if clickerMinimized then
        return
    end

    if input.UserInputType
        == Enum.UserInputType.MouseButton1
        or input.UserInputType
        == Enum.UserInputType.Touch then

        startClickerDrag(input, "title")
    end
end)

connect(clickerMinimize.InputBegan, function(input)
    if input.UserInputType
        == Enum.UserInputType.MouseButton1
        or input.UserInputType
        == Enum.UserInputType.Touch then

        startClickerDrag(input, "minimize")
    end
end)

refreshClickerVisual()

--------------------------------------------------
-- CREATOR HUB WINDOW
--------------------------------------------------

_G.__EriusSteelOpen = false
_G.__EriusSteelMinimized = false
_G.__EriusSteelDragging = false
_G.__EriusSteelDragStart = nil
_G.__EriusSteelStartPosition = nil
_G.__EriusSteelMoved = false
_G.__EriusSteelDragSource = nil
_G.__EriusCreatorUnlocked = false

_G.__EriusSteelFrame = Instance.new("Frame")
_G.__EriusSteelFrame.Name = "CreatorHub"
_G.__EriusSteelFrame.Size = UDim2.fromOffset(320, 250)
_G.__EriusSteelFrame.Position = UDim2.new(0.5, 230, 0.5, 20)
_G.__EriusSteelFrame.BackgroundColor3 = getTheme().Main
_G.__EriusSteelFrame.BorderSizePixel = 0
_G.__EriusSteelFrame.Active = true
_G.__EriusSteelFrame.Visible = false
_G.__EriusSteelFrame.ZIndex = 21
_G.__EriusSteelFrame.Parent = gui
round(_G.__EriusSteelFrame, 14)

_G.__EriusSteelBackground = Instance.new("ImageLabel")
_G.__EriusSteelBackground.Name = "CreatorHubBackground"
_G.__EriusSteelBackground.Size = UDim2.fromScale(1, 1)
_G.__EriusSteelBackground.BackgroundTransparency = 1
_G.__EriusSteelBackground.Image = "rbxassetid://98830209894912"
_G.__EriusSteelBackground.ImageTransparency = 0
_G.__EriusSteelBackground.ScaleType = Enum.ScaleType.Crop
_G.__EriusSteelBackground.ZIndex = 0
_G.__EriusSteelBackground.Visible = currentTheme == "Erius"
_G.__EriusSteelBackground.Parent = _G.__EriusSteelFrame
round(_G.__EriusSteelBackground, 14)

_G.__EriusSteelShade = Instance.new("Frame")
_G.__EriusSteelShade.Size = UDim2.fromScale(1, 1)
_G.__EriusSteelShade.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
_G.__EriusSteelShade.BackgroundTransparency = 0.72
_G.__EriusSteelShade.BorderSizePixel = 0
_G.__EriusSteelShade.ZIndex = 0
_G.__EriusSteelShade.Visible = currentTheme == "Erius"
_G.__EriusSteelShade.Parent = _G.__EriusSteelFrame
round(_G.__EriusSteelShade, 14)

_G.__EriusSteelTitle = Instance.new("TextLabel")
_G.__EriusSteelTitle.Size = UDim2.new(1, -95, 0, 45)
_G.__EriusSteelTitle.Position = UDim2.fromOffset(15, 0)
_G.__EriusSteelTitle.BackgroundTransparency = 1
_G.__EriusSteelTitle.Text = "Creator Hub"
_G.__EriusSteelTitle.TextColor3 = getTheme().Text
_G.__EriusSteelTitle.Font = Enum.Font.GothamBold
_G.__EriusSteelTitle.TextSize = 19
_G.__EriusSteelTitle.TextXAlignment = Enum.TextXAlignment.Left
_G.__EriusSteelTitle.TextYAlignment = Enum.TextYAlignment.Center
_G.__EriusSteelTitle.Active = true
_G.__EriusSteelTitle.Parent = _G.__EriusSteelFrame

_G.__EriusSteelMinimize = Instance.new("TextButton")
_G.__EriusSteelMinimize.Size = UDim2.fromOffset(34, 32)
_G.__EriusSteelMinimize.Position = UDim2.new(1, -82, 0, 7)
_G.__EriusSteelMinimize.BackgroundColor3 = getTheme().Panel
_G.__EriusSteelMinimize.TextColor3 = getTheme().Text
_G.__EriusSteelMinimize.Text = "—"
_G.__EriusSteelMinimize.TextSize = 20
_G.__EriusSteelMinimize.ZIndex = 8
_G.__EriusSteelMinimize.Parent = _G.__EriusSteelFrame
round(_G.__EriusSteelMinimize, 8)

_G.__EriusCreatorClose = Instance.new("TextButton")
_G.__EriusCreatorClose.Size = UDim2.fromOffset(34, 32)
_G.__EriusCreatorClose.Position = UDim2.new(1, -42, 0, 7)
_G.__EriusCreatorClose.BackgroundColor3 = getTheme().Panel
_G.__EriusCreatorClose.TextColor3 = getTheme().Text
_G.__EriusCreatorClose.Text = "×"
_G.__EriusCreatorClose.TextSize = 20
_G.__EriusCreatorClose.ZIndex = 8
_G.__EriusCreatorClose.Parent = _G.__EriusSteelFrame
round(_G.__EriusCreatorClose, 8)

-- Locked screen
_G.__EriusCreatorCodeBox = Instance.new("TextBox")
_G.__EriusCreatorCodeBox.Size = UDim2.new(1, -30, 0, 46)
_G.__EriusCreatorCodeBox.Position = UDim2.fromOffset(15, 62)
_G.__EriusCreatorCodeBox.BackgroundColor3 = getTheme().Control
_G.__EriusCreatorCodeBox.TextColor3 = getTheme().Text
_G.__EriusCreatorCodeBox.PlaceholderText = "Enter code"
_G.__EriusCreatorCodeBox.Text = ""
_G.__EriusCreatorCodeBox.ClearTextOnFocus = false
_G.__EriusCreatorCodeBox.Font = Enum.Font.GothamBold
_G.__EriusCreatorCodeBox.TextSize = 15
_G.__EriusCreatorCodeBox.Parent = _G.__EriusSteelFrame
round(_G.__EriusCreatorCodeBox, 8)

_G.__EriusCreatorUnlock = Instance.new("TextButton")
_G.__EriusCreatorUnlock.Size = UDim2.new(1, -30, 0, 46)
_G.__EriusCreatorUnlock.Position = UDim2.fromOffset(15, 116)
_G.__EriusCreatorUnlock.BackgroundColor3 = getTheme().Control
_G.__EriusCreatorUnlock.TextColor3 = getTheme().Text
_G.__EriusCreatorUnlock.Text = "Unlock Creator Hub"
_G.__EriusCreatorUnlock.Font = Enum.Font.GothamBold
_G.__EriusCreatorUnlock.TextSize = 14
_G.__EriusCreatorUnlock.Parent = _G.__EriusSteelFrame
round(_G.__EriusCreatorUnlock, 8)

_G.__EriusCreatorCodeStatus = Instance.new("TextLabel")
_G.__EriusCreatorCodeStatus.Size = UDim2.new(1, -30, 0, 36)
_G.__EriusCreatorCodeStatus.Position = UDim2.fromOffset(15, 170)
_G.__EriusCreatorCodeStatus.BackgroundTransparency = 1
_G.__EriusCreatorCodeStatus.Text = ""
_G.__EriusCreatorCodeStatus.TextColor3 = getTheme().Muted
_G.__EriusCreatorCodeStatus.Font = Enum.Font.GothamSemibold
_G.__EriusCreatorCodeStatus.TextSize = 12
_G.__EriusCreatorCodeStatus.Parent = _G.__EriusSteelFrame

-- Unlocked controls
_G.__EriusSteelInteractButton = Instance.new("TextButton")
_G.__EriusSteelInteractButton.Size = UDim2.new(1, -30, 0, 50)
_G.__EriusSteelInteractButton.Position = UDim2.fromOffset(15, 70)
_G.__EriusSteelInteractButton.BackgroundColor3 = getTheme().Control
_G.__EriusSteelInteractButton.TextColor3 = getTheme().Text
_G.__EriusSteelInteractButton.Text = T("Instant Interact: OFF")
_G.__EriusSteelInteractButton.Font = Enum.Font.GothamBold
_G.__EriusSteelInteractButton.TextSize = 15
_G.__EriusSteelInteractButton.Visible = false
_G.__EriusSteelInteractButton.Parent = _G.__EriusSteelFrame
round(_G.__EriusSteelInteractButton, 8)

_G.__EriusSteelStatus = Instance.new("TextLabel")
_G.__EriusSteelStatus.Size = UDim2.new(1, -30, 0, 25)
_G.__EriusSteelStatus.Position = UDim2.fromOffset(15, 126)
_G.__EriusSteelStatus.BackgroundTransparency = 1
_G.__EriusSteelStatus.Text = "OFF"
_G.__EriusSteelStatus.TextColor3 = getTheme().Muted
_G.__EriusSteelStatus.Font = Enum.Font.GothamSemibold
_G.__EriusSteelStatus.TextSize = 12
_G.__EriusSteelStatus.Visible = false
_G.__EriusSteelStatus.Parent = _G.__EriusSteelFrame

_G.__EriusCreatorCloseInside = Instance.new("TextButton")
_G.__EriusCreatorCloseInside.Size = UDim2.new(1, -30, 0, 42)
_G.__EriusCreatorCloseInside.Position = UDim2.fromOffset(15, 170)
_G.__EriusCreatorCloseInside.BackgroundColor3 = Color3.fromRGB(150, 50, 55)
_G.__EriusCreatorCloseInside.TextColor3 = getTheme().Text
_G.__EriusCreatorCloseInside.Text = "Close Creator Hub"
_G.__EriusCreatorCloseInside.Font = Enum.Font.GothamBold
_G.__EriusCreatorCloseInside.TextSize = 13
_G.__EriusCreatorCloseInside.Visible = false
_G.__EriusCreatorCloseInside.Parent = _G.__EriusSteelFrame
round(_G.__EriusCreatorCloseInside, 8)

_G.__EriusRefreshSteelVisual = function()
    if not _G.__EriusSteelFrame then
        return
    end

    if _G.__EriusSteelInteractButton then
        _G.__EriusSteelInteractButton.Text =
            T(
                _G.__EriusInstantInteract
                and "Instant Interact: ON"
                or "Instant Interact: OFF"
            )

        _G.__EriusSteelInteractButton.BackgroundColor3 =
            _G.__EriusInstantInteract
            and getAccent()
            or getTheme().Control
    end

    _G.__EriusSteelStatus.Text =
        _G.__EriusInstantInteract
        and "ON"
        or "OFF"

    _G.__EriusSteelStatus.TextColor3 =
        _G.__EriusInstantInteract
        and getAccent()
        or getTheme().Muted

    if _G.__EriusSteelMinimized then
        _G.__EriusSteelTitle.Text =
            _G.__EriusInstantInteract
            and "Creator Hub [ON]"
            or "Creator Hub"
    else
        _G.__EriusSteelTitle.Text = "Creator Hub"
    end

    if currentTheme == "Erius" then
        _G.__EriusSteelFrame.BackgroundTransparency = 1
        _G.__EriusSteelBackground.Visible = true
        _G.__EriusSteelShade.Visible = true

    elseif currentTheme == "Rainbow" then
        _G.__EriusSteelFrame.BackgroundTransparency = 0
        _G.__EriusSteelFrame.BackgroundColor3 =
            getAccent():Lerp(
                Color3.fromRGB(8, 8, 12),
                0.58
            )

        _G.__EriusSteelBackground.Visible = false
        _G.__EriusSteelShade.Visible = false
    else
        _G.__EriusSteelFrame.BackgroundTransparency = 0
        _G.__EriusSteelFrame.BackgroundColor3 = getTheme().Main
        _G.__EriusSteelBackground.Visible = false
        _G.__EriusSteelShade.Visible = false
    end
end

_G.__EriusSetCreatorLockedView = function()
    local unlocked = _G.__EriusCreatorUnlocked

    _G.__EriusCreatorCodeBox.Visible = not unlocked
    _G.__EriusCreatorUnlock.Visible = not unlocked
    _G.__EriusCreatorCodeStatus.Visible = not unlocked

    _G.__EriusSteelInteractButton.Visible =
        unlocked and not _G.__EriusSteelMinimized

    _G.__EriusSteelStatus.Visible =
        unlocked and not _G.__EriusSteelMinimized

    _G.__EriusCreatorCloseInside.Visible =
        unlocked and not _G.__EriusSteelMinimized
end

_G.__EriusSetSteelMinimized = function(state)
    _G.__EriusSteelMinimized = state

    if state then
        _G.__EriusSteelFrame.Size = UDim2.fromOffset(150, 75)

        _G.__EriusSteelTitle.Size = UDim2.fromScale(1, 1)
        _G.__EriusSteelTitle.Position = UDim2.fromOffset(0, 0)
        _G.__EriusSteelTitle.TextSize = 15
        _G.__EriusSteelTitle.TextXAlignment = Enum.TextXAlignment.Center

        _G.__EriusSteelMinimize.Size = UDim2.fromScale(1, 1)
        _G.__EriusSteelMinimize.Position = UDim2.fromOffset(0, 0)
        _G.__EriusSteelMinimize.BackgroundTransparency = 1
        _G.__EriusSteelMinimize.Text = ""

        _G.__EriusCreatorClose.Visible = false
    else
        _G.__EriusSteelFrame.Size = UDim2.fromOffset(320, 250)

        _G.__EriusSteelTitle.Size = UDim2.new(1, -95, 0, 45)
        _G.__EriusSteelTitle.Position = UDim2.fromOffset(15, 0)
        _G.__EriusSteelTitle.TextSize = 19
        _G.__EriusSteelTitle.TextXAlignment = Enum.TextXAlignment.Left

        _G.__EriusSteelMinimize.Size = UDim2.fromOffset(34, 32)
        _G.__EriusSteelMinimize.Position = UDim2.new(1, -82, 0, 7)
        _G.__EriusSteelMinimize.BackgroundTransparency = 0
        _G.__EriusSteelMinimize.Text = "—"

        _G.__EriusCreatorClose.Visible = true
    end

    _G.__EriusSetCreatorLockedView()
    _G.__EriusRefreshSteelVisual()
end

_G.__EriusPlaceSteelBesideHub = function()
    local cameraNow = workspace.CurrentCamera

    if not cameraNow then
        return
    end

    local viewport = cameraNow.ViewportSize
    local gap = 14
    local hubX = main.AbsolutePosition.X
    local hubY = main.AbsolutePosition.Y
    local hubW = main.AbsoluteSize.X

    local steelW =
        _G.__EriusSteelMinimized
        and 150
        or 320

    local steelH =
        _G.__EriusSteelMinimized
        and 75
        or 250

    local rightX = hubX + hubW + gap
    local leftX = hubX - steelW - gap
    local targetX

    if rightX + steelW <= viewport.X - 8 then
        targetX = rightX
    elseif leftX >= 8 then
        targetX = leftX
    else
        targetX =
            math.clamp(
                rightX,
                8,
                math.max(8, viewport.X - steelW - 8)
            )
    end

    local targetY =
        math.clamp(
            hubY + 160,
            8,
            math.max(8, viewport.Y - steelH - 8)
        )

    _G.__EriusSteelFrame.Position =
        UDim2.fromOffset(targetX, targetY)
end

_G.__EriusStartSteelDrag = function(input, source)
    if _G.__EriusBringWindowToFront then
        _G.__EriusBringWindowToFront("Steel")
    end

    _G.__EriusSteelDragging = true
    _G.__EriusSteelMoved = false
    _G.__EriusSteelDragSource = source
    _G.__EriusSteelDragStart = input.Position
    _G.__EriusSteelStartPosition = _G.__EriusSteelFrame.Position
end

_G.__EriusUpdateSteelDrag = function(input)
    if not _G.__EriusSteelDragging
        or not _G.__EriusSteelDragStart
        or not _G.__EriusSteelStartPosition then
        return
    end

    local delta =
        input.Position
        - _G.__EriusSteelDragStart

    if math.abs(delta.X) > 5
        or math.abs(delta.Y) > 5 then
        _G.__EriusSteelMoved = true
    end

    _G.__EriusSteelFrame.Position =
        UDim2.new(
            _G.__EriusSteelStartPosition.X.Scale,
            _G.__EriusSteelStartPosition.X.Offset + delta.X,
            _G.__EriusSteelStartPosition.Y.Scale,
            _G.__EriusSteelStartPosition.Y.Offset + delta.Y
        )
end

_G.__EriusCloseCreatorHub = function()
    _G.__EriusSteelOpen = false
    _G.__EriusSteelDragging = false
    _G.__EriusSteelFrame.Visible = false
end

connect(_G.__EriusCreatorUnlock.MouseButton1Click, function()
    if tostring(_G.__EriusCreatorCodeBox.Text) == "1172" then
        _G.__EriusCreatorUnlocked = true
        _G.__EriusCreatorCodeStatus.Text = "Code accepted"
        _G.__EriusCreatorCodeStatus.TextColor3 = getAccent()

        _G.__EriusSetCreatorLockedView()
        _G.__EriusRefreshSteelVisual()
    else
        _G.__EriusCreatorUnlocked = false
        _G.__EriusCreatorCodeStatus.Text = "Wrong code"
        _G.__EriusCreatorCodeStatus.TextColor3 =
            Color3.fromRGB(235, 80, 80)
    end
end)

connect(_G.__EriusCreatorCodeBox.FocusLost, function(enterPressed)
    if enterPressed then
        if tostring(_G.__EriusCreatorCodeBox.Text) == "1172" then
            _G.__EriusCreatorUnlocked = true
            _G.__EriusSetCreatorLockedView()
            _G.__EriusRefreshSteelVisual()
        else
            _G.__EriusCreatorCodeStatus.Text = "Wrong code"
            _G.__EriusCreatorCodeStatus.TextColor3 =
                Color3.fromRGB(235, 80, 80)
        end
    end
end)

connect(_G.__EriusSteelInteractButton.MouseButton1Click, function()
    if not _G.__EriusCreatorUnlocked then
        return
    end

    _G.__EriusInstantInteract =
        not _G.__EriusInstantInteract

    _G.__EriusRefreshInstantInteract()
    _G.__EriusRefreshSteelVisual()
end)

connect(_G.__EriusCreatorClose.MouseButton1Click, function()
    _G.__EriusCloseCreatorHub()
end)

connect(_G.__EriusCreatorCloseInside.MouseButton1Click, function()
    _G.__EriusCloseCreatorHub()
end)

connect(_G.__EriusSteelTitle.InputBegan, function(input)
    if _G.__EriusSteelMinimized then
        return
    end

    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then

        _G.__EriusStartSteelDrag(input, "title")
    end
end)

connect(_G.__EriusSteelMinimize.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then

        _G.__EriusStartSteelDrag(input, "minimize")
    end
end)

connect(_G.__EriusSteelFrame.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then

        if _G.__EriusBringWindowToFront then
            _G.__EriusBringWindowToFront("Steel")
        end
    end
end)

_G.__EriusSetCreatorLockedView()
_G.__EriusRefreshSteelVisual()

--------------------------------------------------
-- SETTINGS PAGE
--------------------------------------------------

local settingsTitle = Instance.new("TextLabel")
settingsTitle.Size = UDim2.new(1, 0, 0, 35)
settingsTitle.BackgroundTransparency = 1
settingsTitle.TextColor3 = getTheme().Text
settingsTitle.Text = T("Hub Settings")
settingsTitle.Font = Enum.Font.GothamBold
settingsTitle.TextSize = 20
settingsTitle.TextXAlignment = Enum.TextXAlignment.Left
settingsTitle.Parent = settingsPage

registerLanguageObject(settingsTitle, "Hub Settings")

--------------------------------------------------
-- LANGUAGE SETTINGS
--------------------------------------------------

local languageTitle = Instance.new("TextLabel")
languageTitle.Size = UDim2.new(0.48, 0, 0, 35)
languageTitle.Position = UDim2.fromOffset(0, 45)
languageTitle.BackgroundTransparency = 1
languageTitle.TextColor3 = getTheme().Text
languageTitle.Text = T("Language")
languageTitle.Font = Enum.Font.GothamBold
languageTitle.TextSize = 14
languageTitle.TextXAlignment = Enum.TextXAlignment.Left
languageTitle.Parent = settingsPage

registerLanguageObject(languageTitle, "Language")

_G.__EriusLangButtons = {}

local function makeLanguageButton(code, x)
    local button = Instance.new("TextButton")
    button.Size = UDim2.fromOffset(48, 35)
    button.Position = UDim2.fromOffset(x, 45)
    button.Text = code
    button.Font = Enum.Font.GothamBold
    button.TextSize = 12
    button.TextColor3 = getTheme().Text
    button.BackgroundColor3 = getTheme().Control
    button.Parent = settingsPage

    round(button, 8)

    _G.__EriusLangButtons[code] = button

    connect(button.MouseButton1Click, function()
        language = code

        if _G.__EriusRefreshLanguage then
            _G.__EriusRefreshLanguage()
        end
    end)

    return button
end

local englishButton = makeLanguageButton("EN", 102)
local germanButton = makeLanguageButton("DE", 154)
_G.__EriusLangButtons.ES = makeLanguageButton("ES", 206)
_G.__EriusLangButtons.RU = makeLanguageButton("RU", 258)
_G.__EriusLangButtons.FR = makeLanguageButton("FR", 310)
_G.__EriusLangButtons.TR = makeLanguageButton("TR", 362)

--------------------------------------------------
-- THEME SETTINGS
--------------------------------------------------

local themeTitle = Instance.new("TextLabel")
themeTitle.Size = UDim2.new(1, 0, 0, 30)
themeTitle.Position = UDim2.fromOffset(0, 92)
themeTitle.BackgroundTransparency = 1
themeTitle.Text = T("Theme")
themeTitle.TextColor3 = getTheme().Text
themeTitle.Font = Enum.Font.GothamBold
themeTitle.TextSize = 14
themeTitle.TextXAlignment = Enum.TextXAlignment.Left
themeTitle.Parent = settingsPage

registerLanguageObject(themeTitle, "Theme")

local function makeThemeButton(text, x, y, width)
    local button = Instance.new("TextButton")
    button.Size = UDim2.fromOffset(width or 92, 55)
    button.Position = UDim2.fromOffset(x, y)
    button.BackgroundColor3 = getTheme().Control
    button.TextColor3 = getTheme().Text
    button.Text = T(text)
    button.Font = Enum.Font.GothamBold
    button.TextSize = 13
    button.Parent = settingsPage

    round(button, 10)
    registerLanguageObject(button, text)

    return button
end

_G.__EriusThemeButton = makeThemeButton("Erius", 0, 125, 76)
local blackThemeButton = makeThemeButton("Black", 81, 125, 76)
local whiteThemeButton = makeThemeButton("White", 162, 125, 76)
local rainbowThemeButton = makeThemeButton("Rainbow", 243, 125, 76)
local customThemeButton = makeThemeButton("Custom", 324, 125, 76)

--------------------------------------------------
-- CUSTOM COLOR
--------------------------------------------------

local customTitle = Instance.new("TextLabel")
customTitle.Size = UDim2.new(1, 0, 0, 28)
customTitle.Position = UDim2.fromOffset(0, 190)
customTitle.BackgroundTransparency = 1
customTitle.TextColor3 = getTheme().Text
customTitle.Text = T("Custom Color")
customTitle.Font = Enum.Font.GothamBold
customTitle.TextSize = 14
customTitle.TextXAlignment = Enum.TextXAlignment.Left
customTitle.Parent = settingsPage

registerLanguageObject(customTitle, "Custom Color")

local colorSlider = Instance.new("Frame")
colorSlider.Size = UDim2.new(1, 0, 0, 18)
colorSlider.Position = UDim2.fromOffset(0, 225)
colorSlider.BackgroundColor3 = Color3.new(1, 1, 1)
colorSlider.Parent = settingsPage

round(colorSlider, 9)

local colorGradient = Instance.new("UIGradient")
colorGradient.Color = ColorSequence.new({
    ColorSequenceKeypoint.new(0, Color3.fromHSV(0, 1, 1)),
    ColorSequenceKeypoint.new(0.17, Color3.fromHSV(0.17, 1, 1)),
    ColorSequenceKeypoint.new(0.33, Color3.fromHSV(0.33, 1, 1)),
    ColorSequenceKeypoint.new(0.5, Color3.fromHSV(0.5, 1, 1)),
    ColorSequenceKeypoint.new(0.67, Color3.fromHSV(0.67, 1, 1)),
    ColorSequenceKeypoint.new(0.83, Color3.fromHSV(0.83, 1, 1)),
    ColorSequenceKeypoint.new(1, Color3.fromHSV(1, 1, 1))
})
colorGradient.Parent = colorSlider

local colorKnob = Instance.new("Frame")
colorKnob.AnchorPoint = Vector2.new(0.5, 0.5)
colorKnob.Size = UDim2.fromOffset(24, 24)
colorKnob.Position = UDim2.new(0.48, 0, 0.5, 0)
colorKnob.BackgroundColor3 = Color3.new(1, 1, 1)
colorKnob.Parent = colorSlider

round(colorKnob, 12)

local colorSliding = false

--------------------------------------------------
-- SCALE SETTINGS
--------------------------------------------------

local scaleTitle = Instance.new("TextLabel")
scaleTitle.Size = UDim2.new(1, 0, 0, 30)
scaleTitle.Position = UDim2.fromOffset(0, 260)
scaleTitle.BackgroundTransparency = 1
scaleTitle.Text = T("Interface Scale")
scaleTitle.TextColor3 = getTheme().Text
scaleTitle.Font = Enum.Font.GothamBold
scaleTitle.TextSize = 14
scaleTitle.TextXAlignment = Enum.TextXAlignment.Left
scaleTitle.Parent = settingsPage

registerLanguageObject(scaleTitle, "Interface Scale")

local scale80 = makeThemeButton("80%", 0, 295)
local scale100 = makeThemeButton("100%", 102, 295)
local scale120 = makeThemeButton("120%", 204, 295)

--------------------------------------------------
-- EXTRA SETTINGS
--------------------------------------------------

local blurRefresh = makeToggle(
    settingsPage,
    "Background Blur",
    365,
    function()
        return backgroundBlurEnabled
    end,
    function(v)
        backgroundBlurEnabled = v
    end
)

local animationRefresh = makeToggle(
    settingsPage,
    "Animations",
    410,
    function()
        return animationsEnabled
    end,
    function(v)
        animationsEnabled = v
    end
)


--------------------------------------------------
-- STEEL IN EGG
--------------------------------------------------

--------------------------------------------------
-- BACKGROUND BLUR
--------------------------------------------------

local blur = Instance.new("BlurEffect")
blur.Name = "EriusHubBlur"
blur.Size = 0
blur.Parent = Lighting

local function updateBlur()
    local target =
        backgroundBlurEnabled
        and 14
        or 0

    if animationsEnabled then
        TweenService:Create(
            blur,
            TweenInfo.new(0.2),
            {Size = target}
        ):Play()
    else
        blur.Size = target
    end
end

--------------------------------------------------
-- THEME APPLY
--------------------------------------------------

local function applyTheme()
    local theme = getTheme()

    if _G.__EriusHubBackground and _G.__EriusHubBackground.Parent then
        _G.__EriusHubBackground.Image = "rbxassetid://98830209894912"
        _G.__EriusHubBackground.ImageTransparency = 0
    end

    if _G.__EriusHubBackgroundShade
        and _G.__EriusHubBackgroundShade.Parent then

        _G.__EriusHubBackgroundShade.BackgroundColor3 =
            Color3.fromRGB(0, 0, 0)

        _G.__EriusHubBackgroundShade.BackgroundTransparency =
            currentTheme == "White"
            and 0.60
            or 0.52
    end

    main.BackgroundColor3 = theme.Main
    main.BackgroundTransparency =
        currentTheme == "Erius"
        and 1
        or 0

    if _G.__EriusHubBackground and _G.__EriusHubBackground.Parent then
        _G.__EriusHubBackground.Visible =
            currentTheme == "Erius"
    end

    if _G.__EriusHubBackgroundShade
        and _G.__EriusHubBackgroundShade.Parent then

        _G.__EriusHubBackgroundShade.Visible =
            currentTheme == "Erius"

        _G.__EriusHubBackgroundShade.BackgroundTransparency =
            0.74
    end

    title.TextColor3 = theme.Text
    minimize.BackgroundColor3 = theme.Panel
    minimize.TextColor3 = theme.Text

    clickerFrame.BackgroundColor3 = theme.Main

    if currentTheme == "Erius" then
        clickerFrame.BackgroundTransparency = 1

        if _G.__EriusClickerBackground then
            _G.__EriusClickerBackground.Visible = true
        end

        if _G.__EriusClickerShade then
            _G.__EriusClickerShade.Visible = true
        end
    else
        clickerFrame.BackgroundTransparency = 0

        if _G.__EriusClickerBackground then
            _G.__EriusClickerBackground.Visible = false
        end

        if _G.__EriusClickerShade then
            _G.__EriusClickerShade.Visible = false
        end
    end

    clickerTitle.TextColor3 = theme.Text
    clickerMinimize.BackgroundColor3 = theme.Panel
    clickerMinimize.TextColor3 = theme.Text
    clickerCPSLabel.BackgroundColor3 = theme.Panel
    clickerCPSBox.BackgroundColor3 = theme.Control
    clickerCPSBox.TextColor3 = theme.Text
    clickerKeyButton.BackgroundColor3 = theme.Control
    clickerKeyButton.TextColor3 = theme.Text
    clickerToggleButton.TextColor3 = theme.Text
    clickerLeaveButton.TextColor3 = theme.Text

    if _G.__EriusSteelFrame then
        _G.__EriusSteelTitle.TextColor3 = theme.Text
        _G.__EriusSteelMinimize.BackgroundColor3 = theme.Panel
        _G.__EriusSteelMinimize.TextColor3 = theme.Text
        _G.__EriusCreatorClose.BackgroundColor3 = theme.Panel
        _G.__EriusCreatorClose.TextColor3 = theme.Text
        _G.__EriusCreatorCodeBox.BackgroundColor3 = theme.Control
        _G.__EriusCreatorCodeBox.TextColor3 = theme.Text
        _G.__EriusCreatorUnlock.BackgroundColor3 = theme.Control
        _G.__EriusCreatorUnlock.TextColor3 = theme.Text
        _G.__EriusSteelInteractButton.TextColor3 = theme.Text

        if currentTheme == "Erius" then
            _G.__EriusSteelFrame.BackgroundTransparency = 1
            _G.__EriusSteelBackground.Visible = true
            _G.__EriusSteelShade.Visible = true
        else
            _G.__EriusSteelFrame.BackgroundTransparency = 0
            _G.__EriusSteelBackground.Visible = false
            _G.__EriusSteelShade.Visible = false
            _G.__EriusSteelFrame.BackgroundColor3 = theme.Main
        end

        _G.__EriusRefreshSteelVisual()
    end

    if _G.__EriusSteelFrame then
        _G.__EriusSteelTitle.TextColor3 = theme.Text
        _G.__EriusSteelMinimize.BackgroundColor3 = theme.Panel
        _G.__EriusSteelMinimize.TextColor3 = theme.Text
        _G.__EriusSteelInteractButton.TextColor3 = theme.Text

        if currentTheme == "Erius" then
            _G.__EriusSteelFrame.BackgroundTransparency = 1
            _G.__EriusSteelBackground.Visible = true
            _G.__EriusSteelShade.Visible = true
        else
            _G.__EriusSteelFrame.BackgroundTransparency = 0
            _G.__EriusSteelBackground.Visible = false
            _G.__EriusSteelShade.Visible = false
            _G.__EriusSteelFrame.BackgroundColor3 = theme.Main
        end

        _G.__EriusRefreshSteelVisual()
    end

    for _, object in ipairs(gui:GetDescendants()) do
        if object:IsA("TextLabel")
            or object:IsA("TextButton")
            or object:IsA("TextBox") then

            if object ~= leaveButton then
                object.TextColor3 = theme.Text
            end
        end
    end

    local panels = {
        fovLabel,
        searchBox,
        selectedLabel
    }

    for _, object in ipairs(panels) do
        if object and object.Parent then
            object.BackgroundColor3 = theme.Panel
        end
    end

    local controls = {
        flyBox,
        speedBox,
        fovBox,
        rangeBox,
        _G.__EriusInfiniteJumpButton,
        openClickerButton,
        _G.__EriusSteelInteractButton,
        clickerCPSBox,
        clickerKeyButton,
        _G.__EriusClickerModeButton,
        _G.__EriusCreatorCodeBox,
        _G.__EriusCreatorUnlock,
        _G.__EriusSteelInteractButton,
        _G.__EriusThemeButton,
        blackThemeButton,
        whiteThemeButton,
        rainbowThemeButton,
        customThemeButton,
        scale80,
        scale100,
        scale120
    }

    for _, object in ipairs(controls) do
        if object and object.Parent then
            object.BackgroundColor3 = theme.Control
        end
    end

    playerList.BackgroundColor3 = theme.DarkPanel
    searchBox.PlaceholderColor3 = theme.Muted
    fovStroke.Color = theme.Text
    sliderFill.BackgroundColor3 = getAccent()

    if _G.__EriusAimbotRange then
        _G.__EriusAimbotRange.Fill.BackgroundColor3 = getAccent()
        _G.__EriusAimbotRange.Box.BackgroundColor3 = theme.Control
        _G.__EriusAimbotRange.Box.TextColor3 = theme.Text
        _G.__EriusAimbotRange.Title.TextColor3 = theme.Text
    end

    resetTabs()

    if currentTab then
        currentTab.BackgroundColor3 = getAccent()
    end

    setButtonState(
        flyButton,
        flying,
        "Fly: ON",
        "Fly: OFF"
    )

    setButtonState(
        speedButton,
        speedEnabled,
        "Run Speed: ON",
        "Run Speed: OFF"
    )

    setButtonState(
        invisibleButton,
        invisible,
        "Invisible: ON",
        "Invisible: OFF"
    )

    setButtonState(
        noclipButton,
        noclip,
        "NoClip: ON",
        "NoClip: OFF"
    )

    setButtonState(
        aimbotButton,
        aimbotEnabled,
        "Aimbot: ON",
        "Aimbot: OFF"
    )

    setButtonState(
        _G.__EriusInfiniteJumpButton,
        _G.__EriusInfiniteJump,
        "Infinity Jump: ON",
        "Infinity Jump: OFF"
    )

    for _, refresh in ipairs(themeRefreshers) do
        refresh()
    end

    refreshClickerVisual()

    if _G.__EriusRefreshSteelVisual then
        _G.__EriusRefreshSteelVisual()
    end

    if _G.__EriusThemeButton then
        _G.__EriusThemeButton.BackgroundColor3 =
            currentTheme == "Erius"
            and getAccent()
            or theme.Control
    end

    blackThemeButton.BackgroundColor3 =
        currentTheme == "Black"
        and getAccent()
        or theme.Control

    whiteThemeButton.BackgroundColor3 =
        currentTheme == "White"
        and getAccent()
        or theme.Control

    rainbowThemeButton.BackgroundColor3 =
        currentTheme == "Rainbow"
        and getAccent()
        or theme.Control

    customThemeButton.BackgroundColor3 =
        currentTheme == "Custom"
        and getAccent()
        or theme.Control

    for code, button in pairs(_G.__EriusLangButtons) do
        button.BackgroundColor3 =
            language == code
            and getAccent()
            or theme.Control
    end

    scale80.BackgroundColor3 =
        hubScale == 0.8
        and getAccent()
        or theme.Control

    scale100.BackgroundColor3 =
        hubScale == 1
        and getAccent()
        or theme.Control

    scale120.BackgroundColor3 =
        hubScale == 1.2
        and getAccent()
        or theme.Control
end

--------------------------------------------------
-- LANGUAGE APPLY
--------------------------------------------------

local function refreshLanguage()
    for _, data in ipairs(languageObjects) do
        if data.Object and data.Object.Parent then
            data.Object.Text = T(data.Text)
        end
    end

    flyBox.PlaceholderText = T("Fly Speed")
    speedBox.PlaceholderText = T("Run Speed")
    searchBox.PlaceholderText =
        T("Search username or display name...")

    setButtonState(
        flyButton,
        flying,
        "Fly: ON",
        "Fly: OFF"
    )

    setButtonState(
        speedButton,
        speedEnabled,
        "Run Speed: ON",
        "Run Speed: OFF"
    )

    setButtonState(
        invisibleButton,
        invisible,
        "Invisible: ON",
        "Invisible: OFF"
    )

    setButtonState(
        noclipButton,
        noclip,
        "NoClip: ON",
        "NoClip: OFF"
    )

    setButtonState(
        aimbotButton,
        aimbotEnabled,
        "Aimbot: ON",
        "Aimbot: OFF"
    )

    fovModeButton.Text =
        T(
            fovMode == "Crosshair"
            and "FOV Mode: Crosshair"
            or "FOV Mode: Mouse"
        )

    refreshSelectedLabel()

    if _G.__EriusFollow and _G.__EriusFollow.Refresh then
        _G.__EriusFollow.Refresh()
    end

    refreshClickerVisual()

    if _G.__EriusRefreshSteelVisual then
        _G.__EriusRefreshSteelVisual()
    end

    applyTheme()
end

_G.__EriusRefreshLanguage = refreshLanguage

--------------------------------------------------
-- LANGUAGE EVENTS
--------------------------------------------------

-- Language buttons are connected in makeLanguageButton()

--------------------------------------------------
-- THEME EVENTS
--------------------------------------------------

connect(_G.__EriusThemeButton.MouseButton1Click, function()
    currentTheme = "Erius"
    applyTheme()
end)

connect(blackThemeButton.MouseButton1Click, function()
    currentTheme = "Black"
    applyTheme()
end)

connect(whiteThemeButton.MouseButton1Click, function()
    currentTheme = "White"
    applyTheme()
end)

connect(rainbowThemeButton.MouseButton1Click, function()
    currentTheme = "Rainbow"
    applyTheme()
end)

connect(customThemeButton.MouseButton1Click, function()
    currentTheme = "Custom"
    applyTheme()
end)

--------------------------------------------------
-- CUSTOM COLOR SLIDER
--------------------------------------------------

local function setCustomColorFromX(x)
    local startX = colorSlider.AbsolutePosition.X
    local width = colorSlider.AbsoluteSize.X

    if width <= 0 then
        return
    end

    local percent =
        math.clamp(
            (x - startX) / width,
            0,
            1
        )

    customColor =
        Color3.fromHSV(
            percent,
            0.8,
            1
        )

    colorKnob.Position =
        UDim2.new(
            percent,
            0,
            0.5,
            0
        )

    currentTheme = "Custom"
    applyTheme()
end

connect(colorSlider.InputBegan, function(input)
    if input.UserInputType
        == Enum.UserInputType.MouseButton1
        or input.UserInputType
        == Enum.UserInputType.Touch then

        colorSliding = true
        setCustomColorFromX(input.Position.X)
    end
end)

connect(colorKnob.InputBegan, function(input)
    if input.UserInputType
        == Enum.UserInputType.MouseButton1
        or input.UserInputType
        == Enum.UserInputType.Touch then

        colorSliding = true
    end
end)

--------------------------------------------------
-- SCALE EVENTS
--------------------------------------------------

local function setHubScale(value)
    hubScale = value

    if animationsEnabled then
        TweenService:Create(
            mainScale,
            TweenInfo.new(
                0.18,
                Enum.EasingStyle.Quint,
                Enum.EasingDirection.Out
            ),
            {Scale = value}
        ):Play()
    else
        mainScale.Scale = value
    end

    applyTheme()
end

connect(scale80.MouseButton1Click, function()
    setHubScale(0.8)
end)

connect(scale100.MouseButton1Click, function()
    setHubScale(1)
end)

connect(scale120.MouseButton1Click, function()
    setHubScale(1.2)
end)


--------------------------------------------------
-- CREATORS PAGE
--------------------------------------------------

_G.__EriusCreators.Background = Instance.new("Frame")
_G.__EriusCreators.Background.Size = UDim2.fromScale(1, 1)
_G.__EriusCreators.Background.BackgroundColor3 = getTheme().DarkPanel
_G.__EriusCreators.Background.BorderSizePixel = 0
_G.__EriusCreators.Background.Parent = _G.__EriusCreators.Page

round(_G.__EriusCreators.Background, 14)

_G.__EriusCreators.BackgroundStroke = Instance.new("UIStroke")
_G.__EriusCreators.BackgroundStroke.Thickness = 1.5
_G.__EriusCreators.BackgroundStroke.Transparency = 0.35
_G.__EriusCreators.BackgroundStroke.Color = getAccent()
_G.__EriusCreators.BackgroundStroke.Parent = _G.__EriusCreators.Background

_G.__EriusCreators.BackgroundGradient = Instance.new("UIGradient")
_G.__EriusCreators.BackgroundGradient.Rotation = 115
_G.__EriusCreators.BackgroundGradient.Parent = _G.__EriusCreators.Background


_G.__EriusCreators.GlowTop = Instance.new("Frame")
_G.__EriusCreators.GlowTop.AnchorPoint = Vector2.new(0.5, 0)
_G.__EriusCreators.GlowTop.Size = UDim2.new(0.82, 0, 0, 115)
_G.__EriusCreators.GlowTop.Position = UDim2.new(0.5, 0, 0, 0)
_G.__EriusCreators.GlowTop.BackgroundTransparency = 0.72
_G.__EriusCreators.GlowTop.BorderSizePixel = 0
_G.__EriusCreators.GlowTop.Parent = _G.__EriusCreators.Background

round(_G.__EriusCreators.GlowTop, 18)

_G.__EriusCreators.GlowTopGradient = Instance.new("UIGradient")
_G.__EriusCreators.GlowTopGradient.Rotation = 90
_G.__EriusCreators.GlowTopGradient.Parent = _G.__EriusCreators.GlowTop

_G.__EriusCreators.GlowBottom = Instance.new("Frame")
_G.__EriusCreators.GlowBottom.AnchorPoint = Vector2.new(0.5, 1)
_G.__EriusCreators.GlowBottom.Size = UDim2.new(0.90, 0, 0, 90)
_G.__EriusCreators.GlowBottom.Position = UDim2.new(0.5, 0, 1, -4)
_G.__EriusCreators.GlowBottom.BackgroundTransparency = 0.82
_G.__EriusCreators.GlowBottom.BorderSizePixel = 0
_G.__EriusCreators.GlowBottom.Parent = _G.__EriusCreators.Background

round(_G.__EriusCreators.GlowBottom, 18)

_G.__EriusCreators.GlowBottomGradient = Instance.new("UIGradient")
_G.__EriusCreators.GlowBottomGradient.Rotation = 0
_G.__EriusCreators.GlowBottomGradient.Parent = _G.__EriusCreators.GlowBottom

_G.__EriusCreators.TopAccent = Instance.new("Frame")
_G.__EriusCreators.TopAccent.AnchorPoint = Vector2.new(0.5, 0)
_G.__EriusCreators.TopAccent.Size = UDim2.new(0.54, 0, 0, 3)
_G.__EriusCreators.TopAccent.Position = UDim2.new(0.5, 0, 0, 18)
_G.__EriusCreators.TopAccent.BackgroundColor3 = getAccent()
_G.__EriusCreators.TopAccent.BorderSizePixel = 0
_G.__EriusCreators.TopAccent.Parent = _G.__EriusCreators.Background

round(_G.__EriusCreators.TopAccent, 999)

_G.__EriusCreators.Brand = Instance.new("TextLabel")
_G.__EriusCreators.Brand.Size = UDim2.new(1, -30, 0, 42)
_G.__EriusCreators.Brand.Position = UDim2.fromOffset(15, 28)
_G.__EriusCreators.Brand.BackgroundTransparency = 1
_G.__EriusCreators.Brand.Text = "ERIUS HUB"
_G.__EriusCreators.Brand.TextColor3 = getTheme().Text
_G.__EriusCreators.Brand.Font = Enum.Font.GothamBold
_G.__EriusCreators.Brand.TextSize = 29
_G.__EriusCreators.Brand.TextXAlignment = Enum.TextXAlignment.Center
_G.__EriusCreators.Brand.Parent = _G.__EriusCreators.Background

_G.__EriusCreators.Subtitle = Instance.new("TextLabel")
_G.__EriusCreators.Subtitle.Size = UDim2.new(1, -50, 0, 42)
_G.__EriusCreators.Subtitle.Position = UDim2.fromOffset(25, 68)
_G.__EriusCreators.Subtitle.BackgroundTransparency = 1
_G.__EriusCreators.Subtitle.Text = T("Built by creators for a better experience")
_G.__EriusCreators.Subtitle.TextColor3 = getTheme().Muted
_G.__EriusCreators.Subtitle.Font = Enum.Font.GothamSemibold
_G.__EriusCreators.Subtitle.TextSize = 12
_G.__EriusCreators.Subtitle.TextWrapped = true
_G.__EriusCreators.Subtitle.TextXAlignment = Enum.TextXAlignment.Center
_G.__EriusCreators.Subtitle.Parent = _G.__EriusCreators.Background

registerLanguageObject(
    _G.__EriusCreators.Subtitle,
    "Built by creators for a better experience"
)

_G.__EriusCreators.MakeCard = function(xScale, displayName, username)
    local card = Instance.new("Frame")
    card.Size = UDim2.new(0.465, 0, 0, 292)
    card.Position = UDim2.new(xScale, 0, 0, 118)
    card.BackgroundColor3 = getTheme().Panel
    card.BorderSizePixel = 0
    card.ClipsDescendants = true
    card.Parent = _G.__EriusCreators.Background

    round(card, 14)

    local stroke = Instance.new("UIStroke")
    stroke.Thickness = 1.5
    stroke.Transparency = 0.2
    stroke.Color = getAccent()
    stroke.Parent = card

    local gradient = Instance.new("UIGradient")
    gradient.Rotation = 125
    gradient.Parent = card

    local imageHolder = Instance.new("Frame")
    imageHolder.Size = UDim2.new(1, -18, 0, 185)
    imageHolder.Position = UDim2.fromOffset(9, 9)
    imageHolder.BackgroundColor3 = getTheme().DarkPanel
    imageHolder.BorderSizePixel = 0
    imageHolder.ClipsDescendants = true
    imageHolder.Parent = card

    round(imageHolder, 12)

    local imageGradient = Instance.new("UIGradient")
    imageGradient.Rotation = 125
    imageGradient.Parent = imageHolder

    local imageStroke = Instance.new("UIStroke")
    imageStroke.Thickness = 1
    imageStroke.Transparency = 0.45
    imageStroke.Color = getAccent()
    imageStroke.Parent = imageHolder

    local avatar = Instance.new("ImageLabel")
    avatar.Size = UDim2.new(1.12, 0, 1.12, 0)
    avatar.Position = UDim2.new(-0.06, 0, -0.06, 0)
    avatar.BackgroundTransparency = 1
    avatar.Image = ""
    avatar.ScaleType = Enum.ScaleType.Fit
    avatar.Parent = imageHolder

    local name = Instance.new("TextLabel")
    name.Size = UDim2.new(1, -16, 0, 38)
    name.Position = UDim2.fromOffset(8, 204)
    name.BackgroundTransparency = 1
    name.Text = displayName
    name.TextColor3 = getTheme().Text
    name.Font = Enum.Font.GothamBold
    name.TextSize = 24
    name.TextXAlignment = Enum.TextXAlignment.Center
    name.Parent = card

    local role = Instance.new("TextLabel")
    role.Size = UDim2.new(1, -16, 0, 28)
    role.Position = UDim2.fromOffset(8, 241)
    role.BackgroundTransparency = 1
    role.Text = T("THE CREATOR")
    role.TextColor3 = getAccent()
    role.Font = Enum.Font.GothamBold
    role.TextSize = 12
    role.TextXAlignment = Enum.TextXAlignment.Center
    role.Parent = card

    registerLanguageObject(role, "THE CREATOR")

    local accentLine = Instance.new("Frame")
    accentLine.AnchorPoint = Vector2.new(0.5, 0)
    accentLine.Size = UDim2.new(0.48, 0, 0, 3)
    accentLine.Position = UDim2.new(0.5, 0, 1, -15)
    accentLine.BackgroundColor3 = getAccent()
    accentLine.BorderSizePixel = 0
    accentLine.Parent = card

    round(accentLine, 999)

    local cardScale = Instance.new("UIScale")
    cardScale.Scale = 1
    cardScale.Parent = card

    task.spawn(function()
        local okId, userId = pcall(function()
            return Players:GetUserIdFromNameAsync(username)
        end)

        if not okId or not userId then
            return
        end

        local function loadThumbnail(thumbnailType)
            for _ = 1, 8 do
                local okImage, content, isReady = pcall(function()
                    return Players:GetUserThumbnailAsync(
                        userId,
                        thumbnailType,
                        Enum.ThumbnailSize.Size420x420
                    )
                end)

                if okImage and content and content ~= "" and isReady then
                    return content
                end

                task.wait(0.35)
            end

            local okImage, content = pcall(function()
                return Players:GetUserThumbnailAsync(
                    userId,
                    thumbnailType,
                    Enum.ThumbnailSize.Size420x420
                )
            end)

            if okImage and content and content ~= "" then
                return content
            end

            return nil
        end

        local content =
            loadThumbnail(Enum.ThumbnailType.AvatarBust)
            or loadThumbnail(Enum.ThumbnailType.AvatarThumbnail)

        if content and avatar.Parent then
            avatar.Image = content
        end
    end)

    return {
        Card = card,
        Stroke = stroke,
        Gradient = gradient,
        ImageHolder = imageHolder,
        ImageGradient = imageGradient,
        ImageStroke = imageStroke,
        Avatar = avatar,
        Name = name,
        Role = role,
        AccentLine = accentLine,
        Scale = cardScale
    }
end

_G.__EriusCreators.Marius = _G.__EriusCreators.MakeCard(
    0.025,
    "MARIUS",
    "Luluterbach10"
)

_G.__EriusCreators.Erik = _G.__EriusCreators.MakeCard(
    0.51,
    "ERIK",
    "Leoleoleo987654"
)

_G.__EriusCreators.BottomPanel = Instance.new("Frame")
_G.__EriusCreators.BottomPanel.Size = UDim2.new(0.95, 0, 0, 42)
_G.__EriusCreators.BottomPanel.Position = UDim2.new(0.025, 0, 1, -52)
_G.__EriusCreators.BottomPanel.BackgroundColor3 = getTheme().Panel
_G.__EriusCreators.BottomPanel.BorderSizePixel = 0
_G.__EriusCreators.BottomPanel.Parent = _G.__EriusCreators.Background

round(_G.__EriusCreators.BottomPanel, 12)

_G.__EriusCreators.BottomStroke = Instance.new("UIStroke")
_G.__EriusCreators.BottomStroke.Thickness = 1
_G.__EriusCreators.BottomStroke.Transparency = 0.45
_G.__EriusCreators.BottomStroke.Color = getAccent()
_G.__EriusCreators.BottomStroke.Parent = _G.__EriusCreators.BottomPanel

_G.__EriusCreators.BottomText = Instance.new("TextLabel")
_G.__EriusCreators.BottomText.Size = UDim2.new(0.56, -18, 1, 0)
_G.__EriusCreators.BottomText.Position = UDim2.fromOffset(12, 0)
_G.__EriusCreators.BottomText.BackgroundTransparency = 1
_G.__EriusCreators.BottomText.Text = T("Made by Marius and Erik")
_G.__EriusCreators.BottomText.TextColor3 = getTheme().Muted
_G.__EriusCreators.BottomText.Font = Enum.Font.GothamSemibold
_G.__EriusCreators.BottomText.TextSize = 13
_G.__EriusCreators.BottomText.TextXAlignment = Enum.TextXAlignment.Center
_G.__EriusCreators.BottomText.Parent = _G.__EriusCreators.BottomPanel

registerLanguageObject(
    _G.__EriusCreators.BottomText,
    "Made by Marius and Erik"
)


_G.__EriusCreators.CreatorHubButton = Instance.new("TextButton")
_G.__EriusCreators.CreatorHubButton.Size = UDim2.new(0.38, 0, 0, 30)
_G.__EriusCreators.CreatorHubButton.Position = UDim2.new(0.60, 0, 0.5, -15)
_G.__EriusCreators.CreatorHubButton.BackgroundColor3 = getTheme().Control
_G.__EriusCreators.CreatorHubButton.TextColor3 = getTheme().Text
_G.__EriusCreators.CreatorHubButton.Text = "Creator Hub"
_G.__EriusCreators.CreatorHubButton.Font = Enum.Font.GothamBold
_G.__EriusCreators.CreatorHubButton.TextSize = 12
_G.__EriusCreators.CreatorHubButton.Parent = _G.__EriusCreators.BottomPanel
round(_G.__EriusCreators.CreatorHubButton, 8)

connect(_G.__EriusCreators.CreatorHubButton.MouseButton1Click, function()
    _G.__EriusSteelOpen = true
    _G.__EriusSteelFrame.Visible = true

    _G.__EriusPlaceSteelBesideHub()

    if _G.__EriusBringWindowToFront then
        _G.__EriusBringWindowToFront("Steel")
    end

    _G.__EriusSetCreatorLockedView()
    _G.__EriusRefreshSteelVisual()
end)

_G.__EriusCreators.RefreshTheme = function()
    if not _G.__EriusCreators
        or not _G.__EriusCreators.Background
        or not _G.__EriusCreators.Background.Parent then
        return
    end

    local theme = getTheme()
    local accent = getAccent()

    _G.__EriusCreators.Background.BackgroundColor3 = theme.DarkPanel
    _G.__EriusCreators.BackgroundStroke.Color = accent
    _G.__EriusCreators.TopAccent.BackgroundColor3 = accent
    _G.__EriusCreators.Brand.TextColor3 = theme.Text
    _G.__EriusCreators.Subtitle.TextColor3 = theme.Muted

    _G.__EriusCreators.BackgroundGradient.Color =
        ColorSequence.new({
            ColorSequenceKeypoint.new(0, theme.DarkPanel:Lerp(accent, 0.05)),
            ColorSequenceKeypoint.new(
                0.42,
                theme.Main:Lerp(accent, 0.14)
            ),
            ColorSequenceKeypoint.new(
                0.72,
                theme.DarkPanel:Lerp(accent, 0.08)
            ),
            ColorSequenceKeypoint.new(1, theme.DarkPanel)
        })

    _G.__EriusCreators.GlowTop.BackgroundColor3 =
        theme.Main:Lerp(accent, 0.30)

    _G.__EriusCreators.GlowTopGradient.Color =
        ColorSequence.new({
            ColorSequenceKeypoint.new(0, accent:Lerp(theme.Main, 0.20)),
            ColorSequenceKeypoint.new(0.5, theme.Main:Lerp(accent, 0.42)),
            ColorSequenceKeypoint.new(1, theme.DarkPanel)
        })

    _G.__EriusCreators.GlowTopGradient.Transparency =
        NumberSequence.new({
            NumberSequenceKeypoint.new(0, 0.15),
            NumberSequenceKeypoint.new(0.55, 0.55),
            NumberSequenceKeypoint.new(1, 1)
        })

    _G.__EriusCreators.GlowBottom.BackgroundColor3 =
        theme.DarkPanel:Lerp(accent, 0.22)

    _G.__EriusCreators.GlowBottomGradient.Color =
        ColorSequence.new({
            ColorSequenceKeypoint.new(0, theme.DarkPanel),
            ColorSequenceKeypoint.new(0.5, theme.Main:Lerp(accent, 0.25)),
            ColorSequenceKeypoint.new(1, theme.DarkPanel)
        })

    for _, data in ipairs({
        _G.__EriusCreators.Marius,
        _G.__EriusCreators.Erik
    }) do
        if data and data.Card and data.Card.Parent then
            data.Card.BackgroundColor3 = theme.Panel
            data.Stroke.Color = accent
            data.ImageHolder.BackgroundColor3 = theme.DarkPanel
            data.ImageStroke.Color = accent
            data.Name.TextColor3 = theme.Text
            data.Role.TextColor3 = accent
            data.AccentLine.BackgroundColor3 = accent

            data.Gradient.Color =
                ColorSequence.new({
                    ColorSequenceKeypoint.new(0, theme.Panel:Lerp(accent, 0.06)),
                    ColorSequenceKeypoint.new(
                        0.52,
                        theme.Panel:Lerp(accent, 0.16)
                    ),
                    ColorSequenceKeypoint.new(
                        0.82,
                        theme.DarkPanel:Lerp(accent, 0.10)
                    ),
                    ColorSequenceKeypoint.new(1, theme.DarkPanel)
                })

            if data.ImageGradient then
                data.ImageGradient.Color =
                    ColorSequence.new({
                        ColorSequenceKeypoint.new(0, theme.DarkPanel),
                        ColorSequenceKeypoint.new(
                            0.55,
                            theme.Main:Lerp(accent, 0.18)
                        ),
                        ColorSequenceKeypoint.new(1, theme.DarkPanel)
                    })
            end
        end
    end

    _G.__EriusCreators.BottomPanel.BackgroundColor3 = theme.Panel
    _G.__EriusCreators.BottomStroke.Color = accent
    _G.__EriusCreators.BottomText.TextColor3 = theme.Muted

    if _G.__EriusCreators.CreatorHubButton then
        _G.__EriusCreators.CreatorHubButton.BackgroundColor3 =
            theme.Control

        _G.__EriusCreators.CreatorHubButton.TextColor3 =
            theme.Text
    end
end

table.insert(
    themeRefreshers,
    _G.__EriusCreators.RefreshTheme
)

_G.__EriusCreators.PlayIntro = function()
    if not animationsEnabled then
        return
    end

    _G.__EriusCreators.TopAccent.Size = UDim2.new(0.18, 0, 0, 3)

    TweenService:Create(
        _G.__EriusCreators.TopAccent,
        TweenInfo.new(
            0.32,
            Enum.EasingStyle.Quint,
            Enum.EasingDirection.Out
        ),
        {Size = UDim2.new(0.54, 0, 0, 3)}
    ):Play()

    for index, data in ipairs({
        _G.__EriusCreators.Marius,
        _G.__EriusCreators.Erik
    }) do
        if data and data.Scale then
            data.Scale.Scale = 0.93

            task.delay((index - 1) * 0.05, function()
                if data.Scale and data.Scale.Parent then
                    TweenService:Create(
                        data.Scale,
                        TweenInfo.new(
                            0.24,
                            Enum.EasingStyle.Quint,
                            Enum.EasingDirection.Out
                        ),
                        {Scale = 1}
                    ):Play()
                end
            end)
        end
    end
end

_G.__EriusCreators.RefreshTheme()

--------------------------------------------------
-- CREDITS
--------------------------------------------------

local credits = Instance.new("TextLabel")
credits.Size = UDim2.new(1, -30, 0, 30)
credits.Position = UDim2.new(0, 15, 1, -38)
credits.BackgroundTransparency = 1
credits.Text = T("Made by Marius and Erik")
credits.TextColor3 = getTheme().Muted
credits.Font = Enum.Font.GothamSemibold
credits.TextSize = 14
credits.TextXAlignment = Enum.TextXAlignment.Center
credits.Parent = main
registerLanguageObject(credits, "Made by Marius and Erik")

--------------------------------------------------
-- STARTUP / WELCOME ANIMATION
--------------------------------------------------

local startupFinished = false

local startupFrame = Instance.new("Frame")
startupFrame.Size = UDim2.fromScale(1, 1)
startupFrame.Position = UDim2.fromScale(0, 0)
startupFrame.BackgroundColor3 = getTheme().Main
startupFrame.BackgroundTransparency = 1
startupFrame.BorderSizePixel = 0
startupFrame.ZIndex = 100
startupFrame.Parent = main

round(startupFrame, 14)

--------------------------------------------------
-- STARTUP BACKGROUND IMAGE
--------------------------------------------------

_G.__EriusStartupBackground = Instance.new("ImageLabel")
_G.__EriusStartupBackground.Name = "StartupBackgroundImage"
_G.__EriusStartupBackground.Size = UDim2.fromScale(1, 1)
_G.__EriusStartupBackground.Position = UDim2.fromScale(0, 0)
_G.__EriusStartupBackground.BackgroundTransparency = 1
_G.__EriusStartupBackground.Image = "rbxassetid://98830209894912"
_G.__EriusStartupBackground.ImageTransparency = 0
_G.__EriusStartupBackground.ScaleType = Enum.ScaleType.Crop
_G.__EriusStartupBackground.ZIndex = 100
_G.__EriusStartupBackground.Parent = startupFrame

round(_G.__EriusStartupBackground, 14)

_G.__EriusStartupShade = Instance.new("Frame")
_G.__EriusStartupShade.Name = "StartupBackgroundShade"
_G.__EriusStartupShade.Size = UDim2.fromScale(1, 1)
_G.__EriusStartupShade.Position = UDim2.fromScale(0, 0)
_G.__EriusStartupShade.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
_G.__EriusStartupShade.BackgroundTransparency = 0.72
_G.__EriusStartupShade.BorderSizePixel = 0
_G.__EriusStartupShade.ZIndex = 100
_G.__EriusStartupShade.Parent = startupFrame

round(_G.__EriusStartupShade, 14)

local startupScale = Instance.new("UIScale")
startupScale.Scale = 0.82
startupScale.Parent = startupFrame

--------------------------------------------------
-- LOGO
--------------------------------------------------

local startupLogo = Instance.new("ImageLabel")
startupLogo.Name = "EriusLogo"
startupLogo.Size = UDim2.fromOffset(205, 205)
startupLogo.Position = UDim2.new(0.5, -102, 0, 58)
startupLogo.BackgroundTransparency = 1
startupLogo.Image = "rbxassetid://85204079419772"
startupLogo.ImageTransparency = 1
startupLogo.ScaleType = Enum.ScaleType.Fit
startupLogo.ZIndex = 103
startupLogo.Parent = startupFrame

--------------------------------------------------
-- WELCOME
--------------------------------------------------

local startupTitle = Instance.new("TextLabel")
startupTitle.Size = UDim2.new(1, -40, 0, 50)
startupTitle.Position = UDim2.fromOffset(20, 270)
startupTitle.BackgroundTransparency = 1
startupTitle.Text = "Welcome to Erius Hub"
startupTitle.TextColor3 = Color3.fromRGB(255, 255, 255)
startupTitle.TextTransparency = 1
startupTitle.Font = Enum.Font.GothamBold
startupTitle.TextSize = 26
startupTitle.TextXAlignment = Enum.TextXAlignment.Center
startupTitle.ZIndex = 103
startupTitle.Parent = startupFrame

--------------------------------------------------
-- MADE BY - VISIBLE DURING LOADING
--------------------------------------------------

local startupDescription = Instance.new("TextLabel")
startupDescription.Size = UDim2.new(1, -40, 0, 34)
startupDescription.Position = UDim2.fromOffset(20, 318)
startupDescription.BackgroundTransparency = 1
startupDescription.Text = T("Made by Marius and Erik")
startupDescription.TextColor3 = Color3.fromRGB(220, 220, 230)
startupDescription.TextTransparency = 1
startupDescription.Font = Enum.Font.GothamBold
startupDescription.TextSize = 17
startupDescription.TextXAlignment = Enum.TextXAlignment.Center
startupDescription.ZIndex = 103
startupDescription.Parent = startupFrame
registerLanguageObject(startupDescription, "Made by Marius and Erik")

--------------------------------------------------
-- PERCENT
--------------------------------------------------

local startupPercent = Instance.new("TextLabel")
startupPercent.Size = UDim2.new(1, -40, 0, 40)
startupPercent.Position = UDim2.fromOffset(20, 370)
startupPercent.BackgroundTransparency = 1
startupPercent.Text = "0%"
startupPercent.TextColor3 = getAccent()
startupPercent.Font = Enum.Font.GothamBold
startupPercent.TextSize = 24
startupPercent.ZIndex = 103
startupPercent.Parent = startupFrame

--------------------------------------------------
-- LOADING BAR
--------------------------------------------------

local startupBarBackground = Instance.new("Frame")
startupBarBackground.Size = UDim2.new(0.72, 0, 0, 8)
startupBarBackground.Position = UDim2.new(0.14, 0, 0, 420)
startupBarBackground.BackgroundColor3 = Color3.fromRGB(55, 55, 65)
startupBarBackground.BorderSizePixel = 0
startupBarBackground.ZIndex = 103
startupBarBackground.Parent = startupFrame

round(startupBarBackground, 999)

local startupBar = Instance.new("Frame")
startupBar.Size = UDim2.fromScale(0, 1)
startupBar.BackgroundColor3 = getAccent()
startupBar.BorderSizePixel = 0
startupBar.ZIndex = 104
startupBar.Parent = startupBarBackground

round(startupBar, 999)

--------------------------------------------------
-- START PAGE
--------------------------------------------------

showPage(mainPage, mainTab)
updatePlayerList()
applyTheme()

--------------------------------------------------
-- HIDE NORMAL HUB DURING STARTUP
--------------------------------------------------

tabs.Visible = false
pages.Visible = false
credits.Visible = false
title.Visible = false
minimize.Visible = false

--------------------------------------------------
-- PLAY STARTUP
--------------------------------------------------

task.spawn(function()
    TweenService:Create(
        startupScale,
        TweenInfo.new(
            0.22,
            Enum.EasingStyle.Back,
            Enum.EasingDirection.Out
        ),
        {Scale = 1}
    ):Play()

    TweenService:Create(
        startupLogo,
        TweenInfo.new(
            0.28,
            Enum.EasingStyle.Quint,
            Enum.EasingDirection.Out
        ),
        {ImageTransparency = 0}
    ):Play()

    TweenService:Create(
        startupTitle,
        TweenInfo.new(0.18),
        {TextTransparency = 0}
    ):Play()

    TweenService:Create(
        startupDescription,
        TweenInfo.new(0.18),
        {TextTransparency = 0}
    ):Play()

    local loadingTime = 1.25
    local startTime = tick()

    while running do
        local progress =
            math.clamp(
                (tick() - startTime) / loadingTime,
                0,
                1
            )

        local percent =
            math.floor(
                progress * 100
            )

        startupPercent.Text =
            tostring(percent)
            .. "%"

        startupBar.Size =
            UDim2.fromScale(
                progress,
                1
            )

        if progress >= 1 then
            break
        end

        RunService.RenderStepped:Wait()
    end

    startupPercent.Text = "100%"
    startupBar.Size =
        UDim2.fromScale(1, 1)

    task.wait(0.55)

    TweenService:Create(
        startupFrame,
        TweenInfo.new(
            0.2,
            Enum.EasingStyle.Quint,
            Enum.EasingDirection.In
        ),
        {
            BackgroundTransparency = 1
        }
    ):Play()

    TweenService:Create(
        startupScale,
        TweenInfo.new(
            0.2,
            Enum.EasingStyle.Quint,
            Enum.EasingDirection.In
        ),
        {
            Scale = 1.04
        }
    ):Play()

    for _, object in ipairs(
        startupFrame:GetDescendants()
    ) do
        if object:IsA("TextLabel") then
            TweenService:Create(
                object,
                TweenInfo.new(0.18),
                {
                    TextTransparency = 1
                }
            ):Play()

        elseif object:IsA("ImageLabel") then
            TweenService:Create(
                object,
                TweenInfo.new(0.18),
                {
                    ImageTransparency = 1
                }
            ):Play()

        elseif object:IsA("Frame")
            and object ~= startupFrame then

            TweenService:Create(
                object,
                TweenInfo.new(0.18),
                {
                    BackgroundTransparency = 1
                }
            ):Play()
        end
    end

    task.wait(0.22)

    if startupFrame
        and startupFrame.Parent then

        startupFrame:Destroy()
    end

    startupFinished = true

    tabs.Visible = true
    pages.Visible = true
    credits.Visible = true
    title.Visible = true
    minimize.Visible = true

    if animationsEnabled then
        mainScale.Scale = 0.94

        TweenService:Create(
            mainScale,
            TweenInfo.new(
                0.22,
                Enum.EasingStyle.Back,
                Enum.EasingDirection.Out
            ),
            {
                Scale = hubScale
            }
        ):Play()
    else
        mainScale.Scale = hubScale
    end
end)

--------------------------------------------------
-- MAIN LOOP
--------------------------------------------------

connect(RunService.RenderStepped, function()
    if not running then
        return
    end

    --------------------------------------------------
    -- RAINBOW THEME
    --------------------------------------------------

    if currentTheme == "Rainbow" then
        local accent = getAccent()

        local rainbowBackground =
            accent:Lerp(
                Color3.fromRGB(
                    8,
                    8,
                    12
                ),
                0.58
            )

        main.BackgroundColor3 =
            rainbowBackground

        if currentTab then
            currentTab.BackgroundColor3 =
                accent
        end

        sliderFill.BackgroundColor3 =
            accent

        if startupBar
            and startupBar.Parent then

            startupBar.BackgroundColor3 =
                accent
        end

        if startupPercent
            and startupPercent.Parent then

            startupPercent.TextColor3 =
                accent
        end

        if flying then
            flyButton.BackgroundColor3 =
                accent
        end

        if speedEnabled then
            speedButton.BackgroundColor3 =
                accent
        end

        if invisible then
            invisibleButton.BackgroundColor3 =
                accent
        end

        if noclip then
            noclipButton.BackgroundColor3 =
                accent
        end

        if aimbotEnabled then
            aimbotButton.BackgroundColor3 =
                accent
        end

        if clickerOpen then
            clickerFrame.BackgroundTransparency = 0
            clickerFrame.BackgroundColor3 =
                accent:Lerp(
                    Color3.fromRGB(8, 8, 12),
                    0.58
                )

            clickerMinimize.BackgroundColor3 =
                accent:Lerp(
                    Color3.fromRGB(35, 35, 42),
                    0.55
                )

            if _G.__EriusClickerModeButton then
                _G.__EriusClickerModeButton.BackgroundColor3 =
                    accent:Lerp(
                        Color3.fromRGB(42, 42, 50),
                        0.72
                    )
            end

            clickerCPSLabel.BackgroundColor3 =
                accent:Lerp(
                    Color3.fromRGB(35, 35, 42),
                    0.72
                )

            clickerCPSBox.BackgroundColor3 =
                accent:Lerp(
                    Color3.fromRGB(42, 42, 50),
                    0.72
                )

            clickerKeyButton.BackgroundColor3 =
                accent:Lerp(
                    Color3.fromRGB(42, 42, 50),
                    0.72
                )

            if clickerEnabled then
                clickerToggleButton.BackgroundColor3 =
                    accent
                clickerStatus.TextColor3 =
                    accent
            else
                clickerToggleButton.BackgroundColor3 =
                    accent:Lerp(
                        Color3.fromRGB(42, 42, 50),
                        0.72
                    )
            end
        end

        if _G.__EriusSteelOpen
            and _G.__EriusSteelFrame
            and _G.__EriusSteelFrame.Visible then

            _G.__EriusSteelFrame.BackgroundTransparency = 0
            _G.__EriusSteelFrame.BackgroundColor3 =
                accent:Lerp(
                    Color3.fromRGB(8, 8, 12),
                    0.58
                )

            _G.__EriusSteelMinimize.BackgroundColor3 =
                accent:Lerp(
                    Color3.fromRGB(35, 35, 42),
                    0.55
                )

            if _G.__EriusInstantInteract then
                _G.__EriusSteelInteractButton.BackgroundColor3 =
                    accent
                _G.__EriusSteelStatus.TextColor3 =
                    accent
            else
                _G.__EriusSteelInteractButton.BackgroundColor3 =
                    accent:Lerp(
                        Color3.fromRGB(42, 42, 50),
                        0.72
                    )
            end
        end

        rainbowThemeButton.BackgroundColor3 =
            accent

        for code, button in pairs(_G.__EriusLangButtons) do
            button.BackgroundColor3 =
                language == code
                and accent
                or getTheme().Control
        end

        scale80.BackgroundColor3 =
            hubScale == 0.8
            and accent
            or getTheme().Control

        scale100.BackgroundColor3 =
            hubScale == 1
            and accent
            or getTheme().Control

        scale120.BackgroundColor3 =
            hubScale == 1.2
            and accent
            or getTheme().Control

        for _, refresh in ipairs(
            themeRefreshers
        ) do
            refresh()
        end
    end

    --------------------------------------------------
    -- FOV
    --------------------------------------------------

    local center =
        getFOVCenter()

    fovCircle.Position =
        UDim2.fromOffset(
            center.X,
            center.Y
        )

    fovCircle.Visible =
        showFOV
        and aimbotEnabled

    --------------------------------------------------
    -- FLY
    --------------------------------------------------

    if flying then
        local _, root, humanoid =
            getCharacter()

        if root and humanoid then
            local direction =
                Vector3.zero

            if UIS:IsKeyDown(
                Enum.KeyCode.W
            ) then
                direction +=
                    camera.CFrame.LookVector
            end

            if UIS:IsKeyDown(
                Enum.KeyCode.S
            ) then
                direction -=
                    camera.CFrame.LookVector
            end

            if UIS:IsKeyDown(
                Enum.KeyCode.A
            ) then
                direction -=
                    camera.CFrame.RightVector
            end

            if UIS:IsKeyDown(
                Enum.KeyCode.D
            ) then
                direction +=
                    camera.CFrame.RightVector
            end

            if UIS:IsKeyDown(
                Enum.KeyCode.Space
            ) then
                direction +=
                    Vector3.new(
                        0,
                        1,
                        0
                    )
            end

            if UIS:IsKeyDown(
                Enum.KeyCode.LeftShift
            ) then
                direction -=
                    Vector3.new(
                        0,
                        1,
                        0
                    )
            end

            if direction.Magnitude > 0 then
                direction =
                    direction.Unit

                _G.__EriusFlyHoldCFrame =
                    root.CFrame

                root.AssemblyLinearVelocity =
                    direction
                    *
                    flySpeed
            else
                root.AssemblyLinearVelocity =
                    Vector3.zero

                root.AssemblyAngularVelocity =
                    Vector3.zero

                if not _G.__EriusFlyHoldCFrame then
                    _G.__EriusFlyHoldCFrame =
                        root.CFrame
                end

                root.CFrame =
                    _G.__EriusFlyHoldCFrame
            end

            humanoid:ChangeState(
                Enum.HumanoidStateType.Freefall
            )
        end
    end

    --------------------------------------------------
    -- AIMBOT
    --------------------------------------------------

    local function hasClearShot(targetPlayer)
        if not targetPlayer or not targetPlayer.Character then
            return false
        end

        local targetHead = targetPlayer.Character:FindFirstChild("Head")
        local myCharacter = player.Character

        if not targetHead or not myCharacter then
            return false
        end

        local origin = camera.CFrame.Position
        local direction = targetHead.Position - origin

        if direction.Magnitude <= 0 then
            return false
        end

        local params = RaycastParams.new()
        params.FilterType = Enum.RaycastFilterType.Exclude
        params.FilterDescendantsInstances = {myCharacter}
        params.IgnoreWater = true

        local result = workspace:Raycast(origin, direction, params)

        if not result then
            return true
        end

        return result.Instance
            and result.Instance:IsDescendantOf(targetPlayer.Character)
    end

    local function triggerShoot()
        pcall(function()
            if type(mouse1click) == "function" then
                mouse1click()
                return
            end

            if type(mouse1press) == "function"
                and type(mouse1release) == "function" then

                mouse1press()
                task.wait(0.02)
                mouse1release()
                return
            end

            local virtualInput = game:GetService("VirtualInputManager")
            local pos = UIS:GetMouseLocation()

            virtualInput:SendMouseButtonEvent(
                pos.X,
                pos.Y,
                0,
                true,
                game,
                0
            )

            task.wait(0.02)

            virtualInput:SendMouseButtonEvent(
                pos.X,
                pos.Y,
                0,
                false,
                game,
                0
            )
        end)
    end

    if aimbotEnabled
        and rightMouseHeld then

        if currentTarget
            and validTarget(currentTarget) then

            local head =
                currentTarget.Character:
                FindFirstChild("Head")

            if head then
                camera.CFrame =
                    CFrame.new(
                        camera.CFrame.Position,
                        head.Position
                    )

                _G.__EriusAimLastLook =
                    camera.CFrame.LookVector

                local _, myRoot, myHumanoid =
                    getCharacter()

                if myRoot and myHumanoid then
                    if _G.__EriusAimWasAutoRotate == nil then
                        _G.__EriusAimWasAutoRotate =
                            myHumanoid.AutoRotate
                    end

                    myHumanoid.AutoRotate = false

                    -- Lock the character's yaw to the same direction
                    -- the aimbot/camera is currently aiming.
                    local cameraLook =
                        camera.CFrame.LookVector

                    local flatLook =
                        Vector3.new(
                            cameraLook.X,
                            0,
                            cameraLook.Z
                        )

                    if flatLook.Magnitude > 0.001 then
                        myRoot.CFrame =
                            CFrame.lookAt(
                                myRoot.Position,
                                myRoot.Position
                                    + flatLook.Unit
                            )

                        _G.__EriusAimLastLook =
                            cameraLook
                    end
                end
            end

        elseif targetSwitching then
            currentTarget =
                findClosestTarget()
        end
    end

    if triggerAimEnabled
        and aimbotEnabled
        and rightMouseHeld
        and currentTarget
        and validTarget(currentTarget) then

        if hasClearShot(currentTarget) then
            if triggerAimReadyAt == 0 then
                triggerAimReadyAt = tick() + triggerAimDelay
            elseif tick() >= triggerAimReadyAt then
                triggerShoot()
                triggerAimReadyAt = tick() + triggerAimDelay
            end
        else
            triggerAimReadyAt = 0
        end
    else
        triggerAimReadyAt = 0
    end

    --------------------------------------------------
    -- PLAYER ESP
    --------------------------------------------------

    for _, targetPlayer in ipairs(
        Players:GetPlayers()
    ) do
        if targetPlayer ~= player
            and targetPlayer.Character then

            local char =
                targetPlayer.Character

            local humanoid =
                char:
                FindFirstChildOfClass(
                    "Humanoid"
                )

            local sameTeam =
                player.Team ~= nil
                and targetPlayer.Team ~= nil
                and targetPlayer.Team
                    == player.Team

            local allowed =
                espSettings.PlayerESP
                and inESPRange(char)
                and (
                    not sameTeam
                    or espSettings.TeamESP
                )

            if allowed
                and humanoid then

                createESP(char)

                local data =
                    espObjects[char]

                if data then
                    data.Highlight.Enabled =
                        espSettings.Box

                    local lines = {}

                    if espSettings.Nicknames then
                        table.insert(
                            lines,
                            targetPlayer.DisplayName
                        )
                    end

                    if espSettings.HP then
                        table.insert(
                            lines,
                            "HP: "
                            .. math.floor(
                                humanoid.Health
                            )
                            .. "/"
                            .. math.floor(
                                humanoid.MaxHealth
                            )
                        )
                    end

                    data.Text.Text =
                        table.concat(
                            lines,
                            "\n"
                        )

                    data.Billboard.Enabled =
                        espSettings.Nicknames
                        or espSettings.HP
                end
            else
                clearESP(char)
            end
        end
    end
end)

--------------------------------------------------
-- BLUR LOOP
--------------------------------------------------

local lastBlurState =
    backgroundBlurEnabled

connect(
    RunService.Heartbeat,
    function()
        if not running then
            return
        end

        if lastBlurState
            ~= backgroundBlurEnabled then

            lastBlurState =
                backgroundBlurEnabled

            updateBlur()
        end
    end
)

--------------------------------------------------
-- CLICKER LOOP
--------------------------------------------------

connect(
    RunService.Heartbeat,
    function(dt)
        if not running then
            return
        end

        if clickerOpen
            and clickerEnabled then

            clickerAccumulator =
                clickerAccumulator
                +
                dt

            local interval =
                1
                /
                math.max(
                    clickerCPS,
                    1
                )

            local clicksThisFrame =
                0

            while clickerAccumulator
                >= interval
                and clicksThisFrame < 50 do

                clickerAccumulator =
                    clickerAccumulator
                    -
                    interval

                performClickerClick()

                clicksThisFrame =
                    clicksThisFrame
                    +
                    1
            end
        else
            clickerAccumulator =
                0
        end
    end
)

--------------------------------------------------
-- NOCLIP LOOP
--------------------------------------------------

connect(
    RunService.Stepped,
    function()
        if running
            and noclip then

            enableNoclip()
        end
    end
)

--------------------------------------------------
-- NPC ESP
--------------------------------------------------

local npcTimer = 0

connect(
    RunService.Heartbeat,
    function(dt)
        if not running then
            return
        end

        npcTimer += dt

        if npcTimer < 1 then
            return
        end

        npcTimer = 0

        if not espSettings.NPCESP then
            for model in pairs(
                espObjects
            ) do
                if model
                    and model.Parent
                    and not Players:
                    GetPlayerFromCharacter(
                        model
                    ) then

                    clearESP(model)
                end
            end

            return
        end

        for _, model in ipairs(
            workspace:GetDescendants()
        ) do
            if model:IsA("Model") then
                local humanoid =
                    model:
                    FindFirstChildOfClass(
                        "Humanoid"
                    )

                local root =
                    model:
                    FindFirstChild(
                        "HumanoidRootPart"
                    )

                if humanoid
                    and root
                    and not Players:
                    GetPlayerFromCharacter(
                        model
                    ) then

                    if inESPRange(model) then
                        createESP(model)

                        local data =
                            espObjects[model]

                        if data then
                            data.Highlight.Enabled =
                                espSettings.Box

                            local lines = {}

                            if espSettings.Nicknames then
                                table.insert(
                                    lines,
                                    model.Name
                                )
                            end

                            if espSettings.HP then
                                table.insert(
                                    lines,
                                    "HP: "
                                    .. math.floor(
                                        humanoid.Health
                                    )
                                    .. "/"
                                    .. math.floor(
                                        humanoid.MaxHealth
                                    )
                                )
                            end

                            data.Text.Text =
                                table.concat(
                                    lines,
                                    "\n"
                                )

                            data.Billboard.Enabled =
                                espSettings.Nicknames
                                or espSettings.HP
                        end
                    else
                        clearESP(model)
                    end
                end
            end
        end
    end
)

--------------------------------------------------
-- RESPAWN
--------------------------------------------------

connect(
    player.CharacterAdded,
    function()
        originalCollisions = {}
        _G.__EriusFlyHoldCFrame = nil

        task.wait(1)

        if not running then
            return
        end

        if speedEnabled then
            local _, _, humanoid =
                getCharacter()

            if humanoid then
                humanoid.WalkSpeed =
                    runSpeed
            end
        end

        if invisible then
            setInvisible(true)
        end
    end
)

--------------------------------------------------
-- INPUT END / RANGE / COLOR
--------------------------------------------------

connect(
    UIS.InputEnded,
    function(input)
        if clickerOpen
            and clickerKey
            and _G.__EriusClickerMode == "Hold"
            and input.KeyCode == clickerKey then

            _G.__EriusClickerKeyHeld = false
            clickerEnabled = false
            clickerAccumulator = 0
            refreshClickerVisual()
        end

        if input.UserInputType
            == Enum.UserInputType.MouseButton2 then

            rightMouseHeld = false

            local _, myRoot, myHumanoid =
                getCharacter()

            if _G.__EriusAimLastLook then
                local releaseLook =
                    _G.__EriusAimLastLook

                if myRoot then
                    local characterLook =
                        myRoot.CFrame.LookVector

                    local horizontal =
                        Vector3.new(
                            characterLook.X,
                            0,
                            characterLook.Z
                        )

                    if horizontal.Magnitude > 0.001 then
                        local vertical =
                            math.clamp(
                                releaseLook.Y,
                                -0.98,
                                0.98
                            )

                        local horizontalScale =
                            math.sqrt(
                                math.max(
                                    0.001,
                                    1 - vertical * vertical
                                )
                            )

                        releaseLook =
                            Vector3.new(
                                horizontal.Unit.X * horizontalScale,
                                vertical,
                                horizontal.Unit.Z * horizontalScale
                            ).Unit
                    end
                end

                camera.CFrame =
                    CFrame.lookAt(
                        camera.CFrame.Position,
                        camera.CFrame.Position
                            + releaseLook
                    )

                _G.__EriusAimLastLook =
                    releaseLook
            end

            if myHumanoid then
                if _G.__EriusAimWasAutoRotate ~= nil then
                    myHumanoid.AutoRotate =
                        _G.__EriusAimWasAutoRotate
                else
                    myHumanoid.AutoRotate = true
                end
            end

            _G.__EriusAimWasAutoRotate = nil
            currentTarget = nil
        end

        if input.UserInputType
            == Enum.UserInputType.MouseButton1
            or input.UserInputType
            == Enum.UserInputType.Touch then

            slidingRange = false

            if _G.__EriusAimbotRange then
                _G.__EriusAimbotRange.Sliding = false
            end

            colorSliding = false

            if clickerDragging then
                local source =
                    clickerDragSource

                local wasMoved =
                    clickerMoved

                clickerDragging = false
                clickerDragSource = nil
                clickerDragStart = nil
                clickerStartPosition = nil

                if source == "minimize"
                    and not wasMoved then

                    setClickerMinimized(
                        not clickerMinimized
                    )
                end
            end
        end
    end
)

connect(
    UIS.InputChanged,
    function(input)
        if slidingRange then
            if input.UserInputType
                == Enum.UserInputType.MouseMovement
                or input.UserInputType
                == Enum.UserInputType.Touch then

                setRangeFromMouse(
                    input.Position.X
                )
            end
        end

        if _G.__EriusAimbotRange
            and _G.__EriusAimbotRange.Sliding then

            if input.UserInputType
                == Enum.UserInputType.MouseMovement
                or input.UserInputType
                == Enum.UserInputType.Touch then

                _G.__EriusAimbotRange.SetFromX(
                    input.Position.X
                )
            end
        end

        if colorSliding then
            if input.UserInputType
                == Enum.UserInputType.MouseMovement
                or input.UserInputType
                == Enum.UserInputType.Touch then

                setCustomColorFromX(
                    input.Position.X
                )
            end
        end

        if clickerDragging then
            if input.UserInputType
                == Enum.UserInputType.MouseMovement
                or input.UserInputType
                == Enum.UserInputType.Touch then

                updateClickerDrag(input)
            end
        end
    end
)

--------------------------------------------------
-- CLEANUP / LEAVE SCRIPT
--------------------------------------------------

local function cleanup()
    if not running then
        return
    end

    running = false
    flying = false
    noclip = false
    aimbotEnabled = false
    _G.__EriusInfiniteJump = false
    _G.__EriusInstantInteract = false

    if _G.__EriusRestoreInstantPrompts then
        _G.__EriusRestoreInstantPrompts()
    end

    triggerAimEnabled = false
    triggerAimReadyAt = 0

    clickerEnabled = false
    clickerOpen = false
    _G.__EriusClickerKeyHeld = false
    clickerKey = nil
    waitingForClickerKey = false
    clickerAccumulator = 0

    rightMouseHeld = false
    currentTarget = nil

    local _, root, humanoid =
        getCharacter()

    if root then
        root.AssemblyLinearVelocity =
            Vector3.zero
    end

    if humanoid then
        humanoid.WalkSpeed =
            normalSpeed
    end

    disableNoclip()

    if invisible then
        invisible = false

        local character =
            player.Character

        if character then
            for _, object in ipairs(
                character:GetDescendants()
            ) do
                if object:IsA("BasePart") then
                    object.LocalTransparencyModifier =
                        0
                elseif object:IsA("Decal") then
                    object.Transparency =
                        0
                end
            end
        end
    end

    clearAllESP()

    if blur then
        blur:Destroy()
    end

    if fovCircle then
        fovCircle:Destroy()
    end

    for _, connection in ipairs(
        connections
    ) do
        pcall(function()
            connection:Disconnect()
        end)
    end

    table.clear(connections)

    if gui then
        gui:Destroy()
    end
end

connect(
    leaveButton.MouseButton1Click,
    cleanup
)

--------------------------------------------------
-- MINIMIZE
--------------------------------------------------

local function setMinimized(state)
    minimized = state

    tabs.Visible = not minimized
    pages.Visible = not minimized
    credits.Visible = not minimized

    if minimized then
        main.Size =
            UDim2.fromOffset(
                130,
                75
            )

        title.Size =
            UDim2.new(
                1,
                0,
                1,
                0
            )

        title.Position =
            UDim2.fromOffset(
                0,
                0
            )

        title.Text =
            "Erius"

        title.TextSize =
            17

        title.TextXAlignment =
            Enum.TextXAlignment.Center

        title.TextYAlignment =
            Enum.TextYAlignment.Center

        minimize.Size =
            UDim2.fromScale(
                1,
                1
            )

        minimize.Position =
            UDim2.fromOffset(
                0,
                0
            )

        minimize.BackgroundTransparency =
            1

        minimize.Text =
            ""
    else
        main.Size =
            UDim2.fromOffset(
                430,
                650
            )

        title.Size =
            UDim2.new(
                1,
                -100,
                0,
                45
            )

        title.Position =
            UDim2.fromOffset(
                15,
                0
            )

        title.Text =
            "Erius"

        title.TextSize =
            22

        title.TextXAlignment =
            Enum.TextXAlignment.Left

        title.TextYAlignment =
            Enum.TextYAlignment.Center

        minimize.Size =
            UDim2.fromOffset(
                38,
                32
            )

        minimize.Position =
            UDim2.new(
                1,
                -45,
                0,
                7
            )

        minimize.BackgroundTransparency =
            0

        minimize.BackgroundColor3 =
            getTheme().Panel

        minimize.Text =
            "—"
    end
end

--------------------------------------------------
-- DRAG
--------------------------------------------------

local dragging = false
local dragStart
local startPosition
local moved = false
local dragSource

local function startDrag(input, source)
    _G.__EriusBringWindowToFront("Hub")

    dragging = true
    moved = false
    dragSource = source
    dragStart = input.Position
    startPosition = main.Position
end

local function updateDrag(input)
    if not dragging then
        return
    end

    local delta =
        input.Position
        -
        dragStart

    if math.abs(delta.X) > 5
        or math.abs(delta.Y) > 5 then

        moved = true
    end

    main.Position =
        UDim2.new(
            startPosition.X.Scale,
            startPosition.X.Offset + delta.X,
            startPosition.Y.Scale,
            startPosition.Y.Offset + delta.Y
        )
end

connect(
    minimize.InputBegan,
    function(input)
        if input.UserInputType
            == Enum.UserInputType.MouseButton1
            or input.UserInputType
            == Enum.UserInputType.Touch then

            startDrag(
                input,
                "minimize"
            )
        end
    end
)

connect(
    title.InputBegan,
    function(input)
        if minimized then
            return
        end

        if input.UserInputType
            == Enum.UserInputType.MouseButton1
            or input.UserInputType
            == Enum.UserInputType.Touch then

            startDrag(
                input,
                "title"
            )
        end
    end
)

connect(
    UIS.InputChanged,
    function(input)
        if input.UserInputType
            == Enum.UserInputType.MouseMovement
            or input.UserInputType
            == Enum.UserInputType.Touch then

            updateDrag(input)

            if _G.__EriusSteelDragging
                and _G.__EriusUpdateSteelDrag then

                _G.__EriusUpdateSteelDrag(input)
            end
        end
    end
)

connect(
    UIS.InputEnded,
    function(input)
        if input.UserInputType
            == Enum.UserInputType.MouseButton1
            or input.UserInputType
            == Enum.UserInputType.Touch then

            if _G.__EriusSteelDragging then
                local steelSource =
                    _G.__EriusSteelDragSource

                local steelMoved =
                    _G.__EriusSteelMoved

                _G.__EriusSteelDragging = false
                _G.__EriusSteelDragSource = nil
                _G.__EriusSteelDragStart = nil
                _G.__EriusSteelStartPosition = nil

                if steelSource == "minimize"
                    and not steelMoved
                    and _G.__EriusSetSteelMinimized then

                    _G.__EriusSetSteelMinimized(
                        not _G.__EriusSteelMinimized
                    )
                end
            end

            if dragging then
                local source =
                    dragSource

                local wasMoved =
                    moved

                dragging = false
                dragSource = nil
                dragStart = nil
                startPosition = nil

                if source
                    == "minimize"
                    and not wasMoved then

                    setMinimized(
                        not minimized
                    )
                end
            end
        end
    end
)