--========================================================--
-- GREEN AURA WITH FLIES========================================================--

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Debris = game:GetService("Debris")

local LocalPlayer = Players.LocalPlayer

--========================================================--
-- SETTINGS
--========================================================--

local GREEN = Color3.fromRGB(0, 255, 45)

local SMOKE_RATE = 40

local FLY_COUNT = 12

local FLY_MIN_DISTANCE = 1.5
local FLY_MAX_DISTANCE = 5

local FLY_MIN_HEIGHT = 0.5
local FLY_MAX_HEIGHT = 5

local RAGDOLL_DISTANCE = 10

-- Current Creator Store fly SFX
local FLY_SOUND_ID =
	"rbxassetid://9114875500"

--========================================================--
-- STATE
--========================================================--

local Character
local Root

local SmokeObjects = {}
local FlyObjects = {}

local ProcessedPlayers = {}

local FlySound
local FlySoundConnection
local FlyMovementConnection

--========================================================--
-- CHARACTER
--========================================================--

local function GetCharacter()

	Character =
		LocalPlayer.Character
		or LocalPlayer.CharacterAdded:Wait()

	Root =
		Character:FindFirstChild(
			"HumanoidRootPart"
		)

	if not Root then

		Root =
			Character:WaitForChild(
				"HumanoidRootPart",
				10
			)

	end

	return Character, Root
end

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

local function CleanupEffects()

	for _, object in ipairs(
		SmokeObjects
	) do

		if object
			and object.Parent
		then

			object:Destroy()

		end

	end

	table.clear(
		SmokeObjects
	)

	for _, fly in ipairs(
		FlyObjects
	) do

		if fly.Part
			and fly.Part.Parent
		then

			fly.Part:Destroy()

		end

	end

	table.clear(
		FlyObjects
	)

	if FlySoundConnection then

		FlySoundConnection:Disconnect()

		FlySoundConnection =
			nil

	end

	if FlyMovementConnection then

		FlyMovementConnection:Disconnect()

		FlyMovementConnection =
			nil

	end

	if FlySound then

		FlySound:Destroy()

		FlySound =
			nil

	end
end

--========================================================--
-- SMOKE
--========================================================--

local function MakeSmoke(
	position,
	multiplier
)

	if not Root then
		return
	end

	local attachment =
		Instance.new(
			"Attachment"
		)

	attachment.Position =
		position

	attachment.Parent =
		Root

	table.insert(
		SmokeObjects,
		attachment
	)

	local smoke =
		Instance.new(
			"ParticleEmitter"
		)

	smoke.Texture =
		"rbxasset://textures/particles/smoke_main.dds"

	smoke.Color =
		ColorSequence.new({
			ColorSequenceKeypoint.new(
				0,
				GREEN
			),

			ColorSequenceKeypoint.new(
				0.5,
				Color3.fromRGB(
					0,
					180,
					25
				)
			),

			ColorSequenceKeypoint.new(
				1,
				Color3.fromRGB(
					0,
					80,
					5
				)
			)
		})

	smoke.LightEmission =
		0.25

	smoke.Rate =
		SMOKE_RATE * multiplier

	smoke.Lifetime =
		NumberRange.new(
			2,
			3.5
		)

	smoke.Speed =
		NumberRange.new(
			0.5,
			1.8
		)

	smoke.Acceleration =
		Vector3.new(
			0,
			1.5,
			0
		)

	smoke.SpreadAngle =
		Vector2.new(
			180,
			180
		)

	smoke.Rotation =
		NumberRange.new(
			0,
			360
		)

	smoke.RotSpeed =
		NumberRange.new(
			-30,
			30
		)

	smoke.Size =
		NumberSequence.new({
			NumberSequenceKeypoint.new(
				0,
				1.5 * multiplier
			),

			NumberSequenceKeypoint.new(
				0.4,
				4 * multiplier
			),

			NumberSequenceKeypoint.new(
				0.8,
				6 * multiplier
			),

			NumberSequenceKeypoint.new(
				1,
				7 * multiplier
			)
		})

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

			NumberSequenceKeypoint.new(
				0.6,
				0.4
			),

			NumberSequenceKeypoint.new(
				1,
				1
			)
		})

	smoke.Parent =
		attachment

	table.insert(
		SmokeObjects,
		smoke
	)
