local Camera = workspace.CurrentCamera
local UIS = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer

-- ⚙️ CONFIGURATION
local Config = {
    AimbotEnabled = false,
    AimbotToggleMode = false,
    AimbotTeamCheck = true,
    WallCheck = true,
    FOV = 200,
    Smoothness = 8, -- Plus élevé = plus indétectable
    PredictionStrength = 0.12,
    TargetPart = "Head", -- Options: Head, Torso, HumanoidRootPart, UpperTorso, LowerTorso, LeftArm, RightArm, LeftLeg, RightLeg
    ShowFOV = true,
    IgnoreDistance = 500,
    ESPEnabled = true,
    ESPBoxes = true,
    ESPNames = true,
    ESPDistance = true,
    ESPHealth = true,
    ESPTeamCheck = true, -- Team check séparé pour ESP
    ESPTracers = false,
    ESPSkeletons = false,
    HumanizedAiming = true, -- Rend l'aim plus humain
    ShakeAmount = 2, -- Tremblement pour paraître humain
}

-- 🎯 Détection universelle des dossiers de personnages
local function findCharactersFolder()
    local possibleNames = {
        "Characters", "Mobs", "NPCs", "Players", "Entities", 
        "Living", "Creatures", "Humanoids", "Models"
    }
    
    for _, name in ipairs(possibleNames) do
        local folder = workspace:FindFirstChild(name)
        if folder then return folder end
    end
    
    return workspace -- Fallback sur workspace
end

local charsFolder = findCharactersFolder()

-- 🎨 FOV Circle
local FOVCircle = Drawing.new("Circle")
FOVCircle.Thickness = 1
FOVCircle.NumSides = 100
FOVCircle.Radius = Config.FOV
FOVCircle.Filled = false
FOVCircle.Color = Color3.fromRGB(255, 255, 255)
FOVCircle.Transparency = 0.7
FOVCircle.Visible = Config.ShowFOV

-- 📦 ESP Storage
local ESPObjects = {}

-- 🔄 Update FOV
RunService.RenderStepped:Connect(function()
    FOVCircle.Position = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    FOVCircle.Radius = Config.FOV
    FOVCircle.Visible = Config.ShowFOV
end)

-- 🔍 Trouver tous les personnages (universel)
local function getAllCharacters()
    local characters = {}
    
    -- Cherche dans le dossier détecté
    for _, obj in pairs(charsFolder:GetChildren()) do
        if obj:IsA("Model") and obj:FindFirstChildWhichIsA("Humanoid") then
            table.insert(characters, obj)
        end
    end
    
    -- Fallback : cherche dans tout le workspace
    if #characters == 0 then
        for _, obj in pairs(workspace:GetDescendants()) do
            if obj:IsA("Model") and obj:FindFirstChildWhichIsA("Humanoid") and obj ~= LocalPlayer.Character then
                table.insert(characters, obj)
            end
        end
    end
    
    return characters
end

-- 🧱 WALL CHECK (optimisé)
local function isVisible(targetPart)
    if not Config.WallCheck then return true end
    if not targetPart then return false end
    
    local origin = Camera.CFrame.Position
    local direction = (targetPart.Position - origin)
    
    local rayParams = RaycastParams.new()
    rayParams.FilterDescendantsInstances = {LocalPlayer.Character, charsFolder}
    rayParams.FilterType = Enum.RaycastFilterType.Exclude
    rayParams.IgnoreWater = true
    
    local rayResult = workspace:Raycast(origin, direction, rayParams)
    
    if rayResult and rayResult.Instance then
        local hitPart = rayResult.Instance
        -- Vérifie si on touche le personnage cible
        return hitPart:IsDescendantOf(targetPart.Parent)
    end
    
    return true
end

-- 🎯 Prédiction de mouvement
local function predictPosition(part)
    if not part or not part.Parent then return part.Position end
    
    local velocity = part.AssemblyLinearVelocity or part.Velocity or Vector3.new(0, 0, 0)
    local ping = game:GetService("Stats").Network.ServerStatsItem["Data Ping"]:GetValue() / 1000
    local predictionTime = ping + Config.PredictionStrength
    
    return part.Position + (velocity * predictionTime)
end

-- 🎲 Humanized aiming - ajoute du tremblement naturel
local function addHumanShake()
    if not Config.HumanizedAiming then return 0, 0 end
    
    local shakeX = (math.random() - 0.5) * Config.ShakeAmount
    local shakeY = (math.random() - 0.5) * Config.ShakeAmount
    
    return shakeX, shakeY
