--// Aimbot Arena - Client Aim Assist + ESP
--// Place as a LocalScript in StarterPlayer > StarterPlayerScripts

--// Services
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local Camera = workspace.CurrentCamera

local LocalPlayer = Players.LocalPlayer

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

local Window = Rayfield:CreateWindow({
    Name = "Aimbot Arena",
    Icon = 0,
    LoadingTitle = "Aimbot Arena",
    LoadingSubtitle = "Aim Assist + ESP",
    Theme = "Default",

    ToggleUIKeybind = "K",

    ConfigurationSaving = {
        Enabled = true,
        FolderName = "AimbotArena",
        FileName = "Settings"
    },

    Discord = {
        Enabled = false
    },

    KeySystem = false
})

--// Settings
local Settings = {
    AimEnabled = false,
    AimOnRMB = true,

    TeamCheck = true,
    WallCheck = true,

    ESPEnabled = false,
    ESPNames = true,
    ESPDistance = true,

    FOVEnabled = true,
    FOV = 150,

    Smoothness = 0.15,

    TargetPart = "Head"
}

local HoldingRMB = false

--// ESP storage
local ESPObjects = {}

--// FOV circle
local FOVCircle = Drawing and Drawing.new("Circle")

if FOVCircle then
    FOVCircle.Visible = true
    FOVCircle.Filled = false
    FOVCircle.Thickness = 1
    FOVCircle.NumSides = 64
    FOVCircle.Radius = Settings.FOV
    FOVCircle.Transparency = 1
end

----------------------------------------------------------------
--// Utility
----------------------------------------------------------------

local function GetCharacter(player)
    if not player then
        return nil
    end

    local character = player.Character

    if not character then
        return nil
    end

    local humanoid = character:FindFirstChildOfClass("Humanoid")

    if not humanoid or humanoid.Health <= 0 then
        return nil
    end

    return character
end

local function IsEnemy(player)
    if player == LocalPlayer then
        return false
    end

    if not Settings.TeamCheck then
        return true
    end

    -- Standard Roblox team check
    if LocalPlayer.Team ~= nil and player.Team ~= nil then
        return LocalPlayer.Team ~= player.Team
    end

    return true
end

local function IsVisible(part)
    if not Settings.WallCheck then
        return true
    end

    local character = part.Parent

    local origin = Camera.CFrame.Position
    local direction = part.Position - origin

    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = {
        LocalPlayer.Character,
        Camera
    }
    params.IgnoreWater = true

    local result = workspace:Raycast(
        origin,
        direction,
        params
    )

    if not result then
        return true
    end

    return result.Instance:IsDescendantOf(character)
end

local function GetTargetPart(character)
    return character:FindFirstChild(Settings.TargetPart)
        or character:FindFirstChild("Head")
        or character:FindFirstChild("HumanoidRootPart")
end

local function GetMousePosition()
    local mousePosition = UserInputService:GetMouseLocation()

    return Vector2.new(
        mousePosition.X,
        mousePosition.Y
    )
end

----------------------------------------------------------------
--// Target selection
----------------------------------------------------------------

local function GetClosestTarget()
    local mousePosition = GetMousePosition()

    local closestPlayer = nil
    local closestPart = nil
    local closestDistance = math.huge

    for _, player in ipairs(Players:GetPlayers()) do

        if IsEnemy(player) then

            local character = GetCharacter(player)

            if character then

                local targetPart = GetTargetPart(character)

                if targetPart then

                    local screenPosition, onScreen =
                        Camera:WorldToViewportPoint(targetPart.Position)

                    if onScreen and screenPosition.Z > 0 then

                        local screenPoint = Vector2.new(
                            screenPosition.X,
                            screenPosition.Y
                        )

                        local distance =
                            (screenPoint - mousePosition).Magnitude

                        if distance <= Settings.FOV then

                            if IsVisible(targetPart) then

                                if distance < closestDistance then
                                    closestDistance = distance
                                    closestPlayer = player
                                    closestPart = targetPart
                                end

                            end
                        end
                    end
                end
            end
        end
    end

    return closestPlayer, closestPart
