Source Code AIM ESP TEAMCHECK CHAMS NO BANS

-- This WILL NOT WORK ON LOW UNC EXECUTORS LIKE XENO
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")
local Lighting = game:GetService("Lighting")

local LocalPlayer = Players.LocalPlayer


local Tuning = {
    CacheInterval = 0.2,
    TeamScanInterval = 0.5,
    CleanupInterval = 1.0,
    ChamsUpdateInterval = 0.15,
    
    BoxRatio = 0.55,
    CornerLength = 10,
    TracerThickness = 1.5,
    BoxThickness = 1.5,
    
    NameSize = 14,
    DistSize = 12,
    NameOffset = 18,
    DistOffset = 6,
    
    MinBoxSize = 20,
    MaxBoxSize = 400,
    
    MenuWidth = 280,
    MenuItemHeight = 28,
    MenuPadding = 12,
    TabHeight = 32
}

local Palette = {
    Enemy = Color3.fromRGB(255, 75, 85),
    EnemyAlt = Color3.fromRGB(255, 120, 130),
    Friendly = Color3.fromRGB(80, 180, 255),
    Checking = Color3.fromRGB(150, 150, 150),
    Dead = Color3.fromRGB(120, 120, 130),
    
    MenuBg = Color3.fromRGB(18, 18, 22),
    MenuPanel = Color3.fromRGB(24, 24, 30),
    MenuBorder = Color3.fromRGB(45, 45, 55),
    MenuAccent = Color3.fromRGB(255, 75, 85),
    MenuAccentDim = Color3.fromRGB(180, 55, 65),
    MenuText = Color3.fromRGB(235, 235, 240),
    MenuTextDim = Color3.fromRGB(140, 140, 150),
    MenuEnabled = Color3.fromRGB(85, 220, 120),
    MenuDisabled = Color3.fromRGB(70, 70, 80),
    
    Tracer = Color3.fromRGB(255, 140, 100),
    ChamsOutline = Color3.fromRGB(255, 255, 255),
    ChamsFill = Color3.fromRGB(255, 75, 85)
}

local Settings = {
    ESP_Enabled = true,
    ESP_Box = true,
    ESP_BoxStyle = 1,
    ESP_BoxFill = false,
    ESP_Name = true,
    ESP_Distance = true,
    ESP_Tracer = false,
    ESP_TracerOrigin = 1,
    ESP_TeamCheck = true,
    ESP_Chams = false,
    ESP_ChamsOutline = true,
    ESP_MaxDistance = 500,
    
    AIM_Enabled = false,
    AIM_FOV = 180,
    AIM_Smooth = 0.18,
    AIM_ShowFOV = true,
    AIM_TargetPart = 1,
    AIM_TeamCheck = true,
    
    MenuOpen = true
}

local State = {
    Unloaded = false,
    LastCache = 0,
    LastTeamScan = 0,
    LastCleanup = 0,
    LastChamsUpdate = 0,
    CurrentTab = 1,
    MenuPos = nil,
    MenuDragging = false,
    MenuDragOffset = Vector2.zero
}

local Cache = {
    Soldiers = {},
    Positions = {},
    Friendlies = {},
    FriendlyScores = {},
    ConfirmedEnemies = {},
    EnemyConfirmations = {},
    FriendlyIndicators = {},
    LastFriendlyUpdate = {}
}

local ESP = {
    Objects = {},
    Pool = {},
    PoolIndex = 0
}

local Chams = {
    Objects = {}
}

local Menu = {
    Drawings = {},
    Tabs = {"ESP", "AIM"},
    Items = {}
}

local CharacterFolder = nil
local Connections = {}

local function ClampVector2(v, minX, maxX, minY, maxY)
    return Vector2.new(
        math.clamp(v.X, minX, maxX),
        math.clamp(v.Y, minY, maxY)
    )
end

local function IsValidModel(model)
    if not model or not model.Parent then return false end
    local root = model:FindFirstChild("humanoid_root_part")
    return root ~= nil and root.Parent ~= nil
end

local function GetRoot(model)
    return model:FindFirstChild("humanoid_root_part")
end

local function GetHead(model)
    return model:FindFirstChild("head")
end

local function GetTorso(model)
    return model:FindFirstChild("torso")
end

local function GetLocalRoot()
    local char = LocalPlayer.Character
    if not char then return nil end
    return char:FindFirstChild("HumanoidRootPart") or char:FindFirstChild("humanoid_root_part")
end

local function GetLocalPosition()
    local root = GetLocalRoot()
    if root then return root.Position end
    local cam = Workspace.CurrentCamera
    return cam and cam.CFrame.Position or Vector3.zero
end

local function IsLocalPlayer(model)
    local char = LocalPlayer.Character
    if not char then return false end
    if model == char then return true end
    local myRoot = GetLocalRoot()
    local modelRoot = GetRoot(model)
    if myRoot and modelRoot then
        return (myRoot.Position - modelRoot.Position).Magnitude < 1
    end
    return false
end

local function ScanFriendlyIndicators()
    Cache.FriendlyIndicators = {}
    
    if not Settings.ESP_TeamCheck then return end
    
    local playerGui = LocalPlayer:FindFirstChild("PlayerGui")
    if not playerGui then return end
    
    local count = 0
    local maxIndicators = 50
    
    local descendants = playerGui:GetDescendants()
    for i = 1, #descendants do
        if count >= maxIndicators then break end
        
        local gui = descendants[i]
        if not gui:IsA("GuiObject") or not gui.Visible then continue end
        
        local size = gui.AbsoluteSize
        if size.X <= 0 or size.Y <= 0 or size.X >= 20 or size.Y >= 20 then continue end
        
        local isIndicator = false
        
        if gui:IsA("Frame") and gui.BackgroundTransparency < 0.9 then
            local col = gui.BackgroundColor3
            if col.G > 0.5 or col.B > 0.5 then
                isIndicator = true
            end
        elseif gui:IsA("ImageLabel") and gui.ImageTransparency < 0.5 and gui.Image ~= "" then
            isIndicator = true
        end
        
        if isIndicator then
            local pos = gui.AbsolutePosition
            Cache.FriendlyIndicators[count + 1] = Vector2.new(pos.X + size.X/2, pos.Y + size.Y/2)
            count = count + 1
        end
    end
