-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. 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 Rscripts 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=6ae8b1bd18ce2430d797da0c"))()
	end)
end)
--[[rscripts:analytics:end]]

-- Luau | Roblox client | RIVALS/Delta runtime untested.
-- Owner controls: Ernestvolet. Local check only.
-- No paid VIP unlock or wall-shooting functionality.

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Input = game:GetService("UserInputService")
local Http = game:GetService("HttpService")

local me = Players.LocalPlayer
assert(me, "Client execution required")

local OWNER_USERNAME = "Ernestvolet"
local is_owner = string.lower(me.Name) == string.lower(OWNER_USERNAME)
local player_gui = me:WaitForChild("PlayerGui")

local previous = player_gui:FindFirstChild("AimESPPanelV2")
if previous then
    local stop = previous:FindFirstChild("Stop")
    if stop and stop:IsA("BindableEvent") then
        stop:Fire()
    else
        previous:Destroy()
    end
end

local defaults = {
    aim = false,
    esp = false,
    labels = true,
    teams = false,
    visible = true,
    sticky = true,
    fov = 350,
    range = 3000,
    part = "Head",
    mode = "Snap",
    circle = true,
    crosshair = true,
    marker = true,
    hold = false,
    color = "Cyan"
}

if not is_owner then
    defaults.crosshair = false
    defaults.marker = false
end

local cfg = table.clone(defaults)
local hold_inputs = {}
local refreshers, tab_rows = {}, {}
local colors = {
    Cyan = Color3.fromRGB(90, 215, 255),
    Pink = Color3.fromRGB(255, 95, 155),
    Gold = Color3.fromRGB(255, 205, 80),
    Green = Color3.fromRGB(100, 255, 160)
}
local connections, visuals = {}, {}
local alive, locked, elapsed = true, nil, 0
local binding = "AimESP_" .. Http:GenerateGUID(false)

local function connect(event, fn)
    local c = event:Connect(fn)
    table.insert(connections, c)
    return c
end

local function make(class, properties, parent)
    local item = Instance.new(class)
    for key, value in pairs(properties) do
        item[key] = value
    end
    item.Parent = parent
    return item
end

local gui = make("ScreenGui", {
    Name = "AimESPPanelV2",
    ResetOnSpawn = false,
    IgnoreGuiInset = true,
    DisplayOrder = 50,
    ZIndexBehavior = Enum.ZIndexBehavior.Sibling
}, player_gui)

local stop = make("BindableEvent", {Name = "Stop"}, gui)
local effects = make("Folder", {Name = binding}, workspace)

local circle = make("Frame", {
    AnchorPoint = Vector2.new(0.5, 0.5),
    BackgroundTransparency = 1,
    BorderSizePixel = 0
}, gui)

make("UICorner", {CornerRadius = UDim.new(1, 0)}, circle)

local circle_stroke = make("UIStroke", {
    Color = colors.Cyan,
    Thickness = 1,
    Transparency = 0.25
}, circle)

local crosshair = make("Frame", {
    Size = UDim2.fromOffset(22, 22),
    AnchorPoint = Vector2.new(0.5, 0.5),
    BackgroundTransparency = 1
}, gui)

local cross_lines = {}
for _, spec in ipairs({
    {0, 10, 8, 2},
    {14, 10, 8, 2},
    {10, 0, 2, 8},
    {10, 14, 2, 8}
}) do
    table.insert(cross_lines, make("Frame", {
        Position = UDim2.fromOffset(spec[1], spec[2]),
        Size = UDim2.fromOffset(spec[3], spec[4]),
        BorderSizePixel = 0
    }, crosshair))
end

local target_marker = make("Frame", {
    AnchorPoint = Vector2.new(0.5, 0.5),
    Size = UDim2.fromOffset(28, 28),
    BackgroundTransparency = 1,
    Visible = false
}, gui)

make("UICorner", {CornerRadius = UDim.new(1, 0)}, target_marker)
local marker_stroke = make("UIStroke", {
    Thickness = 2,
    Color = Color3.new(1, 1, 1)
}, target_marker)

