package.facepunch.sandbox

Deterministic, bounded recipes shared by the menu, host, clients and saved games.

Render surfaces and convex compound collision, including genuinely hollow pieces.

Recreates the model locally on every peer and after loading a save/dupe. Only the recipe is persistent; runtime model resource names are not portable.

Data passed to . Take objects out of to keep them, or set to true to stop the cleanup.

The client whose objects are being cleaned up, or null for the whole map.

The objects about to be removed.

Implement this on a to hear about cleanups.

Called on the host before the map, or one player's objects, are cleaned up.

Called on every machine after the host has cleaned up the map.

A system that tracks the baseline scene state and allows resetting the map to its original state. Removes all spawned props and restores destroyed map objects while leaving players untouched.

Set of GameObjects that existed in the original scene baseline.

Serialized data of baseline objects so we can restore them if destroyed.

Whether a baseline has been captured.

Call from SaveSystem before Game.ChangeScene() to snapshot the current baseline

Captures the current scene state as the baseline. All objects that exist at this point are considered part of the original map.

Determines if a GameObject is a player or belongs to a player.

Cleans up the scene by removing all spawned objects and restoring destroyed baseline objects. Players and their belongings are preserved.

Console command to cleanup the map.

Engages a visible player: close the gap, fire a burst, pause, then reposition to a flanking point. Cancels immediately if the target leaves sight.

The player to engage.

Weapon to fire. Should be a child component on the NPC's GameObject. Its NPC usage decides the engagement range, burst length and the rest between bursts.

Speed the NPC moves when engaging.

Speed the NPC strafes at when it repositions without sprinting.

Chance to reposition after a burst. Otherwise the NPC holds its ground and fires again.

Seconds to react before the first burst - set for a fresh contact, zero while a fight is already going. The NPC calls the contact out, turns to face it and brings its weapon up in this time, and won't fire before it's up however quickly those finish.

How long the target can drop out of sight (ducking behind something, a glimpse through a gap) before we give up on this engagement and go searching instead.

Radius around the current position to pick a flanking point.

Holds until the schedule's reaction time is up, however long the tasks before it took.

Pick a random position perpendicular to the NPC→target axis at . Snaps to navmesh if possible.

Hold a post, HL2-style: stand at ease facing the way we were posted, now and then glance around, and walk back to the post if a fight or search pulled us away from it.

Where to stand.

Which way to face while standing there.

Walking pace back to the post.

Further than this from the post (chased someone a long way), we hold where we are instead.

A combat NPC that searches for players, advances on them, fires in bursts, and repositions. When friendly, can be recruited to follow a player and engages hostile NPCs instead.

When true, this NPC is friendly to players and will follow them, engaging hostile NPCs. When false, this NPC targets players and friendly NPCs.

The weapon this NPC uses to attack. Its NPC usage decides the engagement range and burst cadence - the same soldier fights differently with a shotgun than an SMG.

Weapon prefabs to arm this NPC with - one is picked at random when it spawns, replacing . Empty keeps the prefab's weapon.

Skill multiplier on the weapon's NPC spread - 1 is a average shot, lower is more accurate.

Movement speed while engaging an enemy.

Walking pace while patrolling.

Cautious walking pace - sweeping for a hostile we've lost, checking out a noise, strafing to a new position. Kept to a walk; only fighting and hot pursuit break into a jog.

Each soldier moves up to this much faster or slower than the rest (0.05 = ±5%), so a squad doesn't move in lockstep. Keep it small - too much pushes a walk into a jog.

How long after the last intel on a hostile (seen, heard or called out) to keep searching for it.

Allies of the same faction within this range are told where a spotted hostile is.

Wander between random points when there's nothing going on, instead of holding a post.

How long the weapon stays up after the last sign of trouble before the NPC relaxes.

Seconds (min, max) to react to a fresh contact when caught at ease - weapon lowered.

Seconds (min, max) to react to a fresh contact when already alert - weapon up, searching or fighting.

Seconds a weapon dropped on death lies around before it's removed, if nobody picks it up.

How far a friendly NPC will follow a player before stopping.

The player this friendly NPC is following, if any.

Where we last saw, heard or were told a hostile was. Null when we've got nothing to go on.

Which way that hostile was moving, so a search can head where it was going.

Time since was last updated.

Swap the prefab's weapon for a random one from .

Remember where a hostile is (and which way it's heading).

Keep the last known position fresh from everything we sense, every think -- not just when a fight starts -- and tell nearby allies about anything we can see.

The last hostile we saw is gone - dead. If we were in the fight, remember where the body is so we can walk over and check, and stop hunting it.

How long it takes to react to spotting a hostile: longer when caught at ease (the weapon has to come up) than when already alert, plus a little more to pick out something far away.

Tell allies of our faction nearby where a hostile is. They'll come and help search, or join the fight once they see it themselves.

Drop the held weapon into the world where the hand was, so it survives the NPC's death and can be picked up. If nobody takes it within it's cleaned up.

Remove a gun we dropped, unless a player has picked it up since. A player who picked it up and dropped it again owns it now, so that drop is theirs to keep.

Wanders to random nearby points when no player is known.

Maximum distance from current position to pick a patrol destination.

Walking pace between patrol points.

Hunt for a hostile we can't see: run to where it was heading, look around, then sweep a couple of nearby spots at a cautious pace. Re-plans if fresh intel moves the last known position, and spotting the hostile preempts it with .

Speed to run to the last known position at.

Cautious speed to sweep the area at once we get there.

Chance to sweep a nearby spot after looking around, rather than holding where we lost them.

How far ahead to lead a moving hostile, in seconds of its last known velocity.

How far around the last known position to sweep.

How one NPC regards another entity. Drives target selection -- who to fight, follow, ignore, or flee from.

No strong feeling -- ignore them.

An ally -- protect or assist.

An enemy -- attack on sight.

A threat to avoid -- flee from them.

A disposition plus a priority. Priority breaks ties when an NPC must choose between several valid targets -- higher wins.

A disposition plus a priority. Priority breaks ties when an NPC must choose between several valid targets -- higher wins.

A minimal NPC to copy when making your own. This "curious villager" wanders around, and goes to investigate any gunshot or disturbance it hears nearby. Everything an NPC needs is here: 1. A -- who it is, so others know how to treat it. 2. Relationships -- who it fights / fears / likes (see ). 3. A -- what it wants to do right now. To put one in the world, make a prefab with this component plus a NavMeshAgent, a SkinnedModelRenderer (wire it to the Renderer field), and a Collider. The four AI layers (Senses, Navigation, Animation, Speech) are added for you automatically.

The built-in faction names -- an NPC's faction is its identity to others, like a Source engine NPC's class. These are plain strings so UGC NPCs can reuse them or invent their own; this list is just the common set so content interoperates.

Provides animation parameters and helpers for behaviors. Also handles look-at (eyes/head) and body turning via animator parameters. Synced properties replicate animation state to all clients.

How fast the body turns to face a look target, in degrees per second. Constant rate - an exponential turn covers most of a half-circle in its first moments, which reads as a jolting spin.

How far the head can aim away from the body, in degrees of yaw.

How quickly the head sweeps onto (and lets go of) a look target.

Play footstep sounds from the model's footstep animation events.

Overall footstep volume multiplier.

Current world-space target the Npc is looking at (if any). Host-only.

The GameObject being tracked as the look target, if any. Host-only.

Hold the weapon lowered, at ease, instead of up and ready. Synced to all clients.

Shows what's feeding the head every frame, to hunt down rhythmic jitter. Watch which value pulses: body yaw (someone rotating the object), aim (look target moving or flickering), or move params (animgraph input).

Look at a target for a limited time, overriding the persistent look target. The NPC aims at the target's eyes. Call again to extend - when it expires we fall back to the persistent target, if any.

Where a GameObject's eyes are - the "eyes" attachment if it has a model with one (players, NPCs), otherwise roughly head height above its position. The local player in first person is really "at" their camera, so on their own screen we look straight down the lens.

Where this NPC looks from.

Set a persistent look target that tracks a GameObject each frame.

Set a persistent look target at a fixed world position.

Clear the persistent look target. The NPC will stop tracking.

Ease the applied aim toward a desired direction and weight, clamped to what a neck can actually do. Every look path feeds through here, so the head sweeps onto targets instead of snapping, and never flip-flops on a target directly behind us.

Command this layer to look at a target (one-shot, no tracking).

Stop looking.

Returns true if the NPC body is facing the current look target within MaxHeadAngle.

Records move state for replication. Called by NavigationLayer on the host. All clients apply this each frame in OnUpdate.

Broadcasts the attack trigger to all clients so the animation plays everywhere.

Sets the holdtype so the NPC poses its arms for the held item - an option name on the animgraph's holdtype enum (e.g. "pistol"). Synced to all clients via HoldType.

A behavior layer provides specific services for tasks to use -- we don't use behavior layers for state, they are services.

The owning NPC

Optional debug string shown in the NPC debug overlay. Return null to skip.

Reset any runtime state on this layer.

Handles Npc navigation

The desired movement speed for the agent (its normal walk). Schedules can raise this.

Speed used to run when the destination is far away -- HL-style: walk when close, run when there's ground to cover. Acts as a floor, so a schedule that sets a higher (fleeing, charging) is never slowed down.

Distance beyond which the NPC breaks into a run.

When true (the default) the NPC turns to face the direction it's moving, so it runs forward. Combat schedules set this false to strafe -- face a target while moving.

How quickly the body turns to face the movement direction.

True while the agent is actually travelling. Standing NPCs are free to turn their body toward whatever they're looking at.

Command this layer to move to a target

Stop moving and forget the current move target.

Current navigation status — reached target, still moving, or failed.

Handles awareness and environmental scanning. Scans for all objects matching and caches them by tag. Whether a scanned object is a hostile target is decided by the NPC's disposition toward it (see ), not by tags.

Total horizontal field of view in degrees. Targets outside this cone aren't seen (they can still be heard, or noticed if they're right next to the NPC).

Hostiles moving slower than this can't be heard -- creep (crouch-walk) to sneak up on someone.

Which agents the NPC scans for and caches: "npc" for other NPCs, "player" for players. This is just the broad-phase filter -- disposition decides who counts as hostile.

Visible entities this NPC is disposed Fearful toward (things to flee from).

The most relevant disturbance (gunshot, death, etc.) this NPC currently senses, if any.

Find the nearest world stimulus this NPC can sense (ignoring its own noise).

Scan for all objects matching , bucket by tag, and populate the hostile-filtered / using the NPC's disposition toward each.

Check if we have line of sight to target

True if a target is within the NPC's forward field of view. Anything inside personal space is always in view -- you notice someone right next to you, even behind.

Get the nearest visible hostile target (anything this NPC is disposed Hostile toward).

Get the visible hostile this NPC should engage first: highest relationship priority, nearest breaking ties.

Get the nearest visible object with a specific tag.

