Look Line Open Source

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

local CONFIG = {
    LineDistance = 500,
    LineThickness = 2,
    LineThicknessAlert = 4,
    NormalColor = Color3.fromRGB(255, 80, 80),
    AlertColor = Color3.fromRGB(255, 0, 0),
    DetectionRadius = 3,
    EnableVFX = true,
    FlashSpeed = 8,
    VignetteIntensity = 0.3,
    HeadCircleRadius = 12,
    HeadBoxSize = 24,
}

local playerLines = {}
local playerHeadCircles = {}
local playerHeadBoxes = {}
local playerNameTags = {}
local warningUI = nil
local connections = {}
local isRunning = true

local function createWarningUI()
    local screenGui = Instance.new("ScreenGui")
    screenGui.Name = "LookWarningVFX"
    screenGui.ResetOnSpawn = false
    screenGui.IgnoreGuiInset = true
    screenGui.DisplayOrder = 999
    
    local vignette = Instance.new("Frame")
    vignette.Name = "Vignette"
    vignette.Size = UDim2.new(1, 0, 1, 0)
    vignette.BackgroundTransparency = 1
    vignette.BorderSizePixel = 0
    vignette.Parent = screenGui
    
    local warningText = Instance.new("TextLabel")
    warningText.Name = "WarningText"
    warningText.Size = UDim2.new(0, 300, 0, 50)
    warningText.Position = UDim2.new(0.5, -150, 0, 50)
    warningText.BackgroundTransparency = 1
    warningText.Text = "WARNING: SOMEONE IS LOOKING AT YOU"
    warningText.TextColor3 = Color3.fromRGB(255, 0, 0)
    warningText.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    warningText.TextStrokeTransparency = 0
    warningText.Font = Enum.Font.GothamBold
    warningText.TextSize = 24
    warningText.TextTransparency = 1
    warningText.Parent = screenGui
    
    local directionIndicator = Instance.new("TextLabel")
    directionIndicator.Name = "DirectionIndicator"
    directionIndicator.Size = UDim2.new(0, 200, 0, 30)
    directionIndicator.Position = UDim2.new(0.5, -100, 0, 95)
    directionIndicator.BackgroundTransparency = 1
    directionIndicator.Text = ""
    directionIndicator.TextColor3 = Color3.fromRGB(255, 150, 150)
    directionIndicator.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
    directionIndicator.TextStrokeTransparency = 0.5
    directionIndicator.Font = Enum.Font.Gotham
    directionIndicator.TextSize = 16
    directionIndicator.TextTransparency = 1
    directionIndicator.Parent = screenGui
    
    pcall(function()
        screenGui.Parent = game:GetService("CoreGui")
    end)
    
    if not screenGui.Parent then
        screenGui.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end
    
    return {
        Gui = screenGui,
        Vignette = vignette,
        Text = warningText,
        Direction = directionIndicator
    }
end

local function createDrawingLine()
    local line = Drawing.new("Line")
    line.Thickness = CONFIG.LineThickness
    line.Color = CONFIG.NormalColor
    line.Transparency = 0.8
    line.Visible = false
    return line
end

local function createHeadCircle()
    local circle = Drawing.new("Circle")
    circle.Radius = CONFIG.HeadCircleRadius
    circle.Color = CONFIG.NormalColor
    circle.Thickness = 2
    circle.Filled = false
    circle.Transparency = 0.8
    circle.Visible = false
    return circle
end

local function createHeadBox()
    local lines = {}
    for i = 1, 4 do
        local line = Drawing.new("Line")
        line.Thickness = 2
        line.Color = CONFIG.NormalColor
        line.Transparency = 0.8
        line.Visible = false
        table.insert(lines, line)
    end
    return lines
end

local function createNameTag()
    local text = Drawing.new("Text")
    text.Size = 14
    text.Color = Color3.fromRGB(255, 255, 255)
    text.Center = true
    text.Outline = true
    text.OutlineColor = Color3.fromRGB(0, 0, 0)
    text.Visible = false
    return text
end