end

local function UpdateFriendlyStatus()
    if not Settings.ESP_TeamCheck then
        return
    end
    
    local cam = Workspace.CurrentCamera
    if not cam then return end
    
    local processedModels = {}
    
    for model, data in pairs(Cache.Soldiers) do
        if not IsValidModel(model) then
            Cache.Friendlies[model] = nil
            Cache.FriendlyScores[model] = nil
            Cache.ConfirmedEnemies[model] = nil
            Cache.EnemyConfirmations[model] = nil
            continue
        end
        
        local root = GetRoot(model)
        if not root then continue end
        
        local screenPos, onScreen = cam:WorldToViewportPoint(root.Position)
        
        if Cache.ConfirmedEnemies[model] then
            continue
        end
        
        if not onScreen or screenPos.Z <= 0 then
            local enemyConfirms = Cache.EnemyConfirmations[model] or 0
            if enemyConfirms > 0 then
                Cache.EnemyConfirmations[model] = enemyConfirms + 1
                if Cache.EnemyConfirmations[model] >= 2 then
                    Cache.ConfirmedEnemies[model] = true
                    Cache.Friendlies[model] = nil
                    Cache.EnemyConfirmations[model] = 999
                end
            end
            continue
        end
        
        processedModels[model] = true
        
        local screenPos2D = Vector2.new(screenPos.X, screenPos.Y)
        local foundIndicator = false
        
        for i = 1, #Cache.FriendlyIndicators do
            local indicator = Cache.FriendlyIndicators[i]
            local dist = (indicator - screenPos2D).Magnitude
            if dist < 120 then
                foundIndicator = true
                break
            end
        end
        
        local currentScore = Cache.FriendlyScores[model] or 0
        local enemyConfirms = Cache.EnemyConfirmations[model] or 0
        
        if foundIndicator then
            currentScore = math.min(currentScore + 2, 8)
            enemyConfirms = math.max(enemyConfirms - 2, 0)
        else
            currentScore = math.max(currentScore - 1, 0)
            enemyConfirms = enemyConfirms + 2
        end
        
        Cache.FriendlyScores[model] = currentScore
        Cache.EnemyConfirmations[model] = enemyConfirms
        Cache.LastFriendlyUpdate[model] = tick()
        
        if currentScore >= 3 then
            Cache.Friendlies[model] = true
            Cache.ConfirmedEnemies[model] = nil
            Cache.EnemyConfirmations[model] = 0
        elseif enemyConfirms >= 2 then
            Cache.Friendlies[model] = nil
            Cache.ConfirmedEnemies[model] = true
            Cache.EnemyConfirmations[model] = 999
        elseif currentScore <= 0 then
            Cache.Friendlies[model] = nil
        end
    end
    
    for model in pairs(Cache.FriendlyScores) do
        if not processedModels[model] and Cache.Soldiers[model] then
            if not Cache.ConfirmedEnemies[model] then
                local lastUpdate = Cache.LastFriendlyUpdate[model] or 0
                if tick() - lastUpdate > 2 then
                    Cache.FriendlyScores[model] = math.max((Cache.FriendlyScores[model] or 0) - 1, 0)
                    Cache.LastFriendlyUpdate[model] = tick()
                    
                    if Cache.FriendlyScores[model] <= 0 then
                        Cache.Friendlies[model] = nil
                    end
                end
            end
        end
    end
end

local function IsFriendly(model)
    if not Settings.ESP_TeamCheck then return false end
    if Cache.ConfirmedEnemies[model] then return false end
    return Cache.Friendlies[model] == true
end

local function IsChecking(model)
    if not Settings.ESP_TeamCheck then return false end
    if Cache.ConfirmedEnemies[model] then return false end
    if Cache.Friendlies[model] == true then return false end
    return true
end

local function GetPlayerStatus(model)
    if not Settings.ESP_TeamCheck then
        return "neutral", Palette.Enemy
    end
    
    if Cache.ConfirmedEnemies[model] then
        return "enemy", Palette.Enemy
    end
    
    if Cache.Friendlies[model] == true then
        return "friendly", Palette.Friendly
    end
    
    return "checking", Palette.Checking
end

local function CreateESPObject()
    local obj = {
        Box = {},
        Corners = {},
        Name = Drawing.new("Text"),
        Distance = Drawing.new("Text"),
        Tracer = Drawing.new("Line"),
        Fill = Drawing.new("Square")
    }
    
    for i = 1, 4 do
        obj.Box[i] = Drawing.new("Line")
        obj.Box[i].Thickness = Tuning.BoxThickness
        obj.Box[i].Visible = false
    end
    
    for i = 1, 8 do
        obj.Corners[i] = Drawing.new("Line")
        obj.Corners[i].Thickness = Tuning.BoxThickness
        obj.Corners[i].Visible = false
    end
    
    obj.Name.Size = Tuning.NameSize
    obj.Name.Font = Drawing.Fonts.Plex
    obj.Name.Center = true
    obj.Name.Outline = true
    obj.Name.Visible = false
    
    obj.Distance.Size = Tuning.DistSize
    obj.Distance.Font = Drawing.Fonts.Plex
    obj.Distance.Center = true
    obj.Distance.Outline = true
    obj.Distance.Color = Palette.MenuTextDim
    obj.Distance.Visible = false
    
    obj.Tracer.Thickness = Tuning.TracerThickness
    obj.Tracer.Visible = false
    
    obj.Fill.Filled = true
    obj.Fill.Transparency = 0.15
    obj.Fill.Visible = false
    
    return obj
end

local function HideESP(obj)
    if not obj then return end
    for i = 1, 4 do
        if obj.Box[i] then obj.Box[i].Visible = false end
    end
    for i = 1, 8 do
        if obj.Corners[i] then obj.Corners[i].Visible = false end
    end
    if obj.Name then obj.Name.Visible = false end
    if obj.Distance then obj.Distance.Visible = false end
    if obj.Tracer then obj.Tracer.Visible = false end
    if obj.Fill then obj.Fill.Visible = false end
