--// ☠ ULTIMATE KILL FX  (LocalScript)
--// Put in: StarterPlayer > StarterPlayerScripts   (or run it in your executor)
--// Tap the floating ☠ button (drag it anywhere) or press K to open the menu.

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

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

local player = Players.LocalPlayer
local R = math.random
local ONE, UP = Vector3.one, Vector3.new(0, 1, 0)

local state = {
	selected = "Nuke",
	mode = 2, -- 1 = my kills (smart), 2 = nearby, 3 = everywhere
	sound = true,
	kills = 0,
}
local MODES = { "My kills", "Nearby", "Everywhere" }
local RANGE = 200

local conns, gui = {}, nil
local function bind(sig, fn)
	local c = sig:Connect(fn)
	table.insert(conns, c)
	return c
end
_G.__KillFXCleanup = function()
	for _, c in ipairs(conns) do pcall(function() c:Disconnect() end) end
	if gui then gui:Destroy() end
end

local function cam() return workspace.CurrentCamera end

------------------------------------------------------------------
-- HELPERS
------------------------------------------------------------------
local function tween(obj, t, props, style, dir)
	local tw = TweenService:Create(obj, TweenInfo.new(t, style or Enum.EasingStyle.Quad, dir or Enum.EasingDirection.Out), props)
	tw:Play()
	return tw
end

local function fxPart(shape, size, color, cf, transparency, material, life)
	local p = Instance.new("Part")
	p.Anchored, p.CanCollide, p.CanQuery, p.CanTouch, p.CastShadow = true, false, false, false, false
	p.Shape = shape
	p.Size = size
	p.Color = color
	p.Material = material or Enum.Material.Neon
	p.Transparency = transparency or 0
	p.CFrame = cf
	p.Parent = workspace
	Debris:AddItem(p, life or 8)
	return p
end

local TEX_SPARK = "rbxasset://textures/particles/sparkles_main.dng"
local TEX_FIRE = "rbxasset://textures/particles/fire_main.dds"
local TEX_SMOKE = "rbxasset://textures/particles/smoke_main.dds"

local function burst(pos, cfg, count)
	local holder = fxPart(Enum.PartType.Ball, ONE, Color3.new(), CFrame.new(pos), 1)
	local e = Instance.new("ParticleEmitter")
	e.Rate = 0
	e.Texture = cfg.Texture or TEX_SPARK
	e.Color = cfg.Color or ColorSequence.new(Color3.new(1, 1, 1))
	e.Size = cfg.Size or NumberSequence.new({ NumberSequenceKeypoint.new(0, 1), NumberSequenceKeypoint.new(1, 0) })
	e.Lifetime = cfg.Lifetime or NumberRange.new(0.6, 1.2)
	e.Speed = cfg.Speed or NumberRange.new(20, 40)
	e.SpreadAngle = Vector2.new(180, 180)
	e.LightEmission = cfg.LightEmission or 1
	e.Drag = cfg.Drag or 3
	e.Acceleration = cfg.Acceleration or Vector3.zero
	e.RotSpeed = NumberRange.new(-180, 180)
	e.Rotation = NumberRange.new(0, 360)
	e.Transparency = NumberSequence.new({ NumberSequenceKeypoint.new(0, 0), NumberSequenceKeypoint.new(0.7, 0.3), NumberSequenceKeypoint.new(1, 1) })
	e.Parent = holder
	e:Emit(count)
	return holder
end

local function shards(pos, color, count, material, speed, size)
	for _ = 1, count do
		local s = fxPart(
			Enum.PartType.Block,
			ONE * (size or 0.3) * (0.6 + R() * 1.4),
			color,
			CFrame.new(pos) * CFrame.Angles(R() * 6, R() * 6, R() * 6),
			0,
			material
		)
		local dir = Vector3.new(R() - 0.5, R() * 0.8 + 0.2, R() - 0.5).Unit
		tween(s, 0.8 + R() * 0.5, {
			Position = pos + dir * speed * (0.5 + R()) - Vector3.new(0, 5, 0),
			Orientation = Vector3.new(R(0, 360), R(0, 360), R(0, 360)),
			Transparency = 1,
		})
	end
end

local function light(pos, color, brightness, range, t)
	local p = fxPart(Enum.PartType.Ball, ONE * 0.5, color, CFrame.new(pos), 1)
	local l = Instance.new("PointLight")
	l.Color, l.Brightness, l.Range = color, brightness, range
	l.Parent = p
	tween(l, t, { Brightness = 0, Range = 0 })
end

local function ring(pos, color, endSize, t, startTransparency)
	local r = fxPart(Enum.PartType.Cylinder, Vector3.new(0.5, 2, 2), color, CFrame.new(pos) * CFrame.Angles(0, 0, math.pi / 2), startTransparency or 0.15)
	tween(r, t, { Size = Vector3.new(0.3, endSize, endSize), Transparency = 1 })
end

local function flash(color, t, strength)
	strength = strength or 0.4
	local cc = Instance.new("ColorCorrectionEffect")
	cc.Brightness, cc.Contrast, cc.TintColor = strength, strength * 0.5, color
	cc.Parent = Lighting
	tween(cc, t, { Brightness = 0, Contrast = 0, TintColor = Color3.new(1, 1, 1) })
	local bl = Instance.new("BloomEffect")
	bl.Intensity, bl.Size, bl.Threshold = strength * 4, 40, 0.8
	bl.Parent = Lighting
	tween(bl, t * 1.5, { Intensity = 0 })
	Debris:AddItem(cc, t + 0.3)
	Debris:AddItem(bl, t * 1.5 + 0.3)
end

local function shake(power, duration)
	task.spawn(function()
		local t0 = os.clock()
		while os.clock() - t0 < duration do
			local char = player.Character
			local hum = char and char:FindFirstChildOfClass("Humanoid")
			if hum then
				local k = 1 - (os.clock() - t0) / duration
				hum.CameraOffset = Vector3.new((R() - 0.5) * power * k, (R() - 0.5) * power * k, 0)
			end
			RunService.RenderStepped:Wait()
		end
		local char = player.Character
		local hum = char and char:FindFirstChildOfClass("Humanoid")
		if hum then hum.CameraOffset = Vector3.zero end
	end)