end

local function CreateSmoke()

	if not Root then
		return
	end

	MakeSmoke(
		Vector3.new(
			0,
			-2,
			0
		),
		1
	)

	MakeSmoke(
		Vector3.new(
			0,
			0,
			0
		),
		0.8
	)

	MakeSmoke(
		Vector3.new(
			0,
			1.7,
			0
		),
		0.7
	)

	MakeSmoke(
		Vector3.new(
			1.3,
			0,
			0
		),
		0.6
	)

	MakeSmoke(
		Vector3.new(
			-1.3,
			0,
			0
		),
		0.6
	)

	local light =
		Instance.new(
			"PointLight"
		)

	light.Color =
		GREEN

	light.Brightness =
		2

	light.Range =
		12

	light.Parent =
		Root

	table.insert(
		SmokeObjects,
		light
	)
end

--========================================================--
-- FLY SOUND
--========================================================--

local function CreateFlySound()

	if not Root then
		return
	end

	if FlySound then
		FlySound:Destroy()
	end

	FlySound =
		Instance.new(
			"Sound"
		)

	FlySound.Name =
		"FlyBuzz"

	FlySound.SoundId =
		FLY_SOUND_ID

	FlySound.Volume =
		0.55

	FlySound.Looped =
		true

	FlySound.RollOffMode =
		Enum.RollOffMode.Inverse

	FlySound.RollOffMinDistance =
		3

	FlySound.RollOffMaxDistance =
		35

	FlySound.Parent =
		Root

	-- Don't wait for IsLoaded.
	-- Start immediately.

	pcall(function()

		FlySound:Play()

	end)

	FlySoundConnection =
		RunService.Heartbeat:Connect(
			function()

				if not FlySound then
					return
				end

				if not FlySound.Parent then
					return
				end

				if not FlySound.IsPlaying then

					pcall(function()

						FlySound:Play()

					end)

				end
			end
		)
end

--========================================================--
-- RANDOM FLY
--========================================================--

local function CreateRandomFly(index)

	local part =
		Instance.new(
			"Part"
		)

	part.Name =
		"RandomFly_" .. index

	part.Shape =
		Enum.PartType.Ball

	part.Size =
		Vector3.new(
			0.18,
			0.18,
			0.18
		)

	part.Material =
		Enum.Material.Neon

	part.Color =
		Color3.fromRGB(
			10,
			10,
			10
		)

	part.Anchored =
		true

	part.CanCollide =
		false

	part.CanTouch =
		false

	part.CanQuery =
		false

	part.CastShadow =
		false

	part.Parent =
		workspace

	local glow =
		Instance.new(
			"PointLight"
		)

	glow.Color =
		GREEN

	glow.Brightness =
		0.15

	glow.Range =
		1.5

	glow.Parent =
		part

	local random =
		Random.new(
			index * 7919
		)

	local flyData = {

		Part = part,

		Position =
			Vector3.new(
				random:NextNumber(
					-FLY_MAX_DISTANCE,
					FLY_MAX_DISTANCE
				),

				random:NextNumber(
					FLY_MIN_HEIGHT,
					FLY_MAX_HEIGHT
				),

				random:NextNumber(
					-FLY_MAX_DISTANCE,
					FLY_MAX_DISTANCE
				)
			),

		Target =
			Vector3.zero,

		Speed =
			random:NextNumber(
				2,
				5
			),

		Timer =
			random:NextNumber(
				0,
				1
			),

		Random =
			random,

	}

	table.insert(
		FlyObjects,
		flyData
	)

	return flyData