end

local function DestroyESP(obj)
    if not obj then return end
    pcall(function()
        for i = 1, 4 do
            if obj.Box[i] then obj.Box[i]:Remove() end
        end
        for i = 1, 8 do
            if obj.Corners[i] then obj.Corners[i]:Remove() end
        end
        if obj.Name then obj.Name:Remove() end
        if obj.Distance then obj.Distance:Remove() end
        if obj.Tracer then obj.Tracer:Remove() end
        if obj.Fill then obj.Fill:Remove() end
    end)
end

local function GetPooledESP()
    ESP.PoolIndex = ESP.PoolIndex + 1
    if not ESP.Pool[ESP.PoolIndex] then
        ESP.Pool[ESP.PoolIndex] = CreateESPObject()
    end
    return ESP.Pool[ESP.PoolIndex]
end

local function ResetPool()
    for i = ESP.PoolIndex + 1, #ESP.Pool do
        HideESP(ESP.Pool[i])
    end
    ESP.PoolIndex = 0
end

local function RenderESP(obj, model, cam, screenSize, screenCenter, myPos)
    local root = GetRoot(model)
    if not root then
        HideESP(obj)
        return
    end
    
    local rootPos = root.Position
    local dist = (rootPos - myPos).Magnitude
    
    if dist > Settings.ESP_MaxDistance then
        HideESP(obj)
        return
    end
    
    local screenPos, onScreen = cam:WorldToViewportPoint(rootPos)
    
    if not onScreen or screenPos.Z <= 0 then
        HideESP(obj)
        return
    end
    
    local baseHeight = 1200 / math.max(screenPos.Z, 1)
    local boxH = math.clamp(baseHeight, Tuning.MinBoxSize, Tuning.MaxBoxSize)
    local boxW = boxH * Tuning.BoxRatio
    
    local cx, cy = screenPos.X, screenPos.Y
    local halfW, halfH = boxW / 2, boxH / 2
    local top = cy - halfH * 1.1
    local bottom = cy + halfH * 0.9
    local left = cx - halfW
    local right = cx + halfW
    
    local status, color = GetPlayerStatus(model)
    
    if Settings.ESP_Box then
        if Settings.ESP_BoxStyle == 1 then
            for i = 1, 8 do obj.Corners[i].Visible = false end
            
            obj.Box[1].From = Vector2.new(left, top)
            obj.Box[1].To = Vector2.new(right, top)
            obj.Box[2].From = Vector2.new(right, top)
            obj.Box[2].To = Vector2.new(right, bottom)
            obj.Box[3].From = Vector2.new(right, bottom)
            obj.Box[3].To = Vector2.new(left, bottom)
            obj.Box[4].From = Vector2.new(left, bottom)
            obj.Box[4].To = Vector2.new(left, top)
            
            for i = 1, 4 do
                obj.Box[i].Color = color
                obj.Box[i].Visible = true
            end
        else
            for i = 1, 4 do obj.Box[i].Visible = false end
            
            local cl = Tuning.CornerLength
            
            obj.Corners[1].From = Vector2.new(left, top)
            obj.Corners[1].To = Vector2.new(left + cl, top)
            obj.Corners[2].From = Vector2.new(left, top)
            obj.Corners[2].To = Vector2.new(left, top + cl)
            
            obj.Corners[3].From = Vector2.new(right, top)
            obj.Corners[3].To = Vector2.new(right - cl, top)
            obj.Corners[4].From = Vector2.new(right, top)
            obj.Corners[4].To = Vector2.new(right, top + cl)
            
            obj.Corners[5].From = Vector2.new(left, bottom)
            obj.Corners[5].To = Vector2.new(left + cl, bottom)
            obj.Corners[6].From = Vector2.new(left, bottom)
            obj.Corners[6].To = Vector2.new(left, bottom - cl)
            
            obj.Corners[7].From = Vector2.new(right, bottom)
            obj.Corners[7].To = Vector2.new(right - cl, bottom)
            obj.Corners[8].From = Vector2.new(right, bottom)
            obj.Corners[8].To = Vector2.new(right, bottom - cl)
            
            for i = 1, 8 do
                obj.Corners[i].Color = color
                obj.Corners[i].Visible = true
            end
        end
    else
        for i = 1, 4 do obj.Box[i].Visible = false end
        for i = 1, 8 do obj.Corners[i].Visible = false end
    end
    
    if Settings.ESP_BoxFill then
        obj.Fill.Position = Vector2.new(left, top)
        obj.Fill.Size = Vector2.new(boxW, bottom - top)
        obj.Fill.Color = color
        obj.Fill.Visible = true
    else
        obj.Fill.Visible = false
    end
    
    if Settings.ESP_Name and Settings.ESP_TeamCheck then
        if status == "friendly" then
            obj.Name.Text = "FRIENDLY"
        elseif status == "checking" then
            obj.Name.Text = "CHECKING"
        else
            obj.Name.Text = "ENEMY"
        end
        obj.Name.Position = Vector2.new(cx, top - Tuning.NameOffset)
        obj.Name.Color = color
        obj.Name.Visible = true
    else
        obj.Name.Visible = false
    end
    
    if Settings.ESP_Distance then
        obj.Distance.Text = math.floor(dist) .. "m"
        obj.Distance.Position = Vector2.new(cx, bottom + Tuning.DistOffset)
        obj.Distance.Visible = true
    else
        obj.Distance.Visible = false
    end
    
    if Settings.ESP_Tracer then
        local origin
        if Settings.ESP_TracerOrigin == 1 then
            origin = Vector2.new(screenCenter.X, screenSize.Y)
        elseif Settings.ESP_TracerOrigin == 2 then
            origin = screenCenter
        else
            origin = Vector2.new(screenCenter.X, 0)
        end
        obj.Tracer.From = origin
        obj.Tracer.To = Vector2.new(cx, bottom)
        obj.Tracer.Color = Palette.Tracer
        obj.Tracer.Visible = true
    else
        obj.Tracer.Visible = false
    end
