Okay, let's significantly refactor and enhance this active ragdoll balancing script. We'll focus on: 1. **Better Structure:** Using tables to organize configuration, state, and functions. 2. **Improved Balancing Logic:** More sophisticated Center of Mass (CoM) prediction, dynamic step adjustments, and active arm counter-balancing. 3. **PD Controllers:** Using Proportional-Derivative control for smoother, more stable torso orientation. 4. **Refined Physics:** More specific joint limits and potentially better constraint management. 5. **Clearer State Management:** Although not adding full FSM, clarifying the stepping state. This is a substantial rewrite focusing on the core balancing mechanics. --[[ Enhanced Active Ragdoll & Balancing Controller Improvements: - Better code structure (Config, State, Modules) - Improved CoM calculation & prediction - PD Controller for Torso Stability - Active Arm Counter-Balancing - Dynamic Step Target Calculation - Refined Foot Planting & Stepping Trajectory - More specific joint limit examples (can be customized further) ]] local Players = game:GetService("Players") local UserInputService = game:GetService("UserInputService") local RunService = game:GetService("RunService") local PhysicsService = game:GetService("PhysicsService") local ReplicatedStorage = game:GetService("ReplicatedStorage") local character = script.Parent local humanoid = character:WaitForChild("Humanoid") local rootPart = character:WaitForChild("HumanoidRootPart") local upperTorso = character:WaitForChild("UpperTorso") local lowerTorso = character:WaitForChild("LowerTorso") local head = character:WaitForChild("Head") local leftFoot = character:WaitForChild("LeftFoot") local rightFoot = character:WaitForChild("RightFoot") local leftUpperArm = character:FindFirstChild("LeftUpperArm") local rightUpperArm = character:FindFirstChild("RightUpperArm") -- ============================================================ -- -- CONFIGURATION -- ============================================================ -- local Config = { -- Balancing Thresholds & Parameters LeanThresholdFwd = 0.4, -- Forward lean threshold before stepping LeanThresholdBack = 0.35, -- Backward lean threshold LeanThresholdSide = 0.3, -- Sideways lean threshold StepDistanceFactor = 1.1, -- How far to step relative to imbalance StepForce = 8000, -- Force applied to move the stepping foot StepResponsiveness = 120, -- How quickly the foot moves to the target StanceWidth = 1.1, -- Desired distance between feet FootLiftHeight = 0.4, -- How high to lift the foot during a step CoMPredictionTime = 0.15, -- How far ahead to predict CoM position (seconds) CoMSmoothingFactor = 0.85, -- Smoothing factor for CoM velocity (0-1, lower = more smoothing) -- Timing StepCooldownTime = 0.5, -- Minimum time between steps StepDuration = 0.45, -- Time to complete a step animation StepCompletionDistance = 0.3, -- How close foot needs to be to target to finish step -- Torso Control (PD Controller Gains) TorsoKp = 15000, -- Proportional gain (stiffness) TorsoKd = 800, -- Derivative gain (damping) TorsoMaxTorque = 40000, -- Max torque for torso correction -- Arm Control ArmCounterBalanceFactor = 0.6, -- How much arms swing to counter lean ArmMaxSwingTorque = 1000, -- Max torque for arm swings ArmDampingFactor = 0.1, -- How quickly arms return to neutral -- Foot Planting FootPlantMaxForce = 5000, FootPlantResponsiveness = 25, FootPlantDamping = 0.7, -- Lerp factor for smoothing target position -- Physics AntiGravityScale = 0.99, -- Slightly less than 1 to keep feet grounded RagdollCollisionGroupName = "Ragdoll", -- Optional: Set up a collision group EnableSelfCollisions = false, -- Whether ragdoll parts should collide with each other -- Joint Limits (Example: More specific limits) JointLimits = { Neck = { UpperAngle = 30, TwistLower = -45, TwistUpper = 45 }, Spine = { UpperAngle = 25, TwistLower = -20, TwistUpper = 20 }, -- Waist/LowerTorso joint Shoulder = { UpperAngle = 120, TwistLower = -90, TwistUpper = 90 }, Elbow = { UpperAngle = 90, TwistLower = -5, TwistUpper = 5 }, Hip = { UpperAngle = 100, TwistLower = -60, TwistUpper = 60 }, Knee = { UpperAngle = 120, TwistLower = -5, TwistUpper = 5 }, Ankle = { UpperAngle = 30, TwistLower = -20, TwistUpper = 20 }, } } -- ============================================================ -- -- STATE VARIABLES -- ============================================================ -- local State = { IsRagdolled = false, SteppingFootName = nil, -- "LeftFoot", "RightFoot", or nil StepTargetPosition = nil, StepStartTime = 0, StepCooldown = 0, LastSteppedFoot = "RightFoot", -- Start alternating CenterOfMass = Vector3.zero, CoMVelocity = Vector3.zero, TotalMass = 10, -- Default, will be calculated OriginalCollisions = {}, JointConstraints = {}, -- Stores { constraint, a1, a2, originalData } PhysicsConstraints = {}, -- Stores AlignPosition, AlignOrientation, VectorForce etc. by name RagdollAttachments = {}, -- Stores all created attachments for cleanup SteppedConnection = nil, LastTickTime = 0, } -- ============================================================ -- -- PHYSICS UTILITIES -- ============================================================ -- local PhysicsUtils = {} function PhysicsUtils.CreateAttachment(parentPart, nameSuffix) local att = Instance.new("Attachment") att.Name = "RagdollAttachment_" .. (nameSuffix or parentPart.Name) att.Parent = parentPart table.insert(State.RagdollAttachments, att) return att end function PhysicsUtils.CalculateCoMAndVelocity(dt) local weightedSum = Vector3.zero local totalMass = 0 local relevantParts = { upperTorso, lowerTorso, head, rootPart, leftUpperArm, rightUpperArm } -- Add more for precision if needed for _, part in pairs(relevantParts) do if part and part:IsA("BasePart") and not part.Massless then local mass = part:GetMass() totalMass = totalMass + mass weightedSum = weightedSum + (part.Position * mass) end end local newCoM if totalMass > 0 then newCoM = weightedSum / totalMass State.TotalMass = totalMass -- Update total mass else newCoM = rootPart.Position -- Fallback State.TotalMass = 10 -- Fallback mass end if State.LastTickTime > 0 and dt > 0 then local displacement = newCoM - State.CenterOfMass local currentVelocity = displacement / dt -- Apply exponential smoothing to velocity State.CoMVelocity = State.CoMVelocity * Config.CoMSmoothingFactor + currentVelocity * (1 - Config.CoMSmoothingFactor) else State.CoMVelocity = Vector3.zero -- Initialize or reset if dt is invalid end State.CenterOfMass = newCoM end function PhysicsUtils.PredictFutureCoM() -- Simple linear prediction return State.CenterOfMass + State.CoMVelocity * Config.CoMPredictionTime end function PhysicsUtils.GetGroundPlaneY(position) local rayOrigin = position + Vector3.new(0, 2, 0) -- Start ray slightly above local rayDir = Vector3.new(0, -5, 0) local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude local result = workspace:Raycast(rayOrigin, rayDir, raycastParams) return result and result.Position.Y or position.Y - 1 -- Fallback if no ground found nearby end function PhysicsUtils.CleanupPhysics() if State.SteppedConnection then State.SteppedConnection:Disconnect() State.SteppedConnection = nil end for name, constraint in pairs(State.PhysicsConstraints) do if constraint and constraint.Parent then constraint:Destroy() end end State.PhysicsConstraints = {} for _, data in pairs(State.JointConstraints) do if data.constraint and data.constraint.Parent then data.constraint:Destroy() end if data.a1 and data.a1.Parent then data.a1:Destroy() end if data.a2 and data.a2.Parent then data.a2:Destroy() end end State.JointConstraints = {} for _, att in pairs(State.RagdollAttachments) do if att and att.Parent then att:Destroy() end end State.RagdollAttachments = {} -- Reset state variables related to stepping/balancing State.SteppingFootName = nil State.StepTargetPosition = nil State.StepStartTime = 0 State.StepCooldown = 0 State.CoMVelocity = Vector3.zero end -- ============================================================ -- -- BALANCING CONTROLLER -- ============================================================ -- local BalanceController = {} function BalanceController.UpdateFootPlanting() if not leftFoot or not rightFoot then return end local feet = { LeftFoot = leftFoot, RightFoot = rightFoot } local groundRayLength = 5 for footName, footPart in pairs(feet) do local plantName = footName .. "_Plant" local alignPos = State.PhysicsConstraints[plantName] if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = plantName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = PhysicsUtils.CreateAttachment(footPart, "PlantAtt") alignPos.MaxForce = Config.FootPlantMaxForce alignPos.Responsiveness = Config.FootPlantResponsiveness alignPos.ApplyAtCenterOfMass = true -- Apply force correctly alignPos.Parent = footPart State.PhysicsConstraints[plantName] = alignPos end -- Disable planting for the stepping foot if State.SteppingFootName == footName then alignPos.Enabled = false else -- Raycast down to find ground local origin = footPart.Position + Vector3.new(0, 0.5, 0) -- Start slightly above foot local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude local result = workspace:Raycast(origin, Vector3.yAxis * -groundRayLength, raycastParams) if result then local groundY = result.Position.Y local targetPos = Vector3.new(footPart.Position.X, groundY + 0.05, footPart.Position.Z) -- Target slightly above ground -- Smooth the target position alignPos.Position = alignPos.Position:Lerp(targetPos, Config.FootPlantDamping) alignPos.Enabled = true else -- No ground detected, disable planting for this foot alignPos.Enabled = false end end end end function BalanceController.UpdateTorsoCorrection(dt) if not upperTorso or not rootPart then return end local torsoAlign = State.PhysicsConstraints["UpperTorso_Align"] if not torsoAlign then return end -- Should exist if ragdolled -- Target Orientation: Upright, facing the same direction as rootPart local lookVector = rootPart.CFrame.LookVector local targetUp = Vector3.yAxis local targetRight = lookVector:Cross(targetUp).Unit targetUp = targetRight:Cross(lookVector).Unit -- Ensure orthogonality local targetCFrame = CFrame.fromMatrix(Vector3.zero, targetRight, targetUp, -lookVector) -- Relative to attachment -- PD Controller Logic local currentCFrame = torsoAlign.Attachment0.WorldCFrame:ToObjectSpace(upperTorso.CFrame) -- Get current relative CFrame local _, currentAxis, currentAngle = currentCFrame:ToAxisAngle() local targetAxis, targetAngle -- Axis/Angle representation of the target rotation relative to current local errorCFrame = targetCFrame * currentCFrame:Inverse() _, targetAxis, targetAngle = errorCFrame:ToAxisAngle() -- Ensure angle is in [-pi, pi] targetAngle = math.atan2(math.sin(targetAngle), math.cos(targetAngle)) -- Calculate corrective torque (PD Controller) local torque = targetAxis * (targetAngle * Config.TorsoKp) -- Proportional term -- Derivative term (damping): Use angular velocity relative to the target orientation -- We approximate world angular velocity for simplicity here local angularVelocity = upperTorso.AssemblyAngularVelocity local dampingTorque = -angularVelocity * Config.TorsoKd torque = torque + dampingTorque -- Apply torque via AlignOrientation's RigidityEnabled mode torsoAlign.PrimaryAxis = targetAxis -- Axis of desired correction torsoAlign.SecondaryAxis = Vector3.zero -- Not needed for pure torque application like this? Test. -- Alternative: Set CFrame directly and let Roblox handle PD internally (simpler but less tunable) -- torsoAlign.CFrame = targetCFrame -- Let Roblox's internal PD handle it -- For direct torque control (if not using AlignOrientation.CFrame): -- Need a way to apply this torque. An AngularVelocity constraint could work, -- but AlignOrientation is generally preferred for orientation tasks. -- Let's stick to letting AlignOrientation handle it via CFrame for now. torsoAlign.CFrame = targetCFrame -- Optional: Dynamically adjust responsiveness based on error? local errorMagnitude = math.abs(targetAngle) torsoAlign.Responsiveness = math.clamp(Config.TorsoKp / 100 + errorMagnitude * 50, 20, 150) -- Heuristic adjustment end function BalanceController.UpdateArmCounterBalancing(leanOffsetLR, leanOffsetFB) if not leftUpperArm or not rightUpperArm then return end local leftArmAV = State.PhysicsConstraints["LeftUpperArm_Swing"] local rightArmAV = State.PhysicsConstraints["RightUpperArm_Swing"] if not leftArmAV or not rightArmAV then return end -- Calculate target swing based on lean (simple model) -- Lean right -> swing left arm out/up, right arm in/down slightly -- Lean forward -> swing arms back local targetLeftVel = Vector3.new(0, 0, -leanOffsetLR * Config.ArmCounterBalanceFactor * 5) -- Z-axis swing for side lean + Vector3.new(leanOffsetFB * Config.ArmCounterBalanceFactor * 3, 0, 0) -- X-axis swing for fwd/back lean local targetRightVel = Vector3.new(0, 0, -leanOffsetLR * Config.ArmCounterBalanceFactor * 5) + Vector3.new(leanOffsetFB * Config.ArmCounterBalanceFactor * 3, 0, 0) -- Apply damping (lerp towards zero) and add target velocity influence leftArmAV.AngularVelocity = leftArmAV.AngularVelocity * (1 - Config.ArmDampingFactor) + targetLeftVel * Config.ArmDampingFactor rightArmAV.AngularVelocity = rightArmAV.AngularVelocity * (1 - Config.ArmDampingFactor) + targetRightVel * Config.ArmDampingFactor end function BalanceController.UpdateActiveBalance(dt) State.StepCooldown = math.max(0, State.StepCooldown - dt) if not leftFoot or not rightFoot or not rootPart or not upperTorso then return end -- 1. Calculate CoM and Predicted CoM PhysicsUtils.CalculateCoMAndVelocity(dt) local predictedCoM = PhysicsUtils.PredictFutureCoM() -- 2. Determine Support Polygon/Point local leftPos = leftFoot.Position local rightPos = rightFoot.Position local avgFootPos = (leftPos + rightPos) / 2 local groundY = math.min(leftPos.Y, rightPos.Y) -- Use lowest foot Y as ground plane estimate -- Use predicted CoM for balance assessment local comXZ = Vector3.new(predictedCoM.X, 0, predictedCoM.Z) local avgFootXZ = Vector3.new(avgFootPos.X, 0, avgFootPos.Z) -- 3. Calculate Lean Offset relative to average foot position local offsetVector = comXZ - avgFootXZ local forwardDir = rootPart.CFrame.LookVector:Cross(Vector3.yAxis).Unit:Cross(Vector3.yAxis) -- Project LookVector onto XZ plane local rightDir = rootPart.CFrame.RightVector:Cross(Vector3.yAxis).Unit:Cross(Vector3.yAxis) -- Project RightVector onto XZ plane local leanOffsetFB = offsetVector:Dot(forwardDir) -- Positive = forward lean local leanOffsetLR = offsetVector:Dot(rightDir) -- Positive = right lean -- 4. Update Ongoing Step (if any) if State.SteppingFootName then local footPart = character:FindFirstChild(State.SteppingFootName) if footPart and State.StepTargetPosition then local stepElapsedTime = tick() - State.StepStartTime local stepProgress = math.clamp(stepElapsedTime / Config.StepDuration, 0, 1) -- S-curve (smoothstep) for vertical motion local verticalEase = stepProgress * stepProgress * (3 - 2 * stepProgress) local currentLift = math.sin(verticalEase * math.pi) * Config.FootLiftHeight -- Horizontal motion (can be linear or eased) local horizontalEase = stepProgress -- Linear for now -- Calculate current target position with lift local baseTarget = State.StepTargetPosition local currentTargetPos = footPart.Position:Lerp(baseTarget, horizontalEase) -- Lerp towards final XZ local targetY = PhysicsUtils.GetGroundPlaneY(baseTarget) -- Get ground Y at the *final* target currentTargetPos = Vector3.new(currentTargetPos.X, targetY + currentLift, currentTargetPos.Z) -- Update the AlignPosition constraint for the stepping foot local constraintName = State.SteppingFootName .. "_BalanceStep" local alignPos = State.PhysicsConstraints[constraintName] if alignPos then -- Smoothly update the target position of the constraint alignPos.Position = alignPos.Position:Lerp(currentTargetPos, 0.5) -- Adjust lerp factor for responsiveness alignPos.Enabled = true end -- Check for step completion local distToFinalTargetXZ = (Vector3.new(footPart.Position.X, 0, footPart.Position.Z) - Vector3.new(baseTarget.X, 0, baseTarget.Z)).Magnitude local isCloseEnough = distToFinalTargetXZ < Config.StepCompletionDistance local isStableEnough = math.abs(leanOffsetFB) < Config.LeanThresholdFwd * 0.5 and math.abs(leanOffsetLR) < Config.LeanThresholdSide * 0.5 if stepProgress >= 1 or (isCloseEnough and stepProgress > 0.7) or (isStableEnough and stepProgress > 0.5) then -- Finish step if alignPos then alignPos.Enabled = false -- Disable step force end State.LastSteppedFoot = State.SteppingFootName State.SteppingFootName = nil State.StepTargetPosition = nil State.StepStartTime = 0 -- Re-enable foot planting for this foot on next frame end else -- Foot or target lost? Cancel step State.SteppingFootName = nil State.StepTargetPosition = nil State.StepStartTime = 0 end BalanceController.UpdateTorsoCorrection(dt) BalanceController.UpdateArmCounterBalancing(leanOffsetLR, leanOffsetFB) return -- Don't try to start a new step while one is in progress end -- 5. Step Decision Logic (if not currently stepping and cooldown is over) if State.StepCooldown <= 0 then local needsStepFwd = leanOffsetFB > Config.LeanThresholdFwd local needsStepBack = leanOffsetFB < -Config.LeanThresholdBack local needsStepRight = leanOffsetLR > Config.LeanThresholdSide local needsStepLeft = leanOffsetLR < -Config.LeanThresholdSide if needsStepFwd or needsStepBack or needsStepRight or needsStepLeft then -- Determine which foot to step with (alternate, or choose based on lean direction) local footToStepPart if needsStepLeft and not needsStepRight then footToStepPart = leftFoot -- Step left with left foot elseif needsStepRight and not needsStepLeft then footToStepPart = rightFoot -- Step right with right foot else -- Forward/backward or combined lean, use alternating foot footToStepPart = (State.LastSteppedFoot == "LeftFoot") and rightFoot or leftFoot end State.SteppingFootName = footToStepPart.Name -- Calculate Step Target Position local stationaryFoot = (State.SteppingFootName == "LeftFoot") and rightFoot or leftFoot local stepVector = Vector3.zero -- Calculate how far past the threshold the CoM is if needsStepFwd then stepVector = stepVector + forwardDir * (leanOffsetFB - Config.LeanThresholdFwd) end if needsStepBack then stepVector = stepVector + forwardDir * (leanOffsetFB + Config.LeanThresholdBack) end -- leanOffsetFB is negative if needsStepRight then stepVector = stepVector + rightDir * (leanOffsetLR - Config.LeanThresholdSide) end if needsStepLeft then stepVector = stepVector + rightDir * (leanOffsetLR + Config.LeanThresholdSide) end -- leanOffsetLR is negative -- Base target relative to the *stationary* foot + desired stance width local stanceOffsetDir = (State.SteppingFootName == "LeftFoot") and -rightDir or rightDir local baseTargetPos = stationaryFoot.Position + stanceOffsetDir * Config.StanceWidth -- Add the corrective step vector (scaled) local finalTargetPos = baseTargetPos + stepVector * Config.StepDistanceFactor -- Ensure target is on the ground plane local targetGroundY = PhysicsUtils.GetGroundPlaneY(finalTargetPos) State.StepTargetPosition = Vector3.new(finalTargetPos.X, targetGroundY, finalTargetPos.Z) -- Activate the stepping constraint local constraintName = State.SteppingFootName .. "_BalanceStep" local alignPos = State.PhysicsConstraints[constraintName] if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = constraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = PhysicsUtils.CreateAttachment(footToStepPart, "BalanceStepAtt") alignPos.MaxForce = Config.StepForce alignPos.Responsiveness = Config.StepResponsiveness alignPos.ApplyAtCenterOfMass = true alignPos.Parent = footToStepPart State.PhysicsConstraints[constraintName] = alignPos end -- Initialize position near current foot to avoid initial jerk alignPos.Position = footToStepPart.Position alignPos.Enabled = true State.StepStartTime = tick() State.StepCooldown = Config.StepCooldownTime -- Disable planting for the stepping foot immediately local plantName = State.SteppingFootName .. "_Plant" if State.PhysicsConstraints[plantName] then State.PhysicsConstraints[plantName].Enabled = false end end end -- 6. Update Torso and Arms regardless of stepping state BalanceController.UpdateTorsoCorrection(dt) BalanceController.UpdateArmCounterBalancing(leanOffsetLR, leanOffsetFB) end -- ============================================================ -- -- RAGDOLL INITIALIZATION & RESET -- ============================================================ -- local RagdollManager = {} function RagdollManager.SaveOriginalCollisions() State.OriginalCollisions = {} for _, part in pairs(character:GetDescendants()) do if part:IsA("BasePart") then State.OriginalCollisions[part] = { CanCollide = part.CanCollide, CollisionGroupId = part.CollisionGroupId, Massless = part.Massless, CustomPhysicalProperties = part.CustomPhysicalProperties } part.Massless = false -- Ensure parts have mass for physics sim -- Optional: Set consistent physical properties -- part.CustomPhysicalProperties = PhysicalProperties.new(0.7, 0.3, 0.5, 1, 1) -- Density, Friction, Elasticity, FrictionWeight, ElasticityWeight end end end function RagdollManager.RestoreOriginalCollisions() for part, data in pairs(State.OriginalCollisions) do if part and part.Parent then part.CanCollide = data.CanCollide part.CollisionGroupId = data.CollisionGroupId part.Massless = data.Massless part.CustomPhysicalProperties = data.CustomPhysicalProperties end end State.OriginalCollisions = {} -- Clear saved data end function RagdollManager.CreateJoints() local collisionGroupId = -1 if Config.RagdollCollisionGroupName and Config.RagdollCollisionGroupName ~= "" then pcall(function() collisionGroupId = PhysicsService:GetCollisionGroupId(Config.RagdollCollisionGroupName) end) if collisionGroupId == 0 then -- Group doesn't exist, create it pcall(function() PhysicsService:CreateCollisionGroup(Config.RagdollCollisionGroupName) collisionGroupId = PhysicsService:GetCollisionGroupId(Config.RagdollCollisionGroupName) -- Configure collisions (example: Ragdoll group doesn't collide with itself) if not Config.EnableSelfCollisions then PhysicsService:CollisionGroupSetCollidable(Config.RagdollCollisionGroupName, Config.RagdollCollisionGroupName, false) end -- Make Ragdoll collide with Default group PhysicsService:CollisionGroupSetCollidable(Config.RagdollCollisionGroupName, "Default", true) end) end end for _, joint in pairs(character:GetDescendants()) do if joint:IsA("Motor6D") then local part0 = joint.Part0 local part1 = joint.Part1 if part0 and part1 and part0:IsA("BasePart") and part1:IsA("BasePart") then -- Assign collision group if valid if collisionGroupId > 0 then pcall(function() part0.CollisionGroupId = collisionGroupId part1.CollisionGroupId = collisionGroupId end) end part0.CanCollide = true -- Ensure parts can collide part1.CanCollide = true local a1 = PhysicsUtils.CreateAttachment(part0, joint.Name .. "_A1") a1.CFrame = joint.C0 local a2 = PhysicsUtils.CreateAttachment(part1, joint.Name .. "_A2") a2.CFrame = joint.C1 local constraint = Instance.new("BallSocketConstraint") constraint.Attachment0 = a1 constraint.Attachment1 = a2 constraint.LimitsEnabled = true constraint.TwistLimitsEnabled = true -- Apply specific limits if defined in Config local jointNameKey = joint.Name:match("Left") or joint.Name:match("Right") or joint.Name -- Try to get generic name if jointNameKey then jointNameKey = jointNameKey:gsub("Upper", ""):gsub("Lower", "") -- Simplify further (e.g., LeftLeg -> Leg) -- Match common joint names if joint.Name:find("Neck") then jointNameKey = "Neck" elseif joint.Name:find("Waist") or joint.Name:find("Root") then jointNameKey = "Spine" elseif joint.Name:find("Shoulder") then jointNameKey = "Shoulder" elseif joint.Name:find("Elbow") then jointNameKey = "Elbow" elseif joint.Name:find("Hip") then jointNameKey = "Hip" elseif joint.Name:find("Knee") then jointNameKey = "Knee" elseif joint.Name:find("Ankle") then jointNameKey = "Ankle" end end local limits = Config.JointLimits[jointNameKey] or Config.JointLimits.Default or { UpperAngle = 45, TwistLower = -30, TwistUpper = 30 } -- Fallback limits constraint.UpperAngle = limits.UpperAngle constraint.TwistLowerAngle = limits.TwistLower constraint.TwistUpperAngle = limits.TwistUpper constraint.Parent = part0 -- Parent constraint to one of the parts table.insert(State.JointConstraints, { constraint = constraint, a1 = a1, a2 = a2, originalData = { -- Store original Motor6D info if needed for reset Name = joint.Name, Parent = joint.Parent, Part0 = joint.Part0, Part1 = joint.Part1, C0 = joint.C0, C1 = joint.C1, } }) joint:Destroy() -- Remove the Motor6D end end end -- Special handling for HumanoidRootPart if rootPart then rootPart.CanCollide = false if collisionGroupId > 0 then pcall(function() rootPart.CollisionGroupId = collisionGroupId end) end end end function RagdollManager.CreatePhysicsConstraints() -- Anti-Gravity Force local antiGravAtt = PhysicsUtils.CreateAttachment(rootPart, "AntiGravityAtt") local standForce = Instance.new("VectorForce") standForce.Name = "AntiGravityForce" standForce.Attachment0 = antiGravAtt standForce.RelativeTo = Enum.ActuatorRelativeTo.World standForce.ApplyAtCenterOfMass = true -- Apply force at CoM for stability -- Force calculated dynamically in the loop based on TotalMass standForce.Force = Vector3.new(0, State.TotalMass * workspace.Gravity * Config.AntiGravityScale, 0) standForce.Parent = rootPart State.PhysicsConstraints[standForce.Name] = standForce -- Torso Alignment if upperTorso then local torsoAlignAtt = PhysicsUtils.CreateAttachment(upperTorso, "TorsoAlignAtt") local align = Instance.new("AlignOrientation") align.Name = "UpperTorso_Align" align.Attachment0 = torsoAlignAtt align.Mode = Enum.OrientationAlignmentMode.OneAttachment align.MaxTorque = Config.TorsoMaxTorque align.Responsiveness = Config.TorsoKp / 100 -- Initial responsiveness based on Kp align.PrimaryAxis = Vector3.xAxis -- Will be updated by PD controller align.SecondaryAxis = Vector3.yAxis -- Will be updated align.RigidityEnabled = true -- Use Rigidity for PD-like behavior align.Parent = upperTorso State.PhysicsConstraints[align.Name] = align end -- Arm Swing Constraints (AngularVelocity for counter-balancing) for _, armName in pairs({"LeftUpperArm", "RightUpperArm"}) do local arm = character:FindFirstChild(armName) if arm then local swingAtt = PhysicsUtils.CreateAttachment(arm, "SwingAtt") local av = Instance.new("AngularVelocity") av.Name = armName .. "_Swing" av.Attachment0 = swingAtt av.MaxTorque = Config.ArmMaxSwingTorque av.RelativeTo = Enum.ActuatorRelativeTo.Attachment0 -- Control relative to arm's orientation av.AngularVelocity = Vector3.zero -- Initial velocity av.Parent = arm State.PhysicsConstraints[av.Name] = av end end end function RagdollManager.MakeRagdoll() if State.IsRagdolled then return end print("Making Ragdoll") State.IsRagdolled = true RagdollManager.SaveOriginalCollisions() PhysicsUtils.CleanupPhysics() -- Clear any previous constraints/attachments first -- Calculate initial mass before creating constraints that might rely on it PhysicsUtils.CalculateCoMAndVelocity(0) -- Calculate initial CoM and Mass RagdollManager.CreateJoints() RagdollManager.CreatePhysicsConstraints() -- Create anti-gravity, torso align etc. humanoid:SetStateEnabled(Enum.HumanoidStateType.GettingUp, false) -- Disable automatic get up humanoid:ChangeState(Enum.HumanoidStateType.Physics) -- Critical step -- Start the update loop State.LastTickTime = tick() State.SteppedConnection = RunService.Stepped:Connect(function(_, dt) -- Use dt from Stepped if not State.IsRagdolled then return end local currentTime = tick() local actualDt = currentTime - State.LastTickTime State.LastTickTime = currentTime if actualDt <= 0 then return end -- Avoid division by zero or weirdness on first frame/pauses -- Update Anti-Gravity Force (in case mass changes, though unlikely here) local standForce = State.PhysicsConstraints["AntiGravityForce"] if standForce then standForce.Force = Vector3.new(0, State.TotalMass * workspace.Gravity * Config.AntiGravityScale, 0) end BalanceController.UpdateFootPlanting() BalanceController.UpdateActiveBalance(actualDt) -- Pass delta time end) end function RagdollManager.ResetCharacter() if not State.IsRagdolled then return end print("Resetting Character") State.IsRagdolled = false PhysicsUtils.CleanupPhysics() -- Destroys constraints, attachments, disconnects Stepped -- Re-create Motor6Ds (This is complex, simplified here) -- Ideally, you'd store the original Motor6D properties and recreate them. -- For now, we'll just rely on the character resetting/respawning or humanoid states. -- A full reset requires recreating all Motor6Ds from State.JointConstraints.originalData -- Example (Conceptual - needs proper implementation): -- for _, data in pairs(State.JointConstraints) do -- if data.originalData then -- local motor = Instance.new("Motor6D") -- motor.Name = data.originalData.Name -- motor.Part0 = data.originalData.Part0 -- motor.Part1 = data.originalData.Part1 -- motor.C0 = data.originalData.C0 -- motor.C1 = data.originalData.C1 -- motor.Parent = data.originalData.Parent -- end -- end -- State.JointConstraints = {} -- Clear after recreating RagdollManager.RestoreOriginalCollisions() humanoid:SetStateEnabled(Enum.HumanoidStateType.GettingUp, true) -- Re-enable default states humanoid:ChangeState(Enum.HumanoidStateType.GettingUp) -- Try to trigger a get up animation/state task.wait(0.1) -- Give it a moment if humanoid:GetState() == Enum.HumanoidStateType.Physics then -- If still in physics state, force another state change humanoid:ChangeState(Enum.HumanoidStateType.Running) -- Or Idle, depending on context end end -- ============================================================ -- -- EVENT HANDLERS & INITIALIZATION -- ============================================================ -- -- Disable default death behavior humanoid.BreakJointsOnDeath = false humanoid.RequiresNeck = false -- Often set false for custom characters/ragdolls humanoid.Died:Connect(function() if not State.IsRagdolled then task.wait(0.05) -- Short delay after death event RagdollManager.MakeRagdoll() end end) -- Toggle Ragdoll with 'R' key (for testing) UserInputService.InputBegan:Connect(function(input, gameProcessed) if gameProcessed then return end if input.UserInputType == Enum.UserInputType.Keyboard then if input.KeyCode == Enum.KeyCode.R and humanoid.Health > 0 then if State.IsRagdolled then RagdollManager.ResetCharacter() else RagdollManager.MakeRagdoll() end end end end) -- Clean up when script is removed script.Destroying:Connect(function() if State.IsRagdolled then RagdollManager.ResetCharacter() -- Attempt cleanup else PhysicsUtils.CleanupPhysics() -- Still cleanup any stray connections/instances end end) print("Enhanced Active Ragdoll Controller Initialized") **How to Use:** 1. Place this script inside `ServerScriptService` within your Roblox place. 2. Ensure the script's parent is the Character model you want to apply it to (e.g., put it directly inside the StarterCharacter model or add it to the character upon joining). 3. **(Optional but Recommended):** Create a Collision Group named "Ragdoll" (or whatever you set `Config.RagdollCollisionGroupName` to) using the `PhysicsService` tools or a script. Configure it so that "Ragdoll" does not collide with itself (`CollisionGroupSetCollidable("Ragdoll", "Ragdoll", false)`) but *does* collide with "Default". This prevents jittery self-collisions. 4. Press 'R' to toggle the ragdoll state while the character is alive. The character will automatically ragdoll upon death. **Key Improvements in this Version:** * **Structure:** Code is organized into `Config`, `State`, `PhysicsUtils`, `BalanceController`, and `RagdollManager` tables for clarity. * **CoM Prediction:** `PhysicsUtils.PredictFutureCoM` estimates where the center of mass will be shortly, making balance reactions more proactive. * **PD Controller for Torso:** `BalanceController.UpdateTorsoCorrection` uses a basic PD control concept (via `AlignOrientation`'s rigidity) for smoother and more stable upright orientation. * **Active Arm Balancing:** `BalanceController.UpdateArmCounterBalancing` uses `AngularVelocity` constraints to make the arms swing slightly to counteract lean, improving stability. * **Dynamic Step Target:** The step target calculation (`BalanceController.UpdateActiveBalance`) is more robust, considering the required correction distance and desired stance width relative to the *stationary* foot. * **Smoother Stepping:** The step update logic uses easing for vertical motion and checks for stability/proximity to complete the step more naturally. * **Refined Foot Planting:** Uses raycasting and smoothing (`AlignPosition.Position:Lerp`) for better ground adaptation. * **Configuration:** Many parameters are now in the `Config` table for easier tuning. * **Joint Limits:** Example of how to apply more specific joint limits from the `Config` table. * **Cleanup:** More robust cleanup functions. * **Delta Time:** Uses `RunService.Stepped`'s delta time correctly for physics calculations. Remember that tuning the values in the `Config` table is crucial to achieve the desired balance behavior for your specific character model and game physics.