BR3X ESP

local Players           = game:GetService("Players")
local RunService        = game:GetService("RunService")
local Workspace         = game:GetService("Workspace")
local UserInputService  = game:GetService("UserInputService")
local SoundService      = game:GetService("SoundService")

local LocalPlayer       = Players.LocalPlayer
local Camera            = Workspace.CurrentCamera

local IS_MOBILE = UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled
local LOGO_ASSET_ID = 87261193955877

local MUSIC_URL = "https://raw.githubusercontent.com/robloxgamelol1/BR3XALITY-HUB-UNOFFICIAL/main/do%20not%20delete%20%F0%9F%93%B1%F0%9F%93%B1%F0%9F%93%B1.mp3"
local CACHE_DIR   = "BR3XALITY"
local MUSIC_CACHE = "BR3XALITY/music.mp3"

local Config = {
    Enabled = false,
    BatMode = false,
    FPS = 60,
    MaxDistance = 500,
    TeamCheck = false,
    ForceFFA = false,

    SkeletonEnabled = true,
    SkeletonColor = Color3.fromRGB(0, 220, 255),
    SkeletonThickness = 1.5,
    SkeletonTransparency = 0.15,
    SkeletonRainbow = false,
    SkeletonRainbowSpeed = 1,

    BoxEnabled = false,
    BoxColor = Color3.fromRGB(255, 255, 255),
    BoxThickness = 1,
    BoxTransparency = 0.3,
    BoxFill = false,
    BoxFillTransparency = 0.85,
    BoxRainbow = false,

    Tracers = false,
    TracerOrigin = "Bottom",
    TracerColor = Color3.fromRGB(255, 255, 255),
    TracerThickness = 1.5,
    TracerTransparency = 0.15,

    NameEnabled = false,
    NameColor = Color3.fromRGB(255, 255, 255),
    NameSize = 14,
    NameOutline = true,

    DistanceEnabled = false,
    DistanceColor = Color3.fromRGB(200, 200, 200),
    DistanceSize = 12,

    HealthEnabled = false,
    HealthWidth = 3,
    HealthOffset = 6,
    HealthBackground = true,

    ToolEnabled = false,
    ToolColor = Color3.fromRGB(255, 200, 100),
    ToolSize = 12,

    HeadDotEnabled = false,
    HeadDotColor = Color3.fromRGB(255, 255, 255),
    HeadDotSize = 4,
    HeadDotFilled = true,

    AimbotEnabled = false,
    AimbotKey = Enum.KeyCode.L,
    AimbotFOV = 90,
    AimbotSmoothness = 0.25,
    AimbotJitter = 0.015,
    AimbotWallCheck = true,
    AimbotPart = "Head",
    AimbotStickyTime = 0.35,
    AimbotDeadzone = 3,
    AimbotPrediction = 0.135,
    AimbotVisibleOnly = true,

    MusicEnabled = false,
    MusicVolume = 1,
    MusicLooped = true,
}

local FPSOptions = {"30", "60", "90", "120"}
local RangeOptions = {"100", "250", "500", "750", "1000", "Unlimited"}
local RangeValues = {
    ["100"] = 100, ["250"] = 250, ["500"] = 500,
    ["750"] = 750, ["1000"] = 1000, ["Unlimited"] = math.huge,
}

local R6Bones = {
    {"top:Head", "joint:Neck"}, {"joint:Neck", "center:Torso"},
    {"center:Torso", "joint:Left Shoulder"}, {"joint:Left Shoulder", "bottom:Left Arm"},
    {"center:Torso", "joint:Right Shoulder"}, {"joint:Right Shoulder", "bottom:Right Arm"},
    {"center:Torso", "joint:Left Hip"}, {"joint:Left Hip", "bottom:Left Leg"},
    {"center:Torso", "joint:Right Hip"}, {"joint:Right Hip", "bottom:Right Leg"},
}

local R15Bones = {
    {"top:Head", "joint:Neck"}, {"joint:Neck", "joint:Waist"},
    {"joint:Neck", "joint:LeftShoulder"}, {"joint:LeftShoulder", "joint:LeftElbow"},
    {"joint:LeftElbow", "joint:LeftWrist"}, {"joint:LeftWrist", "center:LeftHand"},
    {"joint:Neck", "joint:RightShoulder"}, {"joint:RightShoulder", "joint:RightElbow"},
    {"joint:RightElbow", "joint:RightWrist"}, {"joint:RightWrist", "center:RightHand"},
    {"joint:Waist", "joint:LeftHip"}, {"joint:LeftHip", "joint:LeftKnee"},
    {"joint:LeftKnee", "joint:LeftAnkle"}, {"joint:LeftAnkle", "center:LeftFoot"},
    {"joint:Waist", "joint:RightHip"}, {"joint:RightHip", "joint:RightKnee"},
    {"joint:RightKnee", "joint:RightAnkle"}, {"joint:RightAnkle", "center:RightFoot"},
}

local useDrawing = (typeof(Drawing) == "table") and (typeof(Drawing.new) == "function")

local PlayerGui = LocalPlayer:WaitForChild("PlayerGui")
local OVERLAY_NAME = "BR3XALITY_SkeletonOverlay"
local oldOverlay = PlayerGui:FindFirstChild(OVERLAY_NAME)
if oldOverlay then oldOverlay:Destroy() end

local Gui = Instance.new("ScreenGui")
Gui.Name = OVERLAY_NAME
Gui.IgnoreGuiInset = true
Gui.ResetOnSpawn = false
Gui.DisplayOrder = 10
Gui.ZIndexBehavior = Enum.ZIndexBehavior.Global
Gui.Parent = PlayerGui

local Veil = Instance.new("Frame")
Veil.Name = "BatModeOverlay"
Veil.Size = UDim2.fromScale(1, 1)
Veil.BackgroundColor3 = Color3.new(0, 0, 0)
Veil.BackgroundTransparency = 0
Veil.BorderSizePixel = 0
Veil.Visible = false
Veil.Active = false
Veil.ZIndex = 1
Veil.Parent = Gui