end

local function CreateChams(model)
    if Chams.Objects[model] then return end
    
    local h = Instance.new("Highlight")
    h.Name = "Highlight"
    h.Adornee = model
    h.FillColor = Palette.ChamsFill
    h.OutlineColor = Palette.ChamsOutline
    h.FillTransparency = 0.7
    h.OutlineTransparency = Settings.ESP_ChamsOutline and 0 or 1
    h.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    h.Parent = model
    
    Chams.Objects[model] = h
end

local function UpdateChams(model)
    local h = Chams.Objects[model]
    if not h or not h.Parent then return end
    
    local status, fillColor = GetPlayerStatus(model)
    if not Settings.ESP_TeamCheck then
        fillColor = Palette.ChamsFill
    elseif status == "friendly" then
        fillColor = Palette.Friendly
    elseif status == "checking" then
        fillColor = Palette.Checking
    else
        fillColor = Palette.ChamsFill
    end
    
    h.FillColor = fillColor
    h.OutlineTransparency = Settings.ESP_ChamsOutline and 0 or 1
end

local function RemoveChams(model)
    local h = Chams.Objects[model]
    if not h then return end
    
    pcall(function() h:Destroy() end)
    Chams.Objects[model] = nil
end

local function ClearAllChams()
    for model in pairs(Chams.Objects) do
        RemoveChams(model)
    end
end

local function CacheSoldiers()
    if not CharacterFolder then return end
    
    local children = CharacterFolder:GetChildren()
    local validModels = {}
    local myPos = GetLocalPosition()
    local maxDist = Settings.ESP_MaxDistance
    
    for i = 1, #children do
        local model = children[i]
        if not model:IsA("Model") then continue end
        if not IsValidModel(model) then continue end
        if IsLocalPlayer(model) then continue end
        
        local root = GetRoot(model)
        if root then
            local dist = (root.Position - myPos).Magnitude
            if dist <= maxDist then
                validModels[model] = true
                if not Cache.Soldiers[model] then
                    Cache.Soldiers[model] = { added = tick() }
                end
            end
        end
    end
    
    for model in pairs(Cache.Soldiers) do
        if not validModels[model] then
            Cache.Soldiers[model] = nil
            Cache.Friendlies[model] = nil
            Cache.FriendlyScores[model] = nil
            Cache.ConfirmedEnemies[model] = nil
            Cache.EnemyConfirmations[model] = nil
            Cache.LastFriendlyUpdate[model] = nil
            RemoveChams(model)
        end
    end
end

local FOVCircle = Drawing.new("Circle")
FOVCircle.Thickness = 1.5
FOVCircle.NumSides = 64
FOVCircle.Filled = false
FOVCircle.Visible = false
FOVCircle.Color = Palette.MenuAccent
FOVCircle.Transparency = 0.7

local function GetClosestTarget(cam, mousePos)
    local closestTarget = nil
    local shortestDistance = Settings.AIM_FOV
    
    for model in pairs(Cache.Soldiers) do
        if Settings.AIM_TeamCheck and IsFriendly(model) then continue end
        if Settings.ESP_TeamCheck and IsChecking(model) then continue end
        if not IsValidModel(model) then continue end
        
        local targetPart
        if Settings.AIM_TargetPart == 1 then
            targetPart = GetHead(model)
        elseif Settings.AIM_TargetPart == 2 then
            targetPart = GetTorso(model)
        else
            targetPart = GetRoot(model)
        end
        
        if not targetPart then continue end
        
        local screenPos, onScreen = cam:WorldToViewportPoint(targetPart.Position)
        if not onScreen or screenPos.Z <= 0 then continue end
        
        local screenDist = (mousePos - Vector2.new(screenPos.X, screenPos.Y)).Magnitude
        if screenDist < shortestDistance then
            shortestDistance = screenDist
            closestTarget = model
        end
    end
    
    return closestTarget
end

local function ProcessAimbot(cam, screenCenter)
    local mousePos = UserInputService:GetMouseLocation()
    local isHoldingRMB = UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2)
    
    FOVCircle.Position = mousePos
    FOVCircle.Radius = Settings.AIM_FOV
    FOVCircle.Visible = Settings.AIM_Enabled and Settings.AIM_ShowFOV
    FOVCircle.Color = isHoldingRMB and Palette.MenuEnabled or Palette.MenuAccent
    
    if not Settings.AIM_Enabled then return end
    if not isHoldingRMB then return end
    
    local target = GetClosestTarget(cam, mousePos)
    if not target then return end
    
    local targetPart
    if Settings.AIM_TargetPart == 1 then
        targetPart = target:FindFirstChild("head")
    elseif Settings.AIM_TargetPart == 2 then
        targetPart = target:FindFirstChild("torso")
    else
        targetPart = target:FindFirstChild("humanoid_root_part")
    end
    
    if not targetPart then return end
    
    local screenPos = cam:WorldToViewportPoint(targetPart.Position)
    local delta = Vector2.new(screenPos.X, screenPos.Y) - mousePos
    
    mousemoverel(delta.X * Settings.AIM_Smooth, delta.Y * Settings.AIM_Smooth)
end

