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

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

-- ============================================================
-- REMOTES (confirmed from scan)
-- ============================================================
local RemoteEvents = RS:WaitForChild("Events"):WaitForChild("RemoteEvents")
local Deploy         = RemoteEvents:WaitForChild("Deploy")
local ValidateSprint = RemoteEvents:WaitForChild("ValidateSprint")
local KillfeedEntry  = RemoteEvents:WaitForChild("KillfeedEntry")

-- ============================================================
-- CONFIG
-- ============================================================
local CFG = {
    espOn       = true,
    chamsOn     = true,
    boxOn       = true,
    namesOn     = true,
    distOn      = true,
    healthOn    = true,
    tracerOn    = false,
    espColor    = Color3.fromRGB(255, 60, 60),
    chamsColor  = Color3.fromRGB(255, 40, 40),
    chamsTransp = 0.5,
    maxDist     = 2000,

    aimOn       = false,
    aimKey      = Enum.KeyCode.Q,
    -- sensitivity: higher = faster aim, lower = smoother
    aimSens     = 0.45,
    aimFOV      = 150,
    fovOn       = true,
    teamCheck   = false,
    aimPart     = "Head",

    autoRespawn = false,
    killFeed    = true,
}

-- ============================================================
-- STATE
-- ============================================================
local aimHeld    = false
local aimTarget  = nil
local chamStore  = {}
local drawStore  = {}
local killLog    = {}
local sessionKills = 0

-- ============================================================
-- BODY PARTS (R15 confirmed from scan)
-- ============================================================
local PARTS = {
    "Head","UpperTorso","LowerTorso",
    "LeftUpperArm","RightUpperArm","LeftLowerArm","RightLowerArm",
    "LeftHand","RightHand",
    "LeftUpperLeg","RightUpperLeg","LeftLowerLeg","RightLowerLeg",
    "LeftFoot","RightFoot",
}

-- ============================================================
-- HELPERS
-- ============================================================
local function getChar(p)  return p and p.Character end
local function getRoot(p)
    local c = getChar(p)
    return c and c:FindFirstChild("HumanoidRootPart")
end
local function getHum(p)
    local c = getChar(p)
    return c and c:FindFirstChildOfClass("Humanoid")
end
local function alive(p)
    local h = getHum(p)
    return h and h.Health > 0
end
local function myRoot()
    local c = LP.Character
    return c and c:FindFirstChild("HumanoidRootPart")
end
local function getDist(pos)
    local r = myRoot()
    return r and (r.Position - pos).Magnitude or math.huge
end

-- FIXED: sp is Vector3, sp.Z is depth — NO third return value
local function toScreen(pos)
    local sp, onScreen = Camera:WorldToViewportPoint(pos)
    return Vector2.new(sp.X, sp.Y), onScreen, sp.Z
end

local function mousePos()
    return UIS:GetMouseLocation()
end

local function fovRadius()
    local vp = Camera.ViewportSize
    return (CFG.aimFOV / 360) * math.sqrt(vp.X^2 + vp.Y^2) / 2
end

-- ============================================================
-- CHAMS
-- ============================================================
local function clearChams(p)
    if not chamStore[p] then return end
    for _, sb in ipairs(chamStore[p]) do
        pcall(function() sb:Destroy() end)
    end
    chamStore[p] = nil
end

local function buildChams(p)
    clearChams(p)
    local c = getChar(p)
    if not c then return end
    chamStore[p] = {}
    for _, name in ipairs(PARTS) do
        pcall(function()
            local part = c:FindFirstChild(name)
            if part and part:IsA("BasePart") then
                local sb = Instance.new("SelectionBox")
                sb.Color3              = CFG.chamsColor
                sb.SurfaceColor3       = CFG.chamsColor
                sb.SurfaceTransparency = CFG.chamsTransp
                sb.LineThickness       = 0.02
                sb.Adornee             = part
                sb.Visible             = CFG.chamsOn and CFG.espOn
                sb.Parent              = workspace
                table.insert(chamStore[p], sb)
            end
        end)
    end
