-- CQB HELL script: Aimbot + ESP + Instant Interaction + Hitbox Expander + player light

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

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

-- ==========================================
-- CONFIGURATION
-- ==========================================
local LOCK_RADIUS = 150        -- Screen radius (pixels) from center
local TARGET_PART = "Head"     -- "Head" or "HumanoidRootPart"
local MAX_DISTANCE = 300       -- Max distance (studs) to lock on

local isTrackingActive = false
local currentTarget = nil

-- ==========================================
-- NPC DETECTION 
-- ==========================================
local function getAdornee(model)
    return model:FindFirstChild("HumanoidRootPart")
        or model:FindFirstChild("Head")
        or model:FindFirstChild("UpperTorso")
        or model:FindFirstChild("Torso")
end

local function isPlayerCharacter(model)
    return model and model:IsA("Model") and Players:GetPlayerFromCharacter(model) ~= nil
end

local function isNPC(model)
    if not model or not model:IsA("Model") then
        return false
    end
    if isPlayerCharacter(model) then
        return false
    end
    return model:FindFirstChildOfClass("Humanoid") ~= nil and getAdornee(model) ~= nil
end

-- ==========================================
-- LINE OF SIGHT / WALL CHECK (optimized)
-- ==========================================
local function hasLineOfSightToTarget(fromPos, toPos, targetCharacter)
    local direction = toPos - fromPos
    local distance = direction.Magnitude
    local unitDir = direction.Unit

    local params = RaycastParams.new()
    params.FilterDescendantsInstances = {
        localPlayer.Character,
        camera,
        targetCharacter, -- ignore the NPC's own parts
    }
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.IgnoreWater = true

    local result = workspace:Raycast(fromPos, unitDir * distance, params)

    -- If no hit, clear LOS
    if not result then
        return true
    end

    local hitPart = result.Instance
    if not hitPart then
        return true
    end

    local hitModel = hitPart.Parent
    if hitModel and not hitModel:IsA("Model") and hitModel.Parent then
        hitModel = hitModel.Parent
    end

    if hitModel == targetCharacter then
        return true
    end

    return false
end

-- ==========================================
-- DYNAMIC UI GENERATION (hollow circle)
-- ==========================================
local function createFOVUI()
    local playerGui = localPlayer:FindFirstChildOfClass("PlayerGui")
    if not playerGui then
        playerGui = Instance.new("PlayerGui")
        playerGui.Name = "PlayerGui"
        playerGui.Parent = localPlayer
    end

    local oldGui = playerGui:FindFirstChild("InstantLockGui")
    if oldGui then
        oldGui:Destroy()
    end

    local screenGui = Instance.new("ScreenGui")
    screenGui.Name = "InstantLockGui"
    screenGui.ResetOnSpawn = false
    screenGui.IgnoreGuiInset = true
    screenGui.Enabled = true
    screenGui.Parent = playerGui

    local fovCircle = Instance.new("Frame")
    fovCircle.Name = "FOVCircle"
    fovCircle.AnchorPoint = Vector2.new(0.5, 0.5)
    fovCircle.Position = UDim2.new(0.5, 0, 0.5, 0)
    fovCircle.Size = UDim2.new(0, LOCK_RADIUS * 2, 0, LOCK_RADIUS * 2)
    fovCircle.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
    fovCircle.BackgroundTransparency = 1
    fovCircle.Visible = true
    fovCircle.Parent = screenGui

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

    local uiStroke = Instance.new("UIStroke")
    uiStroke.Thickness = 2
    uiStroke.Color = Color3.fromRGB(255, 0, 0)
    uiStroke.Transparency = 0.0
    uiStroke.Parent = fovCircle

    return screenGui
end

local screenGui = createFOVUI()

-- ==========================================
-- TARGET ACQUISITION LOGIC (cached, less heavy)
-- ==========================================
local npcCache = {}
local lastCacheRebuild = 0
local CACHE_LIFETIME = 1.0 -- seconds

