--========================================================--
-- STILL LIFE ENTITY
--========================================================--

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UIS = game:GetService("UserInputService")

local Player = Players.LocalPlayer

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

local NORMAL_SPEED = 9
local RAGE_SPEED = 30

local EXTRA_HEADS_MIN = 1
local EXTRA_HEADS_MAX = 3

local EXTRA_HANDS_MIN = 1
local EXTRA_HANDS_MAX = 4

local EXTRA_LEGS_MIN = 1
local EXTRA_LEGS_MAX = 4

local BLEND = 8

local Character
local Humanoid
local Root

local Motors = {}
local BaseC0 = {}

local ExtraParts = {}

local Rage = false
local AnimTime = 0
local LastTouch = 0
local NextTwitch = 0

--========================================================--
-- MOTOR SEARCH
--========================================================--

local function Motor(...)
	for _, name in ipairs({...}) do
		if Motors[name] then
			return Motors[name]
		end
	end
	return nil
end

--========================================================--
-- FIND MOTORS
--========================================================--

local function GetMotors()

	table.clear(Motors)
	table.clear(BaseC0)

	if not Character then
		return
	end

	for _, obj in ipairs(Character:GetDescendants()) do

		if obj:IsA("Motor6D") then

			Motors[obj.Name] = obj
			BaseC0[obj] = obj.C0

		end

	end
end

--========================================================--
-- REMOVE OLD EXTRAS
--========================================================--

local function RemoveExtras()

	for _, obj in ipairs(ExtraParts) do

		if obj and obj.Parent then
			obj:Destroy()
		end

	end

	table.clear(ExtraParts)
end

--========================================================--
-- CREATE WELDED PART
--========================================================--

local function AddPart(source, parent, cf)

	if not source or not parent then
		return
	end

	local part = source:Clone()

	-- Remove joints/scripts
	for _, obj in ipairs(part:GetDescendants()) do

		if obj:IsA("Motor6D")
			or obj:IsA("Weld")
			or obj:IsA("WeldConstraint")
			or obj:IsA("Script")
			or obj:IsA("LocalScript")
			or obj:IsA("ModuleScript")
			or obj:IsA("Humanoid")
			or obj:IsA("Animator") then

			obj:Destroy()

		end

	end

	part.Name = "StillLifeExtra"
	part.Anchored = false
	part.CanCollide = false
	part.CanTouch = false
	part.CanQuery = false
	part.Massless = true

	part.CFrame = parent.CFrame * cf
	part.Parent = Character

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

	table.insert(ExtraParts, part)
end

--========================================================--
-- EXTRA HEADS
--========================================================--

local function CreateHeads()

	local head = Character:FindFirstChild("Head")

	if not head then
		return
	end

	local amount = math.random(
		EXTRA_HEADS_MIN,
		EXTRA_HEADS_MAX
	)

	for i = 1, amount do

		local side = math.random(0,1) == 0 and -1 or 1

		local cf = CFrame.new(
			side * math.random(35,85) / 100,
			math.random(-20,70) / 100,
			math.random(-35,40) / 100
		)
		*
		CFrame.Angles(
			math.rad(math.random(-25,25)),
			math.rad(math.random(-70,70)),
			math.rad(math.random(-25,25))
		)

		AddPart(
			head,
			head,
			cf
		)

	end
end

--========================================================--
-- FIND ARM PART
--========================================================--

local function FindArm(left)

	if left then

		return Character:FindFirstChild("Left Arm")
			or Character:FindFirstChild("LeftHand")
			or Character:FindFirstChild("LeftLowerArm")

	else

		return Character:FindFirstChild("Right Arm")
			or Character:FindFirstChild("RightHand")
			or Character:FindFirstChild("RightLowerArm")

	end

end

--========================================================--
-- EXTRA HANDS
--========================================================--

local function CreateHands()

	local left = FindArm(true)
	local right = FindArm(false)

	if not left and not right then
		return
	end

	local amount = math.random(
		EXTRA_HANDS_MIN,
		EXTRA_HANDS_MAX
	)

	for i = 1, amount do

		local useLeft =
			math.random(0,1) == 0

		local source =
			useLeft and left or right

		if not source then
			source = left or right
		end

		local side =
			math.random(0,1) == 0
			and -1
			or 1

		local cf = CFrame.new(
			side * math.random(30,100) / 100,
			math.random(-60,70) / 100,
			math.random(-30,70) / 100
		)
		*
		CFrame.Angles(
			math.rad(math.random(-80,80)),
			math.rad(math.random(-80,80)),
			math.rad(math.random(-80,80))
		)

		AddPart(
			source,
			Root,
			cf
		)

	end
end

--========================================================--
-- FIND LEG
--========================================================--