end

local function refreshChams(p)
    if not chamStore[p] then return end
    local on = CFG.chamsOn and CFG.espOn
    for _, sb in ipairs(chamStore[p]) do
        pcall(function()
            sb.Visible             = on
            sb.Color3              = CFG.chamsColor
            sb.SurfaceColor3       = CFG.chamsColor
            sb.SurfaceTransparency = CFG.chamsTransp
        end)
    end
end

-- ============================================================
-- 2D BOUNDING BOX
-- Projects all 8 corners of every body part — tight real box
-- FIXED: uses sp.Z for depth check, not a third return value
-- ============================================================
local function getScreenBounds(p)
    local c = getChar(p)
    if not c then return nil end

    local minX, minY =  math.huge,  math.huge
    local maxX, maxY = -math.huge, -math.huge
    local any = false

    for _, part in ipairs(c:GetChildren()) do
        if part:IsA("BasePart") then
            pcall(function()
                local s  = part.Size * 0.5
                local cf = part.CFrame
                for _, off in ipairs({
                    Vector3.new( s.X,  s.Y,  s.Z),
                    Vector3.new(-s.X,  s.Y,  s.Z),
                    Vector3.new( s.X, -s.Y,  s.Z),
                    Vector3.new(-s.X, -s.Y,  s.Z),
                    Vector3.new( s.X,  s.Y, -s.Z),
                    Vector3.new(-s.X,  s.Y, -s.Z),
                    Vector3.new( s.X, -s.Y, -s.Z),
                    Vector3.new(-s.X, -s.Y, -s.Z),
                }) do
                    -- CORRECT: WorldToViewportPoint returns (Vector3, bool)
                    -- depth is sp.Z, NOT a third return value
                    local sp, _ = Camera:WorldToViewportPoint(cf:PointToWorldSpace(off))
                    if sp.Z > 0 then
                        any  = true
                        minX = math.min(minX, sp.X)
                        minY = math.min(minY, sp.Y)
                        maxX = math.max(maxX, sp.X)
                        maxY = math.max(maxY, sp.Y)
                    end
                end
            end)
        end
    end

    if not any then return nil end
    return minX - 2, minY - 2, maxX + 2, maxY + 2
end

-- ============================================================
-- DRAWINGS
-- ============================================================
local function newLine(thick, transp)
    local l = Drawing.new("Line")
    l.Thickness    = thick or 1.5
    l.Transparency = transp or 1
    l.Visible      = false
    return l
end

local function newTxt(sz)
    local t = Drawing.new("Text")
    t.Size         = sz or 13
    t.Font         = Drawing.Fonts.UI
    t.Center       = true
    t.Outline      = true
    t.OutlineColor = Color3.new(0,0,0)
    t.Visible      = false
    return t
end

local function newSq(filled, transp)
    local s = Drawing.new("Square")
    s.Filled       = filled ~= false
    s.Transparency = transp or 1
    s.Visible      = false
    return s
end

local function buildDrawings(p)
    if drawStore[p] then
        for _, d in pairs(drawStore[p]) do
            pcall(function() d:Remove() end)
        end
    end
    drawStore[p] = {
        c1h=newLine(2), c1v=newLine(2),
        c2h=newLine(2), c2v=newLine(2),
        c3h=newLine(2), c3v=newLine(2),
        c4h=newLine(2), c4v=newLine(2),
        eT=newLine(1,0.8), eB=newLine(1,0.8),
        eL=newLine(1,0.8), eR=newLine(1,0.8),
        name   = newTxt(13),
        dist   = newTxt(11),
        hpBg   = newSq(true, 0.6),
        hpFill = newSq(true, 1),
        hpTxt  = newTxt(10),
        tracer = newLine(1, 0.5),
    }
end

local function removeDrawings(p)
    if not drawStore[p] then return end
    for _, d in pairs(drawStore[p]) do
        pcall(function() d:Remove() end)
    end
    drawStore[p] = nil
end