Get the nearest visible entity this NPC regards with the given disposition (e.g. the nearest thing it's afraid of).

The nearest hostile we can hear moving -- inside and going faster than . Null when nobody's making noise.

A player inside our personal space who's moving toward us -- they're trying to get past and we're in their way. Returns null when nobody is barging in.

Resolve a scanned object's velocity from whatever movement source it has.

Get all visible objects with a specific tag from the cache.

Get all audible objects with a specific tag from the cache.

Manages NPC speech state and plays sound files.

The subtitle text of the current line, if any. Synced to all clients.

Whether the NPC is currently speaking. Voice lines usually have no subtitle, so this has to watch the sound itself, not just the subtitle text.

Minimum seconds between speeches.

A generic fallback sound (e.g. a grunt or mumble) played when we're talking without a specific sound.

Whether the cooldown has elapsed and the NPC can speak again.

Play a sound event, with its subtitle (if one exists) as the current speech. If is given, the NPC looks them in the eyes while talking.

Attempts to play a tagged sound event.

Play a sound event with an explicit subtitle override.

Attempts to play a tagged sound event with a subtitle.

Say a string message using the fallback sound, with the string as the subtitle.

Attempts to show a tagged message using the fallback sound.

Stop any current speech and sound.

Hitting something at or below this speed while airborne doesn't hurt - landing from a throw or a fall, or being slammed into a wall.

Hitting something at or above this speed is fatal.

Off our feet - thrown, dropped, or dangling from a physgun. Only NPCs that walk on the navmesh; ones that roll around on physics (rollermines) are never "airborne".

While airborne the animation falls with the body - the animgraph's in-air pose, driven by the rigidbody rather than the (disabled) nav agent.

Back on our feet after a physgun carried us - keep whichever way it turned us, rather than snapping back to whatever we were looking at or doing before.

Hitting something hard while airborne - a wall we've been thrown into, or the floor if the collision beats the ground check to it. Only the speed straight into the surface counts, so skidding along it doesn't.

A hard hit hurts - harsher than a player's fall damage, being flung around by a physgun should hurt. Nothing at or below , fatal at .

Paint the surface we smacked into - a big splat where we hit, with droplets around it. Harder hits make more mess. Purely cosmetic, so every client makes its own.

The faction this NPC belongs to -- its identity to others, like a Source NPC's class. Override per NPC type.

Declare this NPC's relationships toward other factions with / / . Anything not listed is neutral (ignored). Override per NPC type.

Attack members of these factions.

Attack members of a faction, with a target-selection priority.

Flee members of these factions.

Treat members of these factions as allies.

Override how this NPC regards a specific entity, ignoring faction defaults -- e.g. a cop turning hostile toward someone it saw commit a crime.

Remove a per-entity override, falling back to the faction default.

The full relationship (disposition + priority) this NPC has toward another entity. Per-entity overrides win, then the faction default, then neutral. Override this for fully dynamic relationships (the equivalent of Source's IRelationType).

How this NPC regards another entity.

Resolve any entity's faction -- an NPC's own faction, or the player faction. Returns null for things that don't take part in relationships.

Are we on the ground?

The object we're standing on. Null if we're standing on nothing.

The collider component we're standing on. Null if we're standing nothing

If we're stnding on a surface this is it

Are we being held by a player?

Senses layer - handles environmental awareness and target detection

Navigation layer - handles pathfinding and movement

Animation layer - handles look-at and animation parameters

Speech layer - handles talking, lipsync, etc..

The current running schedule for this NPC.

What the NPC is aware of this tick, refreshed before selection. Schedules declare which of these interrupt them via .

Get a schedule -- if it doesn't exist, one will be created. The instance is reused across selections, so set its inputs each time you return it; its runtime state is reset when it starts.

Pick the schedule the NPC most wants to run right now -- return the highest-priority applicable one. Only called when (re)selecting, so a little work is fine, but keep it free of side effects and avoid randomness that shouldn't re-roll each selection.

Build what the NPC is aware of this tick. Override to add NPC-specific awareness -- call base first.

Runs once per tick: refresh conditions, then preempt the active schedule with something more important, run it, or select a new one when it finishes.

End the active schedule and start whatever the NPC wants next.

End the current schedule cleanly. Can be called by subclasses to interrupt the active schedule (e.g. when damaged).

Broadcast a stimulus from this NPC's position for nearby NPCs to sense (a gunshot when it fires, a death when it dies, and so on).

The name shown in the kill feed when this NPC is killed.

Current health. The NPC dies when this drops below 1.

Spawns a networked ragdoll prop at the NPC's current position, copying the renderer and clothing, and optionally applies a launch velocity from the attacker. Host only.

Who to blame for the damage. The player behind it, like whoever threw the prop, otherwise the attacker.

Base damage handling: subtract health, let the subclass react via , and die at zero. Subclasses react by overriding OnHurt and Die -- they don't touch this.

Whether should leave a ragdoll, a death listener can turn it off.

Called when the NPC takes damage (before the death check). Override to react.

Notifies the kill feed, spawns a ragdoll, and destroys this NPC. Called automatically when health drops below 1. Override to add NPC-specific behaviour before/after death.

What an NPC perceives this tick. Schedules declare which of these interrupt them via , so an idle schedule yields the moment a threat or disturbance appears without having to poll for it itself.

A hostile target is visible.

A visible entity the NPC is afraid of -- something it wants to flee.

A notable disturbance was sensed nearby -- a gunshot, a death, a scream.

A player is walking into us -- they want to get past and we're in the way.

Learned where a hostile is without seeing it -- heard it moving or shooting, or an ally called it out.

Console variables that control NPC AI behaviour globally.

When disabled, all NPC AI thinking is paused — they just stand idle.

When enabled, NPCs cannot target players.

A designed outfit - a set of clothing to dress an NPC in. Just clothes: heads, hair and facial hair come from a .

A head with the hair and beard that go with it, picked together - so nobody ends up with jet black hair and a blonde beard, or a beard that doesn't suit their face.

The head (skin clothing).

Hair, if any.

Beard, moustache or the like, if any. Coloured to match the hair.

Where on the hair's colour range to tint it - 0 is white, through blonde, brown and ginger, to black at 1. The beard is matched to whatever colour that gives.

Dresses an NPC in one of a few designed outfits and one of a few facial appearances, each picked at random when it spawns. Replaces whatever's set on the , which still does the actual dressing.

The dresser to put the outfit on.

Outfits to pick from. Empty leaves the dresser's clothes as they are.

Heads with their hair and beard, picked on top of the outfit. Empty leaves the face alone. Headgear in the outfit wins: hair or a beard that can't be worn with it is left off.

Tint beards, moustaches and the like the same colour as the hair on their head. Each item has its own tint gradient, so match the colour rather than the tint value.

The world stimulus bus. Anything can broadcast a (a gunshot, a death, a crime) and nearby NPCs sense it through their . This is how the world pushes events at NPCs, rather than NPCs only polling for entities.

Broadcast a stimulus into the world. is how far it can be sensed; is how long it lingers (seconds).

Active stimuli whose range reaches a position.

NPC speech coordination.

Shared NPC coordination for a scene.

Attempts to reserve speech around an NPC. Higher priorities preempt lower priorities. The reservation expires after unless stopped early.

NPC requesting the reservation. Length of the selected speech in seconds. Optional tags matched against tag cooldowns. Priority used for blocking and preemption. Defaults to 1000; always speaks. Coordination radius for this line. Defaults to 1500.

Releases all speech reservations owned by an NPC before their normal expiry.

NPC whose reservations should be released.

Adds a timed tag cooldown around a position.

Center of the cooldown area. Speech tag blocked by the cooldown. Cooldown duration in seconds. Cooldown radius. Defaults to 1500. Requests above this priority bypass the cooldown.

Returns whether two speech areas overlap, using the larger radius.

Center of the first speech area. Radius of the first speech area. Center of the second speech area. Radius of the second speech area.

NPCs currently registered in the scene.

Creates the scene NPC coordinator.

Registers an NPC with the scene.

Removes an NPC and any speech reservation it owns.

Roller chase: roll toward target then leap at it. On completion the schedule ends naturally, GetSchedule re-picks it and loops.

Roller idles when no target is visible — waits briefly then re-evaluates.

Drives morph targets and material glow on the rollermine mesh based on hunting state. Same mesh as hoverball — uses Coils_Deployed and Pins_Deployed morphs.

A physics-driven NPC that chases players, leaps at them, and bounces off dealing damage on contact.

Continuous force applied per-frame while rolling toward a target.

Torque applied per-frame to spin the sphere visually.

Upward impulse applied when the rollermine gets stuck.

Impulse applied when leaping at the target.

Upward component added to the leap direction (0 = flat, 1 = 45°).

Impulse magnitude applied to self when bouncing off a surface/player.

Damage applied to anything we crash into.

Distance at which we switch from rolling to leaping.

Eye child GameObject — assign in editor. Rotated to face the current target each frame.

GameObject whose child ParticleEffects are enabled while actively hunting a target.

Prefab cloned at world position when leaping at the target.

Prefab cloned at the contact point when hitting a player.

Looping roll sound — pitch is driven by speed.

Speed (units/s) at which pitch reaches PitchMax.

Pitch at rest.

Pitch at full speed.

Called by chase/idle schedules to toggle the hunting particle children.

Clones the leap effect prefab at our current position (broadcast so all clients see it).

Clones the contact effect prefab at the hit position (broadcast so all clients see it).

Leaps at the current target with a clean impulse (velocity zeroed first), then waits for cooldown before handing back to the roll task.

Rolls toward the current target by applying force and torque. Succeeds when within LeapRange. Fails if target is lost. Force/torque values are configured on RollerNpc.

If lateral speed stays below this for StuckTime, jump to un-stick.

A schedule -- can be understood as a way to execute a sequence of tasks

Selection priority. A running schedule is only preempted by one with a strictly higher priority. Use for the common tiers.

Stimuli that should make this schedule reconsider mid-run. When one of these newly appears, the NPC re-selects and a higher-priority schedule can take over. Defaults to the "drop everything and re-think" stimuli so ambient schedules yield to threats for free; combat and flee schedules override this to stay focused.

Initialize the schedule with the Behavior context

Called when task is ended because of ShouldCancel returning true

Called every frame while schedule is running

Called once when schedule ends

Called when this schedule starts -- this is where you can add tasks to run

Called when this schedule ends -- this is where you can clean stuff up

Add a task to the sequence

Start the current task in sequence

Information about this schedule for debugging purposes

Common schedule priority tiers. A running schedule is only preempted by one with a strictly higher priority, so these tiers decide who interrupts whom. Authors are free to use their own numbers — these are just sensible defaults.

Doing nothing in particular. Yields to everything.

Ambient behaviour — wandering, patrolling, following, inspecting.

Reacting to something — searching a last-known position, investigating.

Actively fighting a target.

Self-preservation — fleeing, panicking. Overrides combat.

Follow a target around, keeping a respectful distance. Re-evaluates each cycle so it tracks a moving target. Higher-priority schedules (like fleeing danger) preempt it.

How close we walk up to the target before stopping.

How far the target gets before we start walking again. The band between this and FollowDistance is "close enough" - without it, a crowd of followers endlessly jockeys and shoves to close the last few units.

If the target walks right up into our face, back off to arm's length -- facing them and walking backwards, not turning our back on them.

Move to a point, look around, and wait -- used to check out a last-known position or a heard disturbance. Re-spotting a target preempts this with a higher-priority schedule.

Speed to head over at. Null walks, breaking into a run if it's far.

A player is walking into us -- step sideways out of their path and let them through, HL2 companion style. We step to whichever side of their path we're already closest to, so we clear it instead of crossing in front of them, and watch them as they pass.

The player barging into us.

How far to step out of the way.

Speed to step aside at. Null uses the NPC's walk.

Wander to a random reachable point nearby, then pause. A simple ambient behaviour any NPC can use as its default.

How far to roam from the current position.

Stop, turn to face whoever we're talking to, deliver a line while looking them in the eyes, and only then get on with life. Used when a player dismisses the scientist, so it says goodbye to their face instead of muttering it while wandering off.

Panic flee — scream while sprinting away from the source.

0–1 panic intensity. Higher values mean faster speed and longer flee distance.

Idle in place — glance around at eye level, and watch the people we can see, HL2 style: a visible player gets looked at for a while, then other NPCs, and otherwise we just scan the room.

Walk to a nearby prop, look at it, and maybe comment on it.

Walking pace.

Wander to a random nearby point, avoiding player directions.

Walking pace.

Current fear level (0–1). Computed from peak fear and time since last hurt.

Seconds at full fear before decay begins.

Fear units lost per second after the grace period.

Walking pace while pottering about. Scientists only run when they're scared, or to keep up with a player they're following.

The player this scientist is following, if any. Press USE on the scientist to toggle.

Pick a random idle behavior so the scientist doesn't just stand around.

Find the nearest prop within range to inspect.

Something that happened in the world that NPCs can sense -- a gunshot, an explosion, a scream. Broadcast via ; sensed by .

Something that happened in the world that NPCs can sense -- a gunshot, an explosion, a scream. Broadcast via ; sensed by .

Common stimulus kinds. Plain strings so UGC can add its own; this is just the shared set.

A task

What is the current status of this task?

Status returned by task execution

Task is still running, continue executing

Task completed successfully

Task failed or was cancelled

Task was interrupted by conditions

Fires a burst at a target. The burst length comes from the weapon's NPC usage - a random shot count between its burst min and max. Shots only fire while the target is inside the weapon's engagement band.

The weapon component to fire.

The GameObject to aim at.

Body rotation speed (degrees/s scale) used while actively aiming. Higher than the default look speed.

Sets a persistent look target on the AnimationLayer and waits until the NPC is facing it. The look target persists after this task completes — call when you no longer need it (typically in ).

Task that commands the NavigationLayer to move to a target position or GameObject. When tracking a GameObject, re-evaluates the path periodically. Does not override the NPC's look target — but will rotate the body to face the movement direction when the angle would otherwise cause silly walking

Movement speed for this task. Null uses the NPC's configured speed.

Keep facing this object while moving instead of turning into the movement direction. The NPC backpedals or strafes -- short moves away from someone happen without turning our back on them.

Task that plays speech via the SpeechLayer. Waits for the speech to finish before completing. Accepts either a SoundEvent or a plain string (which uses the fallback sound). If LookAt is set, the NPC looks them in the eyes while talking.

Tags describing the line and its shared cooldown groups.

Admission and interruption priority for this line.

Distance within which this line coordinates with other NPC speech.

Task that waits for a specified duration

A list of muted users.

Toggles mute for a user

Is this user muted?

A saving/loading system that captures the differences between the current scene state and the original scene.

The current save format version. Saves with a different version are incompatible.

The path of the save file that was most recently loaded, if any.

Whether a save file is currently loaded.

Set metadata on the current session's save. This will be written on the next call.

Get a metadata value from the current session, falling back to a default value.

Get a copy of all metadata for the current session.

Read metadata from a save file on disk without loading the full save. Returns null if the file doesn't exist or is invalid.

Read the save format version from a save file without loading the full save. Returns 0 if the file doesn't exist, is invalid, or has no version field.

Saves the current world to the given path. This means any changes made to the those original scenes are preserved when loading an older save.

True if the save was successful.

Load a previously saved game state from a file, applying the differences to the original scene file(s) to reconstruct the saved scene.

True if the load was successful.

This builds a baseline JSON from all the loaded scene files that we've tracked in BeforeLoad. The final scene gets diffed against this.

Builds a composite baseline JSON from a list of scene files by merging all their GameObjects into a single root node.

The scene files to merge. The GUID to use for the root node. Match the scene's root ID to make sure diffs dont get fucked.

Serializes the current live scene as a JSON object in the same format as so the two can be diffed.

Get any changes made to scene-level properties (like gravity, nav mesh settings, etc)

Snapshots network ownership for all owned GameObjects in the scene, storing the owner's SteamID.

Restores network ownership by matching saved SteamIDs to connected players.

Collects all [Sync]-only property values from every component in the scene, so the networked state can be restored

Restore the [Sync]-only properties

Tells all clients to show the loading screen immediately, before Scene.Load() fires.

Constructs a from the patched JSON data so we can load it just like any other scene

The chat UI. The platform handles sending, validation and delivery, this only shows the messages it reports through

Messages kept in the history

Slideout speed, make sure to keep this inline with ChatBox scss

Shows a message with no sender on this client only, optionally in a colour of its own. It doesn't go through the platform, so other players don't see it.

Opens the box for typing

Closes the box without sending what was typed

Chat message. Comes from the platform's

Colour of the platform's "player joined" notice

Colour of the platform's "player left" notice

The player's name, empty for

Whose avatar to show, zero for none

A system message's own cvolor

A single chat entry. Used twice per entry: in the chat box history, and in the list of recent messages shown while the box is closed, where it fades out on its own.

How long a recent message stays fully visible

How long it then takes to fade out

Implemented by items that occupy a complete row in a .

A virtual grid that mixes fixed-size tiles with full-width rows.

Builds the cells again, for when they show more than their item, like the tile size.

Refreshes composed binding and connection labels when the language changes.

How long the slide in / slide out takes. You need to manually sync this timing with NoticePanel scss file!!

How long the notice lives for. Zero will make the notification stay visible until it is manually dismissed

If true, the notice won't be automatically dismissed. Call Dismiss() to remove it.

Dismiss a manual notice, causing it to slide out and be deleted.

Displays transient HUD notices and delivers messages to individual players.

Sends a phrase and its parameters to a connection, resolving them in the recipient's language. Must be called from the host.

The notice display in the active scene.

Space between the list of who is talking and the notices above it

Displays already formatted text without interpreting leading hashes as phrase references.

Displays an icon and already formatted text without interpreting leading hashes as phrase references.

The colour of a notice's icon, and its timer bar, unless it is given another

Displays an icon in the default colour and already formatted text.

Every notice is made here, so anything a notice can be configured with (icon, colour, duration) goes through this one place.

Send a notice to a specific connection. Must be called from the host.

update every second

This component has a kill icon that can be used in the killfeed, or somewhere else.

Put this on a panel implementing to register it with the inspector.

Data being dragged. Carries enough info for both the visual and the drop action.

The spawner type, e.g. "prop", "entity", "dupe".

The cloud ident or resource path.

The icon URL to display while dragging.

Optional display title.

The panel that initiated the drag, so we can ignore it as a drop target.

Stable spawnlist entry ID when reordering an editable spawnlist.

Set to true when a drop target has already handled this drag (e.g. slot-to-slot swap), so the source panel's OnDragEnd can skip secondary actions like dropping to the world.

The component that owns the effect settings

Screen rects the sections draw into this frame. Empty means there is nothing to paint

Canvas size in whole pixels, which is what the paint target is created with

The section of type , added on first use unless is false (then null if there is none)

One part of the HUD (vitals, weapon buckets etc) painted into the shared HudCanvas

Paint order, lowest first

Paint this section

Screen rects the composite shader runs over. Everything painted (plus its glow) must sit inside them.

The canvas's scale to the screen times the player's HUD scale. Size everything painted by this.

The look of the HUD (font, colours, panels, HDR glow), shared by the HUD sections and the weapon screens

Background colour of HUD panels

Small captions like HEALTH and AMMO

Scales the colour, leaving its alpha alone. A gain past 1 goes over 1 for HDR glow, below 1 darkens.

A flat panel with rounded corners

The HUD's tint and HDR gains, for things painted outside the HUD canvas like the weapon screens

The HUD's tint and HDR gains, for things painted outside the HUD canvas like the weapon screens

Tinted text at the regular HUD brightness

Tinted and pushed into HDR like the HUD digits, so it glows

Add this to a popup panel so it can keep spawn menu up for as long as the popup exists.

Whether the menu is held up right now. Set it to false to let the menu close as usual, for example while the popup is only hovered.

Paints the weapon buckets at the top of the screen

Should the menu be open right now?

Collapsed columns are small squares, the selected one grows to 2:1 as it expands

Works out where the menu sits this frame, so the composite regions are known before anything is painted. Leaves empty while the menu is not visible

A collapsed child slot: just a flat bar, CollapsedHeight tall.

Cached uppercase display name for the inventory weapon

Paints the interaction hint (use key and action name) below the crosshair

The hint to show, null to fade out whatever is showing

The input action that presses things, shown as the key to press

The key and name sit on one centred row below the crosshair

Top level options and headers.

The header new options are added under, or null for the root.

Headers we've opened once already. New headers start open, after that the tree remembers.

Start a collapsible section. Options added after this go inside it.

Whether the name is allowed to reference a localization phrase. Disable this for user-authored entries.

Identifies this option across rebuilds, so the tree keeps it open and selected. Defaults to the name - set it when names can repeat, like folders.

Makes the children the first time the option is opened, for trees too big to build up front.

Whether this can be opened, without loading the children to find out.

Options are recreated on every rebuild. Match them by key so open ones stay open.

Local scripted entities followed by cloud entity packages.

Virtualized, render-once thumbnails; a material change explicitly requests a new render.

Local props followed by cloud model packages.

Class that handles all the spawnlist data fetching and workshop fetching so it's not a huge mess everywhere.

Raised whenever the visible entry list changes.

Raised after a workshop install, with the installed entry name.

Raised after an uninstall.

Number of cookie-tracked workshop entries not yet resolved from storage or the cloud. Non-zero while the initial cloud fetch is in progress.

Rebuilds the visible list and triggers a cloud re-fetch.

Install a workshop item, persist its ID to cookie, and refresh.

Uninstall a workshop-installed entry: remove from cookie, cloud list, and rebuild.

Delete a locally editable spawnlist and rebuild.

A spawnlist item -- lots of cleanup needed, docs, etc

Raised whenever a new spawnlist is created, so UI can refresh without needing a panel ancestor walk.

The literal name chosen by the author. Only the initial fallback is localized.

Asks for a name in a window over the menu, then makes the spawnlist.

An item the new list starts with. What the name box starts with.

"1 item" or "N items", in the player's language.

Material icon shown next to the list in the spawn menu sidebar.

Mount required to see this list in the spawn menu. Leave empty for no requirement.

Nests this list under another one in the spawn menu tree. Leave empty for a top level list.

Lists are sorted by this, then by title.

A raw spawn ident, for anything that isn't a local model or entity, e.g. prop:facepunch.wooden_crate. Used when no model or entity is set.

Item label, or the section heading for a title row.

Optional thumbnail override. Defaults to the content's own thumbnail.

The title in the player's language. Titles can be #phrase references.

The resource in the shape the spawnlist view draws. Items get stable ids from their position so the view can tell when the resource changes.

Every authored spawnlist the player should see, in display order.

Shared spawnlist support for spawn menu pages.

Built-in generated lists, alongside the authored default lists.

Refresh after external changes (create, etc.).

How big tiles are in spawn menu grids.

Compact tiles with an icon only.

Standard tiles with an icon and title.

Large tiles with an icon and title.

The user's chosen tile size, persisted between sessions.

Cell size to give a for this tile size.

CSS class to put on the grid so tiles can adapt their text to the size.

Material icon representing this size in the toolbar and its menu.

Open the menu that picks a tile size, under the mouse.

The key hints to show, in order.

What pressing together does.

What pressing together does.

The vehicle tuning readout, painted into the HUD canvas: gear, speed, rpm, inputs and a per-wheel breakdown of suspension, slip and grip. Fed by while vehicle_debug is on.

Wheel centre above its hard point, inches, and the most it goes either way.

Asking for more grip than the tyre has.

Paints the health, armour and ammo HUD

The component that owns the warning and flash settings

Top edge of the health box on the canvas, so other HUD can sit above it. Zero until it has been painted.

Where the title of a counter whose digits end at starts

Paints a counter, and when is given a box around it. Returns how wide the counter is.

One segment per round, capped at . Past the cap each segment covers a share of the clip and fills by remaining fraction, rounded up so the last one stays lit until the clip is empty

Radial darkening centred on a screen corner (todo: make it optional?)

Digit slots for one counter, each with one of the background variants picked randomly per digit

The digit shown in slot , or null if the slot is blank

Formats an int once per change instead of every frame

A button for a that is made while the game runs

The button can be pressed while this says true. Always, when not set.

What the button says, can be a localization token. Where it goes among the other properties of the sheet.

UI button. A uses it for methods marked with [Button], and [EnabledIf] decides when they can be pressed.

The method this runs when pressed, set by a sheet. It takes the title and icon from [Button], or the name of the method.

Moves the text into the tooltip and leaves only the icon, square like any icon-only button. Clearing the text alone keeps the empty text column, which pushes the icon off centre.

Property for a color swatch and hex value, clicking on it open a color picker

One entry of the list. The label can be a localization token, and is drawn in when one is given.

One entry of the list. The label can be a localization token, and is drawn in when one is given.

An item for each value of an enum, named by its [Title].

Called with the that was picked.

Whether the labels may be localization tokens.

Opens a custom picker instead of the item list when provided.

The picked value, shown in the box.

The list under an open . It's a popup, so it lives above the menu and closes by itself when something else is pressed.

An enum property. Two options are shown side by side as a segmented control, anything more as a .

A string property marked [FontName], picked from . Each one is shown in its own font.

A label with a for a tooltip: its own text as the title and a description. Without a description there's no tooltip.

What the tooltip says under the name. Can be a localization token or carry markup.

A small window with a title bar and a of whatever object you give it.

What goes under the title bar.

Called when Enter is pressed in one of its text boxes.

Called after it closed, by any of the ways.

Opens a window over the menu the panel is in. Only one stays open, a new one replaces it.

A window with a text box and two buttons, for asking a name

The title bar, can be a localization token. What the text box starts with. Called with the name when it is confirmed. What the empty text box says. What the confirm button says. The icon of the confirm button. A line above the text box, rich text like 's.

A confirmation window with buttons underneath

The title bar, can be a localization token. The question, rich text, so <b> works. Escape names in it with . Called when it is confirmed. What the confirm button says. What the cancel button says, no cancel button when null.

Makes text safe to put in the rich message of

Centers a over the HUD when it isn't opened from the menu. Goes away with its last modal.

A resource property that shows all available options in a grid

Make sure all cells fit in grid space properly regardless of screen resolution

One pickable resource

A thin horizontal line between parts of a panel. A sheet makes one for .

The object whose properties we show, or a list of already serialized properties.

Decides which properties get a row. All of them when not set, is the usual choice.

A filter for : members marked [Property] and methods marked [Button], without delegates.

Throws the rows away and makes them again from the target.

A titled run of rows. A toggle group has a checkbox in its title that shows and hides the rows.

One property, its name on the left and its control on the right, wide controls like the resource grid go under the name instead. A button has no name and takes the row, and the buttons that follow with [SameLine] share it.

Another property on the same row, after the ones already there.

Whether every one of the conditions says to hide.

Pick the control for a property. Anything we don't have a Sandbox one for gets the engine's.

Draws a thin line above this property or button in a .

Puts this property or button in the same row as the one above it, buttons share the row evenly.

Puts this [Button] in the title of its group in a , as a square icon with its title as the tooltip. For things that act on the whole group, like resetting it.

Leaves out the name on the left of a property in a , its control takes the whole row.

A slider for this property only sets it when you let go of it or finish typing, not on every change.

A button or property in a only works while a property of the same object has this value, otherwise it shows greyed out.

A number with a range

The left end of the bar. Set from the property's [Range] when there is one.

The right end of the bar. Set from the property's [Range] when there is one.

Values snap to this, and it's marked under the bar - coarsened to a round multiple when there would be too many marks. 0 for none, which marks tenths of the range instead.

Called with the new value when the user changes it.

The number the slider shows. With a property it reads and writes that, without one it keeps the number itself - so the slider can be used anywhere

Sets the value from the user's input, so hears of it.

The step, or a tenth of the range without one, grown by 2/5/10-style multiples until it marks at most divisions.

A Vector2, Vector3 or Vector4 property, a number box for each axis with the axis letter in front of it.

Whether we have a control for this type.

One axis of a .

Gap between the screen edges and the HUD in screen pixels, from the player's HUD margin

for panel styles, which scale it to the panel themselves

Space kept between the vitals and the HUD stacked above them (chat, notices, the voice list)

True if none of the given elements are hidden. HUD panels call this before drawing. The answer comes from every listener in the scene, asked once per frame.

Loads a workshop query one page at a time. Restarting it drops pages of the old query that are still on their way.

Whether the first page has been asked for yet.

Builds the query for the first page. Turns a result into what holds. Return null to skip it. Called when or change.

The next page, one at a time.

A single tile in the grid, whether it came from disk or from the cloud.

A single tile in the grid, whether it came from disk or from the cloud.

Reapplies searches and sorting to the translated names of local entries.

Value of the "type:" term in the package search, e.g. "sent" or "model".

Extra terms appended to the package search.

Title shown when nothing matched. Null uses the empty state's default.

Build the spawn ident for a cloud package.

Local entries shown ahead of cloud results in Popular mode, otherwise after them. Should respect .

The strip of settings along the top, like Garry's Mod's context menu bar. Its menus come from .

The data currently being dragged, or null.

True if something is actively being dragged.

Start dragging with the given data.

Stop dragging and clear all state.

Localized title of the clothing inspector.

Where the listed effects come from.

Sorts installed effects by their translated names after a language change.

Localized title of the face pose inspector.

Localized inspector title including any additional selected objects.

Refreshes the displayed resource type and current selection.

Updates the preview and display title when the selected resource changes.

The HUD colour when nothing has set one, also what the HUD panels fall back to without a layer

Colour multiplied into every HUD element

The colour the HUD paints with: the player's HUD colour if they picked one, otherwise . Always opaque, see .

How opaque the HUD and its glow are, the alpha of the player's HUD colour

HDR color exponent for highlighted HUD elements like digits or selected hotbar slots

HDR color exponent for regular HUD text

HDR multipliers from and

Scanline frequency in pixels

The scene's HUD layer. With it is added next to the screen panel lives under if there isn't one yet

A section of the scene's HUD layer. Hand back the previous result to skip the scene lookup while its canvas is still alive

Which window of the inspect menu a tab goes in.

Saves and effects, under the settings bar.

The inspected object and the tool options, with the tabs under the page.

Puts a panel in one of the inspect menu windows, under a tab of its own, can be implemented this way: [InspectWindow.Tab, Title( "My Tab" ), Order( 300 )] public class MyTab : Panel { } [InspectWindow.Tab( InspectWindow.Corner.BottomRight ), Title( "My Options" ), Order( 300 )] public class MyOptions : Panel { } Tabs are sorted by [Order], then by title. Without a corner they go in the window at the top left. The window is sized by the page, so give it a width of its own: it is measured at its own size to roll the window open.

A tab that only shows while says so, like .

The tabs of this corner are the ones that go in this window.

Makes a panel for every tab type and drops the ones whose type is gone

Seconds after the last selection change before the menu closes on its own, keeping the current weapon

The scroll wheel steps the selection. Runs after the weapon's update, so a weapon that uses the wheel (physgun distance, wire tool ports) clears Input.MouseWheel first and nothing reaches the menu

Pressing a bucket's key opens it on its first weapon (or the one after the held weapon), pressing it again steps through the bucket

The wheel steps through every weapon across all buckets

Localize the modal label while keeping the workshop metadata key stable.

Show the models in this folder and everything under it. Null shows the whole mount.

Image url of the picked resource. The badge shows when it's empty.

Shown instead of the image, cut to three letters so it fits.

Greys the title out, for "none selected" and the like.

The extension being picked, from the asset type or straight from the attribute for types without one (materials).

Refreshes the resource type metadata and current selection.

Updates the preview and display title when the selected resource path changes.

Title bar text, "Surface Selection" or similar when not set.

Opens a picker over the menu is in.

Tile size, kept apart from the spawn menu's since these tiles also show a description.

What's typed in the search box. Local items are filtered right away, the workshop is asked once typing pauses.

Keep the overlay visible this frame — call every frame while a tool wants it up, optionally with a hover card to show. The overlay also shows itself while the inspect menu is open; either way it collects and draws the wires on its own.

Find every wire around the camera: signal connections on outputs, and component links (references and presence) on their ManualLink stamps.

The screen-space box around the object's projected bounds corners, in pixels. False when any corner is behind the camera — the box would be meaningless.

Slide a point sitting inside the box along the line towards the outside point, stopping at the box edge.

A player's spawnlist, local or installed from the workshop.

An authored spawnlist that ships with the game. Always read-only.

Whether the menu is currently up (held or pinned), in any mode.

Where windows go. They are inside the menu, so it stays up while one has focus.

Opening the menu with a controller uses the same stick input as movement, so block movement while the open button is held (mouse/keyboard players can move and open the menu at once).

We want to drag from this panel

Reapplies the active search to the translated prop names.

Whether the sheet would have a single row for this tool.

Every tool under its group, both sorted by what the player reads.

How long text pauses scrolling before continuing

How fast we're scrolling overflowing description text

Maximum height of description block, all text that overflows will be scrolled

A selectable entry. The title can be a localization token.

A selectable entry. The title can be a localization token.

A blue header and the entries under it.

A blue header and the entries under it.

The value of the entry that's highlighted.

Bump this when the groups changed in a way their item count does not show (titles, order, values), to make the list build again.

The groups with only the entries that match the quick filter, and without the emptied ones.

What's being waited for, can be a localization token.

Bump this when the content changed in a way the title does not show, to make the pane build it again.

Reformats action titles and object counts without requesting the history again.

Draws this color when ammo/health reach a critical level

The health readout flashes this color when health drops

Put on an object by the host while a player drives it (see )

Who's driving this?

Start driving this prop

Let go of the prop

Take the noclip tag we put on driven objects out of , serialized, so saves and dupes get them the way they were before they were driven.

Lets an object react to being picked up with use by , or refuse it. Runs on the root of the object.

Called when a player tries to pick this object up. Runs on the machine of the player picking it up, and again on the instance that simulates the object before it starts moving it for them.

Called when a player starts carrying this object. Runs on the instance that simulates the object, the only one that can change its body.

Called when a player stops carrying this object, because it was let go, thrown or got out of reach. Runs on the instance that simulates the object, the only one that can change its body.

The connection attempting to grab this object.

Set to true to cancel the grab.

Called when a player attempts to grab this object with the physgun. Set to true to reject the grab.

Called when a physgun stops moving this object, because it was let go, frozen or launched. Runs on the instance that simulates the object, the only one that can change its body.

The connection attempting to use a tool on this object.

Set to true to reject the toolgun selection.

Called when a player attempts to select this object with the toolgun. Set to true to reject the selection.

A non-physics logical link between two GameObjects. Used by the Wire tool to group unconnected objects so the Duplicator treats them as part of the same contraption.

Wires whose output is the source component itself — reference and presence links.

Stamp the wire on both ends of the pair, so either side can resolve it from its own link children.

Persists morph values on a GameObject so they survive over the network and dupes.

Serialized morphs. Persisted for dupes/saves — not synced over the network.

Apply a partial morph batch on the host, then broadcast to all clients.

Apply a full morph preset on the host (resets all first), then broadcast to all clients.

Snapshot all current morph values from into .

Apply the stored to the first we find. Called on spawn/dupe restore.

Attached to mount-spawned props. This tries to show a graceful bounding box and hints the player what game it's from if they don't have the mount installed.

Tracks which connection spawned this object

I would fucking love to be able to Sync these.. And it would just do this exact behaviour. Why not?

Sets a gameObject as owned by a connection. If the gameObject already has an Ownable component, it'll just update the owner.

Persists physical properties (mass, gravity, health) across duplication and networking. Attach this to any GameObject to ensure these values survive serialization.

Holds a banlist, can ban users

Bans a connected player and kicks them immediately

Bans a Steam ID by value. Use for pre-banning or banning players who are not currently connected. Display name falls back to the Steam ID string.

Removes the ban for the given Steam ID.

Returns true if the given Steam ID is currently banned

Returns a read-only view of all active bans

RPC to ban a connected player. Caller must be host or have admin permission.

Bans a player by name or Steam ID. Optionally provide a reason. Usage: ban [name|steamid] [reason]

A configurable input action for contraptions driven from a seat. This contains no state: it reads the active driver's connection while is running. Wired inputs are ordinary handlers instead.

How far the action's pushed, 0 to 1: a key's all the way, a gamepad's trigger or stick anything between (see ).

Answers "which player caused this?" while entity code is running. When a signal input fires or a seat pushes key states, the system notes who did it here. If your code needs to blame someone — kill credit, undo — just read . It's null when nobody is responsible (e.g. map logic).

The player who caused whatever is currently running, or null.

Restores whoever was responsible before when disposed, so nested pushes unwind cleanly.

Mark a player as responsible for the code that runs until the scope is disposed: using var scope = ControlContext.Push( player );

Lets players drive contraptions from a seat. Every tick, this finds who's sitting in each chair and calls on the attached contraption.

Data passed to .

The seat they sat in, or the prop they drive.

Allows listening to players taking control of things - sitting in seats, which drives whatever the seat is built into, and driving props. Use it for vehicle HUDs or tracking passengers. Runs on the host.

Allows listening to and changing explosions. Implement this on a to make blasts bigger, keep them out of a safe zone, or react to them going off.

Allows listening to and changing damage dealt to players and NPCs. Implement this on a to scale damage, add friendly fire rules, or react to hits.

Allows listening to and stopping the deaths of players and NPCs. Implement this on a .

Allows listening to and stopping admin actions - kicks, bans, server settings and map changes. Use it for audit logs or protecting admins from each other. All of these run on the host.

Allows listening to players joining and leaving the server. Implement this on a . All of these run on the host.

Events broadcasted to the entire scene for any player action.

Allows listening to and stopping undos, for example to lock props during a round. Runs on the host.

Allows listening to events related to the . Implement this on a to receive callbacks before and after saves and loads.

Allows listening to spawn events across the scene. Implement this on a to receive callbacks before and after objects are spawned.

Called on the host before an explosion is spawned.

Called on the host after the explosion has been spawned.

Called on the host before a player or NPC loses health.

Called on the host after a player or NPC has lost health, before they die if it killed them.

Called on the host when damage has taken a player or NPC below 1 health, before they die.

Called on the host after a player or NPC has died, the kill has been credited and their ragdoll made.

Called when someone tries to join, before they load in. Use it for whitelists, passwords or reserved slots. Bans are checked separately.

Called when someone has joined and their exists, just before their first spawn.

Called when someone has left, before their is destroyed. Their player may already be gone.

Store a string in the save, keyed by name - JSON serialize anything bigger. Write it in and read it back in . Host only. Prefix keys with your addon's name so they don't clash.

Read a string stored with , or if there isn't one.

Called before the scene state is captured for saving. Use this to prepare any transient state that needs to be persisted.

Called after the save file has been written to disk.

Called before a save file is loaded — the current scene is still active. Use this to clean up any state that won't survive the scene reload.

Called after a save file has been loaded and the scene is fully restored. Use this to re-initialize any runtime state from the loaded data.

Data passed to . Set to true to prevent the spawn.

The spawner that will create the object(s).

The world-space transform where the object will be placed.

The connection of the player requesting the spawn.

Set to true to cancel the spawn.

Data passed to after a successful spawn.

The GameObjects that were spawned.

Called before an object is spawned into the world. Set to true to reject the spawn.

Called after an object has been successfully spawned into the world.

A component that can be driven by the player occupying a linked seat. runs once per fixed update with the player's input connection active.

The raw value of a signal delivery. You rarely need this — declare inputs as plain bool, float, or parameterless methods and the system converts for you.

The raw value of a signal delivery. You rarely need this — declare inputs as plain bool, float, or parameterless methods and the system converts for you.

Makes a method or property wireable as an input. Works on: a parameterless method (fires once when the signal turns on), a method taking a bool or float, or a writable bool/float property. On a writable property of a Component type it becomes a component input instead: linking sets the property to the source component directly, and only components of that type (marked on their class) can be linked to it. The member's name is the wire's name — renaming it breaks saved contraptions.

The stable port id. Defaults to the member name.

Makes a property wireable as an output. The member's name is the wire's name — renaming it breaks saved contraptions. On a class it exposes the component itself as a linkable reference instead: players can wire it into any component input ( on a property of a matching type) and the input receives the component directly. Wired into a boolean input instead, it holds the input on for as long as the link exists.

One wire: which component and which input it feeds into.

An output port that players can wire to inputs on other entities. Call whichever Emit overload matches what you have — the receiving end converts as needed. State providers should emit every tick while active; this keeps continuous inputs push-driven. Only does anything on the host. Credit follows automatically: whoever last pressed or signaled this component is passed along with the emit. Pass an instigator explicitly only to override that.

Fire a one-shot pulse — "something happened once".

Emit an on/off state.

Emit a number. Values above 0.5 count as "on".

What actually runs when a signal arrives at an input.

What actually runs when a signal arrives at an input.

Lets a custom property type act as a signal input. Just implement this anywhere — it's found automatically.

The shared metadata exposed by both ends of a signal connection.

Component ports: the component type this port provides or accepts. Null for signal ports.

An output port found on a component: its name and how to reach it.

An input port found on a component: its name and how to reach it.

One input or output declared on a component type.

One input or output declared on a component type.

Outputs: the property holding the SignalOutput.

Inputs: what to run when a signal arrives.

Component ports: the component type this port provides or accepts.

Delivers signals from outputs to the inputs they're wired to. Everything runs on the host; clients just see the results through normal networking. TypeLibrary owns member caching and hotload invalidation; this system resolves ports from its current descriptions when needed.

Port id of the synthetic output a class-level creates. Can't collide with member names — C# identifiers can't contain '$'.

The player who last pressed or signaled this component, or null.

Every output under this object's root. Unsorted — UI that lists ports uses .

Any signal output can wire to any signal input. Component outputs wire to component inputs whose property type the component satisfies — or to boolean inputs, which they hold on for as long as the link exists.

Create a logical object link and connect the selected signal ports in one host operation.

Record the wire on the ManualLink pair that carries it, so destroying the link (undo, the wire tool's unlink) also disconnects the wire. Wires between objects joined some other way (welds, same root) have no pair — that's fine.

Disconnect the wire a dying ManualLink was carrying.

Component links set the input property to the source component directly — there is no connection list and nothing ever travels; the reference is the whole wire. Into a boolean input, the reference implicitly reads as a bool instead: on while anything is wired in, off when the last wire dies.

Is there a stamped component wire into this input? Optionally from one specific source, optionally ignoring a link that's currently being destroyed.

Destroy the stamped ManualLink pairs carrying wires into this input.

Every output on this object's contraption (anything joined by welds, joints or links). Tools and UI should use this so they all agree on what's wireable.

Every input on this object's contraption.

An explosive that can be activated by damage, player input, or a signal.

The damage dealt by the explosion.

The radius affected by the explosion.

The strength of the explosion's physical force.

The input that detonates the explosive.

Creates the explosion and removes this explosive.

Detonates the explosive when its signal input is triggered.

Detonates the explosive when the owning player presses its activation input.

Whether the emitter fires while the input is held, or toggles on/off with a press.

Press once to turn on, press again to turn off.

Emits only while the input is held down.

A world-placed SENT that spawns and controls a particle/VFX emitter. The emitter prefab is defined by a resource.

The emitter definition points to a prefab containing a particle system.

Whether this emitter toggles on/off with a press, or emits only while held.

Used when is .

Used when is .

Whether the emitter is currently active. Synced to all clients.

When enabled, forces the emitter on regardless of input or mode. Can be set from the editor or wired up externally.

Toggles emission when a signal triggers in toggle mode.

Updates emission from a signal in hold mode.

Applies the owning player's emitter input for the current mode.

A world-placed SENT that spawns another SENT at its location. Can be triggered manually via player input or automatically on a timer.

The SENT to spawn.

Input binding that triggers a manual spawn when the player uses this entity.

When enabled, spawns the entity automatically every seconds.

Seconds between automatic spawns.

Maximum number of entities spawned by this spawner allowed to exist at once. New spawns are suppressed until existing ones are destroyed.

Spawns an entity when the signal input is triggered.

Spawns an entity when the owning player presses the spawn input.

A player-controlled point light.

Whether the light is switched on.

Whether the light casts shadows.

The color of the light.

The brightness of the light.

The radius affected by the light.

How quickly the light fades with distance.

Whether the light's model casts shadows.

The input that switches the light on.

The input that switches the light off.

The input that toggles the light.

The object shown while the light is on.

The object shown while the light is off.

Toggles the light when its signal input is triggered.

Switches the light on when its signal input is triggered.

Switches the light off when its signal input is triggered.

Applies the owning player's light controls.

The prefab containing the particle/VFX system to emit.

The prefab containing the physical emitter body

Used to group this entity under a named category in the spawn menu (e.g. "Chair", "Weapon", "Npc", "World"). Categories can be nested with /, such as Weapon/Melee. Leave blank to place it under "Other".

If this entity uses code then you should enable this so the code is included when publishing.

If true, this entity only appears in the spawn menu when running in the editor. Use for test/debug entities that shouldn't ship to players.

A player-controlled spotlight.

Whether the light is switched on.

Whether the light casts shadows.

The color of the light.

The brightness of the light.

The radius affected by the light.

The outer angle of the spotlight cone.

How quickly the light fades with distance.

Whether the light's model casts shadows.

The input that switches the light on.

The input that switches the light off.

The input that toggles the light.

The object shown while the light is on.

The object shown while the light is off.

Toggles the light when its signal input is triggered.

Switches the light on when its signal input is triggered.

Switches the light off when its signal input is triggered.

Applies the owning player's light controls.

A TV screen entity that displays the feed from a linked . Use the Wire tool to wire a Camera's video feed to this TV's display input.

The camera whose view is on the screen. A component input: only a Camera can be linked here, and linking just sets this reference.

The brightness of the television screen.

Whether the television screen is switched on.

True when a linked camera is actively providing a render texture.

Put this in a prefab to frame its thumbnail - it's rendered from this object's position and rotation instead of auto-framing the whole prefab. Point it at what should be in shot, or turn on to just set the angle and have the prefab fill the frame.

Keep it narrow and pull the camera back - a long lens flattens the perspective and looks more cinematic than a wide one up close.

How far ahead to draw the framing in the editor - just a guide, it doesn't affect the render.

Ignore where the camera is placed - keep its angle, but move it so the prefab's models fill the frame. Good for things that should all sit the same in a grid, like weapons.

Space left around the prefab when fitting, as a fraction of its size.

Push in past the fit - above 1 crops into the prefab, so long things can run off the edge.

Slide the framing toward the interesting end when zoomed in, as a fraction of the fitted frame - x toward the right, y up. Measured before any roll on the camera, so a tilted gun slides along its own length.

Render to through the thumbnail camera it contains. Returns false if it doesn't have one.

How far below the middle of the image the middle of what's drawn is, in pixels - null if nothing was drawn. Halfway between the middle of its outline and its centre of mass: a rifle's thin barrel along the top shouldn't count as much as the body hanging under it, but its magazine shouldn't drag it off the top either.

Studio lighting that follows the camera, so every thumbnail is lit the same way: a warm key from above-left, a soft fill from beside the camera, and a cool rim from behind to pick out the edges. The rim is a point light - a scene only takes one directional light, a second replaces the first.

Where to put a camera looking along so fills a square frame - measured from the box's outline as seen from that angle, so long thin things fill the frame as well as chunky ones. Then pushed in by and slid across by .

Data passed to . Change the fields to reshape the blast, or set to true to stop it. A cancelled explosive is still used up.

The thing that's exploding - dynamite, a grenade, a rocket, or the grenade weapon when it cooks off in a hand.

The object credited with the damage.

The prefab spawned for the blast. It carries the effects, sound and .

The explosion every explosive spawns unless a listener swaps it.

Fire , then spawn and network the explosion. Host only. Returns null if a listener cancelled it or it couldn't be spawned.

Who got hurt and by whom, shared by damage and death events for players and NPCs alike. Use , and to tell them apart.

The player or NPC being hurt.

Who's blamed for the damage - the player behind it, like whoever threw the prop or drove the car, otherwise the attacker. Not valid for the world.

Data passed to . In , change or set to block it.

The damage to deal, before the victim's own modifiers like headshots and armour.

Set to true to block the damage. Can start out true, when PvP is off and another player is to blame - set it back to false to allow the hit.

The health the victim actually lost, after headshots and armour. Only set in .

Data passed to . In , set to true to keep the victim alive on 1 health (or more, if you heal them), or turn off .

Whether to leave a ragdoll behind.

Implement on any component that can appear as an attacker in the kill feed. Examples: Player, Npc, explosive barrel, turret, whatever the fuck.

Display name

Steam ID for the local "is-me" highlight. Defaults to 0 (not a player).

Entity-type tag passed as attackerTags. Return an empty string for plain player kills. Examples: "npc"

Called on the host when this source kills something. Credit kills, update stats, etc. Default is no-op.

Moves a rigidbody towards a target transform through a control joint, the way the physgun holds things. Only the instance that simulates the body can move it, so run this there

True while there's a joint holding a body.

Starts holding by , in world space. Does nothing if we're already holding. Lower follows the target more tightly, 1 is critically damped.

Rotating a held object with the mouse and movement keys while use is held, snapping to 45 degrees when running.

Drives the game's default on the same GameObject (the system scene camera). The default is disabled whenever the loaded scene provides its own global tonemapping, i.e. an enabled that is on a camera or inside an infinite .

Categories for browsing post-processing effects.

Effects entries.

Overlay entries.

Shaders entries.

Textures entries.

Misc entries.

How hard a ragdoll is thrown when a player or NPC dies, based on what killed them.

Implement on a to enable in-picker previewing. When the user clicks an item in the resource picker, is called instead of immediately selecting it. A "Select" button confirms the choice.

Called when the user clicks this resource in the picker for preview. Use this to play a sound, show a visual, etc.

Called when the preview should stop (another item previewed, picker closed, or resource selected).

A categorized sound resource for use on spawned entities (thrusters, hoverballs, emitters, etc.). The field allows the editor to filter definitions by type.

Display name for this sound definition.

Optional description of the sound.

Category tag used for filtering in the resource picker (e.g. "thruster", "hoverball").

The underlying sound event to play.

Plays the sound at the given world position. Returns default if no sound is set.

Plays the sound at the given world position, parented to a GameObject. Returns default if no sound is set.

Someone or something on either end of damage - a player, an NPC, a prop, or nothing for the world.

Find a component on the object or its parents, like the or behind it.

Base class for pages opened in the utility tab right panel. Decorate subclasses with [Icon], [Title], [Group], and [Order].

Return false to hide this page from the utility menu.

Physical kick applied to a standalone (unheld) gun when it fires.

Ragdolls take the bullet as a velocity change rather than a raw impulse, so a torso shot moves the body as visibly as a hand shot moves the hand. The struck bone gains Ballistics.Force * RagdollImpactScale units/sec along the shot; every other bone gains of that.

Fraction of the struck bone's velocity change given to the rest of the ragdoll.

The per-shot kick - eye punch and camera shake for a held gun, a physical shove for a standalone one.

Runs for every pellet on every peer - death ragdolls are local to each peer, so the push has to be applied wherever the body is simulated, not just on the host.

Gunfire is loud - let NPCs hear a player shooting. NPC shooters announce their own bursts.

Bullet trace for this gun - the sandbox's bullet collision rules, skipping player controller colliders (players are hit through their hitboxes).

Random pitch added to the aim per attack (min, max degrees).

Random yaw added to the aim per attack (min, max degrees).

Random pitch of the first-person view punch per attack (min, max degrees).

Random yaw of the first-person view punch per attack (min, max degrees).

Random roll of the first-person view punch per attack (min, max degrees).

How many times the view punch oscillates before it lapses.

How long the view punch lasts, in seconds.

First-person camera shake strength per attack, in world units. Zero for none.

New shake offsets per second.

How long the shake takes to settle, in seconds.

Kicks the owner's aim, then punches and shakes their view if they're the local player in first person. Returns whether the view was kicked.

How long into a reload pulling the trigger can still cancel it, in seconds. Past this the reload plays out. Zero keeps the whole reload cancellable.

Is it too late in the current reload for a trigger pull to cancel it?

True while this weapon is loose in the world as a pickup rather than held. Host authoritative - the change callback toggles the pickup components (physics, the standalone model) on every peer.

Creates and attaches the world model to the given renderer's bone. Use this overload when the weapon is held by something other than a player (e.g. an NPC).

Used for overriding the display icon

If true the game should hide the hud when holding this weapon. Useful for cameras, or scopes.

Which parts of the HUD hides. Everything by default.

The owner of this carriable

When true, seated aim uses the scene camera direction instead of the weapon's muzzle direction. Override in weapons that support player-directed aim (e.g. RPG tracked mode, Physgun aim mode).

What an NPC holding this weapon is shooting at. While set, shots go from the muzzle to the target's chest instead of along the barrel, which follows the animation and drifts high.

Controlled from a seat with targeted aim fires where the camera looks; an NPC fires at its ; otherwise the engine's muzzle-based unheld aim applies.

Roughly chest height - most of the way from the feet up to the eyes, so it follows crouching.

The root GameObject to ignore when tracing from AimRay.

Who gets credit for this weapon's damage (the engine's ). The owning player if held, the seated player if controlled from a contraption seat, otherwise the nearest kill source or the weapon itself.

Runs on the host when added to an inventory. The engine base seeds the magazines and the shared reserve pool - only when they've never been filled, so a dropped gun keeps its rounds through a pickup.

The input that fires the primary attack when this weapon is controlled via a seat.

The input that fires the secondary attack when this weapon is controlled via a seat.

Weapons wired into a contraption stay put - no pickup prompt, no Touch pickup.

Stays put away while the owner sits with their weapons holstered (see ).

A seated player can only control this while not holding a weapon of their own.

Dispatches a primary action from a connected signal.

Dispatches a secondary action from a connected signal.

Called when setting up the camera - use this to apply effects on the camera based on this carriable

Can directly influence the player's eye angles here

Turns the view model toward the mouse cursor while the inspect menu is open, and back when it closes.

Drops this weapon into the world as a pickup - the same live object, so it keeps its state (ammo, tool modes). Unparents it, drops network ownership, enables the dropped components and tags it cleanable. Host only.

The engine inventory is dropping this - throw the live object out in front of the dropper.

The engine disables a holstered weapon on every peer. Dropping the held weapon holsters it first and then enables it again on the host, but clients only ever see the end state ("enabled", the same as before), so their copy of a dropped weapon stayed disabled and invisible

Is this item currently being used? When true, prevents auto-switching away on item pickup etc.

The player carrying us just jumped. Forwards to the view model so its anim graph can react.

A weapon that can aim down sights

Lowers the amount of recoil / visual noise when aiming

Multiplier for the player's FOV while aiming in first person. 1 disables zoom.

Seconds to blend between normal and aimed FOV. 0 switches instantly.

Draws the crosshair while the weapon is not aiming down sights.

Aiming down sights narrows the spread cone.

Cooldown after a hit connects.

Cooldown after a swing misses.

Damage dealt per hit.

Reach of the swing trace.

Radius of the swing trace sphere.

Physics impulse magnitude applied to hit objects.

The swing. Runs once on the owning client - our trace decides what we hit, the engine claims it to the host, and the host applies the damage.

Draws the aiming dot with the current attack availability.

A projectile. It explodes when it hits something.

Tell the instigator their projectile hit, so they can do things like show a hitmarker

Spawns the medium explosion here, credited to the , and destroys the projectile. Host only - the explosion is network spawned.

Updates the current direction of the projectile

Throwable type

Is this a throwable?

The throwable type

A sound to play at a specific time during reload.

Seconds after reload starts to play this sound.

The sound to play.

Timed sound events to play during reload.

Timed sound events to play during each incremental reload cycle.

Timed sound events played when starting an incremental reload sequence.

Timed sound events played when finishing an incremental reload sequence.

Turns on incremental reloading parameters.

Animation speed in general.

Animation speed for incremental reload sections.

How much inertia should this weapon have?

Limit the inertia to avoid extreme swaying at lower framerate.

Swing the viewmodel around based on the player's look direction, with a springy lag. This is purely cosmetic and does not affect the actual camera.

Spring stiffness - how quickly it pulls back towards your actual look direction.

Spring damping. 1 settles with no overshoot, below 1 wobbles before settling - lower for a springier, bouncier feel.

How far out in front of the eye the gun pivots from. Larger values make the same angle lag produce a bigger visible swing, since the gun is swinging on a longer arm.

Overall strength of the effect, applied after the spring - 0 is off, 1 is the spring's natural lag, above 1 exaggerates it. Use this to dial the whole thing up or down without touching how snappy or bouncy it feels (that's Frequency/Damping).

Further multiplies while aiming down sights (on weapons with an ), so the gun holds steadier while aiming - below 1 calms the sway down, above 1 makes it worse.

Called by the weapon while the camera composes - feeds the aim inertia and lets the animation's camera bone drive the view (reload sway and kicks authored in the anim). This mutates the real camera view, not the viewmodel - the viewmodel itself is placed separately from the pre-bone snapshot, see .

Place the view model - called by the weapon's PlaceViewModel with the pre-bone view, so the camera bone moves the camera around the gun rather than dragging the gun with it.

Follow the render-only camera shake after placement, without feeding it into look inertia. Use the final camera view as the pivot to preserve the camera bone and procedural bob offsets.

Called when starting to reload a weapon.

Called when incrementally reloading a weapon.

Drives the scene's gravity from server settings

Shakes nearby cameras when a physics prop strikes static world geometry. Listening at scene level also covers map props, duplicates and restored saves.

The built-in Inspector right-click options: Ignite/Extinguish, Delete and Break. Addons add their own by implementing the same way.

Delete an object from the Inspector context menu.

Axis lock menu

Set the object's rotation locks from the Inspector context menu

Is this rotation axis locked on the object's physics bodies?

Tags that turn off a prop's collisions with everything but the world, or with the world. Their rules live in ProjectSettings/Collision.config.

Collisions menu

Turn the object's prop and world collisions on or off from the Inspector context menu

Break (gib) a prop from the Inspector context menu.

Set an object on fire from the Inspector context menu. The engine's FireDamage component damages every IDamageable under the root until it breaks. Objects that can't break (unbreakable props, non-damageable entities) just keep burning.

Put out a burning object from the Inspector context menu. Removes every fire effect (anything carrying a FireDamage) under the root; descendant destruction is networked.

Is this object currently burning? Works on clients too, since the fire prefab is replicated as a child of the root. Deliberately not Prop.IsOnFire: that flag is never cleared.

The built-in menus on the inspect menu's settings bar: Client, NPCs and Server. Addons add their own by implementing the same way.

Spawn from a string identifier (e.g. "prop:path", "entity:path", "dupe.local:id", "dupe.workshop:id"). Optional metadata string is passed through to the spawner for type-specific use (e.g. mount bounds/title).

Kicks a connected player with an optional reason.

RPC to kick a player. Caller must be host or have admin permission.

Kicks a player by name or Steam ID. Optionally provide a reason. Usage: kick [name|steamid] [reason]

Sets a replicated convar through the host. Only works for admins.

Broadcasts a phrase reference and data so each player formats the message locally.

Called when someone leaves the server. This will only be called for the host.

Spawns a player for this connection if they don't already have one. Host only. Fires first, so listeners can move or cancel the spawn. Pass to skip that event - for addons that cancelled the normal flow and now want the player in the world. Returns the new player, or null if the connection already has one or a listener cancelled.

Forcefully respawns a player, whether they're dead or alive. Host only. Removes their current player object and any observer without a death, then spawns a fresh one without consulting . This is the entry point for addons that run their own round flow: cancel the normal respawn, then call this when it's time.

Clean up any lingering death observers for this connection.

Called by the client (via PlayerObserver) when they want to respawn. If a listener cancels the respawn the observer is kept, so the player stays spectating until an addon calls or the next request goes through.

Approximate standing-player hull, used for spawn clearance and floor settling.

The last position we spawned a player at, so we can avoid reusing it.

Find a place to respawn: a floor-settled spawn point nobody is standing on, avoiding the last one used.

Called on the host when a played is killed

Called on the host when an NPC is killed. Credits the attacker and adds a kill feed entry.

Change a property, remotely

Apply a debounced batch of morph changes to a , replicated to all clients. Only the morphs present in the batch are modified.

Apply a full morph preset (as json), and captures with which replicates changes to other clients

Set the material that replaces every slot on a renderer, or clear it with a null/empty path.

Roots of objects currently in the water. Handy for playing sounds only once per object, even if it has multiple colliders (like ragdolls)

What the local player's HUD shows and how it looks, edited from the HUD tab of the inspect menu

What the local player sees of physguns, edited from the Physgun tab of the inspect menu

The local user's preferences in Deathmatch

This controls visibility of all HUD sections, such as health, ammo, hotbar...

Intensity of glow on HUD elements

Controls how large your HUD on screen will be

Spacing between HUD elements and screen borders

Tool panel shows current tool name, its description, and available key hints

Draw notifications on the right side of screen

These ones show up when you aim at interactable stuff, like chairs, NPCs and other entity things

Draws the list of who is talking

Nameplates show up above player models, so you know who's standing in front of you

This shows up in inspect menu when you aim at the prop, it tells you who spawned this prop/entity/whatever...

When disabled, you need to hold the key to keep spawnlist/inspect menus open. When enabled, you just need to press the key once to open it, and then press it again to close the menu.

Display physgun beam cast from you and other players

Draw outlines on props when they are being held by physgun

Show effect when prop is freezed

Show effect when prop is unfreezed

Opacity of the outline when it's showing a prop behind some geometry

Colour of your physgun's beam, its effects, its glow and the selection outline, as text. Empty for . Your player syncs it so everyone else sees your physgun in it, see .

Colour your physgun glows while it gravity pulls, as text. Empty for .

Enables automatic switching to better weapons on item pickup

Enables movement bob, weapon inertia and animation-driven camera motion.

Strength of the camera tilt when moving sideways

Intensity of your camera's screenshake

A colour preference as text. Plain invariant numbers rather than hex, so HDR brightness above 1 survives.

A colour preference, null when it's empty for the default or can't be read. Hex from older saves reads too.

Data passed to . In , set to true to stop it, or change to change a reason or map.

Who did it - the admin who sent it, or the host itself for its own menus and console.

The player kicked, banned or unbanned. They might not be connected.

The setting changed, for .

The kick or ban reason, the map, or the setting's new value (which can't be changed here).