end

-- 👤 Vérifie si c'est un ennemi (séparé pour Aimbot et ESP)
local function isEnemy(character, useAimbotCheck)
    if not character then return false end
    
    local player = Players:GetPlayerFromCharacter(character)
    
    -- Si pas de joueur associé (NPC), considéré comme ennemi
    if not player then return true end
    
    -- Team check selon le mode (Aimbot ou ESP)
    local teamCheck = useAimbotCheck and Config.AimbotTeamCheck or Config.ESPTeamCheck
    
    if teamCheck and player.Team and LocalPlayer.Team then
        return player.Team ~= LocalPlayer.Team
    end
    
    return player ~= LocalPlayer
end

-- 🔍 Trouver la partie à viser selon la config
local function getTargetPart(character)
    -- Liste de priorités basée sur le choix de l'utilisateur
    local primaryTarget = Config.TargetPart
    
    -- Mappings pour différents types de rigs
    local partMappings = {
        ["Head"] = {"Head"},
        ["Torso"] = {"UpperTorso", "Torso", "HumanoidRootPart"},
        ["HumanoidRootPart"] = {"HumanoidRootPart", "Torso", "UpperTorso"},
        ["UpperTorso"] = {"UpperTorso", "Torso", "HumanoidRootPart"},
        ["LowerTorso"] = {"LowerTorso", "Torso", "HumanoidRootPart"},
        ["LeftArm"] = {"LeftUpperArm", "LeftLowerArm", "Left Arm"},
        ["RightArm"] = {"RightUpperArm", "RightLowerArm", "Right Arm"},
        ["LeftLeg"] = {"LeftUpperLeg", "LeftLowerLeg", "Left Leg"},
        ["RightLeg"] = {"RightUpperLeg", "RightLowerLeg", "Right Leg"},
    }
    
    -- Essaie d'abord les mappings spécifiques
    local possibleParts = partMappings[primaryTarget] or {primaryTarget}
    
    for _, partName in ipairs(possibleParts) do
        local part = character:FindFirstChild(partName)
        if part and part:IsA("BasePart") then
            return part
        end
    end
    
    -- Fallback universel
    local fallbackParts = {
        "Head", "UpperTorso", "HumanoidRootPart", "Torso",
        "Chest", "Center", "Top", "Middle"
    }
    
    for _, partName in ipairs(fallbackParts) do
        local part = character:FindFirstChild(partName)
        if part and part:IsA("BasePart") then
            return part
        end
    end
    
    -- Dernier recours : cherche n'importe quelle BasePart importante
    for _, child in pairs(character:GetDescendants()) do
        if child:IsA("BasePart") and child.Name:lower():find("head") then
            return child
        end
    end
    
    return character:FindFirstChildWhichIsA("BasePart")
end

-- 🔍 Trouver la cible la plus proche
local function getClosestEnemy()
    local closest = nil
    local minDist = math.huge
    local targetPart = nil
    local mousePos = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)

    for _, char in pairs(getAllCharacters()) do
        if char ~= LocalPlayer.Character and isEnemy(char, true) then -- true = utilise AimbotTeamCheck
            local part = getTargetPart(char)
            
            if part then
                local distance = (part.Position - Camera.CFrame.Position).Magnitude
                
                if distance <= Config.IgnoreDistance then
                    local predictedPos = predictPosition(part)
                    local pos, onScreen = Camera:WorldToViewportPoint(predictedPos)
                    
                    if onScreen and pos.Z > 0 then
                        local screenDist = (Vector2.new(pos.X, pos.Y) - mousePos).Magnitude
                        
                        if screenDist < Config.FOV and screenDist < minDist then
                            if isVisible(part) then
                                minDist = screenDist
                                closest = char
                                targetPart = part
                            end
                        end
                    end
                end
            end
        end
    end

    return closest, targetPart
end