local function FindLeg(left)

	if left then

		return Character:FindFirstChild("Left Leg")
			or Character:FindFirstChild("LeftFoot")
			or Character:FindFirstChild("LeftLowerLeg")

	else

		return Character:FindFirstChild("Right Leg")
			or Character:FindFirstChild("RightFoot")
			or Character:FindFirstChild("RightLowerLeg")

	end

end

--========================================================--
-- EXTRA LEGS
--========================================================--

local function CreateLegs()

	local left = FindLeg(true)
	local right = FindLeg(false)

	if not left and not right then
		return
	end

	local amount = math.random(
		EXTRA_LEGS_MIN,
		EXTRA_LEGS_MAX
	)

	for i = 1, amount do

		local source

		if math.random(0,1) == 0 then
			source = left
		else
			source = right
		end

		if not source then
			source = left or right
		end

		local side =
			math.random(0,1) == 0
			and -1
			or 1

		local cf = CFrame.new(
			side * math.random(25,95) / 100,
			math.random(-40,70) / 100,
			math.random(-40,60) / 100
		)
		*
		CFrame.Angles(
			math.rad(math.random(-35,35)),
			math.rad(math.random(-60,60)),
			math.rad(math.random(-30,30))
		)

		AddPart(
			source,
			Root,
			cf
		)

	end
end

--========================================================--
-- STOP DEFAULT ANIMATION
--========================================================--

local function StopDefaultAnimations()

	if not Humanoid then
		return
	end

	for _, track in ipairs(
		Humanoid:GetPlayingAnimationTracks()
	) do

		track:Stop(0)

	end
end

--========================================================--
-- JOINT POSE
--========================================================--

local function Pose(motor, rotation, dt)

	if not motor then
		return
	end

	local base = BaseC0[motor]

	if not base then
		return
	end

	local target = base * rotation

	local alpha = math.clamp(
		dt * BLEND,
		0,
		1
	)

	motor.C0 = motor.C0:Lerp(
		target,
		alpha
	)
end

--========================================================--
-- TIRED IDLE
--========================================================--

local function TiredIdle(dt)

	local wave = math.sin(
		AnimTime * 1.5
	)

	local slow = math.sin(
		AnimTime * 0.6
	)

	local neck = Motor("Neck")

	local ls = Motor(
		"Left Shoulder",
		"LeftShoulder"
	)

	local rs = Motor(
		"Right Shoulder",
		"RightShoulder"
	)

	local lh = Motor(
		"Left Hip",
		"LeftHip"
	)

	local rh = Motor(
		"Right Hip",
		"RightHip"
	)

	local root = Motor(
		"RootJoint",
		"Root"
	)

	-- Head droops forward
	Pose(
		neck,
		CFrame.Angles(
			math.rad(12 + wave * 2),
			math.rad(slow * 2),
			math.rad(slow * 2)
		),
		dt
	)

	-- Shoulders hang
	Pose(
		ls,
		CFrame.Angles(
			math.rad(5 + wave),
			0,
			math.rad(-9)
		),
		dt
	)

	Pose(
		rs,
		CFrame.Angles(
			math.rad(5 + wave),
			0,
			math.rad(9)
		),
		dt
	)

	-- Slight leg relaxation
	Pose(
		lh,
		CFrame.Angles(
			math.rad(-3),
			0,
			0
		),
		dt
	)

	Pose(
		rh,
		CFrame.Angles(
			math.rad(-3),
			0,
			0
		),
		dt
	)

	-- Slumped torso
	Pose(
		root,
		CFrame.Angles(
			math.rad(-5 + wave),
			0,
			math.rad(slow * 1.5)
		),
		dt
	)
end

--========================================================--
-- TIRED RUN
--========================================================--

local function TiredRun(dt)

	local cycle = AnimTime * 8

	local s = math.sin(cycle)
	local c = math.cos(cycle)

	local neck = Motor("Neck")

	local ls = Motor(
		"Left Shoulder",
		"LeftShoulder"
	)

	local rs = Motor(
		"Right Shoulder",
		"RightShoulder"
	)

	local lh = Motor(
		"Left Hip",
		"LeftHip"
	)

	local rh = Motor(
		"Right Hip",
		"RightHip"
	)

	local root = Motor(
		"RootJoint",
		"Root"
	)

	Pose(
		neck,
		CFrame.Angles(
			math.rad(10 + s * 3),
			math.rad(c * 2),
			math.rad(s * 2)
		),
		dt
	)

	-- Opposite arm swing
	Pose(
		ls,
		CFrame.Angles(
			math.rad(5),
			0,
			math.rad(-s * 22)
		),
		dt
	)

	Pose(
		rs,
		CFrame.Angles(
			math.rad(5),
			0,
			math.rad(s * 22)
		),
		dt
	)

	-- Opposite leg movement
	Pose(
		lh,
		CFrame.Angles(
			math.rad(s * 27),
			0,
			0
		),
		dt
	)

	Pose(
		rh,
		CFrame.Angles(
			math.rad(-s * 27),
			0,
			0
		),
		dt
	)

	-- Forward tired lean
	Pose(
		root,
		CFrame.Angles(
			math.rad(-9),
			0,
			math.rad(s * 2)
		),
		dt
	)