end

local punching, baseFov = 0, 70
local function punch(amount, t)
	local c = cam()
	if not c then return end
	if punching == 0 then baseFov = c.FieldOfView end
	punching += 1
	c.FieldOfView = baseFov + amount
	local tw = tween(c, t, { FieldOfView = baseFov }, Enum.EasingStyle.Quart)
	tw.Completed:Connect(function() punching -= 1 end)
end

local function sfx(id, vol, pitch)
	if not state.sound then return end
	local s = Instance.new("Sound")
	s.SoundId, s.Volume, s.PlaybackSpeed = id, vol or 1, pitch or 1
	s.Parent = SoundService
	s:Play()
	Debris:AddItem(s, 6)
end
local SND_BOOM = "rbxasset://sounds/impact_explosion_03.mp3"
local SND_BASS = "rbxasset://sounds/bass.mp3"
local SND_PING = "rbxasset://sounds/electronicpingshort.wav"
local SND_SNAP = "rbxasset://sounds/snap.mp3"

local function bodyParts(char)
	local list = {}
	if char then
		for _, d in ipairs(char:GetDescendants()) do
			if d:IsA("BasePart") then table.insert(list, d) end
		end
	end
	return list
end

local function hide(char)
	if not char then return end
	for _, d in ipairs(char:GetDescendants()) do
		if d:IsA("BasePart") or d:IsA("Decal") or d:IsA("Texture") then
			d.Transparency = 1
		end
	end
end

local function freezeParts(char)
	for _, p in ipairs(bodyParts(char)) do
		p.Anchored = true
		p.CanCollide = false
	end
end

local function launchParts(char, pos, force, dur, spin)
	for _, p in ipairs(bodyParts(char)) do
		p.Anchored, p.CanCollide = true, false
		local away = p.Position - pos
		away = (away.Magnitude < 0.1) and UP or away.Unit
		away = (away + Vector3.new((R() - 0.5) * 0.6, 0.7, (R() - 0.5) * 0.6)).Unit
		tween(p, dur, {
			CFrame = p.CFrame * CFrame.Angles(R() * spin, R() * spin, R() * spin) + away * force * (0.6 + R() * 0.8),
			Transparency = 1,
		})
	end
end

local function popup(pos, text, color, size)
	local a = fxPart(Enum.PartType.Ball, ONE * 0.2, color, CFrame.new(pos + Vector3.new(0, 4, 0)), 1, nil, 3)
	local bb = Instance.new("BillboardGui")
	bb.Size, bb.AlwaysOnTop, bb.Adornee = UDim2.fromOffset(300, 60), true, a
	bb.Parent = a
	local l = Instance.new("TextLabel")
	l.Size, l.BackgroundTransparency = UDim2.fromScale(1, 1), 1
	l.Text, l.Font, l.TextSize, l.TextColor3 = text, Enum.Font.GothamBlack, size or 26, color
	l.Parent = bb
	local st = Instance.new("UIStroke")
	st.Thickness, st.Color = 2, Color3.new(0, 0, 0)
	st.Parent = l
	tween(a, 1.8, { Position = a.Position + Vector3.new(0, 6, 0) })
	task.delay(0.9, function()
		tween(l, 0.9, { TextTransparency = 1 })
		tween(st, 0.9, { Transparency = 1 })
	end)
end

------------------------------------------------------------------
-- EFFECTS
------------------------------------------------------------------
local EFFECTS = {}
local function add(name, color, fn)
	table.insert(EFFECTS, { name = name, color = color, fn = fn })
end

-- 1. NUKE ---------------------------------------------------------
add("Nuke", Color3.fromRGB(255, 130, 30), function(char, pos)
	local orange, yellow = Color3.fromRGB(255, 120, 20), Color3.fromRGB(255, 220, 90)
	sfx(SND_BOOM, 1.6, 0.9)
	flash(Color3.fromRGB(255, 230, 190), 0.7, 0.7)
	punch(28, 0.7)
	shake(3, 1)
	light(pos, orange, 10, 70, 1.2)

	local core = fxPart(Enum.PartType.Ball, ONE * 2, Color3.new(1, 1, 1), CFrame.new(pos), 0)
	tween(core, 0.35, { Size = ONE * 14, Transparency = 1 })
	local fire = fxPart(Enum.PartType.Ball, ONE * 2, orange, CFrame.new(pos), 0.1)
	tween(fire, 0.6, { Size = ONE * 26, Transparency = 1 })

	for i = 1, 3 do
		task.delay((i - 1) * 0.12, function()
			ring(pos, i == 1 and yellow or orange, 30 + i * 16, 0.7)
		end)
	end

	-- mushroom cloud
	local stem = fxPart(Enum.PartType.Cylinder, Vector3.new(1, 3, 3), orange, CFrame.new(pos) * CFrame.Angles(0, 0, math.pi / 2), 0.2)
	tween(stem, 0.7, { Size = Vector3.new(16, 5, 5), CFrame = CFrame.new(pos + UP * 8) * CFrame.Angles(0, 0, math.pi / 2) })
	local disc = fxPart(Enum.PartType.Cylinder, Vector3.new(1, 4, 4), yellow, CFrame.new(pos) * CFrame.Angles(0, 0, math.pi / 2), 0.2)
	tween(disc, 0.8, { Size = Vector3.new(3, 26, 26), CFrame = CFrame.new(pos + UP * 17) * CFrame.Angles(0, 0, math.pi / 2) })
	local capBall = fxPart(Enum.PartType.Ball, ONE * 2, orange, CFrame.new(pos), 0.2)
	tween(capBall, 0.8, { Size = ONE * 15, Position = pos + UP * 18 })
	task.delay(1, function()
		tween(stem, 0.9, { Transparency = 1 })
		tween(disc, 0.9, { Transparency = 1 })
		tween(capBall, 0.9, { Transparency = 1 })
	end)

	burst(pos, { Color = ColorSequence.new(yellow, orange), Speed = NumberRange.new(30, 70), Texture = TEX_FIRE, Size = NumberSequence.new({ NumberSequenceKeypoint.new(0, 4), NumberSequenceKeypoint.new(1, 0) }), Lifetime = NumberRange.new(0.8, 1.5), Acceleration = Vector3.new(0, 15, 0) }, 40)
	burst(pos, { Color = ColorSequence.new(Color3.fromRGB(70, 70, 70)), Texture = TEX_SMOKE, LightEmission = 0, Speed = NumberRange.new(10, 30), Lifetime = NumberRange.new(1.5, 2.5), Size = NumberSequence.new({ NumberSequenceKeypoint.new(0, 5), NumberSequenceKeypoint.new(1, 12) }), Acceleration = Vector3.new(0, 10, 0) }, 25)
	burst(pos, { Color = ColorSequence.new(yellow), Speed = NumberRange.new(40, 90) }, 60)
	shards(pos, orange, 30, Enum.Material.Neon, 34, 0.5)
	launchParts(char, pos, 40, 1.1, 12)
end)