end

----------------------------------------------------------------
--// Aim
----------------------------------------------------------------

local function AimAt(part)
    if not part then
        return
    end

    local cameraPosition = Camera.CFrame.Position

    local desiredCFrame =
        CFrame.lookAt(cameraPosition, part.Position)

    Camera.CFrame = Camera.CFrame:Lerp(
        desiredCFrame,
        math.clamp(Settings.Smoothness, 0.01, 1)
    )
end

----------------------------------------------------------------
--// ESP
----------------------------------------------------------------

local function RemoveESP(player)
    local esp = ESPObjects[player]

    if not esp then
        return
    end

    if esp.Highlight then
        esp.Highlight:Destroy()
    end

    if esp.Billboard then
        esp.Billboard:Destroy()
    end

    ESPObjects[player] = nil
end

local function CreateESP(player)

    if player == LocalPlayer then
        return
    end

    if ESPObjects[player] then
        return
    end

    local esp = {}

    local character = GetCharacter(player)

    if not character then
        return
    end

    -- Highlight
    local highlight = Instance.new("Highlight")
    highlight.Name = "ArenaESP"
    highlight.Adornee = character
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.FillTransparency = 0.65
    highlight.OutlineTransparency = 0

    highlight.Parent = character

    esp.Highlight = highlight

    -- Billboard
    local head = character:FindFirstChild("Head")

    if head then

        local billboard = Instance.new("BillboardGui")

        billboard.Name = "ArenaESPInfo"
        billboard.Adornee = head
        billboard.Size = UDim2.fromOffset(200, 50)
        billboard.StudsOffset = Vector3.new(0, 2.5, 0)
        billboard.AlwaysOnTop = true

        local label = Instance.new("TextLabel")

        label.BackgroundTransparency = 1
        label.Size = UDim2.fromScale(1, 1)

        label.Font = Enum.Font.GothamBold
        label.TextSize = 13
        label.TextStrokeTransparency = 0.5

        label.Text = player.Name

        label.Parent = billboard
        billboard.Parent = head

        esp.Billboard = billboard
        esp.Label = label
    end

    ESPObjects[player] = esp
end

local function UpdateESP(player)

    local esp = ESPObjects[player]

    if not esp then
        return
    end

    local character = GetCharacter(player)

    if not character then
        RemoveESP(player)
        return
    end

    if esp.Highlight then
        esp.Highlight.Enabled =
            Settings.ESPEnabled and IsEnemy(player)
    end

    if esp.Label then

        if not Settings.ESPEnabled or not IsEnemy(player) then
            esp.Label.Visible = false
            return
        end

        esp.Label.Visible = true

        local text = player.Name

        if Settings.ESPDistance then

            local root = character:FindFirstChild("HumanoidRootPart")

            local localCharacter = LocalPlayer.Character
            local localRoot =
                localCharacter and
                localCharacter:FindFirstChild("HumanoidRootPart")

            if root and localRoot then

                local distance =
                    math.floor(
                        (root.Position - localRoot.Position).Magnitude
                    )

                text = text .. " [" .. distance .. "m]"
            end
        end

        if Settings.ESPNames then
            esp.Label.Text = text
        else
            esp.Label.Text = ""
        end
    end
end

local function RefreshESP()

    for _, player in ipairs(Players:GetPlayers()) do

        if player ~= LocalPlayer then

            if Settings.ESPEnabled then
                CreateESP(player)
            else
                RemoveESP(player)
            end

        end
    end
end

----------------------------------------------------------------
--// Player connections
----------------------------------------------------------------

Players.PlayerRemoving:Connect(function(player)
    RemoveESP(player)
end)

Players.PlayerAdded:Connect(function(player)

    player.CharacterAdded:Connect(function()
        task.wait(0.5)

        if Settings.ESPEnabled then
            CreateESP(player)
        end
    end)

end)