local TeamCache = {}

local function getTeamAttribute(plr)
    return plr:GetAttribute("Team")
        or plr:GetAttribute("TeamName")
        or plr:GetAttribute("team")
end

local function getTeamStandard(plr)
    return plr.Team and plr.Team.Name or nil
end

local function getTeamFolder(plr)
    local char = plr.Character
    if not char then return nil end
    local parent = char.Parent
    if parent and parent ~= Workspace then
        return parent.Name
    end
    return nil
end

local function resolveTeam(plr)
    local cached = TeamCache[plr]
    if cached ~= nil then return cached end
    local t = getTeamFolder(plr) or getTeamAttribute(plr) or getTeamStandard(plr)
    TeamCache[plr] = t
    return t
end

local function isTeammate(plr)
    if Config.ForceFFA then return false end
    local a = resolveTeam(plr)
    local b = resolveTeam(LocalPlayer)
    if not a or not b then return false end
    return a == b
end

Players.PlayerAdded:Connect(function(plr)
    plr.CharacterAdded:Connect(function() TeamCache[plr] = nil end)
    plr:GetPropertyChangedSignal("Team"):Connect(function() TeamCache[plr] = nil end)
end)
Players.PlayerRemoving:Connect(function(plr) TeamCache[plr] = nil end)

LocalPlayer.CharacterAdded:Connect(function()
    TeamCache[LocalPlayer] = nil
    task.wait(0.5)
    TeamCache[LocalPlayer] = nil
end)
LocalPlayer:GetPropertyChangedSignal("Team"):Connect(function() TeamCache[LocalPlayer] = nil end)

local rainbowHue = 0

local function healthColor(ratio)
    if ratio > 0.66 then return Color3.fromRGB(0, 255, 0)
    elseif ratio > 0.33 then return Color3.fromRGB(255, 200, 0)
    else return Color3.fromRGB(255, 0, 0) end
end

local function ensureFolder()
    if not isfolder or not makefolder then return false end
    if not isfolder(CACHE_DIR) then makefolder(CACHE_DIR) end
    return true
end

local function httpGet(url)
    local ok, body = pcall(function()
        if syn and syn.request then return syn.request({Url = url, Method = "GET"}).Body
        elseif request then return request({Url = url, Method = "GET"}).Body
        elseif http and http.request then return http.request({Url = url, Method = "GET"}).Body end
        return nil
    end)
    return ok and body or nil
end

local function isMp3(body)
    if not body or #body < 4 then return false end
    local h = body:sub(1, 3)
    if h == "ID3" then return true end
    return body:byte(1) == 0xFF
end

local function downloadMusic()
    if not writefile or not isfile then return false end
    if not ensureFolder() then return false end
    if isfile(MUSIC_CACHE) then
        local e = readfile and readfile(MUSIC_CACHE)
        if e and isMp3(e) then return true end
    end
    local body = httpGet(MUSIC_URL)
    if not body or not isMp3(body) then return false end
    pcall(writefile, MUSIC_CACHE, body)
    return true
end

local function loadMusic()
    if not downloadMusic() then return nil end
    if not getcustomasset then return nil end
    local ok, asset = pcall(getcustomasset, MUSIC_CACHE)
    if ok and asset then return asset end
    return nil
end

local function normalize(name)
    return string.lower(string.gsub(name, "[^%w]", ""))
end

local function buildRig(model)
    local rig = {Character = model, Parts = {}, Motors = {}, Humanoid = model:FindFirstChildOfClass("Humanoid")}
    for _, item in ipairs(model:GetDescendants()) do
        if item:IsA("BasePart") then
            if not rig.Parts[item.Name] then rig.Parts[item.Name] = item end
        elseif item:IsA("Motor6D") then
            rig.Motors[normalize(item.Name)] = item
        end
    end
    return rig
end

local function jointPosition(rig, name)
    local motor = rig.Motors[normalize(name)]
    if not motor then return nil end
    if motor.Part0 then return (motor.Part0.CFrame * motor.C0).Position end
    if motor.Part1 then return (motor.Part1.CFrame * motor.C1).Position end
    return nil
end

local function partPosition(rig, name, edge)
    local part = rig.Parts[name]
    if not part then return nil end
    if edge == "top" then return part.CFrame:PointToWorldSpace(Vector3.new(0, part.Size.Y / 2, 0)) end
    if edge == "bottom" then return part.CFrame:PointToWorldSpace(Vector3.new(0, -part.Size.Y / 2, 0)) end
    return part.Position
end

local function resolvePoint(rig, key)
    local kind, name = key:match("^([^:]+):(.+)$")
    if not kind then return nil end
    if kind == "joint" then return jointPosition(rig, name) end
    if kind == "top" or kind == "bottom" then return partPosition(rig, name, kind) end
    if kind == "center" then return partPosition(rig, name) end
    return nil
end

local function getBones(rig)
    if rig.Humanoid and rig.Humanoid.RigType == Enum.HumanoidRigType.R15 then return R15Bones end
    return R6Bones
end

