local Fluent = loadstring(game:HttpGet("https://[Log in to view URL]"))()
local SaveManager = loadstring(game:HttpGet("https://[Log in to view URL]"))()
local InterfaceManager = loadstring(game:HttpGet("https://[Log in to view URL]"))()

local Window = Fluent:CreateWindow({
    Title = "ManagerEP",
    SubTitle = "by xmanuel",
    TabWidth = 160,
    Size = UDim2.fromOffset(580, 460),
    Acrylic = true,
    Theme = "Dark",
    MinimizeKey = Enum.KeyCode.LeftControl
})

local Tabs = {
    Main = Window:AddTab({ Title = "Main", Icon = "house" }),
    Settings = Window:AddTab({ Title = "Settings", Icon = "settings" }),
    Player = Window:AddTab({ Title = "Player", Icon = "user-cog" }),
    ESP = Window:AddTab({ Title = "ESP", Icon = "glasses" }),
    Aimbot = Window:AddTab({ Title = "Aimbot" }),
    Teams = Window:AddTab({ Title = "Teams" })
}

-- Terms of Use Dialog
local function showTermsDialog()
    Window:Dialog({
        Title = "Do you accept the Terms of Use?",
        Content = "Never break rules, and ruin other players fun. Do not exploit expensive items.",
        Buttons = {
            {
                Title = "Accept",
                Callback = function()
                    Window:Dialog({
                        Title = "Thank You",
                        Content = "You have accepted the Terms of Use.",
                        Buttons = {
                            {
                                Title = "Close",
                                Callback = function()
                                    
                                end
                            }
                        }
                    })
                end
            },
            {
                Title = "Decline",
                Callback = function()
                    Window:Dialog({
                        Title = "Goodbye",
                        Content = "ManagerEP will now close.",
                        Buttons = {
                            {
                                Title = "Close",
                                Callback = function()
                                    Fluent:Destroy()  -- Closes the Fluent UI
                                end
                            }
                        }
                    })
                end
            }
        }
    })
end

-- Show Terms of Use before anything else
showTermsDialog()

-- Continue with the rest of the script
do
    Tabs.Main:AddParagraph({
        Title = "I know. There is not a lot",
        Content = "We are working on this script.\nTrust the process.!"
    })

    Tabs.Main:AddButton({
        Title = "Terms of Use",
        Description = "Read the terms again",
        Callback = function()
            showTermsDialog()
        end
    })


    local player = game.Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")

-- Add a health slider to the Main tab
local healthSlider = Tabs.Player:AddSlider("HealthSlider", {
    Title = "Player Health",
    Description = "Adjust the player's health",
    Default = humanoid.Health,  -- Default value is current health
    Min = 0,                    -- Minimum health
    Max = humanoid.MaxHealth,    -- Maximum health
    Rounding = 1,               -- Round to whole numbers
    Callback = function(Value)
        humanoid.Health = Value  -- Set player's health to slider value
        print("Health set to:", Value)
    end
})

Tabs.Player:AddButton({
    Title = "Instant Kill",
    Description = "Click to instantly kill the player",
    Callback = function()
        humanoid.Health = 0  -- Set the player's health to 0, causing instant death
        Fluent:Notify({
            Title = "Player Status",
            Content = "Player has been killed!",
            Duration = 5  -- Notification lasts 5 seconds
        })
    end
})

local speedSlider = Tabs.Player:AddSlider("SpeedSlider", {
    Title = "Player Speed",
    Description = "Adjust the player's walk speed",
    Default = humanoid.WalkSpeed,  -- Default to current walk speed
    Min = 0,                       -- Minimum speed
    Max = 100,                     -- Maximum speed
    Rounding = 1,                  -- Round to whole numbers
    Callback = function(Value)
        humanoid.WalkSpeed = Value  -- Set walk speed to slider value
        Fluent:Notify({
            Title = "Player Speed",
            Content = "Walk speed set to: " .. Value,
            Duration = 5
        })
    end
})

