Okay, let's enhance the script by introducing stiffness control and refining the balancing accuracy. We'll add: 1. **Stiffness Control:** Using `AlignOrientation` on the `LowerTorso` and potentially adjusting the existing `UpperTorso` alignment to simulate muscle tension resisting forces. 2. **Hip Stabilization:** An `AlignOrientation` constraint specifically for the `LowerTorso` to keep it more level relative to the world, providing a more stable base for the upper body. 3. **Refined Parameter Tuning:** Adjust some constants for better interaction with the new stiffness. 4. **Smoother Transitions:** Ensure stiffness forces blend well with the balancing reactions. --[[ Improved Roblox Character Balancing Script Inspired by Euphoria physics. Features: - Active ragdoll state toggled with 'R' key. - Dynamic torso stabilization using AlignOrientation. - Predictive stepping based on Center of Mass (COM) offset and velocity. - Active arm balancing using AngularVelocity. - Foot planting to keep feet grounded when not stepping. - Smoother motion using Lerp and dynamic parameter adjustments. - Hip stabilization for a more robust core. - Basic joint stiffness simulation via AlignOrientation torques. ]] local character = script.Parent local humanoid = character:WaitForChild("Humanoid") local rootPart = character:WaitForChild("HumanoidRootPart") local upperTorso = character:FindFirstChild("UpperTorso") local lowerTorso = character:FindFirstChild("LowerTorso") local head = character:FindFirstChild("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") humanoid.BreakJointsOnDeath = false humanoid.RequiresNeck = false -- Often disabled for custom ragdolls -- ============================================================ -- STATE VARIABLES & CONSTANTS -- ============================================================ local isRagdolled = false local jointConstraints = {} -- Stores BallSocketConstraints replacing Motor6Ds local physicsConstraints = {} -- Stores AlignPosition, AlignOrientation, VectorForce etc. local originalCollisions = {} -- Stores original collision settings of parts local ragdollAttachments = {} -- Stores attachments created for constraints local stepConnection = nil -- Connection for the RunService.Stepped event -- Active Balancing State local steppingFootName = nil -- "LeftFoot", "RightFoot", or nil local stepTargetPosition = nil -- Where the stepping foot is aiming local stepCooldown = 0 -- Prevents rapid, jittery stepping local stepProgress = 0 -- [0,1] normalized progress of the current step local lastSteppedFoot = "RightFoot" -- Start by assuming the right foot was last planted local isStumbling = false -- Flag for quick follow-up steps -- Timing & Distance Constants (Adjust these for feel) local STEP_COOLDOWN_TIME = 0.35 -- Base time between steps local STUMBLE_COOLDOWN_TIME = 0.15 -- Faster cooldown if stumbling local STEP_DURATION = 0.30 -- Time to complete a step animation local STEP_COMPLETION_DISTANCE = 0.3 -- How close foot needs to be to target to finish step local STEP_MAX_REACH = 4.0 -- Maximum distance a step will target -- Balancing Thresholds & Parameters (Crucial for tuning the feel) local BALANCE_LeanThreshold_FB = 0.28 -- Forward/backward lean distance before stepping (Increased slightly) local BALANCE_LeanThreshold_LR = 0.22 -- Left/right lean distance before stepping (Increased slightly) local BALANCE_VelocityPredictionFactor = 0.25 -- How much velocity influences predicted lean (Slightly more predictive) local BALANCE_StepDistanceFactor = 1.15 -- Multiplier for how far to step based on lean (Step slightly further) local BALANCE_StepForce = 9000 -- Force applied to move the stepping foot (Increased) local BALANCE_StepResponsiveness = 90 -- How quickly the foot moves to the target (Increased) local BALANCE_StanceWidth = 1.1 -- Desired distance between feet laterally (Slightly wider) local BALANCE_LiftHeight = 0.45 -- How high the foot lifts during a step arc -- Smoothing & Damping Factors (Lower = smoother/slower response) local TORSO_LERP_BASE = 0.10 -- Base interpolation factor for torso upright correction (Slightly slower base) local TORSO_LERP_AGGRESSION = 0.35 -- How much the Lerp factor increases when heavily leaned local HIP_LERP_FACTOR = 0.15 -- Interpolation for hip leveling (Relatively responsive) local ARM_LERP_FACTOR = 0.06 -- Interpolation for arm balancing movements local ARM_SWING_INTENSITY = 18 -- How strongly arms swing out to counterbalance lean (Increased) local FOOT_PLANT_RESPONSIVENESS = 30 -- How quickly planted feet stick to the ground (Increased) local FOOT_PLANT_MAX_FORCE = 6000 -- Force keeping planted feet down (Increased) local COM_SMOOTHING = 0.1 -- Damping factor for Center of Mass calculation (reduces jitter) -- Stiffness Parameters local STIFFNESS_TORSO_MAX_TORQUE = 40000 -- Max torque for upper torso alignment (Increased) local STIFFNESS_TORSO_RESPONSIVENESS = 60 -- Base responsiveness for upper torso local STIFFNESS_HIP_MAX_TORQUE = 35000 -- Max torque for hip leveling (NEW) local STIFFNESS_HIP_RESPONSIVENESS = 70 -- Responsiveness for hip leveling (NEW) local STIFFNESS_AGGRESSION_FACTOR = 150 -- How much responsiveness increases when leaned -- Anti-Gravity Force Multiplier (Slightly less than 1 to keep feet on ground) local ANTI_GRAVITY_MULTIPLIER = 0.985 -- ============================================================ -- SAVE ORIGINAL COLLISION SETTINGS -- ============================================================ local function saveOriginalCollisions() 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 parts have mass for physics end end end saveOriginalCollisions() -- Save initially -- ============================================================ -- UTILITY FUNCTIONS -- ============================================================ -- Cleans up all created 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 = {} for _, att in pairs(ragdollAttachments) do if att and att.Parent then att:Destroy() end end ragdollAttachments = {} steppingFootName = nil stepTargetPosition = nil stepCooldown = 0 stepProgress = 0 isStumbling = false end -- Creates an attachment safely and stores it for cleanup 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 -- Calculates a smoothed Center of Mass (COM) local lastCOM = rootPart.Position local function calculateSmoothedCenterOfMass() local totalMass = 0 local weightedSum = Vector3.new(0, 0, 0) -- Include major body parts for COM calculation local partsToConsider = { upperTorso, lowerTorso, head, rootPart, character:FindFirstChild("LeftUpperLeg"), character:FindFirstChild("RightUpperLeg"), character:FindFirstChild("LeftUpperArm"), character:FindFirstChild("RightUpperArm")} for _, part in pairs(partsToConsider) 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 currentCOM = rootPart.Position -- Fallback if totalMass > 0 then currentCOM = weightedSum / totalMass end -- Smooth the COM using Lerp to reduce jitter lastCOM = lastCOM:Lerp(currentCOM, COM_SMOOTHING) return lastCOM end -- Raycast downwards to find ground position, ignoring the character local groundRaycastParams = RaycastParams.new() groundRaycastParams.FilterType = Enum.RaycastFilterType.Exclude groundRaycastParams.FilterDescendantsInstances = {character} local function findGroundY(position) local result = workspace:Raycast(position + Vector3.new(0, 2, 0), Vector3.new(0, -12, 0), groundRaycastParams) -- Increased range slightly return result and result.Position.Y end -- ============================================================ -- FOOT PLANTING (Keeps non-stepping foot grounded) -- ============================================================ local function updateFootPlanting() for _, footName in pairs({"LeftFoot", "RightFoot"}) do local footPart = character:FindFirstChild(footName) if footPart then local plantConstraintName = footName .. "_Plant" local alignPos = physicsConstraints[plantConstraintName] if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = plantConstraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(footPart, "PlantAtt") alignPos.MaxForce = FOOT_PLANT_MAX_FORCE alignPos.Responsiveness = FOOT_PLANT_RESPONSIVENESS alignPos.ApplyAtCenterOfMass = true -- Apply force smoothly alignPos.Parent = footPart physicsConstraints[plantConstraintName] = alignPos end -- Enable planting only if the foot is NOT the one currently stepping if steppingFootName == footName then alignPos.Enabled = false else local groundY = findGroundY(footPart.Position) if groundY then -- Target slightly above ground to prevent sinking local targetPos = Vector3.new(footPart.Position.X, groundY + 0.05, footPart.Position.Z) -- Lower target slightly -- Smoothly move towards the target position alignPos.Position = alignPos.Position:Lerp(targetPos, 0.6) -- Lerp for smoother planting (slightly faster) alignPos.Enabled = true else -- No ground detected, disable planting alignPos.Enabled = false end end end end end -- ============================================================ -- DYNAMIC TORSO & HIP CORRECTION (Stiffness and Stability) -- ============================================================ local function updateBodyCorrection(dt, leanAmount) -- --- Upper Torso Alignment (Uprightness) --- if upperTorso then local torsoAlign = physicsConstraints["UpperTorso_Align"] if torsoAlign then -- Dynamically adjust responsiveness and interpolation based on lean local aggressionFactor = leanAmount * leanAmount -- Square it to make correction stronger when heavily leaned local currentLerpFactor = math.clamp(TORSO_LERP_BASE + aggressionFactor * TORSO_LERP_AGGRESSION, TORSO_LERP_BASE, 0.7) -- Allow slightly higher max lerp local currentResponsiveness = math.clamp(STIFFNESS_TORSO_RESPONSIVENESS + aggressionFactor * STIFFNESS_AGGRESSION_FACTOR, STIFFNESS_TORSO_RESPONSIVENESS, 200) -- Increase responsiveness when needed -- Target orientation: Upright, facing the same direction as the root part local targetLook = rootPart.CFrame.LookVector local targetUp = Vector3.new(0, 1, 0) local targetRight = targetLook:Cross(targetUp).Unit targetLook = targetUp:Cross(targetRight).Unit -- Ensure orthogonality local targetCFrame = CFrame.fromMatrix(upperTorso.Position, targetRight, targetUp, -targetLook) -- Apply smoothed orientation target torsoAlign.CFrame = torsoAlign.CFrame:Lerp(targetCFrame, currentLerpFactor) torsoAlign.Responsiveness = currentResponsiveness torsoAlign.MaxTorque = math.clamp(STIFFNESS_TORSO_MAX_TORQUE + aggressionFactor * 50000, STIFFNESS_TORSO_MAX_TORQUE, 90000) -- Increase max torque when leaned end end -- --- Hip Alignment (Leveling) --- if lowerTorso then local hipAlign = physicsConstraints["LowerTorso_Align"] if hipAlign then -- Target orientation: Keep the hip's UpVector aligned with World Up, but allow rotation around Y local currentHipCF = lowerTorso.CFrame local targetHipLook = currentHipCF.LookVector * Vector3.new(1, 0, 1) -- Keep current look direction (XZ plane) if targetHipLook.Magnitude < 0.01 then targetHipLook = rootPart.CFrame.LookVector end -- Fallback if looking straight up/down targetHipLook = targetHipLook.Unit local targetHipUp = Vector3.new(0, 1, 0) local targetHipRight = targetHipLook:Cross(targetHipUp).Unit targetHipLook = targetHipUp:Cross(targetHipRight).Unit -- Ensure orthogonality local targetHipCFrame = CFrame.fromMatrix(currentHipCF.Position, targetHipRight, targetHipUp, -targetHipLook) -- Apply smoothed orientation target hipAlign.CFrame = hipAlign.CFrame:Lerp(targetHipCFrame, HIP_LERP_FACTOR) -- Use a dedicated lerp factor for hips -- Adjust responsiveness based on lean, but maybe less aggressively than torso local hipAggressionFactor = leanAmount -- Linear aggression for hips local currentHipResponsiveness = math.clamp(STIFFNESS_HIP_RESPONSIVENESS + hipAggressionFactor * STIFFNESS_AGGRESSION_FACTOR * 0.5, STIFFNESS_HIP_RESPONSIVENESS, 150) hipAlign.Responsiveness = currentHipResponsiveness hipAlign.MaxTorque = math.clamp(STIFFNESS_HIP_MAX_TORQUE + hipAggressionFactor * 40000, STIFFNESS_HIP_MAX_TORQUE, 75000) end end end -- ============================================================ -- ACTIVE ARM BALANCING (Swing arms to counter lean) -- ============================================================ local function updateArmBalancing(leanVectorRight, leanVectorForward, dt) local rightArm = character:FindFirstChild("RightUpperArm") local leftArm = character:FindFirstChild("LeftUpperArm") if not rightArm or not leftArm or not upperTorso then return end local rightAV = physicsConstraints["RightUpperArm_Swing"] local leftAV = physicsConstraints["LeftUpperArm_Swing"] if not rightAV or not leftAV then return end -- Calculate target angular velocity for arms based on lean local torsoRight = upperTorso.CFrame.RightVector local torsoForward = upperTorso.CFrame.LookVector -- Target swing: proportional to lean, opposing the lean direction local targetRightArmVel = (torsoForward * leanVectorRight * -ARM_SWING_INTENSITY) + (torsoRight * leanVectorForward * -ARM_SWING_INTENSITY * 0.6) -- Reduced forward lean influence slightly local targetLeftArmVel = (torsoForward * leanVectorRight * ARM_SWING_INTENSITY) + (torsoRight * leanVectorForward * -ARM_SWING_INTENSITY * 0.6) -- If stepping, add a swing component related to the step if steppingFootName then local swingDir = (steppingFootName == "LeftFoot") and 1 or -1 -- Swing opposite arm forward local stepSwingFactor = math.sin(stepProgress * math.pi) -- Make swing follow the step arc targetRightArmVel = targetRightArmVel + torsoRight * swingDir * -ARM_SWING_INTENSITY * 0.8 * stepSwingFactor targetLeftArmVel = targetLeftArmVel + torsoRight * swingDir * ARM_SWING_INTENSITY * 0.8 * stepSwingFactor end -- Smoothly interpolate towards the target velocity rightAV.AngularVelocity = rightAV.AngularVelocity:Lerp(targetRightArmVel, ARM_LERP_FACTOR) leftAV.AngularVelocity = leftAV.AngularVelocity:Lerp(targetLeftArmVel, ARM_LERP_FACTOR) end -- ============================================================ -- ADVANCED ACTIVE BALANCING LOGIC (Predictive Stepping) -- ============================================================ local function updateActiveBalance(dt) stepCooldown = math.max(0, stepCooldown - dt) if not leftFoot or not rightFoot or not rootPart or not upperTorso or not lowerTorso then return end -- Calculate key vectors and positions local com = calculateSmoothedCenterOfMass() local leftPos = leftFoot.Position local rightPos = rightFoot.Position local avgFootPos = (leftPos + rightPos) / 2 local groundY = math.min(findGroundY(leftPos) or leftPos.Y, findGroundY(rightPos) or rightPos.Y) -- Use raycasted ground if available -- Character's local XZ plane directions (using LowerTorso for more stable base reference) local hipCF = lowerTorso.CFrame local forwardXZ = (hipCF.LookVector * Vector3.new(1, 0, 1)).Unit local rightXZ = (hipCF.RightVector * Vector3.new(1, 0, 1)).Unit -- Handle potential zero vectors if looking straight up/down if forwardXZ.Magnitude < 0.1 then forwardXZ = (rootPart.CFrame.LookVector * Vector3.new(1,0,1)).Unit end if rightXZ.Magnitude < 0.1 then rightXZ = (rootPart.CFrame.RightVector * Vector3.new(1,0,1)).Unit end -- Calculate COM offset relative to average foot position (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 -- Predict future offset based on current velocity local velocityXZ = rootPart.AssemblyLinearVelocity * Vector3.new(1, 0, 1) local predictedOffset = offsetVector + velocityXZ * BALANCE_VelocityPredictionFactor -- Project predicted offset onto character's forward/right axes local leanForward = predictedOffset:Dot(forwardXZ) local leanRight = predictedOffset:Dot(rightXZ) -- Calculate overall lean amount for stiffness/correction scaling local currentUp = upperTorso.CFrame.UpVector local uprightDot = currentUp:Dot(Vector3.new(0, 1, 0)) local leanAmount = 1.0 - math.clamp(uprightDot, 0, 1) -- 0 = upright, 1 = horizontal or more -- Update Torso and Hip stiffness/correction updateBodyCorrection(dt, leanAmount) -- Update active arm balancing based on lean updateArmBalancing(leanRight, leanForward, dt) -- === STEP EXECUTION (If currently stepping) === if steppingFootName then local footPart = character:FindFirstChild(steppingFootName) if footPart and stepTargetPosition then stepProgress = math.min(stepProgress + dt / STEP_DURATION, 1) -- Use SmoothStep for easing (starts slow, accelerates, ends slow) local easeAlpha = stepProgress * stepProgress * (3 - 2 * stepProgress) -- Calculate foot position along the step arc local stepConstraint = physicsConstraints[steppingFootName .. "_BalanceStep"] if not stepConstraint then -- Safety check if constraint got destroyed steppingFootName = nil return end local startPos = stepConstraint.Attachment0.WorldPosition -- Where the step started (more reliable) local currentTargetPos = startPos:Lerp(stepTargetPosition, easeAlpha) local arcHeight = math.sin(stepProgress * math.pi) * BALANCE_LiftHeight -- Sine curve for lift currentTargetPos = currentTargetPos + Vector3.new(0, arcHeight, 0) -- Update the AlignPosition constraint target stepConstraint.Position = currentTargetPos -- Optional: Reduce responsiveness towards the end of the step for softer landing stepConstraint.Responsiveness = BALANCE_StepResponsiveness * (1 - easeAlpha * 0.6) -- Softer landing -- Check for step completion local distToTarget = (footPart.Position * Vector3.new(1, 0, 1) - stepTargetPosition * Vector3.new(1, 0, 1)).Magnitude -- Check if COM is reasonably centered again local isBalancedEnough = math.abs(leanForward) < (BALANCE_LeanThreshold_FB * 0.6) and math.abs(leanRight) < (BALANCE_LeanThreshold_LR * 0.6) if stepProgress >= 1 or (distToTarget < STEP_COMPLETION_DISTANCE and isBalancedEnough) then -- Step finished stepConstraint.Enabled = false lastSteppedFoot = steppingFootName steppingFootName = nil stepTargetPosition = nil stepProgress = 0 stepCooldown = isStumbling and STUMBLE_COOLDOWN_TIME or STEP_COOLDOWN_TIME -- Use normal cooldown after successful step isStumbling = false -- Reset stumble flag -- Gradually reset arm swing after step completion local rightArmAV = physicsConstraints["RightUpperArm_Swing"] local leftArmAV = physicsConstraints["LeftUpperArm_Swing"] if rightArmAV then rightArmAV.AngularVelocity = rightArmAV.AngularVelocity * 0.3 end -- Dampen faster if leftArmAV then leftArmAV.AngularVelocity = leftArmAV.AngularVelocity * 0.3 end end else -- Something went wrong (foot missing?), cancel step steppingFootName = nil stepTargetPosition = nil stepProgress = 0 isStumbling = false local stepConstraint = physicsConstraints[steppingFootName .. "_BalanceStep"] if stepConstraint then stepConstraint.Enabled = false end end return -- Don't evaluate new step while executing one end -- === STEP DECISION (If not currently stepping and cooldown is over) === if stepCooldown > 0 then return end local needsStepFB = math.abs(leanForward) > BALANCE_LeanThreshold_FB local needsStepLR = math.abs(leanRight) > BALANCE_LeanThreshold_LR if needsStepFB or needsStepLR then -- Determine which foot to step with (usually the one opposite the last step) local footToStepName = (lastSteppedFoot == "LeftFoot") and "RightFoot" or "LeftFoot" local footToStepPart = character:FindFirstChild(footToStepName) local stationaryFootPart = (footToStepName == "LeftFoot") and rightFoot or leftFoot if not footToStepPart or not stationaryFootPart then return end -- Safety check steppingFootName = footToStepName stepProgress = 0 -- Calculate step direction and distance based on predicted lean local stepDir = (forwardXZ * leanForward + rightXZ * leanRight).Unit local leanMagnitude = predictedOffset.Magnitude -- Use magnitude of predicted offset local requiredStepLength = math.clamp((leanMagnitude - math.min(BALANCE_LeanThreshold_FB, BALANCE_LeanThreshold_LR) * 0.8) * BALANCE_StepDistanceFactor, 0.2, STEP_MAX_REACH) -- Base step length on magnitude, ensure minimum step -- Calculate base target position relative to the stationary foot local stationaryFootPosXZ = Vector3.new(stationaryFootPart.Position.X, 0, stationaryFootPart.Position.Z) local desiredStanceOffset = rightXZ * ((footToStepName == "LeftFoot") and -1 or 1) * (BALANCE_StanceWidth / 2) local targetXZ = stationaryFootPosXZ + stepDir * requiredStepLength + desiredStanceOffset -- Find ground height at target location local targetGroundY = findGroundY(Vector3.new(targetXZ.X, com.Y + 1, targetXZ.Z)) or groundY -- Raycast from higher up stepTargetPosition = Vector3.new(targetXZ.X, targetGroundY + 0.05, targetXZ.Z) -- Target slightly above ground -- *** Obstacle Avoidance Check (Simple Raycast) *** local stepRayStart = footToStepPart.Position + Vector3.new(0,0.2,0) local stepRayDir = (stepTargetPosition - stepRayStart) local stepRayDist = stepRayDir.Magnitude local stepRayResult = workspace:Raycast(stepRayStart, stepRayDir.Unit * stepRayDist, groundRaycastParams) if stepRayResult and stepRayResult.Position.Y > targetGroundY then -- Hit something above ground level, shorten the step significantly local adjustedTargetXZ = stationaryFootPosXZ + stepDir * requiredStepLength * 0.3 + desiredStanceOffset -- Much shorter step targetGroundY = findGroundY(Vector3.new(adjustedTargetXZ.X, com.Y + 1, adjustedTargetXZ.Z)) or groundY stepTargetPosition = Vector3.new(adjustedTargetXZ.X, targetGroundY + 0.05, adjustedTargetXZ.Z) -- print("Obstacle detected, shortening step!") end -- Activate/Update 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 local stepAtt = createConstraintAttachment(footToStepPart, "BalanceStepAtt") -- stepAtt.Position = Vector3.new(0, -footToStepPart.Size.Y/2, 0) -- Apply force lower? Experiment needed. alignPos.Attachment0 = stepAtt -- Use default attachment position (center) alignPos.MaxForce = BALANCE_StepForce alignPos.ApplyAtCenterOfMass = true -- Apply force at COM of foot for smoother movement alignPos.Parent = footToStepPart physicsConstraints[constraintName] = alignPos end alignPos.Responsiveness = BALANCE_StepResponsiveness -- Reset responsiveness at step start alignPos.Position = footToStepPart.Position -- Start lerping from current pos (AlignPosition handles this internally) alignPos.Enabled = true -- Set cooldown and potentially mark as stumbling if the lean was large if leanMagnitude > (BALANCE_LeanThreshold_FB + BALANCE_LeanThreshold_LR) * 0.9 then -- Heuristic for large lean isStumbling = true stepCooldown = STUMBLE_COOLDOWN_TIME -- Shorter cooldown for potential follow-up step else isStumbling = false stepCooldown = STEP_COOLDOWN_TIME end end end -- ============================================================ -- INITIALIZE RAGDOLL & BALANCING SYSTEM -- ============================================================ local function makeRagdoll() if isRagdolled then return end isRagdolled = true clearRagdollPhysics() -- Clear any previous physics state saveOriginalCollisions() -- Re-save in case properties changed local totalMass = 0 for _, part in pairs(character:GetDescendants()) do if part:IsA("BasePart") and originalCollisions[part] and not originalCollisions[part].Massless then totalMass = totalMass + part:GetMass() -- Optional: Apply slightly higher density for stability? -- part.CustomPhysicalProperties = PhysicalProperties.new(1.0, 0.7, 0.3, 1, 1) -- Density, Friction, Elasticity, FrictionWeight, ElasticityWeight end end totalMass = math.max(totalMass, 1) -- Avoid division by zero -- Replace Motor6Ds with BallSocketConstraints 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 and part1.Parent then local a1 = createConstraintAttachment(part0, part0.Name .. "_" .. part1.Name .. "_A1") a1.CFrame = joint.C0 local a2 = createConstraintAttachment(part1, part0.Name .. "_" .. part1.Name .. "_A2") a2.CFrame = joint.C1 local constraint = Instance.new("BallSocketConstraint") constraint.Name = joint.Name .. "_BSC" constraint.Attachment0 = a1 constraint.Attachment1 = a2 constraint.LimitsEnabled = true constraint.TwistLimitsEnabled = true -- === Refined Joint Limits (Example - Adjust as needed!) === local partName = part1.Name:lower() if partName:find("foot") or partName:find("hand") then constraint.UpperAngle = 50 constraint.TwistLowerAngle = -20 constraint.TwistUpperAngle = 20 elseif partName:find("lower") and partName:find("leg") then -- Lower Leg (Knee) constraint.UpperAngle = 90 -- More bend backward constraint.TwistLowerAngle = -5 constraint.TwistUpperAngle = 5 elseif partName:find("upper") and partName:find("leg") then -- Upper Leg (Hip) constraint.UpperAngle = 100 -- Wide range constraint.TwistLowerAngle = -40 constraint.TwistUpperAngle = 40 elseif partName:find("lower") and partName:find("arm") then -- Lower Arm (Elbow) constraint.UpperAngle = 95 constraint.TwistLowerAngle = -15 constraint.TwistUpperAngle = 15 elseif partName:find("upper") and partName:find("arm") then -- Upper Arm (Shoulder) constraint.UpperAngle = 120 -- Very flexible constraint.TwistLowerAngle = -90 constraint.TwistUpperAngle = 90 elseif partName:find("head") then constraint.UpperAngle = 45 constraint.TwistLowerAngle = -35 constraint.TwistUpperAngle = 35 elseif partName:find("torso") then -- Connection between lower/upper torso constraint.UpperAngle = 30 constraint.TwistLowerAngle = -25 constraint.TwistUpperAngle = 25 else -- Default fallback constraint.UpperAngle = 50 constraint.TwistLowerAngle = -35 constraint.TwistUpperAngle = 35 end constraint.Parent = part0 -- Parent constraint to one of the parts table.insert(jointConstraints, { constraint = constraint, a1 = a1, a2 = a2 }) joint.Enabled = false -- Disable Motor6D instead of destroying end end end -- Set physical properties for ragdoll parts local collisionGroupName = "Ragdoll_" .. character.Name pcall(function() physicsService:CreateCollisionGroup(collisionGroupName) end) pcall(function() physicsService:CollisionGroupSetCollidable(collisionGroupName, collisionGroupName, false) end) for part, data in pairs(originalCollisions) do if part and part.Parent then part.CanCollide = true part.Massless = false -- Ensure all parts have mass pcall(function() physicsService:SetPartCollisionGroup(part, collisionGroupName) end) if part == rootPart then part.CanCollide = false -- HRP usually doesn't collide end end end humanoid:ChangeState(Enum.HumanoidStateType.Physics) -- Enable physics control -- === Create Physics Constraints for Balancing === -- Anti-Gravity Force (applied at COM for stability) local antiGravAtt = createConstraintAttachment(rootPart, "AntiGravityAtt") antiGravAtt.WorldPosition = calculateSmoothedCenterOfMass() -- Apply at COM local standForce = Instance.new("VectorForce") standForce.Name = "AntiGravityForce" standForce.Attachment0 = antiGravAtt standForce.RelativeTo = Enum.ActuatorRelativeTo.World standForce.ApplyAtCenterOfMass = false -- Apply at the attachment point (COM) standForce.Force = Vector3.new(0, totalMass * workspace.Gravity * ANTI_GRAVITY_MULTIPLIER, 0) standForce.Parent = rootPart physicsConstraints[standForce.Name] = standForce -- Upper Torso Alignment (Stiffness/Upright) if upperTorso then local torsoAlignAtt = createConstraintAttachment(upperTorso, "TorsoAlignAtt") local align = Instance.new("AlignOrientation") align.Name = "UpperTorso_Align" align.Attachment0 = torsoAlignAtt align.Mode = Enum.OrientationAlignmentMode.OneAttachment align.MaxTorque = STIFFNESS_TORSO_MAX_TORQUE align.Responsiveness = STIFFNESS_TORSO_RESPONSIVENESS align.CFrame = CFrame.lookAt(Vector3.zero, rootPart.CFrame.LookVector, Vector3.yAxis) -- Initial target align.Parent = upperTorso physicsConstraints[align.Name] = align end -- Lower Torso / Hip Alignment (Stiffness/Leveling) - NEW if lowerTorso then local hipAlignAtt = createConstraintAttachment(lowerTorso, "HipAlignAtt") local hipAlign = Instance.new("AlignOrientation") hipAlign.Name = "LowerTorso_Align" hipAlign.Attachment0 = hipAlignAtt hipAlign.Mode = Enum.OrientationAlignmentMode.OneAttachment hipAlign.MaxTorque = STIFFNESS_HIP_MAX_TORQUE hipAlign.Responsiveness = STIFFNESS_HIP_RESPONSIVENESS hipAlign.CFrame = CFrame.lookAt(Vector3.zero, rootPart.CFrame.LookVector, Vector3.yAxis) -- Initial target (aligned with root) hipAlign.Parent = lowerTorso physicsConstraints[hipAlign.Name] = hipAlign end -- Arm Swing Angular Velocity constraints for _, armName in pairs({"LeftUpperArm", "RightUpperArm"}) do local arm = character:FindFirstChild(armName) if arm then local swingAtt = createConstraintAttachment(arm, "SwingAtt") local av = Instance.new("AngularVelocity") av.Name = armName .. "_Swing" av.Attachment0 = swingAtt av.MaxTorque = 2000 -- Increased torque for more effective swings av.RelativeTo = Enum.ActuatorRelativeTo.Attachment0 -- Swing relative to the arm itself based on world lean av.AngularVelocity = Vector3.new(0, 0, 0) -- Start still av.Parent = arm physicsConstraints[av.Name] = av end end -- Initialize foot planting constraints (they will be enabled/disabled in the update loop) updateFootPlanting() -- Create them initially -- Connect the main update loop stepConnection = runService.Stepped:Connect(function(_, dt) -- Use the second argument (delta time) if not isRagdolled then return end -- Exit if ragdoll was disabled mid-frame -- Update attachment positions if needed (e.g., anti-gravity at COM) local currentCOM = calculateSmoothedCenterOfMass() antiGravAtt.WorldPosition = currentCOM standForce.Force = Vector3.new(0, totalMass * workspace.Gravity * ANTI_GRAVITY_MULTIPLIER, 0) -- Update force if mass changes (unlikely but safe) updateFootPlanting() updateActiveBalance(dt) -- Pass delta time end) end -- ============================================================ -- RESET CHARACTER (Restore original state) -- ============================================================ local function resetCharacter() if not isRagdolled then return end isRagdolled = false clearRagdollPhysics() -- Destroy all constraints and attachments -- Restore original Motor6D state for _, joint in pairs(character:GetDescendants()) do if joint:IsA("Motor6D") then joint.Enabled = true end end -- Restore original collision properties local defaultCollisionGroup = "Default" 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 pcall(function() physicsService:SetPartCollisionGroup(part, defaultCollisionGroup) end) -- Reset collision group -- Reset velocity/angular velocity part.AssemblyLinearVelocity = Vector3.zero part.AssemblyAngularVelocity = Vector3.zero end end originalCollisions = {} -- Clear saved data -- Attempt to reset collision group settings local collisionGroupName = "Ragdoll_" .. character.Name pcall(function() physicsService:RemoveCollisionGroup(collisionGroupName) end) humanoid:ChangeState(Enum.HumanoidStateType.GettingUp) -- Trigger Roblox's standard recovery state task.wait(0.1) -- Short delay to allow GettingUp state if humanoid:GetState() ~= Enum.HumanoidStateType.Dead then -- Ensure root part is upright before enabling standard states rootPart.CFrame = CFrame.new(rootPart.Position) * CFrame.Angles(0, math.rad(rootPart.Orientation.Y), 0) humanoid:ChangeState(Enum.HumanoidStateType.Running) -- Or Idle, depending on context end end -- ============================================================ -- EVENT HANDLERS -- ============================================================ humanoid.Died:Connect(function() if not isRagdolled then task.wait(0.05) -- Short delay before ragdolling on death makeRagdoll() end -- Optionally disable balancing updates on death if desired -- if stepConnection then stepConnection:Disconnect() stepConnection = nil end end) -- Toggle Ragdoll/Balancing with 'R' key 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 or character removed script.Destroying:Connect(resetCharacter) character.Destroying:Connect(resetCharacter) -- Initial state (optional - start ragdolled or standing) -- makeRagdoll() -- Uncomment to start in ragdoll mode -- resetCharacter() -- Ensure clean state initially if not starting ragdolled **Key Changes and Improvements:** 1. **Hip Stabilization (`LowerTorso_Align`):** A new `AlignOrientation` constraint is added to the `LowerTorso`. It primarily tries to keep the hip's UpVector aligned with the world's UpVector, preventing excessive tilting at the waist and providing a more stable platform for the `UpperTorso`. Its responsiveness and max torque (`STIFFNESS_HIP_*`) are tuned separately. 2. **Stiffness Parameters:** Introduced `STIFFNESS_*` constants to control the `MaxTorque` and base `Responsiveness` of the torso and hip alignment constraints. 3. **Dynamic Stiffness Adjustment:** In `updateBodyCorrection`, the `Responsiveness` and `MaxTorque` of both the `UpperTorso` and `LowerTorso` alignment constraints are now dynamically increased based on the `leanAmount`. This makes the character "tense up" more when significantly off-balance. 4. **Balancing Logic Uses Hip Frame:** The calculation of `forwardXZ` and `rightXZ` in `updateActiveBalance` now uses the `LowerTorso.CFrame` as the reference, which should be more stable due to the new hip alignment constraint. 5. **Refined Step Targeting:** * Step length calculation (`requiredStepLength`) is now more directly based on the `leanMagnitude`. * A simple raycast check is added to detect obstacles in the step path. If an obstacle is hit, the step length is significantly reduced to avoid stepping into walls/objects. 6. **Parameter Tuning:** Many constants (`BALANCE_*`, `STIFFNESS_*`, `STEP_*`, `ARM_*`, etc.) have been slightly adjusted to account for the new stiffness and hip control. You'll likely need further tuning based on your specific character model and desired feel. 7. **Smoother Foot Planting:** Slightly adjusted the target height and lerp factor for foot planting. 8. **Collision Groups:** Implemented unique collision groups per character (`Ragdoll_CharacterName`) to prevent ragdolled characters from interfering with each other's physics significantly. Includes cleanup in `resetCharacter`. 9. **Arm Swing:** Changed `RelativeTo` for `AngularVelocity` to `Attachment0` so the swing velocity is applied relative to the arm's orientation, potentially making counter-movements more intuitive. Increased MaxTorque. 10. **Cleanup:** Added cleanup for collision groups in `resetCharacter` and ensured `originalCollisions` is cleared. Added character `Destroying` connection. Remember to place this script inside `StarterPlayer` -> `StarterCharacterScripts`. You will likely need to fine-tune the various `BALANCE_`, `STIFFNESS_`, and `STEP_` constants to achieve the exact balancing behavior you want for your specific character rig and game feel.