-- 👁️ ESP SYSTEM (corrigé et universel)
local function createESP(character)
    if ESPObjects[character] or not character then return end
    
    local esp = {
        Box = Drawing.new("Square"),
        BoxOutline = Drawing.new("Square"),
        Name = Drawing.new("Text"),
        Distance = Drawing.new("Text"),
        HealthBar = Drawing.new("Line"),
        HealthBarOutline = Drawing.new("Line"),
        Tracer = Drawing.new("Line"),
    }
    
    -- Box
    esp.Box.Thickness = 1
    esp.Box.Filled = false
    esp.Box.Color = Color3.fromRGB(255, 255, 255)
    esp.Box.Transparency = 1
    esp.Box.Visible = false
    
    -- Box Outline
    esp.BoxOutline.Thickness = 3
    esp.BoxOutline.Filled = false
    esp.BoxOutline.Color = Color3.fromRGB(0, 0, 0)
    esp.BoxOutline.Transparency = 0.5
    esp.BoxOutline.Visible = false
    
    -- Name
    esp.Name.Size = 13
    esp.Name.Center = true
    esp.Name.Outline = true
    esp.Name.Font = 2
    esp.Name.Color = Color3.fromRGB(255, 255, 255)
    esp.Name.Visible = false
    
    -- Distance
    esp.Distance.Size = 12
    esp.Distance.Center = true
    esp.Distance.Outline = true
    esp.Distance.Font = 2
    esp.Distance.Color = Color3.fromRGB(200, 200, 200)
    esp.Distance.Visible = false
    
    -- Health Bar
    esp.HealthBar.Thickness = 2
    esp.HealthBar.Color = Color3.fromRGB(0, 255, 0)
    esp.HealthBar.Visible = false
    
    -- Health Bar Outline
    esp.HealthBarOutline.Thickness = 4
    esp.HealthBarOutline.Color = Color3.fromRGB(0, 0, 0)
    esp.HealthBarOutline.Transparency = 0.5
    esp.HealthBarOutline.Visible = false
    
    -- Tracer
    esp.Tracer.Thickness = 1
    esp.Tracer.Color = Color3.fromRGB(255, 255, 255)
    esp.Tracer.Transparency = 0.5
    esp.Tracer.Visible = false
    
    ESPObjects[character] = esp
end

local function removeESP(character)
    if ESPObjects[character] then
        for _, drawing in pairs(ESPObjects[character]) do
            pcall(function() drawing:Remove() end)
        end
        ESPObjects[character] = nil
    end
end