local MenuItems = {
    {tab = 1, label = "ESP Settings", type = "header"},
    {tab = 1, label = "Enable ESP", key = "ESP_Enabled", type = "toggle"},
    {tab = 1, label = "Box ESP", key = "ESP_Box", type = "toggle"},
    {tab = 1, label = "Box Style", key = "ESP_BoxStyle", type = "dropdown", options = {"Full", "Corner"}, optionCount = 2},
    {tab = 1, label = "Box Fill", key = "ESP_BoxFill", type = "toggle"},
    {tab = 1, label = "Name", key = "ESP_Name", type = "toggle"},
    {tab = 1, label = "Distance", key = "ESP_Distance", type = "toggle"},
    {tab = 1, label = "Max Distance", key = "ESP_MaxDistance", type = "slider", min = 500, max = 3000, step = 50},
    {tab = 1, label = "Tracer", key = "ESP_Tracer", type = "toggle"},
    {tab = 1, label = "Tracer Origin", key = "ESP_TracerOrigin", type = "dropdown", options = {"Bottom", "Center", "Top"}, optionCount = 3},
    {tab = 1, label = "Team Check", key = "ESP_TeamCheck", type = "toggle"},
    {tab = 1, label = "Chams", type = "header"},
    {tab = 1, label = "Enable Chams", key = "ESP_Chams", type = "toggle"},
    {tab = 1, label = "Chams Outline", key = "ESP_ChamsOutline", type = "toggle"},
    
    {tab = 2, label = "Aimbot Settings", type = "header"},
    {tab = 2, label = "Enable Aimbot", key = "AIM_Enabled", type = "toggle"},
    {tab = 2, label = "Show FOV", key = "AIM_ShowFOV", type = "toggle"},
    {tab = 2, label = "FOV Size", key = "AIM_FOV", type = "slider", min = 50, max = 400, step = 10},
    {tab = 2, label = "Smoothness", key = "AIM_Smooth", type = "slider", min = 0.05, max = 0.5, step = 0.01},
    {tab = 2, label = "Target Part", key = "AIM_TargetPart", type = "dropdown", options = {"Head", "Torso", "Root"}, optionCount = 3},
    {tab = 2, label = "Team Check", key = "AIM_TeamCheck", type = "toggle"}
}

local function CreateMenuDrawings()
    Menu.Drawings.Bg = Drawing.new("Square")
    Menu.Drawings.Bg.Filled = true
    Menu.Drawings.Bg.Color = Palette.MenuBg
    
    Menu.Drawings.Border = Drawing.new("Square")
    Menu.Drawings.Border.Filled = false
    Menu.Drawings.Border.Color = Palette.MenuBorder
    Menu.Drawings.Border.Thickness = 1
    
    Menu.Drawings.AccentLine = Drawing.new("Line")
    Menu.Drawings.AccentLine.Thickness = 2
    Menu.Drawings.AccentLine.Color = Palette.MenuAccent
    
    Menu.Drawings.Title = Drawing.new("Text")
    Menu.Drawings.Title.Size = 18
    Menu.Drawings.Title.Font = Drawing.Fonts.Plex
    Menu.Drawings.Title.Color = Palette.MenuAccent
    Menu.Drawings.Title.Outline = true
    Menu.Drawings.Title.Text = "DEADLINE"
    
    Menu.Drawings.Subtitle = Drawing.new("Text")
    Menu.Drawings.Subtitle.Size = 12
    Menu.Drawings.Subtitle.Font = Drawing.Fonts.Plex
    Menu.Drawings.Subtitle.Color = Palette.MenuTextDim
    Menu.Drawings.Subtitle.Outline = true
    Menu.Drawings.Subtitle.Text = "by leet"
    
    Menu.Drawings.Tabs = {}
    for i = 1, #Menu.Tabs do
        Menu.Drawings.Tabs[i] = {
            Bg = Drawing.new("Square"),
            Label = Drawing.new("Text"),
            Indicator = Drawing.new("Square")
        }
        Menu.Drawings.Tabs[i].Bg.Filled = true
        Menu.Drawings.Tabs[i].Label.Size = 14
        Menu.Drawings.Tabs[i].Label.Font = Drawing.Fonts.Plex
        Menu.Drawings.Tabs[i].Label.Center = true
        Menu.Drawings.Tabs[i].Label.Outline = true
        Menu.Drawings.Tabs[i].Indicator.Filled = true
        Menu.Drawings.Tabs[i].Indicator.Color = Palette.MenuAccent
    end
    
    Menu.Drawings.Items = {}
    for i = 1, 20 do
        Menu.Drawings.Items[i] = {
            Bg = Drawing.new("Square"),
            Label = Drawing.new("Text"),
            Value = Drawing.new("Text"),
            Toggle = Drawing.new("Square"),
            ToggleKnob = Drawing.new("Circle"),
            SliderBg = Drawing.new("Square"),
            SliderFill = Drawing.new("Square")
        }
        local item = Menu.Drawings.Items[i]
        item.Bg.Filled = true
        item.Label.Size = 14
        item.Label.Font = Drawing.Fonts.Plex
        item.Label.Outline = true
        item.Value.Size = 13
        item.Value.Font = Drawing.Fonts.Plex
        item.Value.Outline = true
        item.Toggle.Filled = true
        item.ToggleKnob.Filled = true
        item.ToggleKnob.Color = Color3.new(1, 1, 1)
        item.ToggleKnob.NumSides = 16
        item.SliderBg.Filled = true
        item.SliderBg.Color = Palette.MenuDisabled
        item.SliderFill.Filled = true
        item.SliderFill.Color = Palette.MenuAccent
    end
    
    Menu.Drawings.Footer = Drawing.new("Text")
    Menu.Drawings.Footer.Size = 11
    Menu.Drawings.Footer.Font = Drawing.Fonts.Plex
    Menu.Drawings.Footer.Color = Palette.MenuTextDim
    Menu.Drawings.Footer.Outline = true
    Menu.Drawings.Footer.Text = "[INS] Toggle  [HOME] Panic  [END] FPS"
end

local function HideMenu()
    for name, drawing in pairs(Menu.Drawings) do
        if type(drawing) == "table" then
            for _, subDrawing in pairs(drawing) do
                if type(subDrawing) == "table" then
                    for _, d in pairs(subDrawing) do
                        if d and d.Visible ~= nil then d.Visible = false end
                    end
                elseif subDrawing and subDrawing.Visible ~= nil then
                    subDrawing.Visible = false
                end
            end
        elseif drawing and drawing.Visible ~= nil then
            drawing.Visible = false
        end
    end
end

