-- Bob / Black Figure Stalker (Fixed Countdown)
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Lighting = game:GetService("Lighting")
local TweenService = game:GetService("TweenService")

-- ======================
-- SETTINGS
-- ======================
local CATCH_DISTANCE = 7
local MOVE_SPEED = 145
local UPDATE_RATE = 0.10
local PREDICTION_TIME = 0.9
local IMAGE_ID = "rbxassetid://88195415958694"
local WARNING_TIME = 180 -- 3 minutes
local ALONE_DISTANCE = 90
local BAN_DURATION = 3 * 24 * 60 * 60 -- 3 days

-- ======================
-- WARNING + COUNTDOWN
-- ======================
local warningGuis = {}

local function createWarningGui(player)
	local playerGui = player:WaitForChild("PlayerGui", 10)
	if not playerGui then return end

	-- Remove old one if it exists
	local old = playerGui:FindFirstChild("BobWarning")
	if old then old:Destroy() end

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

	local text = Instance.new("TextLabel")
	text.Name = "WarningText"
	text.Size = UDim2.new(1, 0, 0, 90)
	text.Position = UDim2.new(0, 0, 0.07, 0)
	text.BackgroundTransparency = 1
	text.Text = "Something is coming in 3:00"
	text.TextColor3 = Color3.fromRGB(200, 0, 0)
	text.TextStrokeTransparency = 0.2
	text.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
	text.Font = Enum.Font.Code
	text.TextScaled = true
	text.Parent = screenGui

	warningGuis[player] = text
end

local function updateCountdown(secondsLeft)
	local minutes = math.floor(secondsLeft / 60)
	local seconds = secondsLeft % 60
	local display = string.format("Something is coming in %d:%02d", minutes, seconds)

	for player, textLabel in pairs(warningGuis) do
		if player.Parent and textLabel and textLabel.Parent then
			textLabel.Text = display
		end
	end
end

local function removeAllWarnings()
	for player, textLabel in pairs(warningGuis) do
		local gui = textLabel and textLabel.Parent
		if gui then
			gui:Destroy()
		end
	end
	table.clear(warningGuis)
end

local function startWarning()
	-- Give GUI to current players
	for _, player in Players:GetPlayers() do
		createWarningGui(player)
	end

	-- Give GUI to new players
	Players.PlayerAdded:Connect(function(player)
		createWarningGui(player)
	end)

	-- Clean up when players leave
	Players.PlayerRemoving:Connect(function(player)
		warningGuis[player] = nil
	end)

	-- Countdown loop
	task.spawn(function()
		for i = WARNING_TIME, 0, -1 do
			updateCountdown(i)
			task.wait(1)
		end
		removeAllWarnings()
	end)
end

-- ======================
-- CREATE BOB
-- ======================
local function createBob()
	local bob = Instance.new("Model")
	bob.Name = "Bob"

	local root = Instance.new("Part")
	root.Name = "HumanoidRootPart"
	root.Size = Vector3.new(2, 5, 1)
	root.Transparency = 1
	root.CanCollide = false
	root.Anchored = false
	root.Parent = bob

	local billboard = Instance.new("BillboardGui")
	billboard.Name = "FollowerBillboard"
	billboard.Size = UDim2.new(11, 0, 14, 0)
	billboard.StudsOffset = Vector3.new(0, 4, 0)
	billboard.AlwaysOnTop = true
	billboard.MaxDistance = 500
	billboard.Parent = root

	local image = Instance.new("ImageLabel")
	image.Name = "Image"
	image.Size = UDim2.fromScale(1, 1)
	image.BackgroundTransparency = 1
	image.Image = IMAGE_ID
	image.ScaleType = Enum.ScaleType.Fit
	image.Parent = billboard

	local glow = Instance.new("ImageLabel")
	glow.Name = "Glow"
	glow.Size = UDim2.fromScale(1.4, 1.4)
	glow.Position = UDim2.fromScale(-0.2, -0.2)
	glow.BackgroundTransparency = 1
	glow.Image = IMAGE_ID
	glow.ImageTransparency = 0.7
	glow.ImageColor3 = Color3.fromRGB(30, 0, 0)
	glow.ScaleType = Enum.ScaleType.Fit
	glow.ZIndex = 0
	glow.Parent = billboard

	local humanoid = Instance.new("Humanoid")
	humanoid.MaxHealth = math.huge
	humanoid.Health = math.huge
	humanoid.WalkSpeed = MOVE_SPEED
	humanoid.DisplayDistanceType = Enum.HumanoidDisplayDistanceType.None
	humanoid.Parent = bob

	bob.PrimaryPart = root
	bob.Parent = workspace

	return bob, humanoid, root