local function updateESP()
    if not Config.ESPEnabled then
        for char, _ in pairs(ESPObjects) do
            removeESP(char)
        end
        return
    end
    
    for character, esp in pairs(ESPObjects) do
        local success = pcall(function()
            if not character or not character.Parent then
                removeESP(character)
                return
            end
            
            -- Team check séparé pour ESP
            if not isEnemy(character, false) then -- false = utilise ESPTeamCheck
                for _, drawing in pairs(esp) do
                    drawing.Visible = false
                end
                return
            end
            
            local hrp = getTargetPart(character) or character:FindFirstChild("HumanoidRootPart")
            local head = character:FindFirstChild("Head")
            
            if not hrp then
                for _, drawing in pairs(esp) do
                    drawing.Visible = false
                end
                return
            end
            
            local distance = (hrp.Position - Camera.CFrame.Position).Magnitude
            
            if distance > Config.IgnoreDistance then
                for _, drawing in pairs(esp) do
                    drawing.Visible = false
                end
                return
            end
            
            -- Calculate positions
            local topPos = head and (head.Position + Vector3.new(0, head.Size.Y/2, 0)) or (hrp.Position + Vector3.new(0, 2, 0))
            local bottomPos = hrp.Position - Vector3.new(0, hrp.Size.Y, 0)
            
            local top2D, topOnScreen = Camera:WorldToViewportPoint(topPos)
            local bottom2D, bottomOnScreen = Camera:WorldToViewportPoint(bottomPos)
            
            if not topOnScreen or not bottomOnScreen or top2D.Z < 0 or bottom2D.Z < 0 then
                for _, drawing in pairs(esp) do
                    drawing.Visible = false
                end
                return
            end
            
            local height = math.abs(top2D.Y - bottom2D.Y)
            local width = height / 2
            
            -- Update Box
            if Config.ESPBoxes then
                esp.BoxOutline.Size = Vector2.new(width, height)
                esp.BoxOutline.Position = Vector2.new(top2D.X - width/2, top2D.Y)
                esp.BoxOutline.Visible = true
                
                esp.Box.Size = Vector2.new(width, height)
                esp.Box.Position = Vector2.new(top2D.X - width/2, top2D.Y)
                
                -- Couleur selon l'équipe
                local player = Players:GetPlayerFromCharacter(character)
                if player and player.Team then
                    esp.Box.Color = player.Team.TeamColor.Color
                else
                    esp.Box.Color = Color3.fromRGB(255, 255, 255)
                end
                
                esp.Box.Visible = true
            else
                esp.Box.Visible = false
                esp.BoxOutline.Visible = false
            end
            
            -- Update Name
            if Config.ESPNames then
                local displayName = character.Name
                local player = Players:GetPlayerFromCharacter(character)
                if player then
                    displayName = player.DisplayName or player.Name
                    if player.Team then
                        displayName = displayName .. " [" .. player.Team.Name .. "]"
                    end
                end
                esp.Name.Text = displayName
                esp.Name.Position = Vector2.new(top2D.X, top2D.Y - 16)
                esp.Name.Visible = true
            else
                esp.Name.Visible = false
            end
            
            -- Update Distance
            if Config.ESPDistance then
                esp.Distance.Text = string.format("[%dm]", math.floor(distance))
                esp.Distance.Position = Vector2.new(top2D.X, bottom2D.Y + 2)
                esp.Distance.Visible = true
            else
                esp.Distance.Visible = false
            end
            
            -- Update Health Bar
            if Config.ESPHealth then
                local humanoid = character:FindFirstChildWhichIsA("Humanoid")
                if humanoid and humanoid.MaxHealth > 0 then
                    local healthPercent = math.clamp(humanoid.Health / humanoid.MaxHealth, 0, 1)
                    local barHeight = height * healthPercent
                    
                    esp.HealthBarOutline.From = Vector2.new(top2D.X - width/2 - 6, top2D.Y)
                    esp.HealthBarOutline.To = Vector2.new(top2D.X - width/2 - 6, top2D.Y + height)
                    esp.HealthBarOutline.Visible = true
                    
                    esp.HealthBar.From = Vector2.new(top2D.X - width/2 - 6, top2D.Y + height)
                    esp.HealthBar.To = Vector2.new(top2D.X - width/2 - 6, top2D.Y + height - barHeight)
                    esp.HealthBar.Color = Color3.fromRGB(
                        math.floor(255 * (1 - healthPercent)),
                        math.floor(255 * healthPercent),
                        0
                    )
                    esp.HealthBar.Visible = true
                else
                    esp.HealthBar.Visible = false
                    esp.HealthBarOutline.Visible = false
                end
            else
                esp.HealthBar.Visible = false
                esp.HealthBarOutline.Visible = false
            end
            
            -- Update Tracer
            if Config.ESPTracers then
                esp.Tracer.From = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y)
                esp.Tracer.To = Vector2.new(top2D.X, bottom2D.Y)
                esp.Tracer.Visible = true
            else
                esp.Tracer.Visible = false
            end
        end)
        
        if not success then
            removeESP(character)
        end
    end
end

-- Monitor pour nouveaux personnages
local function monitorCharacters()
    local lastCheck = tick()
    
    RunService.RenderStepped:Connect(function()
        if tick() - lastCheck > 1 then -- Check toutes les secondes
            lastCheck = tick()
            
            if Config.ESPEnabled then
                for _, char in pairs(getAllCharacters()) do
                    if not ESPObjects[char] then
                        createESP(char)
                    end
                end
            end
        end
    end)
end

monitorCharacters()

-- 🎮 GUI CREATION
local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "UniversalAimbot"
ScreenGui.ResetOnSpawn = false
ScreenGui.IgnoreGuiInset = true
pcall(function()
    ScreenGui.Parent = game:GetService("CoreGui")
end)
if not ScreenGui.Parent then
    ScreenGui.Parent = LocalPlayer:WaitForChild("PlayerGui")
end

-- Main Frame
local MainFrame = Instance.new("Frame")
MainFrame.Name = "MainFrame"
MainFrame.Size = UDim2.new(0, 420, 0, 620)
MainFrame.Position = UDim2.new(0.5, -210, 0.5, -310)
MainFrame.BackgroundColor3 = Color3.fromRGB(20, 20, 25)
MainFrame.BorderSizePixel = 0
MainFrame.Active = true
MainFrame.Draggable = true
MainFrame.Parent = ScreenGui

local UICorner = Instance.new("UICorner")
UICorner.CornerRadius = UDim.new(0, 10)
UICorner.Parent = MainFrame

-- Title Bar
local TitleBar = Instance.new("Frame")
TitleBar.Size = UDim2.new(1, 0, 0, 50)
TitleBar.BackgroundColor3 = Color3.fromRGB(30, 30, 35)
TitleBar.BorderSizePixel = 0
TitleBar.Parent = MainFrame

