--[[ EZ AIM V2 | Mobile Delta | Enhanced Edition ]]
-- Fixed: aim camera ordering, wallcheck behind-target bug, teamcheck nil-team,
--        sticky aim churn. Added: smoothness slider, prediction, aim part picker,
--        lock line, tabbed GUI, full cleanup on re-execute.

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

local hasDrawing = false
pcall(function() if Drawing and Drawing.new then hasDrawing = true end end)

------------------------------------------------------------
-- CLEANUP ON RE-EXECUTE
------------------------------------------------------------
if _G.EZ_AIM_V2_Cleanup then pcall(_G.EZ_AIM_V2_Cleanup) end
local Cleanup = {}
_G.EZ_AIM_V2_Cleanup = function()
    for _, fn in ipairs(Cleanup) do pcall(fn) end
end

------------------------------------------------------------
-- CONFIG
------------------------------------------------------------
local AIM_PARTS = { "Head", "HumanoidRootPart", "UpperTorso", "LowerTorso", "Torso" }
local AIM_INDEX = 1

local Config = {
    Aimbot     = true,
    StickyAim  = true,
    TeamCheck  = true,
    WallCheck  = true,
    ESP        = true,
    Tracers    = true,
    Rainbow    = true,
    ShowFOV    = true,
    LockLine   = true,
    AimPart    = AIM_PARTS[AIM_INDEX],
    FOV        = 200,
    Smoothness = 0.30,   -- 0.01 slow → 1.0 instant
    Prediction = 20,     -- 0 → 100
}
local RainbowHue = 0

------------------------------------------------------------
-- GUI PARENT
------------------------------------------------------------
local GuiParent
pcall(function() GuiParent = gethui() end)
if not GuiParent then
    local ok, cg = pcall(function() return game:GetService("CoreGui") end)
    GuiParent = ok and cg or LP:WaitForChild("PlayerGui")
end

local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "EZ_AIM_V2"
ScreenGui.ResetOnSpawn = false
ScreenGui.IgnoreGuiInset = true
ScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
ScreenGui.DisplayOrder = 999
ScreenGui.Parent = GuiParent
table.insert(Cleanup, function() ScreenGui:Destroy() end)

------------------------------------------------------------
-- DRAGGABLE TOGGLE
------------------------------------------------------------
local Toggle = Instance.new("TextButton")
Toggle.Size = UDim2.fromOffset(48, 48)
Toggle.AnchorPoint = Vector2.new(1, 0)
Toggle.Position = UDim2.new(1, -14, 0, 14)
Toggle.BackgroundColor3 = Color3.fromRGB(18, 18, 26)
Toggle.BorderSizePixel = 0
Toggle.Text = "EZ"
Toggle.TextColor3 = Color3.fromRGB(0, 220, 255)
Toggle.Font = Enum.Font.GothamBlack
Toggle.TextSize = 18
Toggle.AutoButtonColor = false
Toggle.Active = true
Toggle.Parent = ScreenGui
Instance.new("UICorner", Toggle).CornerRadius = UDim.new(0, 12)
local tstroke = Instance.new("UIStroke", Toggle)
tstroke.Color = Color3.fromRGB(0, 220, 255)
tstroke.Thickness = 1.8

------------------------------------------------------------
-- PANEL (autoscale + draggable header)
------------------------------------------------------------
local Panel = Instance.new("Frame")
Panel.Size = UDim2.fromOffset(340, 440)
Panel.AnchorPoint = Vector2.new(0.5, 0.5)
Panel.Position = UDim2.new(0.5, 0, 0.5, 0)
Panel.BackgroundColor3 = Color3.fromRGB(14, 14, 20)
Panel.BorderSizePixel = 0
Panel.Visible = false
Panel.Parent = ScreenGui
Instance.new("UICorner", Panel).CornerRadius = UDim.new(0, 14)
local pstroke = Instance.new("UIStroke", Panel)
pstroke.Color = Color3.fromRGB(0, 220, 255)
pstroke.Thickness = 1.4

local PanelScale = Instance.new("UIScale")
PanelScale.Parent = Panel

local function fitPanel()
    local vp = Camera.ViewportSize
    local s = math.min(vp.X / 1600, vp.Y / 900)
    PanelScale.Scale = math.clamp(s, 0.72, 1.12)
end
fitPanel()
Camera:GetPropertyChangedSignal("ViewportSize"):Connect(fitPanel)

