-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6addb5e31ca28656b60fe3ac"))()
	end)
end)
--[[rscripts:analytics:end]]

--=============================================================
--  AIMBOT + ESP  •  v9  (Players-service team check + wall check)
--  LocalScript / executor only
--=============================================================
local Players          = game:GetService("Players")
local RunService       = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

--───────────────────────────────────────────────────────────
-- CONFIG
--───────────────────────────────────────────────────────────
local CONFIG = {
    TargetPartPriority = { "Head", "UpperTorso", "Torso", "HumanoidRootPart" },
    MinDistance        = 1,
    MaxDistance        = 150,
    FOV                = 60,
    AimSpeed           = 0.2,
    Enabled            = true,
    HoldToAim          = true,
    AimAtHead          = true,
    SnapOnAcquire      = true,
    TeamCheck          = false,
    WallCheck          = false,
    ShowFovCircle      = true,
    FovRadius          = 50,
    FovColor           = Color3.fromRGB(0, 255, 133),
    ToggleKey          = Enum.KeyCode.K,
    MenuKey            = Enum.KeyCode.Home,

    ESP = {
        Enabled      = false,
        Box          = true,
        Name         = true,
        Distance     = true,
        Health       = true,
        Tracer       = false,
        Highlight    = true,
        WallCheck    = false,
        MaxDistance  = 500,
        BoxColor     = Color3.fromRGB(0, 255, 133),
        TextColor    = Color3.fromRGB(255, 255, 255),
        TracerOrigin = "Bottom",
    },
}

local LocalPlayer = Players.LocalPlayer
local PlayerData  = {}
local ESP_OBJ     = {}

--───────────────────────────────────────────────────────────
-- Lifecycle state
--───────────────────────────────────────────────────────────
local destroyed   = false
local minimized   = false
local rightHeld   = false
local CONNECTIONS = {}

local aimLookDir  = nil
local aimTarget   = nil
local lastAimName = nil

local function track(conn)
    if destroyed then
        pcall(function() conn:Disconnect() end)
        return conn
    end
    table.insert(CONNECTIONS, conn)
    return conn
end

--───────────────────────────────────────────────────────────
-- Drawing availability
--───────────────────────────────────────────────────────────
local HAS_DRAWING = pcall(function()
    local d = Drawing.new("Line"); d:Remove()
end)

--───────────────────────────────────────────────────────────
-- Team attribute helpers
--   Flow: Players:GetPlayers → Player object → player.Character
--         (workspace[player.Name] fallback) → :GetAttribute("team")
--   Identity is guarded via UserId so we never compare a player to themself.
--───────────────────────────────────────────────────────────
local function getPlayerTeam(player)
    if not player then return nil end
    local char = player.Character
    if not char or not char.Parent then
        char = workspace:FindFirstChild(player.Name)
    end
    if not char then return nil end
    return char:GetAttribute("team")
end

local function isSameTeam(name)
    if not CONFIG.TeamCheck then return false end
    local otherPlayer = Players:FindFirstChild(name)
    if not otherPlayer then return false end
    if otherPlayer.UserId == LocalPlayer.UserId then return false end

    local myTeam = getPlayerTeam(LocalPlayer)
    if myTeam == nil then return false end

    local theirTeam = getPlayerTeam(otherPlayer)
    if theirTeam == nil then return false end

    return myTeam == theirTeam
end

--───────────────────────────────────────────────────────────
-- Wall / line-of-sight check
--───────────────────────────────────────────────────────────
local function hasLineOfSight(targetPart, targetModel)
    local cam = workspace.CurrentCamera
    if not cam then return false end
    local camPos = cam.CFrame.Position
    local dir = targetPart.Position - camPos
    if dir.Magnitude < 0.1 then return true end

    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    local exclude = {}
    if LocalPlayer.Character then table.insert(exclude, LocalPlayer.Character) end
    if targetModel and targetModel ~= LocalPlayer.Character then
        table.insert(exclude, targetModel)
    end
    params.FilterDescendantsInstances = exclude
    params.IgnoreWater = true

    local result = workspace:Raycast(camPos, dir, params)
    return result == nil
end

--───────────────────────────────────────────────────────────
-- Player sync
--───────────────────────────────────────────────────────────
local function getTargetParts(model)
    local parts = {}
    for _, name in ipairs(CONFIG.TargetPartPriority) do
        local p = model:FindFirstChild(name)
        if p and p:IsA("BasePart") then table.insert(parts, p) end
    end
    return parts
end

local function destroyESP(name)
    local o = ESP_OBJ[name]
    if not o then return end
    for _, obj in pairs(o) do
        if typeof(obj) == "Instance" then
            pcall(function() obj:Destroy() end)
        else
            pcall(function() obj:Remove() end)
        end
    end
    ESP_OBJ[name] = nil