Fire , returns false if a listener cancelled it.

Data passed to . Set to true to turn the connection away, with shown to them.

Enforces configurable limits on spawning and tool usage. Maintains a per-player tracked object list populated from post-events. Limit checks iterate only the player's objects, not the entire scene.

Per-player tracked objects keyed by SteamId.

Fast lookup to check if a GameObject is already tracked by any player.

Returns true if the given count meets or exceeds the limit. A limit of -1 means unlimited (never exceeded). A limit of 0 means none allowed (always exceeded).

Count tracked objects for a player, pruning destroyed ones. Applies an optional filter.

Check a per-player tool limit. Returns true if the tool type matched. Every action these tools send to the host places one.

Marks a const string as a permission, so it's sent to clients and listed for admins.

Permission checks that work on clients too. Only the host can ask the engine, so it sends each player the declared permissions they have when they join.

Admins count as having every permission.

True if the setting is on for everyone, or if this player has the permission.

Every permission declared in the gamemode and in addons.

Sends a player their current permissions. Host only.

A sharp impact jolt followed by a fast, fading rumble. Angular motion makes the hit visible against distant scenery as well as nearby props.

Server-controlled settings replicated to all clients.

Puts a server setting under a heading on its page.

Puts a server setting under a heading on its page.

Uses the phrase server.name if there is one, otherwise the [Title].