------------------------------------------------------------
-- HEADER (drag handle)
------------------------------------------------------------
local Header = Instance.new("TextButton")
Header.Size = UDim2.new(1, -16, 0, 34)
Header.Position = UDim2.new(0, 8, 0, 8)
Header.BackgroundColor3 = Color3.fromRGB(24, 24, 34)
Header.BorderSizePixel = 0
Header.Text = "EZ AIM V2"
Header.Font = Enum.Font.GothamBlack
Header.TextSize = 16
Header.TextColor3 = Color3.fromRGB(0, 220, 255)
Header.AutoButtonColor = false
Header.Parent = Panel
Instance.new("UICorner", Header).CornerRadius = UDim.new(0, 8)

------------------------------------------------------------
-- TAB BAR
------------------------------------------------------------
local TabBar = Instance.new("Frame")
TabBar.Size = UDim2.new(1, -16, 0, 28)
TabBar.Position = UDim2.new(0, 8, 0, 46)
TabBar.BackgroundTransparency = 1
TabBar.Parent = Panel
local TabLayout = Instance.new("UIListLayout", TabBar)
TabLayout.FillDirection = Enum.FillDirection.Horizontal
TabLayout.Padding = UDim.new(0, 4)

local function makeTab(text)
    local b = Instance.new("TextButton")
    b.Size = UDim2.new(0.5, -2, 1, 0)
    b.BackgroundColor3 = Color3.fromRGB(26, 26, 36)
    b.BorderSizePixel = 0
    b.Text = text
    b.Font = Enum.Font.GothamBold
    b.TextSize = 13
    b.TextColor3 = Color3.fromRGB(180, 180, 200)
    b.AutoButtonColor = false
    b.Parent = TabBar
    Instance.new("UICorner", b).CornerRadius = UDim.new(0, 8)
    return b
end
local tabAim    = makeTab("AIM")
local tabVisual = makeTab("VISUAL")

------------------------------------------------------------
-- CONTENT FRAMES
------------------------------------------------------------
local Content = Instance.new("Frame")
Content.Size = UDim2.new(1, -16, 1, -84)
Content.Position = UDim2.new(0, 8, 0, 80)
Content.BackgroundTransparency = 1
Content.Parent = Panel

local function makePage()
    local p = Instance.new("ScrollingFrame")
    p.Size = UDim2.new(1, 0, 1, 0)
    p.BackgroundTransparency = 1
    p.BorderSizePixel = 0
    p.CanvasSize = UDim2.new(0, 0, 0, 0)
    p.AutomaticCanvasSize = Enum.AutomaticSize.Y
    p.ScrollBarThickness = 3
    p.ScrollBarImageColor3 = Color3.fromRGB(0, 200, 255)
    p.Parent = Content
    local l = Instance.new("UIListLayout", p)
    l.Padding = UDim.new(0, 4)
    l.SortOrder = Enum.SortOrder.LayoutOrder
    return p
end
local AimPage    = makePage()
local VisualPage = makePage()

local function setTab(tab)
    AimPage.Visible    = (tab == "aim")
    VisualPage.Visible = (tab == "visual")
    tabAim.BackgroundColor3    = (tab == "aim")    and Color3.fromRGB(0, 180, 220) or Color3.fromRGB(26, 26, 36)
    tabAim.TextColor3          = (tab == "aim")    and Color3.fromRGB(255, 255, 255) or Color3.fromRGB(180, 180, 200)
    tabVisual.BackgroundColor3 = (tab == "visual") and Color3.fromRGB(0, 180, 220) or Color3.fromRGB(26, 26, 36)
    tabVisual.TextColor3       = (tab == "visual") and Color3.fromRGB(255, 255, 255) or Color3.fromRGB(180, 180, 200)
end
tabAim.MouseButton1Click:Connect(function() setTab("aim") end)
tabVisual.MouseButton1Click:Connect(function() setTab("visual") end)
setTab("aim")