end

local function syncPlayer(player)
    if destroyed or player == LocalPlayer then return end
    local char = player.Character
    if char and char:FindFirstChildOfClass("Humanoid") then
        PlayerData[player.Name] = {
            Model    = char,
            Parts    = getTargetParts(char),
            Humanoid = char:FindFirstChildOfClass("Humanoid"),
        }
    else
        PlayerData[player.Name] = nil
        destroyESP(player.Name)
    end
end

local function watchPlayer(player)
    if destroyed or player == LocalPlayer then return end
    syncPlayer(player)
    track(player.CharacterAdded:Connect(function(char)
        if destroyed then return end
        char:WaitForChild("Humanoid", 5)
        syncPlayer(player)
    end))
    track(player.CharacterRemoving:Connect(function()
        if destroyed then return end
        PlayerData[player.Name] = nil
        destroyESP(player.Name)
    end))
end

for _, p in ipairs(Players:GetPlayers()) do watchPlayer(p) end
track(Players.PlayerAdded:Connect(watchPlayer))
track(Players.PlayerRemoving:Connect(function(p)
    PlayerData[p.Name] = nil
    destroyESP(p.Name)
end))

--───────────────────────────────────────────────────────────
-- FOV circle
--───────────────────────────────────────────────────────────
local fovGui = Instance.new("ScreenGui")
fovGui.Name = "AimbotFovCircle"
fovGui.ResetOnSpawn = false
fovGui.IgnoreGuiInset = true
fovGui.DisplayOrder = -1
fovGui.Parent = LocalPlayer:WaitForChild("PlayerGui")

local fovFrame = Instance.new("Frame")
fovFrame.AnchorPoint = Vector2.new(0.5, 0.5)
fovFrame.Position = UDim2.fromScale(0.5, 0.5)
fovFrame.Size = UDim2.fromOffset(CONFIG.FovRadius*2, CONFIG.FovRadius*2)
fovFrame.BackgroundTransparency = 1
fovFrame.BorderSizePixel = 0
fovFrame.Visible = CONFIG.ShowFovCircle
fovFrame.Parent = fovGui

local fovCorner = Instance.new("UICorner")
fovCorner.CornerRadius = UDim.new(1, 0)
fovCorner.Parent = fovFrame

local fovStroke = Instance.new("UIStroke")
fovStroke.Color = CONFIG.FovColor
fovStroke.Thickness = 2
fovStroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
fovStroke.Parent = fovFrame

--───────────────────────────────────────────────────────────
-- Projection
--───────────────────────────────────────────────────────────
local function w2s(worldPos)
    local cam = workspace.CurrentCamera
    if not cam then return nil end
    local p, on = cam:WorldToViewportPoint(worldPos)
    if not on then return nil end
    return Vector2.new(p.X, p.Y), p.Z
end

local function newESPObjects()
    return {
        box       = Drawing.new("Square"),
        name      = Drawing.new("Text"),
        dist      = Drawing.new("Text"),
        hpBg      = Drawing.new("Square"),
        hpFill    = Drawing.new("Square"),
        tracer    = Drawing.new("Line"),
        highlight = nil,
    }
end

local function hideESPObjects(o)
    for _, k in ipairs({"box","name","dist","hpBg","hpFill","tracer"}) do
        if o[k] then o[k].Visible = false end
    end
end