One page per group, Gameplay first and Other last.

Changes a replicated convar through the host. Only works for admins.

Rows are made with a generic call, so enums get one of these for their type.

When enabled, developer entities are visible in the spawn menu for all players. Always on in the editor regardless of this value.

On respawn, players get back the weapons they were carrying instead of the starter items.

Players with the GodMode permission can use it even when this is off.

See DamageBlame for how damage is traced back to a player.

Players with the Noclip permission can use it even when this is off.

Player ragdolls stay until a cleanup instead of despawning.

NPC ragdolls stay until a cleanup instead of despawning.

Returns true if developer entities should be shown.

A pickup that gives the player reserve ammo for a matching weapon.

The ammo resource this pickup gives ammo for. When set, ammo is added directly to the player's shared pool for that resource.

The quantity of ammo to give.

A weapon, or weapons, or ammo, that can be picked up

The pickup's collider, it is required

The sound to play when picking up this item

Check if the player can pick up this object

Give the player the effect of this pickup

Should this object be consumed, eg on successful pickup

Called when a gameobject enters the trigger.

Called when a gameobject enters the trigger.

A pickup that gives the player some health.

How much health to give to the player

The toggle state has changed

The toggle state has changed

Moves and Rotates an Object.

If not empty, the target must have one of these tags