local function hideDrawings(p)
    if not drawStore[p] then return end
    for _, d in pairs(drawStore[p]) do
        pcall(function() d.Visible = false end)
    end
end

local function updateDrawings(p)
    if not drawStore[p] then return end
    local d = drawStore[p]
    if not CFG.espOn then hideDrawings(p); return end

    local r = getRoot(p)
    local h = getHum(p)
    if not r or not h then hideDrawings(p); return end

    local dist = getDist(r.Position)
    if dist > CFG.maxDist then hideDrawings(p); return end

    -- FIXED: check sp.Z directly
    local sp, _, depth_check
    pcall(function()
        local s, _ = Camera:WorldToViewportPoint(r.Position)
        sp = s
    end)
    if not sp or sp.Z <= 0 then hideDrawings(p); return end

    local minX, minY, maxX, maxY = getScreenBounds(p)
    if not minX then hideDrawings(p); return end

    local bw  = maxX - minX
    local bh  = maxY - minY
    local cx  = (minX + maxX) / 2
    local col = alive(p) and CFG.espColor or Color3.fromRGB(110,110,110)

    local cw   = bw * 0.22
    local ch   = bh * 0.18
    local show = CFG.boxOn

    local tl = Vector2.new(minX, minY)
    local tr = Vector2.new(maxX, minY)
    local bl = Vector2.new(minX, maxY)
    local br = Vector2.new(maxX, maxY)

    local function setL(line, from, to, c, t)
        pcall(function()
            line.From  = from
            line.To    = to
            line.Color = c or col
            if t then line.Transparency = t end
            line.Visible = show
        end)
    end

    setL(d.eT, tl, tr, col, 0.78)
    setL(d.eB, bl, br, col, 0.78)
    setL(d.eL, tl, bl, col, 0.78)
    setL(d.eR, tr, br, col, 0.78)

    setL(d.c1h, tl, Vector2.new(tl.X+cw, tl.Y))
    setL(d.c1v, tl, Vector2.new(tl.X, tl.Y+ch))
    setL(d.c2h, tr, Vector2.new(tr.X-cw, tr.Y))
    setL(d.c2v, tr, Vector2.new(tr.X, tr.Y+ch))
    setL(d.c3h, bl, Vector2.new(bl.X+cw, bl.Y))
    setL(d.c3v, bl, Vector2.new(bl.X, bl.Y-ch))
    setL(d.c4h, br, Vector2.new(br.X-cw, br.Y))
    setL(d.c4v, br, Vector2.new(br.X, br.Y-ch))

    pcall(function()
        d.name.Text     = p.Name
        d.name.Color    = col
        d.name.Position = Vector2.new(cx, minY - 15)
        d.name.Visible  = CFG.namesOn
    end)

    pcall(function()
        d.dist.Text     = math.floor(dist).."m"
        d.dist.Color    = Color3.fromRGB(200,200,200)
        d.dist.Position = Vector2.new(cx, maxY + 3)
        d.dist.Visible  = CFG.distOn
    end)

    if CFG.healthOn then
        pcall(function()
            local hp    = math.max(h.Health, 0)
            local maxHp = math.max(h.MaxHealth, 1)
            local ratio = math.clamp(hp/maxHp, 0, 1)
            local hpCol = Color3.fromRGB(
                math.floor(255*(1-ratio)),
                math.floor(255*ratio),
                0)
            local bx = minX - 6

            d.hpBg.Position = Vector2.new(bx, minY)
            d.hpBg.Size     = Vector2.new(4, bh)
            d.hpBg.Color    = Color3.fromRGB(10,10,10)
            d.hpBg.Visible  = true

            d.hpFill.Position = Vector2.new(bx, minY + bh*(1-ratio))
            d.hpFill.Size     = Vector2.new(4, bh*ratio)
            d.hpFill.Color    = hpCol
            d.hpFill.Visible  = true

            d.hpTxt.Text     = math.floor(hp)
            d.hpTxt.Color    = hpCol
            d.hpTxt.Position = Vector2.new(bx+2, minY+bh*(1-ratio)-12)
            d.hpTxt.Visible  = true
        end)
    else
        pcall(function()
            d.hpBg.Visible   = false
            d.hpFill.Visible = false
            d.hpTxt.Visible  = false
        end)
    end

    if CFG.tracerOn then
        pcall(function()
            local mp = mousePos()
            d.tracer.From    = mp
            d.tracer.To      = Vector2.new(cx, maxY)
            d.tracer.Color   = col
            d.tracer.Visible = true
        end)
    else
        pcall(function() d.tracer.Visible = false end)
    end