--───────────────────────────────────────────────────────────
-- ESP update
--───────────────────────────────────────────────────────────
local function updateESP()
    if destroyed or not HAS_DRAWING then return end
    local cam = workspace.CurrentCamera
    if not cam then return end

    local viewport = cam.ViewportSize
    local originBottom = Vector2.new(viewport.X * 0.5, viewport.Y)
    local originMouse  = UserInputService:GetMouseLocation()

    for name, data in pairs(PlayerData) do
        local o = ESP_OBJ[name]
        if not o then o = newESPObjects(); ESP_OBJ[name] = o end

        local model, hum = data.Model, data.Humanoid
        local head = model and model:FindFirstChild("Head")
        local hrp  = model and model:FindFirstChild("HumanoidRootPart")

        if not model or not model.Parent or not hum or hum.Health <= 0 or not head or not hrp then
            hideESPObjects(o); if o.highlight then o.highlight.Enabled = false end
            continue
        end

        if isSameTeam(name) then
            hideESPObjects(o); if o.highlight then o.highlight.Enabled = false end
            continue
        end

        local dist = (cam.CFrame.Position - hrp.Position).Magnitude
        if dist > CONFIG.ESP.MaxDistance then
            hideESPObjects(o); if o.highlight then o.highlight.Enabled = false end
            continue
        end

        if CONFIG.ESP.WallCheck and not hasLineOfSight(head, model) then
            hideESPObjects(o); if o.highlight then o.highlight.Enabled = false end
            continue
        end

        local topWorld = head.Position + Vector3.new(0, 0.5, 0)
        local botWorld = hrp.Position - Vector3.new(0, 2.75, 0)
        local topS = w2s(topWorld)
        local botS = w2s(botWorld)
        if not topS or not botS then hideESPObjects(o); continue end

        local height = math.abs(botS.Y - topS.Y)
        if height < 4 then hideESPObjects(o); continue end
        local width = height * 0.5
        local cx = (topS.X + botS.X) * 0.5
        local boxX = cx - width * 0.5
        local boxY = math.min(topS.Y, botS.Y)

        if CONFIG.ESP.Box then
            o.box.Visible   = true
            o.box.Color     = CONFIG.ESP.BoxColor
            o.box.Thickness = 1
            o.box.Filled    = false
            o.box.Position  = Vector2.new(boxX, boxY)
            o.box.Size      = Vector2.new(width, height)
        else o.box.Visible = false end

        if CONFIG.ESP.Name then
            o.name.Visible      = true
            o.name.Text         = name
            o.name.Color        = CONFIG.ESP.TextColor
            o.name.Size         = 14
            o.name.Center       = true
            o.name.Outline      = true
            o.name.OutlineColor = Color3.new(0, 0, 0)
            o.name.Position     = Vector2.new(cx, boxY - 18)
        else o.name.Visible = false end

        if CONFIG.ESP.Distance then
            o.dist.Visible      = true
            o.dist.Text         = string.format("[%d]", math.floor(dist))
            o.dist.Color        = CONFIG.ESP.TextColor
            o.dist.Size         = 12
            o.dist.Center       = true
            o.dist.Outline      = true
            o.dist.OutlineColor = Color3.new(0, 0, 0)
            o.dist.Position     = Vector2.new(cx, boxY + height + 2)
        else o.dist.Visible = false end

        if CONFIG.ESP.Health then
            local hpFrac = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
            local barH, barW = height, 3
            local barX, barY = boxX - barW - 4, boxY

            o.hpBg.Visible      = true
            o.hpBg.Color        = Color3.fromRGB(35, 35, 35)
            o.hpBg.Filled       = true
            o.hpBg.Position     = Vector2.new(barX, barY)
            o.hpBg.Size         = Vector2.new(barW, barH)
            o.hpBg.Transparency = 0.35

            local fillH = barH * hpFrac
            o.hpFill.Visible  = true
            o.hpFill.Filled   = true
            o.hpFill.Color    = Color3.fromRGB(
                math.floor(255 * (1 - hpFrac)),
                math.floor(255 * hpFrac),
                60
            )
            o.hpFill.Position = Vector2.new(barX, barY + (barH - fillH))
            o.hpFill.Size     = Vector2.new(barW, fillH)
        else
            o.hpBg.Visible   = false
            o.hpFill.Visible = false
        end

        if CONFIG.ESP.Tracer then
            local origin = CONFIG.ESP.TracerOrigin == "Mouse" and originMouse or originBottom
            o.tracer.Visible   = true
            o.tracer.Color     = CONFIG.ESP.BoxColor
            o.tracer.Thickness = 1
            o.tracer.From      = origin
            o.tracer.To        = Vector2.new(cx, boxY + height)
        else o.tracer.Visible = false end

        if CONFIG.ESP.Highlight then
            if not o.highlight or not o.highlight.Parent then
                local hl = Instance.new("Highlight")
                hl.Name = "AimbotESP_HL"
                hl.Adornee = model
                hl.FillColor = CONFIG.ESP.BoxColor
                hl.FillTransparency = 0.75
                hl.OutlineColor = CONFIG.ESP.BoxColor
                hl.OutlineTransparency = 0
                hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                hl.Parent = workspace
                o.highlight = hl
            else
                o.highlight.Enabled = true
                o.highlight.Adornee = model
                o.highlight.FillColor = CONFIG.ESP.BoxColor
                o.highlight.OutlineColor = CONFIG.ESP.BoxColor
            end
        elseif o.highlight then
            o.highlight.Enabled = false
        end
    end
end

local function hideAllESP()
    for _, o in pairs(ESP_OBJ) do
        hideESPObjects(o)
        if o.highlight then o.highlight.Enabled = false end
    end
end