local function RenderMenu()
    if State.Unloaded or not Settings.MenuOpen then
        HideMenu()
        return
    end
    
    local cam = Workspace.CurrentCamera
    if not cam then return end
    
    local screenSize = cam.ViewportSize
    local menuW = Tuning.MenuWidth
    local titleH = 44
    local tabH = Tuning.TabHeight
    local footerH = 24
    local padding = Tuning.MenuPadding
    
    local visibleItems = 0
    for _, item in ipairs(MenuItems) do
        if item.tab == State.CurrentTab then
            visibleItems = visibleItems + 1
        end
    end
    
    local contentH = visibleItems * Tuning.MenuItemHeight + padding * 2
    local menuH = titleH + tabH + contentH + footerH
    
    if not State.MenuPos then
        State.MenuPos = Vector2.new(20, screenSize.Y / 2 - menuH / 2)
    end
    
    if State.MenuDragging then
        local mouse = UserInputService:GetMouseLocation()
        State.MenuPos = mouse - State.MenuDragOffset
        State.MenuPos = ClampVector2(State.MenuPos, 0, screenSize.X - menuW, 0, screenSize.Y - menuH)
    end
    
    local x, y = State.MenuPos.X, State.MenuPos.Y
    
    Menu.Drawings.Bg.Position = Vector2.new(x, y)
    Menu.Drawings.Bg.Size = Vector2.new(menuW, menuH)
    Menu.Drawings.Bg.Transparency = 0.97
    Menu.Drawings.Bg.Visible = true
    
    Menu.Drawings.Border.Position = Vector2.new(x, y)
    Menu.Drawings.Border.Size = Vector2.new(menuW, menuH)
    Menu.Drawings.Border.Visible = true
    
    Menu.Drawings.AccentLine.From = Vector2.new(x, y)
    Menu.Drawings.AccentLine.To = Vector2.new(x + menuW, y)
    Menu.Drawings.AccentLine.Visible = true
    
    Menu.Drawings.Title.Position = Vector2.new(x + padding, y + 10)
    Menu.Drawings.Title.Visible = true
    
    Menu.Drawings.Subtitle.Position = Vector2.new(x + padding, y + 28)
    Menu.Drawings.Subtitle.Visible = true
    
    local tabY = y + titleH
    local tabWidth = menuW / #Menu.Tabs
    
    for i, tabName in ipairs(Menu.Tabs) do
        local tabX = x + (i - 1) * tabWidth
        local isSelected = i == State.CurrentTab
        
        Menu.Drawings.Tabs[i].Bg.Position = Vector2.new(tabX, tabY)
        Menu.Drawings.Tabs[i].Bg.Size = Vector2.new(tabWidth, tabH)
        Menu.Drawings.Tabs[i].Bg.Color = isSelected and Palette.MenuPanel or Palette.MenuBg
        Menu.Drawings.Tabs[i].Bg.Transparency = 0.95
        Menu.Drawings.Tabs[i].Bg.Visible = true
        
        Menu.Drawings.Tabs[i].Label.Position = Vector2.new(tabX + tabWidth / 2, tabY + 9)
        Menu.Drawings.Tabs[i].Label.Text = tabName
        Menu.Drawings.Tabs[i].Label.Color = isSelected and Palette.MenuText or Palette.MenuTextDim
        Menu.Drawings.Tabs[i].Label.Visible = true
        
        if isSelected then
            Menu.Drawings.Tabs[i].Indicator.Position = Vector2.new(tabX, tabY + tabH - 2)
            Menu.Drawings.Tabs[i].Indicator.Size = Vector2.new(tabWidth, 2)
            Menu.Drawings.Tabs[i].Indicator.Visible = true
        else
            Menu.Drawings.Tabs[i].Indicator.Visible = false
        end
    end
    
    local contentY = y + titleH + tabH + padding
    local itemIdx = 0
    
    for _, menuItem in ipairs(MenuItems) do
        if menuItem.tab ~= State.CurrentTab then continue end
        
        itemIdx = itemIdx + 1
        if itemIdx > 20 then break end
        
        local itemY = contentY + (itemIdx - 1) * Tuning.MenuItemHeight
        local item = Menu.Drawings.Items[itemIdx]
        
        item.Bg.Position = Vector2.new(x + padding / 2, itemY)
        item.Bg.Size = Vector2.new(menuW - padding, Tuning.MenuItemHeight - 2)
        item.Bg.Color = Palette.MenuPanel
        item.Bg.Transparency = menuItem.type == "header" and 0.5 or 0.9
        item.Bg.Visible = true
        
        item.Label.Position = Vector2.new(x + padding, itemY + 6)
        item.Label.Text = menuItem.label
        item.Label.Color = menuItem.type == "header" and Palette.MenuAccent or Palette.MenuText
        item.Label.Visible = true
        
        if menuItem.type == "toggle" then
            local isOn = Settings[menuItem.key]
            local toggleX = x + menuW - padding - 36
            local toggleY = itemY + 7
            
            item.Toggle.Position = Vector2.new(toggleX, toggleY)
            item.Toggle.Size = Vector2.new(32, 14)
            item.Toggle.Color = isOn and Palette.MenuEnabled or Palette.MenuDisabled
            item.Toggle.Visible = true
            
            local knobX = isOn and (toggleX + 32 - 12) or (toggleX + 2)
            item.ToggleKnob.Position = Vector2.new(knobX + 5, toggleY + 7)
            item.ToggleKnob.Radius = 5
            item.ToggleKnob.Visible = true
            
            item.Value.Visible = false
            item.SliderBg.Visible = false
            item.SliderFill.Visible = false
            
        elseif menuItem.type == "slider" then
            local val = Settings[menuItem.key]
            local pct = (val - menuItem.min) / (menuItem.max - menuItem.min)
            local valText = menuItem.step < 1 and string.format("%.2f", val) or tostring(math.floor(val))
            
            item.Value.Position = Vector2.new(x + menuW - padding - 35, itemY + 6)
            item.Value.Text = valText
            item.Value.Color = Palette.MenuTextDim
            item.Value.Visible = true
            
            local sliderW = menuW - padding * 2 - 50
            item.SliderBg.Position = Vector2.new(x + padding, itemY + Tuning.MenuItemHeight - 6)
            item.SliderBg.Size = Vector2.new(sliderW, 3)
            item.SliderBg.Visible = true
            
            item.SliderFill.Position = Vector2.new(x + padding, itemY + Tuning.MenuItemHeight - 6)
            item.SliderFill.Size = Vector2.new(sliderW * pct, 3)
            item.SliderFill.Visible = true
            
            item.Toggle.Visible = false
            item.ToggleKnob.Visible = false
            
        elseif menuItem.type == "dropdown" then
            local val = Settings[menuItem.key]
            local optionText = menuItem.options[val] or "?"
            
            item.Value.Position = Vector2.new(x + menuW - padding - 60, itemY + 6)
            item.Value.Text = "< " .. optionText .. " >"
            item.Value.Color = Palette.MenuAccent
            item.Value.Visible = true
            
            item.Toggle.Visible = false
            item.ToggleKnob.Visible = false
            item.SliderBg.Visible = false
            item.SliderFill.Visible = false
        else
            item.Value.Visible = false
            item.Toggle.Visible = false
            item.ToggleKnob.Visible = false
            item.SliderBg.Visible = false
            item.SliderFill.Visible = false
        end
    end
    
    for i = itemIdx + 1, 20 do
        local item = Menu.Drawings.Items[i]
        item.Bg.Visible = false
        item.Label.Visible = false
        item.Value.Visible = false
        item.Toggle.Visible = false
        item.ToggleKnob.Visible = false
        item.SliderBg.Visible = false
        item.SliderFill.Visible = false
    end
    
    Menu.Drawings.Footer.Position = Vector2.new(x + padding, y + menuH - footerH + 4)
    Menu.Drawings.Footer.Visible = true