local function checkIfLookingAtMe(player)
    local character = player.Character
    local myCharacter = LocalPlayer.Character
    
    if not character or not myCharacter then 
        return false, nil, nil 
    end
    
    local head = character:FindFirstChild("Head")
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local myHRP = myCharacter:FindFirstChild("HumanoidRootPart")
    
    if not head or not myHRP or not humanoid or humanoid.Health <= 0 then 
        return false, nil, nil 
    end
    
    local lookVector = head.CFrame.LookVector
    local eyePosition = head.Position + Vector3.new(0, 0.5, 0)
    local endPosition = eyePosition + (lookVector * CONFIG.LineDistance)
    
    local rayParams = RaycastParams.new()
    rayParams.FilterType = Enum.RaycastFilterType.Exclude
    rayParams.FilterDescendantsInstances = {character}
    
    local rayResult = workspace:Raycast(eyePosition, lookVector * CONFIG.LineDistance, rayParams)
    
    local hitMe = false
    local actualEndPos = endPosition
    
    if rayResult then
        actualEndPos = rayResult.Position
        local hitModel = rayResult.Instance:FindFirstAncestorOfClass("Model")
        if hitModel == myCharacter then
            hitMe = true
        end
    else
        local toMe = (myHRP.Position - eyePosition).Unit
        local dot = lookVector:Dot(toMe)
        local distance = (myHRP.Position - eyePosition).Magnitude
        
        if dot > 0.98 and distance < CONFIG.LineDistance then
            local projection = eyePosition + lookVector * distance * dot
            local perpDistance = (myHRP.Position - projection).Magnitude
            
            if perpDistance < CONFIG.DetectionRadius then
                hitMe = true
                actualEndPos = myHRP.Position
            end
        end
    end
    
    return hitMe, eyePosition, actualEndPos
end

local function drawHeadBox(boxLines, headPos, size, color, visible)
    if not visible then
        for _, line in ipairs(boxLines) do
            line.Visible = false
        end
        return
    end
    
    local halfSize = size / 2
    local corners = {
        Vector2.new(headPos.X - halfSize, headPos.Y - halfSize),
        Vector2.new(headPos.X + halfSize, headPos.Y - halfSize),
        Vector2.new(headPos.X + halfSize, headPos.Y + halfSize),
        Vector2.new(headPos.X - halfSize, headPos.Y + halfSize)
    }
    
    for i, line in ipairs(boxLines) do
        local nextIndex = i % 4 + 1
        line.From = corners[i]
        line.To = corners[nextIndex]
        line.Color = color
        line.Visible = true
    end
end