local Drawings = {}
local Accumulator = 0
local MAX_BONES = math.max(#R6Bones, #R15Bones)

local function newObj(t, props)
    if not useDrawing then return nil end
    local o = Drawing.new(t)
    for k, v in pairs(props) do o[k] = v end
    return o
end

local function createDrawing(player)
    if Drawings[player] then return end
    local entry = {
        Player = player,
        Lines = {}, Rig = nil,
        Tracer = nil, Box = nil, BoxFill = nil,
        NameText = nil, DistText = nil,
        HealthBg = nil, HealthBar = nil,
        ToolText = nil, HeadCircle = nil,
    }
    if useDrawing then
        for i = 1, MAX_BONES do
            entry.Lines[i] = newObj("Line", {
                Thickness = Config.SkeletonThickness,
                Color = Config.SkeletonColor,
                Transparency = Config.SkeletonTransparency,
                Visible = false, ZIndex = 2,
            })
        end
        entry.Tracer = newObj("Line", {
            Thickness = Config.TracerThickness, Color = Config.TracerColor,
            Transparency = Config.TracerTransparency, Visible = false, ZIndex = 1,
        })
        entry.Box = newObj("Square", {
            Thickness = Config.BoxThickness, Color = Config.BoxColor,
            Transparency = Config.BoxTransparency, Filled = false, Visible = false, ZIndex = 1,
        })
        entry.BoxFill = newObj("Square", {
            Thickness = 0, Color = Config.BoxColor,
            Transparency = Config.BoxFillTransparency, Filled = true, Visible = false, ZIndex = 0,
        })
        entry.NameText = newObj("Text", {
            Size = Config.NameSize, Color = Config.NameColor,
            Outline = true, Center = true, Visible = false, ZIndex = 3,
        })
        entry.DistText = newObj("Text", {
            Size = Config.DistanceSize, Color = Config.DistanceColor,
            Outline = true, Center = true, Visible = false, ZIndex = 3,
        })
        entry.HealthBg = newObj("Line", {
            Thickness = Config.HealthWidth + 2, Color = Color3.fromRGB(0, 0, 0),
            Transparency = 0.3, Visible = false, ZIndex = 1,
        })
        entry.HealthBar = newObj("Line", {
            Thickness = Config.HealthWidth, Color = Color3.fromRGB(0, 255, 0),
            Transparency = 0, Visible = false, ZIndex = 2,
        })
        entry.ToolText = newObj("Text", {
            Size = Config.ToolSize, Color = Config.ToolColor,
            Outline = true, Center = true, Visible = false, ZIndex = 3,
        })
        entry.HeadCircle = newObj("Circle", {
            Thickness = 1, NumSides = 32, Radius = Config.HeadDotSize,
            Color = Config.HeadDotColor, Filled = Config.HeadDotFilled,
            Transparency = 0.15, Visible = false, ZIndex = 3,
        })
    end
    Drawings[player] = entry
end

local function removeDrawing(player)
    local entry = Drawings[player]
    if not entry then return end
    for _, line in ipairs(entry.Lines) do pcall(function() line:Destroy() end) end
    local extras = {"Tracer","Box","BoxFill","NameText","DistText","HealthBg","HealthBar","ToolText","HeadCircle"}
    for _, key in ipairs(extras) do
        if entry[key] then pcall(function() entry[key]:Destroy() end) end
    end
    Drawings[player] = nil
end

local function hideAll(entry)
    for _, line in ipairs(entry.Lines) do line.Visible = false end
    local extras = {"Tracer","Box","BoxFill","NameText","DistText","HealthBg","HealthBar","ToolText","HeadCircle"}
    for _, key in ipairs(extras) do
        if entry[key] then entry[key].Visible = false end
    end
end

local function project(camera, position)
    if not position then return nil end
    local point = camera:WorldToViewportPoint(position)
    if point.Z <= 0 then return nil end
    return Vector2.new(point.X, point.Y), point.Z
end

local function getTracerOrigin(camera)
    local origin = Config.TracerOrigin
    local vp = camera.ViewportSize
    if origin == "Bottom" then return Vector2.new(vp.X / 2, vp.Y)
    elseif origin == "Top" then return Vector2.new(vp.X / 2, 0)
    elseif origin == "Center" then return Vector2.new(vp.X / 2, vp.Y / 2)
    elseif origin == "Mouse" then
        local m = UserInputService:GetMouseLocation()
        return Vector2.new(m.X, m.Y)
    end
    return Vector2.new(vp.X / 2, vp.Y)
end

local function shouldDraw(player, localRoot)
    if player == LocalPlayer then return false end
    if Config.TeamCheck and isTeammate(player) then return false end
    local char = player.Character
    if not char then return false end
    local hum = char:FindFirstChildOfClass("Humanoid")
    local root = char:FindFirstChild("HumanoidRootPart")
    if not hum or not root or hum.Health <= 0 then return false end
    if localRoot and (root.Position - localRoot.Position).Magnitude > Config.MaxDistance then
        return false
    end
    return true, char, hum, root
end

local function computeBounds(rig, camera)
    local minX, minY = math.huge, math.huge
    local maxX, maxY = -math.huge, -math.huge
    local boneList = getBones(rig)
    for _, bone in ipairs(boneList) do
        for i = 1, 2 do
            local pos = resolvePoint(rig, bone[i])
            if pos then
                local screenPos = project(camera, pos)
                if screenPos then
                    minX = math.min(minX, screenPos.X)
                    maxX = math.max(maxX, screenPos.X)
                    minY = math.min(minY, screenPos.Y)
                    maxY = math.max(maxY, screenPos.Y)
                end
            end
        end
    end
    if minX == math.huge then return nil end
    local padding = 4
    return {
        minX = minX - padding, maxX = maxX + padding,
        minY = minY - padding, maxY = maxY + padding,
    }
end

local function updatePlayer(player, entry, camera, localRoot, rainbowColor)
    if not camera then hideAll(entry) return end
    local ok, char, hum, root = shouldDraw(player, localRoot)
    if not ok then hideAll(entry) return end

    if not entry.Rig or entry.Rig.Character ~= char then
        entry.Rig = buildRig(char)
    end
    local rig = entry.Rig
    if not rig.Parts.Head or not rig.Parts.HumanoidRootPart then
        entry.Rig = buildRig(char)
        rig = entry.Rig
    end

    local boneColor = Config.SkeletonRainbow and rainbowColor or Config.SkeletonColor
    local boxColor = Config.BoxRainbow and rainbowColor or Config.BoxColor

    if Config.SkeletonEnabled and Config.Enabled then
        local bones = getBones(rig)
        for index, line in ipairs(entry.Lines) do
            local bone = bones[index]
            if bone then
                local a = resolvePoint(rig, bone[1])
                local b = resolvePoint(rig, bone[2])
                local pa = project(camera, a)
                local pb = project(camera, b)
                if pa and pb then
                    line.From = pa
                    line.To = pb
                    line.Color = boneColor
                    line.Visible = true
                else
                    line.Visible = false
                end
            else
                line.Visible = false
            end
        end
    else
        for _, line in ipairs(entry.Lines) do line.Visible = false end
    end

    local bounds = computeBounds(rig, camera)

    if Config.BoxEnabled and Config.Enabled and bounds and entry.Box then
        local tl = Vector2.new(bounds.minX, bounds.minY)
        local br = Vector2.new(bounds.maxX, bounds.maxY)
        entry.Box.Size = br - tl
        entry.Box.Position = tl
        entry.Box.Color = boxColor
        entry.Box.Thickness = Config.BoxThickness
        entry.Box.Transparency = Config.BoxTransparency
        entry.Box.Visible = true
        if Config.BoxFill and entry.BoxFill then
            entry.BoxFill.Size = br - tl
            entry.BoxFill.Position = tl
            entry.BoxFill.Color = boxColor
            entry.BoxFill.Transparency = Config.BoxFillTransparency
            entry.BoxFill.Visible = true
        elseif entry.BoxFill then
            entry.BoxFill.Visible = false
        end
    else
        if entry.Box then entry.Box.Visible = false end
        if entry.BoxFill then entry.BoxFill.Visible = false end
    end

    if Config.Tracers and Config.Enabled and entry.Tracer then
        local headPoint = project(camera, partPosition(rig, "Head", "top"))
        if headPoint then
            entry.Tracer.From = getTracerOrigin(camera)
            entry.Tracer.To = headPoint
            entry.Tracer.Color = Config.TracerColor
            entry.Tracer.Thickness = Config.TracerThickness
            entry.Tracer.Transparency = Config.TracerTransparency
            entry.Tracer.Visible = true
        else
            entry.Tracer.Visible = false
        end
    elseif entry.Tracer then
        entry.Tracer.Visible = false
    end

    local headTop = project(camera, partPosition(rig, "Head", "top"))
    local headBottom = project(camera, partPosition(rig, "Head", "bottom"))

    if Config.NameEnabled and Config.Enabled and entry.NameText and headTop then
        entry.NameText.Text = player.Name
        entry.NameText.Position = Vector2.new(headTop.X, headTop.Y - Config.NameSize - 6)
        entry.NameText.Color = Config.NameColor
        entry.NameText.Size = Config.NameSize
        entry.NameText.Outline = Config.NameOutline
        entry.NameText.Visible = true
    elseif entry.NameText then
        entry.NameText.Visible = false
    end

    if Config.DistanceEnabled and Config.Enabled and entry.DistText and headBottom then
        local dist = localRoot and math.floor((root.Position - localRoot.Position).Magnitude) or 0
        entry.DistText.Text = tostring(dist) .. "m"
        entry.DistText.Position = Vector2.new(headBottom.X, headBottom.Y + 4)
        entry.DistText.Color = Config.DistanceColor
        entry.DistText.Size = Config.DistanceSize
        entry.DistText.Visible = true
    elseif entry.DistText then
        entry.DistText.Visible = false
    end

    if Config.HealthEnabled and Config.Enabled and bounds and entry.HealthBar and entry.HealthBg then
        local ratio = math.clamp(hum.Health / math.max(hum.MaxHealth, 1), 0, 1)
        local barX = bounds.minX - Config.HealthOffset
        local topY = bounds.minY
        local botY = bounds.maxY
        local fillBotY = botY - (botY - topY) * ratio
        entry.HealthBg.From = Vector2.new(barX, topY)
        entry.HealthBg.To   = Vector2.new(barX, botY)
        entry.HealthBg.Visible = Config.HealthBackground
        entry.HealthBar.From = Vector2.new(barX, fillBotY)
        entry.HealthBar.To   = Vector2.new(barX, botY)
        entry.HealthBar.Color = healthColor(ratio)
        entry.HealthBar.Thickness = Config.HealthWidth
        entry.HealthBar.Visible = true
    else
        if entry.HealthBar then entry.HealthBar.Visible = false end
        if entry.HealthBg then entry.HealthBg.Visible = false end
    end

    if Config.ToolEnabled and Config.Enabled and entry.ToolText and headBottom then
        local tool = char:FindFirstChildOfClass("Tool")
        if tool then
            entry.ToolText.Text = tool.Name
            entry.ToolText.Position = Vector2.new(headBottom.X, headBottom.Y + Config.DistanceSize + 6)
            entry.ToolText.Color = Config.ToolColor
            entry.ToolText.Size = Config.ToolSize
            entry.ToolText.Visible = true
        else
            entry.ToolText.Visible = false
        end
    elseif entry.ToolText then
        entry.ToolText.Visible = false
    end

    if Config.HeadDotEnabled and Config.Enabled and entry.HeadCircle and headTop and headBottom then
        local center = (headTop + headBottom) * 0.5
        local radius = math.max((headTop - headBottom).Magnitude * 0.5, 3)
        entry.HeadCircle.Position = center
        entry.HeadCircle.Radius = radius + Config.HeadDotSize
        entry.HeadCircle.Color = Config.HeadDotColor
        entry.HeadCircle.Filled = Config.HeadDotFilled
        entry.HeadCircle.Visible = true
    elseif entry.HeadCircle then
        entry.HeadCircle.Visible = false
    end
end

local function isVisibleFromCamera(targetChar, targetPart)
    local part = targetChar:FindFirstChild(targetPart)
    if not part then return false end
    local origin = Camera.CFrame.Position
    local direction = part.Position - origin
    local params = RaycastParams.new()
    params.FilterDescendantsInstances = {LocalPlayer.Character, targetChar}
    params.FilterType = Enum.RaycastFilterType.Blacklist
    return Workspace:Raycast(origin, direction, params) == nil
end

local function getPredictedPosition(part, prediction)
    if not part then return nil end
    if prediction <= 0 then return part.Position end
    return part.Position + (part.Velocity * prediction)
end

local aimLastTarget = nil
local aimLastTargetTime = 0

local function aimbotIsValid(char)
    local hum = char:FindFirstChildOfClass("Humanoid")
    local part = char:FindFirstChild(Config.AimbotPart)
    if not hum or not part or hum.Health <= 0 then return false end
    local plr = Players:GetPlayerFromCharacter(char)
    if plr and Config.TeamCheck and isTeammate(plr) then return false end
    return true
end

local function aimbotScore(char)
    local part = char:FindFirstChild(Config.AimbotPart)
    if not part then return nil end
    local predicted = getPredictedPosition(part, Config.AimbotPrediction)
    if not predicted then return nil end
    local screenPos, depth = project(Camera, predicted)
    if not screenPos or depth <= 0 then return nil end
    local center = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    local dist = (screenPos - center).Magnitude
    if dist > Config.AimbotFOV then return nil end
    if Config.AimbotVisibleOnly then
        if not isVisibleFromCamera(char, Config.AimbotPart) then return nil end
    elseif Config.AimbotWallCheck then
        local origin = Camera.CFrame.Position
        local direction = part.Position - origin
        local params = RaycastParams.new()
        params.FilterDescendantsInstances = {LocalPlayer.Character, char}
        params.FilterType = Enum.RaycastFilterType.Blacklist
        local result = Workspace:Raycast(origin, direction, params)
        if result and result.Instance and not result.Instance:IsDescendantOf(char) then return nil end
    end
    return dist
end

local function aimbotSelectTarget()
    local best, bestScore = nil, math.huge
    for _, char in ipairs(Workspace:GetChildren()) do
        if char:IsA("Model") and char ~= LocalPlayer.Character and aimbotIsValid(char) then
            local score = aimbotScore(char)
            if score and score < bestScore then best, bestScore = char, score end
        end
    end
    local now = tick()
    if best then
        aimLastTarget = best
        aimLastTargetTime = now
        return best
    end
    if aimLastTarget and (now - aimLastTargetTime) < Config.AimbotStickyTime then
        if aimLastTarget.Parent and aimbotIsValid(aimLastTarget) then
            local part = aimLastTarget:FindFirstChild(Config.AimbotPart)
            if part then
                local screenPos, depth = project(Camera, part.Position)
                if screenPos and depth > 0 then
                    local center = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
                    if (screenPos - center).Magnitude <= Config.AimbotFOV * 1.25 then
                        return aimLastTarget
                    end
                end
            end
        end
        aimLastTarget = nil
    end
    return nil
end

UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.KeyCode == Config.AimbotKey then
        Config.AimbotEnabled = not Config.AimbotEnabled
    end
end)