------------------------------------------------------------
-- ROW BUILDERS
------------------------------------------------------------
local function makeToggle(parent, label, key, order)
    local row = Instance.new("TextButton")
    row.Size = UDim2.new(1, 0, 0, 30)
    row.BackgroundColor3 = Color3.fromRGB(26, 26, 36)
    row.BorderSizePixel = 0
    row.Text = ""
    row.AutoButtonColor = false
    row.LayoutOrder = order
    row.Parent = parent
    Instance.new("UICorner", row).CornerRadius = UDim.new(0, 8)

    local lbl = Instance.new("TextLabel")
    lbl.Size = UDim2.new(1, -64, 1, 0)
    lbl.Position = UDim2.new(0, 12, 0, 0)
    lbl.BackgroundTransparency = 1
    lbl.Text = label
    lbl.TextXAlignment = Enum.TextXAlignment.Left
    lbl.Font = Enum.Font.GothamBold
    lbl.TextSize = 12
    lbl.TextColor3 = Color3.fromRGB(225, 225, 235)
    lbl.Parent = row

    local pill = Instance.new("Frame")
    pill.Size = UDim2.fromOffset(38, 18)
    pill.Position = UDim2.new(1, -50, 0.5, -9)
    pill.BackgroundColor3 = Config[key] and Color3.fromRGB(0, 200, 100) or Color3.fromRGB(70, 30, 40)
    pill.Parent = row
    Instance.new("UICorner", pill).CornerRadius = UDim.new(1, 0)

    local knob = Instance.new("Frame")
    knob.Size = UDim2.fromOffset(14, 14)
    knob.Position = Config[key] and UDim2.new(1, -17, 0.5, -7) or UDim2.new(0, 2, 0.5, -7)
    knob.BackgroundColor3 = Color3.fromRGB(240, 240, 250)
    knob.Parent = pill
    Instance.new("UICorner", knob).CornerRadius = UDim.new(1, 0)

    row.MouseButton1Click:Connect(function()
        Config[key] = not Config[key]
        pill.BackgroundColor3 = Config[key] and Color3.fromRGB(0, 200, 100) or Color3.fromRGB(70, 30, 40)
        knob.Position = Config[key] and UDim2.new(1, -17, 0.5, -7) or UDim2.new(0, 2, 0.5, -7)
        if key == "ShowFOV" and FOVCircle then
            FOVCircle.Visible = Config.ShowFOV
        end
    end)
end

local function makeSlider(parent, label, min, max, key, order, fmt)
    local row = Instance.new("Frame")
    row.Size = UDim2.new(1, 0, 0, 48)
    row.BackgroundColor3 = Color3.fromRGB(26, 26, 36)
    row.BorderSizePixel = 0
    row.LayoutOrder = order
    row.Parent = parent
    Instance.new("UICorner", row).CornerRadius = UDim.new(0, 8)

    local lbl = Instance.new("TextLabel")
    lbl.Size = UDim2.new(1, -20, 0, 20)
    lbl.Position = UDim2.new(0, 12, 0, 4)
    lbl.BackgroundTransparency = 1
    lbl.Text = label
    lbl.TextXAlignment = Enum.TextXAlignment.Left
    lbl.Font = Enum.Font.GothamBold
    lbl.TextSize = 12
    lbl.TextColor3 = Color3.fromRGB(225, 225, 235)
    lbl.Parent = row

    local bar = Instance.new("Frame")
    bar.Size = UDim2.new(1, -24, 0, 10)
    bar.Position = UDim2.new(0, 12, 0, 30)
    bar.BackgroundColor3 = Color3.fromRGB(44, 44, 58)
    bar.BorderSizePixel = 0
    bar.Parent = row
    Instance.new("UICorner", bar).CornerRadius = UDim.new(1, 0)

    local fill = Instance.new("Frame")
    fill.Size = UDim2.new((Config[key] - min) / (max - min), 0, 1, 0)
    fill.BackgroundColor3 = Color3.fromRGB(0, 220, 255)
    fill.BorderSizePixel = 0
    fill.Parent = bar
    Instance.new("UICorner", fill).CornerRadius = UDim.new(1, 0)

    local function refresh()
        lbl.Text = fmt(label, Config[key])
        fill.Size = UDim2.new((Config[key] - min) / (max - min), 0, 1, 0)
    end
    refresh()

    local dragging = false
    local function updateFromX(x)
        local rel = math.clamp((x - bar.AbsolutePosition.X) / bar.AbsoluteSize.X, 0, 1)
        Config[key] = min + rel * (max - min)
        refresh()
    end
    bar.InputBegan:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 or i.UserInputType == Enum.UserInputType.Touch then
            dragging = true
            updateFromX(i.Position.X)
        end
    end)
    UIS.InputChanged:Connect(function(i)
        if dragging and (i.UserInputType == Enum.UserInputType.MouseMovement or i.UserInputType == Enum.UserInputType.Touch) then
            updateFromX(i.Position.X)
        end
    end)
    UIS.InputEnded:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 or i.UserInputType == Enum.UserInputType.Touch then
            dragging = false
        end
    end)
end