--───────────────────────────────────────────────────────────
-- Target acquisition (sticky, team + wall aware)
--───────────────────────────────────────────────────────────
local function acquireTarget(cam)
    local camPos  = cam.CFrame.Position
    local camLook = cam.CFrame.LookVector
    local refLook = aimLookDir or camLook

    -- Sticky: keep current target if still valid
    if aimTarget then
        local data = PlayerData[aimTarget.name]
        local part = aimTarget.part
        local valid = false
        if data and data.Humanoid and data.Humanoid.Health > 0
           and part and part.Parent and part:IsA("BasePart") then
            local delta = part.Position - camPos
            local cosTol = math.cos(math.rad(CONFIG.FOV * 1.5))
            if delta.Magnitude > 0.01 and refLook:Dot(delta.Unit) >= cosTol then
                if not isSameTeam(aimTarget.name) then
                    if not CONFIG.WallCheck or hasLineOfSight(part, data.Model) then
                        valid = true
                    end
                end
            end
        end
        if valid then return part, aimTarget.name end
        aimTarget = nil
    end

    -- Fresh acquisition
    local cosFov = math.cos(math.rad(CONFIG.FOV))
    local bestPart, bestDist, bestName = nil, math.huge, nil

    for name, d in pairs(PlayerData) do
        local hum   = d.Humanoid
        local model = d.Model
        if not (hum and hum.Health > 0 and model and model.Parent) then continue end
        if isSameTeam(name) then continue end

        local parts
        if CONFIG.AimAtHead then
            local head = model:FindFirstChild("Head")
            parts = (head and head:IsA("BasePart") and head.Parent) and { head } or {}
        else
            parts = d.Parts
        end

        for _, part in ipairs(parts) do
            if part and part.Parent and part:IsA("BasePart") then
                local delta = part.Position - camPos
                local dist  = delta.Magnitude
                if dist >= CONFIG.MinDistance and dist <= CONFIG.MaxDistance
                   and camLook:Dot(delta.Unit) >= cosFov
                   and dist < bestDist then
                    if not CONFIG.WallCheck or hasLineOfSight(part, model) then
                        bestDist, bestPart, bestName = dist, part, name
                    end
                end
            end
        end
    end

    if bestPart then
        aimTarget = { part = bestPart, name = bestName }
    end
    return bestPart, bestName
end

--───────────────────────────────────────────────────────────
-- Render loop
--───────────────────────────────────────────────────────────
RunService:BindToRenderStep("AimbotLogic", Enum.RenderPriority.Last.Value, function()
    if destroyed then return end
    local cam = workspace.CurrentCamera
    if not cam then return end

    local menuOpen = not minimized
    if menuOpen then
        if UserInputService.MouseBehavior ~= Enum.MouseBehavior.Default then
            UserInputService.MouseBehavior = Enum.MouseBehavior.Default
        end
        if not UserInputService.MouseIconEnabled then
            UserInputService.MouseIconEnabled = true
        end
    end

    local shouldAim = CONFIG.Enabled and not menuOpen
    if CONFIG.HoldToAim and not rightHeld then shouldAim = false end

    if shouldAim then
        local part, name = acquireTarget(cam)
        if part then
            local camPos    = cam.CFrame.Position
            local targetDir = (part.Position - camPos).Unit
            local isNew     = (lastAimName ~= name)

            if not aimLookDir then
                aimLookDir = CONFIG.SnapOnAcquire and targetDir or cam.CFrame.LookVector
            elseif CONFIG.SnapOnAcquire and isNew then
                aimLookDir = targetDir
            else
                aimLookDir = aimLookDir:Lerp(targetDir, CONFIG.AimSpeed)
                local m = aimLookDir.Magnitude
                aimLookDir = m > 0.0001 and (aimLookDir / m) or targetDir
            end

            lastAimName = name
            cam.CFrame = CFrame.lookAt(camPos, camPos + aimLookDir)
        else
            aimLookDir  = nil
            lastAimName = nil
        end
    else
        aimLookDir  = nil
        lastAimName = nil
        aimTarget   = nil
    end

    if CONFIG.ESP.Enabled then updateESP() else hideAllESP() end
end)

--───────────────────────────────────────────────────────────
-- GUI theme + helpers
--───────────────────────────────────────────────────────────
local ACCENT    = CONFIG.FovColor
local BG_DARK   = Color3.fromRGB(18, 18, 22)
local BG_MID    = Color3.fromRGB(26, 26, 32)
local BG_ROW    = Color3.fromRGB(30, 30, 36)
local TRACK_COL = Color3.fromRGB(45, 45, 52)
local TEXT_COL  = Color3.fromRGB(230, 230, 235)
local TEXT_DIM  = Color3.fromRGB(150, 150, 160)

local function round(obj, r)
    local c = Instance.new("UICorner")
    c.CornerRadius = UDim.new(0, r or 6)
    c.Parent = obj
    return c
end