local TitleCorner = Instance.new("UICorner")
TitleCorner.CornerRadius = UDim.new(0, 10)
TitleCorner.Parent = TitleBar

local Title = Instance.new("TextLabel")
Title.Size = UDim2.new(1, -20, 1, 0)
Title.Position = UDim2.new(0, 20, 0, 0)
Title.BackgroundTransparency = 1
Title.Text = "🎯 UNIVERSAL AIMBOT + ESP"
Title.TextColor3 = Color3.fromRGB(255, 255, 255)
Title.TextSize = 18
Title.Font = Enum.Font.GothamBold
Title.TextXAlignment = Enum.TextXAlignment.Left
Title.Parent = TitleBar

-- Status Indicator
local StatusIndicator = Instance.new("Frame")
StatusIndicator.Size = UDim2.new(0, 12, 0, 12)
StatusIndicator.Position = UDim2.new(1, -25, 0.5, -6)
StatusIndicator.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
StatusIndicator.BorderSizePixel = 0
StatusIndicator.Parent = TitleBar

local StatusCorner = Instance.new("UICorner")
StatusCorner.CornerRadius = UDim.new(1, 0)
StatusCorner.Parent = StatusIndicator

-- Content Frame
local ContentFrame = Instance.new("ScrollingFrame")
ContentFrame.Size = UDim2.new(1, -20, 1, -70)
ContentFrame.Position = UDim2.new(0, 10, 0, 60)
ContentFrame.BackgroundTransparency = 1
ContentFrame.BorderSizePixel = 0
ContentFrame.ScrollBarThickness = 6
ContentFrame.ScrollBarImageColor3 = Color3.fromRGB(60, 60, 70)
ContentFrame.CanvasSize = UDim2.new(0, 0, 0, 1180)
ContentFrame.Parent = MainFrame

-- Function to create a section
local function createSection(title, yPos)
    local Section = Instance.new("Frame")
    Section.Size = UDim2.new(1, 0, 0, 35)
    Section.Position = UDim2.new(0, 0, 0, yPos)
    Section.BackgroundTransparency = 1
    Section.Parent = ContentFrame
    
    local SectionTitle = Instance.new("TextLabel")
    SectionTitle.Size = UDim2.new(1, 0, 1, 0)
    SectionTitle.BackgroundTransparency = 1
    SectionTitle.Text = title
    SectionTitle.TextColor3 = Color3.fromRGB(200, 200, 200)
    SectionTitle.TextSize = 15
    SectionTitle.Font = Enum.Font.GothamBold
    SectionTitle.TextXAlignment = Enum.TextXAlignment.Left
    SectionTitle.Parent = Section
end

-- Function to create a toggle
local function createToggle(name, yPos, defaultValue, callback)
    local Toggle = Instance.new("Frame")
    Toggle.Size = UDim2.new(1, 0, 0, 40)
    Toggle.Position = UDim2.new(0, 0, 0, yPos)
    Toggle.BackgroundColor3 = Color3.fromRGB(30, 30, 35)
    Toggle.BorderSizePixel = 0
    Toggle.Parent = ContentFrame
    
    local ToggleCorner = Instance.new("UICorner")
    ToggleCorner.CornerRadius = UDim.new(0, 8)
    ToggleCorner.Parent = Toggle
    
    local Label = Instance.new("TextLabel")
    Label.Size = UDim2.new(1, -60, 1, 0)
    Label.Position = UDim2.new(0, 15, 0, 0)
    Label.BackgroundTransparency = 1
    Label.Text = name
    Label.TextColor3 = Color3.fromRGB(220, 220, 220)
    Label.TextSize = 13
    Label.Font = Enum.Font.Gotham
    Label.TextXAlignment = Enum.TextXAlignment.Left
    Label.Parent = Toggle
    
    local Button = Instance.new("TextButton")
    Button.Size = UDim2.new(0, 45, 0, 24)
    Button.Position = UDim2.new(1, -55, 0.5, -12)
    Button.BackgroundColor3 = defaultValue and Color3.fromRGB(0, 200, 100) or Color3.fromRGB(60, 60, 70)
    Button.Text = defaultValue and "ON" or "OFF"
    Button.TextColor3 = Color3.fromRGB(255, 255, 255)
    Button.TextSize = 11
    Button.Font = Enum.Font.GothamBold
    Button.BorderSizePixel = 0
    Button.Parent = Toggle
    
    local ButtonCorner = Instance.new("UICorner")
    ButtonCorner.CornerRadius = UDim.new(0, 6)
    ButtonCorner.Parent = Button
    
    local isEnabled = defaultValue
    
    Button.MouseButton1Click:Connect(function()
        isEnabled = not isEnabled
        Button.BackgroundColor3 = isEnabled and Color3.fromRGB(0, 200, 100) or Color3.fromRGB(60, 60, 70)
        Button.Text = isEnabled and "ON" or "OFF"
        callback(isEnabled)
    end)