end

-- ============================================================
-- FOV CIRCLE
-- ============================================================
local fovCircle       = Drawing.new("Circle")
fovCircle.NumSides    = 80
fovCircle.Color       = Color3.fromRGB(255,255,255)
fovCircle.Thickness   = 1
fovCircle.Filled      = false
fovCircle.Transparency = 0.65
fovCircle.Visible     = false

-- ============================================================
-- AIMBOT — mousemoverel for FPS (confirmed FPS game)
-- Gets the target's head screen position
-- Computes delta from current mouse position
-- Moves mouse toward target using mousemoverel
-- ============================================================
local function getAimPart(p)
    local c = getChar(p)
    if not c then return nil end
    if CFG.aimPart == "Head" then
        return c:FindFirstChild("Head") or c:FindFirstChild("HumanoidRootPart")
    end
    return c:FindFirstChild("UpperTorso") or c:FindFirstChild("HumanoidRootPart")
end

local function screenDistFromMouse(p)
    local part = getAimPart(p)
    if not part then return math.huge end
    local sp, _ = Camera:WorldToViewportPoint(part.Position)
    -- FIXED: check sp.Z not a third value
    if sp.Z <= 0 then return math.huge end
    local mp = mousePos()
    return (Vector2.new(sp.X, sp.Y) - mp).Magnitude
end

local function getBestTarget()
    local best, bestDist = nil, fovRadius()
    for _, p in ipairs(Players:GetPlayers()) do
        if p == LP then continue end
        if not alive(p) then continue end
        local r = getRoot(p)
        if not r then continue end
        if getDist(r.Position) > CFG.maxDist then continue end
        if CFG.teamCheck and p.Team and LP.Team and p.Team == LP.Team then continue end
        local sd = screenDistFromMouse(p)
        if sd < bestDist then
            bestDist = sd
            best = p
        end
    end
    return best
end

local function doAimbot()
    local mp = mousePos()
    fovCircle.Position = mp
    fovCircle.Radius   = fovRadius()
    fovCircle.Visible  = CFG.fovOn and CFG.aimOn

    if not CFG.aimOn or not aimHeld then
        aimTarget = nil
        return
    end

    aimTarget = getBestTarget()
    if not aimTarget then return end

    local part = getAimPart(aimTarget)
    if not part then return end

    -- Get target head position on screen
    local sp, _ = Camera:WorldToViewportPoint(part.Position)
    if sp.Z <= 0 then return end

    local targetScreen = Vector2.new(sp.X, sp.Y)
    local currentMouse = mousePos()

    -- Delta: how far mouse needs to move to reach target
    local dx = targetScreen.X - currentMouse.X
    local dy = targetScreen.Y - currentMouse.Y

    -- mousemoverel moves the actual mouse
    -- sensitivity scales how fast it snaps
    -- this works WITH the FPS camera system naturally
    pcall(function()
        mousemoverel(dx * CFG.aimSens, dy * CFG.aimSens)
    end)
end

UIS.InputBegan:Connect(function(inp, gpe)
    if gpe then return end
    if inp.KeyCode == CFG.aimKey then aimHeld = true end
end)
UIS.InputEnded:Connect(function(inp)
    if inp.KeyCode == CFG.aimKey then
        aimHeld   = false
        aimTarget = nil
    end
end)

