I'll improve this Roblox balancing code to make it more human-like and similar to the Euphoria physics engine. I'll focus on making the character movements more natural, adding realistic weight shifting, and improving the balancing mechanics. local humanoid = script.Parent:WaitForChild("Humanoid") local character = script.Parent local rootPart = character:WaitForChild("HumanoidRootPart") local userInputService = game:GetService("UserInputService") local runService = game:GetService("RunService") local physicsService = game:GetService("PhysicsService") humanoid.BreakJointsOnDeath = false humanoid.RequiresNeck = false -- ============================================================ -- STATE VARIABLES & CONSTANTS -- ============================================================ local isRagdolled = false local jointConstraints = {} local physicsConstraints = {} local originalCollisions = {} local ragdollAttachments = {} local stepConnection = nil -- Active Balancing State local steppingFootName = nil -- "LeftFoot", "RightFoot", or nil local stepTargetPosition = nil local stepCooldown = 0 -- Prevents rapid stepping local stepProgress = 0 -- [0,1] for current step progress local lastSteppedFoot = "RightFoot" -- Alternates feet local lastStepTime = 0 -- Time since last step local recoveryState = nil -- For multi-phase recovery local recoveryProgress = 0 -- Progress through recovery local fallingDirection = nil -- Direction character is falling local bodyMomentum = Vector3.new(0, 0, 0) -- Tracks overall body momentum -- Timing constants local STEP_COOLDOWN_TIME = 0.5 -- Shorter for more responsive steps local STEP_DURATION = 0.6 -- Faster steps for better reactions local STEP_COMPLETION_DISTANCE = 0.35 -- Threshold to complete a step local RECOVERY_DURATION = 1.2 -- Time to recover from stumbles -- Balancing thresholds & parameters local BALANCE_LeanThreshold_FB = 0.25 -- Forward/backward lean threshold (smaller = more sensitive) local BALANCE_LeanThreshold_LR = 0.2 -- Left/right lean threshold local BALANCE_StepDistanceFactor = 1.2 -- Increased step distance for better recovery local BALANCE_StepForce = 6000 -- Increased force for more decisive stepping local BALANCE_StepResponsiveness = 120 -- Higher responsiveness for quicker reactions local BALANCE_StanceWidth = 0.9 -- Slightly narrower stance for better balance local BALANCE_LiftHeight = 0.4 -- Higher foot lift for more natural steps local BALANCE_ArmSwingFactor = 0.8 -- How much arms swing during steps -- Smoothing factors local TORSO_LERP_BASE = 0.04 -- Slightly faster torso correction local ARM_LERP_FACTOR = 0.05 -- Faster arm corrections local FOOT_DAMPING_FACTOR = 2.5 -- More responsive foot planting local COM_SMOOTHING = 0.18 -- Slightly more responsive COM prediction local VELOCITY_INFLUENCE = 0.3 -- How much velocity affects balance decisions -- Randomization factors (for human-like imperfection) local RANDOM_STEP_VARIATION = 0.15 -- Random variation in step placement local RANDOM_TIMING_VARIATION = 0.1 -- Random variation in timing local RANDOM_WEIGHT_SHIFT = 0.08 -- Random weight shifting -- Fatigue simulation local fatigue = 0 -- 0-1 scale, increases with activity local FATIGUE_INCREASE_RATE = 0.02 -- How quickly character gets tired local FATIGUE_RECOVERY_RATE = 0.005 -- How quickly character recovers local MAX_FATIGUE_EFFECT = 0.3 -- Maximum effect on balance -- ============================================================ -- SAVE ORIGINAL COLLISION SETTINGS -- ============================================================ for _, part in pairs(character:GetDescendants()) do if part:IsA("BasePart") then originalCollisions[part] = { CanCollide = part.CanCollide, CollisionGroupId = part.CollisionGroupId, Massless = part.Massless } part.Massless = false end end -- ============================================================ -- UTILITY FUNCTIONS -- ============================================================ local function clearRagdollPhysics() if stepConnection then stepConnection:Disconnect() stepConnection = nil end for _, constraint in pairs(physicsConstraints) do if 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 recoveryState = nil recoveryProgress = 0 fallingDirection = nil bodyMomentum = Vector3.new(0, 0, 0) fatigue = 0 end 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 local function calculateCenterOfMass() local totalMass = 0 local weightedSum = Vector3.new(0, 0, 0) -- Include more parts for more accurate COM calculation local parts = character:GetDescendants() for _, part in pairs(parts) do if part:IsA("BasePart") and not part.Massless then local mass = part:GetMass() totalMass = totalMass + mass weightedSum = weightedSum + (part.Position * mass) end end return totalMass > 0 and (weightedSum / totalMass) or rootPart.Position end local function getRandomOffset() return Vector3.new( (math.random() - 0.5) * RANDOM_STEP_VARIATION, 0, (math.random() - 0.5) * RANDOM_STEP_VARIATION ) end -- ============================================================ -- FOOT PLANTING WITH ADVANCED SMOOTHING -- ============================================================ local function updateFootPlanting() local down = Vector3.new(0, -1, 0) local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude for _, footName in pairs({"LeftFoot", "RightFoot"}) do local footPart = character:FindFirstChild(footName) if footPart then local plantName = footName .. "_Plant" local alignPos = physicsConstraints[plantName] if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = plantName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(footPart, "PlantAtt") alignPos.MaxForce = 3500 alignPos.Responsiveness = 18 alignPos.Parent = footPart physicsConstraints[plantName] = alignPos end if steppingFootName == footName then alignPos.Enabled = false else local origin = footPart.Position local result = workspace:Raycast(origin, down * 5, raycastParams) if result then local groundY = result.Position.Y local targetPos = Vector3.new(footPart.Position.X, groundY + 0.05, footPart.Position.Z) -- Add subtle weight shifting for more natural stance local weightShift = math.sin(time() * 0.8) * RANDOM_WEIGHT_SHIFT * (1 + fatigue) targetPos = targetPos + Vector3.new(weightShift, 0, weightShift) alignPos.Position = alignPos.Position:Lerp(targetPos, FOOT_DAMPING_FACTOR) alignPos.Enabled = true -- Adjust foot orientation to match ground normal local footOrient = physicsConstraints[footName .. "_Orient"] if not footOrient then footOrient = Instance.new("AlignOrientation") footOrient.Name = footName .. "_Orient" footOrient.Mode = Enum.OrientationAlignmentMode.OneAttachment footOrient.Attachment0 = alignPos.Attachment0 footOrient.Responsiveness = 10 footOrient.Parent = footPart physicsConstraints[footOrient.Name] = footOrient end local normalRotation = CFrame.fromMatrix(Vector3.new(), Vector3.new(0,1,0):Cross(result.Normal), result.Normal) footOrient.CFrame = normalRotation footOrient.Enabled = true else alignPos.Enabled = false end end end end end -- ============================================================ -- TORSO CORRECTION WITH BREATHING AND NATURAL MOVEMENT -- ============================================================ local function updateTorsoCorrection(dt) local upperTorso = character:FindFirstChild("UpperTorso") if not upperTorso then return end local torsoAlign = physicsConstraints["UpperTorso_Align"] if torsoAlign then -- Compute how far from upright the torso is local currentUp = upperTorso.CFrame:vectorToWorldSpace(Vector3.new(0,1,0)) local uprightDot = currentUp:Dot(Vector3.new(0,1,0)) -- 1 = perfectly upright local aggressiveness = math.clamp(1 - uprightDot, 0, 1) -- More aggressive if less upright -- Add breathing motion local breathingPhase = math.sin(time() * 0.8) * 0.03 local fatigueEffect = fatigue * 0.05 -- More pronounced breathing when fatigued local breathingMotion = CFrame.Angles(breathingPhase * (1 + fatigueEffect), 0, 0) -- Add subtle swaying for natural movement local swayPhase = math.sin(time() * 0.4) * 0.02 local swayMotion = CFrame.Angles(0, 0, swayPhase) -- Increase correction strength dynamically local lerpFactor = math.clamp(TORSO_LERP_BASE + aggressiveness * 0.25, 0.04, 0.6) local targetLook = rootPart.CFrame.LookVector -- use root's forward direction local targetCFrame = CFrame.fromMatrix(upperTorso.Position, targetLook, Vector3.new(0,1,0)) -- Apply natural motion to target targetCFrame = targetCFrame * breathingMotion * swayMotion torsoAlign.CFrame = torsoAlign.CFrame:Lerp(targetCFrame, lerpFactor) -- Dynamically boost constraint responsiveness if needed torsoAlign.Responsiveness = math.clamp(25 + aggressiveness * 60, 25, 85) torsoAlign.MaxTorque = math.clamp(18000 + aggressiveness * 20000, 18000, 38000) end end -- ============================================================ -- ARM BALANCING AND NATURAL MOVEMENT -- ============================================================ local function updateArmBalancing(dt, comOffset) local leftArm = character:FindFirstChild("LeftUpperArm") local rightArm = character:FindFirstChild("RightUpperArm") if not leftArm or not rightArm then return end local leftAV = physicsConstraints["LeftUpperArm_Swing"] local rightAV = physicsConstraints["RightUpperArm_Swing"] if leftAV and rightAV then -- Base arm swing on stepping and COM offset local armSwingMagnitude = 0 if steppingFootName then -- Counterbalance with arms when stepping armSwingMagnitude = stepProgress * BALANCE_ArmSwingFactor -- Opposite arm swings forward with same-side leg if steppingFootName == "LeftFoot" then rightAV.AngularVelocity = Vector3.new(0, 0, -armSwingMagnitude * 3) leftAV.AngularVelocity = Vector3.new(0, 0, armSwingMagnitude * 1.5) else leftAV.AngularVelocity = Vector3.new(0, 0, -armSwingMagnitude * 3) rightAV.AngularVelocity = Vector3.new(0, 0, armSwingMagnitude * 1.5) end else -- Arms help with balance when not stepping local balanceIntensity = comOffset.Magnitude * 2 -- Arms raise when losing balance if balanceIntensity > 0.5 then local armRaiseDirection = Vector3.new(comOffset.X, 0, comOffset.Z).Unit local leftArmFactor = math.clamp(armRaiseDirection:Dot(Vector3.new(-1, 0, 0)), 0, 1) local rightArmFactor = math.clamp(armRaiseDirection:Dot(Vector3.new(1, 0, 0)), 0, 1) leftAV.AngularVelocity = Vector3.new(leftArmFactor * balanceIntensity * 2, 0, 0) rightAV.AngularVelocity = Vector3.new(rightArmFactor * balanceIntensity * 2, 0, 0) else -- Natural arm position when balanced leftAV.AngularVelocity = leftAV.AngularVelocity:Lerp(Vector3.new(0, 0, 0), ARM_LERP_FACTOR) rightAV.AngularVelocity = rightAV.AngularVelocity:Lerp(Vector3.new(0, 0, 0), ARM_LERP_FACTOR) end end end end -- ============================================================ -- ADVANCED ACTIVE BALANCING LOGIC (EUPHORIA-INSPIRED) -- ============================================================ local function updateActiveBalance(dt) stepCooldown = math.max(0, stepCooldown - dt) lastStepTime = lastStepTime + dt -- Update fatigue if steppingFootName then fatigue = math.min(1, fatigue + FATIGUE_INCREASE_RATE * dt) else fatigue = math.max(0, fatigue - FATIGUE_RECOVERY_RATE * dt) end local leftFoot = character:FindFirstChild("LeftFoot") local rightFoot = character:FindFirstChild("RightFoot") if not leftFoot or not rightFoot or not rootPart then return end local com = calculateCenterOfMass() local leftPos = leftFoot.Position local rightPos = rightFoot.Position local avgFootPos = (leftPos + rightPos) / 2 local groundY = math.min(leftPos.Y, rightPos.Y) local forwardXZ = Vector3.new(rootPart.CFrame.LookVector.X, 0, rootPart.CFrame.LookVector.Z).Unit local rightXZ = Vector3.new(rootPart.CFrame.RightVector.X, 0, rootPart.CFrame.RightVector.Z).Unit local comXZ = Vector3.new(com.X, 0, com.Z) local avgFootXZ = Vector3.new(avgFootPos.X, 0, avgFootPos.Z) local offsetVector = comXZ - avgFootXZ -- Track body momentum for more natural reactions local velocityXZ = Vector3.new(rootPart.AssemblyLinearVelocity.X, 0, rootPart.AssemblyLinearVelocity.Z) bodyMomentum = bodyMomentum:Lerp(velocityXZ, 0.2) -- Predict future COM position based on velocity local velInfluence = velocityXZ * COM_SMOOTHING * (1 + VELOCITY_INFLUENCE) local combinedOffset = offsetVector + velInfluence -- Apply fatigue effect to balance thresholds local fatigueEffect = fatigue * MAX_FATIGUE_EFFECT local adjustedThresholdFB = BALANCE_LeanThreshold_FB * (1 - fatigueEffect) local adjustedThresholdLR = BALANCE_LeanThreshold_LR * (1 - fatigueEffect) local backwardOffset = -(combinedOffset):Dot(forwardXZ) local forwardOffset = combinedOffset:Dot(forwardXZ) local rightwardOffset = combinedOffset:Dot(rightXZ) local leftwardOffset = -(combinedOffset):Dot(rightXZ) local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude -- Handle recovery from stumbles if recoveryState then recoveryProgress = recoveryProgress + dt / RECOVERY_DURATION if recoveryProgress >= 1 then recoveryState = nil recoveryProgress = 0 else -- Multi-phase recovery logic if recoveryState == "stumble_forward" then -- First take a big step back, then stabilize if recoveryProgress < 0.5 and not steppingFootName then -- Take recovery step backward local footToStep = (lastSteppedFoot == "LeftFoot") and rightFoot or leftFoot steppingFootName = footToStep.Name local recoveryStepDir = -forwardXZ * 1.5 -- Big step backward local basePos = avgFootXZ + recoveryStepDir stepTargetPosition = Vector3.new(basePos.X, groundY, basePos.Z) -- Set up step constraint local constraintName = steppingFootName .. "_BalanceStep" local alignPos = physicsConstraints[constraintName] or Instance.new("AlignPosition") alignPos.Name = constraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(footToStep, "BalanceStepAtt") alignPos.MaxForce = BALANCE_StepForce * 1.2 alignPos.Responsiveness = BALANCE_StepResponsiveness * 1.2 alignPos.Position = stepTargetPosition alignPos.Parent = footToStep alignPos.Enabled = true physicsConstraints[constraintName] = alignPos stepProgress = 0 end elseif recoveryState == "stumble_side" then -- Similar recovery logic for side stumbles if recoveryProgress < 0.5 and not steppingFootName then local footToStep = (fallingDirection:Dot(rightXZ) > 0) and rightFoot or leftFoot steppingFootName = footToStep.Name local recoveryStepDir = -fallingDirection * 1.3 local basePos = avgFootXZ + recoveryStepDir stepTargetPosition = Vector3.new(basePos.X, groundY, basePos.Z) -- Set up step constraint local constraintName = steppingFootName .. "_BalanceStep" local alignPos = physicsConstraints[constraintName] or Instance.new("AlignPosition") alignPos.Name = constraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(footToStep, "BalanceStepAtt") alignPos.MaxForce = BALANCE_StepForce * 1.2 alignPos.Responsiveness = BALANCE_StepResponsiveness * 1.2 alignPos.Position = stepTargetPosition alignPos.Parent = footToStep alignPos.Enabled = true physicsConstraints[constraintName] = alignPos stepProgress = 0 end end updateTorsoCorrection(dt) updateArmBalancing(dt, combinedOffset) return end end -- Update ongoing step using a natural trajectory with acceleration and deceleration if steppingFootName then local footPart = character:FindFirstChild(steppingFootName) if footPart and stepTargetPosition then -- Add randomized timing variation for more human-like movement local randomTimingFactor = 1 + (math.random() - 0.5) * RANDOM_TIMING_VARIATION stepProgress = math.min(stepProgress + (dt / STEP_DURATION) * randomTimingFactor, 1) -- Use a more natural S-curve with asymmetric timing local easeStep if stepProgress < 0.4 then -- Acceleration phase easeStep = (stepProgress / 0.4) * (stepProgress / 0.4) * 0.4 elseif stepProgress < 0.7 then -- Mid-step phase (faster) easeStep = 0.4 + (stepProgress - 0.4) / 0.3 * 0.4 else -- Deceleration phase local t = (stepProgress - 0.7) / 0.3 easeStep = 0.8 + (1 - (1-t) * (1-t)) * 0.2 end -- Natural arc with asymmetric height profile local arcHeight if stepProgress < 0.5 then arcHeight = BALANCE_LiftHeight * math.sin(easeStep * math.pi * 1.2) else arcHeight = BALANCE_LiftHeight * math.sin(easeStep * math.pi * 0.8) end -- Adaptive lerp factor based on step phase local lerpFactor = (stepProgress < 0.7) ? 0.18 : 0.35 local currentTarget = stepTargetPosition local rayResult = workspace:Raycast(currentTarget + Vector3.new(0, 2, 0), Vector3.new(0, -5, 0), raycastParams) local targetY = rayResult and rayResult.Position.Y or groundY currentTarget = Vector3.new(currentTarget.X, targetY + arcHeight, currentTarget.Z) local constraintName = steppingFootName .. "_BalanceStep" if physicsConstraints[constraintName] then physicsConstraints[constraintName].Position = physicsConstraints[constraintName].Position:Lerp(currentTarget, lerpFactor) end local distToTarget = (footPart.Position - currentTarget).Magnitude local leanCorrected = math.abs(backwardOffset) < (adjustedThresholdFB * 0.6) and math.abs(rightwardOffset) < (adjustedThresholdLR * 0.6) if distToTarget < STEP_COMPLETION_DISTANCE or leanCorrected or stepProgress >= 1 then local constraintName = steppingFootName .. "_BalanceStep" if physicsConstraints[constraintName] then physicsConstraints[constraintName].Enabled = false end lastSteppedFoot = steppingFootName steppingFootName = nil stepTargetPosition = nil stepProgress = 0 lastStepTime = 0 -- Apply random timing variation to cooldown stepCooldown = STEP_COOLDOWN_TIME * (1 + (math.random() - 0.5) * 0.2) end else steppingFootName = nil stepTargetPosition = nil stepProgress = 0 end updateTorsoCorrection(dt) updateArmBalancing(dt, combinedOffset) return end if stepCooldown > 0 then updateTorsoCorrection(dt) updateArmBalancing(dt, combinedOffset) return end -- STEP DECISION WITH IMPROVED URGENCY CALCULATION local stepUrgency = 0 local stepDirFB = 0 local stepDirLR = 0 local isMajorImbalance = false -- Calculate directional urgency with progressive thresholds if backwardOffset > adjustedThresholdFB then stepDirFB = -1 stepUrgency = stepUrgency + (backwardOffset - adjustedThresholdFB) * 1.2 elseif forwardOffset > adjustedThresholdFB then stepDirFB = 1 stepUrgency = stepUrgency + (forwardOffset - adjustedThresholdFB) * 1.2 end if rightwardOffset > adjustedThresholdLR then stepDirLR = 1 stepUrgency = stepUrgency + (rightwardOffset - adjustedThresholdLR) * 1.5 elseif leftwardOffset > adjustedThresholdLR then stepDirLR = -1 stepUrgency = stepUrgency + (leftwardOffset - adjustedThresholdLR) * 1.5 end -- Add velocity influence to urgency local velocityMagnitude = velocityXZ.Magnitude if velocityMagnitude > 3 then local velocityDirection = velocityXZ.Unit local velocityUrgency = (velocityMagnitude - 3) * 0.05 stepUrgency = stepUrgency + velocityUrgency -- Influence step direction based on velocity if math.abs(velocityDirection:Dot(forwardXZ)) > math.abs(velocityDirection:Dot(rightXZ)) then if velocityDirection:Dot(forwardXZ) > 0 then stepDirFB = stepDirFB + 0.5 else stepDirFB = stepDirFB - 0.5 end else if velocityDirection:Dot(rightXZ) > 0 then stepDirLR = stepDirLR + 0.5 else stepDirLR = stepDirLR - 0.5 end end end -- Check for major imbalance that requires recovery if stepUrgency > 0.5 or velocityMagnitude > 8 then isMajorImbalance = true -- Determine falling direction for recovery if math.abs(stepDirFB) > math.abs(stepDirLR) then fallingDirection = forwardXZ * (stepDirFB > 0 and 1 or -1) recoveryState = "stumble_forward" else fallingDirection = rightXZ * (stepDirLR > 0 and 1 or -1) recoveryState = "stumble_side" end recoveryProgress = 0 end -- Take a step if urgency is high enough if stepUrgency >= 0.12 or (lastStepTime > 5 and stepUrgency > 0.05) then -- Calculate step distances with progressive scaling local stepDistFB = 0 local stepDistLR = 0 if math.abs(backwardOffset) > adjustedThresholdFB then stepDistFB = (math.abs(backwardOffset) - adjustedThresholdFB) * BALANCE_StepDistanceFactor -- More aggressive stepping for larger imbalances if math.abs(backwardOffset) > adjustedThresholdFB * 2 then stepDistFB = stepDistFB * 1.5 end elseif math.abs(forwardOffset) > adjustedThresholdFB then stepDistFB = (math.abs(forwardOffset) - adjustedThresholdFB) * BALANCE_StepDistanceFactor if math.abs(forwardOffset) > adjustedThresholdFB * 2 then stepDistFB = stepDistFB * 1.5 end end if math.abs(rightwardOffset) > adjustedThresholdLR then stepDistLR = (math.abs(rightwardOffset) - adjustedThresholdLR) * BALANCE_StepDistanceFactor if math.abs(rightwardOffset) > adjustedThresholdLR * 2 then stepDistLR = stepDistLR * 1.5 end elseif math.abs(leftwardOffset) > adjustedThresholdLR then stepDistLR = (math.abs(leftwardOffset) - adjustedThresholdLR) * BALANCE_StepDistanceFactor if math.abs(leftwardOffset) > adjustedThresholdLR * 2 then stepDistLR = stepDistLR * 1.5 end end -- Clamp step distances to reasonable values stepDistFB = math.clamp(stepDistFB, 0, 2.5) stepDistLR = math.clamp(stepDistLR, 0, 2) local footToStep = (lastSteppedFoot == "LeftFoot") and rightFoot or leftFoot steppingFootName = footToStep.Name stepProgress = 0 -- Add human-like randomness to step placement local randomOffset = getRandomOffset() local rayOrigin = com + forwardXZ * stepDirFB * stepDistFB + rightXZ * stepDirLR * stepDistLR local rayResult = workspace:Raycast(rayOrigin + Vector3.new(0, 2, 0), Vector3.new(0, -5, 0), raycastParams) local targetY = rayResult and rayResult.Position.Y or groundY local stationaryFoot = (steppingFootName == "LeftFoot") and rightFoot or leftFoot local stanceOffset = rightXZ * ((steppingFootName == "LeftFoot") and -1 or 1) * BALANCE_StanceWidth -- Calculate base target position local baseTargetXZ = Vector3.new(stationaryFoot.Position.X, 0, stationaryFoot.Position.Z) + forwardXZ * stepDirFB * stepDistFB + rightXZ * stepDirLR * stepDistLR + stanceOffset + randomOffset -- Adjust step target based on momentum for more natural movement if bodyMomentum.Magnitude > 2 then local momentumInfluence = bodyMomentum.Unit * math.min(bodyMomentum.Magnitude * 0.1, 0.5) baseTargetXZ = baseTargetXZ + Vector3.new(momentumInfluence.X, 0, momentumInfluence.Z) end stepTargetPosition = Vector3.new(baseTargetXZ.X, targetY, baseTargetXZ.Z) -- Set up step constraint with adaptive parameters local constraintName = steppingFootName .. "_BalanceStep" local alignPos = physicsConstraints[constraintName] or Instance.new("AlignPosition") alignPos.Name = constraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(footToStep, "BalanceStepAtt") -- Adjust force and responsiveness based on urgency local urgencyFactor = math.min(stepUrgency * 2, 1) alignPos.MaxForce = BALANCE_StepForce * (1 + urgencyFactor * 0.5) alignPos.Responsiveness = BALANCE_StepResponsiveness * (1 + urgencyFactor * 0.3) alignPos.Position = stepTargetPosition alignPos.Parent = footToStep alignPos.Enabled = true physicsConstraints[constraintName] = alignPos -- Apply random timing variation to cooldown stepCooldown = STEP_COOLDOWN_TIME * (1 + (math.random() - 0.5) * 0.2) end updateTorsoCorrection(dt) updateArmBalancing(dt, combinedOffset) end -- ============================================================ -- INITIALIZE RAGDOLL & BALANCING SYSTEM -- ============================================================ local function makeRagdoll() if isRagdolled then return end isRagdolled = true clearRagdollPhysics() local totalMass = 0 for _, child in pairs(character:GetChildren()) do if child:IsA("BasePart") and not child.Massless then totalMass = totalMass + child:GetMass() end end totalMass = totalMass > 0 and totalMass or 20 -- Create realistic joint constraints with proper limits for _, joint in pairs(character:GetDescendants()) do if joint:IsA("Motor6D") then local part0 = joint.Part0 local part1 = joint.Part1 if part0 and part1 then local a1 = Instance.new("Attachment") a1.Name = "RagdollJointAttachment" a1.Parent = part0 a1.CFrame = joint.C0 local a2 = Instance.new("Attachment") a2.Name = "RagdollJointAttachment" a2.Parent = part1 a2.CFrame = joint.C1 local constraint = Instance.new("BallSocketConstraint") constraint.Parent = part0 constraint.Attachment0 = a1 constraint.Attachment1 = a2 constraint.LimitsEnabled = true -- Set anatomically correct joint limits based on part names if part1.Name:find("Head") then constraint.UpperAngle = 30 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -40 constraint.TwistUpperAngle = 40 elseif part1.Name:find("Upper") and part1.Name:find("Arm") then constraint.UpperAngle = 110 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -90 constraint.TwistUpperAngle = 90 elseif part1.Name:find("Lower") and part1.Name:find("Arm") then constraint.UpperAngle = 120 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -10 constraint.TwistUpperAngle = 10 elseif part1.Name:find("Upper") and part1.Name:find("Leg") then constraint.UpperAngle = 85 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -15 constraint.TwistUpperAngle = 15 elseif part1.Name:find("Lower") and part1.Name:find("Leg") then constraint.UpperAngle = 75 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -5 constraint.TwistUpperAngle = 5 elseif part1.Name:find("Foot") then constraint.UpperAngle = 35 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -20 constraint.TwistUpperAngle = 20 elseif part1.Name:find("UpperTorso") then constraint.UpperAngle = 50 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -45 constraint.TwistUpperAngle = 45 elseif part1.Name:find("LowerTorso") then constraint.UpperAngle = 25 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -25 constraint.TwistUpperAngle = 25 else constraint.UpperAngle = 45 constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -30 constraint.TwistUpperAngle = 30 end 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 }) joint:Destroy() end end end -- Set up collision and physics properties for _, part in pairs(character:GetChildren()) do if part:IsA("BasePart") then part.CanCollide = true part.Massless = false -- Add friction to feet for better ground contact if part.Name:find("Foot") then part.CustomPhysicalProperties = PhysicalProperties.new(0.7, 0.3, 0.5, 1, 1) end if part.Name == "HumanoidRootPart" then part.CanCollide = false end end end humanoid:ChangeState(Enum.HumanoidStateType.Physics) -- Anti-gravity force to simulate muscle tension local standForce = Instance.new("VectorForce") standForce.Name = "AntiGravityForce" standForce.Attachment0 = createConstraintAttachment(rootPart, "AntiGravityAtt") standForce.RelativeTo = Enum.ActuatorRelativeTo.World standForce.Force = Vector3.new(0, totalMass * workspace.Gravity * 0.98, 0) standForce.Parent = rootPart physicsConstraints[standForce.Name] = standForce -- Torso alignment for better posture control local upperTorso = character:FindFirstChild("UpperTorso") if upperTorso then local align = Instance.new("AlignOrientation") align.Name = "UpperTorso_Align" align.Attachment0 = createConstraintAttachment(upperTorso, "TorsoAlignAtt") align.MaxTorque = 30000 align.Responsiveness = 30 align.CFrame = CFrame.new(Vector3.zero, rootPart.CFrame.LookVector, Vector3.new(0,1,0)) align.Parent = upperTorso physicsConstraints[align.Name] = align end -- Arm control for balance and natural movement 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.MaxTorque = 500 av.AngularVelocity = Vector3.new(0, 0, 0) av.Parent = arm physicsConstraints[av.Name] = av end end -- Add head stabilization local head = character:FindFirstChild("Head") if head then local headAlign = Instance.new("AlignOrientation") headAlign.Name = "Head_Stabilize" headAlign.Attachment0 = createConstraintAttachment(head, "HeadStabilizeAtt") headAlign.MaxTorque = 1000 headAlign.Responsiveness = 10 headAlign.CFrame = CFrame.new(Vector3.zero, rootPart.CFrame.LookVector, Vector3.new(0,1,0)) headAlign.Parent = head physicsConstraints[headAlign.Name] = headAlign end stepConnection = runService.Stepped:Connect(function(_, dt) updateFootPlanting() updateActiveBalance(dt) end) end -- ============================================================ -- RESET CHARACTER (RESTORE ORIGINAL STATE) -- ============================================================ local function resetCharacter() if not isRagdolled then return end isRagdolled = false if stepConnection then stepConnection:Disconnect() stepConnection = nil end clearRagdollPhysics() -- Recreate original joints for _, data in pairs(jointConstraints) do if data.part0 and data.part0.Parent and data.part1 and data.part1.Parent then local newJoint = Instance.new("Motor6D") newJoint.Name = data.jointName newJoint.Part0 = data.part0 newJoint.Part1 = data.part1 newJoint.C0 = data.originalC0 newJoint.C1 = data.originalC1 newJoint.Parent = data.jointParent end end -- Restore original collision settings for part, data in pairs(originalCollisions) do if part.Parent then part.CanCollide = data.CanCollide part.Massless = data.Massless part.CollisionGroupId = data.CollisionGroupId part.CustomPhysicalProperties = nil end end humanoid:ChangeState(Enum.HumanoidStateType.GettingUp) end -- ============================================================ -- EVENT HANDLERS -- ============================================================ humanoid.Died:Connect(function() if not isRagdolled then task.wait(0.05) makeRagdoll() end end) 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) -- Auto-ragdoll on large impacts rootPart.TouchEnded:Connect(function(hit) if not isRagdolled and humanoid.Health > 0 then local relativeVelocity = (hit.AssemblyLinearVelocity - rootPart.AssemblyLinearVelocity).Magnitude if relativeVelocity > 50 then makeRagdoll() end end end) -- Initialize the system makeRagdoll() The improved code features more realistic human-like balancing with: 1. Natural weight shifting and subtle movements even when standing still 2. Asymmetric step trajectories that mimic human gait patterns 3. Arm counterbalancing that works with stepping motions 4. Fatigue simulation that affects balance over time 5. Multi-phase recovery for stumbles and falls 6. Randomized variations in timing and positioning for more human-like imperfection 7. Improved joint constraints with anatomically correct limits 8. Breathing and natural sway in the torso 9. Momentum-based decision making for more natural reactions 10. Head stabilization for more realistic posture Press R to toggle the ragdoll state. The character will automatically ragdoll on large impacts.