-- [[ 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 ]]

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

local player = Players.LocalPlayer
local camera = workspace.CurrentCamera

--==================================================
-- SETTINGS
--==================================================

local aimEnabled = true
local aiming = false

local minFov = 300
local maxFov = 1000
local fovSize = maxFov

--==================================================
-- UI
--==================================================

local screenGui = Instance.new("ScreenGui")
screenGui.Name = "AimLockUI"
screenGui.ResetOnSpawn = false
screenGui.Parent = player:WaitForChild("PlayerGui")

--==================================================
-- AIM BUTTON
--==================================================

local button = Instance.new("TextButton")
button.Size = UDim2.new(0, 150, 0, 45)
button.Position = UDim2.new(0, 20, 0.5, -22)
button.BackgroundColor3 = Color3.fromRGB(40, 170, 70)
button.TextColor3 = Color3.fromRGB(255, 255, 255)
button.TextSize = 18
button.Font = Enum.Font.GothamBold
button.Text = "AIM: ON"
button.AutoButtonColor = false
button.Parent = screenGui

local buttonCorner = Instance.new("UICorner")
buttonCorner.CornerRadius = UDim.new(0, 8)
buttonCorner.Parent = button

--==================================================
-- FOV CIRCLE
--==================================================

local fovCircle = Instance.new("Frame")
fovCircle.Name = "FOVCircle"
fovCircle.AnchorPoint = Vector2.new(0.5, 0.5)
fovCircle.Position = UDim2.fromScale(0.5, 0.5)
fovCircle.Size = UDim2.fromOffset(fovSize, fovSize)
fovCircle.BackgroundTransparency = 1
fovCircle.Visible = true
fovCircle.Parent = screenGui

local circleCorner = Instance.new("UICorner")
circleCorner.CornerRadius = UDim.new(1, 0)
circleCorner.Parent = fovCircle

local circleStroke = Instance.new("UIStroke")
circleStroke.Thickness = 2
circleStroke.Parent = fovCircle

--==================================================
-- FOV SIZE LABEL
--==================================================

local sizeLabel = Instance.new("TextLabel")
sizeLabel.Size = UDim2.new(0, 150, 0, 30)
sizeLabel.Position = UDim2.new(0, 20, 0.5, 35)
sizeLabel.BackgroundTransparency = 1
sizeLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
sizeLabel.TextSize = 16
sizeLabel.Font = Enum.Font.GothamBold
sizeLabel.Text = "FOV: " .. fovSize
sizeLabel.Visible = true
sizeLabel.Parent = screenGui

--==================================================
-- FOV SLIDER
--==================================================

local slider = Instance.new("TextButton")
slider.Size = UDim2.new(0, 150, 0, 12)
slider.Position = UDim2.new(0, 20, 0.5, 70)
slider.BackgroundColor3 = Color3.fromRGB(70, 70, 70)
slider.Text = ""
slider.AutoButtonColor = false
slider.Visible = true
slider.Parent = screenGui

local sliderCorner = Instance.new("UICorner")
sliderCorner.CornerRadius = UDim.new(1, 0)
sliderCorner.Parent = slider

local sliderFill = Instance.new("Frame")
sliderFill.Size = UDim2.new(1, 0, 1, 0)
sliderFill.BackgroundColor3 = Color3.fromRGB(70, 150, 255)
sliderFill.BorderSizePixel = 0
sliderFill.Parent = slider

local fillCorner = Instance.new("UICorner")
fillCorner.CornerRadius = UDim.new(1, 0)
fillCorner.Parent = sliderFill

--==================================================
-- UPDATE FOV
--==================================================

local function updateFOV(value)

    fovSize = math.clamp(
        value,
        minFov,
        maxFov
    )

    fovCircle.Size = UDim2.fromOffset(
        fovSize,
        fovSize
    )

    sizeLabel.Text = "FOV: " .. math.floor(fovSize)

    local percentage =
        (fovSize - minFov) /
        (maxFov - minFov)

    sliderFill.Size = UDim2.new(
        percentage,
        0,
        1,
        0
    )
end

--==================================================
-- SLIDER DRAGGING
--==================================================

local sliderDragging = false

local function setSliderFromMouse(mouseX)

    local sliderStart =
        slider.AbsolutePosition.X

    local sliderWidth =
        slider.AbsoluteSize.X

    local percentage =
        math.clamp(
            (mouseX - sliderStart) / sliderWidth,
            0,
            1
        )

    local value =
        minFov +
        percentage *
        (maxFov - minFov)

    updateFOV(value)
end

slider.InputBegan:Connect(function(input)

    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
        or input.UserInputType ==
        Enum.UserInputType.Touch then

        sliderDragging = true

        setSliderFromMouse(
            input.Position.X
        )
    end
end)

UserInputService.InputChanged:Connect(function(input)

    if not sliderDragging then
        return
    end

    if input.UserInputType ==
        Enum.UserInputType.MouseMovement
        or input.UserInputType ==
        Enum.UserInputType.Touch then

        setSliderFromMouse(
            input.Position.X
        )
    end
end)

UserInputService.InputEnded:Connect(function(input)

    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
        or input.UserInputType ==
        Enum.UserInputType.Touch then

        sliderDragging = false
    end
end)