end

local function HandleMenuClick(mouse)
    if not Settings.MenuOpen or not State.MenuPos then return false end
    
    local x, y = State.MenuPos.X, State.MenuPos.Y
    local menuW = Tuning.MenuWidth
    local titleH = 44
    local tabH = Tuning.TabHeight
    local padding = Tuning.MenuPadding
    
    local visibleItems = 0
    for _, item in ipairs(MenuItems) do
        if item.tab == State.CurrentTab then
            visibleItems = visibleItems + 1
        end
    end
    
    local contentH = visibleItems * Tuning.MenuItemHeight + padding * 2
    local menuH = titleH + tabH + contentH + 24
    
    if mouse.X < x or mouse.X > x + menuW or mouse.Y < y or mouse.Y > y + menuH then
        return false
    end
    
    if mouse.Y >= y and mouse.Y <= y + titleH then
        State.MenuDragging = true
        State.MenuDragOffset = mouse - State.MenuPos
        return true
    end
    
    local tabY = y + titleH
    if mouse.Y >= tabY and mouse.Y <= tabY + tabH then
        local tabWidth = menuW / #Menu.Tabs
        for i = 1, #Menu.Tabs do
            local tabX = x + (i - 1) * tabWidth
            if mouse.X >= tabX and mouse.X <= tabX + tabWidth then
                State.CurrentTab = i
                return true
            end
        end
    end
    
    local contentY = y + titleH + tabH + padding
    local itemIdx = 0
    
    for _, menuItem in ipairs(MenuItems) do
        if menuItem.tab ~= State.CurrentTab then continue end
        
        itemIdx = itemIdx + 1
        local itemY = contentY + (itemIdx - 1) * Tuning.MenuItemHeight
        
        if mouse.Y >= itemY and mouse.Y <= itemY + Tuning.MenuItemHeight then
            if menuItem.type == "toggle" then
                Settings[menuItem.key] = not Settings[menuItem.key]
                
                if menuItem.key == "ESP_Chams" and not Settings.ESP_Chams then
                    ClearAllChams()
                end
                return true
                
            elseif menuItem.type == "dropdown" then
                local current = Settings[menuItem.key]
                current = current + 1
                if current > menuItem.optionCount then current = 1 end
                Settings[menuItem.key] = current
                return true
                
            elseif menuItem.type == "slider" then
                local sliderX = x + padding
                local sliderW = menuW - padding * 2 - 50
                local pct = math.clamp((mouse.X - sliderX) / sliderW, 0, 1)
                local val = menuItem.min + pct * (menuItem.max - menuItem.min)
                val = math.floor(val / menuItem.step + 0.5) * menuItem.step
                Settings[menuItem.key] = math.clamp(val, menuItem.min, menuItem.max)
                return true
            end
        end
    end
    
    return true
end

local function Unload()
    if State.Unloaded then return end
    State.Unloaded = true
    
    for name, conn in pairs(Connections) do
        pcall(function()
            if conn and conn.Disconnect then
                conn:Disconnect()
            end
        end)
    end
    Connections = {}
    
    for i = 1, #ESP.Pool do
        DestroyESP(ESP.Pool[i])
    end
    ESP.Pool = {}
    
    ClearAllChams()
    
    pcall(function()
        if FOVCircle then FOVCircle:Remove() end
    end)
    
    pcall(function()
        for name, drawing in pairs(Menu.Drawings) do
            if type(drawing) == "table" then
                for _, subDrawing in pairs(drawing) do
                    if type(subDrawing) == "table" then
                        for _, d in pairs(subDrawing) do
                            if d and d.Remove then d:Remove() end
                        end
                    elseif subDrawing and subDrawing.Remove then
                        subDrawing:Remove()
                    end
                end
            elseif drawing and drawing.Remove then
                drawing:Remove()
            end
        end
    end)
    
    Cache = {
        Soldiers = {},
        Positions = {},
        Friendlies = {},
        FriendlyScores = {},
        ConfirmedEnemies = {},
        EnemyConfirmations = {},
        FriendlyIndicators = {},
        LastFriendlyUpdate = {}
    }
end