-- 2. THUNDER GOD ---------------------------------------------------
local function bolt(a, b, thick, color, tr, depth)
	local segs = 10
	local prev = a
	local dir = b - a
	for i = 1, segs do
		local target
		if i == segs then
			target = b
		else
			target = a + dir * (i / segs) + Vector3.new((R() - 0.5) * 9, (R() - 0.5) * 3, (R() - 0.5) * 9)
		end
		local dist = (target - prev).Magnitude
		if dist > 0.05 then
			local seg = fxPart(Enum.PartType.Block, Vector3.new(thick, thick, dist), color, CFrame.lookAt(prev, target) * CFrame.new(0, 0, -dist / 2), tr)
			tween(seg, 0.45, { Transparency = 1, Size = Vector3.new(thick * 0.2, thick * 0.2, dist) })
			if depth < 2 and i > 2 and i < segs - 1 and R() < 0.35 then
				bolt(target, target + Vector3.new((R() - 0.5) * 30, -(6 + R() * 14), (R() - 0.5) * 30), thick * 0.55, color, tr, depth + 1)
			end
		end
		prev = target
	end
end

add("Thunder God", Color3.fromRGB(120, 190, 255), function(char, pos)
	local blue, white = Color3.fromRGB(90, 170, 255), Color3.fromRGB(235, 248, 255)
	freezeParts(char)
	for strike = 1, 3 do
		local top = pos + Vector3.new((R() - 0.5) * 10, 90, (R() - 0.5) * 10)
		bolt(top, pos, 3, blue, 0.6, 0)
		bolt(top, pos, 1.1, white, 0, 0)
		sfx(strike == 1 and SND_BASS or SND_PING, 1.2, 0.6 + strike * 0.2)
		flash(Color3.fromRGB(190, 225, 255), 0.4, 0.6)
		shake(1.8, 0.4)
		punch(10, 0.3)
		light(pos, blue, 8, 50, 0.5)
		burst(pos, { Color = ColorSequence.new(white, blue), Speed = NumberRange.new(20, 50) }, 30)
		for _ = 1, 6 do
			for _, p in ipairs(bodyParts(char)) do
				p.Material = Enum.Material.Neon
				p.Color = (R() < 0.5) and white or blue
			end
			task.wait(0.04)
		end
		task.wait(0.08)
	end
	for _, p in ipairs(bodyParts(char)) do
		p.Material = Enum.Material.SmoothPlastic
		p.Color = Color3.fromRGB(20, 20, 20)
	end
	ring(pos, white, 40, 0.6)
	ring(pos, blue, 28, 0.5)
	burst(pos, { Color = ColorSequence.new(white, blue), Speed = NumberRange.new(40, 90) }, 70)
	launchParts(char, pos, 22, 1, 10)
end)

-- 3. SHATTER (ICE) -------------------------------------------------
add("Shatter", Color3.fromRGB(150, 220, 255), function(char, pos)
	local ice, deep = Color3.fromRGB(170, 225, 255), Color3.fromRGB(90, 170, 240)
	freezeParts(char)
	for _, p in ipairs(bodyParts(char)) do
		p.Material = Enum.Material.Ice
		p.Color = ice
	end
	sfx(SND_SNAP, 1, 0.7)
	flash(Color3.fromRGB(190, 230, 255), 0.35, 0.25)
	burst(pos, { Color = ColorSequence.new(Color3.new(1, 1, 1), ice), Speed = NumberRange.new(4, 14), Lifetime = NumberRange.new(1, 1.8) }, 40)

	local spikes = {}
	for i = 1, 10 do
		local ang = i / 10 * math.pi * 2 + R() * 0.5
		local r = 2 + R() * 3.5
		local base = pos + Vector3.new(math.cos(ang) * r, -2.8, math.sin(ang) * r)
		local h = 4 + R() * 7
		local sp = fxPart(Enum.PartType.Block, Vector3.new(0.9, 0.2, 0.9), (R() < 0.5) and ice or deep, CFrame.new(base) * CFrame.Angles((R() - 0.5) * 0.6, R() * 6, (R() - 0.5) * 0.6), 0.1, Enum.Material.Glass)
		tween(sp, 0.35 + R() * 0.2, { Size = Vector3.new(0.9, h, 0.9), CFrame = sp.CFrame * CFrame.new(0, h / 2, 0) })
		table.insert(spikes, sp)
	end
	task.wait(1)

	sfx(SND_BOOM, 0.9, 1.6)
	hide(char)
	for _, sp in ipairs(spikes) do tween(sp, 0.5, { Transparency = 1 }) end
	shards(pos, ice, 55, Enum.Material.Ice, 30, 0.45)
	shards(pos, Color3.new(1, 1, 1), 25, Enum.Material.Glass, 20, 0.3)
	ring(pos, ice, 40, 0.6)
	ring(pos + Vector3.new(0, -2.5, 0), deep, 30, 0.5)
	burst(pos, { Color = ColorSequence.new(Color3.new(1, 1, 1)), Speed = NumberRange.new(20, 50), Acceleration = Vector3.new(0, -12, 0), Lifetime = NumberRange.new(1.2, 2) }, 60)
	light(pos, ice, 6, 40, 0.8)
	flash(Color3.fromRGB(200, 240, 255), 0.4, 0.4)
	punch(14, 0.4)
	shake(2, 0.4)
end)