-- ============================================================
-- KILLFEED HOOK
-- Confirmed from scan: KillfeedEntry sends (killer, victim, bool headshot)
-- ============================================================
KillfeedEntry.OnClientEvent:Connect(function(killer, victim, headshot)
    pcall(function()
        if not CFG.killFeed then return end
        local headshotText = headshot and " 🎯" or ""
        local entry = (killer and killer.Name or "?")
            .. " → "
            .. (victim and victim.Name or "?")
            .. headshotText

        table.insert(killLog, 1, entry)
        if #killLog > 8 then table.remove(killLog) end

        if victim == LP then
            -- auto respawn when we die
            if CFG.autoRespawn then
                task.wait(2)
                pcall(function() Deploy:FireServer() end)
            end
        end

        if killer == LP then
            sessionKills += 1
        end
    end)
end)

-- ============================================================
-- PLAYER MANAGEMENT
-- ============================================================
local function setupPlayer(p)
    if p == LP then return end
    pcall(buildChams, p)
    pcall(buildDrawings, p)
    p.CharacterAdded:Connect(function()
        task.wait(0.8)
        pcall(buildChams, p)
        pcall(buildDrawings, p)
    end)
end

local function removePlayer(p)
    clearChams(p)
    removeDrawings(p)
end

for _, p in ipairs(Players:GetPlayers()) do
    task.spawn(setupPlayer, p)
end
Players.PlayerAdded:Connect(setupPlayer)
Players.PlayerRemoving:Connect(removePlayer)

-- ============================================================
-- MAIN LOOP
-- ============================================================
RunService.RenderStepped:Connect(function()
    -- ESP
    for _, p in ipairs(Players:GetPlayers()) do
        if p == LP then continue end
        if not drawStore[p] then
            task.spawn(setupPlayer, p)
        else
            pcall(updateDrawings, p)
            pcall(refreshChams, p)
        end
    end

    -- Aimbot
    pcall(doAimbot)
end)

-- ============================================================
-- RAYFIELD UI
-- ============================================================
local Window = Rayfield:CreateWindow({
    Name            = "Pistol Arena",
    LoadingTitle    = "Pistol Arena",
    LoadingSubtitle = "ESP + Aimbot",
    ConfigurationSaving = { Enabled = false },
    Discord  = { Enabled = false },
    KeySystem = false,
})

local EspTab = Window:CreateTab("ESP", "eye")

EspTab:CreateToggle({
    Name="Player ESP", CurrentValue=CFG.espOn, Flag="espOn",
    Callback=function(v)
        CFG.espOn = v
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LP then pcall(refreshChams, p) end
        end
    end,
})

EspTab:CreateToggle({
    Name="Chams", CurrentValue=CFG.chamsOn, Flag="chamsOn",
    Callback=function(v)
        CFG.chamsOn = v
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LP then pcall(refreshChams, p) end
        end
    end,
})

EspTab:CreateToggle({
    Name="Corner Boxes", CurrentValue=CFG.boxOn, Flag="boxOn",
    Callback=function(v) CFG.boxOn = v end,
})

EspTab:CreateToggle({
    Name="Names", CurrentValue=CFG.namesOn, Flag="namesOn",
    Callback=function(v) CFG.namesOn = v end,
})

EspTab:CreateToggle({
    Name="Distance", CurrentValue=CFG.distOn, Flag="distOn",
    Callback=function(v) CFG.distOn = v end,
})

EspTab:CreateToggle({
    Name="Health Bar", CurrentValue=CFG.healthOn, Flag="healthOn",
    Callback=function(v) CFG.healthOn = v end,
})

EspTab:CreateToggle({
    Name="Tracers", CurrentValue=CFG.tracerOn, Flag="tracerOn",
    Callback=function(v) CFG.tracerOn = v end,
})

EspTab:CreateSlider({
    Name="Max Distance", Range={100,3000}, Increment=100,
    CurrentValue=CFG.maxDist, Flag="maxDist",
    Callback=function(v) CFG.maxDist = v end,
})