end

-- Function to create a slider
local function createSlider(name, yPos, min, max, default, callback)
    local Slider = Instance.new("Frame")
    Slider.Size = UDim2.new(1, 0, 0, 55)
    Slider.Position = UDim2.new(0, 0, 0, yPos)
    Slider.BackgroundColor3 = Color3.fromRGB(30, 30, 35)
    Slider.BorderSizePixel = 0
    Slider.Parent = ContentFrame
    
    local SliderCorner = Instance.new("UICorner")
    SliderCorner.CornerRadius = UDim.new(0, 8)
    SliderCorner.Parent = Slider
    
    local Label = Instance.new("TextLabel")
    Label.Size = UDim2.new(1, -30, 0, 22)
    Label.Position = UDim2.new(0, 15, 0, 5)
    Label.BackgroundTransparency = 1
    Label.Text = name
    Label.TextColor3 = Color3.fromRGB(220, 220, 220)
    Label.TextSize = 13
    Label.Font = Enum.Font.Gotham
    Label.TextXAlignment = Enum.TextXAlignment.Left
    Label.Parent = Slider
    
    local ValueLabel = Instance.new("TextLabel")
    ValueLabel.Size = UDim2.new(0, 50, 0, 22)
    ValueLabel.Position = UDim2.new(1, -65, 0, 5)
    ValueLabel.BackgroundTransparency = 1
    ValueLabel.Text = tostring(default)
    ValueLabel.TextColor3 = Color3.fromRGB(100, 200, 255)
    ValueLabel.TextSize = 13
    ValueLabel.Font = Enum.Font.GothamBold
    ValueLabel.TextXAlignment = Enum.TextXAlignment.Right
    ValueLabel.Parent = Slider
    
    local SliderBar = Instance.new("Frame")
    SliderBar.Size = UDim2.new(1, -30, 0, 6)
    SliderBar.Position = UDim2.new(0, 15, 1, -18)
    SliderBar.BackgroundColor3 = Color3.fromRGB(50, 50, 60)
    SliderBar.BorderSizePixel = 0
    SliderBar.Parent = Slider
    
    local BarCorner = Instance.new("UICorner")
    BarCorner.CornerRadius = UDim.new(1, 0)
    BarCorner.Parent = SliderBar
    
    local Fill = Instance.new("Frame")
    Fill.Size = UDim2.new((default - min) / (max - min), 0, 1, 0)
    Fill.BackgroundColor3 = Color3.fromRGB(100, 150, 255)
    Fill.BorderSizePixel = 0
    Fill.Parent = SliderBar
    
    local FillCorner = Instance.new("UICorner")
    FillCorner.CornerRadius = UDim.new(1, 0)
    FillCorner.Parent = Fill
    
    local Dragging = false
    
    local function updateSlider(input)
        local pos = math.clamp((input.Position.X - SliderBar.AbsolutePosition.X) / SliderBar.AbsoluteSize.X, 0, 1)
        local value = math.floor(min + (max - min) * pos)
        Fill.Size = UDim2.new(pos, 0, 1, 0)
        ValueLabel.Text = tostring(value)
        callback(value)
    end
    
    SliderBar.InputBegan:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1 then
            Dragging = true
            updateSlider(input)
        end
    end)
    
    SliderBar.InputEnded:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1 then
            Dragging = false
        end
    end)
    
    UIS.InputChanged:Connect(function(input)
        if Dragging and input.UserInputType == Enum.UserInputType.MouseMovement then
            updateSlider(input)
        end
    end)
end

-- Create GUI Elements
createSection("⚙️ AIMBOT SETTINGS", 10)

createToggle("Toggle Mode (Click Lock)", 50, Config.AimbotToggleMode, function(value)
    Config.AimbotToggleMode = value
    if not value then Config.AimbotEnabled = false end
end)

createToggle("Aimbot Team Check", 100, Config.AimbotTeamCheck, function(value)
    Config.AimbotTeamCheck = value
end)

