Okay, let's enhance the realism of the active balancing ragdoll script. We'll focus on: 1. **More Accurate Center of Mass (CoM):** Include more body parts in the calculation. 2. **Torso/Hip Balancing:** Implement counter-leaning with the torso *before* resorting to stepping. 3. **Improved Stepping Logic:** Base steps more directly on CoM offset and desired stable position, incorporating dynamic stance width. 4. **Basic Arm Balancing:** Add simple arm movements to aid stability. 5. **Refined Foot Planting:** Minor adjustments for stability. 6. **Parameter Tuning:** Adjust values for a more human-like feel. Here's the revised script: --!native -- Place this script inside a StarterCharacterScripts or directly under the Character model 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:FindFirstChild("LeftFoot") local rightFoot = character:FindFirstChild("RightFoot") local userInputService = game:GetService("UserInputService") local runService = game:GetService("RunService") local physicsService = game:GetService("PhysicsService") -- Ensure feet exist if not leftFoot or not rightFoot then warn("Character model missing LeftFoot or RightFoot. Balancing may not work correctly.") -- Attempt to find parts named similarly if standard R15 names aren't used if not leftFoot then leftFoot = character:FindFirstChildWhichIsA("BasePart", true, "Left") end if not rightFoot then rightFoot = character:FindFirstChildWhichIsA("BasePart", true, "Right") end if not leftFoot or not rightFoot then error("Cannot find suitable foot parts for balancing.") end warn("Found potential foot parts:", leftFoot, rightFoot) end humanoid.BreakJointsOnDeath = false humanoid.RequiresNeck = false humanoid.AutoRotate = false -- Disable default humanoid rotation control when ragdolled -- State Variables local isRagdolled = false local jointConstraints = {} -- Stores { constraint, a1, a2, part0, part1, originalC0, originalC1, jointName, jointParent } local physicsConstraints = {} -- Stores active physics constraints (AlignPosition, Torque, VectorForce etc.) local originalCollisions = {} -- Stores { CanCollide, CollisionGroupId, Massless } local ragdollAttachments = {} -- Stores temporary attachments created for constraints local stepConnection = nil local characterMass = 0 -- Active Balancing State local steppingFootName = nil -- "LeftFoot" or "RightFoot" or nil local stepTargetPosition = nil local stepCooldown = 0 -- Timer to prevent rapid steps local stepProgress = 0 -- For smooth step interpolation (0 to 1) local lastSteppedFoot = "RightFoot" -- Track last foot for alternating -- Tuning Parameters for Active Balancing local BALANCE_CoM_UpdateRate = 0.05 -- How often to recalculate CoM (seconds) local lastCoMUpdateTime = 0 local currentCoM = Vector3.zero local currentSupportCenter = Vector3.zero -- Torso Control local BALANCE_Torso_MaxCorrectionTorque = 6000 -- Max torque applied to torso for leaning local BALANCE_Torso_Responsiveness = 25 -- How quickly the torso reacts to lean local BALANCE_Torso_LeanFactor_FB = 1500 -- Multiplier for forward/backward lean torque local BALANCE_Torso_LeanFactor_LR = 1800 -- Multiplier for left/right lean torque -- Arm Control (Simplified) local BALANCE_Arm_MaxCorrectionTorque = 800 -- Max torque for arm adjustments local BALANCE_Arm_Responsiveness = 15 -- How quickly arms react local BALANCE_Arm_SpreadFactor = 500 -- Multiplier for spreading arms laterally -- Stepping Control local BALANCE_Step_TriggerThreshold_FB = 0.6 -- CoM offset (studs) forward/backward before stepping local BALANCE_Step_TriggerThreshold_LR = 0.5 -- CoM offset (studs) left/right before stepping local BALANCE_Step_TargetFactor = 1.1 -- How much to overshoot the CoM projection for stability local BALANCE_Step_DistanceMax = 4 -- Maximum length of a single step local BALANCE_Step_LiftHeight = 0.6 -- How high the foot lifts during a step local BALANCE_Step_Duration = 0.3 -- Target time for a step to complete local BALANCE_Step_Force = 15000 -- Force applied to move the stepping foot local BALANCE_Step_Responsiveness = 80 -- AlignPosition responsiveness for stepping foot local BALANCE_Step_CooldownTime = 0.15 -- Minimum time between steps local BALANCE_Step_CompletionDistance = 0.3 -- How close foot needs to be to target to finish step -- Stance Control local BALANCE_Stance_TargetWidth = 1.8 -- Desired width between feet when stable local BALANCE_Stance_AdjustFactor = 0.5 -- How much stance width changes based on lateral lean -- Foot Planting local BALANCE_FootPlant_ForceFactor = 1.1 -- Multiplier for downward force (relative to character weight) local BALANCE_FootPlant_RayLength = 3.5 -- How far down to check for ground local BALANCE_FootPlant_GroundOffset = 0.05 -- How high above the detected ground to place the foot -- Anti-Gravity / Upright Force local BALANCE_AntiGravity_Factor = 0.99 -- Percentage of gravity to counteract (slightly less than 1 allows settling) local BALANCE_Upright_Torque = 3000 -- Gentle torque to keep root part generally upright -- Store original collision settings and calculate mass local function setupCharacterPhysicsProperties() characterMass = 0 originalCollisions = {} for _, part in pairs(character:GetDescendants()) do if part:IsA("BasePart") then originalCollisions[part] = { CanCollide = part.CanCollide, CollisionGroupId = part.CollisionGroupId, Massless = part.Massless, CustomPhysicalProperties = part.CustomPhysicalProperties } part.Massless = false -- Ensure all parts have mass for accurate CoM characterMass = characterMass + part:GetMass() end end if characterMass <= 0 then characterMass = 20; warn("Character mass calculation failed, using default.") end -- print("Character Mass:", characterMass) end -- Function to clear all ragdoll-related physics constraints and attachments local function clearRagdollPhysics() if stepConnection then stepConnection:Disconnect(); stepConnection = nil end for _, constraint in pairs(physicsConstraints) do if constraint and constraint.Parent then constraint:Destroy() end end physicsConstraints = {} 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 = {} -- Clear the joint data table as well for _, att in pairs(ragdollAttachments) do if att and att.Parent then att:Destroy() end end ragdollAttachments = {} -- Reset balancing state variables steppingFootName = nil stepTargetPosition = nil stepCooldown = 0 stepProgress = 0 lastCoMUpdateTime = 0 currentCoM = rootPart.Position -- Reset to root part position initially currentSupportCenter = rootPart.Position end -- Helper to create and track temporary attachments 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 -- Calculate the Center of Mass (CoM) of the character local function calculateCenterOfMass() local totalMass = 0 local weightedSum = Vector3.zero -- Include major body parts for a more accurate CoM local partsToConsider = { upperTorso, lowerTorso, head, rootPart, character:FindFirstChild("LeftUpperArm"), character:FindFirstChild("LeftLowerArm"), character:FindFirstChild("LeftHand"), character:FindFirstChild("RightUpperArm"), character:FindFirstChild("RightLowerArm"), character:FindFirstChild("RightHand"), character:FindFirstChild("LeftUpperLeg"), character:FindFirstChild("LeftLowerLeg"), leftFoot, character:FindFirstChild("RightUpperLeg"), character:FindFirstChild("RightLowerLeg"), rightFoot } for _, part in pairs(partsToConsider) do if part and part:IsA("BasePart") and not part.Massless then local mass = part:GetMass() if mass > 0 then totalMass = totalMass + mass weightedSum = weightedSum + part.Position * mass end end end -- Fallback if calculation fails if totalMass <= 0 then -- print("CoM calculation failed, using RootPart position.") return rootPart.Position end return weightedSum / totalMass end -- Update foot planting logic local function updateFootPlanting() local down = Vector3.new(0, -1, 0) local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude local footPlantForceMagnitude = characterMass * workspace.Gravity * BALANCE_FootPlant_ForceFactor for _, footName in pairs({"LeftFoot", "RightFoot"}) do local footPart = character:FindFirstChild(footName) if footPart then local forceName = footName .. "_PlantForce" local existingForce = physicsConstraints[forceName] -- Disable planting force if this foot is currently stepping if steppingFootName == footName then if existingForce then existingForce.Enabled = false end continue end local origin = footPart.Position + Vector3.new(0, 0.5, 0) -- Raycast slightly above foot local result = workspace:Raycast(origin, down * BALANCE_FootPlant_RayLength, raycastParams) if result then -- Gently push the foot towards the ground if it's slightly above local groundY = result.Position.Y local currentY = footPart.Position.Y if currentY > groundY + 0.2 then -- Only push down if significantly above ground -- Optional: Could apply a small downward velocity or force instead of direct positioning -- footPart.AssemblyLinearVelocity = footPart.AssemblyLinearVelocity * Vector3.new(1, 0, 1) + Vector3.new(0, -5, 0) end -- Apply downward force to keep foot planted if not existingForce then local force = Instance.new("VectorForce") force.Name = forceName force.Attachment0 = createConstraintAttachment(footPart, "PlantForceAtt") force.RelativeTo = Enum.ActuatorRelativeTo.World force.Force = Vector3.new(0, -footPlantForceMagnitude, 0) force.ApplyAtCenterOfMass = true force.Parent = footPart physicsConstraints[forceName] = force else existingForce.Enabled = true existingForce.Force = Vector3.new(0, -footPlantForceMagnitude, 0) end else -- No ground detected, disable planting force if existingForce then existingForce.Enabled = false end end end end end -- Apply torso and arm balancing torques local function applyCorrectiveTorques(comOffsetXZ, rightXZ, forwardXZ) -- Torso Balancing local torsoTorqueTarget = Vector3.zero local leanFB = comOffsetXZ:Dot(forwardXZ) -- Positive = leaning forward local leanLR = comOffsetXZ:Dot(rightXZ) -- Positive = leaning right -- Apply torque to counter the lean (roll and pitch) torsoTorqueTarget = torsoTorqueTarget - rightXZ * leanFB * BALANCE_Torso_LeanFactor_FB -- Pitch correction torsoTorqueTarget = torsoTorqueTarget + forwardXZ * leanLR * BALANCE_Torso_LeanFactor_LR -- Roll correction -- Apply torso torque using AlignOrientation for smoother control local torsoConstraintName = "TorsoBalanceOrientation" local torsoAlign = physicsConstraints[torsoConstraintName] if not torsoAlign then torsoAlign = Instance.new("AlignOrientation") torsoAlign.Name = torsoConstraintName torsoAlign.Attachment0 = createConstraintAttachment(upperTorso, "TorsoBalanceAtt") torsoAlign.Mode = Enum.OrientationAlignmentMode.OneAttachment torsoAlign.MaxTorque = BALANCE_Torso_MaxCorrectionTorque torsoAlign.Responsiveness = BALANCE_Torso_Responsiveness torsoAlign.PrimaryAxisOnly = false -- Allow correction on multiple axes torsoAlign.Parent = upperTorso physicsConstraints[torsoConstraintName] = torsoAlign end -- Calculate target orientation: Start with current orientation, apply corrective rotation local currentTorsoCF = upperTorso.CFrame local correctionAngleX = math.clamp(leanLR * 0.05, -0.5, 0.5) -- Limit correction angle local correctionAngleZ = math.clamp(-leanFB * 0.05, -0.5, 0.5) local targetCF = CFrame.Angles(correctionAngleX, 0, correctionAngleZ) -- We want the target orientation relative to the world, aiming for upright + correction -- A simpler approach: Apply torque directly based on lean local torqueConstraintName = "TorsoBalanceTorque" local torsoTorque = physicsConstraints[torqueConstraintName] if not torsoTorque then torsoTorque = Instance.new("Torque") torqueConstraintName = "TorsoBalanceTorque" torsoTorque.Name = torqueConstraintName torsoTorque.Attachment0 = createConstraintAttachment(upperTorso, "TorsoBalanceAtt") torsoTorque.RelativeTo = Enum.ActuatorRelativeTo.World torsoTorque.Parent = upperTorso physicsConstraints[torqueConstraintName] = torsoTorque end torsoTorque.Torque = torsoTorqueTarget.Magnitude > BALANCE_Torso_MaxCorrectionTorque and torsoTorqueTarget.Unit * BALANCE_Torso_MaxCorrectionTorque or torsoTorqueTarget -- Arm Balancing (Simple Lateral Spread) local leftShoulder = character:FindFirstChild("LeftUpperArm") and character.LeftUpperArm:FindFirstChild("LeftShoulder") local rightShoulder = character:FindFirstChild("RightUpperArm") and character.RightUpperArm:FindFirstChild("RightShoulder") if leftShoulder and rightShoulder then local armTorque = leanLR * BALANCE_Arm_SpreadFactor -- Positive leanLR (right) -> positive torque on left, negative on right -- Apply torque to left arm (relative to UpperTorso's RightVector) local leftArmTorqueConstraint = physicsConstraints["LeftArmBalanceTorque"] if not leftArmTorqueConstraint then leftArmTorqueConstraint = Instance.new("Torque") leftArmTorqueConstraint.Name = "LeftArmBalanceTorque" leftArmTorqueConstraint.Attachment0 = createConstraintAttachment(character.LeftUpperArm, "ArmBalanceAtt") leftArmTorqueConstraint.RelativeTo = Enum.ActuatorRelativeTo.Attachment0 -- Relative to arm itself might be better leftArmTorqueConstraint.Parent = character.LeftUpperArm physicsConstraints["LeftArmBalanceTorque"] = leftArmTorqueConstraint end -- Torque around the arm's forward axis to lift/lower based on torso's right vector lean local leftTargetTorque = upperTorso.CFrame.LookVector * math.clamp(armTorque, -BALANCE_Arm_MaxCorrectionTorque, BALANCE_Arm_MaxCorrectionTorque) leftArmTorqueConstraint.Torque = leftTargetTorque -- Apply torque to right arm local rightArmTorqueConstraint = physicsConstraints["RightArmBalanceTorque"] if not rightArmTorqueConstraint then rightArmTorqueConstraint = Instance.new("Torque") rightArmTorqueConstraint.Name = "RightArmBalanceTorque" rightArmTorqueConstraint.Attachment0 = createConstraintAttachment(character.RightUpperArm, "ArmBalanceAtt") rightArmTorqueConstraint.RelativeTo = Enum.ActuatorRelativeTo.Attachment0 rightArmTorqueConstraint.Parent = character.RightUpperArm physicsConstraints["RightArmBalanceTorque"] = rightArmTorqueConstraint end -- Torque around the arm's forward axis local rightTargetTorque = upperTorso.CFrame.LookVector * math.clamp(-armTorque, -BALANCE_Arm_MaxCorrectionTorque, BALANCE_Arm_MaxCorrectionTorque) rightArmTorqueConstraint.Torque = rightTargetTorque end end -- Core active balancing logic local function updateActiveBalance(dt) stepCooldown = math.max(0, stepCooldown - dt) -- Update CoM periodically if runService.Heartbeat:Wait() > lastCoMUpdateTime + BALANCE_CoM_UpdateRate then currentCoM = calculateCenterOfMass() lastCoMUpdateTime = runService.Heartbeat:Wait() end if not leftFoot or not rightFoot or not rootPart or not upperTorso then return end -- Ensure parts exist local leftPos = leftFoot.Position local rightPos = rightFoot.Position currentSupportCenter = (leftPos + rightPos) / 2 local groundY = math.min(leftPos.Y, rightPos.Y) -- Approximate ground plane under feet -- Character's orientation vectors (ignoring pitch/roll) local forwardXZ = (rootPart.CFrame.LookVector * Vector3.new(1, 0, 1)).Unit local rightXZ = (rootPart.CFrame.RightVector * Vector3.new(1, 0, 1)).Unit -- CoM position relative to the center of the support base (feet), projected onto the ground plane local comXZ = Vector3.new(currentCoM.X, 0, currentCoM.Z) local supportCenterXZ = Vector3.new(currentSupportCenter.X, 0, currentSupportCenter.Z) local comOffsetXZ = comXZ - supportCenterXZ local offsetForward = comOffsetXZ:Dot(forwardXZ) local offsetRight = comOffsetXZ:Dot(rightXZ) -- 1. Apply Corrective Torques (Torso/Arms) - First line of defense applyCorrectiveTorques(comOffsetXZ, rightXZ, forwardXZ) -- 2. Handle Ongoing Step if steppingFootName then local footPart = character:FindFirstChild(steppingFootName) if footPart and stepTargetPosition then local stepDuration = BALANCE_Step_Duration stepProgress = math.min(stepProgress + dt / stepDuration, 1) local currentFootPos = footPart.Position local targetPos = stepTargetPosition local distToTarget = (Vector3.new(currentFootPos.X, 0, currentFootPos.Z) - Vector3.new(targetPos.X, 0, targetPos.Z)).Magnitude -- Check for step completion local leanCorrected = math.abs(offsetForward) < BALANCE_Step_TriggerThreshold_FB * 0.5 and math.abs(offsetRight) < BALANCE_Step_TriggerThreshold_LR * 0.5 if distToTarget < BALANCE_Step_CompletionDistance or (stepProgress >= 0.95 and leanCorrected) then -- print(steppingFootName, "Step Complete. Dist:", distToTarget, "Progress:", stepProgress, "Lean Corrected:", leanCorrected) local constraintName = steppingFootName .. "_BalanceStep" if physicsConstraints[constraintName] then physicsConstraints[constraintName]:Destroy(); physicsConstraints[constraintName] = nil end lastSteppedFoot = steppingFootName steppingFootName = nil stepTargetPosition = nil stepProgress = 0 -- Ensure foot lands reasonably (optional, planting force should handle this) -- local rayParams = RaycastParams.new(); rayParams.FilterDescendantsInstances = {character}; rayParams.FilterType = Enum.RaycastFilterType.Exclude -- local rayResult = workspace:Raycast(footPart.Position + Vector3.new(0,1,0), Vector3.new(0, -5, 0), rayParams) -- if rayResult then footPart.Position = Vector3.new(footPart.Position.X, rayResult.Position.Y + BALANCE_FootPlant_GroundOffset, footPart.Position.Z) end else -- Update step trajectory (arc) local arcHeight = BALANCE_Step_LiftHeight * math.sin(stepProgress * math.pi) local lerpPos = Vector3.new(targetPos.X, groundY, targetPos.Z) -- Target on ground plane for lerp local currentTargetPos = lerpPos + Vector3.new(0, arcHeight, 0) -- Update AlignPosition target local constraintName = steppingFootName .. "_BalanceStep" local alignPos = physicsConstraints[constraintName] if alignPos then alignPos.Position = currentTargetPos else -- Constraint might have been destroyed unexpectedly, stop step -- print("Warning: Step constraint missing for", steppingFootName) steppingFootName = nil; stepTargetPosition = nil; stepProgress = 0; end end else -- Foot or target became invalid, cancel step -- print("Warning: Stepping foot or target invalid, cancelling step.") local constraintName = steppingFootName .. "_BalanceStep" if physicsConstraints[constraintName] then physicsConstraints[constraintName]:Destroy(); physicsConstraints[constraintName] = nil end steppingFootName = nil stepTargetPosition = nil stepProgress = 0 end return -- Don't try to start a new step while one is in progress end -- 3. Decide if Stepping is Necessary if stepCooldown > 0 then return end -- Wait for cooldown local needsStepFB = math.abs(offsetForward) > BALANCE_Step_TriggerThreshold_FB local needsStepLR = math.abs(offsetRight) > BALANCE_Step_TriggerThreshold_LR if not needsStepFB and not needsStepLR then return end -- Torso correction is sufficient -- Determine which foot to step with (usually the one opposite the lean direction, or alternating) local footToStepPart if needsStepLR then -- If leaning significantly right (offsetRight > threshold), step with right foot -- If leaning significantly left (offsetRight < -threshold), step with left foot footToStepPart = (offsetRight > 0) and rightFoot or leftFoot elseif needsStepFB then -- If leaning mostly forward/backward, alternate feet footToStepPart = (lastSteppedFoot == "LeftFoot") and rightFoot or leftFoot else -- Should not happen based on checks above, but fallback to alternating footToStepPart = (lastSteppedFoot == "LeftFoot") and rightFoot or leftFoot end steppingFootName = footToStepPart.Name stepProgress = 0 -- print("Starting Step:", steppingFootName, "Offset F/B:", offsetForward, "Offset L/R:", offsetRight) -- Calculate Step Target Position local stationaryFoot = (steppingFootName == "LeftFoot") and rightFoot or leftFoot local stationaryPosXZ = Vector3.new(stationaryFoot.Position.X, 0, stationaryFoot.Position.Z) -- Target position based on CoM projection, slightly overshot local targetOffset = comOffsetXZ * BALANCE_Step_TargetFactor -- Limit step distance if targetOffset.Magnitude > BALANCE_Step_DistanceMax then targetOffset = targetOffset.Unit * BALANCE_Step_DistanceMax end -- Desired stance width adjustment based on lateral lean local dynamicStanceWidth = BALANCE_Stance_TargetWidth + math.abs(offsetRight) * BALANCE_Stance_AdjustFactor local stanceOffsetDir = (steppingFootName == "LeftFoot") and -1 or 1 -- -1 for left foot, 1 for right local stanceOffset = rightXZ * stanceOffsetDir * (dynamicStanceWidth / 2) -- Combine projected CoM target with desired stance position relative to *projected* CoM local targetXZ = comXZ + stanceOffset -- Aim to place foot relative to where CoM is going -- Raycast down from target XZ to find ground height local rayOrigin = Vector3.new(targetXZ.X, currentCoM.Y + 2, targetXZ.Z) -- Start raycast above CoM local rayParams = RaycastParams.new(); rayParams.FilterDescendantsInstances = {character}; rayParams.FilterType = Enum.RaycastFilterType.Exclude local rayResult = workspace:Raycast(rayOrigin, Vector3.new(0, -10, 0), rayParams) local targetGroundY = rayResult and rayResult.Position.Y or groundY -- Use current ground if ray fails stepTargetPosition = Vector3.new(targetXZ.X, targetGroundY, targetXZ.Z) -- Final target on the ground -- Create AlignPosition constraint for the step local constraintName = steppingFootName .. "_BalanceStep" local alignPos = Instance.new("AlignPosition") alignPos.Name = constraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(footToStepPart, "BalanceStepAtt") alignPos.MaxForce = BALANCE_Step_Force alignPos.Responsiveness = BALANCE_Step_Responsiveness alignPos.ApplyAtCenterOfMass = true -- Initial target is slightly lifted for the start of the arc local initialArcHeight = BALANCE_Step_LiftHeight * math.sin(0.01 * math.pi) -- Tiny initial lift alignPos.Position = stepTargetPosition + Vector3.new(0, initialArcHeight, 0) alignPos.Parent = footToStepPart alignPos.Enabled = true physicsConstraints[constraintName] = alignPos stepCooldown = BALANCE_Step_CooldownTime -- Set cooldown for the next potential step end -- Function to convert Motor6Ds to BallSocketConstraints local function createRagdollJoints() local createdJoints = {} 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.Parent == character and part1.Parent == character then -- Create attachments at the joint's location local a1 = Instance.new("Attachment") a1.Name = "RagdollJointAttachment" a1.CFrame = joint.C0 a1.Parent = part0 local a2 = Instance.new("Attachment") a2.Name = "RagdollJointAttachment" a2.CFrame = joint.C1 a2.Parent = part1 -- Create BallSocketConstraint local constraint = Instance.new("BallSocketConstraint") constraint.Attachment0 = a1 constraint.Attachment1 = a2 constraint.LimitsEnabled = true constraint.TwistLimitsEnabled = true -- Set limits based on joint name (heuristic) if joint.Name:match("Shoulder") then constraint.UpperAngle = 80 constraint.TwistLowerAngle = -90 constraint.TwistUpperAngle = 90 elseif joint.Name:match("Elbow") then constraint.UpperAngle = 70 constraint.TwistLowerAngle = -10 constraint.TwistUpperAngle = 10 elseif joint.Name:match("Hip") or joint.Name:match("Waist") then constraint.UpperAngle = 50 constraint.TwistLowerAngle = -45 constraint.TwistUpperAngle = 45 elseif joint.Name:match("Knee") then constraint.UpperAngle = 70 constraint.TwistLowerAngle = -5 constraint.TwistUpperAngle = 5 elseif joint.Name:match("Neck") then constraint.UpperAngle = 30 constraint.TwistLowerAngle = -25 constraint.TwistUpperAngle = 25 else -- Default limits constraint.UpperAngle = 45 constraint.TwistLowerAngle = -30 constraint.TwistUpperAngle = 30 end constraint.Parent = part0 -- Parent constraint to one of the parts -- Store constraint info for later removal/restoration table.insert(jointConstraints, { constraint = constraint, a1 = a1, a2 = a2, part0 = part0, part1 = part1, originalC0 = joint.C0, originalC1 = joint.C1, jointName = joint.Name, jointParent = joint.Parent }) table.insert(createdJoints, joint) -- Mark Motor6D for destruction *after* iteration end end end -- Destroy original Motor6Ds after creating constraints for _, joint in pairs(createdJoints) do joint:Destroy() end end -- Function to restore Motor6Ds from BallSocketConstraints local function restoreMotor6Ds() for _, data in pairs(jointConstraints) do -- Destroy the ragdoll constraints and attachments 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 -- Recreate the Motor6D if the parts still exist if data.part0 and data.part0.Parent and data.part1 and data.part1.Parent and data.jointParent and data.jointParent.Parent then local motor = Instance.new("Motor6D") motor.Name = data.jointName motor.Part0 = data.part0 motor.Part1 = data.part1 motor.C0 = data.originalC0 motor.C1 = data.originalC1 motor.Parent = data.jointParent -- Restore to original parent end end jointConstraints = {} -- Clear the stored data end -- Main function to enable ragdoll and balancing local function makeRagdoll() if isRagdolled then return end isRagdolled = true -- print("Making Ragdoll") setupCharacterPhysicsProperties() -- Recalculate mass and store collisions clearRagdollPhysics() -- Clear any previous physics state -- Convert Motor6Ds to BallSocketConstraints createRagdollJoints() -- Set physics properties for ragdoll parts for part, data in pairs(originalCollisions) do if part and part.Parent then part.CanCollide = true -- Enable collisions for most parts part.Massless = false -- Ensure parts have mass -- Optional: Apply custom physical properties if needed -- part.CustomPhysicalProperties = PhysicalProperties.new(density, friction, elasticity, frictionWeight, elasticityWeight) if part == rootPart then part.CanCollide = false -- Keep RootPart non-collidable end end end -- Force humanoid into physics state humanoid:ChangeState(Enum.HumanoidStateType.Physics) -- Apply anti-gravity force to the root part local antiGravForce = Instance.new("VectorForce") antiGravForce.Name = "AntiGravityForce" antiGravForce.Attachment0 = createConstraintAttachment(rootPart, "AntiGravityAtt") antiGravForce.RelativeTo = Enum.ActuatorRelativeTo.World antiGravForce.ApplyAtCenterOfMass = true antiGravForce.Force = Vector3.new(0, characterMass * workspace.Gravity * BALANCE_AntiGravity_Factor, 0) antiGravForce.Parent = rootPart physicsConstraints[antiGravForce.Name] = antiGravForce -- Apply a gentle upright torque to the root part local uprightTorque = Instance.new("AlignOrientation") uprightTorque.Name = "UprightTorque" uprightTorque.Attachment0 = createConstraintAttachment(rootPart, "UprightAtt") uprightTorque.Mode = Enum.OrientationAlignmentMode.OneAttachment uprightTorque.MaxTorque = BALANCE_Upright_Torque uprightTorque.Responsiveness = 5 -- Low responsiveness for gentle correction -- Target orientation is just world CFrame (no rotation) uprightTorque.CFrame = CFrame.new(rootPart.Position) -- Only position matters for Attachment0 CFrame uprightTorque.Parent = rootPart physicsConstraints[uprightTorque.Name] = uprightTorque -- Start the balancing loop stepConnection = runService.Stepped:Connect(function(_, dt) if not isRagdolled then return end -- Stop loop if not ragdolled pcall(function() -- Wrap in pcall for safety updateFootPlanting() updateActiveBalance(dt) end) end) end -- Main function to disable ragdoll and restore character local function resetCharacter() if not isRagdolled then return end isRagdolled = false -- print("Resetting Character") if stepConnection then stepConnection:Disconnect(); stepConnection = nil end clearRagdollPhysics() -- Remove all ragdoll constraints and forces -- Restore original Motor6Ds restoreMotor6Ds() -- Restore original collision and physics properties for part, data in pairs(originalCollisions) do if part and part.Parent then part.CanCollide = data.CanCollide part.Massless = data.Massless part.CustomPhysicalProperties = data.CustomPhysicalProperties end end originalCollisions = {} -- Clear stored data -- Let the humanoid recover humanoid:ChangeState(Enum.HumanoidStateType.GettingUp) task.wait(0.1) -- Short delay before re-enabling auto-rotate if not isRagdolled then -- Check again in case ragdoll was re-enabled quickly humanoid.AutoRotate = true end end -- Event Connections humanoid.Died:Connect(function() if not isRagdolled then task.wait(0.05) -- Short delay after death before ragdolling makeRagdoll() end end) -- Allow manual toggle with 'R' key 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 character is removed character.Destroying:Connect(function() if stepConnection then stepConnection:Disconnect(); stepConnection = nil end clearRagdollPhysics() -- Clean up constraints on character removal -- No need to restore motors if character is destroying end) -- Initial setup setupCharacterPhysicsProperties() -- Calculate mass initially -- print("Realistic Balance Ragdoll Script Initialized.") **Key Improvements in this Version:** 1. **Center of Mass (CoM):** `calculateCenterOfMass` now includes arms and legs for better accuracy. CoM is updated periodically (`BALANCE_CoM_UpdateRate`) instead of every frame for performance. 2. **Torso/Hip Control (`applyCorrectiveTorques`):** Before stepping, the script now applies `Torque` to the `UpperTorso` to counteract leaning (roll and pitch). This simulates using core muscles for balance. 3. **Arm Balancing (`applyCorrectiveTorques`):** Basic arm balancing is added. Torques are applied to the `UpperArm` parts to spread them laterally based on side-to-side lean, mimicking how humans use arms for stability. 4. **Stepping Trigger (`updateActiveBalance`):** Stepping now only occurs if the CoM offset exceeds specific thresholds (`BALANCE_Step_TriggerThreshold_FB/LR`) *after* torso correction has been applied. 5. **Step Target Calculation (`updateActiveBalance`):** * The target position is calculated based on projecting the CoM forward and adjusting for a desired stance width. * `BALANCE_Step_TargetFactor` allows overshooting the CoM projection slightly for better stability. * `BALANCE_Stance_TargetWidth` and `BALANCE_Stance_AdjustFactor` allow the stance width to change dynamically based on how much the character is leaning sideways. * Step distance is capped by `BALANCE_Step_DistanceMax`. 6. **Smoother Step Motion:** The step uses `AlignPosition` but now calculates an arc using `math.sin` based on `stepProgress` and `BALANCE_Step_LiftHeight`. The step aims for a target duration (`BALANCE_Step_Duration`). 7. **Foot Planting (`updateFootPlanting`):** Remains similar but uses a force factor relative to character mass. Raycasting starts slightly higher. 8. **Anti-Gravity & Upright Force:** An `AlignOrientation` is added to the `HumanoidRootPart` to provide a gentle upright force, helping prevent the character from easily tipping over completely when idle. The `VectorForce` counteracts most, but not all, of gravity (`BALANCE_AntiGravity_Factor < 1`) allowing the character to settle. 9. **Motor6D Handling:** `createRagdollJoints` and `restoreMotor6Ds` handle the conversion between Motor6Ds and BallSocketConstraints more robustly, including storing/restoring joint names and parents. Joint limits are now heuristically set based on common joint names. 10. **Parameterization:** Many aspects of the balancing behavior are now controlled by clearly named parameters at the top of the script, making tuning easier. 11. **Robustness:** Added checks for missing parts (like feet), pcall wrap for the main update loop, and cleanup on character destruction. Disabled `Humanoid.AutoRotate` during ragdoll. **How to Use:** 1. Place this script inside `StarterPlayer` -> `StarterCharacterScripts`. 2. Ensure your character model follows standard R15 naming conventions (UpperTorso, LowerTorso, LeftFoot, RightFoot, etc.). If not, the script will try to find parts containing "Left" or "Right" but might fail. 3. Press 'R' to toggle the ragdoll/balancing state while alive. The character will automatically ragdoll on death. **Further Tuning:** * The `BALANCE_` parameters at the top are crucial. You'll likely need to experiment with these values significantly to achieve the desired feel for your specific character and game mechanics. * Pay close attention to the interaction between torso torque (`BALANCE_Torso_...`), arm torque (`BALANCE_Arm_...`), and the stepping thresholds (`BALANCE_Step_TriggerThreshold_...`). The goal is for the character to *try* to balance with its upper body before resorting to a step. * Adjust `BALANCE_Step_Duration`, `BALANCE_Step_Force`, and `BALANCE_Step_Responsiveness` to control the speed and feel of the steps.