local function makeCycle(parent, label, key, order, getDisplay, onTap)
    local row = Instance.new("TextButton")
    row.Size = UDim2.new(1, 0, 0, 30)
    row.BackgroundColor3 = Color3.fromRGB(26, 26, 36)
    row.BorderSizePixel = 0
    row.Text = ""
    row.AutoButtonColor = false
    row.LayoutOrder = order
    row.Parent = parent
    Instance.new("UICorner", row).CornerRadius = UDim.new(0, 8)

    local lbl = Instance.new("TextLabel")
    lbl.Size = UDim2.new(1, -12, 1, 0)
    lbl.Position = UDim2.new(0, 12, 0, 0)
    lbl.BackgroundTransparency = 1
    lbl.Text = label .. ": " .. getDisplay()
    lbl.TextXAlignment = Enum.TextXAlignment.Left
    lbl.Font = Enum.Font.GothamBold
    lbl.TextSize = 12
    lbl.TextColor3 = Color3.fromRGB(225, 225, 235)
    lbl.Parent = row

    row.MouseButton1Click:Connect(function()
        onTap()
        lbl.Text = label .. ": " .. getDisplay()
    end)
end

------------------------------------------------------------
-- POPULATE AIM TAB
------------------------------------------------------------
makeToggle(AimPage, "Aimbot",     "Aimbot",    1)
makeToggle(AimPage, "Sticky Aim", "StickyAim", 2)
makeToggle(AimPage, "Team Check", "TeamCheck", 3)
makeToggle(AimPage, "Wall Check", "WallCheck", 4)
makeCycle(AimPage, "Aim Part",    "AimPart",   5,
    function() return Config.AimPart end,
    function()
        AIM_INDEX = (AIM_INDEX % #AIM_PARTS) + 1
        Config.AimPart = AIM_PARTS[AIM_INDEX]
    end)
makeSlider(AimPage, "FOV Radius", 40, 500, "FOV", 6, function(_, v) return "FOV Radius: " .. math.floor(v) end)
makeSlider(AimPage, "Smoothness", 0.01, 1.00, "Smoothness", 7, function(_, v) return string.format("Smoothness: %.2f", v) end)
makeSlider(AimPage, "Prediction", 0, 100, "Prediction", 8, function(_, v) return "Prediction: " .. math.floor(v) end)

------------------------------------------------------------
-- POPULATE VISUAL TAB
------------------------------------------------------------
makeToggle(VisualPage, "ESP Highlight", "ESP",      1)
makeToggle(VisualPage, "Tracers",       "Tracers",  2)
makeToggle(VisualPage, "Rainbow Mode",  "Rainbow",  3)
makeToggle(VisualPage, "Show FOV",      "ShowFOV",  4)
makeToggle(VisualPage, "Lock Line",     "LockLine", 5)

------------------------------------------------------------
-- TOGGLE BUTTON (only this opens/closes the panel)
------------------------------------------------------------
do
    local drag, moved, start, origin
    Toggle.InputBegan:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 or i.UserInputType == Enum.UserInputType.Touch then
            drag, moved = true, false
            start, origin = i.Position, Toggle.Position
        end
    end)
    UIS.InputChanged:Connect(function(i)
        if drag and (i.UserInputType == Enum.UserInputType.MouseMovement or i.UserInputType == Enum.UserInputType.Touch) then
            local d = i.Position - start
            if d.Magnitude > 6 then moved = true end
            Toggle.Position = UDim2.new(origin.X.Scale, origin.X.Offset + d.X, origin.Y.Scale, origin.Y.Offset + d.Y)
        end
    end)
    UIS.InputEnded:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 or i.UserInputType == Enum.UserInputType.Touch then
            if drag and not moved then
                Panel.Visible = not Panel.Visible
            end
            drag  = false
            moved = false
        end
    end)
end

------------------------------------------------------------
-- PANEL DRAG (via header)
------------------------------------------------------------
do
    local drag, start, origin
    Header.InputBegan:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 or i.UserInputType == Enum.UserInputType.Touch then
            drag, start, origin = true, i.Position, Panel.Position
        end
    end)
    UIS.InputChanged:Connect(function(i)
        if drag and (i.UserInputType == Enum.UserInputType.MouseMovement or i.UserInputType == Enum.UserInputType.Touch) then
            local d = i.Position - start
            Panel.Position = UDim2.new(origin.X.Scale, origin.X.Offset + d.X, origin.Y.Scale, origin.Y.Offset + d.Y)
        end
    end)
    UIS.InputEnded:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 or i.UserInputType == Enum.UserInputType.Touch then
            drag = false
        end
    end)