RunService.RenderStepped:Connect(function()
    if not Config.AimbotEnabled then return end
    local target = aimbotSelectTarget()
    if not target then return end
    local part = target:FindFirstChild(Config.AimbotPart)
    if not part then return end
    local predicted = getPredictedPosition(part, Config.AimbotPrediction)
    if not predicted then return end
    local targetCFrame = CFrame.lookAt(Camera.CFrame.Position, predicted)
    local screenPos = project(Camera, predicted)
    if screenPos then
        local delta = (screenPos - Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)).Magnitude
        if delta < Config.AimbotDeadzone then return end
    end
    local jitter = Vector3.new(
        (math.random() - 0.5) * Config.AimbotJitter,
        (math.random() - 0.5) * Config.AimbotJitter,
        0
    )
    Camera.CFrame = Camera.CFrame:Lerp(targetCFrame * CFrame.new(jitter), Config.AimbotSmoothness)
end)

local musicSound = nil
local musicLoaded = false

local function playMusic()
    if musicLoaded and musicSound then musicSound:Play() return true end
    local asset = loadMusic()
    if not asset then return false end
    if not musicSound then
        musicSound = Instance.new("Sound")
        musicSound.Name = "BR3XALITY_Music"
        musicSound.Looped = Config.MusicLooped
        musicSound.Volume = Config.MusicVolume
        musicSound.Parent = SoundService
    end
    musicSound.SoundId = asset
    musicSound.Volume = Config.MusicVolume
    musicSound:Play()
    musicLoaded = true
    return true