local hold_button = make("TextButton", {
    AnchorPoint = Vector2.new(1, 1),
    Position = UDim2.new(1, -28, 1, -145),
    Size = UDim2.fromOffset(90, 60),
    Text = "HOLD AIM",
    TextSize = 15,
    TextColor3 = Color3.new(1, 1, 1),
    BackgroundColor3 = Color3.fromRGB(26, 84, 100),
    Visible = false
}, gui)

make("UICorner", {CornerRadius = UDim.new(0, 14)}, hold_button)

local function clear_hold()
    table.clear(hold_inputs)
end

connect(hold_button.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.Touch
        or input.UserInputType == Enum.UserInputType.MouseButton1 then
        hold_inputs[input] = true
    end
end)

connect(Input.InputBegan, function(input, processed)
    if not processed
        and input.UserInputType == Enum.UserInputType.MouseButton2 then
        hold_inputs[input] = true
    end
end)

connect(Input.InputEnded, function(input)
    hold_inputs[input] = nil
end)
connect(Input.WindowFocusReleased, clear_hold)

local panel = make("Frame", {
    Position = UDim2.fromOffset(18, 64),
    Size = UDim2.fromOffset(280, 474),
    BackgroundColor3 = Color3.fromRGB(19, 23, 31),
    BorderSizePixel = 0,
    Active = true
}, gui)

make("UICorner", {CornerRadius = UDim.new(0, 10)}, panel)
local scale = make("UIScale", {Scale = 1}, panel)

local header = make("TextLabel", {
    Size = UDim2.new(1, -44, 0, 42),
    BackgroundTransparency = 1,
    Text = is_owner and "OWNER VIP - drag here" or "AIM / ESP - drag here",
    TextSize = 16,
    TextColor3 = colors.Cyan,
    Font = Enum.Font.GothamBold,
    Active = true
}, panel)

local minimize = make("TextButton", {
    Position = UDim2.new(1, -40, 0, 5),
    Size = UDim2.fromOffset(34, 32),
    Text = "-",
    TextSize = 22,
    TextColor3 = Color3.new(1, 1, 1),
    BackgroundColor3 = Color3.fromRGB(40, 47, 61)
}, panel)

local body = make("ScrollingFrame", {
    Position = UDim2.fromOffset(10, 82),
    Size = UDim2.new(1, -20, 1, -92),
    BackgroundTransparency = 1,
    BorderSizePixel = 0,
    ScrollBarThickness = 4,
    CanvasSize = UDim2.fromOffset(0, 0),
    AutomaticCanvasSize = Enum.AutomaticSize.Y
}, panel)

make("UIListLayout", {
    Padding = UDim.new(0, 7),
    SortOrder = Enum.SortOrder.LayoutOrder
}, body)

local tabs = make("Frame", {
    Position = UDim2.fromOffset(10, 44),
    Size = UDim2.new(1, -20, 0, 30),
    BackgroundTransparency = 1
}, panel)

local tab_buttons = {}

local function select_tab(name)
    for row, section in pairs(tab_rows) do
        row.Visible = section == name
            and (section ~= "Owner" or is_owner or row:IsA("TextLabel"))
    end

    for title, b in pairs(tab_buttons) do
        b.BackgroundColor3 = title == name
            and Color3.fromRGB(26, 84, 100)
            or Color3.fromRGB(38, 45, 59)
    end
    body.CanvasPosition = Vector2.new(0, 0)
end

for i, name in ipairs({"Aim", "Visuals", "Owner"}) do
    local b = make("TextButton", {
        Position = UDim2.new((i - 1) / 3, 0, 0, 0),
        Size = UDim2.new(1 / 3, -4, 1, 0),
        Text = name,
        TextSize = 14,
        TextColor3 = Color3.new(1, 1, 1),
        BorderSizePixel = 0
    }, tabs)

    tab_buttons[name] = b
    connect(b.Activated, function()
        select_tab(name)
    end)
end

local order = 0

