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

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

local oldGui = playerGui:FindFirstChild("BloxBangGui")
if oldGui then
	local existingCleanupEvent = playerGui:FindFirstChild("BloxBangCleanup")
	if existingCleanupEvent then
		existingCleanupEvent:Fire()
		task.wait(0.1)
	end
	oldGui:Destroy()
end

local cleanupEvent = playerGui:FindFirstChild("BloxBangCleanup")
if not cleanupEvent then
	cleanupEvent = Instance.new("BindableEvent")
	cleanupEvent.Name = "BloxBangCleanup"
	cleanupEvent.Parent = playerGui
end

local screenGui = Instance.new("ScreenGui")
screenGui.Name = "BloxBangGui"
screenGui.ResetOnSpawn = false
screenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
screenGui.Parent = playerGui

local textLabel = Instance.new("TextLabel")
textLabel.Name = "BloxBangLabel"
textLabel.Size = UDim2.new(0, 150, 0, 20)
textLabel.Position = UDim2.new(0, 5, 0, 5)
textLabel.AnchorPoint = Vector2.new(0, 0)
textLabel.BackgroundTransparency = 1
textLabel.Text = "BloxBang v1"
textLabel.TextScaled = false
textLabel.TextSize = 24
textLabel.Font = Enum.Font.GothamBold
textLabel.TextXAlignment = Enum.TextXAlignment.Left
textLabel.TextYAlignment = Enum.TextYAlignment.Top
textLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
textLabel.Parent = screenGui

local hintLabel = Instance.new("TextLabel")
hintLabel.Name = "CleanupHint"
hintLabel.Size = UDim2.new(0, 150, 0, 16)
hintLabel.Position = UDim2.new(0, 5, 0, 30)
hintLabel.AnchorPoint = Vector2.new(0, 0)
hintLabel.BackgroundTransparency = 1
hintLabel.Text = "[F8] to cleanup."
hintLabel.TextScaled = false
hintLabel.TextSize = 14
hintLabel.Font = Enum.Font.GothamBold
hintLabel.TextXAlignment = Enum.TextXAlignment.Left
hintLabel.TextYAlignment = Enum.TextYAlignment.Top
hintLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
hintLabel.Parent = screenGui

local stealthHintLabel = Instance.new("TextLabel")
stealthHintLabel.Name = "StealthHint"
stealthHintLabel.Size = UDim2.new(0, 150, 0, 16)
stealthHintLabel.Position = UDim2.new(0, 5, 0, 46)
stealthHintLabel.AnchorPoint = Vector2.new(0, 0)
stealthHintLabel.BackgroundTransparency = 1
stealthHintLabel.Text = "[F6] to toggle stealth."
stealthHintLabel.TextScaled = false
stealthHintLabel.TextSize = 14
stealthHintLabel.Font = Enum.Font.GothamBold
stealthHintLabel.TextXAlignment = Enum.TextXAlignment.Left
stealthHintLabel.TextYAlignment = Enum.TextYAlignment.Top
stealthHintLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
stealthHintLabel.Parent = screenGui

local controlsHintLabel = Instance.new("TextLabel")
controlsHintLabel.Name = "ControlsHint"
controlsHintLabel.Size = UDim2.new(0, 300, 0, 16)
controlsHintLabel.Position = UDim2.new(0, 5, 0, 62)
controlsHintLabel.AnchorPoint = Vector2.new(0, 0)
controlsHintLabel.BackgroundTransparency = 1
controlsHintLabel.Text = "[K] to cycle left, [L] to cycle right, [P] to toggle"
controlsHintLabel.TextScaled = false
controlsHintLabel.TextSize = 14
controlsHintLabel.Font = Enum.Font.GothamBold
controlsHintLabel.TextXAlignment = Enum.TextXAlignment.Left
controlsHintLabel.TextYAlignment = Enum.TextYAlignment.Top
controlsHintLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
controlsHintLabel.Parent = screenGui