--==================================================
-- DRAG AIM BUTTON
--==================================================

local dragging = false
local dragStart
local startPosition

button.InputBegan:Connect(function(input)

    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
        or input.UserInputType ==
        Enum.UserInputType.Touch then

        dragging = true
        dragStart = input.Position
        startPosition = button.Position

        input.Changed:Connect(function()

            if input.UserInputState ==
                Enum.UserInputState.End then

                dragging = false
            end
        end)
    end
end)

UserInputService.InputChanged:Connect(function(input)

    if not dragging then
        return
    end

    if input.UserInputType ==
        Enum.UserInputType.MouseMovement
        or input.UserInputType ==
        Enum.UserInputType.Touch then

        local delta =
            input.Position - dragStart

        button.Position = UDim2.new(
            startPosition.X.Scale,
            startPosition.X.Offset + delta.X,

            startPosition.Y.Scale,
            startPosition.Y.Offset + delta.Y
        )
    end
end)

--==================================================
-- TOGGLE AIM
--==================================================

local function updateButton()

    if aimEnabled then

        button.Text = "AIM: ON"
        button.BackgroundColor3 =
            Color3.fromRGB(40, 170, 70)

        fovCircle.Visible = true
        sizeLabel.Visible = true
        slider.Visible = true

    else

        button.Text = "AIM: OFF"
        button.BackgroundColor3 =
            Color3.fromRGB(170, 50, 50)

        fovCircle.Visible = false
        sizeLabel.Visible = false
        slider.Visible = false

        aiming = false
    end
end

button.MouseButton1Click:Connect(function()

    aimEnabled = not aimEnabled

    updateButton()
end)

--==================================================
-- E KEY TOGGLE
--==================================================

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

    if gameProcessed then
        return
    end

    if input.KeyCode == Enum.KeyCode.E then

        aimEnabled = not aimEnabled

        updateButton()
    end
end)

--==================================================
-- WALL / LINE-OF-SIGHT CHECK
--==================================================

local function canSeeHead(head)

    local character = player.Character

    if not character then
        return false
    end

    local root =
        character:FindFirstChild("HumanoidRootPart")

    if not root then
        return false
    end

    local raycastParams = RaycastParams.new()

    raycastParams.FilterType = Enum.RaycastFilterType.Exclude
    raycastParams.FilterDescendantsInstances = {
        character
    }

    raycastParams.IgnoreWater = true

    local direction =
        head.Position - root.Position

    local result =
        workspace:Raycast(
            root.Position,
            direction,
            raycastParams
        )

    -- Nothing blocked the ray
    if not result then
        return true
    end

    -- The first thing hit was the target's character
    if result.Instance:IsDescendantOf(
        head.Parent
    ) then
        return true
    end

    return false
end

--==================================================
-- FIND NEAREST HEAD
--==================================================

local function getNearestHead()

    local character = player.Character

    if not character then
        return nil
    end

    local myRoot =
        character:FindFirstChild("HumanoidRootPart")

    if not myRoot then
        return nil
    end

    local nearestHead = nil
    local nearestDistance = math.huge

    local screenCenter = Vector2.new(
        camera.ViewportSize.X / 2,
        camera.ViewportSize.Y / 2
    )

    for _, otherPlayer in
        Players:GetPlayers() do

        if otherPlayer ~= player
            and otherPlayer.Character then

            local head =
                otherPlayer.Character:FindFirstChild("Head")

            local humanoid =
                otherPlayer.Character:FindFirstChildOfClass(
                    "Humanoid"
                )

            if head
                and humanoid
                and humanoid.Health > 0 then

                local screenPosition,
                    onScreen =
                    camera:WorldToViewportPoint(
                        head.Position
                    )

                if onScreen
                    and screenPosition.Z > 0 then

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

                    local distanceFromCenter =
                        (
                            headPosition -
                            screenCenter
                        ).Magnitude

                    -- Must be inside FOV
                    if distanceFromCenter <=
                        fovSize / 2 then

                        -- Must have clear line of sight
                        if canSeeHead(head) then

                            local worldDistance =
                                (
                                    head.Position -
                                    myRoot.Position
                                ).Magnitude

                            if worldDistance <
                                nearestDistance then

                                nearestDistance =
                                    worldDistance

                                nearestHead = head
                            end
                        end
                    end
                end
            end
        end
    end

    return nearestHead
end

--==================================================
-- RIGHT CLICK AIM
--==================================================

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

    if gameProcessed then
        return
    end

    if input.UserInputType ==
        Enum.UserInputType.MouseButton2 then

        if aimEnabled then
            aiming = true
        end
    end
end)

UserInputService.InputEnded:Connect(function(input)

    if input.UserInputType ==
        Enum.UserInputType.MouseButton2 then

        aiming = false
    end
end)

--==================================================
-- CAMERA AIM
--==================================================

RunService.RenderStepped:Connect(function()

    if aiming and aimEnabled then

        local head =
            getNearestHead()

        if head then

            camera.CFrame =
                CFrame.lookAt(
                    camera.CFrame.Position,
                    head.Position
                )
        end
    end
end)

--==================================================
-- INITIALIZE
--==================================================

updateFOV(maxFov)
updateButton()