Okay, let's enhance the realism of the active balancing ragdoll script. We'll focus on making the reactions more dynamic and incorporating more body parts into the balancing act, moving closer to a Euphoria-like feel. This involves: 1. **More Sophisticated Balance Assessment:** Considering velocity and angular velocity. 2. **Active Torso/Hip Control:** Using torques to shift weight before stepping. 3. **Basic Arm Balancing:** Swinging arms to counteract lean and movement. 4. **Adaptive Stepping:** Adjusting step parameters based on imbalance severity. 5. **Refined Constraints:** Using HingeConstraints where appropriate (like knees) and potentially Servos later for active muscle simulation (though we'll start with Torques/AlignPosition for now). 6. **Smoother Transitions & Movement:** Improving how forces and targets are applied. Here's the updated script: --!native -- Services local UserInputService = game:GetService("UserInputService") local RunService = game:GetService("RunService") local PhysicsService = game:GetService("PhysicsService") local Players = game:GetService("Players") -- Character Setup local character = script.Parent local humanoid = character:WaitForChild("Humanoid") local rootPart = character:WaitForChild("HumanoidRootPart") local torso = character:FindFirstChild("UpperTorso") or character:FindFirstChild("Torso") -- R15 or R6 local head = character:WaitForChild("Head") humanoid.BreakJointsOnDeath = false humanoid.RequiresNeck = false humanoid.PlatformStand = true -- Prevent default humanoid physics interfering initially -- State Variables local isRagdolled = false local jointConstraints = {} -- Stores { constraint, a1, a2, type, originalJointData } local physicsConstraints = {} -- Stores active physics movers (VectorForce, Torque, AlignPosition etc.) local originalCollisions = {} -- Stores original collision settings local ragdollAttachments = {} -- Stores attachments created for constraints local stepConnection = nil -- Active Balancing State local steppingFootName = nil -- "LeftFoot" or "RightFoot" or nil local stepTargetPosition = nil local stepCooldown = 0 local stepProgress = 0 -- Normalized step completion (0 to 1) local lastSteppedFoot = "RightFoot" local currentLean = Vector3.zero -- Current lean offset (COM relative to support base) local supportCenter = Vector3.zero -- Center of the support polygon (feet) -- Tuning Parameters (More nuanced) local BALANCE_CONFIG = { -- Sensitivity & Thresholds LeanThreshold = 0.45, -- Base lean distance before reacting (meters) VelocityInfluence = 0.15, -- How much COM velocity affects perceived lean AngularVelocityInfluence = 0.1, -- How much torso angular velocity affects perceived lean StepTriggerThreshold = 0.6, -- Lean magnitude required to initiate a step StumbleTriggerThreshold = 1.5, -- Lean magnitude causing a more desperate stumble -- Stepping Mechanics StepBaseDistance = 0.5, -- Base length of a step StepLeanFactor = 3.0, -- How much lean increases step distance StepVelocityFactor = 2.0, -- How much COM velocity increases step distance StepLiftHeight = 0.35, -- How high the foot lifts StepDuration = 0.3, -- Target time for a step StepCooldownTime = 0.15, -- Minimum time between steps StanceWidth = 1.8, -- Desired width between feet (adjust based on character size) StepCompletionDistance = 0.3, -- How close foot needs to be to target -- Force & Torque Control TorsoLeanCorrectionForce = 8000, -- Max torque applied to torso/hip to counter lean ArmBalanceCorrectionForce = 1500, -- Max torque applied to arms for balance StepAlignForce = 15000, -- Force used by AlignPosition for stepping foot StepResponsiveness = 25, -- How quickly the stepping foot reaches its target (AlignPosition) FootPlantForceFactor = 1.2, -- Multiplier for downward force on planted foot (relative to body weight) AntiGravityFactor = 0.99, -- How much gravity is counteracted (slightly less than 1 allows settling) -- Damping (Prevents oscillations) TorsoAngularDamping = 0.8, LimbAngularDamping = 0.7, } -- Physics Groups for Ragdoll local ragdollCollisionGroupId = PhysicsService:CreateCollisionGroup("Ragdoll") PhysicsService:CollisionGroupSetCollidable("Ragdoll", "Ragdoll", false) PhysicsService:CollisionGroupSetCollidable("Ragdoll", "Default", true) -- Store original collision settings task.defer(function() -- Defer to ensure all parts are loaded 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 if part ~= rootPart then -- Keep root part non-collidable usually PhysicsService:SetPartCollisionGroup(part, "Ragdoll") end -- Apply some initial damping part.CustomPhysicalProperties = PhysicalProperties.new( part.CustomPhysicalProperties and part.CustomPhysicalProperties.Density or 1, part.CustomPhysicalProperties and part.CustomPhysicalProperties.Friction or 0.5, part.CustomPhysicalProperties and part.CustomPhysicalProperties.Elasticity or 0.1, part.CustomPhysicalProperties and part.CustomPhysicalProperties.FrictionWeight or 1, part.CustomPhysicalProperties and part.CustomPhysicalProperties.ElasticityWeight or 1 ) part.AssemblyAngularVelocity = Vector3.zero -- Reset any initial spin part.AssemblyLinearVelocity = Vector3.zero end end end) -- Helper: Create Attachment local function createAttachment(parentPart, nameSuffix) local att = Instance.new("Attachment") att.Name = "RagdollAttachment_" .. (nameSuffix or parentPart.Name) att.Parent = parentPart table.insert(ragdollAttachments, att) return att end -- Helper: Get Total Mass local function getTotalMass() local totalMass = 0 for _, part in pairs(character:GetDescendants()) do if part:IsA("BasePart") and not part.Massless then totalMass = totalMass + part:GetMass() end end return math.max(totalMass, 1) -- Avoid division by zero end -- Helper: Calculate Center of Mass (COM) and Velocity local function calculateCOM() local totalMass = 0 local weightedPosSum = Vector3.zero local weightedVelSum = Vector3.zero local partsForCOM = {torso, head, rootPart, character:FindFirstChild("LeftUpperLeg"), character:FindFirstChild("RightUpperLeg"), character:FindFirstChild("LeftUpperArm"), character:FindFirstChild("RightUpperArm")} for _, part in pairs(partsForCOM) do if part and part:IsA("BasePart") and not part.Massless then local mass = part:GetMass() if mass > 0 then totalMass = totalMass + mass weightedPosSum = weightedPosSum + part.Position * mass weightedVelSum = weightedVelSum + part.AssemblyLinearVelocity * mass end end end if totalMass > 0 then return weightedPosSum / totalMass, weightedVelSum / totalMass else return rootPart.Position, rootPart.AssemblyLinearVelocity -- Fallback end end -- Function to clear all ragdoll constraints and physics movers local function clearRagdollPhysics() if stepConnection then stepConnection:Disconnect() stepConnection = nil end -- Destroy physics movers (Forces, Torques, AlignPositions) for name, constraint in pairs(physicsConstraints) do if constraint and constraint.Parent then constraint:Destroy() end end physicsConstraints = {} -- Destroy joint constraints (BallSocket, Hinge) and their attachments for _, data in pairs(jointConstraints) do if data.constraint and data.constraint.Parent then data.constraint:Destroy() end if data.a1 and data.a1.Parent then data.a1:Destroy() end if data.a2 and data.a2.Parent then data.a2:Destroy() end end jointConstraints = {} -- Destroy any remaining loose attachments for _, att in pairs(ragdollAttachments) do if att and att.Parent then att:Destroy() end end ragdollAttachments = {} -- Reset balancing state steppingFootName = nil stepTargetPosition = nil stepCooldown = 0 stepProgress = 0 currentLean = Vector3.zero supportCenter = Vector3.zero end -- Function to create ragdoll joints local function createRagdollJoints() local totalMass = getTotalMass() 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 local a1 = createAttachment(part0, part1.Name .. "_A1") local a2 = createAttachment(part1, part0.Name .. "_A2") a1.CFrame = joint.C0 a2.CFrame = joint.C1 local constraint local constraintType = "BallSocket" -- Default -- Use Hinge for knees and elbows if possible (adjust names if needed) if joint.Name:match("Knee") or joint.Name:match("Elbow") then constraintType = "Hinge" constraint = Instance.new("HingeConstraint") constraint.LimitsEnabled = true constraint.LowerAngle = -70 -- Example limits, adjust as needed constraint.UpperAngle = 10 constraint.AngularResponsiveness = 50 -- Allow some springiness else -- BallSocket for others (hips, shoulders, spine, neck) constraint = Instance.new("BallSocketConstraint") constraint.LimitsEnabled = true constraint.UpperAngle = 45 -- General limit constraint.TwistLimitsEnabled = true constraint.TwistLowerAngle = -30 constraint.TwistUpperAngle = 30 constraint.AngularResponsiveness = 50 end constraint.Name = joint.Name .. "_RagdollConstraint" constraint.Attachment0 = a1 constraint.Attachment1 = a2 constraint.Parent = part0 -- Or part1, doesn't strictly matter -- Store constraint info for potential later use or cleanup table.insert(jointConstraints, { constraint = constraint, a1 = a1, a2 = a2, type = constraintType, originalJointData = { Name = joint.Name, Parent = joint.Parent, Part0 = joint.Part0, Part1 = joint.Part1, C0 = joint.C0, C1 = joint.C1 } }) joint:Destroy() -- Remove the Motor6D end end end -- Apply Anti-Gravity Force (applied to torso for better stability) local antiGravForce = Instance.new("VectorForce") antiGravForce.Name = "AntiGravityForce" antiGravForce.Attachment0 = createAttachment(torso, "AntiGravityAtt") antiGravForce.RelativeTo = Enum.ActuatorRelativeTo.World antiGravForce.ApplyAtCenterOfMass = true antiGravForce.Force = Vector3.new(0, totalMass * workspace.Gravity * BALANCE_CONFIG.AntiGravityFactor, 0) antiGravForce.Parent = torso physicsConstraints[antiGravForce.Name] = antiGravForce -- Apply Damping via Torques (simulates air resistance / joint friction) local torsoDamping = Instance.new("Torque") torsoDamping.Name = "TorsoAngularDamping" torsoDamping.Attachment0 = createAttachment(torso, "TorsoDampAtt") torsoDamping.RelativeTo = Enum.ActuatorRelativeTo.World torsoDamping.Parent = torso physicsConstraints[torsoDamping.Name] = torsoDamping -- Add similar damping for limbs if needed (can be complex to manage individually) end -- Foot Planting Logic local function updateFootPlanting(dt, totalMass) local down = Vector3.new(0, -1, 0) local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude local plantForceMagnitude = totalMass * workspace.Gravity * BALANCE_CONFIG.FootPlantForceFactor for _, footName in pairs({"LeftFoot", "RightFoot"}) do local footPart = character:FindFirstChild(footName) if footPart then local forceName = footName .. "_PlantForce" local existingForce = physicsConstraints[forceName] -- Don't plant the stepping foot if steppingFootName == footName then if existingForce then existingForce.Enabled = false end continue end -- Raycast down from slightly above the foot local origin = footPart.Position + Vector3.new(0, 0.5, 0) local result = workspace:Raycast(origin, down * 1.5, raycastParams) if result and result.Instance.CanCollide then local groundPos = result.Position local distToGround = (footPart.Position - groundPos).Magnitude -- Apply planting force if close enough to the ground if distToGround < 0.75 then -- Allow force slightly before contact if not existingForce then local force = Instance.new("VectorForce") force.Name = forceName force.Attachment0 = createAttachment(footPart, "PlantForceAtt") force.RelativeTo = Enum.ActuatorRelativeTo.World force.ApplyAtCenterOfMass = true force.Force = Vector3.new(0, -plantForceMagnitude, 0) -- Apply downward force force.Parent = footPart physicsConstraints[forceName] = force else existingForce.Enabled = true existingForce.Force = Vector3.new(0, -plantForceMagnitude, 0) end elseif existingForce then existingForce.Enabled = false -- Disable force if foot is too high end elseif existingForce then existingForce.Enabled = false -- Disable force if no ground detected end end end end -- Active Balancing Logic local function updateActiveBalance(dt, totalMass) stepCooldown = math.max(0, stepCooldown - dt) local leftFoot = character:FindFirstChild("LeftFoot") local rightFoot = character:FindFirstChild("RightFoot") if not leftFoot or not rightFoot or not torso or not rootPart then return end -- 1. Calculate Current State local comPos, comVel = calculateCOM() local torsoRotVel = torso.AssemblyAngularVelocity local leftPos = leftFoot.Position local rightPos = rightFoot.Position -- Determine support base center (average foot position on the ground plane) local groundY = math.min(leftPos.Y, rightPos.Y) -- Approximate ground plane supportCenter = (Vector3.new(leftPos.X, groundY, leftPos.Z) + Vector3.new(rightPos.X, groundY, rightPos.Z)) / 2 -- Calculate Lean Vector (COM relative to support center, projected onto ground plane) local comGroundProj = Vector3.new(comPos.X, groundY, comPos.Z) local leanOffset = comGroundProj - supportCenter -- Factor in Velocity (predictive lean) - where will COM be shortly? local predictedOffset = leanOffset + Vector3.new(comVel.X, 0, comVel.Z) * BALANCE_CONFIG.VelocityInfluence -- Factor in Angular Velocity (rotational influence) - leaning due to spin? -- Project angular velocity onto world axes to estimate lean direction local angularLeanEffect = Vector3.new(-torsoRotVel.Z, 0, torsoRotVel.X) * BALANCE_CONFIG.AngularVelocityInfluence currentLean = predictedOffset + angularLeanEffect local leanMagnitude = currentLean.Magnitude -- 2. Apply Corrective Torques (Torso/Hip and Arms) local torsoTargetUp = Vector3.new(0, 1, 0) local torsoCurrentUp = torso.CFrame.UpVector local correctionAxis = torsoCurrentUp:Cross(torsoTargetUp).Unit local correctionAngle = math.acos(torsoCurrentUp:Dot(torsoTargetUp)) -- Apply torque to keep torso upright AND counter the lean local uprightTorque = correctionAxis * correctionAngle * BALANCE_CONFIG.TorsoLeanCorrectionForce * 0.5 -- Base upright force local leanCorrectionTorque = Vector3.new(-currentLean.Z, 0, currentLean.X) * BALANCE_CONFIG.TorsoLeanCorrectionForce -- Counter lean local totalTorsoTorque = uprightTorque + leanCorrectionTorque -- Clamp torque if totalTorsoTorque.Magnitude > BALANCE_CONFIG.TorsoLeanCorrectionForce then totalTorsoTorque = totalTorsoTorque.Unit * BALANCE_CONFIG.TorsoLeanCorrectionForce end local torsoTorqueConstraint = physicsConstraints["BalanceTorque"] if not torsoTorqueConstraint then torsoTorqueConstraint = Instance.new("Torque") torsoTorqueConstraint.Name = "BalanceTorque" torsoTorqueConstraint.Attachment0 = createAttachment(torso, "BalanceTorqueAtt") torsoTorqueConstraint.RelativeTo = Enum.ActuatorRelativeTo.World torsoTorqueConstraint.Parent = torso physicsConstraints["BalanceTorque"] = torsoTorqueConstraint end torsoTorqueConstraint.Torque = totalTorsoTorque -- Apply Arm Balancing Torques (Simplified) local leftArm = character:FindFirstChild("LeftUpperArm") local rightArm = character:FindFirstChild("RightUpperArm") if leftArm and rightArm then local armLeanCorrection = Vector3.new(currentLean.Z, 0, -currentLean.X) * BALANCE_CONFIG.ArmBalanceCorrectionForce -- Apply opposite torques to arms based on lean direction local leftArmTorque = physicsConstraints["LeftArmBalanceTorque"] if not leftArmTorque then leftArmTorque = Instance.new("Torque"); leftArmTorque.Name = "LeftArmBalanceTorque"; leftArmTorque.Attachment0 = createAttachment(leftArm, "ArmBalanceAtt"); leftArmTorque.RelativeTo = Enum.ActuatorRelativeTo.World; leftArmTorque.Parent = leftArm; physicsConstraints[leftArmTorque.Name] = leftArmTorque end leftArmTorque.Torque = armLeanCorrection local rightArmTorque = physicsConstraints["RightArmBalanceTorque"] if not rightArmTorque then rightArmTorque = Instance.new("Torque"); rightArmTorque.Name = "RightArmBalanceTorque"; rightArmTorque.Attachment0 = createAttachment(rightArm, "ArmBalanceAtt"); rightArmTorque.RelativeTo = Enum.ActuatorRelativeTo.World; rightArmTorque.Parent = rightArm; physicsConstraints[rightArmTorque.Name] = rightArmTorque end rightArmTorque.Torque = -armLeanCorrection end -- Apply Angular Damping to Torso local torsoDampConstraint = physicsConstraints["TorsoAngularDamping"] if torsoDampConstraint then torsoDampConstraint.Torque = -torso.AssemblyAngularVelocity * torso:GetMass() * BALANCE_CONFIG.TorsoAngularDamping end -- 3. Handle Stepping Logic if steppingFootName then -- Currently stepping, update progress and check for completion local footPart = character:FindFirstChild(steppingFootName) if footPart and stepTargetPosition then stepProgress = math.min(stepProgress + dt / BALANCE_CONFIG.StepDuration, 1) local currentFootPos = footPart.Position local targetXZ = Vector3.new(stepTargetPosition.X, 0, stepTargetPosition.Z) local currentXZ = Vector3.new(currentFootPos.X, 0, currentFootPos.Z) local distToTargetXZ = (targetXZ - currentXZ).Magnitude -- Check for step completion local leanCorrected = leanMagnitude < BALANCE_CONFIG.LeanThreshold * 0.5 -- Allow completion if balance is regained if distToTargetXZ < BALANCE_CONFIG.StepCompletionDistance or (stepProgress >= 1 and leanCorrected) then -- Finish Step local stepAlign = physicsConstraints[steppingFootName .. "_StepAlign"] if stepAlign then stepAlign.Enabled = false end lastSteppedFoot = steppingFootName steppingFootName = nil stepTargetPosition = nil stepProgress = 0 -- Ensure foot plants firmly after step task.wait(0.05) -- Short delay to allow physics to settle slightly local plantForce = physicsConstraints[lastSteppedFoot .. "_PlantForce"] if plantForce then plantForce.Enabled = true end else -- Continue Step: Update AlignPosition target with lift arc local stepAlign = physicsConstraints[steppingFootName .. "_StepAlign"] if stepAlign then local liftHeight = BALANCE_CONFIG.StepLiftHeight * math.sin(stepProgress * math.pi) -- Sine arc for lift local rayParamsStep = RaycastParams.new() rayParamsStep.FilterDescendantsInstances = {character} rayParamsStep.FilterType = Enum.RaycastFilterType.Exclude local rayOriginStep = Vector3.new(stepTargetPosition.X, comPos.Y + 2, stepTargetPosition.Z) -- Raycast from above COM height local rayResultStep = workspace:Raycast(rayOriginStep, Vector3.new(0, -5, 0), rayParamsStep) local targetGroundY = rayResultStep and rayResultStep.Position.Y or groundY stepAlign.Position = Vector3.new(stepTargetPosition.X, targetGroundY + liftHeight, stepTargetPosition.Z) stepAlign.Enabled = true -- Ensure it's enabled end end else -- Foot lost or target lost, cancel step steppingFootName = nil stepTargetPosition = nil stepProgress = 0 end return -- Don't try to start a new step while one is in progress end -- 4. Decide IF to Step if stepCooldown > 0 or leanMagnitude < BALANCE_CONFIG.StepTriggerThreshold then return -- Not leaning enough or still cooling down end -- 5. Plan the Step local isStumbling = leanMagnitude > BALANCE_CONFIG.StumbleTriggerThreshold local stepUrgency = math.clamp((leanMagnitude - BALANCE_CONFIG.StepTriggerThreshold) / (BALANCE_CONFIG.StumbleTriggerThreshold - BALANCE_CONFIG.StepTriggerThreshold), 0, 1) -- Determine which foot to step with (alternate, or use the one further from the lean direction) local footToStepPart local stationaryFootPart local leanDir = currentLean.Unit local leftDot = (leftPos - comPos):Dot(leanDir) local rightDot = (rightPos - comPos):Dot(leanDir) -- Generally step with the foot "behind" the lean direction, or alternate if balanced if math.abs(leftDot - rightDot) < 0.1 then -- If feet are roughly equidistant along lean axis, alternate footToStepPart = (lastSteppedFoot == "LeftFoot") and rightFoot or leftFoot else -- Otherwise, step with the foot further away from the lean direction footToStepPart = (leftDot > rightDot) and leftFoot or rightFoot end steppingFootName = footToStepPart.Name stationaryFootPart = (steppingFootName == "LeftFoot") and rightFoot or leftFoot -- Calculate Step Target Position local stepDist = BALANCE_CONFIG.StepBaseDistance + (BALANCE_CONFIG.StepLeanFactor * leanMagnitude) + (BALANCE_CONFIG.StepVelocityFactor * comVel.Magnitude * stepUrgency) local stepDir = currentLean.Unit -- Step directly towards the perceived lean -- Add stance width offset relative to the stationary foot local rootRight = rootPart.CFrame.RightVector local stanceDir = (steppingFootName == "LeftFoot") and -rootRight or rootRight local stanceOffset = stanceDir * (BALANCE_CONFIG.StanceWidth / 2) -- Base target relative to stationary foot + lean correction + stance width local targetPosRelative = stepDir * stepDist + stanceOffset local targetPosWorld = stationaryFootPart.Position + targetPosRelative -- Raycast down to find ground height at target local rayParamsPlan = RaycastParams.new() rayParamsPlan.FilterDescendantsInstances = {character} rayParamsPlan.FilterType = Enum.RaycastFilterType.Exclude local rayOriginPlan = Vector3.new(targetPosWorld.X, comPos.Y + 2, targetPosWorld.Z) local rayResultPlan = workspace:Raycast(rayOriginPlan, Vector3.new(0, -10, 0), rayParamsPlan) local targetGroundY = rayResultPlan and rayResultPlan.Position.Y or groundY stepTargetPosition = Vector3.new(targetPosWorld.X, targetGroundY, targetPosWorld.Z) -- Store the ground target stepProgress = 0 -- Reset progress for the new step -- 6. Initiate Step (Using AlignPosition) local stepAlign = physicsConstraints[steppingFootName .. "_StepAlign"] if not stepAlign then stepAlign = Instance.new("AlignPosition") stepAlign.Name = steppingFootName .. "_StepAlign" stepAlign.Mode = Enum.PositionAlignmentMode.OneAttachment stepAlign.Attachment0 = createAttachment(footToStepPart, "StepAlignAtt") stepAlign.MaxForce = BALANCE_CONFIG.StepAlignForce stepAlign.Responsiveness = BALANCE_CONFIG.StepResponsiveness * (isStumbling and 1.5 or 1) -- Faster response if stumbling stepAlign.ApplyAtCenterOfMass = true -- Apply force correctly stepAlign.Parent = footToStepPart physicsConstraints[stepAlign.Name] = stepAlign end -- Initial target includes some lift local initialLift = BALANCE_CONFIG.StepLiftHeight * 0.1 -- Start slightly lifted stepAlign.Position = Vector3.new(stepTargetPosition.X, stepTargetPosition.Y + initialLift, stepTargetPosition.Z) stepAlign.Enabled = true -- Disable planting force on the stepping foot local plantForce = physicsConstraints[steppingFootName .. "_PlantForce"] if plantForce then plantForce.Enabled = false end stepCooldown = BALANCE_CONFIG.StepCooldownTime * (isStumbling and 0.5 or 1) -- Shorter cooldown if stumbling end -- Function to activate ragdoll physics local function makeRagdoll() if isRagdolled then return end isRagdolled = true print("Making Ragdoll") clearRagdollPhysics() -- Clear any previous state first -- Disable standard humanoid physics control humanoid:ChangeState(Enum.HumanoidStateType.Physics) humanoid.PlatformStand = false -- Allow physics to take over fully -- Set part properties for ragdoll local totalMass = 0 for part, data in pairs(originalCollisions) do if part and part.Parent then part.CanCollide = true -- Enable collisions for most parts part.Massless = false PhysicsService:SetPartCollisionGroup(part, "Ragdoll") part.CustomPhysicalProperties = PhysicalProperties.new( data.CustomPhysicalProperties and data.CustomPhysicalProperties.Density or 1, data.CustomPhysicalProperties and data.CustomPhysicalProperties.Friction or 0.5, data.CustomPhysicalProperties and data.CustomPhysicalProperties.Elasticity or 0.1, BALANCE_CONFIG.LimbAngularDamping, -- Use config for damping 1 -- Elasticity weight ) if part == rootPart then part.CanCollide = false -- Keep HRP non-collidable PhysicsService:SetPartCollisionGroup(part, "Default") -- Keep HRP out of ragdoll group end totalMass = totalMass + part:GetMass() end end totalMass = math.max(totalMass, 1) -- Create the physical joints createRagdollJoints() -- Start the balancing loop stepConnection = RunService.Stepped:Connect(function(t, dt) local currentTotalMass = getTotalMass() -- Recalculate in case parts are added/removed? (Optional) updateFootPlanting(dt, currentTotalMass) updateActiveBalance(dt, currentTotalMass) -- Update anti-gravity force based on current mass local antiGrav = physicsConstraints["AntiGravityForce"] if antiGrav then antiGrav.Force = Vector3.new(0, currentTotalMass * workspace.Gravity * BALANCE_CONFIG.AntiGravityFactor, 0) end end) end -- Function to reset character from ragdoll local function resetCharacter() if not isRagdolled then return end isRagdolled = false print("Resetting Character") clearRagdollPhysics() -- Remove all ragdoll constraints and forces -- Re-create Motor6Ds (This is the tricky part) -- We stored original joint data in `jointConstraints` table for _, data in pairs(jointConstraints) do local oj = data.originalJointData if oj.Part0 and oj.Part0.Parent and oj.Part1 and oj.Part1.Parent then -- Check if parts still exist local motor = Instance.new("Motor6D") motor.Name = oj.Name motor.Part0 = oj.Part0 motor.Part1 = oj.Part1 motor.C0 = oj.C0 motor.C1 = oj.C1 motor.Parent = oj.Parent -- Re-parent to original location (e.g., Torso) end end -- Clear the stored joint data after recreating -- Note: jointConstraints was already cleared in clearRagdollPhysics, this loop reads a temporary copy if needed -- Restore original part properties for part, data in pairs(originalCollisions) do if part and part.Parent then part.CanCollide = data.CanCollide part.Massless = data.Massless PhysicsService:SetPartCollisionGroup(part, data.CollisionGroupId and PhysicsService:GetCollisionGroupName(data.CollisionGroupId) or "Default") part.CustomPhysicalProperties = data.CustomPhysicalProperties -- Reset velocities? Optional, might look more natural if they keep some momentum briefly. -- part.AssemblyLinearVelocity = Vector3.zero -- part.AssemblyAngularVelocity = Vector3.zero end end -- Restore humanoid state humanoid:ChangeState(Enum.HumanoidStateType.GettingUp) -- Triggers the getting up animation/state task.wait(0.1) -- Give it a moment before potentially enabling PlatformStand again if needed humanoid.PlatformStand = true -- Re-enable to prevent default physics interference after reset end -- Event Connections humanoid.Died:Connect(function() if not isRagdolled then task.wait(0.05) -- Short delay after death event makeRagdoll() end -- Ensure the balancing loop stops on death if it was somehow still running without ragdoll state if stepConnection and humanoid.Health <= 0 then stepConnection:Disconnect() stepConnection = nil end end) -- Toggle Ragdoll with 'R' key (only if alive) UserInputService.InputBegan:Connect(function(input, gameProcessed) if not gameProcessed and input.UserInputType == Enum.UserInputType.Keyboard then if input.KeyCode == Enum.KeyCode.R then if humanoid.Health > 0 then if isRagdolled then resetCharacter() else makeRagdoll() end end end end end) -- Initial state (optional - start ragdolled?) -- task.wait(2) -- Wait for character to load -- makeRagdoll() **How to Use:** 1. Place this script inside a `StarterCharacterScripts` in Roblox Studio. 2. When the player's character spawns, the script will initialize. 3. Press the 'R' key to toggle the active balancing ragdoll on and off (only works if the character is alive). 4. If the character dies, it will automatically enter the ragdoll state. **Key Improvements in this Version:** * **Predictive Balancing:** Considers COM velocity and torso angular velocity to anticipate instability. * **Active Torso/Hip Correction:** Applies `Torque` to the torso to counteract lean *before* needing to step. * **Basic Arm Balancing:** Applies opposing torques to upper arms based on lean direction. * **Adaptive Stepping:** Step distance and responsiveness adjust based on how severe the imbalance is (including a basic "stumble" urgency). * **Stance Width Maintenance:** Steps aim to maintain a defined distance between feet. * **Refined Foot Planting:** Uses raycasting and applies downward force when the foot is near the ground. * **Hinge Constraints:** Uses `HingeConstraint` for knees/elbows for more realistic joint movement (can be adjusted). * **Collision Groups:** Uses physics collision groups to prevent self-collision within the ragdoll. * **Damping:** Applies angular damping via torques to prevent excessive spinning and oscillations. * **Cleaner State Management:** Improved functions for entering (`makeRagdoll`) and exiting (`resetCharacter`) the ragdoll state. * **Configuration Block:** `BALANCE_CONFIG` table at the top makes tuning easier. **Further Potential Enhancements (Complexity Increases):** * **True Muscle Simulation:** Use `Servo` constraints on joints with target angles/velocities controlled by PID controllers to simulate muscle tension and posture maintenance. * **Advanced Stumbling:** More complex stumble animations/sequences involving multiple rapid steps, arm flailing, or even falling transitions. * **Getting Up Sequence:** A physics-based getting up routine instead of relying solely on `Humanoid.GettingUp`. * **Environmental Interaction:** Reacting to slopes, stairs, and dynamic objects. * **Collision Reactions:** Flinching, bracing, or specific reactions when parts of the body collide with objects. * **More Detailed COM:** Include lower limbs/arms in COM calculation for higher fidelity. This updated script provides a significant step towards more dynamic and humanlike balancing. Remember that achieving a true Euphoria level of realism requires extensive tuning and potentially more complex physics simulation techniques.