--========================================================--
-- DISTORCER MAN HUB
-- ENGLISH EDITION + REALISTIC LAUGH ANIMATION
--========================================================--

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local TextChatService = game:GetService("TextChatService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Debris = game:GetService("Debris")

local player = Players.LocalPlayer
local camera = workspace.CurrentCamera

--========================================================--
-- STATES
--========================================================--

local running = false
local isLaughing = false
local handCoveringFace = true
local isTotalGlitch = false
local isSprinting = false
local isAttacking = false

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

local humanoid
local rootPart
local rootJoint
local neckJoint
local originalRootC0
local originalNeckC0

local rightArm
local leftArm
local rightLeg
local leftLeg

local fakeLimbs = {}

local hubGui
local introGui
local mainPanel
local keybindsGui

local wasRunningBeforeRespawn = false
local RENDER_NAME = "DISTORCER_MAN_RENDER"
local glitchSound = nil

--========================================================--
-- INTERPOLATION
--========================================================--

local currTorso = CFrame.new()
local currRArm = CFrame.new()
local currLArm = CFrame.new()
local currRLeg = CFrame.new()
local currLLeg = CFrame.new()
local currNeck = CFrame.new()

local NORMAL_SPEED = 10
local SPRINT_SPEED = 24

local isTrembling = false
local tremorStartTime = 0
local nextTremorTrigger = 0

--========================================================--
-- HELPERS
--========================================================--

local function safeDestroy(obj)
	if obj then
		pcall(function()
			obj:Destroy()
		end)
	end
end

local function cf(x, y, z, rx, ry, rz)
	return CFrame.new(x, y, z)
		* CFrame.Angles(
			math.rad(rx or 0),
			math.rad(ry or 0),
			math.rad(rz or 0)
		)
end

--========================================================--
-- R15 / LIMB SETUP
--========================================================--

local function bindR15Part(fakeLimb, partName, yOffset)
	local part = character:FindFirstChild(partName)
	if not part then return end

	for _, obj in ipairs(part:GetChildren()) do
		if obj:IsA("Motor6D")
			or obj:IsA("Weld")
			or obj:IsA("WeldConstraint") then
			obj:Destroy()
		end
	end

	part.CFrame = fakeLimb.CFrame * CFrame.new(0, yOffset, 0)

	local weld = Instance.new("WeldConstraint")
	weld.Part0 = fakeLimb
	weld.Part1 = part
	weld.Parent = fakeLimb
end

local function createFakeLimb(name, p1, p2, p3)
	local fake = Instance.new("Part")
	fake.Name = name
	fake.Size = Vector3.new(1, 2, 1)
	fake.Transparency = 1
	fake.CanCollide = false
	fake.CanTouch = false
	fake.CanQuery = false
	fake.Massless = true
	fake.CFrame = rootPart.CFrame
	fake.Parent = character

	table.insert(fakeLimbs, fake)

	if humanoid.RigType == Enum.HumanoidRigType.R15 then
		bindR15Part(fake, p1, 0.4)
		bindR15Part(fake, p2, -0.2)
		bindR15Part(fake, p3, -0.85)
	else
		bindR15Part(fake, p1, 0)
	end

	return fake
end

--========================================================--
-- REALISTIC LAUGH ANIMATION
--========================================================--

local function getLaughAnimation(time)
	-- Main laugh rhythm
	local laughCycle = math.sin(time * 8)
	local laughFast = math.sin(time * 17)
	local laughSoft = math.sin(time * 4)

	-- Stronger movement during the laugh
	local bounce = math.abs(math.sin(time * 8)) * 0.10

	-- Body naturally leans forward while laughing
	local torso =
		CFrame.new(
			0,
			bounce,
			0
		)
		* CFrame.Angles(
			math.rad(-8 + laughCycle * 5),
			math.rad(laughSoft * 2),
			math.rad(laughCycle * 3)
		)

	-- Hands move toward the mouth/chin instead of staying frozen
	local rightArm =
		cf(
			0.65,
			1.05 + math.abs(laughCycle) * 0.08,
			-0.55,
			-105 + laughCycle * 12,
			-18 + laughFast * 4,
			28 + laughCycle * 10
		)

	local leftArm =
		cf(
			-0.65,
			1.05 + math.abs(laughCycle) * 0.08,
			-0.55,
			-105 - laughCycle * 12,
			18 - laughFast * 4,
			-28 - laughCycle * 10
		)

	-- Slight leg movement makes the laugh feel less robotic
	local rightLeg =
		cf(
			0.5,
			-1.9 + math.abs(laughCycle) * 0.04,
			0,
			laughCycle * 4,
			0,
			0
		)

	local leftLeg =
		cf(
			-0.5,
			-1.9 + math.abs(laughCycle) * 0.04,
			0,
			-laughCycle * 4,
			0,
			0
		)

	-- Head movement follows the laugh rhythm
	local neck =
		CFrame.Angles(
			math.rad(-8 + math.abs(laughCycle) * 4),
			math.rad(laughSoft * 4),
			math.rad(laughCycle * 3)
		)

	return torso, rightArm, leftArm, rightLeg, leftLeg, neck
end

--========================================================--
-- NORMAL ANIMATION SYSTEM
--========================================================--

local function getAnimation(time, moving, state)
	local torsoTilt = CFrame.new()
	local rArm = cf(1.45, 0.1, 0)
	local lArm = cf(-1.45, 0.1, 0)
	local rLeg = cf(0.5, -1.9, 0)
	local lLeg = cf(-0.5, -1.9, 0)
	local neck = CFrame.new()

	local isJumping = state == Enum.HumanoidStateType.Jumping
	local isFreefall = state == Enum.HumanoidStateType.Freefall

	--====================================================--
	-- REALISTIC LAUGH
	--====================================================--

	if isLaughing then
		return getLaughAnimation(time)

	--====================================================--
	-- ATTACK
	--====================================================--

	elseif isAttacking then
		torsoTilt = CFrame.Angles(math.rad(30), 0, 0)

		rArm = cf(
			1.2,
			0.5,
			-0.5,
			-90,
			0,
			30
		)

		lArm = cf(
			-1.2,
			0.5,
			-0.5,
			-90,
			0,
			-30
		)

	--====================================================--
	-- JUMP
	--====================================================--

	elseif isJumping or isFreefall then
		torsoTilt = CFrame.Angles(math.rad(-10), 0, 0)

		rArm = cf(
			1.4,
			1.0,
			0,
			-110,
			0,
			20
		)

		lArm = cf(
			-1.4,
			1.0,
			0,
			-110,
			0,
			-20
		)

		rLeg = cf(
			0.5,
			-1.5,
			-0.3,
			20,
			0,
			0
		)

		lLeg = cf(
			-0.5,
			-1.5,
			0.3,
			-20,
			0,
			0
		)

	--====================================================--
	-- RUN
	--====================================================--

	elseif moving then
		if isSprinting then
			local runCycle = math.sin(time * 10)
			local bob = math.abs(math.sin(time * 10)) * 0.3

			torsoTilt =
				CFrame.new(0, bob, 0)
				* CFrame.Angles(
					0,
					0,
					math.rad(runCycle * 6)
				)

			rArm = cf(
				1.4,
				-0.3,
				0.6,
				45 - runCycle * 40,
				0,
				15
			)

			lArm = cf(
				-1.4,
				-0.3,
				0.6,
				45 + runCycle * 40,
				0,
				-15
			)

			local rLegY = runCycle > 0 and runCycle * 0.5 or 0
			local lLegY = runCycle < 0 and -runCycle * 0.5 or 0

			rLeg = cf(
				0.5,
				-1.9 + rLegY,
				-runCycle * 0.9,
				runCycle * 70,
				0,
				0
			)

			lLeg = cf(
				-0.5,
				-1.9 + lLegY,
				runCycle * 0.9,
				-runCycle * 70,
				0,
				0
			)

		else
			local walkCycle = math.sin(time * 6)

			torsoTilt =
				CFrame.Angles(
					math.rad(-3),
					0,
					math.rad(walkCycle * 3)
				)

			rArm = cf(
				1.4,
				0.1,
				0,
				-walkCycle * 25,
				0,
				10
			)

			lArm = cf(
				-1.4,
				0.1,
				0,
				walkCycle * 25,
				0,
				-10
			)

			local rLegY = walkCycle > 0 and walkCycle * 0.3 or 0
			local lLegY = walkCycle < 0 and -walkCycle * 0.3 or 0

			rLeg = cf(
				0.5,
				-1.9 + rLegY,
				-walkCycle * 0.4,
				walkCycle * 30,
				0,
				0
			)

			lLeg = cf(
				-0.5,
				-1.9 + lLegY,
				walkCycle * 0.4,
				-walkCycle * 30,
				0,
				0
			)
		end

	--====================================================--
	-- IDLE
	--====================================================--

	else
		local breathe = math.sin(time * 3) * 0.03

		torsoTilt =
			CFrame.new(
				0,
				breathe,
				0
			)

		if handCoveringFace then
			rArm = cf(
				0.25,
				1.35,
				-0.35,
				-135,
				25,
				-15
			)

			lArm = cf(
				-0.25,
				1.35,
				-0.35,
				-135,
				-25,
				15
			)
		else
			rArm = cf(
				1.3,
				-0.05,
				0,
				5,
				0,
				10
			)

			lArm = cf(
				-1.3,
				-0.05,
				0,
				5,
				0,
				-10
			)
		end
	end

	return torsoTilt, rArm, lArm, rLeg, lLeg, neck
end

--========================================================--
-- FLOATING CHAT TEXT
--========================================================--

local function showFloatingChatText(msg)
	local head = character and character:FindFirstChild("Head")
	if not head then return end

	local oldBg = head:FindFirstChild("FloatingChatText")

	if oldBg then
		oldBg:Destroy()
	end

	local bg = Instance.new("BillboardGui")
	bg.Name = "FloatingChatText"
	bg.Size = UDim2.new(0, 350, 0, 80)
	bg.StudsOffset = Vector3.new(0, 3.2, 0)
	bg.AlwaysOnTop = true
	bg.Parent = head

	local label = Instance.new("TextLabel")
	label.Size = UDim2.new(1, 0, 1, 0)
	label.BackgroundTransparency = 1
	label.TextColor3 = Color3.fromRGB(180, 0, 255)
	label.TextStrokeTransparency = 0.2
	label.Font = Enum.Font.GothamBold
	label.TextSize = 20
	label.TextWrapped = true
	label.Text = ""
	label.Parent = bg

	task.spawn(function()
		for i = 1, #msg do
			if not bg.Parent then
				break
			end

			label.Text = string.sub(msg, 1, i)

			local sfx = Instance.new("Sound")
			sfx.SoundId = "rbxassetid://6467449877"
			sfx.Volume = 0.6
			sfx.Pitch = math.random(90, 110) / 100
			sfx.Parent = head
			sfx:Play()

			Debris:AddItem(sfx, 1)

			task.wait(0.04)
		end

		task.wait(4)

		if bg.Parent then
			bg:Destroy()
		end
	end)

	task.spawn(function()
		while bg.Parent do
			label.Position = UDim2.new(
				0,
				math.random(-3, 3),
				0,
				math.random(-3, 3)
			)

			task.wait(0.04)
		end
	end)
end

--========================================================--
-- CHAT
--========================================================--

local function sendChatMessage(msg)
	showFloatingChatText(msg)

	if TextChatService.ChatVersion == Enum.ChatVersion.TextChatService then
		local channel =
			TextChatService.TextChannels:FindFirstChild("RBXGeneral")

		if channel then
			channel:SendAsync(msg)
		end
	else
		local events =
			ReplicatedStorage:FindFirstChild(
				"DefaultChatSystemChatEvents"
			)

		if events then
			local remote =
				events:FindFirstChild("SayMessageRequest")

			if remote then
				remote:FireServer(msg, "All")
			end
		end
	end
end

player.Chatted:Connect(function(msg)
	showFloatingChatText(msg)
end)

local randomPhrases = {
	"DISTORCER MAN IS HERE.",
	"SYSTEM OVERLOAD - GLITCH ACTIVE.",
	"REALITY IS SHAKING APART.",
	"THE SYSTEM IS LOSING CONTROL.",
	"ERROR DETECTED.",
	"REALITY DISTORTION ACTIVE."
}

local function sendRandomChat()
	local phrase =
		randomPhrases[
			math.random(1, #randomPhrases)
		]

	sendChatMessage(phrase)
end

--========================================================--
-- REALISTIC LAUGH TRIGGER
--========================================================--

local function triggerLaugh()
	if not running or isLaughing then
		return
	end

	isLaughing = true

	-- Laugh sound
	local sfx = Instance.new("Sound")
	sfx.Name = "RealisticLaugh"
	sfx.SoundId = "rbxassetid://109263303377273"
	sfx.Volume = 2.5
	sfx.PlaybackSpeed = 1
	sfx.Parent = rootPart
	sfx:Play()

	local connection

	connection = sfx.Ended:Connect(function()
		isLaughing = false

		if connection then
			connection:Disconnect()
			connection = nil
		end
	end)

	-- Safety timeout
	task.delay(5, function()
		if isLaughing then
			isLaughing = false

			if connection then
				connection:Disconnect()
				connection = nil
			end
		end
	end)

	Debris:AddItem(sfx, 6)
end

--========================================================--
-- ATTACK
--========================================================--

local function triggerAttack()
	if not running or isAttacking then
		return
	end

	isAttacking = true

	local attackSound = Instance.new("Sound")
	attackSound.SoundId = "rbxassetid://9114221375"
	attackSound.Volume = 3
	attackSound.PlaybackSpeed = 0.75
	attackSound.Parent = rootPart
	attackSound:Play()

	Debris:AddItem(attackSound, 3)

	if humanoid and rootPart then
		local bv = Instance.new("BodyVelocity")
		bv.MaxForce = Vector3.new(50000, 0, 50000)
		bv.Velocity =
			rootPart.CFrame.LookVector * 65
		bv.Parent = rootPart

		Debris:AddItem(bv, 0.3)
	end

	task.delay(0.5, function()
		isAttacking = false
	end)
end

--========================================================--
-- KEYBINDS DISPLAY
--========================================================--

local function showKeybindsDisplay()
	safeDestroy(keybindsGui)

	keybindsGui =
		Instance.new(
			"ScreenGui",
			player:WaitForChild("PlayerGui")
		)

	keybindsGui.Name = "KeybindsDisplay"
	keybindsGui.ResetOnSpawn = false

	local container = Instance.new("Frame")
	container.Size = UDim2.new(0, 270, 0, 250)
	container.Position = UDim2.new(0.02, 0, 0.35, 0)
	container.BackgroundTransparency = 1
	container.Parent = keybindsGui

	local keys = {
		"[C] - Random Chat",
		"[E] - Realistic Laugh",
		"[F] - Toggle Face Cover",
		"[G] - Toggle Sprint",
		"[R] - Glitch Attack",
		"[T] - Toggle Total Glitch"
	}

	for i, text in ipairs(keys) do
		local label = Instance.new("TextLabel")
		label.Size = UDim2.new(1, 0, 0, 30)
		label.Position =
			UDim2.new(
				0,
				0,
				0,
				(i - 1) * 35
			)

		label.BackgroundTransparency = 1
		label.Text = ""
		label.TextColor3 =
			Color3.fromRGB(180, 0, 255)
		label.TextStrokeTransparency = 0.4
		label.Font = Enum.Font.GothamBold
		label.TextSize = 16
		label.TextXAlignment =
			Enum.TextXAlignment.Left
		label.Parent = container

		task.spawn(function()
			task.wait(i * 1.5)

			if not running then
				return
			end

			label.Text = text

			local conn

			conn =
				RunService.RenderStepped:Connect(function()
					if not running or not label.Parent then
						if conn then
							conn:Disconnect()
						end

						return
					end

					label.Position =
						UDim2.new(
							0,
							math.random(-2, 2),
							0,
							(i - 1) * 35
								+ math.random(-2, 2)
						)
				end)
		end)
	end
end

--========================================================--
-- INPUT
--========================================================--

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

	if input.KeyCode == Enum.KeyCode.C then

		sendRandomChat()

	elseif input.KeyCode == Enum.KeyCode.E then

		triggerLaugh()

	elseif input.KeyCode == Enum.KeyCode.F then

		handCoveringFace =
			not handCoveringFace

	elseif input.KeyCode == Enum.KeyCode.G then

		isSprinting = not isSprinting

		if humanoid then
			humanoid.WalkSpeed =
				isSprinting
				and SPRINT_SPEED
				or NORMAL_SPEED
		end

	elseif input.KeyCode == Enum.KeyCode.R then

		triggerAttack()

	elseif input.KeyCode == Enum.KeyCode.T then

		isTotalGlitch =
			not isTotalGlitch

		if isTotalGlitch then

			if not glitchSound and rootPart then
				glitchSound =
					Instance.new("Sound")

				glitchSound.SoundId =
					"rbxassetid://97749286438268"

				glitchSound.Volume = 3
				glitchSound.Looped = true
				glitchSound.Parent = rootPart
				glitchSound:Play()
			end

		else

			if glitchSound then
				glitchSound:Stop()
				glitchSound:Destroy()
				glitchSound = nil
			end
		end
	end
end)

--========================================================--
-- DRAGGABLE GUI
--========================================================--

local function makeDraggable(gui)
	local dragToggle = false
	local dragStart
	local startPos

	gui.InputBegan:Connect(function(input)
		if input.UserInputType ==
				Enum.UserInputType.MouseButton1
			or input.UserInputType ==
				Enum.UserInputType.Touch then

			dragToggle = true
			dragStart = input.Position
			startPos = gui.Position

			input.Changed:Connect(function()
				if input.UserInputState ==
					Enum.UserInputState.End then

					dragToggle = false
				end
			end)
		end
	end)

	UserInputService.InputChanged:Connect(function(input)
		if dragToggle and
			(
				input.UserInputType ==
					Enum.UserInputType.MouseMovement
				or
				input.UserInputType ==
					Enum.UserInputType.Touch
			) then

			local delta =
				input.Position - dragStart

			gui.Position =
				UDim2.new(
					startPos.X.Scale,
					startPos.X.Offset + delta.X,
					startPos.Y.Scale,
					startPos.Y.Offset + delta.Y
				)
		end
	end)
end

--========================================================--
-- START SYSTEM
--========================================================--

local function startAnimation()
	if running then
		return
	end

	if not character then
		character = player.Character
	end

	humanoid =
		character:FindFirstChildOfClass(
			"Humanoid"
		)

	rootPart =
		character:FindFirstChild(
			"HumanoidRootPart"
		)

	if not humanoid or not rootPart then
		return
	end

	pcall(function()
		RunService:UnbindFromRenderStep(
			RENDER_NAME
		)
	end)

	local head =
		character:FindFirstChild("Head")

	if head then
		camera.CameraSubject = head
	end

	local isR15 =
		humanoid.RigType ==
		Enum.HumanoidRigType.R15

	--====================================================--
	-- JOINTS
	--====================================================--

	if isR15 then

		rootJoint =
			character:FindFirstChild(
				"LowerTorso"
			)
			and character.LowerTorso:FindFirstChild(
				"Root"
			)
			or rootPart:FindFirstChild(
				"RootJoint"
			)

		local upperTorso =
			character:FindFirstChild(
				"UpperTorso"
			)

		if upperTorso then
			neckJoint =
				upperTorso:FindFirstChild(
					"Neck"
				)
		end

		rightArm =
			createFakeLimb(
				"RightArm",
				"RightUpperArm",
				"RightLowerArm",
				"RightHand"
			)

		leftArm =
			createFakeLimb(
				"LeftArm",
				"LeftUpperArm",
				"LeftLowerArm",
				"LeftHand"
			)

		rightLeg =
			createFakeLimb(
				"RightLeg",
				"RightUpperLeg",
				"RightLowerLeg",
				"RightFoot"
			)

		leftLeg =
			createFakeLimb(
				"LeftLeg",
				"LeftUpperLeg",
				"LeftLowerLeg",
				"LeftFoot"
			)

	else

		rootJoint =
			rootPart:FindFirstChild(
				"RootJoint"
			)

		local torsoPart =
			character:FindFirstChild(
				"Torso"
			)

		if torsoPart then
			neckJoint =
				torsoPart:FindFirstChild(
					"Neck"
				)

			for _, name in ipairs({
				"Right Shoulder",
				"Left Shoulder",
				"Right Hip",
				"Left Hip"
			}) do

				local joint =
					torsoPart:FindFirstChild(
						name
					)

				if joint then
					joint:Destroy()
				end
			end
		end

		rightArm =
			createFakeLimb(
				"RightArm",
				"Right Arm"
			)

		leftArm =
			createFakeLimb(
				"LeftArm",
				"Left Arm"
			)

		rightLeg =
			createFakeLimb(
				"RightLeg",
				"Right Leg"
			)

		leftLeg =
			createFakeLimb(
				"LeftLeg",
				"Left Leg"
			)
	end

	-- Save original joints
	if rootJoint then
		originalRootC0 = rootJoint.C0
	end

	if neckJoint then
		originalNeckC0 = neckJoint.C0
	end

	humanoid.WalkSpeed =
		isSprinting
		and SPRINT_SPEED
		or NORMAL_SPEED

	humanoid.AutoRotate = true

	currTorso = CFrame.new()

	currRArm =
		cf(1.45, 0.1, 0)

	currLArm =
		cf(-1.45, 0.1, 0)

	currRLeg =
		cf(0.5, -1.9, 0)

	currLLeg =
		cf(-0.5, -1.9, 0)

	currNeck = CFrame.new()

	running = true
	isTrembling = false

	nextTremorTrigger =
		os.clock()
		+ math.random(10, 30) / 10

	showKeybindsDisplay()

	--====================================================--
	-- RENDER LOOP
	--====================================================--

	RunService:BindToRenderStep(
		RENDER_NAME,
		Enum.RenderPriority.Character.Value + 1,
		function(dt)

			if not running
				or not humanoid
				or humanoid.Health <= 0
				or not rootPart then
				return
			end

			local now = os.clock()

			local moving =
				humanoid.MoveDirection.Magnitude
				> 0.05

			local state =
				humanoid:GetState()

			-- Random tremor
			if not isTrembling then

				if now >= nextTremorTrigger then
					isTrembling = true
					tremorStartTime = now
				end

			else

				if now - tremorStartTime >= 0.4 then
					isTrembling = false

					nextTremorTrigger =
						now
						+ math.random(10, 30) / 10
				end
			end

			local torsoTilt
			local targetRight
			local targetLeft
			local targetRLeg
			local targetLLeg
			local targetNeck

			torsoTilt,
			targetRight,
			targetLeft,
			targetRLeg,
			targetLLeg,
			targetNeck =
				getAnimation(
					now,
					moving,
					state
				)

			-- Laugh animation gets a smoother blend
			local animSmooth =
				isLaughing
				and 0.18
				or 0.25

			currTorso =
				currTorso:Lerp(
					torsoTilt,
					animSmooth
				)

			currRArm =
				currRArm:Lerp(
					targetRight,
					animSmooth
				)

			currLArm =
				currLArm:Lerp(
					targetLeft,
					animSmooth
				)

			currRLeg =
				currRLeg:Lerp(
					targetRLeg,
					animSmooth
				)

			currLLeg =
				currLLeg:Lerp(
					targetLLeg,
					animSmooth
				)

			currNeck =
				currNeck:Lerp(
					targetNeck,
					animSmooth
				)

			-- Apply torso
			if rootJoint
				and originalRootC0 then

				rootJoint.C0 =
					originalRootC0
					* currTorso
			end

			-- Apply head movement during laugh
			if neckJoint
				and originalNeckC0 then

				neckJoint.C0 =
					originalNeckC0
					* currNeck
			end

			local bodyBase =
				rootPart.CFrame
				* currTorso

			local tremorRA =
				Vector3.new()

			local tremorLA =
				Vector3.new()

			local tremorRL =
				Vector3.new()

			local tremorLL =
				Vector3.new()

			--================================================--
			-- TOTAL GLITCH
			--================================================--

			if isTotalGlitch then

				local glitchX =
					math.random(-40, 40) / 10

				local glitchY =
					math.random(-30, 30) / 10

				local glitchZ =
					math.random(-40, 40) / 10

				tremorRA =
					Vector3.new(
						glitchX,
						glitchY,
						glitchZ
					)

				tremorLA =
					Vector3.new(
						-glitchX,
						glitchY,
						-glitchZ
					)

				tremorRL =
					Vector3.new(
						glitchX,
						-glitchY,
						glitchZ
					)

				tremorLL =
					Vector3.new(
						-glitchX,
						-glitchY,
						-glitchZ
					)

			--================================================--
			-- RANDOM TREMOR
			--================================================--

			elseif isTrembling then

				local t = now * 25
				local amp = 0.4

				tremorRA =
					Vector3.new(
						math.noise(t, 1, 1) * amp,
						math.noise(1, t, 1) * amp,
						math.noise(1, 1, t) * amp
					)

				tremorLA =
					Vector3.new(
						math.noise(t, 2, 2) * amp,
						math.noise(2, t, 2) * amp,
						math.noise(2, 2, t) * amp
					)

				tremorRL =
					Vector3.new(
						math.noise(t, 3, 3) * amp,
						math.noise(3, t, 3) * amp,
						math.noise(3, 3, t) * amp
					)

				tremorLL =
					Vector3.new(
						math.noise(t, 4, 4) * amp,
						math.noise(4, t, 4) * amp,
						math.noise(4, 4, t) * amp
					)
			end

			--================================================--
			-- APPLY LIMBS
			--================================================--

			if rightArm then
				rightArm.CFrame =
					bodyBase
					* currRArm
					+ tremorRA

				rightArm.AssemblyLinearVelocity =
					Vector3.zero
			end

			if leftArm then
				leftArm.CFrame =
					bodyBase
					* currLArm
					+ tremorLA

				leftArm.AssemblyLinearVelocity =
					Vector3.zero
			end

			if rightLeg then
				rightLeg.CFrame =
					bodyBase
					* currRLeg
					+ tremorRL

				rightLeg.AssemblyLinearVelocity =
					Vector3.zero
			end

			if leftLeg then
				leftLeg.CFrame =
					bodyBase
					* currLLeg
					+ tremorLL

				leftLeg.AssemblyLinearVelocity =
					Vector3.zero
			end
		end
	)
end

--========================================================--
-- STOP SYSTEM
--========================================================--

local function stopAnimation()
	wasRunningBeforeRespawn = running

	running = false
	isLaughing = false
	isTotalGlitch = false
	isSprinting = false
	isAttacking = false

	safeDestroy(keybindsGui)

	if glitchSound then
		glitchSound:Stop()
		glitchSound:Destroy()
		glitchSound = nil
	end

	pcall(function()
		RunService:UnbindFromRenderStep(
			RENDER_NAME
		)
	end)

	if rootJoint
		and originalRootC0 then

		rootJoint.C0 =
			originalRootC0
	end

	if neckJoint
		and originalNeckC0 then

		neckJoint.C0 =
			originalNeckC0
	end

	for _, obj in ipairs(fakeLimbs) do
		safeDestroy(obj)
	end

	fakeLimbs = {}

	if humanoid then
		humanoid.AutoRotate = true
		humanoid.WalkSpeed = 16
		camera.CameraSubject = humanoid
	end
end

--========================================================--
-- HUB UI
--========================================================--

local function createHub()
	safeDestroy(hubGui)

	hubGui =
		Instance.new(
			"ScreenGui",
			player:WaitForChild("PlayerGui")
		)

	hubGui.Name = "DistorcerManHub"
	hubGui.ResetOnSpawn = false

	local openBtn =
		Instance.new("TextButton")

	openBtn.Size =
		UDim2.new(0, 44, 0, 44)

	openBtn.Position =
		UDim2.new(0, 18, 0, 18)

	openBtn.BackgroundColor3 =
		Color3.fromRGB(20, 20, 25)

	openBtn.Text = "D"

	openBtn.TextColor3 =
		Color3.fromRGB(180, 0, 255)

	openBtn.TextScaled = true
	openBtn.Font = Enum.Font.GothamBlack
	openBtn.Parent = hubGui

	Instance.new("UICorner", openBtn)
		.CornerRadius =
		UDim.new(0, 12)

	local openStroke =
		Instance.new("UIStroke", openBtn)

	openStroke.Thickness = 2

	makeDraggable(openBtn)

	-- Main panel
	mainPanel =
		Instance.new("Frame")

	mainPanel.Size =
		UDim2.new(0, 340, 0, 130)

	mainPanel.Position =
		UDim2.new(
			0.5,
			-170,
			0.5,
			-65
		)

	mainPanel.BackgroundColor3 =
		Color3.fromRGB(15, 15, 20)

	mainPanel.BackgroundTransparency = 0.08
	mainPanel.Parent = hubGui

	Instance.new("UICorner", mainPanel)
		.CornerRadius =
		UDim.new(0, 15)

	local panelStroke =
		Instance.new("UIStroke", mainPanel)

	panelStroke.Thickness = 2.5

	makeDraggable(mainPanel)

	-- Title
	local title =
		Instance.new("TextLabel")

	title.Size =
		UDim2.new(1, -20, 0, 32)

	title.Position =
		UDim2.new(0, 10, 0, 7)

	title.BackgroundTransparency = 1

	title.Text =
		"DISTORCER MAN"

	title.TextColor3 =
		Color3.fromRGB(180, 0, 255)

	title.TextScaled = true
	title.Font = Enum.Font.GothamBlack
	title.Parent = mainPanel

	-- Start
	local startBtn =
		Instance.new("TextButton")

	startBtn.Size =
		UDim2.new(0.5, -13, 0, 36)

	startBtn.Position =
		UDim2.new(0, 10, 0, 55)

	startBtn.BackgroundColor3 =
		Color3.fromRGB(0, 140, 70)

	startBtn.Text = "START"
	startBtn.TextColor3 =
		Color3.new(1, 1, 1)

	startBtn.Font =
		Enum.Font.GothamBold

	startBtn.Parent = mainPanel

	Instance.new("UICorner", startBtn)
		.CornerRadius =
		UDim.new(0, 7)

	startBtn.Activated:Connect(
		startAnimation
	)

	-- Stop
	local stopBtn =
		Instance.new("TextButton")

	stopBtn.Size =
		UDim2.new(0.5, -13, 0, 36)

	stopBtn.Position =
		UDim2.new(0.5, 3, 0, 55)

	stopBtn.BackgroundColor3 =
		Color3.fromRGB(150, 40, 40)

	stopBtn.Text = "STOP"
	stopBtn.TextColor3 =
		Color3.new(1, 1, 1)

	stopBtn.Font =
		Enum.Font.GothamBold

	stopBtn.Parent = mainPanel

	Instance.new("UICorner", stopBtn)
		.CornerRadius =
		UDim.new(0, 7)

	stopBtn.Activated:Connect(
		stopAnimation
	)

	local panelOpen = true

	openBtn.Activated:Connect(function()
		panelOpen = not panelOpen
		mainPanel.Visible = panelOpen
	end)
end

--========================================================--
-- ENGLISH INTRO
--========================================================--

local function createIntro()
	safeDestroy(introGui)

	introGui =
		Instance.new(
			"ScreenGui",
			player:WaitForChild("PlayerGui")
		)

	introGui.Name = "DistorcerManIntro"
	introGui.ResetOnSpawn = false

	local frame =
		Instance.new("Frame")

	frame.Size =
		UDim2.new(0, 420, 0, 280)

	frame.Position =
		UDim2.new(
			0.5,
			-210,
			0.5,
			-140
		)

	frame.BackgroundColor3 =
		Color3.fromRGB(12, 12, 16)

	frame.BackgroundTransparency = 0.05
	frame.Parent = introGui

	Instance.new("UICorner", frame)
		.CornerRadius =
		UDim.new(0, 15)

	local stroke =
		Instance.new("UIStroke", frame)

	stroke.Color =
		Color3.fromRGB(180, 0, 255)

	stroke.Thickness = 2.5

	local title =
		Instance.new("TextLabel")

	title.Size =
		UDim2.new(1, -20, 0, 40)

	title.Position =
		UDim2.new(0, 10, 0, 12)

	title.BackgroundTransparency = 1

	title.Text =
		"IMMERSION WARNING"

	title.TextColor3 =
		Color3.fromRGB(180, 0, 255)

	title.Font =
		Enum.Font.GothamBlack

	title.TextSize = 20
	title.Parent = frame

	local desc =
		Instance.new("TextLabel")

	desc.Size =
		UDim2.new(1, -30, 0, 130)

	desc.Position =
		UDim2.new(0, 15, 0, 60)

	desc.BackgroundTransparency = 1

	desc.Text =
		"To fully enjoy the DISTORCER MAN experience, it is recommended that you use a:\n\n• Completely black and spooky avatar\n\nThis helps the hidden limbs and visual glitch effects look cleaner."

	desc.TextColor3 =
		Color3.fromRGB(220, 220, 220)

	desc.Font =
		Enum.Font.Gotham

	desc.TextSize = 14
	desc.TextWrapped = true
	desc.TextXAlignment =
		Enum.TextXAlignment.Left

	desc.Parent = frame

	local skipBtn =
		Instance.new("TextButton")

	skipBtn.Size =
		UDim2.new(1, -30, 0, 42)

	skipBtn.Position =
		UDim2.new(
			0,
			15,
			1,
			-55
		)

	skipBtn.BackgroundColor3 =
		Color3.fromRGB(180, 0, 255)

	skipBtn.Text =
		"SKIP / CONTINUE"

	skipBtn.TextColor3 =
		Color3.new(1, 1, 1)

	skipBtn.Font =
		Enum.Font.GothamBold

	skipBtn.TextSize = 16
	skipBtn.Parent = frame

	Instance.new("UICorner", skipBtn)
		.CornerRadius =
		UDim.new(0, 8)

	skipBtn.Activated:Connect(function()
		introGui:Destroy()
		createHub()
	end)
end

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

player.CharacterAdded:Connect(function(newCharacter)

	local restart =
		wasRunningBeforeRespawn

	if running then
		stopAnimation()
	end

	character = newCharacter

	task.wait(1)

	if restart then
		startAnimation()
	end
end)

--========================================================--
-- INITIALIZE
--========================================================--

createIntro()

print(
	"[DISTORCER MAN] Loaded successfully."
)

--========================================================--
-- AUTO CHAT COMMAND
--========================================================--

task.spawn(function()

	task.wait(1.5)

	sendChatMessage(
		"-gh 95541515822773 16751252009"
	)

	print(
		"[DISTORCER MAN] Command sent."
	)
end)