Aimbot and Esp by DeepSeek AI Lol

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Camera = workspace.CurrentCamera
local LocalPlayer = Players.LocalPlayer

local Sense = loadstring(game:HttpGet("https://sirius.menu/sense"))()
local Rayfield = loadstring(game:HttpGet("https://sirius.menu/rayfield"))()

local Window = Rayfield:CreateWindow({
    Name = "random universal aimbot and esp by deepseek",
    LoadingTitle = "Loading...",
    LoadingSubtitle = "why the fuck are you actually using this dogshit",
    ConfigurationSaving = {
        Enabled = true,
        FolderName = nil,
        FileName = "dogshitmadebychatgptlmao"
    },
    Discord = {
        Enabled = false,
        Invite = "noinvitelink",
        RememberJoins = false
    },
    KeySystem = false
})

local ESPTab = Window:CreateTab("ESP Settings", 4483362458)
local AimbotTab = Window:CreateTab("Aimbot Settings", 4483362458)

local aimbotSettings = {
    enabled = false,
    wallCheck = false,
    teamCheck = false,
    ignoreDead = false,
    targetPart = "Head",
    fov = 500,
    maxDistance = math.huge,
    smoothness = 0.3,
    prioritizeClosest = false,
    mouseMoveRel = false,
}

local targetLocked = nil

ESPTab:CreateToggle({
    Name = "Enable ESP",
    CurrentValue = false,
    Callback = function(value)
        Sense.teamSettings.enemy.enabled = value
        Sense.teamSettings.friendly.enabled = value
    end
})

ESPTab:CreateToggle({
    Name = "Enable Team Check",
    CurrentValue = false,
    Callback = function(value)
        Sense.sharedSettings.useTeamColor = value
    end
})

ESPTab:CreateToggle({
    Name = "Show Boxes",
    CurrentValue = false,
    Callback = function(value)
        Sense.teamSettings.enemy.box = value
        Sense.teamSettings.friendly.box = value
    end
})

ESPTab:CreateToggle({
    Name = "Show Tracers",
    CurrentValue = false,
    Callback = function(value)
        Sense.teamSettings.enemy.tracer = value
        Sense.teamSettings.friendly.tracer = value
    end
})

ESPTab:CreateToggle({
    Name = "Show Health Bars",
    CurrentValue = false,
    Callback = function(value)
        Sense.teamSettings.enemy.healthBar = value
        Sense.teamSettings.friendly.healthBar = value
    end
})

ESPTab:CreateToggle({
    Name = "Show Player Names",
    CurrentValue = false,
    Callback = function(value)
        Sense.teamSettings.enemy.name = value
        Sense.teamSettings.friendly.name = value
    end
})

Sense.teamSettings.enemy.boxColor = {Color3.fromRGB(0, 255, 255), 1}
Sense.teamSettings.enemy.tracerColor = {Color3.fromRGB(255, 0, 0), 1}
Sense.teamSettings.enemy.nameColor = {Color3.fromRGB(255, 255, 255), 1}
Sense.Load()

AimbotTab:CreateToggle({
    Name = "Activate Aimbot",
    CurrentValue = false,
    Callback = function(value)
        aimbotSettings.enabled = value
        if not value then
            targetLocked = nil
        end
    end
})

AimbotTab:CreateToggle({
    Name = "Wall Check",
    CurrentValue = false,
    Callback = function(value)
        aimbotSettings.wallCheck = value
    end
})

AimbotTab:CreateToggle({
    Name = "Team Check",
    CurrentValue = false,
    Callback = function(value)
        aimbotSettings.teamCheck = value
    end
})

AimbotTab:CreateToggle({
    Name = "Ignore Dead",
    CurrentValue = false,
    Callback = function(value)
        aimbotSettings.ignoreDead = value
    end
})

AimbotTab:CreateDropdown({
    Name = "Target Part",
    Options = {"Head", "HumanoidRootPart", "Torso", "Left Arm", "Right Arm", "Left Leg", "Right Leg"},
    CurrentOption = "Head",
    Callback = function(value)
        aimbotSettings.targetPart = value
    end
})

AimbotTab:CreateInput({
    Name = "FOV",
    PlaceholderText = "Default is 120",
    Callback = function(value)
        local num = tonumber(value)
        if num then
            aimbotSettings.fov = num
        else
            aimbotSettings.fov = 120
        end
    end
})

AimbotTab:CreateInput({
    Name = "Target Part",
    PlaceholderText = "Head",
    RemoveTextAfterFocusLost = false,
    Callback = function(text)
        aimbotSettings.targetPart = text
    end
})

