-- Stealth ESP with Visibility Toggle
--test
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera

-- Configuration
local ESP = {
    Enabled = true,
    TeamCheck = true,
    BoxColor = Color3.fromRGB(255, 70, 70),
    TextColor = Color3.fromRGB(255, 255, 255),
    BoxThickness = 1,
    TextSize = 14,
    MaxDistance = 8000,
    VisibilityCheck = false, -- Toggle for raycast checks
    UpdateInterval = 0.01,
    UseRandomOffset = true -- Makes patterns less detectable
}

-- Storage
local ESPStore = {}
local LastUpdate = 0

-- Create stealthy ESP elements
local function CreateStealthESP(player)
    if ESPStore[player] then return end
    
    local drawings = {
        box = Drawing.new("Quad"),
        name = Drawing.new("Text"),
        health = Drawing.new("Text"),
        lastSeen = 0,
        lastPos = Vector3.new()
    }
    
    -- Configure elements to look natural
    drawings.box.Thickness = ESP.BoxThickness
    drawings.box.Filled = false
    drawings.box.ZIndex = 2
    
    drawings.name.Size = ESP.TextSize
    drawings.name.Center = true
    drawings.name.Outline = true
    drawings.name.ZIndex = 3
    
    drawings.health.Size = ESP.TextSize - 2
    drawings.health.Center = true
    drawings.health.ZIndex = 3
    
    ESPStore[player] = drawings
end

-- Check if player is visible
local function IsVisible(character, origin)
    if not ESP.VisibilityCheck then return true end
    
    local params = RaycastParams.new()
    params.FilterDescendantsInstances = {character, LocalPlayer.Character}
    params.FilterType = Enum.RaycastFilterType.Blacklist
    
    local result = workspace:Raycast(origin, (character.HumanoidRootPart.Position - origin).Unit * 1000, params)
    return result and result.Instance:IsDescendantOf(character)
end

-- Update ESP elements with random variations
local function UpdateStealthESP()
    if not ESP.Enabled then
        for _, drawings in pairs(ESPStore) do
            drawings.box.Visible = false
            drawings.name.Visible = false
            drawings.health.Visible = false
        end
        return
    end

    local currentTime = tick()
    local cameraPos = Camera.CFrame.Position
    
    for player, drawings in pairs(ESPStore) do
        if player and player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
            local character = player.Character
            local rootPart = character.HumanoidRootPart
            local humanoid = character:FindFirstChildOfClass("Humanoid")
            
            -- Skip teammates if TeamCheck enabled
            if ESP.TeamCheck and player.Team == LocalPlayer.Team then
                drawings.box.Visible = false
                drawings.name.Visible = false
                drawings.health.Visible = false
                continue
            end
            
            -- Distance check
            local distance = (rootPart.Position - cameraPos).Magnitude
            if distance > ESP.MaxDistance then
                drawings.box.Visible = false
                drawings.name.Visible = false
                drawings.health.Visible = false
                continue
            end
            
            -- Visibility check
            local visible = IsVisible(character, cameraPos)
            local onScreen = true
            
            -- Position calculations with random offset
            if ESP.UseRandomOffset then
                drawings.lastPos = rootPart.Position + Vector3.new(
                    math.random() * 0.2 - 0.1,
                    math.random() * 0.2 - 0.1,
                    math.random() * 0.2 - 0.1
                )
            else
                drawings.lastPos = rootPart.Position
            end
            
            local rootPos, onScreen = Camera:WorldToViewportPoint(drawings.lastPos)
            
            if onScreen and (visible or not ESP.VisibilityCheck) then
                -- Update box
                local headPos = character:FindFirstChild("Head") and Camera:WorldToViewportPoint(character.Head.Position) or rootPos
                local boxSize = Vector2.new(
                    math.abs(headPos.X - rootPos.X) * 2.2,
                    math.abs(headPos.Y - rootPos.Y) * 3.5
                )
                
                drawings.box.PointA = Vector2.new(rootPos.X - boxSize.X/2, rootPos.Y - boxSize.Y/2)
                drawings.box.PointB = Vector2.new(rootPos.X + boxSize.X/2, rootPos.Y - boxSize.Y/2)
                drawings.box.PointC = Vector2.new(rootPos.X + boxSize.X/2, rootPos.Y + boxSize.Y/2)
                drawings.box.PointD = Vector2.new(rootPos.X - boxSize.X/2, rootPos.Y + boxSize.Y/2)
                drawings.box.Color = ESP.BoxColor
                drawings.box.Visible = true
                
                -- Update name
                drawings.name.Text = player.Name
                drawings.name.Position = Vector2.new(rootPos.X, rootPos.Y - boxSize.Y/2 - 18)
                drawings.name.Color = ESP.TextColor
                drawings.name.Visible = true
                
                -- Update health
                if humanoid then
                    drawings.health.Text = math.floor(humanoid.Health) .. " HP"
                    drawings.health.Position = Vector2.new(rootPos.X, rootPos.Y + boxSize.Y/2 + 5)
                    drawings.health.Color = Color3.fromHSV(humanoid.Health/humanoid.MaxHealth * 0.3, 1, 1)
                    drawings.health.Visible = true
                end
                
                drawings.lastSeen = currentTime
            else
                drawings.box.Visible = false
                drawings.name.Visible = false
                drawings.health.Visible = false
            end
        else
            drawings.box.Visible = false
            drawings.name.Visible = false
            drawings.health.Visible = false
        end
    end
end

-- Initialize
for _, player in ipairs(Players:GetPlayers()) do
    if player ~= LocalPlayer then
        CreateStealthESP(player)
    end
end

-- Player management
Players.PlayerAdded:Connect(function(player)
    CreateStealthESP(player)
end)

Players.PlayerRemoving:Connect(function(player)
    if ESPStore[player] then
        ESPStore[player].box:Remove()
        ESPStore[player].name:Remove()
        ESPStore[player].health:Remove()
        ESPStore[player] = nil
    end
end)

-- Optimized update loop
RunService.Heartbeat:Connect(function()
    if tick() - LastUpdate > ESP.UpdateInterval then
        UpdateStealthESP()
        LastUpdate = tick()
    end
end)

-- Control interface
return {
    Toggle = function(state)
        ESP.Enabled = state
    end,
    SetVisibilityCheck = function(state)
        ESP.VisibilityCheck = state
    end,
    Destroy = function()
        for _, drawings in pairs(ESPStore) do
            drawings.box:Remove()
            drawings.name:Remove()
            drawings.health:Remove()
        end
        ESPStore = {}
    end
}