local jumpPowerSlider = Tabs.Player:AddSlider("JumpPowerSlider", {
    Title = "Player Jump Power",
    Description = "Adjust the player's jump power",
    Default = humanoid.JumpPower,  -- Default to current jump power
    Min = 0,                       -- Minimum jump power
    Max = 500,                     -- Maximum jump power
    Rounding = 1,                  -- Round to whole numbers
    Callback = function(Value)
        humanoid.JumpPower = Value  -- Set jump power to slider value
        Fluent:Notify({
            Title = "Player Jump Power",
            Content = "Jump power set to: " .. Value,
            Duration = 5
        })
    end
})

    Tabs.Player:AddButton({
    Title = "Instant Heal",
    Description = "Click to instantly heal the player",
    Callback = function()
        humanoid.Health = humanoid.MaxHealth  -- Restore health to max
        Fluent:Notify({
            Title = "Player Healed",
            Content = "Player has been fully healed!",
            Duration = 5  -- Notification lasts 5 seconds
        })
    end
})

Tabs.Player:AddButton({
    Title = "Reset Stats",
    Description = "Click to reset health, speed, and jump power to defaults",
    Callback = function()
        humanoid.Health = humanoid.MaxHealth      -- Reset health to maximum
        humanoid.WalkSpeed = 16                   -- Default walk speed
        humanoid.JumpPower = 50                   -- Default jump power
        Fluent:Notify({
            Title = "Stats Reset",
            Content = "Health, speed, and jump power have been reset!",
            Duration = 5  -- Notification lasts 5 seconds
        })
    end
})

Tabs.Player:AddButton({
    Title = "Sync Stats",
    Description = "Click to sync all sliders with the current player stats",
    Callback = function()
        -- Update the sliders with the current player stats
        speedSlider:SetValue(humanoid.WalkSpeed)        -- Sync speed slider
        jumpPowerSlider:SetValue(humanoid.JumpPower)    -- Sync jump power slider
        healthSlider:SetValue(humanoid.Health)           -- Sync health slider

        Fluent:Notify({
            Title = "Stats Synced",
            Content = "All sliders have been updated with current player stats!",
            Duration = 5  -- Notification lasts 5 seconds
        })
    end
})

local function updateSliders()
    if humanoid then
        speedSlider:SetValue(humanoid.WalkSpeed)
        jumpPowerSlider:SetValue(humanoid.JumpPower)
        healthSlider:SetValue(humanoid.Health)
    end
end

local invisibleToggle = Tabs.Main:AddToggle("Invisible", { Title = "Invisible Mode", Default = false })

invisibleToggle:OnChanged(function(state)
    if humanoid and humanoid.Parent then
        for _, part in pairs(humanoid.Parent:GetChildren()) do
            if part:IsA("BasePart") then
                part.Transparency = state and 1 or 0
            end
        end
    end
end)

local gravitySlider = Tabs.Main:AddSlider("GravitySlider", {
    Title = "Gravity",
    Description = "Adjust the game's gravity",
    Default = workspace.Gravity,
    Min = 0,
    Max = 500,
    Rounding = 1,
    Callback = function(Value)
        workspace.Gravity = Value
        Fluent:Notify({
            Title = "Gravity Adjusted",
            Content = "Gravity set to: " .. Value,
            Duration = 5
        })
    end
})

local nightVisionToggle = Tabs.Main:AddToggle("NightVision", { Title = "Night Vision", Default = false })

nightVisionToggle:OnChanged(function(state)
    if state then
        local nightVision = Instance.new("ColorCorrectionEffect")
        nightVision.Brightness = 0.2
        nightVision.Contrast = 1
        nightVision.Saturation = 0.1
        nightVision.TintColor = Color3.fromRGB(144, 238, 144)
        nightVision.Parent = game:GetService("Lighting")
    else
        for _, effect in pairs(game:GetService("Lighting"):GetChildren()) do
            if effect:IsA("ColorCorrectionEffect") then
                effect:Destroy()
            end
        end
    end
end)

