@quenty/ragdoll 9.1.0 → 9.1.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [9.1.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/ragdoll@9.1.0...@quenty/ragdoll@9.1.1) (2022-10-16)
+
+
+### Bug Fixes
+
+* **perf:** Make Ragdoll performance better ([566d2bb](https://github.com/Quenty/NevermoreEngine/commit/566d2bb1045d62fd08f16c9042d68c328c5c307d))
+
+
+
+
+
 # [9.1.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/ragdoll@9.0.0...@quenty/ragdoll@9.1.0) (2022-10-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/ragdoll",
-  "version": "9.1.0",
+  "version": "9.1.1",
   "description": "Quenty's Ragdoll system for Roblox - Floppy fun ragdolls",
   "keywords": [
     "Roblox",
@@ -29,7 +29,7 @@
     "@quenty/baseobject": "^6.0.0",
     "@quenty/binder": "^8.1.0",
     "@quenty/brio": "^8.1.0",
-    "@quenty/camera": "^9.1.0",
+    "@quenty/camera": "^9.1.1",
     "@quenty/cancellabledelay": "^3.3.0",
     "@quenty/characterutils": "^6.0.0",
     "@quenty/draw": "^4.2.0",
@@ -54,5 +54,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "69c2153865684748d0a8d6806f1ff999685c2e55"
+  "gitHead": "5fc8df6d4a62c0c774ebc78b275898f7f383935b"
 }

package/src/Client/Classes/RagdollClient.lua

@@ -60,6 +60,7 @@ function RagdollClient:_setupCameraShake(impulseCamera)
 
 	local lastVelocity = head.Velocity
 	self._maid:GiveTask(RunService.Heartbeat:Connect(function()
+		debug.profilebegin("ragdollcamerashake")
 		local cameraCFrame = Workspace.CurrentCamera.CFrame
 
 		local velocity = head.Velocity
@@ -71,6 +72,7 @@ function RagdollClient:_setupCameraShake(impulseCamera)
 		end
 
 		lastVelocity = velocity
+		debug.profileend()
 	end))
 end
 

package/src/Server/Classes/Ragdollable.lua

@@ -15,6 +15,7 @@ local RagdollAdditionalAttachmentUtils = require("RagdollAdditionalAttachmentUti
 local RagdollCollisionUtils = require("RagdollCollisionUtils")
 local RagdollBallSocketUtils = require("RagdollBallSocketUtils")
 local Motor6DBindersServer = require("Motor6DBindersServer")
+local RagdollMotorUtils = require("RagdollMotorUtils")
 
 local Ragdollable = setmetatable({}, BaseObject)
 Ragdollable.ClassName = "Ragdollable"
@@ -48,6 +49,9 @@ function Ragdollable.new(humanoid, serviceBag)
 			maid:GiveTask(RagdollBallSocketUtils.ensureBallSockets(state.character, state.rigType))
 			maid:GiveTask(RagdollCollisionUtils.ensureNoCollides(state.character, state.rigType))
 
+			-- Not super guarded against race conditions but it should be fine, as this is for debugging.
+			RagdollMotorUtils.initMotorAttributes(state.character, state.rigType)
+
 			self._maid._configure = maid
 		else
 			self._maid._configure = nil

package/src/Server/RagdollService.lua

@@ -21,6 +21,10 @@ function RagdollService:Init(serviceBag)
 
 	-- Internal
 	self._binders = self._serviceBag:GetService(require("RagdollBindersServer"))
+
+	self._binders.RagdollHumanoidOnFall:SetAutomaticTagging(false)
+	self._binders.RagdollHumanoidOnDeath:SetAutomaticTagging(false)
+	self._binders.UnragdollAutomatically:SetAutomaticTagging(false)
 end
 
 --[=[

package/src/Shared/Rigging/RagdollMotorUtils.lua

@@ -26,6 +26,9 @@ local Rx = require("Rx")
 
 local RagdollMotorUtils = {}
 
+-- For easier debugging
+local DEFAULT_SPRING_SPEED = 20
+
 local R6_MOTORS = {
 	{
 		partName = "Torso";
@@ -118,6 +121,23 @@ local R15_MOTORS = {
 	};
 }
 
+local ROOT_JOINT_CACHE = {}
+
+function RagdollMotorUtils.getFirstRootJointData(rigType)
+	if ROOT_JOINT_CACHE[rigType] then
+		return ROOT_JOINT_CACHE[rigType]
+	end
+
+	for _, item in pairs(RagdollMotorUtils.getMotorData(rigType)) do
+		if item.isRootJoint then
+			ROOT_JOINT_CACHE[rigType] = item
+			return item
+		end
+	end
+
+	error("Could not find root joint data")
+end
+
 function RagdollMotorUtils.getMotorData(rigType)
 	if rigType == Enum.HumanoidRigType.R15 then
 		return R15_MOTORS
@@ -128,158 +148,217 @@ function RagdollMotorUtils.getMotorData(rigType)
 	end
 end
 
-function RagdollMotorUtils.suppressMotors(character, rigType, velocityReadings)
+function RagdollMotorUtils.initMotorAttributes(character, rigType)
 	assert(typeof(character) == "Instance" and character:IsA("Model"), "Bad character")
 	assert(EnumUtils.isOfType(Enum.HumanoidRigType, rigType), "Bad rigType")
 
+	for _, data in pairs(RagdollMotorUtils.getMotorData(rigType)) do
+		local motor = R15Utils.getRigMotor(character, data.partName, data.motorName)
+		if motor then
+			AttributeUtils.initAttribute(motor, RagdollConstants.IS_MOTOR_ANIMATED_ATTRIBUTE, false)
+			AttributeUtils.initAttribute(motor, RagdollConstants.RETURN_SPRING_SPEED_ATTRIBUTE, DEFAULT_SPRING_SPEED)
+		end
+	end
+end
+
+function RagdollMotorUtils.setupAnimatedMotor(character, part)
+	local maid = Maid.new()
+
+	-- make this stuff not physics collide with our own rig
+	-- O(n^2)
+	maid:GiveTask(RagdollCollisionUtils.preventCollisionAmongOthers(character, part))
+
+	return maid
+end
+
+function RagdollMotorUtils.setupRagdollRootPartMotor(motor, part0, part1)
+	local maid = Maid.new()
+
+	local lastTransformSpring = Spring.new(QFrame.fromCFrameClosestTo(motor.Transform, QFrame.new()))
+	lastTransformSpring.t = QFrame.new()
+
+	-- replacing this weld ensures interpolation for some reason
+	local weldContainer = Instance.new("Camera")
+	weldContainer.Name = "TempWeldContainer"
+	weldContainer.Parent = part0
+	maid:GiveTask(weldContainer)
+
+	local function setupWeld(weldType)
+		local weldMaid = Maid.new()
+
+		local weld = Instance.new(weldType)
+		weld.Name = "TempRagdollWeld"
+		weld.Part0 = part0
+		weld.Part1 = part1
+		weldMaid:GiveTask(weld)
+
+		-- Inserted C1/C0 here
+		weldMaid:GiveTask(Rx.combineLatest({
+			C0 = RxInstanceUtils.observeProperty(motor, "C0");
+			Transform = RxInstanceUtils.observeProperty(motor, "Transform");
+		}):Subscribe(function(innerState)
+			weld.C0 = innerState.C0 * innerState.Transform
+		end))
+		weldMaid:GiveTask(RxInstanceUtils.observeProperty(motor, "C1"):Subscribe(function(c1)
+			weld.C1 = c1
+		end))
+		weld.Parent = weldContainer
+
+		return weldMaid
+	end
+
+	if CharacterUtils.getPlayerFromCharacter(part0) then
+		-- Swap from choppy to interpolation
+		maid._weld = setupWeld("Motor6D")
+		maid:GiveTask(task.delay(0.25, function()
+			maid._weld = setupWeld("Weld")
+		end))
+	else
+		-- Smooth all the way! (Probably NPC)
+		maid._weld = setupWeld("Weld")
+	end
+
+	maid:GiveTask(RxAttributeUtils.observeAttribute(motor, RagdollConstants.RETURN_SPRING_SPEED_ATTRIBUTE, DEFAULT_SPRING_SPEED)
+		:Subscribe(function(speed)
+			lastTransformSpring.s = speed
+		end))
+
+	-- Lerp smoothly to 0 to avoid jarring camera.
+	maid:GiveTask(RunService.Stepped:Connect(function()
+		local target = QFrame.toCFrame(lastTransformSpring.p)
+		if target then
+			motor.Transform = target
+		end
+	end))
+
+	motor.Enabled = false
+
+	maid:GiveTask(function()
+		motor.Enabled = true
+	end)
+
+	return maid
+end
+
+function RagdollMotorUtils.setupRagdollMotor(motor, part0, part1)
+	local maid = Maid.new()
+
+	motor.Enabled = false
+	maid:GiveTask(function()
+		local implemention = Motor6DStackInterface:FindFirstImplementation(motor)
+		if implemention then
+			local initialTransform = (part0.CFrame * motor.C0):toObjectSpace(part1.CFrame * motor.C1)
+			local speed = AttributeUtils.getAttribute(motor, RagdollConstants.RETURN_SPRING_SPEED_ATTRIBUTE, DEFAULT_SPRING_SPEED)
+
+			implemention:TransformFromCFrame(initialTransform, speed)
+		end
+
+		motor.Enabled = true
+	end)
+
+	maid:GiveTask(RunService.Stepped:Connect(function()
+		motor.Transform = CFrame.new()
+	end))
+
+	return maid
+end
+
+function RagdollMotorUtils.suppressJustRootPart(character, rigType)
+	local data = RagdollMotorUtils.getFirstRootJointData(rigType)
+
+	local observable = RxR15Utils.observeRigMotorBrio(character, data.partName, data.motorName):Pipe({
+		RxBrioUtils.switchMapBrio(function(motor)
+			return RxBrioUtils.flatCombineLatest({
+				motor = motor;
+				part0 = RxInstanceUtils.observeProperty(motor, "Part0");
+				part1 = RxInstanceUtils.observeProperty(motor, "Part1");
+				isAnimated = RxAttributeUtils.observeAttribute(motor, RagdollConstants.IS_MOTOR_ANIMATED_ATTRIBUTE, false);
+			})
+		end);
+	})
+
 	local topMaid = Maid.new()
 
-	for _, data in pairs(RagdollMotorUtils.getMotorData(rigType)) do
-		local observable = RxR15Utils.observeRigMotorBrio(character, data.partName, data.motorName)
-		topMaid:GiveTask(RxBrioUtils.flatCombineLatest({
-			motor = observable;
-			part0 = observable:Pipe({
-				RxBrioUtils.switchMapBrio(function(motor)
-					return RxInstanceUtils.observeProperty(motor, "Part0");
-				end);
-			});
-			part1 = observable:Pipe({
-				RxBrioUtils.switchMapBrio(function(motor)
-					return RxInstanceUtils.observeProperty(motor, "Part1");
-				end);
-			});
-		}):Subscribe(function(state)
-			if state.motor and state.part0 and state.part1 then
-				local motorMaid = Maid.new()
-				local motor = state.motor
-
-				-- For easier debugging
-				local DEFAULT_SPEED = 20
-				AttributeUtils.initAttribute(motor, RagdollConstants.IS_MOTOR_ANIMATED_ATTRIBUTE, false)
-				AttributeUtils.initAttribute(motor, RagdollConstants.RETURN_SPRING_SPEED_ATTRIBUTE, DEFAULT_SPEED)
-
-				motorMaid:GiveTask(RxAttributeUtils.observeAttribute(motor, RagdollConstants.IS_MOTOR_ANIMATED_ATTRIBUTE, false):Subscribe(function(isAnimated)
-					if isAnimated then
-						local lockMaid = Maid.new()
-
-						-- make this stuff not physics collide with our own rig
-						lockMaid:GiveTask(RagdollCollisionUtils.preventCollisionAmongOthers(character, state.part1))
-
-						motorMaid._lock = lockMaid
-					else
-						local lockMaid = Maid.new()
-
-						if data.isRootJoint then
-							local lastTransformSpring = Spring.new(QFrame.fromCFrameClosestTo(motor.Transform, QFrame.new()))
-							lastTransformSpring.t = QFrame.new()
-
-							-- replacing this weld ensures interpolation for some reason
-							local weldContainer = Instance.new("Camera")
-							weldContainer.Name = "TempWeldContainer"
-							weldContainer.Parent = state.part0
-							lockMaid:GiveTask(weldContainer)
-
-							local function setupWeld(weldType)
-								local weldMaid = Maid.new()
-
-								local weld = Instance.new(weldType)
-								weld.Name = "TempRagdollWeld"
-								weld.Part0 = state.part0
-								weld.Part1 = state.part1
-								weldMaid:GiveTask(weld)
-
-								-- Inserted C1/C0 here
-								weldMaid:GiveTask(Rx.combineLatest({
-									C0 = RxInstanceUtils.observeProperty(motor, "C0");
-									Transform = RxInstanceUtils.observeProperty(motor, "Transform");
-								}):Subscribe(function(innerState)
-									weld.C0 = innerState.C0 * innerState.Transform
-								end))
-								weldMaid:GiveTask(RxInstanceUtils.observeProperty(motor, "C1"):Subscribe(function(c1)
-									weld.C1 = c1
-								end))
-								weld.Parent = weldContainer
-
-								return weldMaid
-							end
+	topMaid:GiveTask(observable:Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
 
+		local state = brio:GetValue()
+		local motorMaid = brio:ToMaid()
 
-							if CharacterUtils.getPlayerFromCharacter(state.part0) then
-								-- Swap from choppy to interpolation
-								lockMaid._weld = setupWeld("Motor6D")
-								lockMaid:GiveTask(task.delay(0.25, function()
-									lockMaid._weld = setupWeld("Weld")
-								end))
-							else
-								-- Smooth all the way! (Probably NPC)
-								lockMaid._weld = setupWeld("Weld")
-							end
+		if not (state.motor and state.part0 and state.part1) then
+			return
+		end
 
-							lockMaid:GiveTask(RxAttributeUtils.observeAttribute(motor, RagdollConstants.RETURN_SPRING_SPEED_ATTRIBUTE, DEFAULT_SPEED)
-								:Subscribe(function(speed)
-									lastTransformSpring.s = speed
-								end))
-
-							-- Lerp smoothly to 0 to avoid jarring camera.
-							lockMaid:GiveTask(RunService.Stepped:Connect(function()
-								local target = QFrame.toCFrame(lastTransformSpring.p)
-								if target then
-									motor.Transform = target
-								end
-							end))
-
-							motor.Enabled = false
-
-							lockMaid:GiveTask(function()
-								motor.Enabled = true
-							end)
-						else
-							motor.Enabled = false
-
-							lockMaid:GiveTask(function()
-								local implemention = Motor6DStackInterface:FindFirstImplementation(state.motor)
-								if implemention then
-									local initialTransform = (state.part0.CFrame * motor.C0):toObjectSpace(state.part1.CFrame * motor.C1)
-									local speed = AttributeUtils.getAttribute(state.motor, RagdollConstants.RETURN_SPRING_SPEED_ATTRIBUTE, DEFAULT_SPEED)
-
-									implemention:TransformFromCFrame(initialTransform, speed)
-								end
-
-								motor.Enabled = true
-							end)
-
-							lockMaid:GiveTask(RunService.Stepped:Connect(function()
-								motor.Transform = CFrame.new()
-							end))
-						end
+		if state.isAnimated then
+			motorMaid._current = RagdollMotorUtils.setupAnimatedMotor(character, state.part1)
+		else
+			motorMaid._current = RagdollMotorUtils.setupRagdollRootPartMotor(state.motor, state.part0, state.part1)
+		end
+	end))
 
-						task.defer(function()
-							-- Note animator:ApplyJointVelocities fails. Do this manually.
-							-- We only want to do this on the network owner.
-							if RagdollMotorUtils.guessIfNetworkOwner(state.part1) then
-								-- use physics time
-								local passed = time() - velocityReadings.readingTimePhysics
-								if passed <= 0.1 then
-									local rotVelocity = velocityReadings.rotation[data]
-									if rotVelocity then
-										state.part1.RotVelocity += rotVelocity
-									end
-
-									local velocity = velocityReadings.linear[data]
-									if velocity then
-										state.part1.Velocity += velocity
-									end
-								end
-							end
-						end)
+	return topMaid
+end
+
+function RagdollMotorUtils.suppressMotors(character, rigType, velocityReadings)
+	assert(typeof(character) == "Instance" and character:IsA("Model"), "Bad character")
+	assert(EnumUtils.isOfType(Enum.HumanoidRigType, rigType), "Bad rigType")
 
-						motorMaid._lock = lockMaid
-					end
-				end))
+	local topMaid = Maid.new()
 
-				topMaid[data] = motorMaid
+	for _, data in pairs(RagdollMotorUtils.getMotorData(rigType)) do
+		local observable = RxR15Utils.observeRigMotorBrio(character, data.partName, data.motorName):Pipe({
+			RxBrioUtils.switchMapBrio(function(motor)
+				return RxBrioUtils.flatCombineLatest({
+					motor = motor;
+					part0 = RxInstanceUtils.observeProperty(motor, "Part0");
+					part1 = RxInstanceUtils.observeProperty(motor, "Part1");
+					isAnimated = RxAttributeUtils.observeAttribute(motor, RagdollConstants.IS_MOTOR_ANIMATED_ATTRIBUTE, false);
+				})
+			end);
+		})
+
+		topMaid:GiveTask(observable:Subscribe(function(brio)
+			if brio:IsDead() then
+				return
+			end
+
+			local state = brio:GetValue()
+			local motorMaid = brio:ToMaid()
+
+			if not (state.motor and state.part0 and state.part1) then
+				return
+			end
+
+			if state.isAnimated then
+				motorMaid._current = RagdollMotorUtils.setupAnimatedMotor(character, state.part1)
 			else
-				topMaid[data] = nil
+				if data.isRootJoint then
+					motorMaid._current = RagdollMotorUtils.setupRagdollRootPartMotor(state.motor, state.part0, state.part1)
+				else
+					motorMaid._current = RagdollMotorUtils.setupRagdollMotor(state.motor, state.part0, state.part1)
+				end
+
+				-- Note animator:ApplyJointVelocities fails. Do this manually.
+				-- We only want to do this on the network owner.
+				if RagdollMotorUtils.guessIfNetworkOwner(state.part1) then
+					task.defer(function()
+						-- use physics time
+						local passed = time() - velocityReadings.readingTimePhysics
+						if passed <= 0.1 then
+							local rotVelocity = velocityReadings.rotation[data]
+							if rotVelocity then
+								state.part1.RotVelocity += rotVelocity
+							end
+
+							local velocity = velocityReadings.linear[data]
+							if velocity then
+								state.part1.Velocity += velocity
+							end
+						end
+					end)
+				end
 			end
 		end))
 	end

package/src/Shared/Rigging/RxRagdollUtils.lua

@@ -6,11 +6,15 @@
 
 local require = require(script.Parent.loader).load(script)
 
+local Players = game:GetService("Players")
+local RunService = game:GetService("RunService")
+
 local Maid = require("Maid")
 local RxBrioUtils = require("RxBrioUtils")
 local RxInstanceUtils = require("RxInstanceUtils")
 local RxR15Utils = require("RxR15Utils")
 local RagdollMotorUtils = require("RagdollMotorUtils")
+local CharacterUtils = require("CharacterUtils")
 
 local RxRagdollUtils = {}
 
@@ -94,19 +98,34 @@ function RxRagdollUtils.runLocal(humanoid)
 
 			local maid = Maid.new()
 
-			maid:GivePromise(RagdollMotorUtils.promiseVelocityRecordings(character, rigType))
-				:Then(function(velocityReadings)
-					maid:GiveTask(RxRagdollUtils.suppressRootPartCollision(character, rigType))
-					maid:GiveTask(RxRagdollUtils.enforceHeadCollision(character))
+			local player = CharacterUtils.getPlayerFromCharacter(humanoid)
+			-- This velocity work only really needs to occur on the network owner and on the server
+			-- since the server will replicate all changes over to the client.
+			if RunService:IsServer() or player == Players.LocalPlayer then
+				maid:GivePromise(RagdollMotorUtils.promiseVelocityRecordings(character, rigType))
+					:Then(function(velocityReadings)
+						debug.profilebegin("initragdoll")
+
+						maid:GiveTask(RxRagdollUtils.suppressRootPartCollision(character, rigType))
+						maid:GiveTask(RxRagdollUtils.enforceHeadCollision(character))
+
+						-- Do motors
+						maid:GiveTask(RagdollMotorUtils.suppressMotors(character, rigType, velocityReadings))
 
-					humanoid:ChangeState(Enum.HumanoidStateType.Physics)
-					maid:GiveTask(function()
-						humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)
+						humanoid:ChangeState(Enum.HumanoidStateType.Physics)
+						maid:GiveTask(function()
+							humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)
+						end)
+
+						debug.profileend()
 					end)
+			else
+				debug.profilebegin("initragdoll_nonowner")
+
+				maid:GiveTask(RagdollMotorUtils.suppressJustRootPart(character, rigType))
 
-					-- Do motors
-					maid:GiveTask(RagdollMotorUtils.suppressMotors(character, rigType, velocityReadings))
-				end)
+				debug.profileend()
+			end
 
 			topMaid._current = maid
 		else