local function row_button(text, fn, section)
    order = order + 1
    local button = make("TextButton", {
        Size = UDim2.new(1, -6, 0, 34),
        Text = text,
        TextSize = 14,
        Font = Enum.Font.Gotham,
        TextColor3 = Color3.new(1, 1, 1),
        BackgroundColor3 = Color3.fromRGB(38, 45, 59),
        BorderSizePixel = 0,
        LayoutOrder = order
    }, body)

    tab_rows[button] = section or "Aim"
    make("UICorner", {CornerRadius = UDim.new(0, 6)}, button)

    connect(button.Activated, function()
        if section == "Owner" and not is_owner then return end
        fn(button)
    end)
    return button
end

local function toggle(key, title, section)
    local function update(b)
        b.Text = title .. ": " .. (cfg[key] and "ON" or "OFF")
        b.BackgroundColor3 = cfg[key]
            and Color3.fromRGB(26, 84, 100)
            or Color3.fromRGB(38, 45, 59)
    end

    local b = row_button("", function(button)
        cfg[key] = not cfg[key]
        locked = nil
        clear_hold()
        update(button)
    end, section)

    table.insert(refreshers, function() update(b) end)
    update(b)
end

toggle("aim", "Aim assist")
toggle("esp", "Wall ESP", "Visuals")
toggle("labels", "Names / health / distance", "Visuals")
toggle("teams", "Exclude same team")
toggle("visible", "Aim only at visible targets")
toggle("sticky", "Keep current target")
toggle("circle", "Show aim circle", "Visuals")
toggle("crosshair", "Center crosshair", "Owner")
toggle("marker", "Selected target marker", "Owner")
toggle("hold", "Hold-to-aim mode", "Owner")

