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.

The resource path of the loaded scene, used to reload the baseline.

Whether a baseline has been captured.

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.

Provides animation parameters and helpers for behaviors. Also handles look-at (eyes/head) and body turning via animator parameters.

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.

Current world-space target the Npc is looking at (if any). Resolved each frame from either or a fixed position.

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

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.

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

Stop looking

Check if we're facing the target sufficiently. Returns true if the target is within the head's comfortable range, since the head/eyes will handle the rest.

Update look direction - handles head/eye tracking and rotates the body only when the target is outside the comfortable head-turn range.

Set both eye and head aim using a single local-space direction.

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

Called when the layer is created

Called each frame to update the layer

Reset the layer state

Optional debug string for the overlay. Return null to skip.

Handles Npc navigation

The desired movement speed for the agent. Schedules can raise this to make the NPC run.

Command this layer to move to a target

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

Handles awareness and environmental scanning

Scan for objects of interest

Check if we have line of sight to target

Get the nearest visible

Manages NPC speech state, plays sound files, and renders subtitle text above their head.

The subtitle text currently being shown, if any.

Whether the NPC is currently speaking.

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.

Play a sound event with an explicit subtitle override.

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

Stop any current speech and sound.

Whether the sound has finished and the subtitle duration has elapsed.

Draw a simple speech bubble above the NPC.

All layers in this npc

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

Creates, initializes, and adds a new layer of the specified type to the collection of layers. Generally called in the constructor of the NPC.

The current running schedule for this NPC.

Get a schedule -- if it doesn't exist, one will be created

Updates a behavior, returns if there is an active schedule - this will stop lower priority behaviors from running

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

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

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

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 in a natural forward arc and occasionally mutter.

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.

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

Find the nearest prop within range to inspect.

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

Should this be a nice helper?

Extends a SoundFile to add subtitle text that will be shown when the sound is played. This is used for Npc speech.

The text to show in the subtitle for this sound event. If empty, no subtitle will be shown.

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.

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

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

Task that waits for a specified duration

A list of muted users.

Toggles mute for a user

Is this user muted?

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

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.

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

Rebuild if the owner connection changes

update every second

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.

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.

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

Top-level spawn menu tab for user-created spawnlists.

Query the cloud for the current user's published spawnlists and install them so they appear in the sidebar.

Call this to refresh the sidebar after creating or deleting a spawnlist.

Creates a bunch of other common effects

Shake the screen in a roll motion

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.

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.

Called with the trimmed string when the user confirms.

The currently selected value of any sub-menus

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?

Specify a hint on a Doo explaining that we're going to be passing in an expected argument when calling it.

Wait for a number of seconds

Call a global method or a method on a component.

Variable name to set to the returned value. Leave empty to ignore the return value.

Set a variable to a value.

Reset this block to some sensible defaults. This is called when the block is first added, so this is a good opportunity to set up default values for properties.

Find and delete this block from the Doo tree.

Remove a block from a list, searching recursively.

Insert a block before the target block.

Insert a block after the target block.

Insert relative to target (offset 0 = before, offset 1 = after).

Add a block as a child of the target block's body.

Returns an analog value between 0 and 1 representing how much the input is pressed

Returns true if button is currently held down

Returns true if button was released

Returns true if button was pressed

Used to group this entity under a named category in the spawn menu (e.g. "Chair", "Weapon", "Npc", "World"). Leave blank to place it under "Other".

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

Opens cleanup pages in the utility tab right panel.

Execute this utility function directly. Called when no types are registered for this function.

Return false to hide this function from the menu.

Links a to the it belongs to.

Base class for pages opened in the utility tab right panel. Decorate subclasses with [Icon], [Title], [Order], and [UtilityOf(typeof(YourFunction))].

Return false to hide this page from the option list.

Returns 0 for no aim spread, 1 for full aim cone, based on time since last shot.

Returns the aim cone amount using the configured recovery time

Shoot a bullet out of the front of the gun

The prefab to spawn in the world when this item is dropped from the inventory.

Used for overriding the display icon

Wether this weapon should be avoided when determining an item to swap to

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

The value of this weapon, used for auto-switch.

Gets a reference to the weapon model for this weapon - if there's a viewmodel, pick the viewmodel, if not, world model.

The owner of this carriable

Where shoot effects come from. Either the point on the world model or the viewmodel, whichever is currently being used.

The inventory slot this item is assigned to, or -1 if unassigned. Set at runtime when picked up.

Can we switch to this?

Called when added to the player's inventory

Called every frame, when active

Called every frame, on the owning player's client.

Called every update, scoped to the owning player

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

Run a trace related attack with some set information. This is targeted to the host who then does things.

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

Info about a trace attack. It's a struct so we can add to it without updating params everywhere.

Constructs a from a trace and input damage.

Does this weapon consume ammo at all?

Does this weapon use clips?

When reloading, we'll take ammo from the reserve as much as we can to fill to this amount.

The default amount of bullets in a weapon's magazine on pickup.