end

--========================================================--
-- TIRED JUMP
--========================================================--

local function TiredJump(dt)

	local wave = math.sin(
		AnimTime * 4
	)

	local neck = Motor("Neck")

	local ls = Motor(
		"Left Shoulder",
		"LeftShoulder"
	)

	local rs = Motor(
		"Right Shoulder",
		"RightShoulder"
	)

	local lh = Motor(
		"Left Hip",
		"LeftHip"
	)

	local rh = Motor(
		"Right Hip",
		"RightHip"
	)

	local root = Motor(
		"RootJoint",
		"Root"
	)

	Pose(
		neck,
		CFrame.Angles(
			math.rad(-5),
			0,
			math.rad(wave * 2)
		),
		dt
	)

	Pose(
		ls,
		CFrame.Angles(
			math.rad(-25),
			0,
			math.rad(-10)
		),
		dt
	)

	Pose(
		rs,
		CFrame.Angles(
			math.rad(-25),
			0,
			math.rad(10)
		),
		dt
	)

	Pose(
		lh,
		CFrame.Angles(
			math.rad(12),
			0,
			0
		),
		dt
	)

	Pose(
		rh,
		CFrame.Angles(
			math.rad(12),
			0,
			0
		),
		dt
	)

	Pose(
		root,
		CFrame.Angles(
			math.rad(7),
			0,
			math.rad(wave * 2)
		),
		dt
	)
end

--========================================================--
-- RAGE RUN
--========================================================--

local function RageRun(dt)

	local cycle = AnimTime * 15

	local s = math.sin(cycle)
	local c = math.cos(cycle)

	local neck = Motor("Neck")

	local ls = Motor(
		"Left Shoulder",
		"LeftShoulder"
	)

	local rs = Motor(
		"Right Shoulder",
		"RightShoulder"
	)

	local lh = Motor(
		"Left Hip",
		"LeftHip"
	)

	local rh = Motor(
		"Right Hip",
		"RightHip"
	)

	local root = Motor(
		"RootJoint",
		"Root"
	)

	-- Head pushed forward
	Pose(
		neck,
		CFrame.Angles(
			math.rad(19 + s * 5),
			math.rad(c * 4),
			math.rad(s * 5)
		),
		dt
	)

	-- Large aggressive arm swing
	Pose(
		ls,
		CFrame.Angles(
			math.rad(-10),
			math.rad(-4),
			math.rad(-s * 45)
		),
		dt
	)

	Pose(
		rs,
		CFrame.Angles(
			math.rad(-10),
			math.rad(4),
			math.rad(s * 45)
		),
		dt
	)

	-- Fast legs
	Pose(
		lh,
		CFrame.Angles(
			math.rad(s * 50),
			0,
			0
		),
		dt
	)

	Pose(
		rh,
		CFrame.Angles(
			math.rad(-s * 50),
			0,
			0
		),
		dt
	)

	-- Deep forward lean
	Pose(
		root,
		CFrame.Angles(
			math.rad(-18 + c * 3),
			0,
			math.rad(s * 3)
		),
		dt
	)
end

--========================================================--
-- RAGE JUMP
--========================================================--

local function RageJump(dt)

	local wave = math.sin(
		AnimTime * 8
	)

	local neck = Motor("Neck")

	local ls = Motor(
		"Left Shoulder",
		"LeftShoulder"
	)

	local rs = Motor(
		"Right Shoulder",
		"RightShoulder"
	)

	local lh = Motor(
		"Left Hip",
		"LeftHip"
	)

	local rh = Motor(
		"Right Hip",
		"RightHip"
	)

	local root = Motor(
		"RootJoint",
		"Root"
	)

	Pose(
		neck,
		CFrame.Angles(
			math.rad(20),
			math.rad(wave * 3),
			math.rad(wave * 3)
		),
		dt
	)

	Pose(
		ls,
		CFrame.Angles(
			math.rad(-35),
			0,
			math.rad(-18)
		),
		dt
	)

	Pose(
		rs,
		CFrame.Angles(
			math.rad(-35),
			0,
			math.rad(18)
		),
		dt
	)

	Pose(
		lh,
		CFrame.Angles(
			math.rad(20),
			0,
			math.rad(-4)
		),
		dt
	)

	Pose(
		rh,
		CFrame.Angles(
			math.rad(20),
			0,
			math.rad(4)
		),
		dt
	)

	Pose(
		root,
		CFrame.Angles(
			math.rad(-12),
			0,
			math.rad(wave * 3)
		),
		dt
	)