local function cycle(key, title, values, suffix, section)
    local function update(b)
        b.Text = title .. ": " .. tostring(cfg[key]) .. (suffix or "")
    end

    local button = row_button("", function(b)
        local i = table.find(values, cfg[key]) or 0
        cfg[key] = values[i % #values + 1]
        locked = nil
        update(b)
    end, section)

    update(button)
    table.insert(refreshers, function() update(button) end)
end

cycle("mode", "Aim mode", {"Snap", "Smooth", "Gentle"})
cycle("part", "Target", {"Head", "HumanoidRootPart", "UpperTorso"})
cycle("fov", "Aim radius", {100, 200, 350, 500, 800}, " px")
cycle("range", "Maximum range", {500, 1500, 3000, 10000}, " studs")
cycle("color", "Visual color", {"Cyan", "Pink", "Gold", "Green"}, "", "Owner")

row_button("Reset all controls", function()
    cfg = table.clone(defaults)
    locked = nil
    clear_hold()
    for _, refresh in ipairs(refreshers) do refresh() end
end, "Owner")

local owner_label = make("TextLabel", {
    Size = UDim2.new(1, -6, 0, 58),
    BackgroundTransparency = 1,
    Text = is_owner
        and ("Owner: @" .. OWNER_USERNAME .. "\nYour custom controls are enabled.")
        or ("Owner controls are locked.\nOwner account: @" .. OWNER_USERNAME),
    TextWrapped = true,
    TextSize = 12,
    TextColor3 = colors.Gold,
    LayoutOrder = 0
}, body)

tab_rows[owner_label] = "Owner"
select_tab("Aim")

local status = make("TextLabel", {
    Size = UDim2.new(1, -6, 0, 62),
    BackgroundTransparency = 1,
    Text = "Aim OFF",
    TextWrapped = true,
    TextSize = 12,
    TextColor3 = Color3.fromRGB(185, 201, 220),
    Font = Enum.Font.Gotham,
    LayoutOrder = 100
}, body)

local function cleanup()
    if not alive then return end
    alive = false
    RunService:UnbindFromRenderStep(binding)
    for _, c in ipairs(connections) do c:Disconnect() end
    effects:Destroy()
    gui:Destroy()
end

local close = row_button("Close and remove", cleanup)
close.LayoutOrder = 101
tab_rows[close] = nil

connect(stop.Event, cleanup)
connect(gui.Destroying, cleanup)

local collapsed = false
connect(minimize.Activated, function()
    collapsed = not collapsed
    body.Visible = not collapsed
    tabs.Visible = not collapsed
    panel.Size = UDim2.fromOffset(280, collapsed and 42 or 474)
    minimize.Text = collapsed and "+" or "-"
end)

local drag, drag_start, panel_start

connect(header.InputBegan, function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
        drag = input
        drag_start = input.Position
        panel_start = panel.Position
    end
end)

connect(Input.InputEnded, function(input)
    if input == drag then drag = nil end
end)

connect(Input.InputChanged, function(input)
    if not drag then return end
    if input ~= drag
        and input.UserInputType ~= Enum.UserInputType.MouseMovement then return end
    if drag.UserInputType == Enum.UserInputType.Touch
        and input ~= drag then return end

    local camera = workspace.CurrentCamera
    if not camera then return end

    local delta = input.Position - drag_start
    local size = camera.ViewportSize
    local x = math.clamp(
        panel_start.X.Offset + delta.X,
        0, math.max(0, size.X - panel.AbsoluteSize.X)
    )
    local y = math.clamp(
        panel_start.Y.Offset + delta.Y,
        0, math.max(0, size.Y - panel.AbsoluteSize.Y)
    )
    panel.Position = UDim2.fromOffset(x, y)
end)

local function eligible(p)
    if p == me then return nil end
    if cfg.teams and me.Team and not me.Neutral
        and not p.Neutral and p.Team == me.Team then return nil end

    local c = p.Character
    local h = c and c:FindFirstChildOfClass("Humanoid")
    if not h or h.Health <= 0 then return nil end

    local part = c:FindFirstChild(cfg.part)
        or c:FindFirstChild("Head")
        or c:FindFirstChild("HumanoidRootPart")

    if not part or not part:IsA("BasePart") then return nil end
    return c, h, part
end

local params = RaycastParams.new()
params.FilterType = Enum.RaycastFilterType.Exclude

local function aim_candidate(p, camera, center)
    local c, h, part = eligible(p)
    if not c then return nil end

    local delta = part.Position - camera.CFrame.Position
    if delta.Magnitude > cfg.range or delta.Magnitude < 0.01 then return nil end

    local point, on_screen = camera:WorldToViewportPoint(part.Position)
    local distance = (Vector2.new(point.X, point.Y) - center).Magnitude
    if not on_screen or distance > cfg.fov then return nil end

    if cfg.visible then
        local hit = workspace:Raycast(camera.CFrame.Position, delta, params)
        if hit and not hit.Instance:IsDescendantOf(c) then return nil end
    end
    return part, distance
end

local function remove_visual(p)
    local v = visuals[p]
    if v then
        v.highlight:Destroy()
        v.billboard:Destroy()
        visuals[p] = nil
    end
end

connect(Players.PlayerRemoving, function(p)
    remove_visual(p)
    if locked == p then locked = nil end
end)

local function update_visual(p, camera)
    local c, h, part = eligible(p)
    if not cfg.esp or not c
        or (part.Position - camera.CFrame.Position).Magnitude > cfg.range then
        local v = visuals[p]
        if v then
            v.highlight.Enabled = false
            v.billboard.Enabled = false
        end
        return
    end

    local v = visuals[p]
    if not v then
        local highlight = make("Highlight", {
            DepthMode = Enum.HighlightDepthMode.AlwaysOnTop,
            FillTransparency = 0.75,
            OutlineTransparency = 0,
            OutlineColor = colors.Cyan,
            FillColor = colors.Cyan
        }, effects)

        local billboard = make("BillboardGui", {
            AlwaysOnTop = true,
            Size = UDim2.fromOffset(200, 44),
            StudsOffsetWorldSpace = Vector3.new(0, 2.3, 0)
        }, gui)

        local label = make("TextLabel", {
            Size = UDim2.fromScale(1, 1),
            BackgroundTransparency = 1,
            TextColor3 = Color3.new(1, 1, 1),
            TextStrokeTransparency = 0.25,
            TextSize = 12,
            Font = Enum.Font.GothamBold
        }, billboard)

        v = {highlight = highlight, billboard = billboard, label = label}
        visuals[p] = v
    end

    v.highlight.Adornee = c
    v.highlight.Enabled = true
    v.highlight.FillColor = colors[cfg.color]
    v.highlight.OutlineColor = colors[cfg.color]
    v.billboard.Adornee = c:FindFirstChild("Head") or part
    v.billboard.Enabled = cfg.labels

    local distance = (part.Position - camera.CFrame.Position).Magnitude
    v.label.Text = string.format(
        "%s (@%s)\n%d/%d HP | %d studs",
        p.DisplayName, p.Name,
        math.floor(h.Health), math.floor(h.MaxHealth),
        math.floor(distance)
    )
end

local last_error = nil

local function render(dt)
    local camera = workspace.CurrentCamera
    if not camera then return end

    local size = camera.ViewportSize
    if size.X < 1 or size.Y < 1 then return end
    local center = size / 2

    scale.Scale = math.min(1, (size.Y - 24) / 474, (size.X - 24) / 280)
    panel.Position = UDim2.fromOffset(
        math.clamp(panel.Position.X.Offset, 0,
            math.max(0, size.X - panel.AbsoluteSize.X)),
        math.clamp(panel.Position.Y.Offset, 0,
            math.max(0, size.Y - panel.AbsoluteSize.Y))
    )

    circle.Position = UDim2.fromOffset(center.X, center.Y)
    circle.Size = UDim2.fromOffset(cfg.fov * 2, cfg.fov * 2)
    circle.Visible = cfg.circle
    circle_stroke.Color = colors[cfg.color]

    crosshair.Position = UDim2.fromOffset(center.X, center.Y)
    crosshair.Visible = cfg.crosshair
    for _, line in ipairs(cross_lines) do
        line.BackgroundColor3 = colors[cfg.color]
    end

    hold_button.Visible = cfg.hold and cfg.aim
    hold_button.BackgroundColor3 = next(hold_inputs)
        and Color3.fromRGB(38, 135, 150)
        or Color3.fromRGB(26, 84, 100)

    params.FilterDescendantsInstances = me.Character
        and {me.Character, effects} or {effects}

    local list = Players:GetPlayers()
    local target = nil
    local aiming = cfg.aim and (not cfg.hold or next(hold_inputs) ~= nil)

    if aiming then
        if cfg.sticky and locked and locked.Parent == Players then
            target = aim_candidate(locked, camera, center)
        end

        if not target then
            locked = nil
            local best = math.huge
            for _, p in ipairs(list) do
                local part, distance = aim_candidate(p, camera, center)
                if part and distance < best then
                    target = part
                    best = distance
                    locked = p
                end
            end
        end

        if target then
            local desired = CFrame.lookAt(camera.CFrame.Position, target.Position)
            local strength = cfg.mode == "Gentle" and 7 or 22
            camera.CFrame = cfg.mode == "Snap"
                and desired
                or camera.CFrame:Lerp(desired, 1 - math.exp(-strength * dt))
        end
    else
        locked = nil
    end

    target_marker.Visible = false
    if cfg.marker and target then
        local point, on_screen = camera:WorldToViewportPoint(target.Position)
        target_marker.Position = UDim2.fromOffset(point.X, point.Y)
        target_marker.Visible = on_screen
        marker_stroke.Color = colors[cfg.color]
    end

    elapsed = elapsed + dt
    if elapsed >= 0.1 then
        elapsed = 0
        local supported = 0
        for _, p in ipairs(list) do
            if eligible(p) then supported = supported + 1 end
            update_visual(p, camera)
        end

        local message = "Aim OFF"
        if cfg.aim then
            if not aiming then
                message = "Hold AIM / right mouse to aim"
            elseif locked then
                message = "Target: @" .. locked.Name
            else
                message = "No target in circle / visibility filter"
            end
        end

        status.Text = last_error and ("Error: " .. last_error)
            or string.format(
                "%s\n%d supported opponents | radius %d px\nRuntime untested",
                message, supported, cfg.fov
            )
    end
end

RunService:BindToRenderStep(
    binding,
    Enum.RenderPriority.Last.Value + 1,
    function(dt)
        if not alive then return end
        local ok, err = pcall(render, dt)
        if not ok then
            last_error = tostring(err)
            status.Text = "Error: " .. last_error
            cfg.aim = false
            RunService:UnbindFromRenderStep(binding)
            warn("Aim ESP stopped: " .. last_error)
        end
    end
)