Buchhin Nuke | Universal Server Nuke

--============================================================
-- KICH CLIENT-SIDE HORROR CHAOS
--============================================================

local Players = game:GetService("Players")
local Lighting = game:GetService("Lighting")
local SoundService = game:GetService("SoundService")
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")

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

--============================================================
-- CONFIG
--============================================================

local DECAL_ID = "rbxassetid://122665175794198"

local JUMPSCARE_IMAGES = {
	"rbxassetid://128380752547605",
	"rbxassetid://76089406750584",
	"rbxassetid://124063283044930"
}

local BACKGROUND_SOUND_ID = "rbxassetid://123143562570662"
local JUMPSCARE_SOUND_ID = "rbxassetid://6129291390"

local WORLD_TILT = 40

local SCREEN_AVATAR_COUNT = 10

local JUMPSCARE_VISIBLE = 5
local JUMPSCARE_HIDDEN = 10

local MESSAGE_VISIBLE = 3
local MESSAGE_HIDDEN = 5

local PARTICLE_INTERVAL = 1

local FIRE_MIN_SIZE = 2
local FIRE_MAX_SIZE = 12

local FIRE_INTERVAL_MIN = 0.25
local FIRE_INTERVAL_MAX = 1

--============================================================
-- CLEAN PREVIOUS VERSION
--============================================================

if _G.KichChaosCleanup then
	pcall(_G.KichChaosCleanup)
end

local Running = true

local Connections = {}
local Created = {}

local OriginalCFrames = {}
local OriginalLighting = {}

local function Track(object)
	table.insert(Created, object)
	return object
end

local function Connect(signal, callback)
	local connection = signal:Connect(callback)
	table.insert(Connections, connection)
	return connection
end

--============================================================
-- CLEANUP
--============================================================

_G.KichChaosCleanup = function()

	Running = false

	for _, connection in ipairs(Connections) do
		pcall(function()
			connection:Disconnect()
		end)
	end

	for _, object in ipairs(Created) do
		pcall(function()
			object:Destroy()
		end)
	end

	for part, cf in pairs(OriginalCFrames) do
		pcall(function()
			if part and part.Parent then
				part.CFrame = cf
			end
		end)
	end

	for property, value in pairs(OriginalLighting) do
		pcall(function()
			Lighting[property] = value
		end)
	end

	_G.KichChaosCleanup = nil
end

--============================================================
-- HELPER: IS PLAYER CHARACTER?
--============================================================

local function IsPlayerCharacter(object)

	if not object then
		return false
	end

	local model = object:FindFirstAncestorOfClass("Model")

	if not model then
		return false
	end

	if Players:GetPlayerFromCharacter(model) then
		return true
	end

	return false
end

--============================================================
-- GUI
--============================================================

local ScreenGui = Track(Instance.new("ScreenGui"))

ScreenGui.Name = "KichHorrorGUI"
ScreenGui.ResetOnSpawn = false
ScreenGui.IgnoreGuiInset = true
ScreenGui.DisplayOrder = 999999
ScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling

ScreenGui.Parent = PlayerGui

--============================================================
-- BACKGROUND SOUND
--============================================================

local BackgroundSound = Track(Instance.new("Sound"))

BackgroundSound.Name = "KichBackground"
BackgroundSound.SoundId = BACKGROUND_SOUND_ID
BackgroundSound.Volume = 1
BackgroundSound.Looped = true
BackgroundSound.Parent = SoundService

pcall(function()
	BackgroundSound:Play()
end)

--============================================================
-- JUMPSCARE SOUND
--============================================================

local function PlayJumpscareSound()

	if not Running then
		return
	end

	local sound = Track(Instance.new("Sound"))

	sound.Name = "KichJumpscareSound"
	sound.SoundId = JUMPSCARE_SOUND_ID
	sound.Volume = 2
	sound.Parent = SoundService

	pcall(function()
		sound:Play()
	end)

	task.delay(10, function()
		pcall(function()
			sound:Destroy()
		end)
	end)
end

--============================================================
-- FULL SCREEN JUMPSCARE
--============================================================

local CurrentJumpscare = nil