end

--========================================================--
-- CHOOSE RANDOM FLY TARGET
--========================================================--

local function ChooseNewFlyTarget(
	fly
)

	local random =
		fly.Random

	fly.Target =
		Vector3.new(

			random:NextNumber(
				-FLY_MAX_DISTANCE,
				FLY_MAX_DISTANCE
			),

			random:NextNumber(
				FLY_MIN_HEIGHT,
				FLY_MAX_HEIGHT
			),

			random:NextNumber(
				-FLY_MAX_DISTANCE,
				FLY_MAX_DISTANCE
			)

		)

	fly.Speed =
		random:NextNumber(
			1.5,
			4.5
		)

end

--========================================================--
-- CREATE RANDOM FLIES
--========================================================--

local function CreateFlies()

	table.clear(
		FlyObjects
	)

	for i = 1, FLY_COUNT do

		local fly =
			CreateRandomFly(i)

		ChooseNewFlyTarget(
			fly
		)

	end

	if FlyMovementConnection then

		FlyMovementConnection:Disconnect()

	end

	FlyMovementConnection =
		RunService.RenderStepped:Connect(
			function(deltaTime)

				if not Root
					or not Root.Parent
				then
					return
				end

				for index, fly in ipairs(
					FlyObjects
				) do

					if not fly.Part
						or not fly.Part.Parent
					then
						continue
					end

					-- Randomly change target

					fly.Timer -=
						deltaTime

					if fly.Timer <= 0 then

						ChooseNewFlyTarget(
							fly
						)

						fly.Timer =
							fly.Random:NextNumber(
								0.5,
								2
							)

					end

					-- Move toward random target

					local difference =
						fly.Target
						- fly.Position

					local distance =
						difference.Magnitude

					if distance > 0.05 then

						local direction =
							difference.Unit

						local movement =
							math.min(
								distance,
								fly.Speed
								* deltaTime
							)

						fly.Position +=
							direction
							* movement

					end

					-- Add natural buzzing movement

					local time =
						os.clock()

					local wobble =
						Vector3.new(

							math.sin(
								time * 7
								+ index
							) * 0.15,

							math.sin(
								time * 11
								+ index * 2
							) * 0.12,

							math.cos(
								time * 8
								+ index
							) * 0.15

						)

					local worldPosition =
						Root.Position
						+ fly.Position
						+ wobble

					fly.Part.Position =
						worldPosition

				end
			end
		)
end

--========================================================--
-- HIDE TARGET ONLY
--========================================================--

local function HideTarget(
	model
)

	if not model then
		return
	end

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

		if object:IsA("BasePart") then

			object.LocalTransparencyModifier =
				1

		elseif object:IsA("Decal")
			or object:IsA("Texture")
		then

			object.Transparency =
				1

		end

	end

	local humanoid =
		model:FindFirstChildOfClass(
			"Humanoid"
		)

	if humanoid then

		humanoid.DisplayDistanceType =
			Enum.HumanoidDisplayDistanceType.None

		humanoid.HealthDisplayType =
			Enum.HumanoidHealthDisplayType.AlwaysOff

	end
end

--========================================================--
-- CLEAN DUMMY
--========================================================--

local function CleanDummy(
	dummy
)

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

		if object:IsA("Script")
			or object:IsA("LocalScript")
			or object:IsA("ModuleScript")
			or object:IsA("Tool")
			or object:IsA("BillboardGui")
			or object:IsA("SurfaceGui")
			or object:IsA("Sound")
		then

			object:Destroy()

		end

	end
end

--========================================================--
-- PREPARE PART
--========================================================--

local function PreparePart(
	part
)

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

	part.Anchored =
		false

	part.CanCollide =
		true

	part.CanTouch =
		false

	part.CanQuery =
		false

	part.Massless =
		false

	part.LocalTransparencyModifier =
		0
end

--========================================================--
-- RAGDOLL
--========================================================--