end

--========================================================--
-- ANIMATION UPDATE
--========================================================--

local function UpdateAnimation(dt)

	if not Humanoid then
		return
	end

	AnimTime += dt

	local state = Humanoid:GetState()

	local airborne =
		state == Enum.HumanoidStateType.Jumping
		or state == Enum.HumanoidStateType.Freefall

	local moving =
		Humanoid.MoveDirection.Magnitude > 0.05

	if airborne then

		if Rage then
			RageJump(dt)
		else
			TiredJump(dt)
		end

	elseif moving then

		if Rage then
			RageRun(dt)
		else
			TiredRun(dt)
		end

	else

		TiredIdle(dt)

	end
end

--========================================================--
-- RAGE
--========================================================--

local function ToggleRage()

	if not Humanoid then
		return
	end

	if Humanoid.Health <= 0 then
		return
	end

	Rage = not Rage

	if Rage then

		Humanoid.WalkSpeed = RAGE_SPEED
		AnimTime = 0

		print("[STILL LIFE] RAGE ON")

	else

		Humanoid.WalkSpeed = NORMAL_SPEED
		AnimTime = 0

		print("[STILL LIFE] RAGE OFF")

	end
end

--========================================================--
-- PC RAGE
--========================================================--

UIS.InputBegan:Connect(function(input, processed)

	if processed then
		return
	end

	if input.KeyCode == Enum.KeyCode.R then
		ToggleRage()
	end
end)

--========================================================--
-- MOBILE DOUBLE TAP
--========================================================--

UIS.TouchTap:Connect(function()

	local now = os.clock()

	if now - LastTouch <= 0.35 then

		ToggleRage()

		LastTouch = 0

	else

		LastTouch = now

	end
end)

--========================================================--
-- CHARACTER SETUP
--========================================================--

local function SetupCharacter(char)

	Character = char

	Humanoid = Character:WaitForChild(
		"Humanoid"
	)

	Root = Character:WaitForChild(
		"HumanoidRootPart"
	)

	task.wait(0.3)

	RemoveExtras()

	GetMotors()

	Rage = false
	AnimTime = 0

	Humanoid.WalkSpeed = NORMAL_SPEED
	Humanoid.AutoRotate = true

	StopDefaultAnimations()

	CreateHeads()
	CreateHands()
	CreateLegs()

	NextTwitch =
		os.clock() + 0.7

	print("[STILL LIFE] Loaded")
	print("[STILL LIFE] Press R to rage")
end

--========================================================--
-- MAIN LOOP
--========================================================--

RunService.Heartbeat:Connect(function(dt)

	if not Character
		or not Character.Parent
		or not Humanoid then
		return
	end

	if Humanoid.Health <= 0 then
		return
	end

	-- Keep speed correct
	if Rage then

		if Humanoid.WalkSpeed ~= RAGE_SPEED then
			Humanoid.WalkSpeed = RAGE_SPEED
		end

	else

		if Humanoid.WalkSpeed ~= NORMAL_SPEED then
			Humanoid.WalkSpeed = NORMAL_SPEED
		end

	end

	-- Animation
	UpdateAnimation(dt)

	-- Random twitch
	local now = os.clock()

	if now >= NextTwitch then

		local neck = Motor("Neck")

		if neck and math.random(1,6) == 1 then

			local old = neck.C0
			local base = BaseC0[neck]

			if base then

				neck.C0 =
					base *
					CFrame.Angles(
						math.rad(math.random(-5,5)),
						math.rad(math.random(-20,20)),
						math.rad(math.random(-5,5))
					)

				task.delay(0.08, function()

					if neck and neck.Parent then
						neck.C0 = old
					end

				end)

			end

		else

			local list = {}

			for _, motor in pairs(Motors) do
				table.insert(list, motor)
			end

			if #list > 0 then

				local motor =
					list[
						math.random(
							1,
							#list
						)
					]

				local base = BaseC0[motor]

				if base then

					motor.C0 =
						base *
						CFrame.Angles(
							math.rad(math.random(-10,10)),
							math.rad(math.random(-10,10)),
							math.rad(math.random(-10,10))
						)

					task.delay(0.06, function()

						if motor and motor.Parent then
							motor.C0 = base
						end

					end)

				end
			end
		end

		NextTwitch =
			now +
			math.random(
				math.floor(TWITCH_MIN * 100),
				math.floor(TWITCH_MAX * 100)
			) / 100

	end
end)

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

Player.CharacterAdded:Connect(function(char)

	task.wait(0.5)

	SetupCharacter(char)

end)

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

if Player.Character then
	SetupCharacter(Player.Character)
end