local flyToggle = Tabs.Main:AddToggle("FlyToggle", { Title = "Fly Mode", Default = false })

local function enableFly()
    local flyPart = Instance.new("BodyVelocity")
    flyPart.Velocity = Vector3.new(0, 50, 0)  -- Adjust height
    flyPart.MaxForce = Vector3.new(100000, 100000, 100000)
    flyPart.Parent = humanoid.Parent:WaitForChild("HumanoidRootPart")
end

flyToggle:OnChanged(function(state)
    if state then
        enableFly()
        Fluent:Notify({
            Title = "Fly Mode",
            Content = "You are now flying!",
            Duration = 5
        })
    else
        humanoid.Parent:WaitForChild("HumanoidRootPart"):ClearAllChildren()
        Fluent:Notify({
            Title = "Fly Mode Disabled",
            Content = "Fly mode is now off.",
            Duration = 5
        })
    end
end)

local walkOnWaterToggle = Tabs.Main:AddToggle("WalkOnWater", { Title = "Walk on Water", Default = false })

walkOnWaterToggle:OnChanged(function(state)
    if state then
        humanoid:SetStateEnabled(Enum.HumanoidStateType.Swimming, false)
        Fluent:Notify({
            Title = "Walk on Water",
            Content = "You can now walk on water!",
            Duration = 5
        })
    else
        humanoid:SetStateEnabled(Enum.HumanoidStateType.Swimming, true)
        Fluent:Notify({
            Title = "Walk on Water Disabled",
            Content = "You can no longer walk on water.",
            Duration = 5
        })
    end
end)

local autoHealToggle = Tabs.Main:AddToggle("AutoHeal", { Title = "Auto-Heal", Default = false })

local function autoHeal()
    while autoHealToggle.Value do
        if humanoid.Health < humanoid.MaxHealth then
            humanoid.Health = humanoid.Health + 5
        end
        wait(1)
    end
end

autoHealToggle:OnChanged(function(state)
    if state then
        Fluent:Notify({
            Title = "Auto-Heal Enabled",
            Content = "You will be healed over time.",
            Duration = 5
        })
        autoHeal()
    else
        Fluent:Notify({
            Title = "Auto-Heal Disabled",
            Content = "Auto-Heal is now off.",
            Duration = 5
        })
    end
end)
-- Connect to CharacterAdded to update the humanoid reference
player.CharacterAdded:Connect(function(character)
    humanoid = character:WaitForChild("Humanoid")  -- Get new humanoid
    updateSliders()  -- Update sliders to match new character stats
end)

-- Initial slider values update
if player.Character then
    updateSliders()
end


-- Sync slider with current jump power
humanoid:GetPropertyChangedSignal("JumpPower"):Connect(function()
    jumpPowerSlider:SetValue(humanoid.JumpPower)
end)

-- Sync slider with current speed
humanoid:GetPropertyChangedSignal("WalkSpeed"):Connect(function()
    speedSlider:SetValue(humanoid.WalkSpeed)
end)

-- Update slider value if health changes in-game
humanoid:GetPropertyChangedSignal("Health"):Connect(function()
    healthSlider:SetValue(humanoid.Health)
end)

local espToggle = Tabs.ESP:AddToggle("ESP", { Title = "Player ESP", Default = false })

local function toggleESP(enabled)
    local players = game:GetService("Players")
    local localPlayer = players.LocalPlayer

    for _, player in pairs(players:GetPlayers()) do
        if player ~= localPlayer and player.Character then
            if enabled then
                local highlight = Instance.new("Highlight", player.Character)
                highlight.OutlineColor = Color3.fromRGB(255, 0, 0)  -- Red outline
                highlight.FillColor = Color3.fromRGB(0, 0, 0)  -- Optional fill color
                highlight.Adornee = player.Character
                player.CharacterAdded:Connect(function(character)
                    highlight.Adornee = character
                end)
            else
                -- Remove ESP if it was previously added
                for _, child in pairs(player.Character:GetChildren()) do
                    if child:IsA("Highlight") then
                        child:Destroy()
                    end
                end
            end
        end
    end