end

------------------------------------------------------------
-- DRAWINGS
------------------------------------------------------------
local FOVCircle, LockLine

if hasDrawing then
    FOVCircle = Drawing.new("Circle")
    FOVCircle.Thickness = 1.5
    FOVCircle.NumSides = 72
    FOVCircle.Transparency = 1
    FOVCircle.Filled = false
    FOVCircle.Visible = Config.ShowFOV
    table.insert(Cleanup, function() FOVCircle:Remove() end)

    LockLine = Drawing.new("Line")
    LockLine.Thickness = 2
    LockLine.Color = Color3.fromRGB(255, 60, 60)
    LockLine.Transparency = 0.6
    LockLine.Visible = false
    table.insert(Cleanup, function() LockLine:Remove() end)
end

------------------------------------------------------------
-- ESP STORAGE
------------------------------------------------------------
local Highlights, Tracers = {}, {}

local function clearESP(plr)
    if Highlights[plr] then pcall(function() Highlights[plr]:Destroy() end); Highlights[plr] = nil end
    if Tracers[plr] then pcall(function() Tracers[plr]:Remove() end); Tracers[plr] = nil end
end

local function addESP(plr)
    local char = plr.Character
    if not char or not char:FindFirstChildOfClass("Humanoid") then return end
    clearESP(plr)
    local hl = Instance.new("Highlight")
    hl.FillColor = Color3.fromRGB(0, 220, 255)
    hl.OutlineColor = Color3.fromRGB(255, 255, 255)
    hl.FillTransparency = 0.55
    hl.OutlineTransparency = 0
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Adornee = char
    hl.Parent = char
    Highlights[plr] = hl

    if hasDrawing then
        local tr = Drawing.new("Line")
        tr.Thickness = 1.4
        tr.Transparency = 0.85
        tr.Visible = false
        Tracers[plr] = tr
    end
end

------------------------------------------------------------
-- HELPERS
------------------------------------------------------------
local function isAlive(plr)
    local c = plr.Character
    local h = c and c:FindFirstChildOfClass("Humanoid")
    return h ~= nil and h.Health > 0
end

local function isTeammate(plr)
    if not Config.TeamCheck then return false end
    if not LP.Team then return false end
    return plr.Team == LP.Team
end