local function createSlider(parent, label, min, max, default, intOnly, onChange)
    local row = Instance.new("Frame")
    row.Size = UDim2.new(1, 0, 0, 42)
    row.BackgroundTransparency = 1
    row.Parent = parent

    local lbl = Instance.new("TextLabel")
    lbl.Size = UDim2.new(1, -70, 0, 18)
    lbl.BackgroundTransparency = 1
    lbl.Text = label; lbl.TextColor3 = TEXT_COL
    lbl.Font = Enum.Font.Gotham; lbl.TextSize = 12
    lbl.TextXAlignment = Enum.TextXAlignment.Left
    lbl.Parent = row

    local val = Instance.new("TextLabel")
    val.Size = UDim2.new(0, 70, 0, 18)
    val.Position = UDim2.new(1, -70, 0, 0)
    val.BackgroundTransparency = 1
    val.TextColor3 = ACCENT; val.Font = Enum.Font.GothamBold
    val.TextSize = 12; val.TextXAlignment = Enum.TextXAlignment.Right
    val.Parent = row

    local trackF = Instance.new("Frame")
    trackF.Size = UDim2.new(1, 0, 0, 6)
    trackF.Position = UDim2.new(0, 0, 0, 24)
    trackF.BackgroundColor3 = TRACK_COL
    trackF.BorderSizePixel = 0; trackF.Parent = row
    round(trackF, 3)

    local fill = Instance.new("Frame")
    fill.Size = UDim2.fromScale((default - min) / (max - min), 1)
    fill.BackgroundColor3 = ACCENT; fill.BorderSizePixel = 0
    fill.Parent = trackF; round(fill, 3)

    local knob = Instance.new("Frame")
    knob.Size = UDim2.fromOffset(12, 12)
    knob.AnchorPoint = Vector2.new(0.5, 0.5)
    knob.Position = UDim2.new(fill.Size.X.Scale, 0, 0.5, 0)
    knob.BackgroundColor3 = Color3.new(1, 1, 1); knob.BorderSizePixel = 0
    knob.Parent = trackF; round(knob, 6)

    local function fmt(v) return intOnly and tostring(math.floor(v+0.5)) or string.format("%.2f", v) end
    local function apply(v)
        local a = math.clamp((v - min) / (max - min), 0, 1)
        fill.Size = UDim2.fromScale(a, 1)
        knob.Position = UDim2.new(a, 0, 0.5, 0)
        val.Text = fmt(v); onChange(v)
    end
    val.Text = fmt(default)

    local dragging = false
    local function fromX(x)
        local a = math.clamp((x - trackF.AbsolutePosition.X) / trackF.AbsoluteSize.X, 0, 1)
        apply(min + (max - min) * a)
    end
    trackF.InputBegan:Connect(function(i)
        if destroyed then return end
        if i.UserInputType == Enum.UserInputType.MouseButton1
        or i.UserInputType == Enum.UserInputType.Touch then
            dragging = true; fromX(i.Position.X)
        end
    end)
    track(UserInputService.InputChanged:Connect(function(i)
        if destroyed or not dragging then return end
        if i.UserInputType == Enum.UserInputType.MouseMovement
        or i.UserInputType == Enum.UserInputType.Touch then
            fromX(i.Position.X)
        end
    end))
    track(UserInputService.InputEnded:Connect(function(i)
        if destroyed then return end
        if i.UserInputType == Enum.UserInputType.MouseButton1
        or i.UserInputType == Enum.UserInputType.Touch then dragging = false end
    end))
    return row
end

local function createToggle(parent, label, default, onChange)
    local row = Instance.new("TextButton")
    row.Size = UDim2.new(1, 0, 0, 32)
    row.BackgroundColor3 = BG_ROW; row.BorderSizePixel = 0
    row.Text = ""; row.AutoButtonColor = false; row.Parent = parent
    round(row, 6)

    local lbl = Instance.new("TextLabel")
    lbl.Size = UDim2.new(1, -60, 1, 0); lbl.Position = UDim2.new(0, 10, 0, 0)
    lbl.BackgroundTransparency = 1; lbl.Text = label
    lbl.TextColor3 = TEXT_COL; lbl.Font = Enum.Font.Gotham
    lbl.TextSize = 12; lbl.TextXAlignment = Enum.TextXAlignment.Left
    lbl.Parent = row

    local pill = Instance.new("Frame")
    pill.Size = UDim2.fromOffset(34, 18)
    pill.Position = UDim2.new(1, -44, 0.5, -9)
    pill.BackgroundColor3 = default and ACCENT or TRACK_COL
    pill.BorderSizePixel = 0; pill.Parent = row; round(pill, 9)

    local knob = Instance.new("Frame")
    knob.Size = UDim2.fromOffset(14, 14)
    knob.Position = default and UDim2.new(1, -16, 0.5, -7) or UDim2.new(0, 2, 0.5, -7)
    knob.BackgroundColor3 = Color3.new(1, 1, 1); knob.BorderSizePixel = 0
    knob.Parent = pill; round(knob, 7)

    local state = default
    row.MouseButton1Click:Connect(function()
        if destroyed then return end
        state = not state
        pill.BackgroundColor3 = state and ACCENT or TRACK_COL
        knob.Position = state and UDim2.new(1, -16, 0.5, -7) or UDim2.new(0, 2, 0.5, -7)
        onChange(state)
    end)
    return row