end

-- ======================
-- ALONE CHECK
-- ======================
local function isPlayerAlone(player)
	local char = player.Character
	if not char then return false end
	local root = char:FindFirstChild("HumanoidRootPart")
	if not root then return false end

	for _, other in Players:GetPlayers() do
		if other ~= player then
			local otherChar = other.Character
			if otherChar then
				local otherHum = otherChar:FindFirstChildOfClass("Humanoid")
				local otherRoot = otherChar:FindFirstChild("HumanoidRootPart")
				if otherHum and otherRoot and otherHum.Health > 0 then
					if (otherRoot.Position - root.Position).Magnitude < ALONE_DISTANCE then
						return false
					end
				end
			end
		end
	end
	return true
end

-- ======================
-- BAN
-- ======================
local function banPlayer(player)
	local success, err = pcall(function()
		Players:BanAsync({
			UserIds = {player.UserId},
			Duration = BAN_DURATION,
			DisplayReason = "You were caught alone by something in the dark.",
			PrivateReason = "Caught by Bob while alone"
		})
	end)

	if not success then
		warn("Ban failed:", err)
		player:Kick("You were caught alone...")
	end
end

-- ======================
-- TARGETING
-- ======================
local function getBestTarget(fromPosition)
	local bestPlayer = nil
	local bestScore = -math.huge

	for _, player in Players:GetPlayers() do
		if not isPlayerAlone(player) then continue end

		local char = player.Character
		if not char then continue end

		local hum = char:FindFirstChildOfClass("Humanoid")
		local root = char:FindFirstChild("HumanoidRootPart")
		if not hum or not root or hum.Health <= 0 then continue end

		local distance = (root.Position - fromPosition).Magnitude
		local score = 3000 - distance

		if score > bestScore then
			bestScore = score
			bestPlayer = player
		end
	end

	return bestPlayer
end

local function predictPosition(rootPart, timeAhead)
	local velocity = rootPart.AssemblyLinearVelocity
	local horizontalVel = Vector3.new(velocity.X, 0, velocity.Z)
	return rootPart.Position + horizontalVel * timeAhead
end

-- ======================
-- DAY / NIGHT
-- ======================
local function startDayNightCycle()
	local startClock = Lighting.ClockTime

	Lighting.Brightness = 1.4
	Lighting.Ambient = Color3.fromRGB(40, 35, 50)
	Lighting.OutdoorAmbient = Color3.fromRGB(30, 25, 40)
	Lighting.FogEnd = 400
	Lighting.FogColor = Color3.fromRGB(20, 15, 25)

	task.spawn(function()
		while true do
			local tween = TweenService:Create(Lighting, TweenInfo.new(70, Enum.EasingStyle.Linear), {
				ClockTime = startClock + 24
			})
			tween:Play()
			tween.Completed:Wait()
			startClock += 24
		end
	end)
end

-- ======================
-- MAIN
-- ======================
startWarning()
startDayNightCycle()

-- Wait for the full 3 minutes
task.wait(WARNING_TIME)

local bob, humanoid, root = createBob()
root.CFrame = CFrame.new(0, 16, 0)

local lastUpdate = 0
local alreadyBanned = {}

RunService.Heartbeat:Connect(function()
	if not bob.Parent or humanoid.Health <= 0 then return end

	local now = tick()
	if now - lastUpdate < UPDATE_RATE then return end
	lastUpdate = now

	local target = getBestTarget(root.Position)

	if not target or not target.Character or alreadyBanned[target.UserId] then
		humanoid:MoveTo(root.Position)
		return
	end

	local targetRoot = target.Character:FindFirstChild("HumanoidRootPart")
	if not targetRoot then return end

	local predictedPos = predictPosition(targetRoot, PREDICTION_TIME)
	local direction = predictedPos - root.Position
	local distance = direction.Magnitude

	if direction.Magnitude > 0.5 then
		root.CFrame = CFrame.lookAt(root.Position, Vector3.new(predictedPos.X, root.Position.Y, predictedPos.Z))
	end

	-- Full sprint at them
	humanoid.WalkSpeed = MOVE_SPEED + 30
	humanoid:MoveTo(predictedPos)

	-- Catch + Ban
	if distance <= CATCH_DISTANCE then
		alreadyBanned[target.UserId] = true
		banPlayer(target)
		print(target.Name .. " was caught and banned for 3 days.")
	end
end)

print("Countdown fixed. He only comes when you're alone.")