local function MainLoop()
    if State.Unloaded then return end
    
    local now = tick()
    local cam = Workspace.CurrentCamera
    if not cam then return end
    
    local screenSize = cam.ViewportSize
    local screenCenter = Vector2.new(screenSize.X / 2, screenSize.Y / 2)
    
    if now - State.LastCache > Tuning.CacheInterval then
        State.LastCache = now
        CacheSoldiers()
    end
    
    if Settings.ESP_TeamCheck and now - State.LastTeamScan > Tuning.TeamScanInterval then
        State.LastTeamScan = now
        ScanFriendlyIndicators()
        UpdateFriendlyStatus()
    end
    
    if now - State.LastCleanup > Tuning.CleanupInterval then
        State.LastCleanup = now
        for model in pairs(Cache.Soldiers) do
            if not IsValidModel(model) then
                Cache.Soldiers[model] = nil
                Cache.Friendlies[model] = nil
                Cache.FriendlyScores[model] = nil
                Cache.ConfirmedEnemies[model] = nil
                Cache.EnemyConfirmations[model] = nil
                Cache.LastFriendlyUpdate[model] = nil
                RemoveChams(model)
            end
        end
    end
    
    ResetPool()
    
    if Settings.ESP_Enabled then
        local myPos = GetLocalPosition()
        local maxDistSq = Settings.ESP_MaxDistance * Settings.ESP_MaxDistance
        
        for model in pairs(Cache.Soldiers) do
            if not IsValidModel(model) then continue end
            if Settings.ESP_TeamCheck and IsFriendly(model) then continue end
            
            local root = GetRoot(model)
            if not root then continue end
            
            local rootPos = root.Position
            local distVec = rootPos - myPos
            local distSq = distVec.X * distVec.X + distVec.Y * distVec.Y + distVec.Z * distVec.Z
            if distSq > maxDistSq then continue end
            
            local espObj = GetPooledESP()
            RenderESP(espObj, model, cam, screenSize, screenCenter, myPos)
        end
    end
    
    if Settings.ESP_Chams then
        if now - State.LastChamsUpdate > Tuning.ChamsUpdateInterval then
            State.LastChamsUpdate = now
            
            for model in pairs(Cache.Soldiers) do
                if not IsValidModel(model) then continue end
                if Settings.ESP_TeamCheck and IsFriendly(model) then
                    RemoveChams(model)
                    continue
                end
                
                if not Chams.Objects[model] then
                    CreateChams(model)
                else
                    UpdateChams(model)
                end
            end
        end
    else
        if next(Chams.Objects) then
            ClearAllChams()
        end
    end
    
    ProcessAimbot(cam, screenCenter)
    RenderMenu()
end

local FPSOptimizer = {
    Enabled = false,
    LastOptimize = 0,
    OptimizeInterval = 3.0
}

local function OptimizeFPS()
    if not FPSOptimizer.Enabled then return end
    
    pcall(function()
        Lighting.GlobalShadows = false
        Lighting.ShadowSoftness = 0
        Lighting.Brightness = 1.5
        Lighting.FogEnd = 100000
        Lighting.FogStart = 0
        Lighting.Ambient = Color3.fromRGB(128, 128, 128)
    end)
    
    pcall(function()
        for _, effect in ipairs(Lighting:GetChildren()) do
            if effect:IsA("BlurEffect") or effect:IsA("BloomEffect") or 
               effect:IsA("DepthOfFieldEffect") or effect:IsA("SunRaysEffect") or
               effect:IsA("ColorCorrectionEffect") then
                effect.Enabled = false
            end
        end
    end)
    
    pcall(function()
        settings().Rendering.QualityLevel = 1
    end)
end

local function InitializeFPSOptimizer()
    Connections.FPSOptimizer = RunService.Heartbeat:Connect(function()
        if FPSOptimizer.Enabled then
            local now = tick()
            if now - FPSOptimizer.LastOptimize > FPSOptimizer.OptimizeInterval then
                OptimizeFPS()
                FPSOptimizer.LastOptimize = now
            end
        end
    end)
    
    Connections.WorkspaceDescendantAdded = Workspace.DescendantAdded:Connect(function(descendant)
        if FPSOptimizer.Enabled then
            pcall(function()
                if descendant:IsA("ParticleEmitter") or descendant:IsA("Fire") or descendant:IsA("Smoke") then
                    descendant.Enabled = false
                elseif descendant:IsA("Beam") or descendant:IsA("Trail") then
                    descendant.Enabled = false
                elseif descendant:IsA("Explosion") then
                    descendant.BlastRadius = 0
                end
            end)
        end
    end)
end

local function HandleInput(input, gameProcessed)
    if State.Unloaded then return end
    
    if input.UserInputType == Enum.UserInputType.Keyboard then
        if input.KeyCode == Enum.KeyCode.Home then
            Unload()
            return
        end
        
        if input.KeyCode == Enum.KeyCode.Insert then
            Settings.MenuOpen = not Settings.MenuOpen
            return
        end
        
        if input.KeyCode == Enum.KeyCode.End then
            FPSOptimizer.Enabled = not FPSOptimizer.Enabled
            if FPSOptimizer.Enabled then
                OptimizeFPS()
            end
            return
        end
    end
    
    if input.UserInputType == Enum.UserInputType.MouseButton1 and Settings.MenuOpen then
        local mouse = UserInputService:GetMouseLocation()
        HandleMenuClick(mouse)
    end
end

local function HandleInputEnd(input)
    if State.Unloaded then return end
    
    if input.UserInputType == Enum.UserInputType.MouseButton1 then
        State.MenuDragging = false
    end
end

local function Initialize()
    CharacterFolder = Workspace:WaitForChild("characters", 10)
    
    if not CharacterFolder then
        warn("Could not find characters folder")
        return
    end
    
    InitializeFPSOptimizer()
    CreateMenuDrawings()
    
    Connections.Render = RunService.RenderStepped:Connect(MainLoop)
    Connections.Input = UserInputService.InputBegan:Connect(HandleInput)
    Connections.InputEnd = UserInputService.InputEnded:Connect(HandleInputEnd)
    
    Connections.CharacterAdded = LocalPlayer.CharacterAdded:Connect(function()
        ClearAllChams()
        Cache.Soldiers = {}
        Cache.Friendlies = {}
        Cache.FriendlyScores = {}
        Cache.ConfirmedEnemies = {}
        Cache.EnemyConfirmations = {}
        Cache.LastFriendlyUpdate = {}
    end)
end

Initialize()