end

--───────────────────────────────────────────────────────────
-- Main GUI
--───────────────────────────────────────────────────────────
local gui = Instance.new("ScreenGui")
gui.Name = "AimbotMenu"
gui.ResetOnSpawn = false
gui.IgnoreGuiInset = true
gui.DisplayOrder = 10
gui.Parent = LocalPlayer:WaitForChild("PlayerGui")

local PANEL_W, PANEL_H, TITLE_H = 320, 690, 38

local main = Instance.new("Frame")
main.AnchorPoint = Vector2.new(0.5, 0.5)
main.Position = UDim2.fromScale(0.5, 0.5)
main.Size = UDim2.fromOffset(PANEL_W, PANEL_H)
main.BackgroundColor3 = BG_DARK
main.BorderSizePixel = 0; main.Active = true; main.Parent = gui
round(main, 10)

local ms = Instance.new("UIStroke")
ms.Color = Color3.fromRGB(55, 55, 65); ms.Thickness = 1; ms.Parent = main

local titleBar = Instance.new("Frame")
titleBar.Size = UDim2.new(1, 0, 0, TITLE_H)
titleBar.BackgroundColor3 = BG_MID; titleBar.BorderSizePixel = 0
titleBar.Active = true; titleBar.Parent = main
round(titleBar, 10)

local tbMask = Instance.new("Frame")
tbMask.Size = UDim2.new(1, 0, 0, 12)
tbMask.Position = UDim2.new(0, 0, 1, -12)
tbMask.BackgroundColor3 = BG_MID; tbMask.BorderSizePixel = 0
tbMask.Parent = titleBar

local titleDot = Instance.new("Frame")
titleDot.Size = UDim2.fromOffset(8, 8)
titleDot.Position = UDim2.new(0, 14, 0.5, -4)
titleDot.BackgroundColor3 = ACCENT; titleDot.BorderSizePixel = 0
titleDot.Parent = titleBar; round(titleDot, 4)

local titleLbl = Instance.new("TextLabel")
titleLbl.Position = UDim2.new(0, 30, 0, 0)
titleLbl.Size = UDim2.new(1, -90, 1, 0)
titleLbl.BackgroundTransparency = 1
titleLbl.Text = "AIMBOT + ESP"; titleLbl.TextColor3 = TEXT_COL
titleLbl.Font = Enum.Font.GothamBold; titleLbl.TextSize = 13
titleLbl.TextXAlignment = Enum.TextXAlignment.Left
titleLbl.Parent = titleBar

local minBtn = Instance.new("TextButton")
minBtn.Size = UDim2.fromOffset(22, 22)
minBtn.Position = UDim2.new(1, -56, 0.5, -11)
minBtn.BackgroundColor3 = Color3.fromRGB(50, 50, 58); minBtn.BorderSizePixel = 0
minBtn.Text = "–"; minBtn.TextColor3 = TEXT_COL
minBtn.Font = Enum.Font.GothamBold; minBtn.TextSize = 14
minBtn.AutoButtonColor = false; minBtn.Parent = titleBar
round(minBtn, 5)

local closeBtn = Instance.new("TextButton")
closeBtn.Size = UDim2.fromOffset(22, 22)
closeBtn.Position = UDim2.new(1, -30, 0.5, -11)
closeBtn.BackgroundColor3 = Color3.fromRGB(60, 40, 45); closeBtn.BorderSizePixel = 0
closeBtn.Text = "×"; closeBtn.TextColor3 = Color3.fromRGB(255, 180, 180)
closeBtn.Font = Enum.Font.GothamBold; closeBtn.TextSize = 16
closeBtn.AutoButtonColor = false; closeBtn.Parent = titleBar
round(closeBtn, 5)

local content = Instance.new("ScrollingFrame")
content.Size = UDim2.new(1, -20, 1, -TITLE_H - 10)
content.Position = UDim2.new(0, 10, 0, TITLE_H + 5)
content.BackgroundTransparency = 1; content.BorderSizePixel = 0
content.ScrollBarThickness = 4
content.ScrollBarImageColor3 = Color3.fromRGB(80, 80, 90)
content.CanvasSize = UDim2.new(0, 0, 0, 0)
content.AutomaticCanvasSize = Enum.AutomaticSize.Y
content.Parent = main

local list = Instance.new("UIListLayout")
list.Padding = UDim.new(0, 6)
list.SortOrder = Enum.SortOrder.LayoutOrder
list.Parent = content