local warningLabel = Instance.new("TextLabel")
warningLabel.Name = "Force3rdWarning"
warningLabel.Size = UDim2.new(0, 320, 0, 16)
warningLabel.Position = UDim2.new(0, 5, 0, 78)
warningLabel.AnchorPoint = Vector2.new(0, 0)
warningLabel.BackgroundTransparency = 1
warningLabel.Text = "[WARNING] Force 3rd Person is unreliable."
warningLabel.TextScaled = false
warningLabel.TextSize = 14
warningLabel.Font = Enum.Font.GothamBold
warningLabel.TextXAlignment = Enum.TextXAlignment.Left
warningLabel.TextYAlignment = Enum.TextYAlignment.Top
warningLabel.TextColor3 = Color3.fromRGB(255, 165, 0)
warningLabel.Parent = screenGui

local features = {
	{ name = "Big Heads",        enabled = false },
	{ name = "Force 3rd Person", enabled = false },
	{ name = "Auto Jump",        enabled = false },
	{ name = "Bloxbang Visuals", enabled = false },
	{ name = "Outlines",         enabled = false },
}

local function getFeature(name)
	for _, f in ipairs(features) do
		if f.name == name then return f end
	end
	return nil
end

local selectedIndex = 1

local featureLabel = Instance.new("TextLabel")
featureLabel.Name = "FeatureLabel"
featureLabel.Size = UDim2.new(0, 250, 0, 16)
featureLabel.Position = UDim2.new(0, 5, 0, 94)
featureLabel.AnchorPoint = Vector2.new(0, 0)
featureLabel.BackgroundTransparency = 1
featureLabel.TextScaled = false
featureLabel.TextSize = 14
featureLabel.Font = Enum.Font.GothamBold
featureLabel.TextXAlignment = Enum.TextXAlignment.Left
featureLabel.TextYAlignment = Enum.TextYAlignment.Top
featureLabel.RichText = true
featureLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
featureLabel.Parent = screenGui

local function updateFeatureLabel()
	local f = features[selectedIndex]
	local stateColor = f.enabled and "rgb(80,255,80)" or "rgb(255,80,80)"
	local stateText = f.enabled and "true" or "false"
	featureLabel.Text = string.format(
		'Feature &lt;%s&gt; <font color="%s">%s</font>',
		f.name, stateColor, stateText
	)
end

local function cycleLeft()
	selectedIndex = selectedIndex - 1
	if selectedIndex < 1 then selectedIndex = #features end
	updateFeatureLabel()
end

local function cycleRight()
	selectedIndex = selectedIndex + 1
	if selectedIndex > #features then selectedIndex = 1 end
	updateFeatureLabel()
end

-- Helpers
local function getCharacter()
	return player.Character
end

local function getHumanoid()
	local char = getCharacter()
	if not char then return nil end
	return char:FindFirstChildOfClass("Humanoid")
end

local function getHead(char)
	if not char then return nil end
	return char:FindFirstChild("Head")
end

local function isAlive()
	local humanoid = getHumanoid()
	return humanoid ~= nil and humanoid.Health > 0
end

-- Stealth mode
local stealthModeActive = false
local allLabels = { textLabel, hintLabel, stealthHintLabel, controlsHintLabel, warningLabel, featureLabel }

local function setStealthMode(active)
	stealthModeActive = active
	for _, label in ipairs(allLabels) do
		label.Visible = not active
	end
end

local function toggleStealthMode()
	setStealthMode(not stealthModeActive)
end

-- Big Heads state
local bigHeadsConnections = {}
local originalHeadSizes = {}
local playerAddedConn

local function applyBigHead(plr, char)
	if not char then return end
	local head = getHead(char)
	if not head then
		for i = 1, 20 do
			task.wait(0.1)
			if not getFeature("Big Heads").enabled then return end
			head = getHead(char)
			if head then break end
		end
	end
	if not head then return end
	if not getFeature("Big Heads").enabled then return end
	originalHeadSizes[plr.UserId] = head.Size
	head.Size = Vector3.new(3, 3, 3)
end