local function rebuildNPCCache()
    npcCache = {}
    for _, obj in ipairs(workspace:GetDescendants()) do
        if obj:IsA("Model") and isNPC(obj) then
            npcCache[#npcCache + 1] = obj
        end
    end
    lastCacheRebuild = tick()
end

local function getNPCCandidates()
    if tick() - lastCacheRebuild > CACHE_LIFETIME then
        rebuildNPCCache()
    end
    return npcCache
end

local function findTargetInRadius()
    local screenCenter = Vector2.new(camera.ViewportSize.X / 2, camera.ViewportSize.Y / 2)
    local closestTarget = nil
    local shortestDistance = LOCK_RADIUS

    local localRoot = localPlayer.Character and localPlayer.Character:FindFirstChild("HumanoidRootPart")
    if not localRoot then
        return nil
    end

    local cameraPos = camera.CFrame.Position
    local candidates = getNPCCandidates()

    for _, obj in ipairs(candidates) do
        if obj and obj.Parent then
            local targetPart = obj:FindFirstChild(TARGET_PART) or getAdornee(obj)
            local humanoid = obj:FindFirstChildOfClass("Humanoid")

            if targetPart and humanoid and humanoid.Health > 0 then
                local targetPos = targetPart.Position
                local distanceBetween = (targetPos - localRoot.Position).Magnitude

                if distanceBetween <= MAX_DISTANCE then
                    local screenPos, onScreen = camera:WorldToViewportPoint(targetPos)

                    if onScreen then
                        local screenDistance = (screenCenter - Vector2.new(screenPos.X, screenPos.Y)).Magnitude

                        if screenDistance < shortestDistance then
                            -- Optional wall check: comment out the if to skip it entirely
                            if hasLineOfSightToTarget(cameraPos, targetPos, obj) then
                                shortestDistance = screenDistance
                                closestTarget = targetPart
                            end
                        end
                    end
                end
            end
        end
    end

    return closestTarget
end

-- ==========================================
-- INPUT TRACKING (RMB = always control lock)
-- ==========================================
local function isRightClick(input)
    return input.UserInputType == Enum.UserInputType.MouseButton2
        or input.KeyCode == Enum.KeyCode.ButtonR
end

UserInputService.InputBegan:Connect(function(input, processed)
    if isRightClick(input) then
        isTrackingActive = true
        -- Only scan once on press
        currentTarget = findTargetInRadius()
    end
end)

UserInputService.InputEnded:Connect(function(input)
    if isRightClick(input) then
        isTrackingActive = false
        currentTarget = nil
    end
end)

-- ==========================================
-- CONTINUOUS LOCK-ON WHILE HOLDING RMB
-- ==========================================
RunService.RenderStepped:Connect(function()
    if isTrackingActive then
        -- If we have no target or the current target is invalid, try to find a new one
        if not currentTarget or not currentTarget.Parent then
            currentTarget = findTargetInRadius()
        else
            -- Target exists: keep lock unless dead / too far / gone
            local character = currentTarget.Parent
            local humanoid = character and character:FindFirstChildOfClass("Humanoid")
            local localRoot = localPlayer.Character and localPlayer.Character:FindFirstChild("HumanoidRootPart")

            if not humanoid or humanoid.Health <= 0 or not localRoot then
                currentTarget = nil
            else
                local distanceBetween = (currentTarget.Position - localRoot.Position).Magnitude
                if distanceBetween > MAX_DISTANCE then
                    currentTarget = nil
                end
            end
        end

        -- Apply lock if we have a valid target
        if currentTarget and currentTarget.Parent then
            local character = currentTarget.Parent
            local humanoid = character and character:FindFirstChildOfClass("Humanoid")
            local localRoot = localPlayer.Character and localPlayer.Character:FindFirstChild("HumanoidRootPart")

            if humanoid and humanoid.Health > 0 and localRoot then
                local distanceBetween = (currentTarget.Position - localRoot.Position).Magnitude

                if distanceBetween <= MAX_DISTANCE then
                    local cameraPosition = camera.CFrame.Position
                    local targetPosition = currentTarget.Position

                    camera.CFrame = CFrame.lookAt(cameraPosition, targetPosition)
                else
                    currentTarget = nil
                end
            else
                currentTarget = nil
            end
        end
    else
        currentTarget = nil
    end
end)

-- ==========================================
-- INSTANT INTERACTION SCRIPT
-- ==========================================
local Workspace = game:GetService("Workspace")

local function fixPrompt(p)
    if p.HoldDuration and p.HoldDuration > 0 then
        p.HoldDuration = 0
    end
end

for _, v in ipairs(Workspace:GetDescendants()) do
    if v:IsA("ProximityPrompt") then
        fixPrompt(v)
    end
end

Workspace.DescendantAdded:Connect(function(obj)
    if obj:IsA("ProximityPrompt") then
        fixPrompt(obj)
    end
end)

-- ==========================================
-- ESP SCRIPT 
-- Players = Green  |  NPC = Yellow 
-- ==========================================
repeat task.wait() until game:IsLoaded()

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local StarterGui = game:GetService("StarterGui")
local UserInputService = game:GetService("UserInputService")
local workspace = game:GetService("Workspace")

local LocalPlayer = Players.LocalPlayer
local enabled = true
local playerColor = Color3.fromRGB(0, 255, 0)
local npcColor = Color3.fromRGB(255, 255, 0)
local npcNameMaxDistance = 500

local nameMode = "displayname"
local npcList = {}

local function notify(title, text, duration)
    pcall(function()
        StarterGui:SetCore("SendNotification", {
            Title = title,
            Text = text,
            Duration = duration or 3
        })
    end)
end

notify("System Notification", "Made by: JigglingCheeks1", 15)

local function getAdornee(model)
    return model:FindFirstChild("HumanoidRootPart")
        or model:FindFirstChild("Head")
        or model:FindFirstChild("UpperTorso")
        or model:FindFirstChild("Torso")
end

local function isPlayerCharacter(model)
    return model and model:IsA("Model") and Players:GetPlayerFromCharacter(model) ~= nil
end

local function isNPC(model)
    if not model or not model:IsA("Model") then
        return false
    end
    if isPlayerCharacter(model) then
        return false
    end
    return model:FindFirstChildOfClass("Humanoid") ~= nil and getAdornee(model) ~= nil
end

local function getLocalRoot()
    local char = LocalPlayer.Character
    return char and char:FindFirstChild("HumanoidRootPart")
end

local function getHumanoid(model)
    return model and model:FindFirstChildOfClass("Humanoid")
end

local function safeDestroy(parent, name, className)
    local child = parent and parent:FindFirstChild(name)
    if child and child:IsA(className) then
        child:Destroy()
    end
end

local function ensureHighlight(model, color, name)
    safeDestroy(model, name, "Highlight")
    local hl = Instance.new("Highlight")
    hl.Name = name
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    hl.FillColor = color
    hl.OutlineColor = color
    hl.Enabled = enabled
    hl.Parent = model
    return hl
end

local function ensureBox(part, color, name)
    safeDestroy(part, name, "BoxHandleAdornment")
    local box = Instance.new("BoxHandleAdornment")
    box.Name = name
    box.Size = Vector3.new(2, 3, 2)
    box.Adornee = part
    box.AlwaysOnTop = true
    box.ZIndex = 5
    box.Transparency = 1
    box.Color3 = color
    box.Visible = enabled
    box.Parent = part
    return box
end

local function ensureNameTag(model, color, name)
    local part = model:FindFirstChild("Head") or model:FindFirstChild("HumanoidRootPart") or getAdornee(model)
    if not part then return nil end

    safeDestroy(part, name, "BillboardGui")

    local gui = Instance.new("BillboardGui")
    gui.Name = name
    gui.Adornee = part
    gui.AlwaysOnTop = true
    gui.Size = UDim2.new(0, 180, 0, 28)
    gui.StudsOffset = Vector3.new(0, 2.4, 0)
    gui.MaxDistance = 100000000000
    gui.Parent = part

    local label = Instance.new("TextLabel")
    label.Name = "NameLabel"
    label.BackgroundTransparency = 1
    label.Size = UDim2.new(1, 0, 1, 0)
    label.Font = Enum.Font.SourceSansBold
    label.TextScaled = true
    label.TextStrokeTransparency = 0.35
    label.TextColor3 = color
    label.Text = ""
    label.Parent = gui

    return gui, label, part
end

local function applyPlayerESP(plr)
    if not plr or plr == LocalPlayer then return end
    local char = plr.Character
    if not char then return end

    ensureHighlight(char, playerColor, "GetReal")

    local part = getAdornee(char)
    if part then
        ensureBox(part, playerColor, "BoxESP")
    end

    local nameText = plr.DisplayName
    if nameMode == "username" then
        nameText = plr.Name
    elseif nameMode == "both" then
        nameText = string.format("%s (%s)", plr.DisplayName, plr.Name)
    end

    local gui, label = ensureNameTag(char, playerColor, "NameESP")
    if gui and label then
        local hum = getHumanoid(char)
        local hpText = hum and string.format("HP: %d/%d", math.floor(hum.Health), math.floor(hum.MaxHealth)) or "HP: N/A"
        label.Text = string.format("%s [%s]", nameText, hpText)
        label.Visible = enabled
        gui.Enabled = enabled
    end
end

local function addNPC(model)
    if not isNPC(model) then return end
    if npcList[model] then return end
    npcList[model] = true

    local part = getAdornee(model)
    if not part then return end

    ensureHighlight(model, npcColor, "NPC_Highlight")
    ensureBox(part, npcColor, "NPC_Box")
end

local function removeNPC(model)
    npcList[model] = nil
end

local npcScanIndex = 1
local npcScanBatch = 50
local scanList = {}

local function rebuildScanList()
    scanList = workspace:GetDescendants()
    npcScanIndex = 1
end

local function scanForNPCsStep()
    if #scanList == 0 then
        rebuildScanList()
    end

    local count = 0
    while npcScanIndex <= #scanList and count < npcScanBatch do
        local obj = scanList[npcScanIndex]
        npcScanIndex += 1
        count += 1

        if obj and obj:IsA("Model") and isNPC(obj) then
            addNPC(obj)
        end
    end

    if npcScanIndex > #scanList then
        rebuildScanList()
    end
end

local function refreshAllESP()
    for _, plr in ipairs(Players:GetPlayers()) do
        applyPlayerESP(plr)
    end

    for model in pairs(npcList) do
        if model and model.Parent and isNPC(model) then
            local part = getAdornee(model)
            if part then
                ensureHighlight(model, npcColor, "NPC_Highlight")
                ensureBox(part, npcColor, "NPC_Box")
            end
        else
            npcList[model] = nil
        end
    end
end

UserInputService.InputBegan:Connect(function(input, processed)
    if processed then return end
    if input.KeyCode == Enum.KeyCode.RightBracket then
        enabled = not enabled
        notify("System Notification", enabled and "ESP Enabled" or "ESP Disabled")
    elseif input.KeyCode == Enum.KeyCode.LeftBracket then
        if nameMode == "displayname" then
            nameMode = "username"
        elseif nameMode == "username" then
            nameMode = "both"
        else
            nameMode = "displayname"
        end
        notify("System Notification", "Name ESP mode: " .. nameMode)
    end
end)

Players.PlayerAdded:Connect(function(plr)
    plr.CharacterAdded:Connect(function()
        task.wait(0.3)
        applyPlayerESP(plr)
    end)
end)

for _, plr in ipairs(Players:GetPlayers()) do
    if plr ~= LocalPlayer then
        plr.CharacterAdded:Connect(function()
            task.wait(0.3)
            applyPlayerESP(plr)
        end)
    end
end

workspace.DescendantAdded:Connect(function(desc)
    if desc:IsA("Model") then
        task.defer(function()
            task.wait(0.15)
            if desc and desc.Parent and isNPC(desc) then
                addNPC(desc)
            end
        end)
    end
end)

workspace.DescendantRemoving:Connect(function(desc)
    if desc:IsA("Model") then
        removeNPC(desc)
    end
end)

rebuildScanList()

local npcTimer = 0
local espTimer = 0

RunService.Heartbeat:Connect(function(dt)
    npcTimer += dt
    espTimer += dt

    if npcTimer >= 0.08 then
        npcTimer = 0
        scanForNPCsStep()
    end

    if espTimer >= 1 then
        espTimer = 0
        refreshAllESP()
    end
end)




-- NPC Head Hitbox Expander

repeat task.wait() until game:IsLoaded()

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local workspace = game:GetService("Workspace")

local LocalPlayer = Players.LocalPlayer

-- ============ SETTINGS ============
local HEAD_SIZE = 16
local SHOW_HITBOX = true
local TRANSPARENCY = 0.65
-- ==================================

local function getAdornee(model)
	return model:FindFirstChild("HumanoidRootPart")
		or model:FindFirstChild("Head")
		or model:FindFirstChild("UpperTorso")
		or model:FindFirstChild("Torso")
end

local function isPlayerCharacter(model)
	return model and model:IsA("Model") and Players:GetPlayerFromCharacter(model) ~= nil
end

local function isNPC(model)
	if not model or not model:IsA("Model") then return false end
	if isPlayerCharacter(model) then return false end
	return model:FindFirstChildOfClass("Humanoid") ~= nil and getAdornee(model) ~= nil
end

-- Find any part that is likely the head
local function findHead(model)
	-- Common names first
	local names = {
		"Head",
		"head",
		"FakeHead",
		"HeadHB",
		"HB_Head",
		"HitboxHead",
		"UpperTorso", -- fallback if no real head
	}

	for _, name in ipairs(names) do
		local p = model:FindFirstChild(name)
		if p and p:IsA("BasePart") then
			return p
		end
	end

	-- Last resort: any BasePart that has "head" in the name (case insensitive)
	for _, p in ipairs(model:GetDescendants()) do
		if p:IsA("BasePart") and string.find(string.lower(p.Name), "head") then
			return p
		end
	end

	return nil
end

local tracked = {} -- [Model] = headPart

local function forceHead(model)
	if not isNPC(model) then return end

	local head = findHead(model)
	if not head then return end

	head.Size = Vector3.new(HEAD_SIZE, HEAD_SIZE, HEAD_SIZE)
	head.Transparency = SHOW_HITBOX and TRANSPARENCY or 1
	head.CanCollide = false
	head.Massless = true
	head.CanQuery = true
	head.CanTouch = true

	tracked[model] = head
end

-- Force every frame so nothing resets it
RunService.Heartbeat:Connect(function()
	for model, head in pairs(tracked) do
		if model and model.Parent and head and head.Parent and isNPC(model) then
			if head.Size.X < HEAD_SIZE * 0.95 then
				head.Size = Vector3.new(HEAD_SIZE, HEAD_SIZE, HEAD_SIZE)
				head.Transparency = SHOW_HITBOX and TRANSPARENCY or 1
				head.CanCollide = false
				head.Massless = true
				head.CanQuery = true
			end
		else
			tracked[model] = nil
		end
	end
end)

local function scan()
	for _, obj in ipairs(workspace:GetDescendants()) do
		if obj:IsA("Model") then
			forceHead(obj)
		end
	end
end

workspace.DescendantAdded:Connect(function(desc)
	if desc:IsA("Model") then
		task.defer(function()
			task.wait(0.2)
			forceHead(desc)
		end)
	elseif desc:IsA("BasePart") then
		-- If a head-like part is added later, catch it
		local model = desc:FindFirstAncestorOfClass("Model")
		if model and isNPC(model) then
			task.defer(function()
				forceHead(model)
			end)
		end
	end
end)

task.spawn(function()
	while true do
		scan()
		task.wait(0.8) -- scan more often
	end
end)

scan()

print("[NPC Head Hitbox] Improved version loaded | Size:", HEAD_SIZE)


-- player light

local Players = game:GetService("Players")
local player = Players.LocalPlayer

local function addLight(character)
	local root = character:WaitForChild("HumanoidRootPart")

	local light = root:FindFirstChild("CharacterLight")
	if light then
		light:Destroy()
	end

	light = Instance.new("PointLight")
	light.Name = "CharacterLight"
	light.Color = Color3.fromRGB(255, 255, 255)
	light.Brightness = 0.8
	light.Range = 50
	light.Shadows = false
	light.Parent = root
end

if player.Character then
	addLight(player.Character)
end

player.CharacterAdded:Connect(addLight)

notify("Recommendation", "HIGHLY suggest you set ragdall despawn time to 0", 30)
notify("Recommendation", "(Settings button at bottom right)", 30)