Okay, let's significantly enhance this active ragdoll script. We'll focus on: 1. **Robust Reset:** Properly restoring the character's Motor6D joints. 2. **Improved Balancing:** More accurate Center of Mass (CoM), better step prediction, and counter-movement arm swings. 3. **Refined Constraints:** More specific joint limits for realism. 4. **Code Structure:** Better organization and clarity. 5. **Parameter Tuning:** Grouping constants for easier adjustment. Here's the improved version: --[[ Enhanced Active Balancing Ragdoll Script - Improved CoM calculation - Predictive stepping based on CoM and velocity - Counter-movement arm swings - More realistic joint limits - Robust reset mechanism restoring Motor6Ds - Tunable parameters grouped at the top ]] 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 userInputService = game:GetService("UserInputService") local runService = game:GetService("RunService") local physicsService = game:GetService("PhysicsService") humanoid.BreakJointsOnDeath = false humanoid.RequiresNeck = false -- ============================================================ -- CONFIGURATION PARAMETERS (Tune These!) -- ============================================================ local Config = { -- Balancing Thresholds & Parameters LeanThresholdForward = 0.4, -- Forward lean distance before stepping LeanThresholdBackward = 0.35, -- Backward lean distance before stepping LeanThresholdSideways = 0.3, -- Sideways lean distance before stepping StepDistanceFactor = 1.1, -- How far to step relative to lean amount StepUrgencyThreshold = 0.1, -- Minimum combined lean offset to trigger a step StanceWidth = 1.0, -- Desired distance between feet laterally LiftHeight = 0.4, -- Maximum foot lift height during step CoMPredictionFactor = 0.2, -- How much velocity influences predicted CoM (0-1) -- Step Timing & Smoothing StepCooldownTime = 0.5, -- Minimum time between steps StepDuration = 0.6, -- Time to complete a step animation StepCompletionDistance = 0.3, -- How close foot needs to be to target to finish step FootPlantResponsiveness = 25, -- How quickly planted feet stick to ground FootPlantMaxForce = 5000, -- Max force for planted feet sticking StepResponsiveness = 150, -- How quickly stepping foot moves to target StepMaxForce = 8000, -- Max force for stepping foot movement -- Torso & Arm Control TorsoUprightStrength = 40000, -- Base MaxTorque for torso alignment TorsoResponsiveness = 40, -- Base Responsiveness for torso alignment TorsoAggressivenessFactor = 1.5, -- How much torso correction scales with lean (higher = stronger correction when off-balance) ArmSwingStrength = 800, -- MaxTorque for arm swing constraints ArmSwingDamping = 0.1, -- How quickly arm swings return to neutral -- Physics Properties AntiGravityScale = 0.99, -- Percentage of gravity to counteract (1.0 = neutral buoyancy) CharacterDensity = 700, -- Approx density kg/m^3 (affects inertia) - Default is 700 } -- ============================================================ -- STATE VARIABLES -- ============================================================ local isRagdolled = false local jointConstraints = {} -- Stores BallSocketConstraints replacing Motor6Ds local physicsConstraints = {} -- Stores AlignPosition, AlignOrientation, VectorForce etc. local originalCollisions = {} -- Stores original collision settings local originalMotor6Ds = {} -- Stores original Motor6D details for restoration local ragdollAttachments = {} -- Stores dynamically created attachments local stepConnection = nil -- Connection for RunService.Stepped -- Active Balancing State local steppingFootName = nil -- "LeftFoot", "RightFoot", or nil local stepTargetPosition = Vector3.zero local stepStartTime = 0 local stepCooldown = 0 -- Prevents rapid stepping local lastSteppedFoot = "RightFoot" -- Alternates feet -- ============================================================ -- PHYSICS GROUPS (Optional: For finer collision control) -- ============================================================ -- Example: Create a collision group where ragdoll parts don't collide with each other -- physicsService:RegisterCollisionGroup("Ragdoll") -- physicsService:CollisionGroupSetCollidable("Ragdoll", "Ragdoll", false) -- ============================================================ -- UTILITY FUNCTIONS -- ============================================================ local function createConstraintAttachment(parentPart, nameSuffix) local att = Instance.new("Attachment") att.Name = "RagdollAttachment_" .. (nameSuffix or parentPart.Name) att.Parent = parentPart table.insert(ragdollAttachments, att) return att end -- More comprehensive CoM calculation including limbs local function calculateCenterOfMass() local totalMass = 0 local weightedSum = Vector3.zero for _, part in pairs(character:GetDescendants()) do if part:IsA("BasePart") and not part.Massless and part.Name ~= "HumanoidRootPart" then local mass = part:GetMass() totalMass = totalMass + mass weightedSum = weightedSum + (part.Position * mass) end end -- Include HRP position but not its mass if it's massless (common setup) if not rootPart.Massless then local mass = rootPart:GetMass() totalMass = totalMass + mass weightedSum = weightedSum + (rootPart.Position * mass) end return totalMass > 0 and (weightedSum / totalMass) or rootPart.Position end -- Get the other foot's name local function getOtherFoot(footName) return (footName == "LeftFoot") and "RightFoot" or "LeftFoot" end -- Clean up all ragdoll-related instances local function clearRagdollPhysics() if stepConnection then stepConnection:Disconnect() stepConnection = nil end -- Destroy physics constraints (AlignPosition, VectorForce, etc.) for _, constraint in pairs(physicsConstraints) do if constraint and constraint.Parent then constraint:Destroy() end end physicsConstraints = {} -- Destroy joint constraints (BallSocketConstraint) and their attachments for _, data in pairs(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 jointConstraints = {} -- Destroy any remaining dynamically created attachments for _, att in pairs(ragdollAttachments) do if att and att.Parent then att:Destroy() end end ragdollAttachments = {} -- Reset balancing state steppingFootName = nil stepTargetPosition = Vector3.zero stepCooldown = 0 stepStartTime = 0 lastSteppedFoot = "RightFoot" end -- ============================================================ -- RAGDOLL SETUP & TEARDOWN -- ============================================================ local function setupRagdollJoints() local totalMass = 0 originalMotor6Ds = {} -- Clear previous data for _, descendant in pairs(character:GetDescendants()) do if descendant:IsA("BasePart") then -- Store original collision state originalCollisions[descendant] = { CanCollide = descendant.CanCollide, CollisionGroupId = descendant.CollisionGroupId, Massless = descendant.Massless, CustomPhysicalProperties = descendant.CustomPhysicalProperties, } -- Apply ragdoll physics properties descendant.Massless = false descendant.CustomPhysicalProperties = PhysicalProperties.new(Config.CharacterDensity, 0.5, 0.5, 1, 1) -- Density, Friction, Elasticity, FrictionWeight, ElasticityWeight if descendant.Name == "HumanoidRootPart" then descendant.CanCollide = false -- HRP should generally not collide else descendant.CanCollide = true -- Optional: Assign to custom collision group -- physicsService:SetPartCollisionGroup(descendant, "Ragdoll") end if not descendant.Massless then totalMass = totalMass + descendant:GetMass() end elseif descendant:IsA("Motor6D") then local part0 = descendant.Part0 local part1 = descendant.Part1 if part0 and part1 then -- Store original Motor6D info for restoration originalMotor6Ds[descendant.Name .. "_" .. part1.Name] = { Name = descendant.Name, Parent = descendant.Parent, Part0 = part0, Part1 = part1, C0 = descendant.C0, C1 = descendant.C1, MaxVelocity = descendant.MaxVelocity, } -- Create Attachments local a1 = createConstraintAttachment(part0, part1.Name .. "_Attach0") a1.CFrame = descendant.C0 local a2 = createConstraintAttachment(part1, part1.Name .. "_Attach1") a2.CFrame = descendant.C1 -- Create BallSocketConstraint local constraint = Instance.new("BallSocketConstraint") constraint.Name = descendant.Name .. "_Constraint" constraint.Attachment0 = a1 constraint.Attachment1 = a2 constraint.LimitsEnabled = true constraint.TwistLimitsEnabled = true -- === JOINT LIMITS (Customize these based on joint name/location) === local baseName = part1.Name:gsub("Right", ""):gsub("Left", "") -- Get base name like "Foot", "UpperArm" if baseName == "Foot" or baseName == "Hand" then constraint.UpperAngle = 60 constraint.TwistLowerAngle = -45 constraint.TwistUpperAngle = 45 elseif baseName == "LowerLeg" or baseName == "LowerArm" then constraint.UpperAngle = 90 -- More like a hinge, but BallSocket is simpler for now constraint.TwistLowerAngle = -10 constraint.TwistUpperAngle = 10 elseif baseName == "UpperLeg" or baseName == "UpperArm" then constraint.UpperAngle = 110 constraint.TwistLowerAngle = -60 constraint.TwistUpperAngle = 60 elseif baseName == "UpperTorso" then -- Connection to LowerTorso constraint.UpperAngle = 30 constraint.TwistLowerAngle = -25 constraint.TwistUpperAngle = 25 elseif baseName == "Head" then constraint.UpperAngle = 60 constraint.TwistLowerAngle = -40 constraint.TwistUpperAngle = 40 else -- Default fallback constraint.UpperAngle = 45 constraint.TwistLowerAngle = -30 constraint.TwistUpperAngle = 30 end constraint.Restitution = 0.1 -- Reduce bounciness constraint.Parent = part0 -- Parent to Part0 for organization table.insert(jointConstraints, { constraint = constraint, a1 = a1, a2 = a2, }) descendant.Enabled = false -- Disable Motor6D instead of destroying end end end return totalMass end local function setupPhysicsConstraints(totalMass) -- Anti-Gravity Force (applied to RootPart for stability) local antiGravityForce = Instance.new("VectorForce") antiGravityForce.Name = "AntiGravityForce" antiGravityForce.Attachment0 = createConstraintAttachment(rootPart, "AntiGravityAtt") antiGravityForce.RelativeTo = Enum.ActuatorRelativeTo.World antiGravityForce.ApplyAtCenterOfMass = true antiGravityForce.Force = Vector3.new(0, totalMass * workspace.Gravity * Config.AntiGravityScale, 0) antiGravityForce.Parent = rootPart physicsConstraints[antiGravityForce.Name] = antiGravityForce -- Torso Upright Alignment if upperTorso then local torsoAlign = Instance.new("AlignOrientation") torsoAlign.Name = "UpperTorso_Align" torsoAlign.Attachment0 = createConstraintAttachment(upperTorso, "TorsoAlignAtt") torsoAlign.Mode = Enum.OrientationAlignmentMode.OneAttachment torsoAlign.MaxTorque = Config.TorsoUprightStrength torsoAlign.Responsiveness = Config.TorsoResponsiveness torsoAlign.PrimaryAxisOnly = false -- Align all axes initially -- Set initial target orientation (upright, facing rootpart's direction) local initialLookVector = rootPart.CFrame.LookVector local initialUpVector = Vector3.yAxis local initialRightVector = initialLookVector:Cross(initialUpVector).Unit initialLookVector = initialUpVector:Cross(initialRightVector).Unit -- Ensure orthogonality torsoAlign.CFrame = CFrame.fromMatrix(Vector3.zero, initialRightVector, initialUpVector, -initialLookVector) torsoAlign.Parent = upperTorso physicsConstraints[torsoAlign.Name] = torsoAlign end -- Foot Planting Constraints (created dynamically in updateFootPlanting) -- Arm Swing Constraints for _, armName in pairs({"LeftUpperArm", "RightUpperArm"}) do local arm = character:FindFirstChild(armName) if arm then local av = Instance.new("AngularVelocity") av.Name = armName .. "_Swing" av.Attachment0 = createConstraintAttachment(arm, "SwingAtt") av.RelativeTo = Enum.ActuatorRelativeTo.Attachment0 av.MaxTorque = Config.ArmSwingStrength av.AngularVelocity = Vector3.zero -- Start neutral av.Parent = arm physicsConstraints[av.Name] = av end end end local function makeRagdoll() if isRagdolled then return end isRagdolled = true print("Ragdolling...") clearRagdollPhysics() -- Ensure clean state local totalMass = setupRagdollJoints() setupPhysicsConstraints(totalMass) humanoid:ChangeState(Enum.HumanoidStateType.Physics) -- Start the balancing loop stepConnection = runService.Stepped:Connect(updateBalancingLoop) end local function resetCharacter() if not isRagdolled then return end isRagdolled = false print("Resetting Character...") clearRagdollPhysics() -- Stop loop and destroy constraints/attachments -- Restore original Motor6Ds for _, data in pairs(originalMotor6Ds) do local motor = data.Parent:FindFirstChild(data.Name) if motor and motor:IsA("Motor6D") then motor.Enabled = true -- Re-enable the existing motor -- Optional: Restore other properties if needed, though usually not necessary -- motor.C0 = data.C0 -- motor.C1 = data.C1 -- motor.Part0 = data.Part0 -- motor.Part1 = data.Part1 else -- If motor was somehow destroyed, recreate it (less ideal) warn("Motor6D not found, recreating:", data.Name) local newMotor = Instance.new("Motor6D") newMotor.Name = data.Name newMotor.Part0 = data.Part0 newMotor.Part1 = data.Part1 newMotor.C0 = data.C0 newMotor.C1 = data.C1 newMotor.MaxVelocity = data.MaxVelocity newMotor.Parent = data.Parent end end originalMotor6Ds = {} -- Clear stored data -- Restore original collision settings for part, data in pairs(originalCollisions) do if part and part.Parent then part.CanCollide = data.CanCollide part.CollisionGroupId = data.CollisionGroupId part.Massless = data.Massless part.CustomPhysicalProperties = data.CustomPhysicalProperties -- Optional: Reset collision group if changed -- physicsService:SetPartCollisionGroup(part, "Default") end end originalCollisions = {} humanoid:ChangeState(Enum.HumanoidStateType.GettingUp) task.wait(0.1) -- Short delay before allowing movement again humanoid:ChangeState(Enum.HumanoidStateType.Running) -- Or Idle, depending on context end -- ============================================================ -- BALANCING SUB-SYSTEMS -- ============================================================ local function updateFootPlanting() local down = Vector3.yAxis * -5 -- Raycast down 5 studs local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude raycastParams.IgnoreWater = true for _, footName in pairs({"LeftFoot", "RightFoot"}) do local footPart = character:FindFirstChild(footName) if not footPart then continue end local plantConstraintName = footName .. "_Plant" local alignPos = physicsConstraints[plantConstraintName] -- Create constraint if it doesn't exist if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = plantConstraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(footPart, "PlantAtt") alignPos.MaxForce = Config.FootPlantMaxForce alignPos.Responsiveness = Config.FootPlantResponsiveness alignPos.ApplyAtCenterOfMass = true -- Apply force more naturally alignPos.Parent = footPart physicsConstraints[plantConstraintName] = alignPos end -- Disable planting for the stepping foot if steppingFootName == footName then alignPos.Enabled = false else -- Raycast downwards to find ground local origin = footPart.Position + Vector3.yAxis * 0.5 -- Start ray slightly above foot local result = workspace:Raycast(origin, down, raycastParams) if result then local groundPos = result.Position local targetPos = groundPos + Vector3.yAxis * 0.05 -- Target slightly above ground -- Smoothly move towards the target position alignPos.Position = alignPos.Position:Lerp(targetPos, 0.5) -- Adjust Lerp factor for desired stickiness alignPos.Enabled = true else -- No ground detected, disable planting alignPos.Enabled = false end end end end local function updateTorsoCorrection() local torsoAlign = physicsConstraints["UpperTorso_Align"] if not torsoAlign or not upperTorso then return end -- Calculate lean amount (dot product with world up vector) local currentUp = upperTorso.CFrame.UpVector local uprightDot = currentUp:Dot(Vector3.yAxis) -- 1 = perfectly upright, 0 = horizontal, -1 = upside down local leanAmount = 1.0 - math.max(0, uprightDot) -- 0 = upright, 1 = horizontal or more -- Dynamically adjust strength based on lean local responsiveness = Config.TorsoResponsiveness + leanAmount * Config.TorsoResponsiveness * Config.TorsoAggressivenessFactor local maxTorque = Config.TorsoUprightStrength + leanAmount * Config.TorsoUprightStrength * Config.TorsoAggressivenessFactor torsoAlign.Responsiveness = responsiveness torsoAlign.MaxTorque = maxTorque -- Target Orientation: Keep torso upright relative to world, facing root part's direction local targetLook = rootPart.CFrame.LookVector local targetUp = Vector3.yAxis local targetRight = targetLook:Cross(targetUp).Unit targetLook = targetUp:Cross(targetRight).Unit -- Ensure orthogonal local targetCFrame = CFrame.fromMatrix(Vector3.zero, targetRight, targetUp, -targetLook) -- Apply the target CFrame (AlignOrientation handles the interpolation) torsoAlign.CFrame = targetCFrame end local function updateArmSwings(stepDirFB, stepDirLR) local leftArmAV = physicsConstraints["LeftUpperArm_Swing"] local rightArmAV = physicsConstraints["RightUpperArm_Swing"] local targetLeftVel = Vector3.zero local targetRightVel = Vector3.zero if steppingFootName then -- Determine swing direction based on which foot is stepping and step direction local swingMagnitude = 2.0 -- Adjust magnitude as needed -- Forward/Backward Swing (Counter movement) if steppingFootName == "LeftFoot" then targetRightVel = targetRightVel + upperTorso.CFrame.RightVector * stepDirFB * swingMagnitude * -1 -- Right arm forward/back else -- Stepping with RightFoot targetLeftVel = targetLeftVel + upperTorso.CFrame.RightVector * stepDirFB * swingMagnitude * 1 -- Left arm forward/back end -- Sideways Swing (Less pronounced, helps balance lateral movement) -- Arms swing slightly away from the direction of lateral step if stepDirLR ~= 0 then targetLeftVel = targetLeftVel + upperTorso.CFrame.LookVector * stepDirLR * swingMagnitude * 0.5 targetRightVel = targetRightVel + upperTorso.CFrame.LookVector * stepDirLR * swingMagnitude * -0.5 end end -- Apply damping (Lerp towards zero when not actively swinging) if leftArmAV then leftArmAV.AngularVelocity = leftArmAV.AngularVelocity:Lerp(targetLeftVel, Config.ArmSwingDamping) end if rightArmAV then rightArmAV.AngularVelocity = rightArmAV.AngularVelocity:Lerp(targetRightVel, Config.ArmSwingDamping) end end local function updateActiveBalance(dt) stepCooldown = math.max(0, stepCooldown - dt) local leftFoot = character:FindFirstChild("LeftFoot") local rightFoot = character:FindFirstChild("RightFoot") if not leftFoot or not rightFoot or not rootPart or not upperTorso then return end -- 1. Calculate Center of Mass (CoM) and Support Base local com = calculateCenterOfMass() local leftPos = leftFoot.Position local rightPos = rightFoot.Position local avgFootPos = (leftPos + rightPos) * 0.5 local groundY = math.min(leftPos.Y, rightPos.Y) -- Approximate ground plane -- 2. Project CoM and calculate offset from support base center local comXZ = Vector3.new(com.X, 0, com.Z) local avgFootXZ = Vector3.new(avgFootPos.X, 0, avgFootPos.Z) local offsetVector = comXZ - avgFootXZ -- 3. Predict future CoM based on velocity local velocityXZ = Vector3.new(rootPart.AssemblyLinearVelocity.X, 0, rootPart.AssemblyLinearVelocity.Z) local predictedOffset = offsetVector + velocityXZ * Config.CoMPredictionFactor -- 4. Determine lean relative to character's orientation local forwardDir = rootPart.CFrame.LookVector:Cross(Vector3.yAxis).Unit:Cross(Vector3.yAxis) -- Projected LookVector on XZ plane local rightDir = rootPart.CFrame.RightVector:Cross(Vector3.yAxis).Unit:Cross(Vector3.yAxis) -- Projected RightVector on XZ plane local leanForward = predictedOffset:Dot(forwardDir) local leanRight = predictedOffset:Dot(rightDir) -- 5. Handle Ongoing Step if steppingFootName then local footPart = character:FindFirstChild(steppingFootName) local stepConstraint = physicsConstraints[steppingFootName .. "_BalanceStep"] if footPart and stepConstraint then local stepDuration = Config.StepDuration local timeElapsed = workspace:GetServerTimeNow() - stepStartTime local progress = math.clamp(timeElapsed / stepDuration, 0, 1) -- S-curve (smoothstep) for vertical movement local verticalProgress = progress * progress * (3 - 2 * progress) local currentLift = math.sin(verticalProgress * math.pi) * Config.LiftHeight -- Calculate current target position with lift local currentTargetPos = stepTargetPosition + Vector3.yAxis * currentLift -- Smoothly move the AlignPosition target stepConstraint.Position = stepConstraint.Position:Lerp(currentTargetPos, 0.2) -- Adjust lerp for responsiveness -- Check for step completion local distToTargetPlane = (Vector3.new(footPart.Position.X, 0, footPart.Position.Z) - Vector3.new(stepTargetPosition.X, 0, stepTargetPosition.Z)).Magnitude local isBalancedEnough = math.abs(leanForward) < Config.LeanThresholdForward * 0.7 and math.abs(leanRight) < Config.LeanThresholdSideways * 0.7 if progress >= 0.95 and (distToTargetPlane < Config.StepCompletionDistance or isBalancedEnough) then -- Finish step stepConstraint.Enabled = false -- Disable step force lastSteppedFoot = steppingFootName steppingFootName = nil stepTargetPosition = Vector3.zero stepCooldown = Config.StepCooldownTime -- Start cooldown for next step print("Step completed:", lastSteppedFoot) end else -- Something went wrong (foot or constraint missing), cancel step if stepConstraint then stepConstraint.Enabled = false end steppingFootName = nil stepTargetPosition = Vector3.zero print("Step cancelled") end updateArmSwings(leanForward, leanRight) -- Continue arm swing during step return -- Don't evaluate for new step while one is in progress end -- 6. Decide if a Step is Needed (if not cooling down) if stepCooldown > 0 then updateArmSwings(0, 0) -- Dampen arm swings when standing return end local stepUrgency = 0 local stepDirFB = 0 -- Forward/Backward direction (+1 forward, -1 backward) local stepDirLR = 0 -- Left/Right direction (+1 right, -1 left) if leanForward > Config.LeanThresholdForward then stepDirFB = 1 stepUrgency = stepUrgency + (leanForward - Config.LeanThresholdForward) elseif leanForward < -Config.LeanThresholdBackward then stepDirFB = -1 stepUrgency = stepUrgency + (-leanForward - Config.LeanThresholdBackward) end if leanRight > Config.LeanThresholdSideways then stepDirLR = 1 stepUrgency = stepUrgency + (leanRight - Config.LeanThresholdSideways) elseif leanRight < -Config.LeanThresholdSideways then stepDirLR = -1 stepUrgency = stepUrgency + (-leanRight - Config.LeanThresholdSideways) end -- 7. Initiate Step if Urgent Enough if stepUrgency > Config.StepUrgencyThreshold then -- Choose foot to step with (alternate) local footToStepName = getOtherFoot(lastSteppedFoot) local footToStepPart = character:FindFirstChild(footToStepName) local stationaryFootName = lastSteppedFoot local stationaryFootPart = character:FindFirstChild(stationaryFootName) if not footToStepPart or not stationaryFootPart then return end -- Safety check steppingFootName = footToStepName stepStartTime = workspace:GetServerTimeNow() print("Starting step:", steppingFootName, "DirFB:", stepDirFB, "DirLR:", stepDirLR) -- Calculate step target position local stepLength = math.abs(leanForward) * Config.StepDistanceFactor local stepWidth = math.abs(leanRight) * Config.StepDistanceFactor -- Base target relative to stationary foot, considering desired stance width local targetOffset = forwardDir * stepDirFB * stepLength + rightDir * stepDirLR * stepWidth local stanceOffset = rightDir * ((steppingFootName == "LeftFoot") and -1 or 1) * (Config.StanceWidth / 2) local stationaryFootXZ = Vector3.new(stationaryFootPart.Position.X, 0, stationaryFootPart.Position.Z) local targetXZ = stationaryFootXZ + targetOffset + stanceOffset * 2 -- Aim for full stance width from stationary foot -- Raycast down from target XZ to find ground height local rayOrigin = Vector3.new(targetXZ.X, com.Y + 2, targetXZ.Z) -- Start raycast high up local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude local result = workspace:Raycast(rayOrigin, Vector3.yAxis * -10, raycastParams) local targetY = result and result.Position.Y or groundY -- Use current groundY as fallback stepTargetPosition = Vector3.new(targetXZ.X, targetY, targetXZ.Z) -- Get or create the AlignPosition constraint for the step local constraintName = steppingFootName .. "_BalanceStep" local alignPos = physicsConstraints[constraintName] if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = constraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment -- Ensure attachment exists or create it local att = footToStepPart:FindFirstChild("RagdollAttachment_BalanceStepAtt") or createConstraintAttachment(footToStepPart, "BalanceStepAtt") alignPos.Attachment0 = att alignPos.MaxForce = Config.StepMaxForce alignPos.Responsiveness = Config.StepResponsiveness alignPos.ApplyAtCenterOfMass = true alignPos.Parent = footToStepPart physicsConstraints[constraintName] = alignPos end -- Initialize position slightly towards current foot pos for smoother start alignPos.Position = footToStepPart.Position:Lerp(stepTargetPosition + Vector3.yAxis * Config.LiftHeight * 0.5, 0.1) alignPos.Enabled = true updateArmSwings(stepDirFB, stepDirLR) -- Start arm swing immediately else -- Not stepping, dampen arm swings updateArmSwings(0, 0) end end -- ============================================================ -- MAIN UPDATE LOOP (Called by RunService.Stepped) -- ============================================================ local function updateBalancingLoop(dt) if not isRagdolled then return end -- Should not happen if connection is managed properly, but safety first -- Order matters: Plant feet first, then correct torso, then decide/update steps updateFootPlanting() updateTorsoCorrection() updateActiveBalance(dt) -- Optional: Update Anti-Gravity if mass changes (unlikely unless parts are added/removed) -- local antiGrav = physicsConstraints["AntiGravityForce"] -- if antiGrav then antiGrav.Force = Vector3.new(0, totalMass * workspace.Gravity * Config.AntiGravityScale, 0) end end -- ============================================================ -- EVENT HANDLERS -- ============================================================ humanoid.Died:Connect(function() if not isRagdolled then task.wait(0.05) -- Short delay after death event makeRagdoll() -- Optional: Disable balancing updates on death? Or let it try to stand? -- if stepConnection then stepConnection:Disconnect() stepConnection = nil end end end) -- Allow toggling ragdoll state with 'R' key (only if alive) userInputService.InputBegan:Connect(function(input, gameProcessed) if not gameProcessed and input.UserInputType == Enum.UserInputType.Keyboard then if input.KeyCode == Enum.KeyCode.R and humanoid.Health > 0 then if isRagdolled then resetCharacter() else makeRagdoll() end end end end) -- Clean up when the script is removed script.Destroying:Connect(function() if isRagdolled then resetCharacter() -- Attempt to restore character state end clearRagdollPhysics() -- Final cleanup end) -- Initial state check (e.g., if character spawns dead) if humanoid:GetState() == Enum.HumanoidStateType.Dead then task.wait(0.1) -- Wait a moment for character setup if humanoid.Health <= 0 then -- Double check health makeRagdoll() end end **Key Improvements:** 1. **`resetCharacter` Fix:** Now correctly stores `Motor6D` data and re-enables them instead of destroying/relying on BallSockets alone. It also restores original collision properties. 2. **`setupRagdollJoints`:** Disables `Motor6D`s instead of destroying them. Stores original properties. Applies more specific (though still approximate) joint limits based on part names. Sets `CustomPhysicalProperties` for density. 3. **CoM Calculation:** Includes all non-massless `BasePart` descendants for better accuracy. 4. **`updateActiveBalance`:** * Uses the more accurate CoM. * Includes velocity prediction (`predictedOffset`). * Calculates lean relative to the character's forward/right directions. * Step target calculation considers desired `StanceWidth` relative to the *stationary* foot. * Step completion check is slightly refined. * Calls `updateArmSwings`. 5. **`updateArmSwings`:** Implements basic counter-movement logic based on the stepping foot and direction. Uses `AngularVelocity` constraints. Includes damping to return arms to neutral. 6. **`updateTorsoCorrection`:** Target orientation calculation is more robust. Dynamic strength adjustment based on lean amount. 7. **`updateFootPlanting`:** Uses `AlignPosition` for planted feet, raycasting down to find the ground. Disabled for the stepping foot. 8. **Configuration:** All major tuning parameters are grouped in the `Config` table at the top. 9. **Structure:** Functions are grouped logically (Utils, Setup/Teardown, Balancing Sub-systems, Main Loop, Event Handlers). 10. **Cleanup:** Added `script.Destroying` connection for better cleanup if the script is removed during gameplay. **How to Use:** 1. Place this script inside `StarterPlayer` -> `StarterCharacterScripts`. It will be copied to each character when they spawn. 2. **Tune the `Config` table!** The default values are starting points. You will likely need to adjust thresholds, forces, responsiveness, and timing significantly based on your character model, desired stability, and game physics. Experimentation is key. 3. Press 'R' to toggle the ragdoll state while the character is alive. The character will automatically ragdoll on death.