-- 4. THANOS DUST ---------------------------------------------------
add("Dust", Color3.fromRGB(190, 190, 190), function(char, pos)
	local parts = bodyParts(char)
	freezeParts(char)
	sfx(SND_BASS, 0.7, 0.5)
	local wind = Vector3.new(26, 5, R() * 8 - 4)
	for _, p in ipairs(parts) do
		if p.Transparency < 1 then
			local vol = p.Size.X * p.Size.Y * p.Size.Z
			local n = math.clamp(math.floor(vol * 1.4), 4, 16)
			local col = p.Color
			for _ = 1, n do
				local off = Vector3.new((R() - 0.5) * p.Size.X, (R() - 0.5) * p.Size.Y, (R() - 0.5) * p.Size.Z)
				local at = p.CFrame:PointToWorldSpace(off)
				local c = fxPart(Enum.PartType.Block, ONE * (0.25 + R() * 0.35), col, CFrame.new(at) * CFrame.Angles(R() * 6, R() * 6, R() * 6), 0, Enum.Material.SmoothPlastic, 6)
				local height = math.clamp((at.Y - pos.Y + 3) / 7, 0, 1)
				local delay = (1 - height) * 0.9 + R() * 0.25
				task.delay(delay, function()
					tween(c, 1.4 + R() * 0.8, {
						Position = at + wind * (0.6 + R() * 0.8) + Vector3.new(0, R() * 5, (R() - 0.5) * 10),
						Orientation = Vector3.new(R(0, 360), R(0, 360), R(0, 360)),
						Size = ONE * 0.05,
						Transparency = 1,
						Color = Color3.fromRGB(60, 60, 60),
					}, Enum.EasingStyle.Sine, Enum.EasingDirection.In)
					if R() < 0.2 then
						burst(at, { Color = ColorSequence.new(Color3.fromRGB(110, 110, 110)), Texture = TEX_SMOKE, LightEmission = 0, Speed = NumberRange.new(2, 8), Lifetime = NumberRange.new(1, 1.6), Acceleration = wind * 0.4, Size = NumberSequence.new({ NumberSequenceKeypoint.new(0, 1.4), NumberSequenceKeypoint.new(1, 3) }) }, 1)
					end
				end)
			end
		end
	end
	hide(char)
	burst(pos, { Color = ColorSequence.new(Color3.fromRGB(230, 230, 230)), Speed = NumberRange.new(3, 10), Lifetime = NumberRange.new(1.5, 2.5), Acceleration = wind * 0.5 }, 30)
	flash(Color3.fromRGB(230, 230, 230), 0.5, 0.15)
end)