end

local function stopMusic() if musicSound then musicSound:Stop() end end
local function setMusicVolume(v)
    v = math.clamp(v, 0, 10)
    Config.MusicVolume = v
    if musicSound then musicSound.Volume = v end
end
local function setMusicLoop(v)
    Config.MusicLooped = v
    if musicSound then musicSound.Looped = v end
end

local function onPlayerAdded(player)
    createDrawing(player)
    player.CharacterAdded:Connect(function()
        local entry = Drawings[player]
        if entry then entry.Rig = nil end
        TeamCache[player] = nil
    end)
    player.CharacterRemoving:Connect(function()
        local entry = Drawings[player]
        if entry then entry.Rig = nil end
    end)
end

for _, player in ipairs(Players:GetPlayers()) do onPlayerAdded(player) end
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(removeDrawing)

local conn = RunService.RenderStepped:Connect(function(dt)
    rainbowHue = (rainbowHue + 0.003 * Config.SkeletonRainbowSpeed) % 1
    Accumulator = Accumulator + dt
    local interval = 1 / Config.FPS
    if Accumulator < interval then return end
    Accumulator = Accumulator % interval

    if not Camera then Camera = Workspace.CurrentCamera end
    local character = LocalPlayer.Character
    local localRoot = character and character:FindFirstChild("HumanoidRootPart")

    local rc = Color3.fromHSV(rainbowHue, 1, 1)
    for player, entry in pairs(Drawings) do
        if not player.Parent then
            removeDrawing(player)
        else
            local ok, err = pcall(updatePlayer, player, entry, Camera, localRoot, rc)
            if not ok then
                warn("[BR3XALITY ESP] " .. tostring(err))
            end
        end
    end
end)