local function ShowJumpscare()

	if not Running then
		return
	end

	if CurrentJumpscare then
		pcall(function()
			CurrentJumpscare:Destroy()
		end)
	end

	local frame = Track(Instance.new("Frame"))

	frame.Name = "KichFullScreenJumpscare"

	frame.Size = UDim2.fromScale(1, 1)
	frame.Position = UDim2.fromScale(0, 0)

	frame.BackgroundColor3 = Color3.new(0, 0, 0)
	frame.BackgroundTransparency = 0

	frame.BorderSizePixel = 0

	frame.ZIndex = 1000000

	frame.Parent = ScreenGui

	CurrentJumpscare = frame

	local image = Instance.new("ImageLabel")

	image.Name = "JumpscareImage"

	image.Size = UDim2.fromScale(1, 1)
	image.Position = UDim2.fromScale(0, 0)

	image.BackgroundTransparency = 1
	image.BorderSizePixel = 0

	image.Image =
		JUMPSCARE_IMAGES[
			math.random(1, #JUMPSCARE_IMAGES)
		]

	image.ScaleType = Enum.ScaleType.Stretch
	image.ZIndex = 1000001

	image.Parent = frame

	-- White flash.
	local flash = Instance.new("Frame")

	flash.Size = UDim2.fromScale(1, 1)
	flash.Position = UDim2.fromScale(0, 0)

	flash.BackgroundColor3 = Color3.new(1, 1, 1)
	flash.BackgroundTransparency = 0

	flash.BorderSizePixel = 0

	flash.ZIndex = 1000002
	flash.Parent = frame

	TweenService:Create(
		flash,
		TweenInfo.new(0.12),
		{
			BackgroundTransparency = 1
		}
	):Play()

	task.delay(0.15, function()
		pcall(function()
			flash:Destroy()
		end)
	end)

	PlayJumpscareSound()

	task.delay(JUMPSCARE_VISIBLE, function()

		if CurrentJumpscare == frame then
			CurrentJumpscare = nil
		end

		pcall(function()
			frame:Destroy()
		end)

	end)
end

task.spawn(function()

	task.wait(1)

	while Running do

		ShowJumpscare()

		task.wait(JUMPSCARE_VISIBLE)

		if not Running then
			break
		end

		task.wait(JUMPSCARE_HIDDEN)

	end

end)

--============================================================
-- SCREEN AVATAR SPAM
--============================================================

local AvatarImage =
	"rbxthumb://type=AvatarHeadShot&id="
	.. tostring(LocalPlayer.UserId)
	.. "&w=420&h=420"

local function CreateScreenAvatar(index)

	local avatar = Track(Instance.new("ImageLabel"))

	avatar.Name = "KichAvatar_" .. index

	avatar.BackgroundTransparency = 1
	avatar.BorderSizePixel = 0

	avatar.Image = AvatarImage

	local size = math.random(45, 80)

	avatar.Size = UDim2.fromOffset(size, size)

	avatar.AnchorPoint =
		Vector2.new(0.5, 0.5)

	avatar.Position =
		UDim2.fromScale(
			math.random(5, 95) / 100,
			math.random(5, 95) / 100
		)

	avatar.Rotation = math.random(-45, 45)

	avatar.ImageTransparency =
		math.random(0, 30) / 100

	avatar.ZIndex = 500

	avatar.Parent = ScreenGui

	task.spawn(function()

		while Running and avatar.Parent do

			task.wait(
				math.random(8, 18) / 10
			)

			if not Running or not avatar.Parent then
				break
			end

			local tween = TweenService:Create(
				avatar,

				TweenInfo.new(
					math.random(8, 18) / 10,
					Enum.EasingStyle.Sine,
					Enum.EasingDirection.InOut
				),

				{
					Position =
						UDim2.fromScale(
							math.random(4, 96) / 100,
							math.random(4, 96) / 100
						),

					Rotation =
						math.random(-50, 50)
				}
			)

			tween:Play()

		end

	end)

end

for i = 1, SCREEN_AVATAR_COUNT do
	CreateScreenAvatar(i)
end

--============================================================
-- DECAL SPAM
--============================================================

local Faces = {
	Enum.NormalId.Front,
	Enum.NormalId.Back,
	Enum.NormalId.Left,
	Enum.NormalId.Right,
	Enum.NormalId.Top,
	Enum.NormalId.Bottom
}

local function AddDecals(part)

	if not Running then
		return
	end

	if not part:IsA("BasePart") then
		return
	end

	-- IMPORTANT:
	-- Never put the decal spam on players.
	if IsPlayerCharacter(part) then
		return
	end

	for _, face in ipairs(Faces) do

		local decal = Instance.new("Decal")

		decal.Name = "KichDecal"
		decal.Texture = DECAL_ID
		decal.Face = face
		decal.Transparency = 0

		decal.Parent = part

		Track(decal)

	end

end

for _, object in ipairs(workspace:GetDescendants()) do

	if not Running then
		break
	end

	if object:IsA("BasePart") then
		AddDecals(object)
	end

end

Connect(
	workspace.DescendantAdded,
	function(object)

		if not Running then
			return
		end

		if object:IsA("BasePart") then

			task.defer(function()

				if Running and object.Parent then
					AddDecals(object)
				end

			end)

		end

	end
)

--============================================================
-- WORLD TILT
--============================================================

-- Save original positions.
for _, object in ipairs(workspace:GetDescendants()) do

	if object:IsA("BasePart") then

		if not IsPlayerCharacter(object) then
			OriginalCFrames[object] =
				object.CFrame
		end

	end

end

-- Find a stable pivot.
local PivotPosition = Vector3.zero
local GotPivot = false

for _, object in ipairs(workspace:GetDescendants()) do

	if object:IsA("SpawnLocation") then

		PivotPosition = object.Position
		GotPivot = true

		break

	end

end

if not GotPivot then

	for part, cf in pairs(OriginalCFrames) do

		if part and part.Parent then

			PivotPosition = cf.Position
			GotPivot = true

			break

		end

	end

end

local Pivot =
	CFrame.new(PivotPosition)

local Rotation =
	CFrame.Angles(
		0,
		0,
		math.rad(WORLD_TILT)
	)

-- Apply identical rotation around the same pivot.
for part, originalCF in pairs(OriginalCFrames) do

	if Running and part and part.Parent then

		local relative =
			Pivot:ToObjectSpace(originalCF)

		part.CFrame =
			Pivot
			* Rotation
			* relative

	end

end

--============================================================
-- TRUE COLOR INVERSION
--============================================================
-- This follows the method used by the script you linked:
-- TWO ColorCorrectionEffects with Contrast = -1.
--
-- Roblox ColorCorrection supports Contrast, Saturation,
-- Brightness and TintColor, and Contrast = -1 produces
-- the negative-style effect.
--============================================================

local OldEffects = {}

-- Don't leave old Kich effects from previous executions.
for _, object in ipairs(Lighting:GetChildren()) do

	if object.Name == "KichInvert1"
		or object.Name == "KichInvert2"
		or object.Name == "KichDarkGrade" then

		pcall(function()
			object:Destroy()
		end)

	end

end

local Invert1 =
	Track(
		Instance.new("ColorCorrectionEffect")
	)

Invert1.Name = "KichInvert1"

Invert1.Brightness = 0
Invert1.Contrast = -1
Invert1.Saturation = 0
Invert1.TintColor = Color3.new(1, 1, 1)

Invert1.Parent = Lighting

local Invert2 =
	Track(
		Instance.new("ColorCorrectionEffect")
	)

Invert2.Name = "KichInvert2"

Invert2.Brightness = 0
Invert2.Contrast = -1
Invert2.Saturation = 0
Invert2.TintColor = Color3.new(1, 1, 1)

Invert2.Parent = Lighting

--============================================================
-- KEEP THE WORLD VISIBLE
--============================================================

OriginalLighting.Brightness =
	Lighting.Brightness

OriginalLighting.ExposureCompensation =
	Lighting.ExposureCompensation

OriginalLighting.Ambient =
	Lighting.Ambient

OriginalLighting.OutdoorAmbient =
	Lighting.OutdoorAmbient

OriginalLighting.FogColor =
	Lighting.FogColor

OriginalLighting.FogStart =
	Lighting.FogStart

OriginalLighting.FogEnd =
	Lighting.FogEnd

-- Don't crush the scene to black.
Lighting.Brightness = 1.5
Lighting.ExposureCompensation = 0

Lighting.Ambient =
	Color3.fromRGB(80, 80, 80)

Lighting.OutdoorAmbient =
	Color3.fromRGB(65, 65, 65)

Lighting.FogStart = 200
Lighting.FogEnd = 1200

--============================================================
-- KICH AVATAR PARTICLES ON PLAYERS
--============================================================

local function CreatePlayerParticle(player)

	if not Running then
		return
	end

	if not player.Character then
		return
	end

	local character = player.Character

	local root =
		character:FindFirstChild("HumanoidRootPart")

	if not root then
		return
	end

	local attachment = Instance.new("Attachment")

	attachment.Name =
		"KichAvatarParticleAttachment"

	attachment.Position =
		Vector3.new(
			math.random(-2, 2),
			math.random(0, 3),
			math.random(-2, 2)
		)

	attachment.Parent = root

	Track(attachment)

	-- Use the avatar image as the particle texture.
	local emitter =
		Instance.new("ParticleEmitter")

	emitter.Name =
		"KichAvatarParticles"

	emitter.Texture = AvatarImage

	emitter.Rate = 0

	emitter.Lifetime =
		NumberRange.new(2, 4)

	emitter.Speed =
		NumberRange.new(1, 4)

	emitter.Rotation =
		NumberRange.new(-180, 180)

	emitter.RotSpeed =
		NumberRange.new(-90, 90)

	emitter.SpreadAngle =
		Vector2.new(360, 360)

	emitter.LightEmission = 0.2

	emitter.Size =
		NumberSequence.new({
			NumberSequenceKeypoint.new(
				0,
				0.6
			),

			NumberSequenceKeypoint.new(
				0.5,
				0.9
			),

			NumberSequenceKeypoint.new(
				1,
				0
			)
		})

	emitter.Transparency =
		NumberSequence.new({
			NumberSequenceKeypoint.new(
				0,
				0.1
			),

			NumberSequenceKeypoint.new(
				0.7,
				0.3
			),

			NumberSequenceKeypoint.new(
				1,
				1
			)
		})

	emitter.Parent = attachment

	Track(emitter)

	-- One avatar particle every second.
	task.spawn(function()

		while Running
			and player.Parent
			and character.Parent
			and root.Parent do

			emitter:Emit(1)

			task.wait(PARTICLE_INTERVAL)

		end

	end)

end

local function SetupPlayer(player)

	task.spawn(function()

		local character =
			player.Character
			or player.CharacterAdded:Wait()

		if Running then
			task.wait(0.5)
			CreatePlayerParticle(player)
		end

	end)

	Connect(
		player.CharacterAdded,
		function(character)

			task.wait(0.5)

			if Running then
				CreatePlayerParticle(player)
			end

		end
	)

end

for _, player in ipairs(Players:GetPlayers()) do
	SetupPlayer(player)
end

Connect(
	Players.PlayerAdded,
	function(player)

		if Running then
			SetupPlayer(player)
		end

	end
)

--============================================================
-- RANDOM FIRE ON WORLD PARTS
--============================================================

local FireColors = {
	Color3.fromRGB(255, 70, 20),
	Color3.fromRGB(255, 120, 10),
	Color3.fromRGB(255, 210, 30),
	Color3.fromRGB(40, 120, 255),
	Color3.fromRGB(70, 220, 255),
	Color3.fromRGB(180, 30, 255),
	Color3.fromRGB(255, 30, 120),
	Color3.fromRGB(255, 255, 255)
}

local function FindRandomWorldPart()

	local candidates = {}

	for _, object in ipairs(workspace:GetDescendants()) do

		if object:IsA("BasePart")
			and not IsPlayerCharacter(object)
			and object.Transparency < 1
			and object.Size.Magnitude > 1 then

			table.insert(candidates, object)

		end

	end

	if #candidates == 0 then
		return nil
	end

	return candidates[
		math.random(1, #candidates)
	]

end

local function PutFireOnPart(part)

	if not Running or not part then
		return
	end

	if IsPlayerCharacter(part) then
		return
	end

	local fire = Instance.new("Fire")

	fire.Name = "KichRandomFire"

	fire.Size =
		math.random(
			FIRE_MIN_SIZE,
			FIRE_MAX_SIZE
		)

	fire.Heat =
		math.random(5, 25)

	fire.Color =
		FireColors[
			math.random(
				1,
				#FireColors
			)
		]

	fire.SecondaryColor =
		FireColors[
			math.random(
				1,
				#FireColors
			)
		]

	fire.Parent = part

	Track(fire)

	-- Random duration.
	task.delay(
		math.random(3, 10),
		function()

			pcall(function()
				fire:Destroy()
			end)

		end
	)

end

task.spawn(function()

	while Running do

		task.wait(
			math.random(
				FIRE_INTERVAL_MIN * 100,
				FIRE_INTERVAL_MAX * 100
			) / 100
		)

		if not Running then
			break
		end

		local part =
			FindRandomWorldPart()

		if part then
			PutFireOnPart(part)
		end

	end

end)

--============================================================
-- HINTS
--============================================================

local HintMessages = {
	"KICH IS WATCHING.",
	"KICH KNOWS YOU ARE HERE.",
	"DO NOT TURN AROUND.",
	"KICH REMEMBERS YOU.",
	"YOU ARE NOT ALONE.",
	"HE CAN SEE YOU.",
	"KICH HAS FOUND YOU.",
	"WHY ARE YOU STILL HERE?",
	"DO NOT TRUST THIS WORLD.",
	"KICH.",
	"HE IS GETTING CLOSER.",
	"YOU SHOULD LEAVE."
}

task.spawn(function()

	local index = 1

	while Running do

		local hint =
			Track(
				Instance.new("Hint")
			)

		hint.Name = "KichHint"
		hint.Text =
			HintMessages[index]

		hint.Parent = workspace

		index += 1

		if index > #HintMessages then
			index = 1
		end

		task.wait(3)

		pcall(function()
			hint:Destroy()
		end)

		task.wait(0.2)

	end

end)

--============================================================
-- CENTER MESSAGES
--============================================================

local CenterMessages = {
	"KICH HAS ENTERED THE WORLD.",
	"DO NOT TRUST WHAT YOU SEE.",
	"HE IS WATCHING.",
	"YOU CANNOT ESCAPE.",
	"TURN AROUND.",
	"THIS WORLD IS NOT YOURS.",
	"KICH KNOWS YOU ARE HERE.",
	"RUN.",
	"IT IS TOO LATE.",
	"HE NEVER LEFT."
}

task.spawn(function()

	local index = 1

	while Running do

		local message =
			Track(
				Instance.new("Message")
			)

		message.Name =
			"KichCenterMessage"

		message.Text =
			CenterMessages[index]

		message.Parent = workspace

		index += 1

		if index > #CenterMessages then
			index = 1
		end

		task.wait(MESSAGE_VISIBLE)

		pcall(function()
			message:Destroy()
		end)

		task.wait(MESSAGE_HIDDEN)

	end

end)

--============================================================
-- SCREEN GLITCH
--============================================================

task.spawn(function()

	while Running do

		task.wait(
			math.random(4, 9)
		)

		if not Running then
			break
		end

		if CurrentJumpscare then
			continue
		end

		local glitch =
			Track(
				Instance.new("Frame")
			)

		glitch.Name =
			"KichGlitch"

		glitch.BorderSizePixel = 0

		glitch.BackgroundColor3 =
			Color3.fromRGB(
				math.random(50, 120),
				math.random(100, 220),
				math.random(160, 255)
			)

		glitch.BackgroundTransparency =
			math.random(70, 90) / 100

		glitch.Size =
			UDim2.fromScale(
				math.random(20, 100) / 100,
				math.random(1, 5) / 100
			)

		glitch.Position =
			UDim2.fromScale(
				math.random(0, 100) / 100,
				math.random(0, 100) / 100
			)

		glitch.ZIndex = 999998

		glitch.Parent = ScreenGui

		task.delay(
			math.random(5, 20) / 100,
			function()

				pcall(function()
					glitch:Destroy()
				end)

			end
		)

	end

end)

--============================================================
-- CLEAN PLAYER DECALS IF SOMETHING ADDED THEM
--============================================================

Connect(
	RunService.Heartbeat,
	function()

		if not Running then
			return
		end

		-- Only occasionally check to avoid unnecessary work.
		if math.random(1, 120) ~= 1 then
			return
		end

		for _, player in ipairs(Players:GetPlayers()) do

			local character = player.Character

			if character then

				for _, object in ipairs(character:GetDescendants()) do

					if object:IsA("Decal")
						and object.Name == "KichDecal" then

						pcall(function()
							object:Destroy()
						end)

					end

				end

			end

		end

	end
)

--============================================================
-- STARTUP
--============================================================

task.wait(0.5)

if Running then
	ShowJumpscare()
end

print("================================================")
print("              KICH HORROR CHAOS")
print("================================================")
print("DECALS                  : ON")
print("PLAYER DECALS           : OFF")
print("FULLSCREEN JUMPSCARE    : 5s ON / 10s OFF")
print("JUMPSCARE SOUND         : ON")
print("BACKGROUND SOUND        : LOOP")
print("SCREEN AVATARS          : 10")
print("PLAYER AVATAR PARTICLES : 1 / SECOND")
print("RANDOM FIRE             : ON")
print("RANDOM FIRE COLORS      : ON")
print("HINTS                   : ON")
print("CENTER MESSAGES         : ON")
print("WORLD TILT              : 40 DEGREES LEFT")
print("COLOR INVERSION         : TRUE NEGATIVE")
print("================================================")