local ORDER = 0
local function nextOrder() ORDER = ORDER + 1; return ORDER end
local function sectionHeader(text)
    local h = Instance.new("TextLabel")
    h.Size = UDim2.new(1, 0, 0, 22)
    h.BackgroundTransparency = 1
    h.Text = text:upper()
    h.TextColor3 = TEXT_DIM; h.Font = Enum.Font.GothamBold
    h.TextSize = 10; h.TextXAlignment = Enum.TextXAlignment.Left
    h.LayoutOrder = nextOrder(); h.Parent = content
    return h
end

--────── AIMBOT ────────────────────────────────────────────
createToggle(content, "Aimbot Enabled", CONFIG.Enabled, function(v) CONFIG.Enabled = v end).LayoutOrder = nextOrder()
createToggle(content, "Hold Right Click to Aim", CONFIG.HoldToAim, function(v) CONFIG.HoldToAim = v end).LayoutOrder = nextOrder()
createToggle(content, "Aim at Head (exact)", CONFIG.AimAtHead, function(v) CONFIG.AimAtHead = v end).LayoutOrder = nextOrder()
createToggle(content, "Snap on Acquire", CONFIG.SnapOnAcquire, function(v) CONFIG.SnapOnAcquire = v end).LayoutOrder = nextOrder()
createToggle(content, "Team Check (attribute)", CONFIG.TeamCheck, function(v)
    CONFIG.TeamCheck = v
    if v then
        local myTeam = getPlayerTeam(LocalPlayer)
        print(("[TeamCheck] Local team = %s (%s)"):format(
            tostring(myTeam),
            myTeam and ("enemies are team " .. (myTeam == 1 and "2" or "1")) or "unknown"
        ))
    end
end).LayoutOrder = nextOrder()
createToggle(content, "Wall Check (raycast)", CONFIG.WallCheck, function(v) CONFIG.WallCheck = v end).LayoutOrder = nextOrder()
createToggle(content, "Show FOV Circle", CONFIG.ShowFovCircle, function(v)
    CONFIG.ShowFovCircle = v; fovFrame.Visible = v
end).LayoutOrder = nextOrder()

sectionHeader("Aim Tuning")
createSlider(content, "FOV (deg)", 10, 180, CONFIG.FOV, true, function(v) CONFIG.FOV = v end).LayoutOrder = nextOrder()
createSlider(content, "Aim Smoothing", 0.05, 1.0, CONFIG.AimSpeed, false, function(v) CONFIG.AimSpeed = v end).LayoutOrder = nextOrder()
createSlider(content, "Min Distance", 0, 100, CONFIG.MinDistance, true, function(v) CONFIG.MinDistance = v end).LayoutOrder = nextOrder()
createSlider(content, "Max Distance", 50, 500, CONFIG.MaxDistance, true, function(v) CONFIG.MaxDistance = v end).LayoutOrder = nextOrder()
createSlider(content, "FOV Circle Radius", 20, 200, CONFIG.FovRadius, true, function(v)
    CONFIG.FovRadius = v; fovFrame.Size = UDim2.fromOffset(v*2, v*2)
end).LayoutOrder = nextOrder()

--────── ESP ───────────────────────────────────────────────
sectionHeader("ESP")
createToggle(content, "ESP Enabled", CONFIG.ESP.Enabled, function(v)
    CONFIG.ESP.Enabled = v
    if not v then hideAllESP() end
end).LayoutOrder = nextOrder()
createToggle(content, "Box", CONFIG.ESP.Box, function(v) CONFIG.ESP.Box = v end).LayoutOrder = nextOrder()
createToggle(content, "Name", CONFIG.ESP.Name, function(v) CONFIG.ESP.Name = v end).LayoutOrder = nextOrder()
createToggle(content, "Distance", CONFIG.ESP.Distance, function(v) CONFIG.ESP.Distance = v end).LayoutOrder = nextOrder()
createToggle(content, "Health Bar", CONFIG.ESP.Health, function(v) CONFIG.ESP.Health = v end).LayoutOrder = nextOrder()
createToggle(content, "Tracer", CONFIG.ESP.Tracer, function(v) CONFIG.ESP.Tracer = v end).LayoutOrder = nextOrder()
createToggle(content, "Highlight (through walls)", CONFIG.ESP.Highlight, function(v)
    CONFIG.ESP.Highlight = v
    if not v then
        for _, o in pairs(ESP_OBJ) do
            if o.highlight then o.highlight.Enabled = false end
        end
    end
end).LayoutOrder = nextOrder()
createToggle(content, "ESP Wall Check (hide behind walls)", CONFIG.ESP.WallCheck, function(v) CONFIG.ESP.WallCheck = v end).LayoutOrder = nextOrder()
createSlider(content, "ESP Max Distance", 50, 2000, CONFIG.ESP.MaxDistance, true, function(v)
    CONFIG.ESP.MaxDistance = v
end).LayoutOrder = nextOrder()
createSlider(content, "ESP / FOV Hue", 0, 360, 160, true, function(v)
    local c = Color3.fromHSV(v/360, 0.9, 1.0)
    CONFIG.ESP.BoxColor = c
    CONFIG.FovColor = c
    fovStroke.Color = c
    titleDot.BackgroundColor3 = c
end).LayoutOrder = nextOrder()