for _, player in ipairs(Players:GetPlayers()) do

    if player ~= LocalPlayer then

        player.CharacterAdded:Connect(function()
            task.wait(0.5)

            if Settings.ESPEnabled then
                CreateESP(player)
            end
        end)

    end
end

----------------------------------------------------------------
--// RMB
----------------------------------------------------------------

UserInputService.InputBegan:Connect(function(input, processed)

    if processed then
        return
    end

    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        HoldingRMB = true
    end

end)

UserInputService.InputEnded:Connect(function(input)

    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        HoldingRMB = false
    end

end)

----------------------------------------------------------------
--// Rayfield UI
----------------------------------------------------------------

local AimTab = Window:CreateTab(
    "Aim Assist",
    4483362458
)

AimTab:CreateSection("Aimbot")

AimTab:CreateToggle({
    Name = "Enable Aim Assist",
    CurrentValue = false,

    Callback = function(value)
        Settings.AimEnabled = value
    end
})

AimTab:CreateToggle({
    Name = "RMB Activation",
    CurrentValue = true,

    Callback = function(value)
        Settings.AimOnRMB = value
    end
})

AimTab:CreateToggle({
    Name = "Team Check",
    CurrentValue = true,

    Callback = function(value)
        Settings.TeamCheck = value
    end
})

AimTab:CreateToggle({
    Name = "Wall Check",
    CurrentValue = true,

    Callback = function(value)
        Settings.WallCheck = value
    end
})

AimTab:CreateSlider({
    Name = "FOV",
    Range = {25, 500},
    Increment = 5,
    Suffix = " px",
    CurrentValue = 150,

    Callback = function(value)
        Settings.FOV = value

        if FOVCircle then
            FOVCircle.Radius = value
        end
    end
})

AimTab:CreateSlider({
    Name = "Aim Smoothness",
    Range = {1, 100},
    Increment = 1,
    Suffix = "%",

    CurrentValue = 15,

    Callback = function(value)
        Settings.Smoothness = value / 100
    end
})

AimTab:CreateToggle({
    Name = "Show FOV",
    CurrentValue = true,

    Callback = function(value)
        Settings.FOVEnabled = value
    end
})

----------------------------------------------------------------
--// ESP Tab
----------------------------------------------------------------

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

ESPTab:CreateSection("Player ESP")

ESPTab:CreateToggle({
    Name = "Enable ESP",
    CurrentValue = false,

    Callback = function(value)

        Settings.ESPEnabled = value

        RefreshESP()
    end
})

ESPTab:CreateToggle({
    Name = "Names",
    CurrentValue = true,

    Callback = function(value)
        Settings.ESPNames = value
    end
})

ESPTab:CreateToggle({
    Name = "Distance",
    CurrentValue = true,

    Callback = function(value)
        Settings.ESPDistance = value
    end
})

----------------------------------------------------------------
--// Main loop
----------------------------------------------------------------

RunService.RenderStepped:Connect(function()

    ----------------------------------------------------------------
    -- FOV
    ----------------------------------------------------------------

    if FOVCircle then

        local mousePosition = GetMousePosition()

        FOVCircle.Position = mousePosition
        FOVCircle.Radius = Settings.FOV
        FOVCircle.Visible = Settings.FOVEnabled
    end

    ----------------------------------------------------------------
    -- Aim
    ----------------------------------------------------------------

    local shouldAim =
        Settings.AimEnabled
        and (
            not Settings.AimOnRMB
            or HoldingRMB
        )

    if shouldAim then

        local player, targetPart = GetClosestTarget()

        if player and targetPart then
            AimAt(targetPart)
        end
    end

    ----------------------------------------------------------------
    -- ESP
    ----------------------------------------------------------------

    if Settings.ESPEnabled then

        for _, player in ipairs(Players:GetPlayers()) do

            if player ~= LocalPlayer then
                CreateESP(player)
                UpdateESP(player)
            end

        end

    end

end)

Rayfield:LoadConfiguration()

Rayfield:Notify({
    Title = "Aimbot Arena",
    Content = "Aim assist loaded successfully.",
    Duration = 4
})