package.facepunch.sandbox

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.

Radius around the current position to pick a flanking point.

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

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.

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

How long after losing sight of a player to keep searching their last known position.

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

The player this friendly NPC is following, if any.

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

Wanders to random nearby points when no player is known.

Maximum distance from current position to pick a patrol destination.

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.

The prop currently being held, if any.

Pick up and hold a prop — disables physics holdtype_pose ranges: 0-2 : close grip (~16u out), interpolates weight poses — used for heavy objects, but small enough to hold close 2-4 : arms extend outwards — used for normal objects, mapped by width 4-5 : above the head — used for large objects

Drop the held prop — clears IK, holdtype, holdtype_pose, places the prop on the ground in front of the NPC, unparents, and re-enables physics. Safe to call when nothing is held.

Update IK hand targets each frame from the held prop's bounds. If the object is too wide to grip from the sides, support from below with palms up.

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.

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).

All tags the NPC should scan for and cache. This is just the broad-phase filter -- disposition decides who counts as hostile. Defaults to other agents.

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).

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, plays sound files, and renders subtitle text above their head.

The subtitle text currently being shown, 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 and show its subtitle (if one exists) above the NPC. 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 shown as a subtitle.

Attempts to show a tagged message using the fallback sound.

Stop any current speech and sound.

Draw a simple speech bubble above the NPC.

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.

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 ragdoll at the NPC's current position, copying the renderer and clothing, and optionally applies a launch velocity from the attacker.

Resolves the attacker's current velocity from whatever movement source it has.

Calculates the launch velocity for a ragdoll based on the damage source. For explosions, uses the direction from the blast origin to this NPC. Otherwise, falls back to the attacker's physical velocity.

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.

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.

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.

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.

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.

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. If the prop is small enough, pick it up, carry it around, then drop it.

Wander to a random nearby point, avoiding player directions.

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.

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

Tells the AnimationLayer to drop the held prop.

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.

Tells the AnimationLayer to pick up and hold a prop.

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

Implemented by items that occupy a complete row in a .

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

If true, the notice won't auto-dismiss. Call to remove it.

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

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.

Local scripted entities followed by cloud entity packages.

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.

Shared spawnlist support for spawn menu pages.

Refresh after external changes (create, etc.).

How big tiles are in spawn menu grids.

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.

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.

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.

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. Should respect .

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.

Pressing a number key directly switches to that slot's weapon. If the slot is empty or already active, holsters the current weapon.

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.

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

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

Title shown at the top of the popup.

Optional subtitle/prompt below the title.

Placeholder text for the text entry.

Label for the confirm button.

Pre-filled value in the text entry.

When false, hides the text entry — acts as a simple confirm/deny dialog.

Called with the trimmed string when the user confirms.

The currently selected value of any sub-menus

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.

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.

When enabled, players can only physgun/toolgun objects they own. Host is always exempt. Off by default.

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.

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, prop protection — 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.

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.

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.

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.

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 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.

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

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.

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.

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.

Random pitch punch per shot (min, max degrees).

Random yaw punch per shot (min, max degrees).

First-person camera shake strength per shot.

First-person camera shake frequency per shot.

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

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

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

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.

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).

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

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.

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

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

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.

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

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.

A projectile. It explodes when it hits something.

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

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.

Use fast anims?

How much inertia should this weapon have?

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.

Called when starting to reload a weapon.

Called when incrementally reloading a weapon.

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.

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.

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 boolean convar and broadcasts the change to all players via chat. Only callable by the host.

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

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

The local user's preferences in Deathmatch

Enables automatic switching to better weapons on item pickup

Enables fast switching between inventory weapons

Intensity of your camera's screenshake

Intensity of your camera's screenshake

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.

Server-controlled settings replicated to all clients.

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

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.

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.

Holds player information like health

Kill yourself

Switch to another map

Undo the last action for the calling player

Find a player for this connection

Get player from a connection id

Access the undo system for this player

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

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

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

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

Calculates the launch velocity for a ragdoll based on the damage source. For explosions, uses the direction from the blast origin to this NPC. Otherwise, falls back to the attacker's physical velocity.

Broadcasts death to other players

Called on the host when a player dies

Holds persistent player information like deaths, kills

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.

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.

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

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 when a player kills another player or NPC.

Events fired only to the Player's own GameObject hierarchy.

Called every tick before movement input is applied. Set to false to prevent the player from moving with WASD this tick (e.g. while spinning a physgun-held object).

Events broadcasted to the entire scene for any player action.

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 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.

Apply fall damage to the player

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

Fall damage sound

Describes a player gib.

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 .

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 .

Manages loadout persistence, presets, and restoration for a player. 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 and the slot it occupies.

Clears the current inventory, waits a frame, then gives the loadout from JSON and equips the best weapon.

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

Record stats for the local player

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

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 name of the undo, should fit the format "Undo something". Like "Undo Spawn Prop".

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

Remove a GameObject from this entry so it will no longer be destroyed on undo.

Run this undo

Tracks how many instances are currently loading, across every spawn path (holding the spawner tool, spawn-menu clicks, dupes). Each spawner registers its own task in its constructor - see .

True while any spawner is still loading its payload.

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.

Payload for spawning a scripted entity prefab.

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.

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).

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.

Serialize mount metadata to pass through the Spawn RPC.

Payload for spawning a prop model from a cloud ident.

A weapon that 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 weapon handles aiming, previewing, and placement.

Synced payload descriptor. When this changes on any client, reconstructs the locally.

The local spawner, built from .

Override the inventory icon with the payload's cloud thumbnail.

Whether the current aim position is a valid placement target.

True while the player is holding Use to rotate the preview.

Accumulated rotation offset applied to the spawn preview.

Set what this spawner should spawn. Serializes the payload and syncs to all clients via .

Clear the current payload, returning to an idle state.

Directly restores a previously serialized payload string

Called on every client when changes. Reconstructs the locally so each client can render the preview.

Serialize a spawner for networking to type:data

Reconstruct an from type:data

Remove this weapon from the player's inventory entirely. Holsters first, then destroys the game object.

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 built-ins use 100 (Ignite/Extinguish), 200 (Delete) and 300 (Break); the default of 0 lands above them.

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.

Build the collected options into a menu.

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 crosshair, pressable tooltips and the cloud-loading ring around it.

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.

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.

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.

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.

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 .

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.

A typed sort mode for finding packages.

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.

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.

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.

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 with an underbarrel grenade launcher on secondary fire. Grenades feed from the secondary magazine (Clip2), topped back up from its reserve when reloading.

The grenade the launcher fires.

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.

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.

How quickly A/D yaws a held object while rotate mode is active.

When true, the physgun aims where the seated player's camera looks.

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

Override to match a different model's screen material.

Override to use a different screen material

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.

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.

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.

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.

Lets tools define what constraints should be removed when removing constraints from a game object.

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.

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.

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.

Is the hoverball on?

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.

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.

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.

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.

Which direction to stack in.

Whether to align the stack axis to the world or the target object.

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.

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.

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.

Called every frame when the weld tool hovers a valid object. 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 .

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.

The active snap grid, updated every frame in . Null when snap grid is disabled or the tool is inactive.

While hovering an object, hold E to lock the camera aim onto the nearest snap corner.

Override to control which objects show the snap grid. Returns false for world and 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.

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. These are passed through to when the post-event fires.

Returns the display name for the first registered action matching , or null.

Fire before executing an action. Returns true if the action should proceed, false if cancelled.

Fire after a successful action. Passes a snapshot of tracked objects, then clears the list.

Check registered actions and invoke any whose input condition is met this frame. Wraps each callback with pre/post events.

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.