If not empty, the target must not have one of these tags

A reusable property attribute that stores a string tag for resource picker filtering. The editor can read this attribute to filter GameResource assets by matching metadata.

Put this on something that acts for a player, like a vehicle for its driver, so its damage counts as theirs.

Return null if nobody is responsible right now.

Finds the player behind a piece of damage, like the shooter, the driver or whoever threw the prop. Null for the world, NPCs and unowned props.

How long a prop still counts as thrown after it's let go.

Call every tick while a player holds or throws something, on the machine that simulates it.

Scales and . Read on the owner, who moves their own player.

If true, the player will still collide with the world and other players. This probably means that the noclip mode is named wrong. But it's cool. It just becomes a fly around mode.

Drive mode, control props with various modes

Holds player information like health

Kill yourself

Switch to another map

Undo the last action for the calling player

The object we're driving, set by the host

Whether this player wants physics on what they drive, when the server leaves it up to them.

Whether what this player drives has physics right now

Flying, where we want to be. We fly it on our machine, the host moves it there.

Flying, how we want turned. With physics, what the host turns it towards.

With physics, how fast we want to go along the ground.

Whether we're sending where to fly or which way to push it, so the host doesn't use one for the other while it hears about a switch.

With physics, whether we've let go of the controls and left to physics.

The object the drive values are for, so the host doesn't move it anywhere before we've said.

Owner only, whether someone else had hold of what we're driving last frame.

Owner only, where the drive camera orbited last frame, so we can keep orbiting there if what we drive is destroyed.

Owner only, when we give the player back after what they drove was destroyed, or null if it wasn't.

Whether what we drove was just destroyed and the drive camera still orbits where it was before giving the player back.

Owner only, whether the driving panel is hidden. Kept between drives.

The tool panel's title and key hints while we're driving, or null if we aren't or hid the panel.

The controls that do something right now. Only getting out and hiding the panel while someone else holds it.

What we drove was destroyed, keep the player still while the camera keeps orbiting where it was.

Look around and zoom the drive camera

Fly it where the camera looks. We work out where it goes, the host puts it there.

The physgun colour this player picked, as text, empty for the weapon's own. Their own client keeps it up to date from their preferences, so everyone draws their physgun in it.

The colour this player's physgun glows while gravity pulling, like

Find a player for this connection

Get player from a connection id

Access the undo system for this player

The HUD elements the player wants hidden right now: everything in freecam, otherwise whatever the held weapon hides

True if the player wants any of the HUD not to draw right now

What pressing use would do to the thing the player is looking at, or null if there's nothing to show. The HUD shows it below the crosshair

Feeds into the HUD visibility event, so the camera weapon and freecam hide the HUD through the same path addons use. Panels ask through .

Whether this player is currently noclipping. Synced so proxies can animate correctly.

How far each action is pushed, 0 to 1, when it's on a gamepad's trigger or stick rather than a key. What the player drives from a seat runs on the host, which only gets whether actions are down, so they sync this with it. See .

Seconds of invulnerability after spawning, to stop spawn-killing. 0 disables it.

Time since this player last spawned. Drives .

True while the player is briefly invulnerable just after spawning, per the sandbox.spawnprotection convar.

Try to inherit transforms from the player onto its new ragdoll

Broadcasts death to other players

Called on the host when a player dies

Seated, a gamepad's triggers are forward and backward and its left stick steers: the same actions as the keys, so whatever we're driving needs nothing new - plus how far each is pushed, in .

Press an action from an analog input past its deadzone, and note how far. A key on it counts as all the way.

Runs on the owning client, since it simulates movement.

Launch velocity for a living player caught in a blast: away from the blast origin and upward, stronger the closer they were.

Movement is simulated by the owner, so the velocity change has to happen there.

Whether props have physics while they're driven, see .

Props are all forced to be in noclip

Players can control if they want to use physics

Physics are always enabled, cannot be disabled

Lets the player pick up light physics objects.

When disabled, nobody can pick things up with use.

The heaviest object players can pick up

How fast prop will fly once you throw it out of hands

How far in front of the eyes the near side of a carried object is held

We let go once the object gets this far from where we're holding it, like when it's pushed against a wall

The object we're carrying

The we're turning towards, at most degrees a second.

Scales how fast we can turn what we're holding. Starts at nothing on pickup and builds up over half a second.

An axis of what we pick up within 30 degrees of one of ours lines up with it.

Releasing use within this long of pressing it drops what we're holding, holding it longer rotates.

What we had out before picking something up, to take it back out when we let go.

How long a client waits for the host to put away before taking it as refused.

The object our joint is moving, so we can tell it when we let go.

Simulating instance only, clamp the target the holder sends to this far from their eyes

Called by the on their own machine every frame, before the weapon gets input.

What we carry turns with our yaw but not our pitch.

The body we're looking at within reach, if any.

Whether we're allowed to pick up . Asks the object and any listeners through a .

Picks up if we're allowed to (owner only)

Lines up any axis of within acos( ) of a frame axis with it, up first, so things are picked up straight.

Rebuilds the other two axes square to , keeping them as close to where they were as we can.

Turns what we're holding towards , slowly at first after pickup.

Lets go of what we're carrying where it is (owner only)

Puts away the active weapon, carrying takes both hands. False if it couldn't be put away.

Takes back out the weapon we put away to pick something up, unless something else has come out since.

Throws what we're carrying where we're looking (owner only)

Whether the holder can see within use reach, with some slack for where we see their eyes.

Displays fading HUD indicators pointing toward recent damage sources.

Texture drawn around the crosshair to indicate the direction of incoming damage.

Draws each active damage indicator and removes indicators whose lifetime has elapsed.

Holds persistent player information like deaths, kills

Sent by the host. Check with Permissions.Has instead, it also counts admins.

Is this player data me?

Data for all players

Get player data for a player

Called on the host, calls a RPC on the player and adds a stat

Data passed to pickup events. Set to true to prevent the pickup.

Data passed to drop events. Set to true to prevent the drop.

Fired from player's client when they try to pick up an object, and again on the instance that simulates it before it's moved for them. Set to true to refuse, or change to let them lift more or less. See .

Data passed to switch weapon events. Set to true to prevent the switch.

Data passed to remove weapon events. Set to true to prevent the removal.

Data passed to slot move events. Set to true to prevent the move.

Fired on the host when a player sits in a seat, before their weapon is put away. Set to true to let them keep weapons out in it.

Fired on the player's own machine when they press the flashlight key, before the flashlight toggles. Set to true to keep the key for yourself - a vehicle uses it for its headlights.

Pre-damage event. Fired before damage is applied. Listeners can modify or set to block damage entirely.

The player behind the damage, can be the victim. Null for the world and NPCs.

Pre-respawn event. Fired on the host before the player is spawned. Listeners can modify to control where the player appears, or set to stop the spawn entirely - for example an addon running its own round loop that wants dead players to wait. A player cancelled after death stays in the observer state; spawn them later with , which skips this event. This also fires for the first spawn on join, so a listener that cancels there is responsible for giving that connection something to look at.

Fired on the host before a player is given their starter weapons, on spawning without a saved hotbar to restore. Edit to change what they get, or set to true to give nothing.

The weapon prefabs to give, in order. Starts as the player prefab's starting items.

Fired when a player kills another player or NPC.

Events fired only to the Player's own GameObject hierarchy, except and the camera events, which go to the whole scene on the machine controlling the local player so UI can listen too.

Called on the local player's machine as they look around, sent to the whole scene.

Called on the local player's machine while their camera is set up, sent to the whole scene.

Called on the local player's machine after their camera is set up, sent to the whole scene.

Called every tick on the local player's machine before movement input is applied, sent to the whole scene. Set to false to prevent the player from moving with WASD this tick (e.g. while spinning a physgun-held object).

Apply fall damage to the player

Off is the Garry's Mod style, a flat for any fall past the safe speed.

Fatal fall speed, you will die if you fall at or above this speed

Maximum safe fall speed, you won't take damage at or below this speed

Multiply damage amount by this much

Damage taken from any unsafe fall when realistic fall damage is off

Fall damage sound

Optional point light placed in front of the player, softly lighting what's right around them.

How far in front of the eyes the fill light sits. Pulled back if something is in the way.

Ask whether anything else wants the flashlight key right now, like the headlights of a car we're driving.

Describes a player gib.

Give reserve ammo and report the amount actually accepted to its owner.

True while the player sits in a seat with their weapons put away. While seated, player cannot switch weapons. You can use to cancel holstering and keep weapons equipped while seated.

All weapons currently in the inventory, ordered by slot. Narrowing shim over engine Items.

The currently active weapon. Narrowing shim over the engine's .

Returns the weapon in the given slot, or null if the slot is empty.

A weapon of the same class we already carry, if any. Duplicate handling itself is the engine's (a duplicate donates its magazine to the reserve, see BaseCombatWeapon.OnAdding) - this just finds the weapon the donation lands on, for the pickup notices.

Activates the named tool mode, giving and equipping the toolgun first if the player doesn't have one.