local function refreshUI() Veil.Visible = Config.BatMode end

local function showVolumeWarning(onConfirm, onCancel)
    local old = Gui:FindFirstChild("VolumeWarning")
    if old then old:Destroy() end

    local backdrop = Instance.new("Frame")
    backdrop.Name = "VolumeWarning"
    backdrop.Size = UDim2.fromScale(1, 1)
    backdrop.BackgroundColor3 = Color3.new(0, 0, 0)
    backdrop.BackgroundTransparency = 0.5
    backdrop.BorderSizePixel = 0
    backdrop.ZIndex = 500
    backdrop.Parent = Gui

    local panel = Instance.new("Frame")
    panel.Size = UDim2.fromOffset(320, 180)
    panel.Position = UDim2.new(0.5, -160, 0.5, -90)
    panel.BackgroundColor3 = Color3.fromRGB(15, 15, 15)
    panel.BorderSizePixel = 0
    panel.ZIndex = 501
    panel.Parent = backdrop

    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(0, 10)
    corner.Parent = panel

    local stroke = Instance.new("UIStroke")
    stroke.Color = Color3.fromRGB(255, 80, 80)
    stroke.Thickness = 2
    stroke.Parent = panel

    local title = Instance.new("TextLabel")
    title.Size = UDim2.new(1, 0, 0, 40)
    title.Position = UDim2.fromOffset(0, 10)
    title.BackgroundTransparency = 1
    title.Text = "WARNING"
    title.TextColor3 = Color3.fromRGB(255, 80, 80)
    title.TextSize = 22
    title.Font = Enum.Font.GothamBold
    title.ZIndex = 502
    title.Parent = panel

    local body = Instance.new("TextLabel")
    body.Size = UDim2.new(1, -30, 0, 70)
    body.Position = UDim2.fromOffset(15, 55)
    body.BackgroundTransparency = 1
    body.Text = "Volume above 2 can damage hearing.\nConfirm to raise volume anyway?"
    body.TextColor3 = Color3.fromRGB(255, 255, 255)
    body.TextSize = 14
    body.Font = Enum.Font.Gotham
    body.TextWrapped = true
    body.ZIndex = 502
    body.Parent = panel

    local yes = Instance.new("TextButton")
    yes.Size = UDim2.fromOffset(120, 36)
    yes.Position = UDim2.new(0, 20, 1, -50)
    yes.BackgroundColor3 = Color3.fromRGB(200, 40, 40)
    yes.Text = "Yes, raise it"
    yes.TextColor3 = Color3.fromRGB(255, 255, 255)
    yes.TextSize = 13
    yes.Font = Enum.Font.GothamMedium
    yes.BorderSizePixel = 0
    yes.ZIndex = 502
    yes.Parent = panel

    local yc = Instance.new("UICorner")
    yc.CornerRadius = UDim.new(0, 6)
    yc.Parent = yes

    local no = Instance.new("TextButton")
    no.Size = UDim2.fromOffset(120, 36)
    no.Position = UDim2.new(1, -140, 1, -50)
    no.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
    no.Text = "Cancel"
    no.TextColor3 = Color3.fromRGB(255, 255, 255)
    no.TextSize = 13
    no.Font = Enum.Font.GothamMedium
    no.BorderSizePixel = 0
    no.ZIndex = 502
    no.Parent = panel

    local nc = Instance.new("UICorner")
    nc.CornerRadius = UDim.new(0, 6)
    nc.Parent = no

    yes.MouseButton1Click:Connect(function()
        backdrop:Destroy()
        if onConfirm then onConfirm() end
    end)

    no.MouseButton1Click:Connect(function()
        backdrop:Destroy()
        if onCancel then onCancel() end
    end)
end

local BW_THEME = {
    Text                  = Color3.fromRGB(255, 255, 255),
    Placeholder           = Color3.fromRGB(150, 150, 150),
    Background            = Color3.fromRGB(10, 10, 10),
    BackgroundSecondary   = Color3.fromRGB(20, 20, 20),
    BackgroundTertiary    = Color3.fromRGB(30, 30, 30),
    MainAccent            = Color3.fromRGB(255, 255, 255),
    MainTransparency      = 0.05,
    Border                = Color3.fromRGB(60, 60, 60),
    ToggleOn              = Color3.fromRGB(255, 255, 255),
    ToggleOff             = Color3.fromRGB(60, 60, 60),
    SliderBackground      = Color3.fromRGB(40, 40, 40),
    SliderFill            = Color3.fromRGB(255, 255, 255),
}

local Rayfield = loadstring(game:HttpGet("https://sirius.menu/gen2"))()
local Window = Rayfield:CreateWindow({
    name = "BR3XALITY",
    subtitle = IS_MOBILE and "Android" or "Visualizer",
    sidebarLayout = true,
    Icon = LOGO_ASSET_ID,
    Theme = BW_THEME,
})

local Visuals = Window:CreateTab({ name = "Visuals" })

Visuals:CreateToggle({
    name = "Master ESP",
    value = Config.Enabled,
    callback = function(v) Config.Enabled = v end,
})

Visuals:CreateToggle({
    name = "Team Check",
    value = Config.TeamCheck,
    callback = function(v) Config.TeamCheck = v end,
})

Visuals:CreateToggle({
    name = "Force FFA",
    value = Config.ForceFFA,
    callback = function(v) Config.ForceFFA = v end,
})

Visuals:CreateToggle({
    name = "Bat Mode",
    value = false,
    callback = function(v) Config.BatMode = v; refreshUI() end,
})

