-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]
-- Feel free to use this code
local Fluent = loadstring(game:HttpGet("https://github.com/dawid-scripts/Fluent/releases/latest/download/main.lua"))()
local SaveManager = loadstring(game:HttpGet("https://raw.githubusercontent.com/dawid-scripts/Fluent/master/Addons/SaveManager.lua"))()
local InterfaceManager = loadstring(game:HttpGet("https://raw.githubusercontent.com/dawid-scripts/Fluent/master/Addons/InterfaceManager.lua"))()

-- Services
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")

local LocalPlayer = Players.LocalPlayer

-- Unload Flag
local isUnloaded = false
local originalWalkSpeed = 16
local walkSpeedActive = false
local cleanupAntiInvisible = function() end -- Placeholder for cleanup

-- Connections
local jumpConn, pAddConn, pRemConn

-- Game Modules (Bypasses UI Remote fetching completely)
local PersonalRemoteService = assert(require(ReplicatedStorage:FindFirstChild("PersonalRemoteService", true)), "PersonalRemoteService not found")
local PlayerDataService = assert(require(ReplicatedStorage:FindFirstChild("PlrDataService", true)), "PlayerDataService not found")
local ShurikenService = assert(require(ReplicatedStorage:FindFirstChild("ShurikenService", true)), "ShurikenService not found")
local AscensionService = assert(require(ReplicatedStorage:FindFirstChild("AscensionService", true)), "AscensionService not found")
local UpgradeRules = assert(require(ReplicatedStorage:FindFirstChild("UpgradeRules", true)), "UpgradeRules not found")
local ClassService = assert(require(ReplicatedStorage:FindFirstChild("ClassService", true)), "ClassService not found")
local SwordService = assert(require(ReplicatedStorage:FindFirstChild("SwordService", true)), "SwordService not found")
local SuccessRate = assert(require(ReplicatedStorage:FindFirstChild("SuccessRate", true)), "SuccessRate not found")
local BucksConfig = assert(require(ReplicatedStorage:FindFirstChild("BucksConfig", true)), "BucksConfig not found")
local UIService = assert(require(ReplicatedStorage:FindFirstChild("UIService", true)), "UIService not found")

-- Game Functions & Data
local RemoteEvent = assert(PersonalRemoteService.RemoteEvent, "RemoteEvent not found")
local PlayerData = assert(PlayerDataService.PlrData, "PlayerData not found")
local GetFinalSuccessRate = assert(SuccessRate.GetFinalSuccessRate, "GetFinalSuccessRate not found")
local GetSuccessRate = assert(SuccessRate.GetSuccessRate, "GetSuccessRate not found")
local UIServiceInvokePersonalRemote = assert(UIService.InvokePersonalRemote, "InvokePersonalRemote for UIService not found")

-- Window Setup
local Window = Fluent:CreateWindow({
    Title = "+1 OP Ninja Hub",
    SubTitle = "Auto Farm, ESP & Teleport",
    TabWidth = 160,
    Size = UDim2.fromOffset(580, 460),
    Acrylic = true, 
    Theme = "Dark",
    MinimizeKey = Enum.KeyCode.LeftControl 
})

-- Tabs Setup
local Tabs = {
    Main = Window:AddTab({ Title = "Main", Icon = "sword" }),
    Visuals = Window:AddTab({ Title = "Visuals", Icon = "eye" }),
    Player = Window:AddTab({ Title = "Player", Icon = "user" }),
    Misc = Window:AddTab({ Title = "Misc", Icon = "cloud" }),
    Settings = Window:AddTab({ Title = "Settings", Icon = "settings" })
}

local Options = Fluent.Options

