Physical characters

A physical character keeps playing its animation and physically exists. Players can grab its wrist and pull, shove it in the chest, knock it off balance, and watch it get back up — all while it carries on doing whatever it was doing.

This is not a ragdoll toggle. Animation says what the character wants to do; physics decides what actually happens. A strong character resists you. A weak one goes where you push it.

Add it

1. Select a humanoid character (its model's Rig must be set to Humanoid).
2. Add Component ▸ Social Scape ▸ Physical Character.

For a character you specifically want to pose, use Social Scape ▸ Make Poseable Character (NPC) instead — its Full Body Physical style adds this component with the posing dials on (pose on release, the segmented spine, carry, grab handles), and its Full Body Ik style builds a pure-IK mannequin with no physics at all, which is often the better tool when posing is the whole point. See Poseable Limbs.

That is the whole setup. The physics is built for you when the world runs, and nothing extra is added to what you upload — so you can add this to a character you have already published without re-uploading it.

Strength is the dial that matters

Overall scales everything. The per-part sliders decide where the character is strong.

Preset	Feels like
Strong	Hard to move, stays on its feet
Average	Movable, but it fights back
Weak	Easy to push around and knock over
Limp	Essentially a ragdoll
Zombie	Solid body, floppy limbs, poor balance
Heavy	Very hard to move, slow to go down

Start from a preset, then adjust. A character with strong legs and weak arms stays standing while its upper body gets shoved around — that reads very differently from one that is uniformly weak, even at the same Overall strength.

Grabbing

Allow Grab decides whether players can grab the character at all. Grab Strength is how hard a player's pull is: raise it above the character's strength and players win, lower it and they struggle. Break Force lets a strong character tear out of a hold — leave it at 0 and a grab never breaks.

Players grab whichever body part is nearest their hand. The same comfort settings that govern grabbing Social Bones apply here, and a player who has turned off being grabbed cannot be grabbed.

Picking a character up

Turn on Allow Carry and taking hold of the hips picks the whole character up — the body travels with your hand instead of the pelvis being dragged out of a character that stays standing where it was. Everything else keeps hanging and animating while you carry it.

Let go near the ground and the character is put down on it. Let go in mid-air and it falls, goes limp on landing, and gets back up on its own if Auto Recover is on.

Balance, falling and getting up

Balance decides how the character handles being knocked off its feet. There is nothing to assign — pick a style:

Balance	Behaviour
Standard	A normal person: resists, staggers, falls when overwhelmed, gets back up
Heavy	Hard to topple, and slow and heavy once it goes down
Fragile	Loses its footing easily and stays down longer
None	Never falls over — still grabbable and pushable, but always on its feet

Tilt Tolerance is how far it can lean before it starts losing its footing, and Stagger Time is how long it fights to stay up once it is past that lean. A character with a high tilt tolerance and a long stagger time is hard to topple and looks like it is really trying; a low one drops as soon as it wobbles.

Auto Recover stands the character back up after Recovery Delay seconds, and Recovery Strength decides whether it crawls up groggily or springs to its feet. It waits until nobody is still holding on, so a character does not try to get up while you have its arm. With Auto Recover off it stays down until a script calls Body.Recover().

Posing

Normally a limb springs back to its animation the moment you let go. Turn on Pose On Release and the character becomes posable: grab a wrist, place the arm, let go, and it holds — while the rest of the body carries on animating.

On a posable character, a grabbed part follows your hand or cursor one-for-one, and the limb behind it trails along like a puppet's. (On characters that are not posable, a grab is a contest — the character's strength fights yours. That mode is for gameplay.)

What you grab decides how it behaves. A hand, foot or the head is the thing itself: it follows in position and rotation, and turning your grip turns it. A knee, thigh, elbow or forearm is a bend handle: dragging it moves that point and the limb reorients around it naturally, while the foot or hand past it keeps its own orientation — dragging a knee never twists the foot on the end of it. (Turning a bend handle is still there when you want it: Shift-drag on desktop, or turning your wrist in VR.) Trunk parts — hips, spine, chest — carry everything hanging off them, so leaning the chest brings the arms and head with it, the way leaning does.

Posing works on whole limbs: releasing a hand poses the hand, forearm and upper arm together, wherever you left each of them. Bones past what you posed keep animating relative to it — pose a knee and the foot keeps doing its animated thing at the end of the posed shin.

The spine