local function Ragdoll(
	dummy
)

	local humanoid =
		dummy:FindFirstChildOfClass(
			"Humanoid"
		)

	if humanoid then

		humanoid.AutoRotate =
			false

		humanoid.PlatformStand =
			true

		humanoid.WalkSpeed =
			0

		humanoid.JumpPower =
			0

		humanoid.DisplayDistanceType =
			Enum.HumanoidDisplayDistanceType.None

		humanoid.HealthDisplayType =
			Enum.HumanoidHealthDisplayType.AlwaysOff

		humanoid:SetStateEnabled(
			Enum.HumanoidStateType.GettingUp,
			false
		)

		pcall(function()

			humanoid:ChangeState(
				Enum.HumanoidStateType.Physics
			)

		end)
	end

	-- Create physical joints

	for _, motor in ipairs(
		dummy:GetDescendants()
	) do

		if motor:IsA("Motor6D") then

			local part0 =
				motor.Part0

			local part1 =
				motor.Part1

			if part0
				and part1
			then

				local a0 =
					Instance.new(
						"Attachment"
					)

				local a1 =
					Instance.new(
						"Attachment"
					)

				a0.CFrame =
					motor.C0

				a1.CFrame =
					motor.C1

				a0.Parent =
					part0

				a1.Parent =
					part1

				local socket =
					Instance.new(
						"BallSocketConstraint"
					)

				socket.Attachment0 =
					a0

				socket.Attachment1 =
					a1

				socket.LimitsEnabled =
					true

				socket.UpperAngle =
					70

				socket.TwistLimitsEnabled =
					true

				socket.TwistLowerAngle =
					-50

				socket.TwistUpperAngle =
					50

				socket.Parent =
					part0

				motor.Enabled =
					false

			end

		end

	end

	-- Physical parts

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

		if object:IsA("BasePart") then

			PreparePart(
				object
			)

		end

	end

	if humanoid then

		pcall(function()

			humanoid:ChangeState(
				Enum.HumanoidStateType.Physics
			)

		end)

	end
end

--========================================================--
-- CARTOON VOMIT EFFECT
--========================================================--

local function CreateVomit(
	dummy
)

	local head =
		dummy:FindFirstChild(
			"Head"
		)

	if not head then
		return
	end

	local attachment =
		Instance.new(
			"Attachment"
		)

	attachment.Name =
		"VomitAttachment"

	-- Front/lower part of head

	attachment.Position =
		Vector3.new(
			0,
			-0.15,
			-0.5
		)

	attachment.Parent =
		head

	local particles =
		Instance.new(
			"ParticleEmitter"
		)

	particles.Name =
		"CartoonVomit"

	particles.Texture =
		"rbxasset://textures/particles/smoke_main.dds"

	particles.Color =
		ColorSequence.new(
			Color3.fromRGB(
				100,
				230,
				15
			)
		)

	particles.Rate =
		0

	particles.Lifetime =
		NumberRange.new(
			0.35,
			0.8
		)

	particles.Speed =
		NumberRange.new(
			4,
			7
		)

	particles.SpreadAngle =
		Vector2.new(
			10,
			10
		)

	particles.EmissionDirection =
		Enum.NormalId.Front

	particles.Size =
		NumberSequence.new({
			NumberSequenceKeypoint.new(
				0,
				0.35
			),

			NumberSequenceKeypoint.new(
				0.5,
				0.55
			),

			NumberSequenceKeypoint.new(
				1,
				0.05
			)
		})

	particles.Transparency =
		NumberSequence.new({
			NumberSequenceKeypoint.new(
				0,
				0.05
			),

			NumberSequenceKeypoint.new(
				0.8,
				0.3
			),

			NumberSequenceKeypoint.new(
				1,
				1
			)
		})

	particles.Parent =
		attachment

	-- Instant burst

	particles:Emit(
		20
	)

	Debris:AddItem(
		attachment,
		2
	)