Visuals:CreateDropdown({
    name = "Update Rate",
    options = FPSOptions,
    value = "60",
    callback = function(v) Config.FPS = tonumber(v) or 60; Accumulator = 0 end,
})

Visuals:CreateDropdown({
    name = "Maximum Distance",
    options = RangeOptions,
    value = "500",
    callback = function(v) Config.MaxDistance = RangeValues[v] or 500 end,
})

local ESPTab = Window:CreateTab({ name = "ESP" })

ESPTab:CreateSection({ name = "Skeleton" })
ESPTab:CreateToggle({ name = "Skeleton Enabled", value = Config.SkeletonEnabled,
    callback = function(v) Config.SkeletonEnabled = v end })
ESPTab:CreateColorPicker({ name = "Skeleton Color", color = Config.SkeletonColor,
    callback = function(v)
        Config.SkeletonColor = v
        for _, e in pairs(Drawings) do
            for _, l in ipairs(e.Lines) do
                if not Config.SkeletonRainbow then l.Color = v end
            end
        end
    end })
ESPTab:CreateSlider({ name = "Skeleton Thickness", range = {0.5, 5}, increment = 0.1, value = Config.SkeletonThickness,
    callback = function(v)
        Config.SkeletonThickness = v
        for _, e in pairs(Drawings) do
            for _, l in ipairs(e.Lines) do l.Thickness = v end
        end
    end })
ESPTab:CreateSlider({ name = "Skeleton Transparency", range = {0, 1}, increment = 0.05, value = Config.SkeletonTransparency,
    callback = function(v)
        Config.SkeletonTransparency = v
        for _, e in pairs(Drawings) do
            for _, l in ipairs(e.Lines) do l.Transparency = v end
        end
    end })
ESPTab:CreateToggle({ name = "Rainbow Skeleton", value = Config.SkeletonRainbow,
    callback = function(v) Config.SkeletonRainbow = v end })
ESPTab:CreateSlider({ name = "Rainbow Speed", range = {0.1, 5}, increment = 0.1, value = Config.SkeletonRainbowSpeed,
    callback = function(v) Config.SkeletonRainbowSpeed = v end })

ESPTab:CreateSection({ name = "Bounding Box" })
ESPTab:CreateToggle({ name = "Box Enabled", value = Config.BoxEnabled,
    callback = function(v) Config.BoxEnabled = v end })
ESPTab:CreateColorPicker({ name = "Box Color", color = Config.BoxColor,
    callback = function(v)
        Config.BoxColor = v
        for _, e in pairs(Drawings) do
            if e.Box and not Config.BoxRainbow then e.Box.Color = v end
            if e.BoxFill and not Config.BoxRainbow then e.BoxFill.Color = v end
        end
    end })
ESPTab:CreateSlider({ name = "Box Thickness", range = {0.5, 5}, increment = 0.1, value = Config.BoxThickness,
    callback = function(v) Config.BoxThickness = v end })
ESPTab:CreateSlider({ name = "Box Transparency", range = {0, 1}, increment = 0.05, value = Config.BoxTransparency,
    callback = function(v) Config.BoxTransparency = v end })
ESPTab:CreateToggle({ name = "Box Fill", value = Config.BoxFill,
    callback = function(v) Config.BoxFill = v end })
ESPTab:CreateSlider({ name = "Box Fill Transparency", range = {0, 1}, increment = 0.05, value = Config.BoxFillTransparency,
    callback = function(v) Config.BoxFillTransparency = v end })
ESPTab:CreateToggle({ name = "Rainbow Box", value = Config.BoxRainbow,
    callback = function(v) Config.BoxRainbow = v end })

ESPTab:CreateSection({ name = "Tracers" })
ESPTab:CreateToggle({ name = "Tracers Enabled", value = Config.Tracers,
    callback = function(v) Config.Tracers = v end })
ESPTab:CreateDropdown({ name = "Tracer Origin", options = {"Bottom", "Center", "Top", "Mouse"}, value = "Bottom",
    callback = function(v) Config.TracerOrigin = v end })
ESPTab:CreateColorPicker({ name = "Tracer Color", color = Config.TracerColor,
    callback = function(v)
        Config.TracerColor = v
        for _, e in pairs(Drawings) do if e.Tracer then e.Tracer.Color = v end end
    end })
ESPTab:CreateSlider({ name = "Tracer Thickness", range = {0.5, 5}, increment = 0.1, value = Config.TracerThickness,
    callback = function(v) Config.TracerThickness = v end })
ESPTab:CreateSlider({ name = "Tracer Transparency", range = {0, 1}, increment = 0.05, value = Config.TracerTransparency,
    callback = function(v) Config.TracerTransparency = v end })

ESPTab:CreateSection({ name = "Name Tag" })
ESPTab:CreateToggle({ name = "Name Enabled", value = Config.NameEnabled,
    callback = function(v) Config.NameEnabled = v end })
ESPTab:CreateColorPicker({ name = "Name Color", color = Config.NameColor,
    callback = function(v)
        Config.NameColor = v
        for _, e in pairs(Drawings) do if e.NameText then e.NameText.Color = v end end
    end })
ESPTab:CreateSlider({ name = "Name Size", range = {8, 30}, increment = 1, value = Config.NameSize,
    callback = function(v)
        Config.NameSize = v
        for _, e in pairs(Drawings) do if e.NameText then e.NameText.Size = v end end
    end })
ESPTab:CreateToggle({ name = "Name Outline", value = Config.NameOutline,
    callback = function(v)
        Config.NameOutline = v
        for _, e in pairs(Drawings) do if e.NameText then e.NameText.Outline = v end end
    end })

ESPTab:CreateSection({ name = "Distance" })
ESPTab:CreateToggle({ name = "Distance Enabled", value = Config.DistanceEnabled,
    callback = function(v) Config.DistanceEnabled = v end })
ESPTab:CreateColorPicker({ name = "Distance Color", color = Config.DistanceColor,
    callback = function(v)
        Config.DistanceColor = v
        for _, e in pairs(Drawings) do if e.DistText then e.DistText.Color = v end end
    end })