The maximum reserve ammo this weapon can hold.

The current reserve ammo on this weapon.

How much reserve ammo this weapon starts with on pickup.

How long does it take to reload?

Can we switch to this gun?

Takes ammo from the clip, or from reserve if not using clips.

Do we have ammo?

Adds reserve ammo to this weapon, clamped to max.

Should we consume 1 bullet per reload instead of filling the clip?

Can we cancel reloads?

How long after deploying a weapon can you not shoot a gun?

How long until we can shoot again

Adds a delay, making it so we can't shoot for the specified time

The dry fire sound if we have no ammo

Play a dry fire sound. You should only call this on weapons that can't auto reload - if they can, use instead.

Player has fired an empty gun - play dry fire sound and start reloading. You should only call this on weapons that can reload - if they can't, use instead.

Override to perform the weapon's primary attack. Default no-op.

Override to perform the weapon's secondary attack. Default no-op.

Determines if the primary attack should trigger

Determines if the secondary attack should trigger

Override the primary fire rate

Override the secondary fire rate

Throwable type

Is this a throwable?

The throwable type

Turns on incremental reloading parameters.

Animation speed in general.

Animation speed for incremental reload sections.

How much inertia should this weapon have?

Called when starting to reload a weapon.

Called when incrementally reloading a weapon.

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

Find the most appropriate place to respawn

Called on the host when a played is killed

Spawn from a string identifier (e.g. "prop:path", "entity:path", "dupe.local:id", "dupe.workshop:id").

Resolve a dupe ident to a , this sucks a bit but okay, the DuplicatorSpawner should handle this

Change a property, remotely

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

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

The weapon prefab this ammo is for.

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.

A pickup that gives the player some health.

How much health to give to the player

A pickup that gives an inventory item, like a weapon

A list of prefabs (that have to be inventory items) that are given to the player

The toggle state has changed

The button's behavior mode.

Normal toggle button - click to turn on, click again to turn off.

Button is only on while being held down.

Button briefly turns on then immediately off when pressed.

Animation curve to use, X is the time between 0-1 and Y is how much the button is pressed from 0-1.

How long in seconds should it take to animate this button.

Sound to play when the button is pressed.

Sound to play when the button is released.

Called when the button's state changes.

True if the button is currently on

True if the button is currently animating

Turns the button on. Does nothing if already on or animating.

Turns the button off. Does nothing if already off or animating.

Toggles the button between on and off states.

Animation curve to use, X is the time between 0-1 and Y is how much the door is open to its target angle from 0-1.

Sound to play when a door is opened.

Sound to play when a door is interacted with while locked.

Sound to play when a door is fully opened.

Sound to play when a door is closed.

Sound to play when a door has finished closing.

Optional pivot point, origin will be used if not specified.

How far should the door rotate.

How long in seconds should it take to open this door.

Open away from the person who uses this door.

The door's state

Is this door locked?

Called when the door's state changes. When it opens, closed, is closing, etc..

Opens the door. Does nothing if already open or opening.

Closes the door. Does nothing if already closed or closing.

Toggles the door between open and closed states.

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

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

Find a player for this connection

Get player from a connecction id

Kill yourself

Switch to another map

Access the undo system for this player

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

Try to inherit transforms from the player onto its new ragdoll

Creates a ragdoll but it isn't enabled

Broadcasts death to other players

Called on the host when a player dies

Holds persistent player information like deaths, kills

Unique Id per each player and bot, equal to owning Player connection Id if it's a real player.

Is this player data me?

Data for all players

Get player data for a player

Get player data for a player's id

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

Called only on the Player's GameObject for their actions or events

Broadcasted to the entire scene on the local player's actions or events

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.

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

Returns the first empty slot index, or -1 if the inventory is full.

Drops the given weapon from the inventory.

Moves the item in to . If both slots are occupied the items are swapped; if is empty the item is simply relocated.

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

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

Record stats for the local player

Get the undo stack for a specific SteamId

Per-player undo stack

Create a new undo entry

Run the undo

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

Run this undo

Payload for spawning a duplicator contraption.

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.

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.

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

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.

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.

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.

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

Creates a bunch of callbacks, allowing finer control over applying camera effects

A typed sort mode for finding packages.

Returns the API supported string equivalent of this sort mode.

Only play the collision sound from this object's surface - not both the impacting surface and this surface.

We want to control the camera fov

A throwable grenade weapon Cooks while held — explodes in hand if held too long

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.

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.

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.

Add to the sniper viewmodel prefab. Looks up the parent SniperWeapon and pushes the viewmodel down out of view when scoped.

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

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

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.

Adds a GameObject. Won't find connections.

Add a GameObject with all connected GameObjects

A pair of ball sockets, we try to align the balls towards eachother.

While the client input is active we'll apply thrust

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 the client input is active we'll apply thrust

Current thrust output, 0-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.

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.

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

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.

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.

Label for the secondary action (attack2), or null if none.

Label for the reload action, or null if none.