end

--========================================================--
-- INSTANT VOMIT SOUND
--========================================================--

local function PlayVomitSound(
	dummy
)

	local head =
		dummy:FindFirstChild(
			"Head"
		)

	if not head then
		return
	end

	local sound =
		Instance.new(
			"Sound"
		)

	sound.Name =
		"VomitSound"

	sound.SoundId =
		"rbxassetid://528349992"

	sound.Volume =
		0.8

	sound.Looped =
		false

	sound.RollOffMode =
		Enum.RollOffMode.Inverse

	sound.RollOffMinDistance =
		3

	sound.RollOffMaxDistance =
		30

	sound.Parent =
		head

	-- NO WAITING

	pcall(function()

		sound:Play()

	end)

	Debris:AddItem(
		sound,
		8
	)
end

--========================================================--
-- CREATE RAGDOLL
--========================================================--

local function CreateRagdoll(
	player
)

	if player ==
		LocalPlayer
	then
		return
	end

	if ProcessedPlayers[player] then
		return
	end

	local original =
		player.Character

	if not original then
		return
	end

	local originalRoot =
		original:FindFirstChild(
			"HumanoidRootPart"
		)

	if not originalRoot then
		return
	end

	-- Clone

	local oldArchivable =
		original.Archivable

	original.Archivable =
		true

	local dummy =
		original:Clone()

	original.Archivable =
		oldArchivable

	if not dummy then
		return
	end

	ProcessedPlayers[player] =
		true

	dummy.Name =
		player.Name
		.. "_LocalCollapse"

	CleanDummy(
		dummy
	)

	-- Put dummy in workspace

	dummy.Parent =
		workspace

	local dummyRoot =
		dummy:FindFirstChild(
			"HumanoidRootPart"
		)

	if dummyRoot then

		dummyRoot.CFrame =
			originalRoot.CFrame

	end

	-- Hide ONLY target

	HideTarget(
		original
	)

	-- Ragdoll

	Ragdoll(
		dummy
	)

	-- Vomit from head

	CreateVomit(
		dummy
	)

	-- Sound immediately

	PlayVomitSound(
		dummy
	)
end

--========================================================--
-- DETECT PLAYERS
--========================================================--

local function CheckPlayers()

	if not Root
		or not Root.Parent
	then
		return
	end

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

		if player ~= LocalPlayer
			and not ProcessedPlayers[player]
		then

			local character =
				player.Character

			if character then

				local targetRoot =
					character:FindFirstChild(
						"HumanoidRootPart"
					)

				if targetRoot then

					local distance =
						(
							targetRoot.Position
							- Root.Position
						).Magnitude

					if distance
						<= RAGDOLL_DISTANCE
					then

						CreateRagdoll(
							player
						)

					end
				end
			end
		end
	end
end

--========================================================--
-- RESPAWN
--========================================================--

LocalPlayer.CharacterAdded:Connect(
	function(
		newCharacter
	)

	Character =
		newCharacter

	Root =
		newCharacter:WaitForChild(
			"HumanoidRootPart",
			10
		)

	task.wait(
		0.5
	)

	CleanupEffects()

	table.clear(
		ProcessedPlayers
	)

	CreateSmoke()

	CreateFlySound()

	CreateFlies()

end)

--========================================================--
-- START
--========================================================--

GetCharacter()

task.wait(
	0.5
)

CreateSmoke()

CreateFlySound()

CreateFlies()

--========================================================--
-- DETECTION LOOP
--========================================================--

local timer = 0

RunService.Heartbeat:Connect(
	function(deltaTime)

		timer +=
			deltaTime

		if timer >= 0.1 then

			timer = 0

			CheckPlayers()

		end
	end
)

print(
	"[Green Fly] ACTIVE"
)

print(
	"[Green Fly] Random flying mode"
)

print(
	"[Green Fly] 10 stud collapse range"
)

print(
	"[Green Fly] Client-side only"
)