local function updateSystem()
    if not isRunning then return end
    
    local camera = workspace.CurrentCamera
    local watchingPlayers = {}
    
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            if not playerLines[player] then
                playerLines[player] = createDrawingLine()
                playerHeadCircles[player] = createHeadCircle()
                playerHeadBoxes[player] = createHeadBox()
                playerNameTags[player] = createNameTag()
            end
            
            local line = playerLines[player]
            local headCircle = playerHeadCircles[player]
            local headBox = playerHeadBoxes[player]
            local nameTag = playerNameTags[player]
            
            local character = player.Character
            local head = character and character:FindFirstChild("Head")
            local humanoid = character and character:FindFirstChildOfClass("Humanoid")
            
            if head and humanoid and humanoid.Health > 0 then
                local isLooking, startPos, endPos = checkIfLookingAtMe(player)
                local headScreen, headOnScreen = camera:WorldToViewportPoint(head.Position)
                
                if headOnScreen and headScreen.Z > 0 then
                    local headPos2D = Vector2.new(headScreen.X, headScreen.Y)
                    local distanceFactor = math.clamp(50 / headScreen.Z, 0.5, 2)
                    local dynamicRadius = CONFIG.HeadCircleRadius * distanceFactor
                    local dynamicBoxSize = CONFIG.HeadBoxSize * distanceFactor
                    
                    local currentColor = CONFIG.NormalColor
                    local pulse = 1
                    
                    if isLooking then
                        pulse = math.abs(math.sin(tick() * CONFIG.FlashSpeed))
                        currentColor = CONFIG.AlertColor
                        table.insert(watchingPlayers, player)
                    end
                    
                    headCircle.Position = headPos2D
                    headCircle.Radius = dynamicRadius + (isLooking and pulse * 4 or 0)
                    headCircle.Color = currentColor
                    headCircle.Thickness = isLooking and 3 or 2
                    headCircle.Visible = true
                    
                    drawHeadBox(headBox, headPos2D, dynamicBoxSize + (isLooking and pulse * 6 or 0), currentColor, true)
                    
                    nameTag.Text = player.Name
                    nameTag.Position = Vector2.new(headPos2D.X, headPos2D.Y - dynamicRadius - 20)
                    nameTag.Color = isLooking and CONFIG.AlertColor or Color3.fromRGB(255, 255, 255)
                    nameTag.Size = math.clamp(14 * distanceFactor, 10, 18)
                    nameTag.Visible = true
                    
                    if startPos and endPos then
                        local startScreen = camera:WorldToViewportPoint(startPos)
                        local endScreen = camera:WorldToViewportPoint(endPos)
                        
                        if startScreen.Z > 0 then
                            line.From = Vector2.new(startScreen.X, startScreen.Y)
                            line.To = Vector2.new(endScreen.X, endScreen.Y)
                            
                            if isLooking then
                                line.Color = CONFIG.AlertColor
                                line.Thickness = CONFIG.LineThicknessAlert + (pulse * 2)
                                line.Transparency = 0.4 + (pulse * 0.3)
                            else
                                line.Color = CONFIG.NormalColor
                                line.Thickness = CONFIG.LineThickness
                                line.Transparency = 0.6
                            end
                            line.Visible = true
                        else
                            line.Visible = false
                        end
                    else
                        line.Visible = false
                    end
                else
                    line.Visible = false
                    headCircle.Visible = false
                    drawHeadBox(headBox, Vector2.new(0, 0), 0, CONFIG.NormalColor, false)
                    nameTag.Visible = false
                end
            else
                line.Visible = false
                headCircle.Visible = false
                drawHeadBox(headBox, Vector2.new(0, 0), 0, CONFIG.NormalColor, false)
                nameTag.Visible = false
            end
        end
    end
    
    if warningUI and CONFIG.EnableVFX then
        local isBeingWatched = #watchingPlayers > 0
        
        if isBeingWatched then
            local pulse = math.abs(math.sin(tick() * CONFIG.FlashSpeed))
            
            warningUI.Vignette.BackgroundColor3 = CONFIG.AlertColor
            warningUI.Vignette.BackgroundTransparency = 1 - (CONFIG.VignetteIntensity * (0.5 + pulse * 0.5))
            
            warningUI.Text.TextTransparency = 0.2 + (pulse * 0.3)
            warningUI.Text.TextSize = 24 + (pulse * 4)
            
            local names = {}
            for _, p in ipairs(watchingPlayers) do
                table.insert(names, p.Name)
            end
            warningUI.Direction.Text = table.concat(names, ", ")
            warningUI.Direction.TextTransparency = 0.3
        else
            warningUI.Vignette.BackgroundTransparency = 1
            warningUI.Text.TextTransparency = 1
            warningUI.Direction.TextTransparency = 1
        end
    end
end

local function cleanupPlayer(player)
    if playerLines[player] then
        playerLines[player]:Remove()
        playerLines[player] = nil
    end
    if playerHeadCircles[player] then
        playerHeadCircles[player]:Remove()
        playerHeadCircles[player] = nil
    end
    if playerHeadBoxes[player] then
        for _, line in ipairs(playerHeadBoxes[player]) do
            line:Remove()
        end
        playerHeadBoxes[player] = nil
    end
    if playerNameTags[player] then
        playerNameTags[player]:Remove()
        playerNameTags[player] = nil
    end
end

local function fullCleanup()
    isRunning = false
    
    for _, conn in pairs(connections) do
        pcall(function() conn:Disconnect() end)
    end
    
    for player, _ in pairs(playerLines) do
        cleanupPlayer(player)
    end
    
    if warningUI and warningUI.Gui then
        warningUI.Gui:Destroy()
    end
end

warningUI = createWarningUI()

table.insert(connections, Players.PlayerRemoving:Connect(cleanupPlayer))
table.insert(connections, RunService.RenderStepped:Connect(updateSystem))

spawn(function()
    while isRunning do
        wait(0.5)
        if _G.StopLookChams then
            fullCleanup()
            _G.StopLookChams = false
            break
        end
    end
end)