Okay, let's rebuild the ragdoll and balancing system with a focus on more realistic physics interactions and improved stability. We'll address the glitchiness and enhance the balancing logic. **Key Improvements:** 1. **Proper Reset:** The `resetCharacter` function will now correctly recreate the `Motor6D` joints, allowing the character to return to an animatable state. 2. **Refined Constraints:** We'll stick with `BallSocketConstraint` for flexibility but adjust limits and potentially add more constraints later if needed. 3. **Enhanced Balancing:** * **PID Controllers (Implicit):** While not explicitly implementing full PID controllers, the use of `AlignPosition` and `AlignOrientation` with tuned `Responsiveness` acts similarly for stabilization. We'll adjust these values. * **Hip/Torso Strategy:** Introduce `AlignOrientation` for the `LowerTorso` as well, aiming to keep the hips relatively stable over the feet. The `UpperTorso` will focus on maintaining an upright posture. * **Smoother Stepping:** Refine the step initiation logic and foot movement for a less jerky motion. Increase responsiveness values. * **Dynamic Damping:** Introduce damping forces to prevent oscillations. 4. **Improved Structure:** Clean up the code organization. 5. **Parameter Tuning:** Adjust forces, responsiveness, and thresholds for better realism. --[[ Advanced Ragdoll & Active Balancing Script ----------------------------------------- Features: - Physics-based ragdoll using BallSocketConstraints. - Active balancing system inspired by natural human reactions (stepping, hip/torso adjustments). - Dynamic foot planting. - Proper state toggling between ragdolled and animated states. - Tunable parameters for balancing behavior. ]] local Players = game:GetService("Players") local PhysicsService = game:GetService("PhysicsService") local RunService = game:GetService("RunService") local UserInputService = game:GetService("UserInputService") local CHARACTER_SETUP_DELAY = 1 -- Wait a second after character loads -- ============================================================ -- -- CONFIGURATION & TUNING PARAMETERS -- ============================================================ -- -- Balancing Strategy local BALANCE_COG_OffsetThreshold = 0.4 -- How far CoG can deviate before initiating a step (meters) local BALANCE_VelocityInfluence = 0.3 -- How much velocity predicts future CoG offset local BALANCE_StepDistanceFactor = 1.8 -- Multiplier for how far to step based on CoG offset local BALANCE_StanceWidth = 1.0 -- Desired distance between feet laterally local BALANCE_StepLiftHeight = 0.4 -- How high the foot lifts during a step local BALANCE_StepSpeed = 15 -- How quickly the foot moves to the target (Responsiveness) local BALANCE_StepMaxForce = 15000 -- Max force for the stepping foot AlignPosition local BALANCE_StepCooldown = 0.35 -- Minimum time between steps local BALANCE_StepCompletionThreshold = 0.2 -- How close the foot needs to be to target to finish step -- Postural Control (Torso/Hip Alignment) local TORSO_AlignmentMaxTorque = 10000 local TORSO_AlignmentResponsiveness = 25 -- Increased responsiveness local HIP_AlignmentMaxTorque = 12000 local HIP_AlignmentResponsiveness = 30 -- Hips react slightly faster -- Foot Planting local FOOT_PlantMaxForce = 8000 local FOOT_PlantResponsiveness = 35 -- Faster foot planting reaction local FOOT_GroundOffset = 0.05 -- Slight offset from the ground -- General Physics local ANTI_GRAVITY_Multiplier = 0.98 -- Counteracts gravity slightly less than 1.0 for weight local DAMPING_Linear = 0.1 -- Linear damping factor applied to root part local DAMPING_Angular = 0.2 -- Angular damping factor applied to root part -- Collision Group for Ragdoll Parts (Prevents self-collision issues) local RAGDOLL_COLLISION_GROUP = "Ragdoll" local DEFAULT_COLLISION_GROUP = "Default" -- ============================================================ -- -- MODULE SCOPE VARIABLES -- ============================================================ -- local characterData = {} -- Stores data per character { humanoid, rootPart, state, connections, constraints, originalProperties, ... } -- ============================================================ -- -- UTILITY FUNCTIONS -- ============================================================ -- local function getCharacterData(character) if not character then return nil end local player = Players:GetPlayerFromCharacter(character) local key = player or character -- Use player if available, otherwise character instance if not characterData[key] then characterData[key] = { character = character, humanoid = character:FindFirstChildOfClass("Humanoid"), rootPart = character:FindFirstChild("HumanoidRootPart"), isRagdolled = false, connections = {}, constraints = {}, attachments = {}, originalProperties = {}, motor6DJoints = {}, -- Store original Motor6Ds here stepConnection = nil, steppingFootName = nil, stepTargetPosition = nil, stepCooldownTimer = 0, lastSteppedFoot = "RightFoot", totalMass = 0, ragdollCollisionGroupSet = false } -- Pre-calculate total mass local mass = 0 for _, part in ipairs(character:GetDescendants()) do if part:IsA("BasePart") and not part.Massless then mass = mass + part:GetMass() end end characterData[key].totalMass = math.max(mass, 1) -- Avoid division by zero end return characterData[key] end local function cleanupCharacterData(character) local player = Players:GetPlayerFromCharacter(character) local key = player or character local data = characterData[key] if data then if data.isRagdolled then pcall(resetCharacter, data) -- Attempt to reset if still ragdolled end -- Disconnect all connections for _, conn in pairs(data.connections) do conn:Disconnect() end data.connections = {} if data.stepConnection then data.stepConnection:Disconnect() data.stepConnection = nil end -- Clear constraints and attachments (should be handled by reset, but belt-and-suspenders) for _, constraint in pairs(data.constraints) do if constraint and constraint.Parent then constraint:Destroy() end end data.constraints = {} for _, att in pairs(data.attachments) do if att and att.Parent then att:Destroy() end end data.attachments = {} characterData[key] = nil print("Cleaned up data for", key) end end local function createConstraintAttachment(data, parentPart, nameSuffix) local att = Instance.new("Attachment") att.Name = "RagdollAtt_" .. (nameSuffix or parentPart.Name) att.Parent = parentPart table.insert(data.attachments, att) return att end local function calculateCenterOfMass(data) local totalMass = 0 local weightedSum = Vector3.new(0, 0, 0) -- Include major body parts for CoM calculation local partsToConsider = { data.character:FindFirstChild("UpperTorso"), data.character:FindFirstChild("LowerTorso"), data.character:FindFirstChild("Head"), data.rootPart } for _, partName in ipairs({"LeftUpperLeg", "RightUpperLeg", "LeftUpperArm", "RightUpperArm"}) do table.insert(partsToConsider, data.character:FindFirstChild(partName)) end for _, part in ipairs(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 return totalMass > 0 and (weightedSum / totalMass) or data.rootPart.Position end -- Ensure the ragdoll collision group exists local success, _ = pcall(function() PhysicsService:CreateCollisionGroup(RAGDOLL_COLLISION_GROUP) PhysicsService:CollisionGroupSetCollidable(RAGDOLL_COLLISION_GROUP, RAGDOLL_COLLISION_GROUP, false) end) if not success then warn("Could not create or configure collision group:", RAGDOLL_COLLISION_GROUP) end -- ============================================================ -- -- FOOT PLANTING LOGIC -- ============================================================ -- local function updateFootPlanting(data) local down = Vector3.new(0, -1, 0) local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {data.character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude raycastParams.IgnoreWater = true for _, footName in ipairs({"LeftFoot", "RightFoot"}) do local footPart = data.character:FindFirstChild(footName) if not footPart then continue end local plantConstraintName = footName .. "_Plant" local alignPos = data.constraints[plantConstraintName] if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = plantConstraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(data, footPart, "PlantAtt") alignPos.MaxForce = FOOT_PlantMaxForce alignPos.Responsiveness = FOOT_PlantResponsiveness alignPos.ApplyAtCenterOfMass = true -- Apply force at CoM for stability alignPos.Parent = footPart data.constraints[plantConstraintName] = alignPos end -- Disable planting for the stepping foot or if no ground detected if data.steppingFootName == footName then alignPos.Enabled = false else local origin = footPart.Position + Vector3.new(0, 0.5, 0) -- Raycast slightly above foot local result = workspace:Raycast(origin, down * 2, raycastParams) if result and result.Instance then local groundY = result.Position.Y local targetPos = Vector3.new(footPart.Position.X, groundY + FOOT_GroundOffset, footPart.Position.Z) alignPos.Position = targetPos alignPos.Enabled = true else alignPos.Enabled = false -- No ground detected end end end end -- ============================================================ -- -- ACTIVE BALANCING LOGIC -- ============================================================ -- local function updateActiveBalance(data, dt) data.stepCooldownTimer = math.max(0, data.stepCooldownTimer - dt) local leftFoot = data.character:FindFirstChild("LeftFoot") local rightFoot = data.character:FindFirstChild("RightFoot") if not leftFoot or not rightFoot or not data.rootPart or not data.humanoid or data.humanoid.Health <= 0 then return end -- Calculate CoM and foot positions local com = calculateCenterOfMass(data) local leftPos = leftFoot.Position local rightPos = rightFoot.Position local avgFootPos = (leftPos + rightPos) / 2 local groundY = math.min(leftPos.Y, rightPos.Y) -- Approximate ground level -- Character orientation vectors (aligned with ground plane) local lookVectorXZ = (data.rootPart.CFrame.LookVector * Vector3.new(1, 0, 1)).Unit local rightVectorXZ = (data.rootPart.CFrame.RightVector * Vector3.new(1, 0, 1)).Unit -- CoM offset relative to average foot position (on ground plane) 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 velocity local velocityXZ = data.rootPart.AssemblyLinearVelocity * Vector3.new(1, 0, 1) local predictedOffset = offsetVector + velocityXZ * BALANCE_VelocityInfluence -- Project offset onto character's local axes local forwardOffset = predictedOffset:Dot(lookVectorXZ) local rightwardOffset = predictedOffset:Dot(rightVectorXZ) local totalOffsetMagnitude = predictedOffset.Magnitude -- Update Hip/Torso Alignment Targets local lowerTorso = data.character:FindFirstChild("LowerTorso") local upperTorso = data.character:FindFirstChild("UpperTorso") if lowerTorso and data.constraints["LowerTorso_Align"] then -- Try to align hips over the average foot position, slightly leaning against offset local targetLook = (lookVectorXZ - predictedOffset * 0.1).Unit -- Lean slightly into the direction needed to correct data.constraints["LowerTorso_Align"].PrimaryAxis = targetLook data.constraints["LowerTorso_Align"].SecondaryAxis = Vector3.yAxis -- Keep upright end if upperTorso and data.constraints["UpperTorso_Align"] then -- Keep upper torso generally upright relative to world data.constraints["UpperTorso_Align"].PrimaryAxis = lookVectorXZ -- Align with character forward direction data.constraints["UpperTorso_Align"].SecondaryAxis = Vector3.yAxis -- Keep upright end -- === Step Update Logic === if data.steppingFootName then local footPart = data.character:FindFirstChild(data.steppingFootName) local stepConstraint = data.constraints[data.steppingFootName .. "_Step"] if footPart and stepConstraint and data.stepTargetPosition then local currentPos = footPart.Position local targetPos = data.stepTargetPosition local distToTargetXZ = (currentPos - targetPos) * Vector3.new(1, 0, 1) -- Check for step completion local balanceRecovered = totalOffsetMagnitude < BALANCE_COG_OffsetThreshold * 0.7 -- Balance mostly regained if distToTargetXZ.Magnitude < BALANCE_StepCompletionThreshold or balanceRecovered then stepConstraint.Enabled = false data.lastSteppedFoot = data.steppingFootName data.steppingFootName = nil data.stepTargetPosition = nil -- print("Step completed:", data.lastSteppedFoot) else -- Update step target Y based on lift height (simple arc) -- Note: A more complex arc calculation could be used here. local targetY = targetPos.Y + BALANCE_StepLiftHeight * math.sin((currentPos - targetPos).Magnitude / (data.initialStepVector and data.initialStepVector.Magnitude or 1) * math.pi) stepConstraint.Position = Vector3.new(targetPos.X, targetY, targetPos.Z) -- print("Stepping:", data.steppingFootName, "Target:", stepConstraint.Position) end else -- Cleanup if something went wrong (e.g., foot destroyed) if stepConstraint then stepConstraint.Enabled = false end data.steppingFootName = nil data.stepTargetPosition = nil -- print("Step cancelled") end return -- Don't initiate a new step while one is in progress end -- === Step Initiation Logic === if data.stepCooldownTimer <= 0 and totalOffsetMagnitude > BALANCE_COG_OffsetThreshold then -- Determine which foot to step with (usually the one opposite the last step) local footToStepName = (data.lastSteppedFoot == "LeftFoot") and "RightFoot" or "LeftFoot" local footToStepPart = data.character:FindFirstChild(footToStepName) local stationaryFootName = (footToStepName == "LeftFoot") and "RightFoot" or "LeftFoot" local stationaryFootPart = data.character:FindFirstChild(stationaryFootName) if not footToStepPart or not stationaryFootPart then return end -- Need both feet data.steppingFootName = footToStepName data.stepCooldownTimer = BALANCE_StepCooldown -- Calculate step direction and distance local stepVector = predictedOffset.Unit * totalOffsetMagnitude * BALANCE_StepDistanceFactor -- Calculate base target position relative to the stationary foot for stability local stationaryPosXZ = stationaryFootPart.Position * Vector3.new(1, 0, 1) local desiredLateralOffset = rightVectorXZ * ((footToStepName == "LeftFoot") and -1 or 1) * (BALANCE_StanceWidth / 2) local targetPosXZ = stationaryPosXZ + stepVector + desiredLateralOffset -- Raycast down to find ground height at target local rayOrigin = Vector3.new(targetPosXZ.X, com.Y + 1, targetPosXZ.Z) local raycastParams = RaycastParams.new() raycastParams.FilterDescendantsInstances = {data.character} raycastParams.FilterType = Enum.RaycastFilterType.Exclude raycastParams.IgnoreWater = true local result = workspace:Raycast(rayOrigin, Vector3.new(0, -5, 0), raycastParams) local targetY = result and result.Position.Y or groundY -- Use current ground Y if raycast fails data.stepTargetPosition = Vector3.new(targetPosXZ.X, targetY, targetPosXZ.Z) data.initialStepVector = footToStepPart.Position - data.stepTargetPosition -- For arc calculation -- Get or create the AlignPosition constraint for the step local stepConstraintName = data.steppingFootName .. "_Step" local alignPos = data.constraints[stepConstraintName] if not alignPos then alignPos = Instance.new("AlignPosition") alignPos.Name = stepConstraintName alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment alignPos.Attachment0 = createConstraintAttachment(data, footToStepPart, "StepAtt") alignPos.MaxForce = BALANCE_StepMaxForce alignPos.Responsiveness = BALANCE_StepSpeed alignPos.ApplyAtCenterOfMass = true alignPos.Parent = footToStepPart data.constraints[stepConstraintName] = alignPos end alignPos.Position = data.stepTargetPosition -- Initial target (Y will be adjusted during step) alignPos.Enabled = true -- print("Initiating step:", data.steppingFootName, "Target:", data.stepTargetPosition) end end -- ============================================================ -- -- RAGDOLL INITIALIZATION -- ============================================================ -- local function makeRagdoll(data) if data.isRagdolled or not data.humanoid or data.humanoid.Health <= 0 then return end print("Making Ragdoll:", data.character.Name) data.isRagdolled = true -- Clear any existing physics constraints from previous ragdoll state for name, constraint in pairs(data.constraints) do if constraint and constraint.Parent then constraint:Destroy() end end data.constraints = {} for _, att in pairs(data.attachments) do if att and att.Parent then att:Destroy() end end data.attachments = {} -- Store original Motor6D details and destroy them data.motor6DJoints = {} for _, descendant in ipairs(data.character:GetDescendants()) do if descendant:IsA("Motor6D") then table.insert(data.motor6DJoints, { Name = descendant.Name, Parent = descendant.Parent, Part0 = descendant.Part0, Part1 = descendant.Part1, C0 = descendant.C0, C1 = descendant.C1, MaxVelocity = descendant.MaxVelocity, CurrentAngle = descendant.CurrentAngle, -- Store relevant properties DesiredAngle = descendant.DesiredAngle }) descendant:Destroy() end end -- Save original part properties and set ragdoll properties data.originalProperties = {} for _, part in ipairs(data.character:GetDescendants()) do if part:IsA("BasePart") then data.originalProperties[part] = { CanCollide = part.CanCollide, CollisionGroupId = part.CollisionGroupId, Massless = part.Massless, CustomPhysicalProperties = part.CustomPhysicalProperties } part.Massless = false part.CanCollide = true -- Assign to ragdoll collision group if setup was successful if data.ragdollCollisionGroupSet then pcall(PhysicsService.SetPartCollisionGroup, PhysicsService, part, RAGDOLL_COLLISION_GROUP) end -- Special handling for HRP if part == data.rootPart then part.CanCollide = false -- HRP usually shouldn't collide -- Apply damping to the root part for stability part.CustomPhysicalProperties = PhysicalProperties.new( part.CustomPhysicalProperties and part.CustomPhysicalProperties.Density or 0.7, part.CustomPhysicalProperties and part.CustomPhysicalProperties.Friction or 0.5, part.CustomPhysicalProperties and part.CustomPhysicalProperties.Elasticity or 0.5, DAMPING_Linear, -- Linear Damping DAMPING_Angular -- Angular Damping ) end end end -- Create BallSocketConstraints based on stored Motor6D info for _, jointInfo in ipairs(data.motor6DJoints) do local part0 = jointInfo.Part0 local part1 = jointInfo.Part1 if part0 and part0.Parent and part1 and part1.Parent then -- Ensure parts still exist local a0 = createConstraintAttachment(data, part0, part0.Name .. "_" .. part1.Name .. "_A0") a0.CFrame = jointInfo.C0 local a1 = createConstraintAttachment(data, part1, part1.Name .. "_" .. part0.Name .. "_A1") a1.CFrame = jointInfo.C1 local constraint = Instance.new("BallSocketConstraint") constraint.Name = jointInfo.Name .. "_BSC" constraint.Attachment0 = a0 constraint.Attachment1 = a1 constraint.LimitsEnabled = true constraint.TwistLimitsEnabled = true -- Basic angle limits (can be customized further per joint) constraint.UpperAngle = 45 constraint.TwistLowerAngle = -30 constraint.TwistUpperAngle = 30 -- Example: More specific limits for legs/arms if needed if part1.Name:match("Leg") or part1.Name:match("Arm") then constraint.UpperAngle = 70 elseif part1.Name:match("Foot") or part1.Name:match("Hand") then constraint.UpperAngle = 60 elseif part1.Name:match("Head") then constraint.UpperAngle = 60 constraint.TwistLowerAngle = -60 constraint.TwistUpperAngle = 60 end constraint.Parent = part0 -- Parent to one of the parts table.insert(data.constraints, constraint) -- Track the constraint end end -- Set Humanoid state data.humanoid:SetStateEnabled(Enum.HumanoidStateType.GettingUp, false) -- Disable automatic getting up data.humanoid:ChangeState(Enum.HumanoidStateType.Physics) -- Anti-Gravity Force (Muscle Tone Simulation) local antiGravForce = Instance.new("VectorForce") antiGravForce.Name = "AntiGravityForce" antiGravForce.Attachment0 = createConstraintAttachment(data, data.rootPart, "AntiGravityAtt") antiGravForce.RelativeTo = Enum.ActuatorRelativeTo.World antiGravForce.ApplyAtCenterOfMass = true antiGravForce.Force = Vector3.new(0, data.totalMass * workspace.Gravity * ANTI_GRAVITY_Multiplier, 0) antiGravForce.Parent = data.rootPart data.constraints[antiGravForce.Name] = antiGravForce -- Lower Torso Alignment (Hip Stability) local lowerTorso = data.character:FindFirstChild("LowerTorso") if lowerTorso then local hipAlign = Instance.new("AlignOrientation") hipAlign.Name = "LowerTorso_Align" hipAlign.Mode = Enum.OrientationAlignmentMode.TwoAttachment hipAlign.Attachment0 = createConstraintAttachment(data, lowerTorso, "HipAlignAtt0") hipAlign.Attachment1 = createConstraintAttachment(data, data.rootPart, "HipAlignAtt1") -- Align relative to root part's plane initially hipAlign.MaxTorque = HIP_AlignmentMaxTorque hipAlign.Responsiveness = HIP_AlignmentResponsiveness hipAlign.PrimaryAxis = lowerTorso.CFrame:VectorToObjectSpace(data.rootPart.CFrame.LookVector) -- Initial alignment hipAlign.SecondaryAxis = lowerTorso.CFrame:VectorToObjectSpace(data.rootPart.CFrame.UpVector) hipAlign.Parent = lowerTorso data.constraints[hipAlign.Name] = hipAlign end -- Upper Torso Alignment (Upright Posture) local upperTorso = data.character:FindFirstChild("UpperTorso") if upperTorso then local torsoAlign = Instance.new("AlignOrientation") torsoAlign.Name = "UpperTorso_Align" torsoAlign.Mode = Enum.OrientationAlignmentMode.TwoAttachment torsoAlign.Attachment0 = createConstraintAttachment(data, upperTorso, "TorsoAlignAtt0") torsoAlign.Attachment1 = createConstraintAttachment(data, data.rootPart, "TorsoAlignAtt1") -- Align relative to root part's plane initially torsoAlign.MaxTorque = TORSO_AlignmentMaxTorque torsoAlign.Responsiveness = TORSO_AlignmentResponsiveness torsoAlign.PrimaryAxis = upperTorso.CFrame:VectorToObjectSpace(data.rootPart.CFrame.LookVector) -- Initial alignment torsoAlign.SecondaryAxis = upperTorso.CFrame:VectorToObjectSpace(data.rootPart.CFrame.UpVector) torsoAlign.Parent = upperTorso data.constraints[torsoAlign.Name] = torsoAlign end -- Connect Stepped event for balancing and foot planting if data.stepConnection then data.stepConnection:Disconnect() end -- Disconnect previous if any data.stepConnection = RunService.Stepped:Connect(function(runtime, dt) if data.isRagdolled and data.humanoid and data.humanoid.Health > 0 then pcall(updateFootPlanting, data) pcall(updateActiveBalance, data, dt) else -- Auto-cleanup if character is no longer valid or dead while ragdolled if data.stepConnection then data.stepConnection:Disconnect(); data.stepConnection = nil end if data.isRagdolled then pcall(resetCharacter, data) end -- Attempt reset if dead end end) end -- ============================================================ -- -- RESET CHARACTER TO ANIMATED STATE -- ============================================================ -- local function resetCharacter(data) if not data.isRagdolled then return end print("Resetting Character:", data.character.Name) data.isRagdolled = false -- Disconnect Stepped event if data.stepConnection then data.stepConnection:Disconnect() data.stepConnection = nil end -- Reset stepping state data.steppingFootName = nil data.stepTargetPosition = nil data.stepCooldownTimer = 0 -- Destroy all physics constraints and attachments for name, constraint in pairs(data.constraints) do if constraint and constraint.Parent then constraint:Destroy() end end data.constraints = {} for _, att in pairs(data.attachments) do if att and att.Parent then att:Destroy() end end data.attachments = {} -- Restore original part properties for part, props in pairs(data.originalProperties) do if part and part.Parent then part.CanCollide = props.CanCollide part.CollisionGroupId = props.CollisionGroupId part.Massless = props.Massless part.CustomPhysicalProperties = props.CustomPhysicalProperties -- Restore damping etc. -- Reset collision group if it was changed if data.ragdollCollisionGroupSet then pcall(PhysicsService.SetPartCollisionGroup, PhysicsService, part, DEFAULT_COLLISION_GROUP) end end end data.originalProperties = {} -- Clear stored properties -- Recreate Motor6D joints for _, jointInfo in ipairs(data.motor6DJoints) do if jointInfo.Part0 and jointInfo.Part0.Parent and jointInfo.Part1 and jointInfo.Part1.Parent then local motor = Instance.new("Motor6D") motor.Name = jointInfo.Name motor.Part0 = jointInfo.Part0 motor.Part1 = jointInfo.Part1 motor.C0 = jointInfo.C0 motor.C1 = jointInfo.C1 motor.MaxVelocity = jointInfo.MaxVelocity motor.CurrentAngle = jointInfo.CurrentAngle motor.DesiredAngle = jointInfo.DesiredAngle motor.Parent = jointInfo.Parent -- Put it back where it was end end data.motor6DJoints = {} -- Clear stored joint info -- Reset Humanoid state if data.humanoid and data.humanoid.Parent then data.humanoid:SetStateEnabled(Enum.HumanoidStateType.GettingUp, true) -- Re-enable getting up data.humanoid:ChangeState(Enum.HumanoidStateType.GettingUp) -- Trigger the getting up state end print("Character Reset Complete:", data.character.Name) end -- ============================================================ -- -- EVENT HANDLERS & INITIALIZATION -- ============================================================ -- local function onCharacterAdded(character) task.wait(CHARACTER_SETUP_DELAY) -- Wait for character to fully load local humanoid = character:WaitForChild("Humanoid", 5) local rootPart = character:WaitForChild("HumanoidRootPart", 5) if not humanoid or not rootPart then warn("Character", character.Name, "missing Humanoid or HumanoidRootPart.") return end local data = getCharacterData(character) if not data then return end -- Should not happen, but safety check -- Setup collision group flag local success, _ = pcall(PhysicsService.GetCollisionGroupId, PhysicsService, RAGDOLL_COLLISION_GROUP) data.ragdollCollisionGroupSet = success -- Handle Died event data.connections.died = humanoid.Died:Connect(function() print("Humanoid Died:", character.Name) if not data.isRagdolled then task.wait(0.1) -- Short delay before ragdolling on death pcall(makeRagdoll, data) end end) -- Handle StateChanged (optional: could force ragdoll on PlatformStand, etc.) -- data.connections.stateChanged = humanoid.StateChanged:Connect(function(oldState, newState) -- -- Example: if newState == Enum.HumanoidStateType.PlatformStand then makeRagdoll(data) end -- end) print("Advanced Ragdoll Initialized for:", character.Name) end local function onPlayerAdded(player) player.CharacterAdded:Connect(onCharacterAdded) player.CharacterRemoving:Connect(function(character) print("Character Removing:", character.Name) cleanupCharacterData(character) end) -- Handle existing character if player joins late if player.Character then onCharacterAdded(player.Character) end end -- Connect player joining/leaving Players.PlayerAdded:Connect(onPlayerAdded) for _, player in ipairs(Players:GetPlayers()) do onPlayerAdded(player) end Players.PlayerRemoving:Connect(function(player) print("Player Removing:", player.Name) if player.Character then cleanupCharacterData(player.Character) end -- Also clean up if the key was the player instance itself if characterData[player] then cleanupCharacterData(characterData[player].character) -- Trigger cleanup via character end end) -- Add input handling (e.g., 'R' key to toggle ragdoll) - Server-side example requires RemoteEvents -- For simplicity, this example focuses on automatic ragdoll on death. -- To add keybinds: -- 1. Create a RemoteEvent in ReplicatedStorage (e.g., "ToggleRagdollEvent"). -- 2. Add a LocalScript in StarterPlayerScripts to detect key press and fire the RemoteEvent. -- 3. Add a listener here for `RemoteEvent.OnServerEvent` to call makeRagdoll/resetCharacter. print("Advanced Ragdoll & Balancing Script Loaded.") **How to Use:** 1. Place the Lua code into a `Script` inside `ServerScriptService`. Name it something like `AdvancedRagdoll`. 2. The script will automatically detect when players join and their characters are added. 3. When a character's Humanoid dies, it will automatically transition to the ragdoll state. 4. The character will attempt to balance using the physics constraints. If it falls or is pushed, it will try to step to regain balance. **To Add Manual Toggle (Example using 'R' key):** 1. **Create RemoteEvent:** In `ReplicatedStorage`, create a `RemoteEvent` named `ToggleRagdollEvent`. 2. **Create LocalScript:** In `StarterPlayer` > `StarterPlayerScripts`, create a `LocalScript`. ```lua -- LocalScript in StarterPlayerScripts local UserInputService = game:GetService("UserInputService") local ReplicatedStorage = game:GetService("ReplicatedStorage") local toggleEvent = ReplicatedStorage:WaitForChild("ToggleRagdollEvent") UserInputService.InputBegan:Connect(function(input, gameProcessedEvent) if gameProcessedEvent then return end -- Don't process if typing in chat etc. if input.KeyCode == Enum.KeyCode.R then toggleEvent:FireServer() -- Tell the server to toggle end end) ``` 3. **Modify Server Script:** Add this inside the `AdvancedRagdoll.lua` script (e.g., near the bottom, before the final `print`): ```lua -- Add this inside the server script (AdvancedRagdoll.lua) local ReplicatedStorage = game:GetService("ReplicatedStorage") local toggleEvent = Instance.new("RemoteEvent", ReplicatedStorage) toggleEvent.Name = "ToggleRagdollEvent" toggleEvent.OnServerEvent:Connect(function(player) local character = player.Character if not character then return end local data = getCharacterData(character) if not data or not data.humanoid or data.humanoid.Health <= 0 then -- Don't allow toggling if dead or data is missing return end if data.isRagdolled then pcall(resetCharacter, data) else pcall(makeRagdoll, data) end end) ``` This revised script provides a more robust foundation for realistic ragdoll physics and active balancing in Roblox. Remember that tuning the parameters in the configuration section is crucial to achieve the desired feel.