-- 5. BLACK HOLE ----------------------------------------------------
add("Black Hole", Color3.fromRGB(160, 70, 255), function(char, pos)
	local purple, orange = Color3.fromRGB(160, 70, 255), Color3.fromRGB(255, 140, 40)
	local center = pos + UP
	sfx(SND_BASS, 1.3, 0.4)
	flash(Color3.fromRGB(170, 110, 255), 0.5, 0.2)
	local halo = fxPart(Enum.PartType.Ball, ONE, purple, CFrame.new(center), 0.5)
	local hole = fxPart(Enum.PartType.Ball, ONE, Color3.new(0, 0, 0), CFrame.new(center), 0, Enum.Material.SmoothPlastic)
	local disc = fxPart(Enum.PartType.Cylinder, Vector3.new(0.3, 1, 1), orange, CFrame.new(center) * CFrame.Angles(0.35, 0, math.pi / 2), 0.35)
	tween(halo, 0.5, { Size = ONE * 11 })
	tween(hole, 0.5, { Size = ONE * 7 })
	tween(disc, 0.5, { Size = Vector3.new(0.3, 20, 20) })
	light(center, purple, 6, 45, 1.6)

	for _, p in ipairs(bodyParts(char)) do
		p.Anchored, p.CanCollide = true, false
		tween(p, 1.1, {
			CFrame = CFrame.new(center) * CFrame.Angles(R() * 6, R() * 6, R() * 6),
			Size = p.Size * 0.1,
		}, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
	end

	local orbs = {}
	for i = 1, 30 do
		orbs[i] = {
			part = fxPart(Enum.PartType.Block, ONE * (0.3 + R() * 0.5), (R() < 0.5) and purple or orange, CFrame.new(center), 0),
			a = R() * 6.28, r = 8 + R() * 10, y = (R() - 0.5) * 6, s = 3 + R() * 3,
		}
	end
	local T, t0 = 1.1, os.clock()
	while os.clock() - t0 < T do
		local a = (os.clock() - t0) / T
		for _, o in ipairs(orbs) do
			local ang = o.a + a * o.s * 3
			local rr = o.r * (1 - a) ^ 1.5
			o.part.Position = center + Vector3.new(math.cos(ang) * rr, o.y * (1 - a), math.sin(ang) * rr)
		end
		RunService.Heartbeat:Wait()
	end
	for _, o in ipairs(orbs) do o.part:Destroy() end

	hide(char)
	tween(halo, 0.25, { Size = ONE, Transparency = 1 }, Enum.EasingStyle.Back, Enum.EasingDirection.In)
	tween(hole, 0.25, { Size = ONE * 0.5 }, Enum.EasingStyle.Back, Enum.EasingDirection.In)
	tween(disc, 0.25, { Size = Vector3.new(0.3, 1, 1), Transparency = 1 })
	task.wait(0.28)
	sfx(SND_BOOM, 1.4, 0.7)
	ring(center, purple, 50, 0.7)
	ring(center, orange, 34, 0.55)
	burst(center, { Color = ColorSequence.new(Color3.new(1, 1, 1), purple), Speed = NumberRange.new(40, 90) }, 90)
	shards(center, purple, 25, Enum.Material.Neon, 30, 0.4)
	flash(Color3.fromRGB(210, 170, 255), 0.5, 0.5)
	punch(24, 0.6)
	shake(3, 0.6)
end)

-- 6. SOUL REAPER ---------------------------------------------------
add("Soul Reaper", Color3.fromRGB(110, 255, 235), function(char, pos)
	local cyan, white = Color3.fromRGB(110, 255, 235), Color3.new(1, 1, 1)
	sfx(SND_PING, 1, 0.5)
	for _, p in ipairs(bodyParts(char)) do
		p.Anchored, p.CanCollide = true, false
		tween(p, 0.9, { Color = white, Transparency = 1, Position = p.Position + Vector3.new(0, 3, 0) })
	end
	burst(pos, { Color = ColorSequence.new(white, cyan), Speed = NumberRange.new(8, 22), Acceleration = Vector3.new(0, 18, 0), Lifetime = NumberRange.new(1, 1.8) }, 50)
	ring(pos - UP * 2.5, cyan, 26, 0.7)

	local soul = fxPart(Enum.PartType.Ball, ONE * 2.4, white, CFrame.new(pos + UP), 0.1)
	local pl = Instance.new("PointLight")
	pl.Color, pl.Brightness, pl.Range = cyan, 4, 26
	pl.Parent = soul
	local em = Instance.new("ParticleEmitter")
	em.Texture, em.Rate = TEX_SPARK, 90
	em.Color = ColorSequence.new(white, cyan)
	em.Size = NumberSequence.new({ NumberSequenceKeypoint.new(0, 1.4), NumberSequenceKeypoint.new(1, 0) })
	em.Lifetime, em.Speed = NumberRange.new(0.7, 1.2), NumberRange.new(2, 6)
	em.SpreadAngle, em.LightEmission = Vector2.new(180, 180), 1
	em.Acceleration = Vector3.new(0, 5, 0)
	em.Transparency = NumberSequence.new({ NumberSequenceKeypoint.new(0, 0.1), NumberSequenceKeypoint.new(1, 1) })
	em.Parent = soul

	local trail = {}
	for i = 1, 7 do
		trail[i] = fxPart(Enum.PartType.Ball, ONE * math.max(2.4 - i * 0.3, 0.3), cyan, CFrame.new(pos), 0.25 + i * 0.09)
	end
	local function spiral(a)
		local ang = a * math.pi * 6
		return pos + Vector3.new(math.cos(ang) * a * 3.5, 1 + a * a * 42, math.sin(ang) * a * 3.5)
	end
	local T, t0 = 2.2, os.clock()
	while os.clock() - t0 < T do
		local a = (os.clock() - t0) / T
		soul.Position = spiral(a)
		for i, tp in ipairs(trail) do
			tp.Position = spiral(math.max(a - i * 0.025, 0))
		end
		RunService.Heartbeat:Wait()
	end
	local top = spiral(1)
	em.Enabled = false
	tween(soul, 0.3, { Size = ONE * 8, Transparency = 1 })
	for _, tp in ipairs(trail) do tween(tp, 0.3, { Transparency = 1 }) end
	burst(top, { Color = ColorSequence.new(white, cyan), Speed = NumberRange.new(30, 70) }, 70)
	ring(top, cyan, 30, 0.6)
	light(top, cyan, 6, 50, 0.6)
	flash(Color3.fromRGB(190, 255, 245), 0.4, 0.25)
end)

-- 7. GOLDEN STATUE -------------------------------------------------
add("Golden", Color3.fromRGB(255, 205, 60), function(char, pos)
	local gold, bright = Color3.fromRGB(255, 195, 45), Color3.fromRGB(255, 240, 150)
	freezeParts(char)
	sfx(SND_PING, 1, 1.4)
	for _, p in ipairs(bodyParts(char)) do
		p.Material = Enum.Material.Metal
		tween(p, 0.35, { Color = gold })
	end
	light(pos, gold, 6, 35, 1.1)
	burst(pos, { Color = ColorSequence.new(bright, gold), Speed = NumberRange.new(6, 20) }, 45)
	ring(pos - UP * 2.5, gold, 22, 0.6)
	flash(Color3.fromRGB(255, 225, 130), 0.4, 0.25)
	task.wait(0.9)

	sfx(SND_SNAP, 1.2, 1.3)
	hide(char)
	for _ = 1, 40 do
		local dir = Vector3.new(R() - 0.5, 0.001, R() - 0.5).Unit
		local coin = fxPart(Enum.PartType.Cylinder, Vector3.new(0.15, 1.4, 1.4), gold, CFrame.new(pos) * CFrame.Angles(R() * 6, R() * 6, R() * 6), 0, Enum.Material.Metal)
		local peak = pos + dir * (4 + R() * 14) + Vector3.new(0, 10 + R() * 10, 0)
		local land = pos + dir * (8 + R() * 22) - Vector3.new(0, 2.5, 0)
		tween(coin, 0.45, { CFrame = CFrame.new(peak) * CFrame.Angles(R() * 12, R() * 12, R() * 12) })
		task.delay(0.45, function()
			tween(coin, 0.55, { CFrame = CFrame.new(land) * CFrame.Angles(R() * 12, R() * 12, R() * 12) }, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
			task.delay(0.6, function() tween(coin, 0.5, { Transparency = 1 }) end)
		end)
	end
	shards(pos, gold, 30, Enum.Material.Metal, 26, 0.5)
	burst(pos, { Color = ColorSequence.new(bright, gold), Speed = NumberRange.new(30, 70) }, 80)
	ring(pos, bright, 36, 0.6)
	flash(Color3.fromRGB(255, 230, 140), 0.5, 0.5)
	punch(14, 0.4)
	shake(1.5, 0.4)
end)

-- 8. GLITCH --------------------------------------------------------
add("Glitch", Color3.fromRGB(0, 255, 200), function(char, pos)
	local cols = { Color3.fromRGB(0, 255, 255), Color3.fromRGB(255, 0, 255), Color3.fromRGB(0, 255, 90) }
	local parts = bodyParts(char)
	local orig = {}
	for _, p in ipairs(parts) do
		p.Anchored, p.CanCollide = true, false
		p.Material = Enum.Material.Neon
		orig[p] = p.CFrame
	end
	sfx(SND_PING, 1, 0.3)
	for f = 1, 18 do
		for _, p in ipairs(parts) do
			p.CFrame = orig[p] + Vector3.new((R() - 0.5) * 3.5, (R() - 0.5) * 1.5, (R() - 0.5) * 3.5)
			p.Color = cols[R(1, 3)]
			p.Transparency = (R() < 0.3) and 0.6 or 0
		end
		for _ = 1, 3 do
			local c = cols[R(1, 3)]
			local px = fxPart(Enum.PartType.Block, ONE * (0.4 + R() * 1.2), c, CFrame.new(pos + Vector3.new((R() - 0.5) * 8, (R() - 0.5) * 8, (R() - 0.5) * 8)), 0)
			tween(px, 0.25, { Transparency = 1 })
		end
		if f % 4 == 0 then flash(cols[R(1, 3)], 0.15, 0.15) end
		task.wait(0.05)
	end
	for _, p in ipairs(parts) do
		p.Transparency = 0
		tween(p, 0.25, { Size = Vector3.new(p.Size.X * 2.5, 0.1, p.Size.Z * 2.5), Color = cols[1] }, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
	end
	task.wait(0.25)
	hide(char)
	burst(pos, { Color = ColorSequence.new(cols[1], cols[2]), Speed = NumberRange.new(15, 40) }, 60)
	ring(pos, cols[1], 30, 0.5)
	for _ = 1, 26 do
		local top = pos + Vector3.new((R() - 0.5) * 12, 14 + R() * 6, (R() - 0.5) * 12)
		local col = fxPart(Enum.PartType.Block, Vector3.new(0.25, 6 + R() * 6, 0.25), cols[3], CFrame.new(top), 0.1, nil, 3)
		task.delay(R() * 0.4, function()
			tween(col, 0.8, { Position = top - Vector3.new(0, 18, 0), Transparency = 1 }, Enum.EasingStyle.Sine, Enum.EasingDirection.In)
		end)
	end
	shake(1.5, 0.4)
end)

-- 9. PARTY ---------------------------------------------------------
add("Party", Color3.fromRGB(255, 90, 200), function(char, pos)
	local colors = {
		Color3.fromRGB(255, 70, 70), Color3.fromRGB(255, 210, 60), Color3.fromRGB(80, 230, 110),
		Color3.fromRGB(70, 200, 255), Color3.fromRGB(190, 90, 255), Color3.fromRGB(255, 100, 200),
	}
	sfx(SND_SNAP, 1, 1.1)
	launchParts(char, pos, 16, 0.9, 10)
	for _, c in ipairs(colors) do
		burst(pos, { Color = ColorSequence.new(c), Speed = NumberRange.new(30, 65), Lifetime = NumberRange.new(1.3, 2.4), Acceleration = Vector3.new(0, -40, 0), Drag = 1.5, Size = NumberSequence.new({ NumberSequenceKeypoint.new(0, 0.8), NumberSequenceKeypoint.new(1, 0.3) }) }, 28)
	end
	ring(pos, Color3.new(1, 1, 1), 26, 0.5)
	flash(Color3.fromRGB(255, 220, 245), 0.3, 0.2)
	shake(0.8, 0.3)

	for i = 1, 3 do
		task.delay(0.15 + i * 0.22, function()
			local c = colors[R(1, #colors)]
			local c2 = colors[R(1, #colors)]
			local peak = pos + Vector3.new((R() - 0.5) * 18, 14 + R() * 10, (R() - 0.5) * 18)
			local rocket = fxPart(Enum.PartType.Ball, ONE * 0.8, c, CFrame.new(pos), 0)
			tween(rocket, 0.35, { Position = peak }, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
			task.wait(0.35)
			rocket:Destroy()
			sfx(SND_PING, 0.8, 1.2 + R() * 0.5)
			light(peak, c, 6, 40, 0.6)
			burst(peak, { Color = ColorSequence.new(c, c2), Speed = NumberRange.new(25, 55), Lifetime = NumberRange.new(1, 1.8), Acceleration = Vector3.new(0, -14, 0), Size = NumberSequence.new({ NumberSequenceKeypoint.new(0, 1.6), NumberSequenceKeypoint.new(1, 0) }) }, 70)
			ring(peak, c, 20, 0.5)
		end)
	end
	for _ = 1, 34 do
		local start = pos + Vector3.new((R() - 0.5) * 20, 12 + R() * 6, (R() - 0.5) * 20)
		local rib = fxPart(Enum.PartType.Block, Vector3.new(0.15, 2.5, 0.5), colors[R(1, #colors)], CFrame.new(start) * CFrame.Angles(R() * 6, R() * 6, R() * 6), 0, nil, 4)
		task.delay(R() * 0.5, function()
			tween(rib, 1.6, { Position = start - Vector3.new(0, 16, 0) + Vector3.new((R() - 0.5) * 8, 0, (R() - 0.5) * 8), Orientation = Vector3.new(R(0, 720), R(0, 720), R(0, 720)) }, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
			task.delay(1.1, function() tween(rib, 0.5, { Transparency = 1 }) end)
		end)
	end
end)

local byName = {}
for _, e in ipairs(EFFECTS) do byName[e.name] = e end

------------------------------------------------------------------
-- PLAY + KILL COUNTER
------------------------------------------------------------------
local combo, lastKill = 0, 0
local updateKills = function() end

local function runEffect(char, pos)
	local e = byName[state.selected]
	if e then task.spawn(e.fn, char, pos) end
end

local function play(char, pos)
	local e = byName[state.selected]
	if not e then return end
	if os.clock() - lastKill < 4 then combo += 1 else combo = 1 end
	lastKill = os.clock()
	state.kills += 1
	updateKills()
	local pl = Players:GetPlayerFromCharacter(char)
	local name = pl and pl.DisplayName or char.Name
	popup(pos, "☠ " .. string.upper(name), e.color, 24)
	if combo > 1 then
		task.delay(0.15, function() popup(pos + Vector3.new(0, 3, 0), "x" .. combo .. " COMBO", Color3.new(1, 1, 1), 20) end)
	end
	runEffect(char, pos)
end

------------------------------------------------------------------
-- TEST DUMMY
------------------------------------------------------------------
local function makeDummy(cf)
	local m = Instance.new("Model")
	m.Name = "FXDummy"
	local function part(name, size, offset, color)
		local p = Instance.new("Part")
		p.Name, p.Size, p.Anchored, p.CanCollide, p.Color = name, size, true, false, color
		p.CFrame = cf * CFrame.new(offset)
		p.Parent = m
	end
	local skin, shirt, pants = Color3.fromRGB(245, 205, 48), Color3.fromRGB(13, 105, 172), Color3.fromRGB(80, 200, 90)
	part("Head", Vector3.new(2, 1, 1), Vector3.new(0, 1.5, 0), skin)
	part("Torso", Vector3.new(2, 2, 1), Vector3.zero, shirt)
	part("Left Arm", Vector3.new(1, 2, 1), Vector3.new(-1.5, 0, 0), skin)
	part("Right Arm", Vector3.new(1, 2, 1), Vector3.new(1.5, 0, 0), skin)
	part("Left Leg", Vector3.new(1, 2, 1), Vector3.new(-0.5, -2, 0), pants)
	part("Right Leg", Vector3.new(1, 2, 1), Vector3.new(0.5, -2, 0), pants)
	m.Parent = workspace
	Debris:AddItem(m, 8)
	return m, m.Torso.Position
end

local function testEffect()
	local char = player.Character
	local root = char and char:FindFirstChild("HumanoidRootPart")
	if not root then return end
	local flat = Vector3.new(root.CFrame.LookVector.X, 0, root.CFrame.LookVector.Z)
	if flat.Magnitude < 0.01 then flat = Vector3.new(0, 0, -1) end
	local at = root.Position + flat.Unit * 16
	local dummy, pos = makeDummy(CFrame.new(at))
	runEffect(dummy, pos)
end

------------------------------------------------------------------
-- KILL DETECTION (players + NPCs)
------------------------------------------------------------------
local lastInput = 0
bind(UserInputService.InputBegan, function() lastInput = os.clock() end)

local function trigger(char, hum)
	if char == player.Character then return end
	local root = char:FindFirstChild("HumanoidRootPart") or char:FindFirstChild("Torso") or char.PrimaryPart
	local pos = root and root.Position
	if not pos then
		local ok, pv = pcall(function() return char:GetPivot().Position end)
		if ok then pos = pv end
	end
	if not pos then return end

	local myChar = player.Character
	local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
	local dist = myRoot and (pos - myRoot.Position).Magnitude or math.huge

	local yes = false
	local tag = hum:FindFirstChild("creator")
	if tag and tag.Value == player then
		yes = true
	elseif state.mode == 1 then
		yes = (os.clock() - lastInput < 2.5) and dist < 120
	elseif state.mode == 2 then
		yes = dist <= RANGE
	else
		yes = true
	end
	if yes then play(char, pos) end
end

local watched = {}
local function watch(hum)
	if watched[hum] then return end
	local char = hum.Parent
	if not char or not char:IsA("Model") then return end
	watched[hum] = true
	local done = hum.Health <= 0
	bind(hum.Died, function()
		if done then return end
		done = true
		trigger(char, hum)
	end)
	bind(hum.HealthChanged, function(h)
		if h > 0 then
			done = false
		elseif not done then
			done = true
			trigger(char, hum)
		end
	end)
end

for _, d in ipairs(workspace:GetDescendants()) do
	if d:IsA("Humanoid") then watch(d) end
end
bind(workspace.DescendantAdded, function(d)
	if d:IsA("Humanoid") then task.defer(watch, d) end
end)

------------------------------------------------------------------
-- UI (mobile friendly)
------------------------------------------------------------------
local function new(class, props, parent)
	local o = Instance.new(class)
	for k, v in pairs(props) do o[k] = v end
	o.Parent = parent
	return o
end

local function getGuiParent()
	local ok, ui = pcall(function() return gethui() end)
	if ok and typeof(ui) == "Instance" then return ui end
	return player:WaitForChild("PlayerGui")
end

local BG = Color3.fromRGB(16, 16, 24)
local CARD = Color3.fromRGB(30, 30, 44)
local CARD_ON = Color3.fromRGB(52, 52, 74)

gui = new("ScreenGui", {
	Name = "KillFX_UI", ResetOnSpawn = false, IgnoreGuiInset = true,
	ZIndexBehavior = Enum.ZIndexBehavior.Sibling, DisplayOrder = 999,
}, getGuiParent())

-- floating open button
local openBtn = new("TextButton", {
	Size = UDim2.fromOffset(60, 60),
	Position = UDim2.new(0, 16, 0.5, -30),
	BackgroundColor3 = BG,
	Text = "☠",
	TextSize = 30,
	TextColor3 = Color3.new(1, 1, 1),
	AutoButtonColor = false,
	ZIndex = 10,
}, gui)
new("UICorner", { CornerRadius = UDim.new(1, 0) }, openBtn)
local openStroke = new("UIStroke", { Color = byName[state.selected].color, Thickness = 2.5 }, openBtn)
TweenService:Create(openStroke, TweenInfo.new(1, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true), { Thickness = 5 }):Play()

-- panel
local holder = new("Frame", {
	AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.fromScale(0.5, 0.5),
	Size = UDim2.fromOffset(480, 320), BackgroundTransparency = 1, Visible = false, ZIndex = 5,
}, gui)
local fit = new("UIScale", {}, holder)
local panel = new("Frame", {
	AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.fromScale(0.5, 0.5),
	Size = UDim2.fromScale(1, 1), BackgroundColor3 = BG,
}, holder)
local pop = new("UIScale", { Scale = 1 }, panel)
new("UICorner", { CornerRadius = UDim.new(0, 16) }, panel)
local panelStroke = new("UIStroke", { Color = byName[state.selected].color, Thickness = 2.5 }, panel)

new("TextLabel", {
	Position = UDim2.fromOffset(16, 0), Size = UDim2.fromOffset(240, 42),
	BackgroundTransparency = 1, Text = "☠  KILL EFFECTS", Font = Enum.Font.GothamBlack,
	TextSize = 18, TextColor3 = Color3.new(1, 1, 1), TextXAlignment = Enum.TextXAlignment.Left,
}, panel)
local killsLabel = new("TextLabel", {
	Position = UDim2.new(1, -170, 0, 0), Size = UDim2.fromOffset(100, 42),
	BackgroundTransparency = 1, Text = "Kills: 0", Font = Enum.Font.GothamBold,
	TextSize = 14, TextColor3 = Color3.fromRGB(190, 190, 210), TextXAlignment = Enum.TextXAlignment.Right,
}, panel)
updateKills = function() killsLabel.Text = "Kills: " .. state.kills end

local closeBtn = new("TextButton", {
	AnchorPoint = Vector2.new(1, 0), Position = UDim2.new(1, -8, 0, 5), Size = UDim2.fromOffset(34, 32),
	BackgroundColor3 = Color3.fromRGB(200, 60, 70), Text = "вњ•", Font = Enum.Font.GothamBlack,
	TextSize = 16, TextColor3 = Color3.new(1, 1, 1),
}, panel)
new("UICorner", { CornerRadius = UDim.new(0, 8) }, closeBtn)

local grid = new("ScrollingFrame", {
	Position = UDim2.fromOffset(10, 46), Size = UDim2.fromOffset(460, 180),
	BackgroundTransparency = 1, BorderSizePixel = 0, ScrollBarThickness = 3,
	CanvasSize = UDim2.new(), AutomaticCanvasSize = Enum.AutomaticSize.Y,
}, panel)
new("UIGridLayout", { CellSize = UDim2.fromOffset(146, 54), CellPadding = UDim2.fromOffset(8, 8), SortOrder = Enum.SortOrder.LayoutOrder }, grid)

local cards, strokes = {}, {}
local testBtn

local function refresh()
	local sel = byName[state.selected]
	for name, b in pairs(cards) do
		local on = name == state.selected
		tween(b, 0.15, { BackgroundColor3 = on and CARD_ON or CARD })
		strokes[name].Transparency = on and 0 or 1
	end
	tween(panelStroke, 0.2, { Color = sel.color })
	tween(openStroke, 0.2, { Color = sel.color })
	if testBtn then tween(testBtn, 0.2, { BackgroundColor3 = sel.color }) end
end

for i, e in ipairs(EFFECTS) do
	local b = new("TextButton", {
		BackgroundColor3 = CARD, Text = e.name, Font = Enum.Font.GothamBold, TextSize = 14,
		TextColor3 = Color3.new(1, 1, 1), AutoButtonColor = false, LayoutOrder = i,
	}, grid)
	new("UICorner", { CornerRadius = UDim.new(0, 12) }, b)
	strokes[e.name] = new("UIStroke", { Color = e.color, Thickness = 2.5, Transparency = 1 }, b)
	local bar = new("Frame", { Size = UDim2.new(0, 5, 0.6, 0), Position = UDim2.new(0, 8, 0.2, 0), BackgroundColor3 = e.color }, b)
	new("UICorner", { CornerRadius = UDim.new(1, 0) }, bar)
	cards[e.name] = b
	b.MouseButton1Click:Connect(function()
		state.selected = e.name
		refresh()
	end)
end

local controls = new("Frame", { Position = UDim2.fromOffset(10, 238), Size = UDim2.fromOffset(460, 68), BackgroundTransparency = 1 }, panel)
new("UIListLayout", { FillDirection = Enum.FillDirection.Horizontal, Padding = UDim.new(0, 8), SortOrder = Enum.SortOrder.LayoutOrder }, controls)

local function ctrl(text, order)
	local b = new("TextButton", {
		Size = UDim2.fromOffset(146, 68), BackgroundColor3 = CARD, Text = text, Font = Enum.Font.GothamBold,
		TextSize = 14, TextColor3 = Color3.new(1, 1, 1), TextWrapped = true, AutoButtonColor = true, LayoutOrder = order,
	}, controls)
	new("UICorner", { CornerRadius = UDim.new(0, 12) }, b)
	return b
end

testBtn = ctrl("в–¶  TEST", 1)
testBtn.Font, testBtn.TextSize = Enum.Font.GothamBlack, 18
testBtn.BackgroundColor3 = byName[state.selected].color
testBtn.MouseButton1Click:Connect(testEffect)

local modeBtn = ctrl("", 2)
local function refreshMode() modeBtn.Text = "TRIGGER\n" .. MODES[state.mode] end
modeBtn.MouseButton1Click:Connect(function()
	state.mode = state.mode % #MODES + 1
	refreshMode()
end)

local soundBtn = ctrl("", 3)
local function refreshSound() soundBtn.Text = "SOUND\n" .. (state.sound and "ON" or "OFF") end
soundBtn.MouseButton1Click:Connect(function()
	state.sound = not state.sound
	refreshSound()
end)

refresh()
refreshMode()
refreshSound()

-- fit panel to any screen size
local function refit()
	local c = cam()
	if not c then return end
	local vp = c.ViewportSize
	fit.Scale = math.clamp(math.min(vp.X * 0.94 / 480, vp.Y * 0.9 / 320), 0.45, 1.2)
end
refit()
if cam() then bind(cam():GetPropertyChangedSignal("ViewportSize"), refit) end

local function setOpen(open)
	if open then
		refit()
		pop.Scale = 0.8
		holder.Visible = true
		tween(pop, 0.2, { Scale = 1 }, Enum.EasingStyle.Back)
	else
		holder.Visible = false
	end
end
local function toggle() setOpen(not holder.Visible) end

closeBtn.MouseButton1Click:Connect(function() setOpen(false) end)
bind(UserInputService.InputBegan, function(input, processed)
	if not processed and input.KeyCode == Enum.KeyCode.K then toggle() end
end)

-- draggable open button (tap = open, drag = move)
local dragging, moved, dragStart, startPos = false, false, nil, nil
openBtn.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
		dragging, moved = true, false
		dragStart, startPos = input.Position, openBtn.Position
		input.Changed:Connect(function()
			if input.UserInputState == Enum.UserInputState.End then
				dragging = false
				if not moved then toggle() end
			end
		end)
	end
end)
bind(UserInputService.InputChanged, function(input)
	if dragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
		local d = input.Position - dragStart
		if d.Magnitude > 8 then moved = true end
		if moved then
			openBtn.Position = UDim2.new(startPos.X.Scale, startPos.X.Offset + d.X, startPos.Y.Scale, startPos.Y.Offset + d.Y)
		end
	end
end)

print("[KillFX] loaded - tap the skull button or press K")