do
    Fluent:Notify({
        Title = "+1 OP Ninja Hub",
        Content = "Script loaded successfully!",
        SubContent = "All features initialized. Ready to use!",
        Duration = 5
    })

    -- ==================== //
    --       MAIN TAB       --
    -- ==================== //
    Tabs.Main:AddParagraph({
        Title = "Welcome to +1 OP Ninja Hub",
        Content = "Use the toggles below to automate your training and upgrades.\nNote: Auto Train requires your sword to be equipped!"
    })

    Tabs.Main:AddToggle("AutoTrain", {Title = "Auto Train", Default = false })
    Tabs.Main:AddToggle("AutoKill", {Title = "Auto Kill (HOLD SWORD)", Default = false })
    Tabs.Main:AddToggle("AutoDecline", {Title = "Auto Decline", Default = false })
    
    Tabs.Main:AddDropdown("AutoUpgradeDropdown", {
        Title = "Auto Upgrades",
        Description = "Select which upgrades to automate",
        Values = { "Sword", "Stars", "Class", "Ascendant" },
        Multi = true,
        Default = { "Sword", "Stars", "Class", "Ascendant" },
    })

    -- Auto Train Loop
    task.spawn(function()
        while task.wait(0.1) and not isUnloaded do
            if Options.AutoTrain.Value then
                pcall(function()
                    RemoteEvent:FireServer("SwordSlash", 67)
                end)
            end
        end
    end)

    -- Auto Kill Loop
    task.spawn(function()
        while task.wait(0.1) and not isUnloaded do
            if Options.AutoKill.Value then
                local lpChar = LocalPlayer.Character
                local lpHum = lpChar and lpChar:FindFirstChild("Humanoid")
                if lpChar and lpChar:FindFirstChild("HumanoidRootPart") and lpHum and lpHum.Health > 0 then
                    local tool = lpChar:FindFirstChildWhichIsA("Tool")
                    if tool then
                        for _, target in ipairs(Players:GetPlayers()) do
                            if not Options.AutoKill.Value then break end
                            if target ~= LocalPlayer and (target.Team == nil or target.Team ~= LocalPlayer.Team) then
                                local tChar = target.Character
                                if tChar then
                                    local tRoot = tChar:FindFirstChild("HumanoidRootPart")
                                    local tHum = tChar:FindFirstChild("Humanoid")
                                    if tRoot and tHum and tHum.Health > 0 then
                                        -- Teleport behind the player
                                        lpChar.HumanoidRootPart.CFrame = tRoot.CFrame * CFrame.new(0, 0, 4)
                                        
                                        -- Spam tool:Activate() for 1 second
                                        local startTime = tick()
                                        while tick() - startTime < 1 do
                                            if not Options.AutoKill.Value then break end
                                            
                                            -- Check Local Player
                                            if not lpChar or not lpChar.Parent then break end
                                            local lHum = lpChar:FindFirstChild("Humanoid")
                                            if not lHum or lHum.Health <= 0 then break end
                                            
                                            -- Check Target
                                            if not target or not target.Parent then break end
                                            if not tChar or not tChar.Parent then break end
                                            local tHumCheck = tChar:FindFirstChild("Humanoid")
                                            if not tHumCheck or tHumCheck.Health <= 0 then break end
                                            
                                            tool:Activate()
                                            task.wait(0.1)
                                        end
                                        
                                        -- Small delay before moving to next player
                                        task.wait(0.1)
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end)

    -- Auto Decline Loop
    task.spawn(function()
        while task.wait(0.1) and not isUnloaded do
            if Options.AutoDecline.Value then
                pcall(function()
                    LocalPlayer.PlayerGui.MainGui["64d781ce-77fc-417a-8531-b94d668fded7"]:InvokeServer("อัพเกรดดาบแม็กซ์")
                end)
            end
        end
    end)

    -- Auto Upgrade Loop
    task.spawn(function()
        while task.wait(0.1) and not isUnloaded do
            local SelectedUpgrades = Options.AutoUpgradeDropdown.Value
            
            if SelectedUpgrades["Sword"] then
                local NextSwordData = SwordService:GetNextSword()
                if NextSwordData and UpgradeRules.CanUpgrade(PlayerData, NextSwordData.Requirements) then
                    task.spawn(function()
                        pcall(function()
                            UIServiceInvokePersonalRemote("Max sword upgrade", "อัพเกรดดาบแม็กซ์")
                        end)
                    end)
                end
            end
            
            if SelectedUpgrades["Stars"] then
                local NextShurikenData = ShurikenService:GetNext()
                if NextShurikenData and UpgradeRules.CanUpgrade(PlayerData, NextShurikenData.Requirements) then
                    local rate = GetFinalSuccessRate(GetSuccessRate(NextShurikenData.SuccessRate, BucksConfig.HasGamepassBenefit(PlayerData, "x2Luck")) + (tonumber(PlayerData.ShPityRate) or 0))
                    task.spawn(function()
                        pcall(function()
                            UIServiceInvokePersonalRemote("Shuriken upgrade", "อัพเกรดดาวกระจาย", rate)
                        end)
                    end)
                end
            end
            
            if SelectedUpgrades["Class"] then
                local NextClassData = ClassService:GetNext(PlayerData.Class, PlayerData.ClassSubTier)
                if NextClassData and UpgradeRules.CanUpgrade(PlayerData, NextClassData.Requirements) then
                    local rate = GetFinalSuccessRate(GetSuccessRate(NextClassData.SuccessRate, BucksConfig.HasGamepassBenefit(PlayerData, "x2Luck")) + (tonumber(PlayerData.CPityRate) or 0))
                    task.spawn(function()
                        pcall(function()
                            UIServiceInvokePersonalRemote("Class upgrade", "อัพเกรดคลาส", rate)
                        end)
                    end)
                end
            end
            
            if SelectedUpgrades["Ascendant"] then
                local NextRealmData = AscensionService:GetNext(PlayerData.Ascension, PlayerData.AscensionSubTier)
                if NextRealmData and UpgradeRules.CanUpgrade(PlayerData, NextRealmData.Requirements) then
                    local rate = GetFinalSuccessRate(GetSuccessRate(NextRealmData.SuccessRate, BucksConfig.HasGamepassBenefit(PlayerData, "x2Luck")) + (tonumber(PlayerData.APityRate) or 0))
                    task.spawn(function()
                        pcall(function()
                            UIServiceInvokePersonalRemote("Ascension upgrade", "อัพเกรดแอสเซนต์", rate)
                        end)
                    end)
                end
            end
        end
    end)

    -- ==================== //
    --     VISUALS TAB      --
    -- ==================== //
    Tabs.Visuals:AddParagraph({
        Title = "ESP Settings",
        Content = "Customize what you see on other players."
    })

    Tabs.Visuals:AddToggle("ESPEnabled", {Title = "Enable ESP", Default = false})
    Tabs.Visuals:AddToggle("ESPName", {Title = "Show Names", Default = true})
    Tabs.Visuals:AddToggle("ESPDist", {Title = "Show Distance", Default = true})
    Tabs.Visuals:AddToggle("ESPBox", {Title = "Show Box (Highlight)", Default = true})

    Tabs.Visuals:AddParagraph({
        Title = "Visibility Settings",
        Content = "Force all player models to be visible."
    })

    Tabs.Visuals:AddToggle("AntiInvisible", {Title = "Anti-Invisible", Default = false})

    -- ANTI-INVISIBLE BYPASS LOGIC (Optimized & Hook-based)
    local antiInvisibleConn
    local playerAddedConn, playerRemovingConn
    local trackedInstances = {}
    local charConnections = {}
    local playerConnections = {}
    local PROPS_TO_BYPASS = {"Transparency", "Enabled", "Opacity", "Visible", "LocalTransparencyModifier"}

    local function addInstance(inst)
        if trackedInstances[inst] then return end
        
        local isTracked = false
        
        if inst:IsA("BasePart") or inst:IsA("Decal") or inst:IsA("Texture") then
            if inst.Name ~= "HumanoidRootPart" then
                isTracked = true
            end
        elseif inst:IsA("ParticleEmitter") or inst:IsA("Beam") or inst:IsA("Trail") or
               inst:IsA("Smoke") or inst:IsA("Fire") or inst:IsA("Sparkles") or 
               inst:IsA("Light") or inst:IsA("ForceField") or inst:IsA("Highlight") or 
               inst:IsA("BillboardGui") or inst:IsA("SurfaceGui") then
            isTracked = true
        end

        if isTracked then
            trackedInstances[inst] = true
            
            for _, prop in ipairs(PROPS_TO_BYPASS) do
                pcall(function()
                    inst:SetAttribute("PerformanceModeControls" .. prop, true)
                end)
            end
        end
    end

    local function removeInstance(inst)
        if trackedInstances[inst] then
            for _, prop in ipairs(PROPS_TO_BYPASS) do
                pcall(function()
                    inst:SetAttribute("PerformanceModeControls" .. prop, nil)
                end)
            end
            trackedInstances[inst] = nil
        end
    end

    local function hookCharacter(char)
        if not char then return end
        for _, desc in ipairs(char:GetDescendants()) do
            addInstance(desc)
        end
        local conn1 = char.DescendantAdded:Connect(addInstance)
        local conn2 = char.DescendantRemoving:Connect(removeInstance)
        charConnections[char] = {conn1, conn2}
    end

    local function unhookCharacter(char)
        if charConnections[char] then
            for _, conn in ipairs(charConnections[char]) do
                conn:Disconnect()
            end
            charConnections[char] = nil
        end
    end

    local function hookPlayer(player)
        if player.Character then
            hookCharacter(player.Character)
        end
        local conn1 = player.CharacterAdded:Connect(hookCharacter)
        local conn2 = player.CharacterRemoving:Connect(unhookCharacter)
        playerConnections[player] = {conn1, conn2}
    end

    local function unhookPlayer(player)
        if playerConnections[player] then
            for _, conn in ipairs(playerConnections[player]) do
                conn:Disconnect()
            end
            playerConnections[player] = nil
        end
        if player.Character then
            unhookCharacter(player.Character)
        end
    end

    cleanupAntiInvisible = function()
        if antiInvisibleConn then
            antiInvisibleConn:Disconnect()
            antiInvisibleConn = nil
        end
        if playerAddedConn then
            playerAddedConn:Disconnect()
            playerAddedConn = nil
        end
        if playerRemovingConn then
            playerRemovingConn:Disconnect()
            playerRemovingConn = nil
        end
        
        for player, _ in pairs(playerConnections) do
            unhookPlayer(player)
        end
        table.clear(playerConnections)
        table.clear(charConnections)
        
        for inst, _ in pairs(trackedInstances) do
            if inst and inst.Parent then
                for _, prop in ipairs(PROPS_TO_BYPASS) do
                    pcall(function()
                        inst:SetAttribute("PerformanceModeControls" .. prop, nil)
                    end)
                end
            end
        end
        table.clear(trackedInstances)
    end

    Options.AntiInvisible:OnChanged(function(state)
        if state then
            for _, player in ipairs(Players:GetPlayers()) do
                hookPlayer(player)
            end
            
            playerAddedConn = Players.PlayerAdded:Connect(hookPlayer)
            playerRemovingConn = Players.PlayerRemoving:Connect(function(player)
                unhookPlayer(player)
            end)
            
            antiInvisibleConn = RunService.RenderStepped:Connect(function()
                for inst, _ in pairs(trackedInstances) do
                    if inst.Parent then
                        -- Explicitly force our ESP elements to remain visible against the game's InvisibilityRenderer
                        if inst.Name == "ESPHighlight" and inst:IsA("Highlight") then
                            pcall(function()
                                inst.Enabled = true
                                inst.FillTransparency = 0.5
                                inst.OutlineTransparency = 0
                            end)
                        elseif inst.Name == "ESPNameTag" and inst:IsA("BillboardGui") then
                            pcall(function()
                                inst.Enabled = true
                            end)
                        else
                            local attrs = inst:GetAttributes()
                            for attrName, originalValue in pairs(attrs) do
                                if string.sub(attrName, 1, 20) == "InvisibilityOriginal" then
                                    local propName = string.sub(attrName, 21)
                                    pcall(function()
                                        inst[propName] = originalValue
                                    end)
                                end
                            end
                            
                            if inst:IsA("BasePart") and inst.Name ~= "HumanoidRootPart" then
                                if not attrs["InvisibilityOriginalLocalTransparencyModifier"] then
                                    pcall(function()
                                        inst.LocalTransparencyModifier = 0
                                    end)
                                end
                            end
                        end
                    else
                        trackedInstances[inst] = nil
                    end
                end
            end)
        else
            cleanupAntiInvisible()
        end
    end)

    -- FIXED ESP LOOP (Now ignores teammates and forces ESP visibility)
    task.spawn(function()
        while task.wait(0.1) and not isUnloaded do
            for _, player in ipairs(Players:GetPlayers()) do
                if player ~= LocalPlayer then
                    local char = player.Character
                    local valid = char and char:FindFirstChild("HumanoidRootPart")
                    
                    local isTeamMate = (player.Team ~= nil and player.Team == LocalPlayer.Team)
                    
                    if Options.ESPEnabled.Value and valid and not isTeamMate then
                        -- Handle Highlight
                        local hl = char:FindFirstChild("ESPHighlight")
                        if Options.ESPBox.Value then
                            if not hl then
                                hl = Instance.new("Highlight")
                                hl.Name = "ESPHighlight"
                                hl.FillColor = Color3.fromRGB(255, 0, 0)
                                hl.OutlineColor = Color3.fromRGB(255, 255, 255)
                                hl.FillTransparency = 0.5
                                hl.OutlineTransparency = 0
                                hl.Parent = char
                            else
                                -- Fallback to ensure ESP stays visible if game tries to hide it
                                pcall(function()
                                    hl.Enabled = true
                                    hl.FillTransparency = 0.5
                                    hl.OutlineTransparency = 0
                                end)
                            end
                        else
                            if hl then hl:Destroy() end
                        end
                        
                        -- Handle Billboard (Name/Distance)
                        local bb = char:FindFirstChild("ESPNameTag")
                        local showText = Options.ESPName.Value or Options.ESPDist.Value
                        
                        if showText then
                            if not bb then
                                bb = Instance.new("BillboardGui")
                                bb.Name = "ESPNameTag"
                                bb.Size = UDim2.new(0, 200, 0, 50)
                                bb.StudsOffset = Vector3.new(0, 3, 0)
                                bb.AlwaysOnTop = true
                                bb.Parent = char
                                
                                local lbl = Instance.new("TextLabel")
                                lbl.Name = "ESPLabel"
                                lbl.Size = UDim2.new(1, 0, 1, 0)
                                lbl.BackgroundTransparency = 1
                                lbl.TextColor3 = Color3.fromRGB(255, 255, 255)
                                lbl.TextStrokeTransparency = 0
                                lbl.TextScaled = true
                                lbl.Font = Enum.Font.SourceSansBold
                                lbl.Parent = bb
                            else
                                -- Fallback to ensure ESP stays visible
                                pcall(function()
                                    bb.Enabled = true
                                end)
                            end
                            
                            local txt = ""
                            if Options.ESPName.Value then txt = txt .. player.Name end
                            if Options.ESPDist.Value and LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart") then
                                local dist = math.floor((char.HumanoidRootPart.Position - LocalPlayer.Character.HumanoidRootPart.Position).Magnitude)
                                if txt ~= "" then txt = txt .. "\n" end
                                txt = txt .. "[" .. dist .. " studs]"
                            end
                            bb.ESPLabel.Text = txt
                        else
                            if bb then bb:Destroy() end
                        end
                    else
                        if char then
                            local hl = char:FindFirstChild("ESPHighlight")
                            local bb = char:FindFirstChild("ESPNameTag")
                            if hl then hl:Destroy() end
                            if bb then bb:Destroy() end
                        end
                    end
                end
            end
        end
    end)

    -- ==================== //
    --      PLAYER TAB      --
    -- ==================== //
    Tabs.Player:AddToggle("WalkSpeedToggle", {Title = "Enable WalkSpeed", Default = false})
    Tabs.Player:AddSlider("WalkSpeedSlider", {
        Title = "WalkSpeed Amount",
        Description = "Set your character's walkspeed",
        Default = 16,
        Min = 16,
        Max = 500,
        Rounding = 0
    })

    Tabs.Player:AddToggle("InfJump", {Title = "Infinite Jump", Default = false})

    task.spawn(function()
        while task.wait(0.1) and not isUnloaded do
            local char = LocalPlayer.Character
            if char and char:FindFirstChild("Humanoid") then
                if Options.WalkSpeedToggle.Value then
                    if not walkSpeedActive then
                        originalWalkSpeed = char.Humanoid.WalkSpeed
                        walkSpeedActive = true
                    end
                    char.Humanoid.WalkSpeed = Options.WalkSpeedSlider.Value
                else
                    if walkSpeedActive then
                        char.Humanoid.WalkSpeed = originalWalkSpeed
                        walkSpeedActive = false
                    end
                end
            end
        end
    end)

    jumpConn = UserInputService.JumpRequest:Connect(function()
        if not isUnloaded and Options.InfJump.Value then
            local char = LocalPlayer.Character
            if char and char:FindFirstChild("Humanoid") then
                char.Humanoid:ChangeState("Jumping")
            end
        end
    end)

    -- ==================== //
    -- TELEPORT TO PLAYERS  --
    -- ==================== //
    local function updatePlayerDropdown()
        if isUnloaded then return end
        local playerList = {}
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LocalPlayer then
                table.insert(playerList, p.Name)
            end
        end
        if Options.TpPlayerDropdown then
            Options.TpPlayerDropdown:SetValues(playerList)
        end
    end

    Tabs.Player:AddDropdown("TpPlayerDropdown", {
        Title = "Select Player",
        Values = {},
        Multi = false,
        Default = "",
    })

    updatePlayerDropdown()
    
    pAddConn = Players.PlayerAdded:Connect(updatePlayerDropdown)
    pRemConn = Players.PlayerRemoving:Connect(updatePlayerDropdown)

    Tabs.Player:AddButton({
        Title = "Teleport to Player",
        Callback = function()
            local targetName = Options.TpPlayerDropdown.Value
            local targetPlayer = Players:FindFirstChild(targetName)
            if targetPlayer and targetPlayer.Character and targetPlayer.Character:FindFirstChild("HumanoidRootPart") then
                local lpChar = LocalPlayer.Character
                if lpChar and lpChar:FindFirstChild("HumanoidRootPart") then
                    lpChar.HumanoidRootPart.CFrame = targetPlayer.Character.HumanoidRootPart.CFrame
                end
            else
                Fluent:Notify({
                    Title = "Teleport",
                    Content = "Invalid player or player has no character!",
                    Duration = 3
                })
            end
        end
    })

    -- ==================== //
    --       MISC TAB       --
    -- ==================== //
    Tabs.Misc:AddParagraph({
        Title = "Miscellaneous Features",
        Content = "Fun and utility features that don't fit anywhere else."
    })

    Tabs.Misc:AddToggle("Disable3DRendering", {
        Title = "Disable 3D Rendering",
        Default = false,
        Description = "Disables 3D rendering to significantly boost FPS."
    })

    Options.Disable3DRendering:OnChanged(function(state)
        RunService:Set3dRenderingEnabled(not state)
    end)

    Tabs.Misc:AddToggle("PathSystem", {
        Title = "Path", 
        Default = false,
        Description = "Spawns a fading path underneath you as you walk."
    })

    Tabs.Misc:AddColorpicker("PathColor", {
        Title = "Path Color",
        Default = Color3.fromRGB(255, 255, 255)
    })

    Tabs.Misc:AddSlider("PathTransparency", {
        Title = "Starting Transparency",
        Description = "Set the starting transparency of the path",
        Default = 0.75,
        Min = 0,
        Max = 1,
        Rounding = 2
    })

    Tabs.Misc:AddButton({
        Title = "Rejoin Server",
        Callback = function()
            game:GetService("TeleportService"):Teleport(game.PlaceId, LocalPlayer)
        end
    })

    Tabs.Misc:AddButton({
        Title = "Server Hop",
        Callback = function()
            local Http = game:GetService("HttpService")
            local servers = Http:JSONDecode(game:HttpGet("https://games.roblox.com/v1/games/" .. game.PlaceId .. "/servers/Public?sortOrder=Asc&limit=100")).data
            for _, server in ipairs(servers) do
                if server.id ~= game.JobId then
                    game:GetService("TeleportService"):TeleportToPlaceInstance(game.PlaceId, server.id, LocalPlayer)
                    break
                end
            end
        end
    })

    task.spawn(function()
        local lastPathTime = 0
        while task.wait(0.1) and not isUnloaded do
            if Options.PathSystem.Value then
                local char = LocalPlayer.Character
                if char and char:FindFirstChild("HumanoidRootPart") then
                    local currentTime = tick()
                    if currentTime - lastPathTime >= 0.025 then
                        lastPathTime = currentTime
                        
                        local part = Instance.new("Part")
                        part.Size = Vector3.new(6, 1, 6)
                        part.Color = Options.PathColor.Value
                        part.Position = char.HumanoidRootPart.Position - Vector3.new(0, 3, 0)
                        part.Rotation = Vector3.new(0, math.random(0, 360), 0)
                        part.Anchored = true
                        part.CanCollide = false
                        part.Material = Enum.Material.Neon
                        part.Transparency = Options.PathTransparency.Value
                        part.Parent = Workspace
                        
                        local tween = TweenService:Create(part, TweenInfo.new(4, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
                            Size = Vector3.new(0, 0, 0),
                            Transparency = 1
                        })
                        tween:Play()
                        
                        task.delay(4.1, function()
                            if part and part.Parent then
                                part:Destroy()
                            end
                        end)
                    end
                end
            end
        end
    end)