local function enableBigHeads(plr)
	if plr == player then return end

	task.spawn(function()
		applyBigHead(plr, plr.Character)
	end)

	if bigHeadsConnections[plr.UserId] then return end

	local conn = plr.CharacterAdded:Connect(function(newChar)
		if not getFeature("Big Heads").enabled then return end
		task.spawn(function()
			applyBigHead(plr, newChar)
		end)
	end)
	bigHeadsConnections[plr.UserId] = conn
end

local function disableBigHeads(plr)
	if plr == player then return end

	local conn = bigHeadsConnections[plr.UserId]
	if conn then
		conn:Disconnect()
		bigHeadsConnections[plr.UserId] = nil
	end

	local char = plr.Character
	if char then
		local head = getHead(char)
		if head then
			head.Size = originalHeadSizes[plr.UserId] or Vector3.new(2, 1, 1)
		end
	end
	originalHeadSizes[plr.UserId] = nil
end

-- Auto Jump state
local autoJumpHeartbeat

local function enableAutoJump()
	if autoJumpHeartbeat then return end
	autoJumpHeartbeat = RunService.Heartbeat:Connect(function()
		if not getFeature("Auto Jump").enabled then return end
		if not isAlive() then return end
		if not UserInputService:IsKeyDown(Enum.KeyCode.Space) then return end
		local humanoid = getHumanoid()
		if not humanoid then return end
		local state = humanoid:GetState()
		if state ~= Enum.HumanoidStateType.Running
		and state ~= Enum.HumanoidStateType.RunningNoPhysics then return end
		humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
	end)
end

local function disableAutoJump()
	if autoJumpHeartbeat then
		autoJumpHeartbeat:Disconnect()
		autoJumpHeartbeat = nil
	end
end

-- Force 3rd Person state
local originalMinZoom = nil
local originalMaxZoom = nil
local force3rdHeartbeat
local FORCE_ZOOM = 8

local function enableForce3rdPerson()
	if force3rdHeartbeat then return end
	if not player then return end
	originalMinZoom = player.CameraMinZoomDistance
	originalMaxZoom = player.CameraMaxZoomDistance

	player.CameraMinZoomDistance = FORCE_ZOOM
	player.CameraMaxZoomDistance = FORCE_ZOOM

	force3rdHeartbeat = RunService.Heartbeat:Connect(function()
		if not getFeature("Force 3rd Person").enabled then return end
		if not player then return end

		if player.CameraMinZoomDistance ~= FORCE_ZOOM then
			player.CameraMinZoomDistance = FORCE_ZOOM
		end
		if player.CameraMaxZoomDistance ~= FORCE_ZOOM then
			player.CameraMaxZoomDistance = FORCE_ZOOM
		end

		local camera = workspace.CurrentCamera
		local char = getCharacter()
		if not camera or not char then return end
		local rootPart = char:FindFirstChild("HumanoidRootPart")
		if not rootPart then return end
		local direction = (camera.CFrame.Position - rootPart.Position).Unit
		if direction.Magnitude == 0 then return end
		camera.CFrame = CFrame.new(rootPart.Position + direction * FORCE_ZOOM, rootPart.Position)
	end)
end

local function disableForce3rdPerson()
	if force3rdHeartbeat then
		force3rdHeartbeat:Disconnect()
		force3rdHeartbeat = nil
	end
	if not player then return end
	if originalMinZoom then
		player.CameraMinZoomDistance = originalMinZoom
		originalMinZoom = nil
	end
	if originalMaxZoom then
		player.CameraMaxZoomDistance = originalMaxZoom
		originalMaxZoom = nil
	end
end

-- Bloxbang Visuals state
local originalBrightness = nil
local disabledLights = {}

local function enableVisuals()
	originalBrightness = Lighting.Brightness
	Lighting.Brightness = 0

	for _, obj in ipairs(Workspace:GetDescendants()) do
		if obj:IsA("PointLight") or obj:IsA("SpotLight") or obj:IsA("SurfaceLight") then
			if obj.Enabled then
				disabledLights[obj] = true
				obj.Enabled = false
			end
		end
	end
end

local function disableVisuals()
	if originalBrightness ~= nil then
		Lighting.Brightness = originalBrightness
		originalBrightness = nil
	end

	for lightObj, _ in pairs(disabledLights) do
		if lightObj and lightObj.Parent then
			lightObj.Enabled = true
		end
	end
	disabledLights = {}