ESPTab:CreateSlider({ name = "Distance Size", range = {8, 30}, increment = 1, value = Config.DistanceSize,
    callback = function(v)
        Config.DistanceSize = v
        for _, e in pairs(Drawings) do if e.DistText then e.DistText.Size = v end end
    end })

ESPTab:CreateSection({ name = "Health Bar" })
ESPTab:CreateToggle({ name = "Health Bar Enabled", value = Config.HealthEnabled,
    callback = function(v) Config.HealthEnabled = v end })
ESPTab:CreateSlider({ name = "Health Bar Width", range = {1, 10}, increment = 0.5, value = Config.HealthWidth,
    callback = function(v)
        Config.HealthWidth = v
        for _, e in pairs(Drawings) do if e.HealthBar then e.HealthBar.Thickness = v end end
    end })
ESPTab:CreateSlider({ name = "Health Bar Offset", range = {1, 30}, increment = 1, value = Config.HealthOffset,
    callback = function(v) Config.HealthOffset = v end })
ESPTab:CreateToggle({ name = "Health Bar Background", value = Config.HealthBackground,
    callback = function(v) Config.HealthBackground = v end })

ESPTab:CreateSection({ name = "Tool Display" })
ESPTab:CreateToggle({ name = "Tool Enabled", value = Config.ToolEnabled,
    callback = function(v) Config.ToolEnabled = v end })
ESPTab:CreateColorPicker({ name = "Tool Color", color = Config.ToolColor,
    callback = function(v)
        Config.ToolColor = v
        for _, e in pairs(Drawings) do if e.ToolText then e.ToolText.Color = v end end
    end })
ESPTab:CreateSlider({ name = "Tool Text Size", range = {8, 30}, increment = 1, value = Config.ToolSize,
    callback = function(v)
        Config.ToolSize = v
        for _, e in pairs(Drawings) do if e.ToolText then e.ToolText.Size = v end end
    end })

ESPTab:CreateSection({ name = "Head Dot" })
ESPTab:CreateToggle({ name = "Head Dot Enabled", value = Config.HeadDotEnabled,
    callback = function(v) Config.HeadDotEnabled = v end })
ESPTab:CreateColorPicker({ name = "Head Dot Color", color = Config.HeadDotColor,
    callback = function(v)
        Config.HeadDotColor = v
        for _, e in pairs(Drawings) do if e.HeadCircle then e.HeadCircle.Color = v end end
    end })
ESPTab:CreateSlider({ name = "Head Dot Size", range = {0, 20}, increment = 1, value = Config.HeadDotSize,
    callback = function(v) Config.HeadDotSize = v end })
ESPTab:CreateToggle({ name = "Head Dot Filled", value = Config.HeadDotFilled,
    callback = function(v)
        Config.HeadDotFilled = v
        for _, e in pairs(Drawings) do if e.HeadCircle then e.HeadCircle.Filled = v end end
    end })

local Combat = Window:CreateTab({ name = "Combat" })

Combat:CreateToggle({ name = "Aimbot", value = false,
    callback = function(v) Config.AimbotEnabled = v end })
Combat:CreateKeybind({ name = "Aimbot Key", key = IS_MOBILE and "ButtonX" or "L",
    callback = function(v) Config.AimbotKey = v end })
Combat:CreateSlider({ name = "Aimbot FOV", range = {10, 360}, increment = 5, value = 90,
    callback = function(v) Config.AimbotFOV = v end })
Combat:CreateSlider({ name = "Aimbot Smoothness", range = {0.05, 1}, increment = 0.05, value = 0.25,
    callback = function(v) Config.AimbotSmoothness = v end })
Combat:CreateSlider({ name = "Aimbot Jitter", range = {0, 0.1}, increment = 0.005, value = 0.015,
    callback = function(v) Config.AimbotJitter = v end })
Combat:CreateSlider({ name = "Aimbot Prediction", range = {0, 0.5}, increment = 0.005, value = 0.135,
    callback = function(v) Config.AimbotPrediction = v end })
Combat:CreateSlider({ name = "Aimbot Sticky Time", range = {0, 1}, increment = 0.05, value = 0.35,
    callback = function(v) Config.AimbotStickyTime = v end })
Combat:CreateSlider({ name = "Aimbot Deadzone", range = {0, 20}, increment = 1, value = 3,
    callback = function(v) Config.AimbotDeadzone = v end })
Combat:CreateDropdown({ name = "Aimbot Part", options = {"Head", "HumanoidRootPart", "UpperTorso", "LowerTorso"}, value = "Head",
    callback = function(v) Config.AimbotPart = v end })
Combat:CreateToggle({ name = "Aimbot Wall Check", value = true,
    callback = function(v) Config.AimbotWallCheck = v end })
Combat:CreateToggle({ name = "Aimbot Visible Only", value = true,
    callback = function(v) Config.AimbotVisibleOnly = v end })

local Music = Window:CreateTab({ name = "Music" })

Music:CreateToggle({ name = "Enable Music", value = false,
    callback = function(v)
        Config.MusicEnabled = v
        if v then
            if not playMusic() then Config.MusicEnabled = false end
        else
            stopMusic()
        end
    end })
Music:CreateButton({ name = "Play", callback = function() playMusic() end })
Music:CreateButton({ name = "Stop", callback = function() stopMusic() end })
Music:CreateSlider({
    name = "Volume",
    range = {0, 10},
    increment = 0.1,
    value = 1,
    callback = function(v)
        if v >= 3 then
            showVolumeWarning(
                function()
                    setMusicVolume(v)
                end,
                function()
                    setMusicVolume(Config.MusicVolume)
                end
            )
        else
            setMusicVolume(v)
        end
    end,
})
Music:CreateToggle({ name = "Loop", value = true,
    callback = function(v) setMusicLoop(v) end })