Engine Touch pickup lands here (see ). Routes into , so duplicates donate their ammo and the pickup notices fire. Contraption- wired weapons refuse themselves (see 's OnCanPickup).

Fires the cancellable pickup events before the engine adds an item.

Drops the given weapon from the inventory. The engine holsters it, the weapon throws itself into the world (see ) and we switch to the best remaining weapon. The cancellable drop event fires from .

Whether picking up should switch to it. means it was handed over explicitly (spawn menu, give): that still honours AutoSwitch and a weapon in use, but skips the value comparison.

The weapon the inventory would auto-switch to. The engine's handles the Value ordering and the avoid-empty-guns fallback.

Asks whether this player may switch to (null means holster). Checks the weapon's own , then fires the cancellable switch event on the player and scene-wide, so addons can refuse. Runs wherever it's called - the hotbar uses it client-side to filter, uses it as the gate. Voluntary switches are therefore vetoed on the initiating client; the engine's host path isn't hookable.

Switches to the given weapon after asking . Wraps the engine inventory's , which handles host-routing and the outgoing weapon's holster veto. Forced switches (death, drop, removal) don't come through here and can't be vetoed.

Called by the owning client to drop their currently held weapon.

Removes a weapon from the inventory and destroys it without dropping it into the world. The engine holsters it, destroys it and switches to the best remaining weapon. The cancellable remove event fires from .

Remembers the weapons a player carries and, when the server has Re-equip Last on (), gives them back on respawn instead of the starter items. Lives on the Player GameObject alongside PlayerInventory. Listens to inventory events to auto-save, and handles all loadout RPCs directly.

One entry in a serialized loadout: the prefab resource path.

The saved hotbar to restore on spawn, or null for the starter items. Read on the owning client, where the hotbar is stored; the replicated server setting decides whether it's used.

Clears the current inventory, waits a frame, then gives the loadout from JSON and equips the best weapon. A layout that gives back nothing falls back to the starter items.

Dead players become these. They try to observe their last corpse.

Record stats for the local player

Data passed to . In , set to true to keep the entry and its objects.

The client whose undo history this is.

The action's title, possibly a phrase like "#undo.spawn".

The objects the undo removes.

Named parameters for the action title, resolved by the player viewing the history.

Raised on the requesting client when the host sends the latest undo history.

Get the undo stack for a specific SteamId

Call this when a player disconnects to prevent memory leaks!

Remove a GameObject from all player undo stacks.

Ask the host for the local player's current undo history.

Undo one specific history entry. The caller can only address their own stack.

Per-player undo stack

Create a new undo entry

Is this entry still in the history? False once it has been undone, evicted, or pruned.

Run the undo

Run and remove one specific entry from this player's history.

Return newest-first history, pruning entries whose objects no longer exist.

Remove a GameObject from all entries in this stack.

An undo entry

The action title, optionally a hash-prefixed phrase resolved by the receiving player.

Named parameters for a localized action title. Keep phrase references unresolved here.

Add a GameObject that should be destroyed when the undo is undone

Add a collection of GameObjects that should be destroyed when the undo is undone. The owner is sent their updated history, so add everything in one call.

Remove a GameObject from this entry so it will no longer be destroyed on undo.

Ask listeners whether this can be undone. Entries with nothing left to remove are always allowed, they're just skipped.

Run this undo

Displays the undone action using the receiving player's language.

Builder payloads use the standard placement, undo, drag and spawn event pipeline.

Tracks how many spawner payloads are loading on behalf of the local player, so the shows on the client who asked for the spawn - not whoever happens to be doing the loading (usually the host). Call with the requesting connection.

True while any spawner requested by the local player is still loading its payload.

Show the loading ring for until completes. A null owner means the local connection.

Payload for spawning a duplicator contraption.

Create a duplicator spawner from a storage or workshop ident. Resolution and package installation happen asynchronously via .

Create from raw dupe JSON (e.g. from a storage entry). No icon.

Creates a duplicator spawner from the serialized data string. This is what gets synced to clients, so it includes the icon and raw JSON.

Draws the duplication ghost, using a separate blueprint material for models that have not loaded yet.

Payload for spawning a scripted entity prefab.

Wrap an entity that's already loaded.

Get a yaw correction so the longest horizontal axis of the bounds aligns with forward.

Create an from its type, path, and optional metadata. The spawner may still be loading — await before use.

Resolve any metadata the host might not be able to work out itself (e.g. mount bounds and title). Call this on the requesting client before a spawn RPC. Returns null if there's nothing to pass.

Describes something that can be spawned into the world Implementations handle their own preview rendering and spawn logic.

Display name shown in the HUD while holding this payload.

A full ident if it's a sbox.game thing

Icon path for this payload, used for inventory display via thumb:path.

The local-space bounds of the thing being spawned, used to offset placement so it sits on surfaces.

Whether all required resources (packages, models, etc.) are loaded and ready to place.

A task that completes with true when loading succeeds, or false if it fails.

The raw data needed to reconstruct this spawner (e.g. a cloud ident, or JSON).

Extra data resolved on the requesting client that the host might not be able to work out itself (e.g. bounds and game title of mounted content). Passed alongside when networking.

The unspawned prefab GameObject, if available. Allows inspecting components before spawning. Returns null for spawners that don't use prefabs (e.g. props, duplicator).

Populate a right-click context menu with spawner-specific options. Override in spawner implementations to add custom menu items.

Draw a ghost preview at the given world transform.

Actually spawn the thing at the given transform. Called on the host. Returns the root GameObject(s) that were spawned so they can be added to undo.

Like , but attaches to the spawned object so clients without the mount installed can show a fallback cube and install prompt.

What the requesting client resolved locally, so a host without the mount still spawns it with the right size and game title.

What the requesting client resolved locally, so a host without the mount still spawns it with the right size and game title.

True if the mounted model loaded locally.

What we know about this mount (title and bounds), serialized to pass through spawn RPCs.

Resolve mount metadata on this machine, before asking the host to spawn it.

Payload for spawning a prop model from a cloud ident.

Lets scene components and systems add actions to an object's right-click menu. Options are collected with a sort order (lower is higher in the menu), then the Inspector builds the menu.

The network root of the object that was right-clicked.

Options collected so far, sorted by order. Stable, so options sharing an order keep insertion order.

Add an option. A disabled one is shown greyed out and can't be picked.

Build the collected options into a menu.

Lets scene components and systems add menus to the strip of settings along the top of the inspect menu, like Garry's Mod's context menu bar. Menus are found by title, so several listeners can add to the same one. The built-ins use the order 100 (Client), 200 (NPCs) and 300 (Server); the default of 0 lands before them.

Menus collected so far, sorted by order. Stable, so menus sharing an order keep insertion order.

Get the menu with this title, or add one. The order only counts when the menu is added.

Add a checkable row that reads and writes a setting. Its check mark is refreshed every time the menu opens.

A toggle only admins can change, greyed out for everyone else.

The mouse cursor while the inspect menu is open

How far the mouse has to move with the button held before a click turns into a prop drag

The pieces of the HUD that can be hidden independently. Flags, so a listener can hide several at once; hides everything, which is what the camera weapon and freecam do.

Health and armour.

The active weapon's clip and reserve.

The weapon hotbar.

The kill feed.

The scoreboard (held on the Score bind).

The active tool's name, description and action hints.

The weapon's crosshair and the cloud-loading ring around it. Use prompts are .

Name and avatar floating over other players.

The "Owned by" label for the object you're looking at.

Toast notices in the corner.

Who is talking.

Recent ammo pickups above the ammo counter.

The chat box and the recent messages.

The use key prompt for what you're looking at.

Lets any component in the scene hide parts of the HUD. Asked once a frame by whenever a HUD panel wants to know if it may draw. Implement this on an addon component and add the elements you want off screen: hidden |= HudElement.Inventory | HudElement.Ammo during a build phase, or hidden = HudElement.All for a cutscene. Anything nobody hides stays visible. (the camera weapon, freecam) hides everything through this same event.

This component has a kill icon that can be used in the killfeed, or somewhere else.

This component has a kill icon that can be used in the killfeed, or somewhere else.

Vehicle duplication category.

Robot duplication category.

Plane duplication category.

Pose duplication category.

Weapon duplication category.

Art duplication category.

Scene duplication category.

Game duplication category.

Spaceship duplication category.

Machine duplication category.

Toys duplication category.

Trap duplication category.

Boat duplication category.

Other duplication category.

Static movement classification.

Wheeled movement classification.

Flying movement classification.

Walking movement classification.

Water movement classification.

Tracked movement classification.

This component has a kill icon that can be used in the killfeed, or somewhere else.

Translate known category labels without changing their resource or search identifiers.

This component has a kill icon that can be used in the killfeed, or somewhere else.

The folders under this one that have models somewhere inside, each opening onto its own.

Hardcoded models that ship with the game and aren't available on the workshop. Add new entries here — they'll appear automatically in the Local props section.

A bundled model with a category identifier and optional localized title.

A bundled model with a category identifier and optional localized title.

Derives a display name from the filename: strips the extension, replaces underscores with spaces, and title-cases each word.

This component has a kill icon that can be used in the killfeed, or somewhere else.

We want to save the properties of this instance as cookies.

Prefix to put before the names of any cookies, without a trailing period. For example: "tool.balloon"

Extension methods for .

Saves any instance properties with a , excluding any with , into .

Loads any instance properties with a , excluding any with , from .

The burst of particles on something being frozen or unfrozen, by the physgun or while driving it.

Play the freeze or unfreeze effect on , here only. Callers broadcast it themselves.

How an object highlight looks: its outline colour, the colour where something closer hides it, and its width.

How an object highlight looks: its outline colour, the colour where something closer hides it, and its width.

Something we're acting on - held by the physgun, frozen, or selected in the inspector. In the local player's physgun colour.

Something under the inspector's cursor

The local player's outline width and how much of an outline shows through what's in front of it

The opacity-aware highlight material every sandbox outline draws with.

Add a hidden outline to , to point at things later with .

Outline , or hide the outline if it's not valid.

Outline , or hide the outline if there are none.

Stop outlining anything.

Briefly flash an outline around , fading in to times the style's colour and back out over seconds.

What to outline for : the whole ragdoll for one of its bones, otherwise itself.

A short-lived outline that fades in, peaks at boosted brightness and fades back out. Start one with .

Color multiplier at the peak of the flash effect

Fonts that can be picked by a player. Font must be added either from engine or project "fonts" folder, then put its name here.

Quick data folder file storage, good for saving local data

Serialize and write it to {key}.json under . The directory hierarchy is created automatically.

Read and deserialize the value stored at . Returns if the file doesn't exist or deserialization fails.

Returns true if a value has been stored at .

Delete the value stored at . No-op if it doesn't exist.

Resolves phrase references at the point of display, including data received from the host. Plain text such as workshop titles and player names is kept as supplied.

Resolves a hash-prefixed phrase and its named parameters using the local player's language. Parameter values can themselves be hash-prefixed phrase references.

Escapes user-supplied parameter text so a leading hash cannot become a phrase reference.

Localizes an input title inside the game while keeping the input configuration readable by the engine's settings menu, which does not load this game's phrase catalogs.

Localizes the display name of an input group without changing its identifier.

Returns a phrase reference for built-in resource types while preserving custom type names. Editor asset metadata remains readable outside the game's localization context.

The same by extension, for types without an asset type like materials.

A typed sort mode for finding packages.

Popular entries.

Newest entries.

Trending entries.

Random entries.

Returns the API supported string equivalent of this sort mode.

Material icon representing this sort mode in menus.

Only play the collision sound from this object's surface - not both the impacting surface and this surface.

Pure queries for placing things in the world: drop a position to the floor, test whether a spot is occupied, and pick a spawn position from one or more candidates. Never moves anything.

Settle onto the first solid (non-trigger) surface within below it. Returns it unchanged if nothing solid is below.

True if nothing solid (excluding the static world and triggers) overlaps the hull at — i.e. no player, prop or NPC is already standing there.

Pick a spawn position from one or more seed transforms: settle to the floor (unless is false), make sure nothing is standing there, and scan outward up to for a clear spot. Prefers spots away from . Best-effort if nothing is clear.

Candidate positions for a seed: the seed itself, then concentric rings of offsets when scanning is enabled.

A friendly sort mode for Storage/Workshop queries, wrapping .

Converts to the underlying value.

The tuning readout: everything the vehicle is doing, painted into the HUD by . Turn it on for the vehicle you're driving with vehicle_debug 1, or for one vehicle with its Draw Debug property. Host only, since only the host simulates.

The driver's keys, turned into throttle, brake, steering, boost and handbrake controls.

The drivetrain: engine, gearbox, brakes, handbrake, steering, power slides and boost, turned into torque and steering for the wheels (FourWheelVehicle.Wheels.cs), plus the pushes on the body - extra gravity and the power slide. The maths is in meters and Newtons, converted where it touches the engine (inches).

The driver's hands on the steering wheel, by IK. Put the hand targets under the steering_wheel bone's object so they turn with it ( poses it before we read them), each oriented the way the hand should grip. While the horn's held () the right hand moves off the wheel onto and opens flat. The seated pose sits too far back to reach a turned wheel, and the body's aim only bends the neck, so the whole body model tilts forward about the hips () before it's animated - the IK then solves from there. Foot targets (under the pedal bones, say) keep the legs from swinging down through the floor with it. Runs on everyone, from the synced steering and horn, on whoever's in .

Posing the model, a . Every machine poses its own from wherever it has the body: Wheel travel follows the host suspension state, interpolated between updates. The bones, where {c} is fl, fr, rl or rr: wheel_{c} - the knuckle, where the arm meets it (at the front, on the steering axis). It moves up and down with the suspension. The arm and shock are skinned from the body to this, so they follow. wheel_{c}_steer - a child of the knuckle where it is, that turns to steer: the front axle. Without one, a front knuckle steers itself. wheel_{c}_spin - a child of those at the tyre's centre, which is where the suspension holds the wheel. It rolls about whichever of its axes runs closest to the axle. steering_wheel - turns about . pedal_gas, pedal_brake, pedal_clutch - on their hinges, pushed forward - only for the driver, from their own feet (see ). Any other bone rides on its parent.

The wheels. They aren't bodies: each finds the ground below where it rests, and everything a wheel does - spring, damper, anti-roll bar, drive, brake and grip - is a push on the body where it meets the ground. The maths is in meters and Newtons. Lengths and velocities come in as inches and are converted, forces are Newtons until they become impulses on the body.

A drivable four wheel vehicle. It goes on the vehicle body, a normal rigidbody that still collides, tumbles and can be picked up. This file - the seat, the engine starting and stopping, what's synced to everyone FourWheelVehicle.Driver.cs - the driver's keys into throttle, brake, steering, boost and handbrake FourWheelVehicle.Drivetrain.cs - engine, gearbox, brakes, steering, power slides and boost FourWheelVehicle.Wheels.cs - the wheels: suspension, anti-roll bars, drive and grip FourWheelVehicle.Rig.cs - posing the model: wheels, suspension and steering wheel The wheels aren't bodies: each finds the ground below it and pushes the body where they meet. Where they are and what they look like comes from the model's bones.

Fill the HUD's vehicle readout, or hide it if this vehicle was showing it.

Slip the way tyre models think of it: how much faster the tread turns than the ground goes past under it (ratio) and how far the contact patch's travel is from where the wheel points (angle). The wheels always turn at the body's speed, so the ratio only shows locked wheels and the car turning about itself.

Slower than this (in/s) the car counts as stopped, and the throttle drives rather than brakes.

How fast the brake comes on, per second. Twice as fast braking with forward while rolling back.

Throttle held with the handbrake on: revving the engine in neutral.

The pedals, 0 to 1. Keys are all or nothing, a gamepad's triggers anything between.

Where to steer, -1 full left to 1 full right. Keys are full lock, a gamepad's stick anything between.

The boost is burning.

Recharging from a boost, so another can't start yet.

Let go of the steering: it returns to centre, slower the faster we're going.

Steering towards where the driver's steering (full lock on the keys), slower the faster we're going - but snapping back through the centre when changing direction or easing off, quicker on the brakes and while boosting.

Rolling the wrong way faster than this (in/s) with the throttle down locks the wheels, so you can hold the car on a hill and pull away.

The wheel torques are brakes, not drive.

Gravity in meters per second squared - what the tuning's multiples of gravity are of.

Scale on the scene's gravity that gives us .

Run the drivetrain for a tick with the driver's controls.

Speed along the body's forward axis, in/s, over the last tick (see ).

The most the front wheels can turn at a speed (mph), in degrees: less the faster the car goes.

Point both front wheels at the angle. Positive is to the right, in radians.

On the handbrake at speed the tyres swap for slippier ones, and steering into it pushes the nose and tail apart.

Wheels on the ground, and how fast the fastest sliding one goes - or the car's speed, sliding on the handbrake.

The automatic gearbox: the engine rpm from how fast the wheels turn, shifting up (only while accelerating) and down at the tuning's rpms.

The wheels' torques, in Newton meters, from the throttle [-1, 1] or the brake [0, 1].

The driver got out: normal tyres back on, and the handbrake.

Pushes on the body itself: extra gravity, and the power slide pushing the nose and tail sideways, two meters either side of the centre of mass. Both scale with the body's mass alone, without the wheels.

Where the right hand goes to press the horn.

How long the right hand takes to move between the wheel and the horn, seconds.

The animgraph hold type that shapes the right hand on the horn (holdtype), and its hand pose (holdtype_pose_hand) - tune these for the open palm. Empty leaves the hand as it is.

Optional foot targets. With the body tilted, the legs swing down too - these hold the feet where they belong.

How far the driver's whole body tilts forward towards the wheel, degrees, about .

Most the driver sways to the side in a turn, degrees, thrown to the outside of it.

Cornering (sideways acceleration, in/s²) that sways the driver all the way. The tuning's gravity is 600.

The sway's a spring: how stiffly it follows the cornering, and how quickly it stops wobbling.

What the body tilts about. Empty, it's the driver's pelvis, so they stay sat on the seat.

After , so the targets on the steering wheel are where it is this frame.

The hand and foot IK targets. takes them relative to the body as it is when it's called, so this has to come after the tilt or the targets get carried forward with it.

Where the driver's pelvis is with the body upright - so it stays on the seat while the body tilts over it.

Shape the right hand for the horn with the animgraph's hold type, right hand only - the arm's on IK, so only the fingers take it. puts the hold type back to none every update while there's no weapon out, so this is set from the late pose step each frame it's wanted and simply stops when it isn't.

Give the last driver their hands, feet, fingers and posture back.

Multiplies crash damage to the driver. Zero disables impact damage.

Closing speed in inches per second below which impacts are harmless.

Closing speed that deals 100 damage at a scale of one.

The vehicle hit something, on the host: closing speed in in/s and where. From the body's physics collisions and from the tyres blocking against obstacles (), which aren't physics collisions.

How far the pedals swing on their hinges when they're pushed all the way, degrees.

How long the clutch is in for a gear change, seconds.

The rig the wheels were set up from.

How far each wheel centre sits below its hard point as posed last frame, inches, and how fast that's shrinking - the wheel being pushed up into the body - in/s. Where it is in the world, for sounds.

How fast a wheel is being pushed up into the body, in/s (negative while it drops away). From the posed wheels, so it's the same on every machine - a landing or a bump hits hard.

Where a wheel's centre is in the world, as posed.

The model's rig, or null if there's no model or it doesn't have the wheel bones.

Put the wheels where the ground is, steer and roll them, and turn the steering wheel.

The driver's feet, on their own machine - it's their input, and nobody else can see the pedals. Gas and brake are what they're pressing, split the way the car splits it (the throttle brakes when it's against the way we're going). The clutch goes in for a gear change, lifting off the gas, and is held in at a standstill until we pull away.

How far the local driver's pressing an input, 0 to 1 - a gamepad's trigger part way ().

Swing a pedal forward on its hinge, which runs across the car.

A model's bones, where they rest in body space, and their pose this frame.

Every bone, parents before their children.

How each bone has been moved this frame, in its own rest frame.

Where the suspension holds the wheel: the tyre's centre at rest.

The axle a wheel rolls about at rest, pointing left: the spin bone's axis closest to the car's left, so it doesn't matter which way the bone was built.

Move a bone by an offset and turn it about itself, both in body space as it sits at rest. Its children go with it.

A bone's pose in body space this frame: riding on its parent as it did at rest, then moved. Call it in , so the parent's is ready.

Where the wheel centre rests in body space. The suspension runs straight down the body from here.

Steering angle, radians, positive to the right.

Drive or brake torque, Newton meters.

Held still by the handbrake.

Friction of the tyre the wheel has on (normal, braking or power slide).

How far below the hard point's radius-above the ground is, inches: the wheel centre sits at HardPoint + down * (GroundDistance - Radius). Spring length plus radius in the air.

What the wheel is pushing the body up with, Newtons.

Rolling speed, radians a second.

The hard point and the suspension's direction in the world this tick.

Where the tyre touches the ground, or would at full extension.

The spring pushes harder on a slope, to hold the car up as well as into it.

The axle and the way the wheel rolls, both flat on the ground.

Whether the grip forces hit the friction limit, and how fast the tyre slides over the ground once they have (in/s) - for the skid sound and the debug readout.

The axle in body space, steered: straight it points left.

The car carries its wheels' mass, and their inertia as point masses at the hard points - without it, it's light and far too easy to spin. The wheels' weight goes straight to the ground at the contact patches (), so the springs still only hold the body up.

The wheels' pushes on the body for this tick.

Find the ground under the wheel () and lay the axle flat on it.

See .

Where the ground is under a wheel: a sweep of the wheel's own shape, a cylinder as wide as the tyre around its axle, from a radius above the hard point down to the spring's full length. It meets a step's edge on the front of the tyre, and the slant of that contact is what lifts the wheel up onto it.

What a wheel stands on: anything but this vehicle and players.

An anti-roll bar: the more one wheel of an axle is compressed than the other, the harder it pushes them back level.

The spring and damper, pushing the body up off the ground, plus the wheel's own weight on it.

Gravity the physics applies to the body over a tick (the extra gravity is ours, a push like any other).

How the body moved at a point over the last tick. The velocity we read is where the last tick ended, and the physics adds gravity across its substeps, so a car sitting still reads as sinking (or rolling downhill) at half a tick's gravity - 6 in/s at 50 Hz. Taken as it is, the dampers hold the car up instead of the springs, and a car held on a hill never reads as stopped.

How the body will move at a point over the next tick if nothing but gravity acts. What a brake or a locked wheel has to cancel to hold the car still - including on a hill.

The tyres' grip. First the sideways forces that would stop each axle sliding, then each wheel's share of those and its drive or brake force, cut down to what its load and friction can hold.

The sideways force at the middle of each axle that takes its sideways speed away this tick (a little more, to settle quicker), solved for both axles at once since pushing one also turns the body under the other.

A locked wheel slides with plain friction against wherever its contact patch is going - which includes the patch swinging round as the car yaws, so a handbrake turn doesn't spin away. Each locked wheel stops its patch exactly, for the car's real inertia at that point, and the next one works from the car's motion after it. Pushed all at once from the same motion, the pushes below the centre of mass roll the car under the other wheels, and a parked car rocks and creeps sideways.

Carry an impulse we've just pushed the body with (kg in/s, at a point) into this tick's idea of how it's moving.

Push the body at the wheel's contact, an impulse in Newton seconds - and push back on whatever it's standing on.

How much a push at point A along direction A changes the body's speed at point B along direction B, per kg m/s - the inverse mass the body has between those two.

The driver's seat. Whoever sits here drives.

Local axis of the steering column, pointing at the driver.

How far the steering wheel turns at full lock, in degrees.

The gravity the tuning is for, in inches per second squared. The vehicle falls at this rather than the scene's gravity. Zero uses the scene's gravity.

Let tyres block against walls and other obstacles in addition to supporting the suspension.

Front wheel steering angle in degrees, positive to the right.

The handbrake has the wheels locked.

Engine speed for sound: the gearbox's, or the free revving engine's while revving in neutral.

The driver is accelerating (not braking, not on the handbrake).

Fastest a wheel is sliding over the ground, in/s.

Forward speed, in/s, negative backwards.

Speed in miles per hour, either way.

How fast the engine revs up and runs down in neutral, rpm a second.

Set up the body and the wheels from the tuning.

Driven from the seat by , before our fixed update, with the driver's input active.

A parked car that has settled goes to sleep, rather than being held up by its wheels every tick - that never quite comes to rest, it jitters on the spot. Anything that wakes the body (a hit, the physgun, a driver getting in) brings the wheels back.

Sync what everyone else needs: the steering and wheel visuals, and the engine state for sounds.

The engine starts and stops as people get in and out of the seat. Getting out puts the handbrake on.

Tilts drivers forward over their wheels and sets their IK () once every component has updated - the player controller places the body in its update, so ours has to land after it - and before the bones are animated, so the IK solves from the tilted body.

A chase camera for whoever's driving, in third person. It sits behind the car and swings round after it, a little late - more so in a slide, where it looks the way the car's going. It hangs back as the car accelerates and closes in under braking, the field of view opens up with speed and boost, it shakes a little when it's going fast, and it settles after jumps. The mouse orbits it and it stays where you put it, until you've been driving a while without touching the mouse - then it eases back behind the car.

How far behind the car the camera sits, inches.

How far above the car's origin the camera sits, inches.

The point the camera looks at: this far above the car's origin, inches...

...and this far ahead of it.

How quickly the camera swings round behind the car - higher is tighter.

How far towards the way the car's actually going the camera looks in a slide, 0 to 1.

How much of the car's pitch on a slope the camera takes, 0 to 1.

Inches the camera hangs back per inch per second squared of acceleration (closes in under braking).

Inches further back at top speed.

Degrees of field of view added at top speed, and on top of that while boosting.

How much the camera shakes at top speed, inches.

Seconds of driving without touching the mouse before the camera eases back behind the car.

Miles per hour the car has to be doing for the camera to ease back behind it. Slower, it stays where you put it.

The local player is in the driver's seat, looking from behind.

Straight behind the car, no lag - getting in, or switching to third person.

A critically damped spring towards a target moving at a given speed, responding at about the given rate.

A vehicle's headlights (the low beams) and its light bar (the high beams), which comes on as well as them. The driver taps the flashlight key to switch the headlights on and off, and holds it to switch between low and high beam. While they're driving the key is ours: we cancel the player's own flashlight through .

How long the key has to be held to switch beams, seconds. A shorter press switches the lights on or off.

How long the bulbs take to come up to full brightness or go out, seconds.

The light bar. It comes on as well as the low beams.

Tap to switch the lights, hold to switch beams. Runs on the host, from the driver's seat.

The driver's flashlight key works the headlights instead.

Small maths helpers for the vehicle code.

Move towards by at most .

Map from [a, b] to [c, d], clamped to the range.

Zero counts as positive.

How the body handles. Values are in the units they're tuned in (mph, inches, kg, multiples of body mass) and converted where the physics uses them.

Local centre of mass. Zero uses the model's.

Body mass in kg, without the wheels. Zero uses the model's.

Extra gravity pushed on the body, as a fraction of normal gravity.

Degrees per second. The body's angular velocity is clamped to this.

Miles per hour.

Miles per hour.

Speed gain allowed over while coasting before the brakes go on.

The auto brake is this times the speed gain.

How much boost multiplies the engine's torque.

Seconds after the boost ends before it can be used again.

Miles per hour.

How much of the boost you get from a standstill, rising to all of it at .

Steering cone at zero to slow speed.

Steering cone at fast speed to max speed.

Steering cone at max boost speed (blends toward this after max speed).

Steering is linear, then raised to this power to be slower at the beginning of the curve.

Miles per hour.

Miles per hour.

Inches per second squared, pushing the nose and tail apart while power sliding.

Inches.

Inches. The width of the cylinder swept for the ground.

Kilograms. Carried by the car, but standing on the ground rather than on the springs.

Tyre friction, times the ground's.

Tyre friction while handbrake sliding.

Tyre friction while power sliding.

Drag on a rolling wheel, as a fraction of the load on it.

How far below its rest position the wheel hangs with the spring relaxed, in inches.

Maximum wheel travel above rest, in inches.

Multiple of body mass, Newtons per meter.

Multiple of body mass, damping while the spring relaxes.

Multiple of body mass, anti-roll bar stiffness between this axle's wheels.

Multiple of body mass, damping while the spring compresses.

What the driver's asking for.

What the vehicle's doing.

Inches per second along the body's forward axis.

Degrees.

What the engine's doing, as far as its sound goes. Each state plays its own recording.

A band of speed (as a fraction of top speed) one gear sound covers.

The recording for a sound state.

Recording for this state. Left empty, the state is silent.

Seconds to stay in this state before moving on.

An impact sound for the body hitting something. The hardest one a hit reaches plays.

How hard the body has to hit, in/s along the contact normal.

Knock the engine sound back to idle, as if the driver lifted off.

Engine, gear, skid and crash sounds for a : one recording per sound state, chosen from the throttle and how fast the car is going. And the exhaust backfires - a crackle when you lift off from high revs, pops against the rev limiter and on hard upshifts - with a flame out of the pipe. Runs on everyone from the engine state the host syncs on the vehicle.

Where the exhaust comes out, pointing out of the pipe. Backfire flames come from here.

Spawned at the exhaust on each backfire.

Most backfires a second in the crackle after lifting off.

Revs the crackle starts from, as a fraction of max rpm.

Backfires a second against the rev limiter.

Pop on upshifts with the throttle down.

As the vehicle speeds up it moves through these, each with its own gear sound.

Seconds after an impact sound before another one that isn't harder can play - several shapes and substeps report the same hit.

Looped while skidding.

Played at a wheel when it's shoved up into the body - landing, bumps, kerbs.

How fast a wheel has to be pushed up (in/s, in the model's own scale) to make a sound, and how fast for full volume. Read from the posed wheels, which ease towards the host's suspension, so it peaks lower than the real spring - about 30x the jump in travel.

Seconds before the same wheel can clunk again.

Sounds while the driver holds , until they let go or it runs out.

How long the horn takes to fade out when let go early, seconds.

The driver's holding the horn.

The horn key. Runs on the host, from the driver's seat.

Move through the sound gears with the speed and pick the state - the throttle, reverse, boost and speed come from the host.

Listen for the vehicle's impacts () - the body's collisions and the tyres blocking against walls - following if it's swapped.

On the host: keep the hardest hit this tick, played from .

The hardest of this speed reaches, whatever order they're listed in. -1 for none.

The skid sound. We have to slide at least 15% of our speed at higher speeds to make it, otherwise it plays too often.

A clunk when a wheel is shoved up into the body hard enough, louder the harder. Engine or not - a car dropped off the physgun lands just the same. Only the hardest hit each frame plays, so four wheels landing together don't stack up into one loud one.

Fade out the old state's sound and start the new one.

The exhaust backfiring. Unburnt fuel lights in the hot pipe: for a moment after lifting off from high revs (it builds up under hard throttle and dies away over about a second), against the rev limiter, and on hard upshifts. Each one pops and shoots a flame out of the exhaust.

A camera weapon that can be held by a player and renders to a render target texture, which can be displayed on a TV.

The RT camera's resolution

The render target texture produced by this camera. Read by .

We want to control the camera fov when held by a player.

Keeps the camera view clear of weapon HUD elements.

Draws the outlined aiming dot with the current firing status.

Draws the outlined aiming dot with the current firing status.

A throwable grenade weapon Cooks while held — explodes in hand if held too long

Sound played when the pin is pulled and cooking starts.

Sound played when deploying the next grenade after a throw.

Fuse time in seconds — grenade explodes after this, whether thrown or not.

Explosion damage radius.

Maximum damage at the center.

Physics force scale for the explosion.

Draws the aiming dot with the current grenade availability.

Explodes after a set time. Spawns an explosion prefab with configurable radius, damage, and force.

Who gets credit/blame for the explosion (the thrower). Host-side only. Falls back to the explosion itself.

M4 assault rifle.

Draws the crosshair arms at the current spread and firing status.

A 40mm launcher round - flies on a ballistic arc, nose along its velocity, and explodes on the first thing it touches. Shooting it mid-flight sets it off too.

Seconds before a round that never hit anything is removed.

The round the launcher fires - needs an .

Launch speed of the grenade.

Reserve grenades granted on first pickup - reloads top the launcher's magazine up from these.

Spawns and launches the grenade with the host's permission.

Draws the crosshair arms at the current spread and firing status.

How bright the glow is, while pulling and not. The colour itself comes from the holder's physgun colours, see .

Strength of the glow particles and tip sprites in grav (yellow) mode relative to phys (blue). Yellow at full strength saturates into flat, hard-edged blooming discs.

How bright the glow is, while pulling and not. The colour itself comes from the holder's physgun colours, see .

Input for increasing the distance to the grabbed object.

Input for decreasing the distance to the grabbed object.

Spring frequency of the beam's middle point. Higher values follow the physgun aim more tightly.

Damping ratio of the beam's middle point. Below 1 overshoots, lower values wobble.

How far, in degrees, the beam's middle point may swing away from the aim direction when the camera moves fast.

The physgun's colours when the holder hasn't picked any, what an empty stands for

The holder's colour for the beam, its effects, the glow and the outline - the only place they get their colour from

The holder's colour for the glow while gravity pulling

A part of the physgun in exactly . The colour the part has in its prefab only says how bright it glows: it stays that bright to the eye in , the default, and brighter or darker colours scale every part alike.

for a part in the beam colour

A physgun colour for the screen and crosshair, which show it as it is: HDR ones are brought down to fit

Outlines the object held by the beam, visible only to player holding the physgun

Takes the beam and its end effects off screen, leaving the outline alone

Draws the power meter and channel labels on the viewmodel screen.

Draws a targeting dot when the physgun is not holding an object.

Half-angle, in degrees, of the cone player aim has to stay within to keep pulling a locked object.

Within this many degrees of the object the pull runs at full strength, fading out towards .

How far in front of player aim the cone's apex is placed when we lock onto an object.

Once a gravity pull finds an object it locks onto it, and keeps pulling while our aim stays within a cone from an apex in front of us to the object. The apex follows our position.

How strongly we pull, from 1 when aiming at the object down to 0 at the edge of the cone.

Pulls the locked object along the cone, towards its apex.

When the aim ray misses, look for something to pull near it.

The ragdoll a body is part of, if it's one of its bodies.

The root body of the ragdoll this body is part of, the same one that drives the ragdoll's transform.

The closest point on an object, counting every body of a ragdoll and not just the one we hold.

The gravity hold loop plays at when the object is this far away or further.

The gravity hold loop plays at full pitch when the object is this close or closer.

Gravity pulls only: the pull cone's apex, as a world-space offset from the aim position.

Gravity pulls only: how strongly the object is pulled, depending on how well we aim at it.

on the physics body. On a proxy the body chases the latest network transform while the object is drawn interpolated, so measure the body against this, not the drawn point.

The force applied to pull objects to us.

The force applied when launching grabbed objects.

The distance at which we'll grab an object when pulling it towards us.

How quickly W/S moves a held object while rotate mode is active.

Increases the grab distance using a connected signal.

Decreases the grab distance using a connected signal.

The object our joint is moving

Tells the object we were moving that we let go of it

The holder's target once the interpolated one is all for what they hold, until then where we grabbed it.

The frame is relative to: the full aim rotation for gravity holds, only the stabilized yaw for beam grabs.

When true, the physgun aims where the seated player's camera looks.

Ask the object if it allows being grabbed (anything can reject via IPhysgunEvent)

Is this physgun holding or pulling it in? The grab is synced, so this works everywhere.

The holder picks what to grab on their machine, so check it again here before moving it for them.

Colours a physgun effect (the beam end and the grab ball) in exactly the holder's colour. The prefab's own colours only say how bright each part is: particle gradients are turned grey and glowing materials neutral, so nothing else tints them. Remembers what the prefab set up, so it can be applied every frame.

Colour and everything under it in

Swaps a glowing material for a copy without its self-illum tint, which goes into the model's original tint instead so it stays as bright

Draws the outlined aiming dot with the current firing status.

An RPG projectile. It supports either being fired in a set direction, or continuously updated with an end target.

This is meant to be called continuously, updates the target, rotates slowly to it and moves at a set speed.

When enabled, fired rockets will continuously track toward the player's crosshair. Toggle with right-click (player) or SecondaryInput (standalone/seat).

Whether a live rocket is currently being guided toward the crosshair.

Standalone / seat control — uses SecondaryInput to toggle tracking.

Traces from AimRay and returns the world-space point the player is looking at.

Muzzle flash + launch sound. Plays for the shooter (predicted) and, via the host relay, everyone else.

Creates the projectile with the host's permission

Draws a diamond for guided aim or a square for an unguided rocket.

Play the shared tool beam (including its sound), impact and viewmodel animation.

How long a screen transition lasts after

How bright the screen flares at the start of a transition, fading back to 1

Starts a transition on the screen, drawn by using

A transition from is still running

How far through the current transition the screen is, 0 to 1

Override to match a different model's screen material.

Override to use a different screen material

Size of the screen texture. The toolgun's dot matrix shader draws one dot per pixel.

Minimum time in seconds between screen redraws

Add energy to the coil spin (e.g. on fire).

Smoothly decays the coil spin and applies it to the viewmodel's "coil" object.

Updates joystick_x and joystick_y on the viewmodel based on a per-frame look delta.

Updates the viewmodel screen render target and redraws it.

Override this to draw custom content onto the viewmodel screen.

Draws a smooth spread ring and aiming dot with the current firing status.

Sniper viewmodel helper. Moves the weapon down during scope transitions.

Scoped zoom goes through the engine's camera modifier chain - one owner for the FOV, no fighting the player's preference FOV write.

Updates the scope overlay while scoped, otherwise draws the targeting dot.

Draws an outlined targeting dot showing whether the weapon can fire.

Updates the scope's blur from mouse movement and player velocity.

Limits the world scale the resizer tool can apply to an object.

Allows listening to tool actions across the scene. Implement this on a to receive callbacks before and after any tool action fires. Use this to enforce limits (e.g. max balloons, max constraints) or react to tool usage. Runs on the host, from the RPC that carries the action out, so a cancel can't be skipped by the client. Actions that never reach the host, like cycling a tool's local settings, don't fire it.

Data passed to . Set to true to prevent the action.

The tool mode that is about to execute. Check e.Tool is BalloonTool, e.Tool is WeldTool, etc. for tool-specific logic.

Which input triggered this action.

The connection of the player performing the action.

Set to true to cancel the action.

Data passed to after a successful action.

The tool mode that executed the action.

Which input triggered this action.

The connection of the player who performed the action.

GameObjects created by this action, if any.

Called before a tool action executes. Set to true to reject the action.

Called after a tool action has executed successfully.

What sent with the constraint, on the host while runs.

Lets tools define what constraints should be removed when removing constraints from a game object.

Settings for the entity the constraint carries, sent to the host with it, see .

Called on the owning client after a valid constraint creation was submitted to the host. Follow-up RPCs are ordered after the constraint creation RPC.

Determines whether the button is active only briefly when pressed, or alternates between on and off for each press.

Cloud decals that ship with the game. Each ident must be a string literal inside so the code generator picks it up as a package dependency, which mounts it and makes it show up in the decal tool's resource grid.

How fast we're scaling this decal depending on player's mouse input

Multiplies the decal's own attenuation angle, lower fades less at grazing angles.

If enabled, each decal will be applied with random rotation

The rotation hint is pointless when random rotation is enabled, hide it if true

Reload and secondary held together scale the decal

Owner-side id of the current spray

Host-side undo entry for the spray identified by .

Local client preview of the selected decal where the player is looking

Spawn a decal on the host. A non-zero groups the decal with every other decal sent with the same id into a single undo entry. The settings come with the call, since only the owner has their current values.

The spray has no explicit end, the entry is created lazily with its first decal, so it is registered no matter how painting stops. A new spray id, or the entry leaving the history (undone mid-spray, evicted, stack cleared), starts a new entry

Holds a bunch of GameObject json, a bounding box, and some preview models for a duplication. This is what gets serialized to a string and stored in the Duplicator tool. The objects and the bounds are created in selection space. Where the user right clicked to select is 0,0,0, and the player's view yaw is the rotation identity.

An array of JsonObject objects, which are serialzed GameObjects

The bounds are used to work out where to place the duplication, so it doesn't clip through the floor.

Describes where to draw a model for the preview

Describes where to draw a model for the preview

A list of preview models to help visualze where the duplication will be placed

Packages used in this

Create DuplicationData from a bunch of objects. center is the transform to use as the origin for the duplication. The rotation of center should be the player's view yaw when they made the selection.

Render duplicator Json to a bitmap

When we right click, to "copy" something, we create a Duplication object and serialize it to Json and store it here.

While held, the duplication's up axis follows the surface normal instead of world up

Shows the rotation hint while a duplication is available to place.

Handles copying, placing, and rotating the duplication while reload is held.

Save the current dupe to storage.

Reject players and any objects with players as descendants. This is used for the duplicator to avoid accidentally duping the player and all their attachments.

Adds a GameObject. Won't find connections.

Add a GameObject with all connected GameObjects

The physical emitter body to spawn (model + physics).

The particle/VFX effect the emitter will produce.

Check if we're hitting an object with model physics or regular rigidbody prop

The world Z position the hoverball is trying to maintain.

How fast the target height changes when inputs are held.

Horizontal air resistance applied while hovering. Also increases vertical damping.

Is the hoverball on?

While held, raises the hover target.

While held, lowers the hover target.

Toggles the hoverball on/off

A pair of ball sockets, we try to align the balls towards eachother.

Shared geometry for two-point length-changing constraints (Hydraulic, Muscle, Winch): a shaft between two capped anchors, driven by a .

A length-changing constraint: a SliderJoint whose length is puppeted between MinLength and MaxLength by player input, wires, or an idle animation loop. Hydraulic, Muscle and Winch are the same component with different presentation and defaults - just picks which one this instance is, for undo names, tool info and wiring titles.

While the input is active we'll extend towards full length

Emits the current 0-1 extension whenever it changes. Wire it into a gauge, a dependent mechanism, or another length constraint's Push/Pull to gang two rams together.

The material to apply, a local path or a workshop package ident.

Drives a at a continuous angular velocity — a spinning axle, turntable, or wheel that isn't a ground-contact wheel.

Spins on its own as soon as it's created, without needing a driver or a wire signal.

While held, spins forward regardless of or .

While held, spins backward regardless of or .

Emits the joint's current angle, normalized so a full turn is 1.0 — wire it into a gauge, or into another motor's Forward/Reverse to sync two axles.

The spin axis is the surface normal where you make the first selection - this flips it 180 degrees, which is only useful in combination with and a limit range.

Previews and places objects into the world. Accepts any to define what to spawn. The spawn menu (or any other system) sets the payload, and this mode handles aiming, previewing, and placement.

Synced payload descriptor. When this changes on any client, reconstructs the locally.

The local spawner, built from .

True while the player is holding reload to rotate the preview.

Accumulated rotation offset applied to the spawn preview.

Hold snap to steer the aim onto the grid, so placement lands on grid points.

Set what this mode should spawn. Host only, syncs to all clients via .

Clear the current payload, returning to an idle state.

Called on every client when changes. Reconstructs the locally so each client can render the preview.

Serialize a spawner for networking, including its so clients build it the same as the host, even if they're missing its content.

Reconstruct an from

Handles placing, clearing, and rotating the preview while reload is held.

Direction to stack objects in.

How to interpret the stack direction axis.

Stack along world-space axes regardless of object orientation.

Stack along the target object's local axes.

Number of copies to create.

Rotation offset (degrees) around the first perpendicular axis of the stack direction. For Up/Down stacking this rotates around the right axis.

Rotation offset (degrees) around the second perpendicular axis of the stack direction. For Up/Down stacking this rotates around the forward axis.

Extra gap (in units) between each stacked copy.

Which direction to stack in.

Whether to align the stack axis to the world or the target object.

When true, stacked copies will be frozen (motion disabled).

Resolve to the networked root object so we clone the full prop, not a child collider.

Cycle through stack directions on reload.

Toggle between world and object alignment.

Check if the aimed-at object is a valid stacking target.

Get the local-space direction vector for the configured .

Get the two perpendicular axes for a given stack direction. X and Y angle offsets rotate around these respectively.

Build the per-step rotation from the X/Y angle offsets around the two axes perpendicular to the stack direction.

Compute how far apart copies should be along the stack axis by projecting the object's oriented bounding box corners onto the actual world-space axis.

Compute the world transforms for all stacked copies using iterative placement. Each copy is positioned relative to the previous one, so angle offsets produce correct arcs and circles rather than spirals.

Render ghost previews of each stacked copy.

Server-side spawn: recomputes transforms from synced properties to prevent clients from sending arbitrary placement data.

Which renderers an outline effect is drawing around, and in what colour. Worked out once a frame, the first time someone asks, for things that can't be outlined by the effect and draw the highlight themselves, like .

The colour of the first active outline drawing around , if any is.

Text placed in the world

How thick the box we trace and grab against is.

Height of the font in world units.

Whether the text falls. Only when it collides, so there's something to land on.

The look of the text, from its properties

What we show, never empty. Text with nothing in it couldn't be seen or picked again, so an edit that erases it all keeps the last text.

Builds the text as soon as we're on, the same frame as the renderer, so we avoid seeing engine placeholder text

Changes with any of the settings, so a frame where none did costs a hash rather than a new .

The colour of an outline effect drawing around us, like the inspector's selection or the physgun's hold. Those only draw around models, so we draw the highlight into the text ourselves.

Offset from the surface to avoid collision clashing

Where the text goes for a point on a surface. It faces out of the surface and stands upright on walls, on floors and ceilings its top points the way we're looking so it reads the right way round.

Every text style is a cached text block, so the pulse moves in steps rather than making a new one each frame

Local client preview of the text where the player is looking

Spawn the text on the host. The settings come with the call, the look as a , since only the owner has their current values.

How a placed text looks, everything apart from what it says. The text tool and both show these as properties of their own, this carries them from one to the other and turns them into what the renderer draws. Lengths are world units, like the font size.

The text is laid out this many times bigger than it shows and scaled down, so small sizes keep their shape.

This style kept within the limits, for values that came from someone else. Numbers that aren't numbers go back to the defaults.

The text cut down to .

This style see-through by , its outline and shadow too.

What the renderer draws for in this style. A highlight is drawn as an outline around everything else, for when an outline effect wants to draw around the text but can't since it isn't a model.

The size in world units of the text drawn in this style, effects included.

We can't get exact size by when we're from dedicated server, so fuck it and just try using approximate colliders instead.

Puts the text on a renderer in this style, at its size in the world.

Attach to a thruster GameObject to spin a target model based on thrust output. The model spins around its local up axis proportional to ThrustAmount.

The model renderer to spin.

Spin speed in full rotations per second at maximum thrust.

While this input is active we'll apply thrust

While this input is active we'll apply thrust in the opposite direction

The fallback sound for all thrusters.

Looping sound played while the thruster is active.

Current thrust output, -1 to 1. Updated every control frame.

Overrides a SelectionPoint's local position to the nearest snap grid corner

Stage 2: mouse controls rotation, shift snaps to 15° grid, attack1 confirms, attack2 cancels.

Intercept the Stage 1 click to enter rotation stage instead of finalizing.

Accumulate mouse yaw into rotation, with optional shift-to-snap.

Draw a ghost preview of the source object and all its connected objects at the given placement.

Draws a spinning direction arrow overlay on a wheel face.

Center of the wheel. The wheel's spin axis (points outward from the wheel face). A stable up reference that doesn't rotate with the wheel. Visual radius of the overlay. Whether the spin direction is reversed.

Manages a world-space snap grid overlay projected onto a surface plane.

Fallback half-extent used when the hovered object has no usable bounds.

The snapped world-space position of the highlighted corner

Returns the nearest grid corner index (cx, cy) and its world-space position, given the face plane in world space and the aim world position.

Updates the collision-based snap target and render-mesh overlay. After calling, read for a snapped position

Hide the overlay

Returns the OBB (oriented bounding box) of in world space. Prefers model-local bounds (tight, rotation-aware) over collider world AABB.

Projects onto the plane defined by and .

Returns the half-extents of an OBB projected along and . Uses the OBB support function, which correctly handles rotated objects.

Destroys the underlying scene object.

Identifies which toolgun input slot an action is bound to.

How the input is sampled each frame.

Fires once when the button is first pressed.

Fires every frame while the button is held.

A registered tool action. Stores the input binding, a dynamic display-name lambda, the callback to invoke, and the input sampling mode.

A registered tool action. Stores the input binding, a dynamic display-name lambda, the callback to invoke, and the input sampling mode.

The engine input action string for this .

This tool's settings that share a name and type with 's properties, as JSON for a spawn RPC, since only the owner has their current values. See .

Host side of : sets the settings on a newly placed entity, only ever its properties, the same ones its context menu can change.

A point in the world selected by the current player's toolgun. We try to keep this as minimal as possible while catering for as much as possible.

Returns true if GameObject is valid - which means we hit something

Returns the position of the hit - in the world space. This is the transformed position of the LocalTransform relative to the GameObject.

Returns the transform of the hit

Returns true if this object is a part of the static map

Returns true if this object is a player

Get a SelectionPoint along a ray.

Get a SelectionPoint from the tool gun owner's eyes.

Given a clicked point on a, and a clicked point on b, return a transform that places the objects so the points are touching

Helper to apply physics properties from a model to a GameObject's

When true (default), a SnapGrid overlay is shown on the hovered object surface. Override to return false to opt out.

Label for the snap hint, shown whenever this tool uses the snap grid.

The active snap grid, updated every frame in . Null when snap grid is disabled or the tool is inactive.

While snapping, the unsnapped aim driven by the mouse. The grid is traced from this, and the real camera is steered onto the resulting snap point.

True when the snap grid was updated from a valid surface this frame.

While hovering an object, hold alt key to keep the camera aim snapped to the grid

The ray the snap grid is traced from, free aim while snapping, otherwise the eyes.

Override to control which objects show the snap grid. Excludes player geometry by default.

The mode should set this true or false in OnControl to indicate if the current state is valid for performing actions.

When true, the toolgun will absorb mouse input so the camera doesn't move. The mode can then read to use the mouse for rotation etc.

Display name for the tool, defaults to the TypeDescription title.

Description of what this tool does.

Label for the primary action (attack1), or null if none. Auto-populated from registered when not overridden.

Label for the secondary action (attack2), or null if none. Auto-populated from registered when not overridden.

Label for the reload action, or null if none. Auto-populated from registered when not overridden.

Label for reload and secondary held together, or null if none.

Tags that TraceSelect will ignore. Override per-tool to filter out specific objects. Defaults to "player" so tools cannot target players.

When true, TraceSelect will also hit hitboxes.

Reflection info for this tool's type. Lazy so it's valid before the component starts.

Register a tool action that will be dispatched automatically by the base . The display name is a lambda so it can vary with tool state (e.g. stage-dependent hints).

Track a GameObject created by this tool action on the host. These are passed through to when the post-event fires.

Returns the display name for the first registered action matching , or null.

Fire at the top of the host RPC that carries out an action, so listeners can refuse it where it counts. Returns true if the action should proceed, false if cancelled.

Fire at the end of the host RPC once the action has succeeded. Passes a snapshot of tracked objects, then clears the list.

Check registered actions and invoke any whose input condition is met this frame. The host RPCs the callbacks call fire the pre/post events.

Scrolls the tool name across the viewmodel screen's dot matrix in .

Draws a crosshair showing whether the current tool action is valid.

Called on the host after placing an entity or constraint. Fires an RPC to the owning client so it can walk the contraption graph and record achievement stats locally.

Not shown in the tool list, seperate from because that's a much more general thing.

Colour of the tool name and swipe edge on the viewmodel screen, independent of the HUD tint. Goes past 1 for HDR glow.

The mode the screen is switching to, and the one it showed before

Draws the current tool mode on the viewmodel screen. A new mode swipes in from the left over the old one, along a glowing, ragged edge that jumps about as it goes.

Cheap repeatable 0-1 noise for the swipe edge

Draws the active tool mode's HUD, its crosshair.

Switches the local player's toolgun to a random tool other than the current one.

How tall the list is on screen in screen pixels, zero when nobody is shown. The notices stack above it.

How much someone is talking, 0 to 1. Never quite zero while they are in the list, so a quiet moment still looks lit.