A posable character's spine is built as separate segments — lower back, chest, and upper chest on rigs that have all three — so the back can genuinely curve. Grab each segment and pose it on its own to build a hunch, an arch or a twist. This turns on automatically with Pose On Release, because a spine made of one solid block can only bend in one place: pose it and the whole back pivots at that single joint, which reads as an unnatural arch and leaves you nothing to adjust.

Poseable Rig ticks the same thing on by itself, for a character you want the finer spine on without pose-on-release. Leave both off — the default — and the character keeps the simpler, cheaper rig, which is what you want for combat and for crowds.

How many segments you get depends on the rig: characters with a full spine chain get three, most get two, and a character with only a chest bone gets exactly what it always had. Nothing needs re-rigging.

A posed limb is still completely physical. It has weight, it collides with the world, players can grab it again and move it somewhere else, and a hard enough knock will shove it out of position — after which it springs back to the pose, not to the animation. Knocking the character down clears every pose, so it gets up animating normally.

Pose Holds decides what the pose is measured against:

• Body — the limb keeps its shape relative to the character and travels with it. Right for arms, heads and torsos: pose an arm pointing forward and it stays pointing forward as the character walks around.
• World — the limb stays where it is in the world while the body moves. Right for planting a foot on a specific spot. If the character walks away, its own joints drag the limb along, the way a really planted foot would.

The character picks one as its default, and a script can override it for a single limb — Body.PoseLimb("Guard", "leftFoot", "world") plants one foot on a character whose arms still travel with the body.

Impacts

Knockdown From Impacts lets a hard enough hit put the character on the floor. Knockdown Resistance is how much punishment it takes — 4 is an average person, higher shrugs hits off, lower crumples. Hits weaken the character rather than flooring it outright, so it goes down to one heavy blow or to several smaller ones in quick succession, and it recovers if you leave it alone.

Wobble

Settle (under Strength) controls how quickly the body stops moving after it is disturbed. Low values are loose and bouncy, high values settle almost instantly. 1 is the natural point where it comes to rest without overshooting.

Scripting

Body.Ragdoll("Guard")              // go limp
Body.Recover("Guard")              // get back up
Body.SetStrength("Guard", 0.3)     // 0 = limp, 1 = full strength
Body.SetBalance("Guard", 0.5)
Body.SetGrabResistance("Guard", 0.8)
Body.SetLimbStrength("Guard", "rightArm", 0.2)
Body.SetGrabbable("Guard", false)

Body.GetState("Guard")             // "animated" | "manipulated" | "staggering" |
                                      // "falling" | "ragdoll" | "recovering"
Body.IsHeld("Guard")               // is a player holding it right now?
Body.IsPhysical("Guard")           // false when it is too far away to simulate
Body.GetStrength("Guard")
Body.Exists("Guard")

Body.PoseLimb("Guard", "rightArm")            // hold this limb where it is now
Body.PoseLimb("Guard", "leftFoot", "world")   // ...planted in the world instead
Body.ReleaseLimb("Guard", "rightArm")         // back to the animation
Body.IsLimbPosed("Guard", "rightArm")
Body.ClearPose("Guard")                       // release every posed limb

Characters are addressed by their name in the scene.

Limb names for SetLimbStrength: head, torso, hips, leftArm, rightArm, leftLeg, rightLeg, or a specific bone — leftUpperArm, leftLowerArm, leftHand, rightUpperArm, rightLowerArm, rightHand, leftUpperLeg, leftLowerLeg, leftFoot, rightUpperLeg, rightLowerLeg, rightFoot.

On a character with the segmented spine you can also name spine and upperChest — so Body.PoseLimb("Guard", "spine") holds the lower back while the chest above it keeps moving. On a character without them the call simply does nothing.

Seeing it in the Scene view

The Show in Scene view section turns individual gizmos on and off — All / None buttons, then one toggle each:

• Skeleton — the stick figure that is actually simulated. This is the physics body, which is not always where the visible mesh is. It follows the spine setting, so a posable character shows its segmented back before you ever press Play.
• Collision Shapes — the capsules and head sphere physics really uses.
• Joint Limits — how far each joint can bend (drawn while the object is selected).
• Strength Tint — colours the skeleton red-to-green by strength, so weak spots are obvious at a glance.
• Grab Points — which body parts players can take hold of.
• Balance Axis — the upright line the fall test measures, and the tilt cone it can lean inside before it starts going down. Useful for understanding why a character falls when you think it should not.
• Centres Of Mass — where each bone's weight sits (Play mode only).

Before you press Play these draw a preview of the rig that will be built, so you can check proportions without entering Play mode.