createToggle("Wall Check", 150, Config.WallCheck, function(value)
    Config.WallCheck = value
end)

createToggle("Show FOV Circle", 200, Config.ShowFOV, function(value)
    Config.ShowFOV = value
end)

createToggle("Humanized Aiming", 250, Config.HumanizedAiming, function(value)
    Config.HumanizedAiming = value
end)

-- Target Part Selector
local TargetFrame = Instance.new("Frame")
TargetFrame.Size = UDim2.new(1, 0, 0, 100)
TargetFrame.Position = UDim2.new(0, 0, 0, 300)
TargetFrame.BackgroundColor3 = Color3.fromRGB(30, 30, 35)
TargetFrame.BorderSizePixel = 0
TargetFrame.Parent = ContentFrame

local TargetCorner = Instance.new("UICorner")
TargetCorner.CornerRadius = UDim.new(0, 8)
TargetCorner.Parent = TargetFrame

local TargetLabel = Instance.new("TextLabel")
TargetLabel.Size = UDim2.new(1, -30, 0, 25)
TargetLabel.Position = UDim2.new(0, 15, 0, 10)
TargetLabel.BackgroundTransparency = 1
TargetLabel.Text = "Target Body Part"
TargetLabel.TextColor3 = Color3.fromRGB(220, 220, 220)
TargetLabel.TextSize = 13
TargetLabel.Font = Enum.Font.Gotham
TargetLabel.TextXAlignment = Enum.TextXAlignment.Left
TargetLabel.Parent = TargetFrame

local TargetValue = Instance.new("TextLabel")
TargetValue.Size = UDim2.new(0, 100, 0, 25)
TargetValue.Position = UDim2.new(1, -115, 0, 10)
TargetValue.BackgroundTransparency = 1
TargetValue.Text = Config.TargetPart
TargetValue.TextColor3 = Color3.fromRGB(100, 200, 255)
TargetValue.TextSize = 13
TargetValue.Font = Enum.Font.GothamBold
TargetValue.TextXAlignment = Enum.TextXAlignment.Right
TargetValue.Parent = TargetFrame

-- Buttons grid for body parts
local bodyParts = {
    {"Head", "Torso", "HumanoidRootPart"},
    {"UpperTorso", "LowerTorso"},
    {"LeftArm", "RightArm", "LeftLeg", "RightLeg"}
}