end

-- Addons Setup
SaveManager:SetLibrary(Fluent)
InterfaceManager:SetLibrary(Fluent)

SaveManager:IgnoreThemeSettings()
SaveManager:SetIgnoreIndexes({})

InterfaceManager:SetFolder("FluentScriptHub")
SaveManager:SetFolder("FluentScriptHub/op-ninja")

InterfaceManager:BuildInterfaceSection(Tabs.Settings)
SaveManager:BuildConfigSection(Tabs.Settings)

-- CORRECT HOOK: Hook Fluent.Destroy instead of Window.Destroy
local originalDestroy = Fluent.Destroy
Fluent.Destroy = function(self, ...)
    isUnloaded = true 
    
    cleanupAntiInvisible()
    
    RunService:Set3dRenderingEnabled(true)
    
    for _, player in ipairs(Players:GetPlayers()) do
        if player.Character then
            local hl = player.Character:FindFirstChild("ESPHighlight")
            local bb = player.Character:FindFirstChild("ESPNameTag")
            if hl then hl:Destroy() end
            if bb then bb:Destroy() end
        end
    end

    if walkSpeedActive then
        local char = LocalPlayer.Character
        if char and char:FindFirstChild("Humanoid") then
            char.Humanoid.WalkSpeed = originalWalkSpeed
        end
        walkSpeedActive = false
    end

    if jumpConn then jumpConn:Disconnect() end
    if pAddConn then pAddConn:Disconnect() end
    if pRemConn then pRemConn:Disconnect() end

    originalDestroy(self, ...)
end

Window:SelectTab(1)
SaveManager:LoadAutoloadConfig()