local function isVisible(targetPart)
    if not Config.WallCheck then return true end
    local origin = Camera.CFrame.Position
    local direction = targetPart.Position - origin
    if direction.Magnitude < 0.1 then return true end
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    local filter = {}
    if LP.Character then filter[#filter + 1] = LP.Character end
    if targetPart.Parent then filter[#filter + 1] = targetPart.Parent end
    params.FilterDescendantsInstances = filter
    params.IgnoreWater = true
    local result = Workspace:Raycast(origin, direction, params)
    return result == nil
end

local function getAimPos(part)
    local pos = part.Position
    if Config.Prediction > 0 then
        local vel = part.AssemblyLinearVelocity or Vector3.zero
        local lookahead = Config.Prediction * 0.005
        pos = pos + vel * lookahead
    end
    return pos
end

local function findCandidate()
    local center = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    local best, bestDist = nil, Config.FOV
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= LP and isAlive(plr) and not isTeammate(plr) then
            local char = plr.Character
            local part = char:FindFirstChild(Config.AimPart) or char:FindFirstChild("HumanoidRootPart")
            if part then
                local sp, onScreen = Camera:WorldToViewportPoint(part.Position)
                if onScreen then
                    local d = (Vector2.new(sp.X, sp.Y) - center).Magnitude
                    if d < bestDist and isVisible(part) then
                        bestDist = d
                        best = { part = part, plr = plr }
                    end
                end
            end
        end
    end
    return best
end

local function stickyValid(t)
    if not t or not t.part or not t.part.Parent then return false end
    local char = t.part.Parent
    local hum = char:FindFirstChildOfClass("Humanoid")
    if not hum or hum.Health <= 0 then return false end
    local plr = Players:GetPlayerFromCharacter(char)
    if not plr or plr == LP then return false end
    if isTeammate(plr) then return false end
    if not isVisible(t.part) then return false end
    -- reject if camera is looking > 90° away (target behind)
    local toTarget = (t.part.Position - Camera.CFrame.Position)
    if toTarget.Magnitude > 0.1 and toTarget.Unit:Dot(Camera.CFrame.LookVector) < 0 then
        return false
    end
    return true
end

------------------------------------------------------------
-- ONE RENDER LOOP, CAMERA PRIORITY +1
-- (runs after default camera, so aim camera write wins cleanly)
------------------------------------------------------------
local StickyTarget = nil

local function renderStep(dt)
    RainbowHue = (RainbowHue + dt * 0.4) % 1
    local rainbow = Color3.fromHSV(RainbowHue, 1, 1)
    local accent  = Config.Rainbow and rainbow or Color3.fromRGB(0, 220, 255)

    local vp     = Camera.ViewportSize
    local center = Vector2.new(vp.X / 2, vp.Y / 2)

    -- FOV circle (locked center)
    if FOVCircle then
        FOVCircle.Position = center
        FOVCircle.Radius   = Config.FOV
        FOVCircle.Visible  = Config.ShowFOV
        FOVCircle.Color    = accent
    end

    -- ESP
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr == LP then continue end
        local alive = isAlive(plr)
        local skip  = isTeammate(plr)

        if Config.ESP and alive and not skip then
            if not Highlights[plr] or Highlights[plr].Adornee ~= plr.Character then
                addESP(plr)
            end
            local hl = Highlights[plr]
            if hl then
                hl.Enabled = true
                hl.FillColor    = Config.Rainbow and rainbow or Color3.fromRGB(0, 220, 255)
                hl.OutlineColor = Config.Rainbow and Color3.fromHSV((RainbowHue + 0.5) % 1, 1, 1) or Color3.fromRGB(255, 255, 255)
            end
        else
            if Highlights[plr] then Highlights[plr].Enabled = false end
        end

        local tr = Tracers[plr]
        if tr then
            local hrp = plr.Character and plr.Character:FindFirstChild("HumanoidRootPart")
            if Config.Tracers and Config.ESP and alive and not skip and hrp then
                local sp, on = Camera:WorldToViewportPoint(hrp.Position)
                if on then
                    tr.From    = Vector2.new(vp.X / 2, vp.Y)
                    tr.To      = Vector2.new(sp.X, sp.Y)
                    tr.Color   = accent
                    tr.Visible = true
                else
                    tr.Visible = false
                end
            else
                tr.Visible = false
            end
        end
    end

    -- Aimbot: pick target, then write camera (safe ordering)
    local activeTarget = nil
    if Config.Aimbot then
        if Config.StickyAim and stickyValid(StickyTarget) then
            activeTarget = StickyTarget
        else
            StickyTarget = nil
            local c = findCandidate()
            if c then
                activeTarget = c
                if Config.StickyAim then StickyTarget = c end
            end
        end

        if activeTarget then
            local aimPos = getAimPos(activeTarget.part)
            local desired = CFrame.lookAt(Camera.CFrame.Position, aimPos)
            local alpha = math.clamp(Config.Smoothness * (dt * 60), 0, 1)
            Camera.CFrame = Camera.CFrame:Lerp(desired, alpha)
        end
    else
        StickyTarget = nil
    end

    -- Lock line
    if LockLine then
        if activeTarget then
            local sp, on = Camera:WorldToViewportPoint(activeTarget.part.Position)
            if on then
                LockLine.From    = center
                LockLine.To      = Vector2.new(sp.X, sp.Y)
                LockLine.Color   = Config.Rainbow and rainbow or Color3.fromRGB(255, 60, 60)
                LockLine.Visible = Config.LockLine
            else
                LockLine.Visible = false
            end
        else
            LockLine.Visible = false
        end
    end
end

pcall(function()
    RunService:UnbindFromRenderStep("EZ_AIM_V2_Render")
end)
RunService:BindToRenderStep("EZ_AIM_V2_Render", Enum.RenderPriority.Camera.Value + 1, renderStep)
table.insert(Cleanup, function() pcall(function() RunService:UnbindFromRenderStep("EZ_AIM_V2_Render") end) end)

------------------------------------------------------------
-- PLAYER HOOKS
------------------------------------------------------------
local function hookPlr(p)
    if p == LP then return end
    if p.Character then task.wait(0.5); addESP(p) end
    p.CharacterAdded:Connect(function()
        task.wait(0.5)
        addESP(p)
    end)
end

for _, p in ipairs(Players:GetPlayers()) do hookPlr(p) end
Players.PlayerAdded:Connect(hookPlr)
Players.PlayerRemoving:Connect(clearESP)
LP.CharacterAdded:Connect(function() StickyTarget = nil end)