local buttonY = 45
for rowIndex, row in ipairs(bodyParts) do
    local buttonX = 15
    local buttonWidth = (380 - 30 - (#row - 1) * 5) / #row
    
    for _, partName in ipairs(row) do
        local Button = Instance.new("TextButton")
        Button.Size = UDim2.new(0, buttonWidth, 0, 25)
        Button.Position = UDim2.new(0, buttonX, 0, buttonY)
        Button.BackgroundColor3 = Config.TargetPart == partName and Color3.fromRGB(0, 200, 100) or Color3.fromRGB(50, 50, 60)
        Button.Text = partName
        Button.TextColor3 = Color3.fromRGB(255, 255, 255)
        Button.TextSize = 10
        Button.Font = Enum.Font.Gotham
        Button.BorderSizePixel = 0
        Button.Parent = TargetFrame
        
        local BtnCorner = Instance.new("UICorner")
        BtnCorner.CornerRadius = UDim.new(0, 4)
        BtnCorner.Parent = Button
        
        Button.MouseButton1Click:Connect(function()
            Config.TargetPart = partName
            TargetValue.Text = partName
            
            -- Update all buttons
            for _, child in pairs(TargetFrame:GetChildren()) do
                if child:IsA("TextButton") then
                    child.BackgroundColor3 = child.Text == partName and Color3.fromRGB(0, 200, 100) or Color3.fromRGB(50, 50, 60)
                end
            end
        end)
        
        buttonX = buttonX + buttonWidth + 5
    end
    
    buttonY = buttonY + 30
end

createSection("🎯 AIM SETTINGS", 410)

createSlider("FOV Radius", 450, 50, 500, Config.FOV, function(value)
    Config.FOV = value
end)

createSlider("Smoothness", 515, 1, 20, Config.Smoothness, function(value)
    Config.Smoothness = value
end)

createSlider("Max Distance", 580, 100, 1000, Config.IgnoreDistance, function(value)
    Config.IgnoreDistance = value
end)

createSlider("Prediction", 645, 0, 300, math.floor(Config.PredictionStrength * 1000), function(value)
    Config.PredictionStrength = value / 1000
end)

createSlider("Shake Amount", 710, 0, 10, Config.ShakeAmount, function(value)
    Config.ShakeAmount = value
end)

createSection("👁️ ESP SETTINGS", 785)

createToggle("ESP Enabled", 825, Config.ESPEnabled, function(value)
    Config.ESPEnabled = value
end)

createToggle("ESP Team Check", 875, Config.ESPTeamCheck, function(value)
    Config.ESPTeamCheck = value
end)

createToggle("Show Boxes", 925, Config.ESPBoxes, function(value)
    Config.ESPBoxes = value
end)

createToggle("Show Names", 975, Config.ESPNames, function(value)
    Config.ESPNames = value
end)

createToggle("Show Distance", 1025, Config.ESPDistance, function(value)
    Config.ESPDistance = value
end)

createToggle("Show Health", 1075, Config.ESPHealth, function(value)
    Config.ESPHealth = value
end)

createToggle("Show Tracers", 1125, Config.ESPTracers, function(value)
    Config.ESPTracers = value
end)

-- Info Label
local InfoLabel = Instance.new("TextLabel")
InfoLabel.Size = UDim2.new(1, -20, 0, 35)
InfoLabel.Position = UDim2.new(0, 10, 1, -45)
InfoLabel.BackgroundColor3 = Color3.fromRGB(40, 40, 50)
InfoLabel.Text = "K = Toggle GUI | Right Click = Aim"
InfoLabel.TextColor3 = Color3.fromRGB(150, 150, 150)
InfoLabel.TextSize = 11
InfoLabel.Font = Enum.Font.Gotham
InfoLabel.BorderSizePixel = 0
InfoLabel.Parent = MainFrame

local InfoCorner = Instance.new("UICorner")
InfoCorner.CornerRadius = UDim.new(0, 6)
InfoCorner.Parent = InfoLabel

-- Toggle GUI
local guiVisible = true
UIS.InputBegan:Connect(function(input, processed)
    if processed then return end
    
    if input.KeyCode == Enum.KeyCode.K then
        guiVisible = not guiVisible
        MainFrame.Visible = guiVisible
    end
    
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        if Config.AimbotToggleMode then
            Config.AimbotEnabled = not Config.AimbotEnabled
        else
            Config.AimbotEnabled = true
        end
        
        if Config.AimbotEnabled then
            FOVCircle.Color = Color3.fromRGB(0, 255, 0)
            StatusIndicator.BackgroundColor3 = Color3.fromRGB(0, 255, 0)
        else
            FOVCircle.Color = Color3.fromRGB(255, 255, 255)
            StatusIndicator.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
        end
    end
end)

UIS.InputEnded:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        if not Config.AimbotToggleMode then
            Config.AimbotEnabled = false
            FOVCircle.Color = Color3.fromRGB(255, 255, 255)
            StatusIndicator.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
        end
    end
end)

-- Aimbot loop principal
local currentTarget = nil
local lastAimTime = 0
RunService.RenderStepped:Connect(function()
    -- Update ESP
    updateESP()
    
    -- Aimbot
    if Config.AimbotEnabled then
        local target, part = getClosestEnemy()
        
        if target and part then
            currentTarget = part
            
            local predictedPos = predictPosition(part)
            local screenPos, onScreen = Camera:WorldToViewportPoint(predictedPos)
            
            if onScreen and screenPos.Z > 0 then
                local mouse = UIS:GetMouseLocation()
                local delta = (Vector2.new(screenPos.X, screenPos.Y) - mouse) / Config.Smoothness
                
                -- Ajoute tremblement humain
                local shakeX, shakeY = addHumanShake()
                delta = delta + Vector2.new(shakeX, shakeY)
                
                -- Délai aléatoire pour paraître humain (anti-detection)
                local currentTime = tick()
                if currentTime - lastAimTime > 0.016 then -- ~60 FPS max
                    lastAimTime = currentTime
                    
                    delta = Vector2.new(
                        math.clamp(delta.X, -50, 50),
                        math.clamp(delta.Y, -50, 50)
                    )
                    
                    pcall(function()
                        mousemoverel(delta.X, delta.Y)
                    end)
                end
            end
        else
            currentTarget = nil
        end
    else
        currentTarget = nil
    end
end)

print("✅ Universal Aimbot + ESP loaded!")
print("🎯 Press K to toggle menu")
print("🖱️ Hold Right Click to aim")
print("🌍 Works on ALL Roblox games!")