AimbotTab:CreateInput({
    Name = "Smoothness",
    PlaceholderText = "0.3 Default (lower = faster)",
    Callback = function(value)
        local num = tonumber(value)
        if num then
            aimbotSettings.smoothness = math.clamp(num, 0, 1)
        else
            aimbotSettings.smoothness = 0.3
        end
    end
})

AimbotTab:CreateToggle({
    Name = "Prioritize Closest",
    CurrentValue = false,
    Callback = function(value)
        aimbotSettings.prioritizeClosest = value
    end
})

AimbotTab:CreateToggle({
    Name = "Use MouseMoveRel",
    CurrentValue = false,
    Callback = function(value)
        aimbotSettings.mouseMoveRel = value
    end
})

local function isVisible(targetPos, targetChar)
    if not aimbotSettings.wallCheck then return true end
    local origin = Camera.CFrame.Position
    local direction = (targetPos - origin).Unit
    local distance = (targetPos - origin).Magnitude

    local raycastParams = RaycastParams.new()
    raycastParams.FilterDescendantsInstances = {LocalPlayer.Character, targetChar}
    raycastParams.FilterType = Enum.RaycastFilterType.Blacklist
    raycastParams.IgnoreWater = true

    local raycastResult = workspace:Raycast(origin, direction * distance, raycastParams)
    if raycastResult and not raycastResult.Instance:IsDescendantOf(targetChar) then
        return false
    end

    return true
end

local function isEnemy(player)
    if not aimbotSettings.teamCheck then return true end
    return player.Team ~= LocalPlayer.Team
end

local function isValidTarget(player)
    if player == LocalPlayer then return false end
    if not isEnemy(player) then return false end
    local char = player.Character
    if not char then return false end
    local humanoid = char:FindFirstChildOfClass("Humanoid")
    local rootPart = char:FindFirstChild("HumanoidRootPart")
    if not humanoid or not rootPart then return false end
    if aimbotSettings.ignoreDead and humanoid.Health <= 0 then return false end
    return true, char, rootPart
end

local function getTargetPart(character)
    return character:FindFirstChild(aimbotSettings.targetPart) or character:FindFirstChild("HumanoidRootPart")
end

local function getClosestTarget()
    local closestTarget = nil
    local closestFov = aimbotSettings.fov
    local localChar = LocalPlayer.Character
    if not localChar then return nil end
    local localRoot = localChar:FindFirstChild("HumanoidRootPart")
    if not localRoot then return nil end

    for _, player in pairs(Players:GetPlayers()) do
        local valid, char, rootPart = isValidTarget(player)
        if valid then
            local part = getTargetPart(char)
            if part then
                local screenPos, onScreen = Camera:WorldToViewportPoint(part.Position)
                if onScreen then
                    local mousePos = UserInputService:GetMouseLocation()
                    local dist = (Vector2.new(screenPos.X, screenPos.Y) - Vector2.new(mousePos.X, mousePos.Y)).Magnitude
                    local magnitudeCheck = (part.Position - localRoot.Position).Magnitude

                    if dist <= closestFov and magnitudeCheck <= aimbotSettings.maxDistance and isVisible(part.Position, char) then
                        if not closestTarget or (aimbotSettings.prioritizeClosest and magnitudeCheck < (closestTarget.Distance or math.huge)) then
                            closestTarget = {Player = player, Part = part, Distance = magnitudeCheck, ScreenDistance = dist}
                        end
                    end
                end
            end
        end
    end

    if closestTarget then
        return closestTarget.Part, closestTarget.Player
    end
    return nil, nil
end

local function updateAimbot()
    if not aimbotSettings.enabled then
        targetLocked = nil
        return
    end

    if targetLocked then
        local valid, char = isValidTarget(targetLocked)
        if not valid or not char then
            targetLocked = nil
        else
            local part = getTargetPart(char)
            if not part or not isVisible(part.Position, char) then
                targetLocked = nil
            end
        end
    end

    if not targetLocked then
        local part, player = getClosestTarget()
        targetLocked = player
    end

    if targetLocked and targetLocked.Character then
        local part = getTargetPart(targetLocked.Character)
        if part then
            if aimbotSettings.mouseMoveRel then
                local mousePos = UserInputService:GetMouseLocation()
                local screenPos, onScreen = Camera:WorldToViewportPoint(part.Position)
                if onScreen then
                    local dx = (screenPos.X - mousePos.X) * aimbotSettings.smoothness
                    local dy = (screenPos.Y - mousePos.Y) * aimbotSettings.smoothness
                    mousemoverel(dx, dy)
                end
            else
                local currentCF = Camera.CFrame
                local targetPos = part.Position
                local newCF = CFrame.new(currentCF.Position, targetPos)
                Camera.CFrame = currentCF:Lerp(newCF, 1 - aimbotSettings.smoothness)
            end
        end
    end
end

RunService.RenderStepped:Connect(updateAimbot)