end

espToggle:OnChanged(function(state)
    toggleESP(state)
end)

-- Ensure ESP is removed when character respawns
Players.PlayerAdded:Connect(function(player)
    player.CharacterAdded:Connect(function(character)
        if espToggle.Value then
            toggleESP(true)
        end
    end)
end)

Tabs.Main:AddToggle("InfiniteJumpToggle", {Title = "Infinite Jump", Default = false}):OnChanged(function(enabled)
    if enabled then
        game:GetService("UserInputService").JumpRequest:Connect(function()
            game.Players.LocalPlayer.Character.Humanoid:ChangeState("Jumping")
        end)
    end
end)

-- Noclip
Tabs.Main:AddToggle("NoclipToggle", {Title = "Noclip", Default = false}):OnChanged(function(enabled)
    game:GetService("RunService").Stepped:Connect(function()
        if enabled then
            game.Players.LocalPlayer.Character.Humanoid:ChangeState(11)
        end
    end)
end)

-- ESP Toggle
Tabs.ESP:AddToggle("TeamESP", {Title = "Team ESP", Default = false}):OnChanged(function(enabled)
    if enabled then
        for _, player in pairs(game.Players:GetPlayers()) do
            if player.Team == game.Players.LocalPlayer.Team then
                -- Set ESP color green for teammates
            else
                -- Set ESP color red for enemies
            end
        end
    end
end)

-- Aimbot Headshot Priority
Tabs.Aimbot:AddToggle("HeadshotPriority", {Title = "Headshot Priority", Default = false}):OnChanged(function(enabled)
    if enabled then
        -- Modify aimbot targeting to prioritize headshots
    end
end)

-- Auto-Heal
Tabs.Main:AddToggle("AutoHealToggle", {Title = "Auto-Heal on Low Health", Default = false}):OnChanged(function(enabled)
    game:GetService("RunService").Heartbeat:Connect(function()
        if enabled and game.Players.LocalPlayer.Character.Humanoid.Health < 0.2 * game.Players.LocalPlayer.Character.Humanoid.MaxHealth then
            game.Players.LocalPlayer.Character.Humanoid.Health = game.Players.LocalPlayer.Character.Humanoid.MaxHealth
        end
    end)
end)

-- Team-Switch to Balance Players
Tabs.Teams:AddButton({Title = "Auto Team-Switch", Callback = function()
    local teams = game:GetService("Teams")
    local smallestTeam, minPlayers = nil, math.huge

    for _, team in pairs(teams:GetTeams()) do
        if #team:GetPlayers() < minPlayers then
            smallestTeam = team
            minPlayers = #team:GetPlayers()
        end
    end

    if smallestTeam then
        game.Players.LocalPlayer.Team = smallestTeam
    end
end})

-- Initial state based on toggle value
toggleESP(espToggle.Value)

    -- Other content here (toggles, sliders, etc.)
end

-- Addon and SaveManager/InterfaceManager initialization as before

SaveManager:SetLibrary(Fluent)
InterfaceManager:SetLibrary(Fluent)
SaveManager:IgnoreThemeSettings()
SaveManager:SetIgnoreIndexes({})
InterfaceManager:SetFolder("FluentScriptHub")
SaveManager:SetFolder("FluentScriptHub/specific-game")
InterfaceManager:BuildInterfaceSection(Tabs.Settings)
SaveManager:BuildConfigSection(Tabs.Settings)

Window:SelectTab(1)

Fluent:Notify({
    Title = "Fluent",
    Content = "The script has been loaded.",
    Duration = 8
})

SaveManager:LoadAutoloadConfig()