end

-- Outlines state
local outlineHeartbeat
local outlineLastRun = 0
local OUTLINE_COOLDOWN = 0.5

local function enableEnemyOutlines()
	outlineHeartbeat = RunService.Heartbeat:Connect(function()
		if not getFeature("Outlines").enabled then return end
		local now = tick()
		if now - outlineLastRun < OUTLINE_COOLDOWN then return end
		outlineLastRun = now
		for _, plr in ipairs(Players:GetPlayers()) do
			if plr == player then continue end
			local char = plr.Character
			if not char then continue end
			if char:FindFirstChild("BloxBangOutline") then continue end
			local highlight = Instance.new("Highlight")
			highlight.Name = "BloxBangOutline"
			highlight.FillColor = Color3.fromRGB(255, 255, 255)
			highlight.OutlineColor = Color3.fromRGB(255, 255, 255)
			highlight.FillTransparency = 0.6
			highlight.OutlineTransparency = 0
			highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
			highlight.Adornee = char
			highlight.Parent = char
		end
	end)
end

local function disableEnemyOutlines()
	if outlineHeartbeat then
		outlineHeartbeat:Disconnect()
		outlineHeartbeat = nil
	end
	for _, obj in ipairs(Workspace:GetDescendants()) do
		if obj.Name == "BloxBangOutline" then
			obj:Destroy()
		end
	end
end

-- Dispatch tables
local enableHandlers = {
	["Big Heads"] = function()
		for _, plr in ipairs(Players:GetPlayers()) do
			enableBigHeads(plr)
		end
		if not playerAddedConn then
			playerAddedConn = Players.PlayerAdded:Connect(function(plr)
				enableBigHeads(plr)
			end)
		end
	end,
	["Force 3rd Person"] = enableForce3rdPerson,
	["Auto Jump"] = enableAutoJump,
	["Bloxbang Visuals"] = enableVisuals,
	["Outlines"] = enableEnemyOutlines,
}

local disableHandlers = {
	["Big Heads"] = function()
		if playerAddedConn then
			playerAddedConn:Disconnect()
			playerAddedConn = nil
		end
		for _, plr in ipairs(Players:GetPlayers()) do
			disableBigHeads(plr)
		end
	end,
	["Force 3rd Person"] = disableForce3rdPerson,
	["Auto Jump"] = disableAutoJump,
	["Bloxbang Visuals"] = disableVisuals,
	["Outlines"] = disableEnemyOutlines,
}

local function enableFeature(index)
	local f = features[index]
	local handler = enableHandlers[f.name]
	if handler then handler() end
end

local function disableFeature(index)
	local f = features[index]
	local handler = disableHandlers[f.name]
	if handler then handler() end
end

updateFeatureLabel()

local hue = 0
local heartbeatConn

heartbeatConn = RunService.Heartbeat:Connect(function(dt)
	hue = (hue + dt * 0.5) % 1
	textLabel.TextColor3 = Color3.fromHSV(hue, 1, 1)
end)

local function fullCleanup()
	for i, f in ipairs(features) do
		if f.enabled then
			disableFeature(i)
		end
	end
	if heartbeatConn then
		heartbeatConn:Disconnect()
	end
	screenGui:Destroy()
end

cleanupEvent.Event:Connect(fullCleanup)

UserInputService.InputBegan:Connect(function(input, gameProcessed)
	if gameProcessed then return end

	if input.KeyCode == Enum.KeyCode.K then
		cycleLeft()

	elseif input.KeyCode == Enum.KeyCode.L then
		cycleRight()

	elseif input.KeyCode == Enum.KeyCode.P then
		local f = features[selectedIndex]
		f.enabled = not f.enabled
		if f.enabled then
			enableFeature(selectedIndex)
		else
			disableFeature(selectedIndex)
		end
		updateFeatureLabel()

	elseif input.KeyCode == Enum.KeyCode.F6 then
		toggleStealthMode()

	elseif input.KeyCode == Enum.KeyCode.F8 then
		fullCleanup()
	end
end)