EspTab:CreateSlider({
    Name="Chams Transparency", Range={0,90}, Increment=5,
    CurrentValue=math.floor(CFG.chamsTransp*100), Flag="chamsTransp",
    Callback=function(v)
        CFG.chamsTransp = v/100
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LP then pcall(refreshChams, p) end
        end
    end,
})

local AimTab = Window:CreateTab("Aimbot", "crosshair")

AimTab:CreateToggle({
    Name="Aimbot (FPS - moves mouse)", CurrentValue=CFG.aimOn, Flag="aimOn",
    Callback=function(v) CFG.aimOn = v end,
})

AimTab:CreateKeybind({
    Name="Hold to Aim",
    CurrentKeybind="Q",
    HoldToInteract=false,
    Flag="aimKey",
    Callback=function(key)
        local kc = Enum.KeyCode[key]
        if kc then CFG.aimKey = kc end
    end,
})

AimTab:CreateToggle({
    Name="Show FOV", CurrentValue=CFG.fovOn, Flag="fovOn",
    Callback=function(v) CFG.fovOn = v end,
})

AimTab:CreateToggle({
    Name="Team Check", CurrentValue=CFG.teamCheck, Flag="teamCheck",
    Callback=function(v) CFG.teamCheck = v end,
})

AimTab:CreateDropdown({
    Name="Target Part",
    Options={"Head","UpperTorso"},
    CurrentOption={"Head"},
    Flag="aimPart",
    Callback=function(v) CFG.aimPart = type(v)=="table" and v[1] or v end,
})

AimTab:CreateSlider({
    Name="Sensitivity", Range={1,100}, Increment=1,
    CurrentValue=math.floor(CFG.aimSens*100),
    Flag="aimSens",
    Callback=function(v) CFG.aimSens = v/100 end,
})

AimTab:CreateSlider({
    Name="FOV Size", Range={10,360}, Increment=5,
    CurrentValue=CFG.aimFOV, Flag="aimFOV",
    Callback=function(v) CFG.aimFOV = v end,
})

local MiscTab = Window:CreateTab("Misc", "settings")

MiscTab:CreateToggle({
    Name="Auto Respawn", CurrentValue=CFG.autoRespawn, Flag="autoRespawn",
    Callback=function(v) CFG.autoRespawn = v end,
})

MiscTab:CreateToggle({
    Name="Kill Feed", CurrentValue=CFG.killFeed, Flag="killFeed",
    Callback=function(v) CFG.killFeed = v end,
})

MiscTab:CreateButton({
    Name="Deploy (Spawn In)",
    Callback=function()
        pcall(function() Deploy:FireServer() end)
        Rayfield:Notify({Title="Deployed", Content="Spawning in...", Duration=2})
    end,
})

local InfoTab = Window:CreateTab("Info", "info")
local targetLbl  = InfoTab:CreateLabel("Target: none")
local killsLbl   = InfoTab:CreateLabel("Session kills: 0")
local feedLbl    = InfoTab:CreateLabel("Kill feed: --")
local playersLbl = InfoTab:CreateLabel("Players: 0")

-- info update
local lastInfo = 0
RunService.Heartbeat:Connect(function()
    local now = tick()
    if now - lastInfo < 0.3 then return end
    lastInfo = now

    pcall(function() playersLbl:Set("Players: "..(#Players:GetPlayers()-1)) end)
    pcall(function() killsLbl:Set("Session kills: "..sessionKills) end)

    if aimTarget and aimTarget.Parent then
        local r  = getRoot(aimTarget)
        local h  = getHum(aimTarget)
        local d  = r and math.floor(getDist(r.Position)) or 0
        local hp = h and math.floor(h.Health) or 0
        pcall(function()
            targetLbl:Set("Target: "..aimTarget.Name.."  "..d.."m  "..hp.."hp")
        end)
    else
        pcall(function() targetLbl:Set("Target: none") end)
    end

    if #killLog > 0 then
        pcall(function() feedLbl:Set("Kill feed: "..killLog[1]) end)
    end
end)

print("[Pistol Arena] Loaded — hold Q to aim")