--───────────────────────────────────────────────────────────
-- Minimize helper
--───────────────────────────────────────────────────────────
local fullSize = UDim2.fromOffset(PANEL_W, PANEL_H)

local function setMinimized(v)
    if destroyed then return end
    minimized = v
    content.Visible = not v
    main.Size = v and UDim2.fromOffset(PANEL_W, TITLE_H) or fullSize
    minBtn.Text = v and "+" or "–"
end

minBtn.MouseButton1Click:Connect(function()
    if destroyed then return end
    setMinimized(not minimized)
end)

--───────────────────────────────────────────────────────────
-- Terminate
--───────────────────────────────────────────────────────────
local function terminate()
    if destroyed then return end
    destroyed = true

    pcall(function() RunService:UnbindFromRenderStep("AimbotLogic") end)

    for _, c in ipairs(CONNECTIONS) do
        pcall(function() c:Disconnect() end)
    end
    CONNECTIONS = {}

    for _, o in pairs(ESP_OBJ) do
        for k, obj in pairs(o) do
            if typeof(obj) == "Instance" then
                pcall(function() obj:Destroy() end)
            else
                pcall(function() obj:Remove() end)
            end
        end
    end
    ESP_OBJ = {}

    for _, hl in ipairs(workspace:GetDescendants()) do
        if hl:IsA("Highlight") and hl.Name == "AimbotESP_HL" then
            pcall(function() hl:Destroy() end)
        end
    end

    pcall(function() fovGui:Destroy() end)
    pcall(function() gui:Destroy() end)

    PlayerData = {}
    aimLookDir = nil
    aimTarget  = nil

    print("[Aimbot+ESP] Terminated.")
end

closeBtn.MouseButton1Click:Connect(terminate)

--───────────────────────────────────────────────────────────
-- Dragging
--───────────────────────────────────────────────────────────
local dragStart, startPos
titleBar.InputBegan:Connect(function(i)
    if destroyed then return end
    if i.UserInputType == Enum.UserInputType.MouseButton1
    or i.UserInputType == Enum.UserInputType.Touch then
        dragStart = i.Position; startPos = main.Position
    end
end)
track(UserInputService.InputChanged:Connect(function(i)
    if destroyed or not dragStart then return end
    if i.UserInputType == Enum.UserInputType.MouseMovement
    or i.UserInputType == Enum.UserInputType.Touch then
        local d = i.Position - dragStart
        main.Position = UDim2.new(
            startPos.X.Scale, startPos.X.Offset + d.X,
            startPos.Y.Scale, startPos.Y.Offset + d.Y)
    end
end))
track(UserInputService.InputEnded:Connect(function(i)
    if destroyed then return end
    if i.UserInputType == Enum.UserInputType.MouseButton1
    or i.UserInputType == Enum.UserInputType.Touch then dragStart = nil end
end))

--───────────────────────────────────────────────────────────
-- Hotkeys + right-click tracking
--───────────────────────────────────────────────────────────
track(UserInputService.InputBegan:Connect(function(i, processed)
    if destroyed then return end

    if i.UserInputType == Enum.UserInputType.MouseButton2 then
        rightHeld = true
    end

    if processed then return end

    if i.KeyCode == CONFIG.ToggleKey then
        CONFIG.Enabled = not CONFIG.Enabled
        print(("[Aimbot] %s"):format(CONFIG.Enabled and "Enabled" or "Disabled"))
    elseif i.KeyCode == Enum.KeyCode.L then
        CONFIG.ESP.Enabled = not CONFIG.ESP.Enabled
        if not CONFIG.ESP.Enabled then hideAllESP() end
        print(("[ESP] %s"):format(CONFIG.ESP.Enabled and "Enabled" or "Disabled"))
    elseif i.KeyCode == CONFIG.MenuKey then
        setMinimized(not minimized)
        print(("[Menu] %s"):format(minimized and "Minimized" or "Restored"))
    end
end))

track(UserInputService.InputEnded:Connect(function(i)
    if destroyed then return end
    if i.UserInputType == Enum.UserInputType.MouseButton2 then
        rightHeld = false
    end
end))

print("[Aimbot+ESP] v9 loaded.  K = aim,  L = ESP,  Home = minimize/restore,  × = terminate.")
print("[Aimbot+ESP] Team check: Players:FindFirstChild(name) → player.Character:GetAttribute('team').")