Testing in the SDK

Physical characters work in the SDK — press Play and grab one.

On desktop, add an SSPhysicalDesktopPoser anywhere in the scene (the camera is a natural home) and turn on Show Grab Handles on the character. Every grab point appears as a sphere: point at one, hold the mouse button and drag the limb around, scroll to push it away or pull it closer, and let go.

To turn what you are holding, hold Shift while dragging: drag sideways and it turns the way you drag, drag up or down and it tips, and the scroll wheel rolls it — all relative to your view, from whatever angle you are looking.

While you are turning, the camera holds still and the mouse is captured, so the movement turns the limb instead of swinging your view at the same time. Both come back exactly as they were the moment you release Shift, and you are moving the limb again from wherever the turn left it. If the poser needs to suspend your own camera script to do that it says so in the console once; you can name the script in Camera Controller to have it suspend only that one.

Handles light up white under the cursor, amber while held, and green while holding a pose. R releases the poses on whatever you are pointing at, K knocks it down and L tells it to get up.

In VR, turning your hand turns the limb you are holding — the grab carries rotation as well as position.

In VR, add an SdkPhysicalGrabber to each hand of the test rig and grab with the grip.

Grab handles are a testing aid — turn Show Grab Handles off before players see it.

In a live world, players don't need any of this

The poser and the handles are for building. Once your world is published, players grab a character with their normal controls — right-click on desktop, grip in VR — and the platform aims from their own camera. You don't ship an SSPhysicalDesktopPoser, and you don't leave handles on.

If you do keep a poser in a published world, it now finds the local player's camera by itself. Previously it could not: a running client has several cameras (the player's view, UI, mirrors, portals), the player's isn't tagged MainCamera, and the poser gave up — so the handles still drew while nothing highlighted or could be grabbed, which looks exactly like the feature being broken. It now says so in the log instead of failing silently.

The SDK and the live platform run the same physics. Which body part you grab, what a grab does, strengths, balance, knockdown, recovery, states and the script API — and the solver underneath all of it — are the same code in both. An NPC that behaves correctly in the editor behaves the same way after uploading, including how heavy a pull feels and how a fall settles.

Multiplayer

Grabbing replicates. When a player takes hold of a physical character, everyone sees which part is held and where it is being pulled, keyed to the character so it works for NPCs as well as players.

Poses and knockdowns are shared. Pose a limb and everyone sees it posed — not just while you are holding it, but after you let go, after you walk away, and after you leave the world entirely. A player who joins later sees the character exactly as you left it. Knocking a character down is shared the same way, so a character on the floor is on the floor for everyone.

The simulation itself runs on each player's own machine. Every client works out the character's physics from the animation it is already playing, which is what keeps a physical character free of per-frame bone traffic. The fine detail therefore differs slightly between screens — the exact angle a knocked-down NPC settles at is each machine's own answer. What is shared is where you put things and whether the character is down, which is what players actually notice.

Because the pose belongs to the character rather than to you, the last player to move a limb is the one who decides where it is. Two people posing the same arm is resolved the same way as two people pressing the same button — one of them is last.

A script can set the same state for everyone from anywhere: Body.Ragdoll, Body.Recover and the pose calls all produce shared results.

Performance

Physical characters are the most expensive thing you can put in a world, so the platform manages them for you: nearby characters simulate fully, distant ones simulate more cheaply, far ones fall back to plain animation, and there is a ceiling on how many simulate at once — the nearest keep physics and the rest animate. A character a player is holding always simulates fully, however far away it is.

You do not need to configure any of this. It does mean a character can report Body.IsPhysical as false when nobody is near it, which is normal and not an error.

Rules and limits

• Humanoid rigs only. A non-humanoid character stays animated.
• One Physical Character component per character.
• Poseable limbs (Grab IK) and Physical Character do not mix on the same character — if both are present, physical wins and the poseable limbs are ignored. They do different jobs: poseable limbs let you arrange a character like a mannequin, physical characters let players shove a body around.
• Social Bones (hair, cloth, tails) work normally alongside a physical character.

Troubleshooting

Nothing is physical. Check the rig is Humanoid, that Physics Enabled is on, and — in Play mode — the status strip at the bottom of the inspector, which says whether it is simulating.

It can be grabbed but never falls over. Balance is set to None.

Players can barely move it. Grab Strength is low relative to the character's strength. Raise Grab Strength, or lower Overall.

It gets up too fast / too slowly. Recovery Delay.