package.thieves.terrortown

THis fucking sucks??????? https://github.com/Facepunch/sbox-issues/issues/4827

Quick and dirty way to find the player we're controlling right now

Linearly blends two colors.

"background-color:" styling with alpha support using rgba().

"background-color:" scss styling, returns a hex color after desaturating and darkening

"color:" scss styling, returns a hex color after desaturating and darkening

"background-tint:" scss styling, returns a hex color after darkening

"background-color:" scss styling, returns a hex color

"color:" scss styling, returns a hex color

Replace any base surface with our new equivelents.

The ModelRenderer that our attachment is from.

A utility component that lets you have tags update based on conditions, similarly to how we have Panel.BindClass

A cache of binds.

Do we have a bind already?

Bind a tag to a specific condition. Must not exist.

Client-side tracker for bodies the local player has covertly inspected. Used by the scoreboard to show "Dead" for privately inspected bodies.

A list of game utilities that'll help us achieve common goals with less code... I guess?

Resolve the owning player for a damage-related component without searching arbitrary descendants from a broad scene root.

Host-only!!! Snapshot the current list of connected players, make sure that they're correctly owned, then return it. Should help avoid potential churn during heavy things like respawning everyone after a round ends or whatever.

Host-only snapshot of round-managed player pawns. Includes connected human players plus ownerless replicated bots.

Host-only snapshot used during host migration recovery. Unlike the normal strict connected-player snapshot, this tolerates transient pawn-binding churn so promoted hosts can still normalize surviving players.

All players, both assigned to a team and spectating.

Get all spawn point transforms for the given team.

Pick a random spawn point for the given team.

Returns the invoking client to the main menu

Change level

Try to request a level change. Returns false when request is rejected.

Dedicated servers should return to a clean map baseline after everyone leaves.

Delay before reloading an empty dedicated server, allowing disconnect bookkeeping to settle.

Dedicated-server lifecycle only. P2P/listen hosts use GameMode's host migration recovery instead.

Set for the kicked/banned player before scene change so the menu can show the reason when they arrive.

The ConnectedClient prefab we'll spawn whenever a player joins.

Which player prefab should we spawn?

Is this game multiplayer? If not, we won't create a lobby.

Is this game an editor mode lobby?

Is this game secret?

Server name for dedicated hosts. "+hostname" launch arg and used as the native lobby name. Empty falls back to "Dedicated Server".

Network membership transition diagnostics.

Map travel and snapshot diagnostics.

Test-only: when true, players matching GlobalGameBanList are allowed to join and the runtime enforcer also skips dropping them. Use to verify the client-side warning + auto-migrate flow. Default off (production enforces normally).

Detailed host-side player join state snapshots.

Auto dump lobby state on join/leave for debugging.

Delay (seconds) before auto dump to allow host state to settle.

Called on the host to decide whether to accept a Sandbox.Connection.

Called when a network connection becomes active

Ban a player by Steam ID with optional duration. Duration in hours; null = forever.

Bootstrap-file admin/role facade. Live authority lives in MatchSessionState; this class only seeds it.

Highest publicly-visible role. Null for User, Founder (host star covers it), and devs.

Max immunity across all effective groups. Devs are Founder-tier (100).

Caller can target a player whose immunity is <= their own. Devs auto-pass.

Host-authored settings captured in the main menu before a lobby starts.

Persisted local defaults for the create-lobby page.

Locally saved defaults for the configurable lobby-rules tree. Native lobby launch choices remain in .

Compatibility wrapper for lobby-start settings advertised over compact server metadata.

Host-only bootstrap that applies host-authored start settings to in-scene systems and syncs normalized values.

Default document builders for match-session state. These helpers are intentionally small and opinionated so runtime wiring can create a valid session root without re-encoding group ids, permissions, and policy in multiple places.

Canonical built-in group ids and permission keys for match-session authority. Keeping these centralized avoids string drift as runtime systems move onto the session root.

Our cross-round match state API for host migration and session state in general

Custom-item idents this player has purchased from the pointshop.

Admin-curated category labels for the manifest. "Default" is implicit and always present.

Type of Pointshop Item

One entry in the host-managed pointshop manifest. Captured by the host at add time so clients can render and resolve without re-deriving anything from the package metadata.

Sbox.game package ident, e.g. "raf.highrollerwatchrosegold".

Asset kind. Defaults to Clothing so manifests saved before models existed keep loading.

Resolved resource path (clothing.vmdl_c-equivalent for Clothing, model .vmdl for Model). Captured at add time.

Display title; falls back to package title.

Path of the clothing icon (or package thumbnail) for UI rendering.

The clothing's native category enum value as a string (used for slot resolution and Auto-category). For Model items this is the sentinel "PlayerModel".

Display category for the shop/loadout. "Default" if no specific category was chosen.

How much the item costs in pointshop credits.

Tiny native server-browser metadata so we show the right map on the native menu. DO NOT USE THIS AS LOAD AUTHORITY!!!

Host launch and map identity state that should survive regular map-travel bookkeeping.

Dedicated-server operator settings stored in FileSystem.Data/server_settings.json. This is for rich game configuration; dedicated Steam metadata should stay compact.

Native scalar host-rule ConVars. Scene components mirror these values at runtime. Structured host config, such as map rotations, should stay out of this surface.

Describes where a host setting is suitable to be authored, changed, or shown. This is presentation and policy metadata; each surface still decides how to render or consume it.

The setting is not intentionally exposed anywhere.

The setting can be offered to a peer-to-peer lobby host on the create-lobby page.

The setting can be shown to dedicated server operators or generated operator-facing docs.

The setting can be changed or inspected through a console variable or console command.

The setting is appropriate to show to clients as part of the server's advertised rule set.

The setting is suitable for every public host-facing surface.

Describes when a changed value is expected to take effect. Runtime systems still own the actual enforcement and may apply stricter behavior.

The value should be chosen before the server or lobby starts and should not be changed during a running match.

Changes should be captured now but applied on the next map load.

Changes should be captured now but applied at the next round boundary.

Changes may be applied immediately while a match is running.

Gives UI and tooling a preferred control shape for editing a setting. This is a hint, not a requirement; each surface can choose a simpler or safer control.

Let the consuming surface choose a control based on the setting value type and metadata.

Use a binary on/off control for boolean settings.

Use a bounded numeric slider, normally backed by Min, Max, and Step.

Use a numeric text entry or stepper when direct numeric input is more appropriate than a slider.

Use a free text entry control.

Use a discrete option selector. Option metadata is intentionally not modeled yet.

Show the value without allowing edits on that surface.

Marks a runtime-owned property as a public host setting. The registry generator turns these annotations into presentation metadata, avoiding runtime reflection. Adding this attribute does not automatically create UI; it makes the setting discoverable to host-facing surfaces.

Stable machine-readable ID used by snapshots, generated registry definitions, and cross-surface persistence. Prefer a namespaced ID from HostSettingIds rather than an inline string.

Broad top-level grouping for presentation, such as Rules, Map Vote, or Player. Groups are intended to stay coarse so different surfaces can lay them out in their own way.

Smaller grouping within Group for display ordering and sectioning. Examples include Time, Roles, Karma, Communication, Map Vote, and Movement.

Human-facing display name for menus, server info, and generated help. Keep this short enough to fit compact UI rows.

Human-facing explanation of what changing the setting does. This should describe player-visible behavior rather than implementation details.

Host-facing places where this setting is allowed to appear. A surface flag marks eligibility only; the surface must still choose to consume it.

Expected timing for when a new value becomes active. This is user guidance and display metadata; runtime code remains authoritative.

Preferred editing control for UI and tooling. Use Auto when the value type is enough for the consumer to decide.

Native ConVar name that owns persistence and runtime authority for this scalar setting. Leave empty for structured settings that cannot sensibly be represented as ConVars.

String representation of the normal default value. Stored as text so bool, int, float, and future value types can share the same metadata field.

Minimum recommended authoring value for numeric settings. Leave as NaN when the setting is not numeric or does not have a public-facing lower bound.

Maximum recommended authoring value for numeric settings. Leave as NaN when the setting is not numeric or does not have a public-facing upper bound.

Suggested increment for numeric controls. Runtime validation should still clamp or normalize values that arrive through console or JSON.

Display format for numeric values, using standard .NET numeric format strings where applicable. This is for presentation only and should not be used for parsing.

Optional legacy/display key for generated docs or migration notes. Native ConVars are the authority for scalar host-rule persistence. Keep this stable if external docs or generated tables already reference it.

Sort key within a category. Use gaps between values so related settings can be inserted later without renumbering everything.

Whether this setting should be included when host settings are saved or snapshotted by default. Set false for derived, diagnostic, or display-only values.

Marks the setting as advanced so simple surfaces can hide it while operator-focused tools can still expose it.

Shared package discovery and authored map metadata projection for browser and vote UI. This only fetches package metadata; mounting/downloading stays on the map travel path.

Normalizes a package ident or sbox.game package URL and validates that it is a loadable map.

Authored map metadata. Package discovery can add maps, but explicit trust, size, tag, and blocklist data should live here instead of UI or vote code.

Owns the normal end-of-map vote and the single host-scheduled direct map change. Synced state keeps a schedule visible and recoverable if P2P host authority moves.

Static state carrier for the main-menu popup shown after auto-disconnect from a server that wouldn't remove a globally-banned player. Static fields survive the scene change that returning to the main menu triggers.

Developer-only emergency moderation commands. These intentionally bypass host/admin immunity because they are project developer controls, not normal lobby moderation.

Host-only runtime enforcer for the global ban list. Drops any connection matching GlobalGameBanList on join and on a slow periodic sweep, in case the AcceptConnection gate missed someone (mid-session ban list update, family-share edge cases, etc). This is deliberately not persisted into HostBanListStore; GlobalGameBanList is the source of truth and removing an entry should stop future enforcement. Independent of the client-side migrator (GlobalBanWarningClient).

Client-side check that detects globally-banned players in the lobby and migrates the local player out if the server isn't removing them. Decides entirely from its own copy of GlobalGameBanList against the engine-provided Connection.All. Never trusts a server-relayed signal.

Developer-owned game-wide bans. This is intentionally separate from host/admin session bans and should only be changed by us.

Host-owned persistent ban list. Session sanctions still drive live moderation state; this file is the durable source that survives server restarts.

On a dedicated server, reports require at least one Mod+ ranked human player to be connected. The dedicated host slot (SteamId == 0) and bots are excluded by the SteamId > 0 filter. On listen hosts, reports are always enabled.

One row in the round-log viewer, sent host → admin.

Client-side FIFO cache of round-log query responses, capped at .

Host-side bridge: admins ask, host filters round events, response RPC'd back.

The default voice filter which prevents alive players from hearing dead players.

Consolidated cleanup for round transitions. This cleans transient round objects, corpses, and the active map lifecycle without depending on a specific map source.

Little helper for removing equipment between rounds that isn't "in the inventory" (Body armor, radar etc)

Host-authored transition gate for round flow. This tracks transition phases in one place so subsystems can opt into consistent policies.

Increments once per round-start transition. Tracked now for observability; not yet used as a hard gate.

Begins host-side pre-round processing and bumps round epoch.

Host-only phase transition entrypoint.

Host-side authority for weapons every round participant should have.

Consolidated round lifecycle rules: waiting, prepare time, counting, time limits, and round delay.

Host-first transition coordinator for round transitions and map-switch recovery.

Temporary bridge that replays death events into legacy IKillListener callbacks.

Projection lifecycle hooks for consuming host-auth round events.

Called when a new round ledger starts.

Called each time the host appends an event.

Called when the current round ledger is sealed.

Normalized report model consumed by body UI and logs.

Host-authoritative attribution result for one resolved damage action.

Read-model notification used by kill feed projection/UI.

Shared actor reference used by round-event payloads.

Shared inflictor reference used by round-event payloads.

Shared damage context used by round-event payloads.

Shared attribution details used by round-event payloads.

Snapshot row used by scoreboard projection/UI.

Replicated read model for latest body inspection reports.

Collects death notifications for round-end kill feed rendering.

Replicated scoreboard read model composed from host-auth state + score events.

Broadcast from host when a player disconnects so every peer immediately hides their row, even before the synced SnapshotJson catches up.

Core metadata for one round event.

Deterministic event-id helper.

Pure helpers for filtering round events by player id.

Events touching either player id. = wildcard.

One typed event entry in the host-auth round ledger.

Helper methods for resolving actor/inflictor components from round event payload references.

Host-auth append-only event ledger for the active round.

The canonical event families used by the round event store.

Who is allowed to see an event payload.

Confidence level for attribution decisions.

Attribution path selected by host authority.

Marker interface for round-event payloads.

Registry/broadcast helper for event projections.

Tracks recent damage contributors for assist resolution.

Host-only corpse inspection service with reveal policy + event emission.

Resolves canonical attacker/inflictor attribution for round events.

Tracks short-lived causal ownership links used to attribute indirect damage and deaths. Host-only and reset each round.

Host-auth death pipeline that emits exactly one death-class round event per lethal hit.

Typed host-side notification router for round events.

Centralized visibility/reveal rules for body + scoreboard role state.

Host-auth scoring pipeline that derives score deltas from death events.

Custom-item manifest support for . Admins can paste an sbox.game URL and the host will fetch + mount the package, resolve its primary clothing resource, and publish the entry on the synced session document. Clients react and mount the same packages locally so the resources resolve when they're displayed in the loadout.

Host-authored pointshop economy. Awards per-round credits to participating players and stores the credits-per-round setting alongside the player banks on . Banks and settings are persisted to disk so they survive server restarts.

The implicit category every item falls back to. Cannot be created or removed by admins - it always exists alongside whatever they curate.

Parse "https://sbox.game/raf/highrollerwatchrosegold" (or already-bare "raf.highrollerwatchrosegold") into a normalized ident "raf.highrollerwatchrosegold".

Returns an item's display category. Falls back to when nothing is set - the shop and loadout group items by this string.

Best-effort label for an item whose admin asked for "Auto" categorization. Knows about s&box clothing categories today; returns null when nothing applies (caller falls back to ). Designed so future non-clothing item types can extend this without breaking the data model.

Returns the curated category list with first. The session document is the authority; this helper just guarantees Default is always present and at the head of the list.

True when this s&box clothing category renders into a head/face/neck slot - used by the loadout to decide whether a sandbox item is even displayable (body items aren't, since the team outfit owns the body slot).

True when a path either belongs to a built-in package (not in our manifest at all) OR is in the active manifest. Removed manifest items return false so the rest of the system never tries to resolve them.

Heuristic: paths whose first segment contains a '.' look like custom packages ("raf.highrollerwatchrosegold/foo.clothing"). Built-in paths use plain folder segments ("models/citizen_clothes/...").

Sentinel native-category value used for player-model manifest entries.

Display category models are assigned to when admin doesn't pick one. Mirrors DefaultCategory but distinct so the UI radio can filter cleanly.

Player-initiated purchase. Anyone with credits can call this; the host validates the item is in the manifest, the player has enough credits, and they don't already own it.

Pick the category an item should land in. When is true the caller-supplied category is ignored and we derive one from the native category, falling back to when that resolution fails (e.g., future non-clothing item types). Otherwise the caller's choice wins, with empty/blank coerced to Default. Model items get a separate default () so the Models tab in the UI has a sensible group header out of the box.

Host-side: validate, deduct credits, grant ownership, and persist. Returns true if a purchase actually went through.

Many sbox.game packages don't ship a Clothing.Icon - fall back through the package's CDN thumbnails so the card always has something to render. Sandbox auto-derives Icon.Path to "<resource>.clothing.png" when no explicit icon is set, which usually doesn't exist on disk, so we verify the file before trusting it.

True when the path is either a remote URL (CDN thumb) or an actual file in the mounted game filesystem. Used to skip the auto-derived "<resource>.clothing.png" paths that many custom Clothing resources advertise but never ship.

Picks the best icon path to render for a manifest item: the local clothing's Icon.Path when it points at a real file, otherwise whatever the host stored on the manifest entry (typically a package CDN thumb URL).

Fetch + mount a package once and detect whether its primary asset is a Clothing or a citizen- rigged Model. Clothing is checked first because it's the more common case and cheaper to confirm. Returns null if the primary asset is neither, or if a model fails the citizen-rig probe - same rejection logic as .

Resolve a package as a player model. Smoke-tests that the primary asset is a real Model and that the model carries the citizen bones our animation helper drives. Anything that fails these checks is rejected - the caller drops the add entirely so the manifest can't end up with a "model" that T-poses every player who equips it.

True when the model exposes the citizen bones our animator + clothing system depend on. On false, is the first probe bone that wasn't found.

Best-effort icon path for a model package - models don't ship a Clothing.Icon, so we fall back through the package's CDN thumbnails.

Host-side: hydrate the synced manifest from disk on first boot, then ensure each entry's package is mounted.

Both host and client: walk the synced manifest and kick off fetch+mount for any ident we haven't tried yet. Async mount completes whenever it completes; the loadout filter will stop showing items whose resource path doesn't yet resolve.

Reads the authoritative credits-per-round value. On the host, the ConVar wins; clients fall back to the synced session document.

Public host-side hook for callers (e.g., disconnect handlers) that want to flush the current banks to disk.

Save settings + the full player banks snapshot from the session document to disk.

Called by ConnectedClient.PersistSessionStatsHost so the static, in-memory snapshot used for fast restore-on-reconnect mirrors live credit balances.

Defaults to Clothing so saves written before the Models feature still load with the right type.

Developer-only role locks for testing. These apply the next time round role assignment runs.

Consolidated reward logic for score and traitor credits.

Canonical policy for any role-sensitive display logic. UI and presentation code should evaluate through this API instead of reading TeamComponent.Team directly!

Designates the team for a player.

An action (for ActionGraph, or other components) to listen for team changes

The team this player is on.

Called when changes across the network.

Accessor to get the team of someone/something.

Are we friendly with this other team?

Are these two s friends with each other?

Are these two s friends with each other?

Is this a certain team?

Host-authored map vote configuration edited from the terrortown systems prefab. MapVoteSystem remains runtime-spawned and reads from this singleton when present.

Our networked list of voting options.

Our networked list of votes.

How long until we decide who won?

How long until we move server?

Which option is the winner?

An instance of the map vote overlay UI

The screen panel which draws our UI

Whether the vote UI is minimized (local client-side state)

Public property to check if minimized

Set whether the vote panel is minimized

What's our current winning option?

Returns the full list of options with their vote counts, sorted descending. Useful for external systems to decide winners or resolve draws.

Start a vote. This'll make a component on the server and

Starts the admin-forced map change flow, matching the mod menu action.

RPCs a vote, targeted to the host, so it's not exposed to any public API.

Sends a vote to the host.

A networked vote.

The player's SteamId

Which option are we voting for? (Mapped to the list)

A voting option that has real data.

Admin/host force-passes a map change. Skips the normal vote - flags the system as HasPassed/PendingMapVoteAfterRound so the existing round-end → MapVoteSystem flow takes over.

Seconds to wait after pressing Attack1 before the C4 actually spawns. Gives the toss animation time to play (e.g. 11 frames at 30fps ≈ 0.367s).

How far in front of the player's eyes the C4 spawns when thrown.

Seconds to keep the viewmodel visible after the C4 spawns, so the toss animation can finish.

Add this to objects you want to be scannable with the DNA Scanner

The player who started this fire (for karma tracking)

Applies one tick of heal if conditions are met. Host-only.

Runs a trace with all the data we have supplied it, and returns the result

Manually constrains a rigidbody to stay within rope length of an anchor point

Visual rope renderer

Cleans up the hanging anchor when the corpse is destroyed

Runs a trace with all the data we have supplied it, and returns the result

Presumably for weapons prefabs placed in the world and to track the player who placed it

Makes some tracers using particle effects.

Runs a trace with all the data we have supplied it, and returns the result

Describes one item-specific control shown in the buy menu. The action name is resolved to the local player's current binding when rendered.

Explicit weapon asset root and lookup surface for runtime systems.

TTT Drops ammo with the weapon if no other weapons you have need it.

Carried over from the source : true if it was bought from the T/D shop.

Temporary marker just to make it obvious there's a grenade

The player who threw the incendiary grenade (for karma tracking)

Prefab containing a VolumetricSmokeCloud component, cloned on explosion. If unset, falls back to PrefabOnExplode from BaseGrenade.

Console variables for smoke grenade rendering.

Downscale factor for the shared smoke render target. 1=full-res, 2=half-res (default), 4=quarter-res. Changed default to 3 for now.

Animated per-frame ray jitter. Looks smoother with TAA enabled, flickery without it. 0 = stable fixed offset (default, no TAA required). 1 = animated jitter (use with TAA).

Dither the smoke edge threshold per-pixel per-frame (IGN). Resolves cleanly with TAA. 0=hard cutoff, 1=dithered.

Skip sky occlusion for deep interior march samples (dist < 0.3). Saves ~4 Worley lookups per interior step. 0=always compute, 1=skip interior (default).

///

Ray march steps per cloud per pixel. Higher = less banding, more GPU cost.

Singleton compositor that owns the shared half-res smoke render target. All VolumetricSmokeCloud instances register here; every frame this object: 1. Clears the shared half-res RT 2. For each cloud: dispatches compute, then Graphics.Blit into the RT 3. Composites the RT back to full-res with bilateral depth-aware upscale This gives us: - Per-draw RenderAttributes per cloud → fixes multi-cloud disappear (no shared SceneModel attrs) - One RT for all clouds → additive blending between grenades works correctly - Half-res march → ~4x GPU cost reduction

Thin per-cloud object. Handles only C#-side lifecycle (visibility tracking, bounds for shadow casting). All rendering goes through SmokeCompositor.

Manages the singleton SmokeCompositor per SceneWorld.

Recompute compositor bounds every frame from outside RenderSceneObject, so the engine never frustum-culls the compositor and misses the render call.

Optional hook for prefabs spawned by .

Exposes a stable weapon resource for damage caused by objects that are not live Weapon components.

A weapon component that reacts to input actions.

When false, shooting is blocked (e.g. weapon wheel hover) but reload and other input still work.

Authoritative shoot block owned by higher-priority systems (e.g. round-end grace). Unlike , this isn't reset by weapon-wheel / slot-swap input handling, so holding Attack1 across weapon swaps won't phantom-fire when the block is lifted elsewhere.

What input action are we going to listen for?

Should we perform the action when ALL input actions match, or any?

What kind of input are we listening for?

ActionGraphs action so you can do stuff with visual scripting.

Gets the input method

Called when the input method succeeds.

When the button is up

When the button is down

Common magazine surface for weapons.

Fetches the desired model renderer that we'll focus effects on like trail effects, muzzle flashes, etc.

Do shoot effects

Runs a trace with all the data we have supplied it, and returns the result

Can we shoot this gun right now?

Runs a trace with all the data we have supplied it, and returns the result

Can we push right now?

Do push effects

This seems like it would be used for things like throwing a knife at a player, or sticking a poltergeist explosive to them, or maybe a flare gun.. etc

The current weapon's ammo container.

Remove current weapon on use.

Prefab Offset.

how long since we shot?

Can we shoot this gun right now?

A weapon component.

Optional editor-authored damage descriptor overrides for this equippable item.

Subscribe to changes in the weapon's deployed state.

A reference to the weapon's .

A reference to the weapon's model renderer.

Scale multiplier for the world model when spawned, dropped, thrown

Scale multiplier for the world model when held by a player

True if this weapon was bought from the T/D shop, persisted across drop/pickup.

A tag binder for this weapon.

Shorthand to bind a tag.

The default holdtype for this weapon.

What sound should we play when taking this gun out?

What sound should we play when taking this gun out?

How slower do we walk with this weapon out?

Is this weapon currently deployed by the player?

Updates the render mode, if we're locally controlling a player, we want to hide the world model.

A reference to the weapon's if it has one.

Get the weapon's owner - namely the player controller

How long it's been since we used this attack.

How long it's been since we used this attack.

Deploy this weapon.

Holster this weapon.

Allow weapons to override holdtypes at any notice.

Called when trying to shoot the weapon with the "Attack1" input action.

Can we even use this attack?

Called when trying to shoot the weapon with the "Attack2" input action.

Can we even use this attack?

Creates a viewmodel for the player to use.

A weapon component. This can be anything that controls a weapon. Aiming, recoil, sway, shooting..

The weapon. It's going to be a component on the same .

Where we hold all of the player's stats, both persistent ones and per-lobby/map ones.

This class represents a connected client and their core data. Replaces the old PawnSystem. The PREFAB this class is on owns round-mode routing (Playing, Spectating, joining late, etc), and everything else (SpectateSystem, PlayerComponent.State, UI) will react accordingly.

Pipe-delimited list of owned pointshop item idents. Use for a parsed/lower-cased view.

Unique ID given to players, equal to the owning Player connection ID if it's a real player (and not a bot).

Host-authored AFK state. AFK clients are excluded from round admission until cleared.

Host-authored count of upcoming rounds to skip (used for slay-style exclusions).

Whether this client is currently excluded from the round cycle.

This is "What we are right now", the GameObject. Networked reference that lets every client resolve the pawn when/if they need to.

Host-authored: epoch for pawn binding updates. Used to detect missed bindings.

Host-authored: component Id of the pawn (PlayerComponent).

Host-authored: explicit pawn bind state. Avoids empty IDs during transitions.

Non-networked, clientside-only: "This local client is currently controlling/viewimg through this pawn". The rule: This is the ONLY control/view truth in the game. This is used around the codebase for control routing and spectating is entirely about which Viewer we're on.

Is this client me?

Data for all players. Only the host should ever be making use of this!

The local client's ClientData (null if not spawned yet).

Our persistent player pawn that we always own, whether we're dead or alive.

The player we're viewing from the perspective of; ourselves or someone we're spectating.

Derived lifecycle state from the owned pawn. This replaces ParticipationState.

Clientside-only: currently spectated player (if any).

Clientside-only: current spectate camera mode.

Should we be controlling our pawn in the world?

Are we currently in a spectating state?

Are we spectating without a target?

Local helper: push AFK preference to host and suppress one-time baseline announce races.

Host only: Assign the "owned pawn" for this client- whatever they are controlling and playing as right now. This is NOT the same as Viewer (spectating changes Viewer).

Clientside: switch the local view/control target to a pawn. Stops running if we're not the local client or if we are already controlling/viewing this pawn, which lets us use this as a guard rail around the codebase

Clientside: Depossesses a pawn. If it's not currently Viewer, it's a no-op.

Host-side decision outcome for round admission.

Host-side authority for round participation decisions (AFK and skip-round exclusions).

Player lifecycle during a round. This replaces RoundParticipation and is the single authoritative signal for play vs spectate.

Centralized, host-only authority for player life/lifecycle transitions. Everything is host authoritative here. KEEP CORE STATE TRANSITIONS ROUTED THROUGH HERE so ordering and logging stay consistent.

Guard for clients attempting to call this method.

Host-only: set the player's lifecycle state. This is the single source of truth for play vs spectate. Also ensures LifeState is consistent with the lifecycle.

Put a player into observer posture and NotInRound lifecycle.

Exit observer posture and mark as PreRound.

Host-only: diagnose and repair expected round participants without making this the normal spawn owner.

Host-only diagnostic dump for all players in the lobby.

Legacy resync console variables (used only when GameMode.ResyncUseProperties is false). Kept outside PlayerComponent to avoid mixing core gameplay logic with console settings.

ConVar: t.resync.enable Master toggle for client-side resync requests. Default: true

ConVar: t.resync.interval Minimum seconds between resync requests from the same client. Default: 1

ConVar: t.resync.broadcast.interval Host-only: if > 0, broadcast authoritative state every N seconds (0 disables). Default: 0

Shared round-phase policy for kill/stat side effects.

Only the live round should count kill/death side effects (score, rewards, stats, haste timers).

Visual corpse presentation is separate from round scoring/stat side effects. Round-end grace still allows play, so deaths there should leave a body without counting as kills.

Pawn interface. Anything that can be used as a viewing target or possessed/controlled implements this. Importantly, calls to Possess and Depossess are done by internally calling ConnectedClient to keep the truth in only one place for the player.

Called during possession, from the pawn. ConnectedClient initiates the call, the pawn object does any specific work.

Called when leaving possession, from the pawn. ConnectedClient initiates the call, the pawn object does any specific work.

Shorthand accessor for the value coming from ConnectedClient.

Shorthand accessor for the value coming from ConnectedClient.

Who is the client that owns this pawn? Pawns

Do we have network rights over this pawn?

Are we possessing this pawn right now? (Clientside) True when this pawn is the local viewer target, not necessarily controlling This is reference equality. It's fine but we need to be aware as time goes on Viewer should always be the actual IPawn instance not a proxy wrapper or anything

Make this pawn the local viewer target.

Clear local viewer target (if it is this pawn).

Host-authored forensic snapshot attached to each corpse object.

Centralized entrypoint for damage classification + descriptor lookup.

Stable cause ids for logs, descriptors, and gameplay branching.

Canonical classification output for one damage event.

Priority-ordered rule classifier for TerrorTown damage events.

Canonical high-level damage kind used by gameplay systems and UI.

One data-driven classification rule with priority.

Describes the damage that should be done to something. This is purposefully a class so it can be derived from, allowing games to create their own special types of damage, while not having to create a whole new system.

Usually a player or Npc

The weapon/object that did the damage, or a vehicle etc

The hitbox that we hit (if any)

Stable hitbox/bone name string for networked and descriptor contexts.

Tags that define the type of damage this is

Amount of damage this should do

The location of the damage

The source/origin position of this damage, if known.

The force of the damage

The physics shape that we hit (if any)

Canonical classification computed by .

Bridge from engine-native damage events to TerrorTown damage info.

Editor-authored descriptor overrides for specific damage-producing objects.

Master switch for this source. When false, this component is ignored and fallback descriptor data is used.

Optional cause ID override for the built descriptor. This currently feeds snapshots; round-event attribution/scoring still use classified cause.

Optional scoring category override on the descriptor model. Reserved for scoring/rules consumers; not currently read by .

If true, apply instead of inheriting fallback descriptor behavior.

Body-info formatting preference used only when is true. When active, BodyInfo context appends weapon naming to the resolved phrase (example: "{bodyInfoText} with {weapon}").

If true, apply instead of inheriting fallback descriptor behavior.

Default DNA policy for this descriptor when is enabled. This flows to corpse forensics via .

Base body-inspection phrase for BodyInfo context. Grammar slot: treated as the leading clause, then UI appends " {seconds} second(s) ago". Example: "Shot in the chest" -> "Shot in the chest 12 seconds ago".

Base kill-feed verb/phrase for KillFeed context. Grammar slot: intended to sit between killer and victim (e.g. "stabbed", "burned"). This is consumed by the live kill-feed projection.

Context override text for ConsoleLog context. Intended as a short death descriptor phrase; currently no active console formatter resolves this context.

Context override text for RoundSummary context. Intended as a summary-friendly phrase/sentence fragment; currently reserved until summary rendering resolves descriptor context.

Context override text for Stats context. Intended as compact stats/log wording; currently reserved until stats renderers resolve descriptor context.

Context override text for DetectiveInfo context. Intended for forensic/detective-only readouts; currently reserved until detective views resolve descriptor context.

Headshot-only replacement for BodyInfo context. Grammar slot is identical to and still receives the " {seconds} second(s) ago" suffix.

Headshot-only replacement for KillFeed context. Grammar slot is identical to (verb/phrase between killer and victim).

Descriptor overrides for player equipment and weapons.

Descriptor overrides for non-equippable world objects (props, scripted world explosions, etc).

Descriptor overrides for authored map hazards (traps, trigger hazards, environmental killers).

Text/profile metadata for one canonical damage cause.

Base phrase for BodyInfo-like contexts (corpse/inspection wording).

Base phrase for KillFeed-like contexts (typically a kill method verb/phrase).

Where a damage description is being rendered.

Corpse/body inspection text. Current runtime grammar: value is used as a leading clause, then body UI appends elapsed-time text.

Kill feed method verb/phrase (typically between killer and victim names). Currently reserved in descriptor pipeline; live kill feed still emits fixed verbs.

Console logging representation of the death method.

Round summary representation of the death method.

Stats/telemetry representation of the death method.

Detective/forensics representation of the death method.

Registry for cause descriptors used by corpse text, kill feed, and logs.

Resolves the best descriptor source component for a damage payload or snapshot.

Canonical runtime snapshot of one resolved damage application.

One optional weighted descriptor text variant with context/predicate filtering.

A health component for any kind of GameObject.

Are we in god mode?

An action (mainly for ActionGraphs) to respond to when a GameObject's health changes.

How long has it been since life state changed?

Grace window before reporting life/health mismatch as desync.

Are we ready to respawn?

How much to reduce damage by when we have armor.

What's our health?

What's our life state?

Called when is changed across the network.

The component's life state.

A listener put on a component that listens to damage.

Called when YOU inflict damage on something

Called when YOU take damage from something

Called when YOU take damage from something

A listener put on a component that listens to damage.

Called when something dies

A listener that is called BEFORE a player dies, allowing you to handle equipment drops, etc.

Called when something is about to die, before the kill sequence begins

Hosts the canonical last-damage snapshot authoring path, keeping state storage lean.

Identity-only visibility rules for the disguiser. Keep these separate from role visibility: knowing a player's role and being allowed to identify that player are different concerns.

Host-authoritative pickup gate. Returns the amount actually granted.

The player's inventory.

What weapons do we have right now?

A that will hold all of our weapons.

Can we unequip the current weapon so we have no weapons out?

Players current Credits

Gets the player's current weapon.

Internal method that actually performs the weapon drop logic. Can be called directly from host without going through RPC.

Tries to set the player's current weapon to a specific one, which has to be in the player's inventory.

Removes the given weapon and destroys it.

Removes the given weapon (by its resource data) and destroys it.

Transfers credits from this player to a teammate (Traitor only). Runs on host via RPC.

How far down to trace when checking for a floor below the player.

Detection mode used when validating candidate positions during the unstuck process.

Simple void check. This only checks if there is a floor below the player.

Casts rays in all axis-aligned directions. If every ray hits a surface, the player is inside the sealed map hull. If any ray escapes, the player is outside.

Fires an outward ray, then a return ray back toward the player. If the return ray hits a closer surface before reaching the player, there is a hull wall between the player and that surface, meaning the player is outside it.

Checks whether the player overlaps any collider tagged with .

Check if the player is outside of the navmesh.

Use .

When jumping into walls, should we bounce off or just stop dead?

If enabled, determine what to collide with using current project's collision rules for the of the containing .

Optional collider used as the shape of the player's movement trace, uses helper physics body or bbox if unset.

Move up and leave the ground, great for jumping.

Add acceleration to the current velocity. No need to scale by time delta - it will be done inside.

Add our wish direction and speed onto our velocity

Same but for air

Apply an amount of friction to the current velocity. No need to scale by time delta - it will be done inside.

Trace the controller's current position to the specified delta

Disconnect from ground and punch our velocity. This is useful if you want the player to jump or something.

We're no longer on the ground, remove it

We have a new ground

Move from our current position to this target position, but using tracing an sliding. This is good for different control modes like ladders and stuff.

The current gravity.

How much friction does the player have?

The speed at which we fully come to a stop.

Can we control our movement in the air?

Move a character, with this velocity

Get the current friction.

Marks local player physics-helper contacts with loose props so the movement controller can reject raw solver velocity while preserving explicit pushes and authored-mover support velocity.

Constructs a ray using the camera's GameObject

The Input Action that noclipping is triggered by.

TODO

TODO

How quickly does the player move by default?

The Input Action that the alternate speed mode is triggered by.

If the player should run by default, pressing the run action will swap to default speed

The speed the player moves at while in the alternate speed mode.

The Input Action that the alternate speed mode is triggered by.

The speed the player moves at while in the alternate speed mode.

The Input Action that crouching is triggered by.

The speed the player moves at while crouching.

The Input Action that jumping is triggered by.

Can the player jump immediately on the first grounded frame?

Can the player hold down jump to repeatedly jump?

How powerful is the player's jump?

Do we want to jump next movement update?

A network message that lets other users that we've triggered a jump.

Values from popular games.

The Input Action that noclipping is triggered by.

Local-only visibility toggle. Network truth comes from PlayerComponent.LifeSnapshot.

Client-side loop: detect mismatch and request host resync.

Host-side loop: broadcast authoritative state on an interval. See GameMode.cs Resync properties

Decide if we should request a resync from the host. ... I am a little worried about this, but we have to make the determination somewhere. Todo: It may be worth checking the game's state as part of this, as opposed to LifecycleState, but we manually set the LifecycleState on transitions- it's probably more reliable than GameState info for the client rn

Host-only: owner requests a resync for their pawn. I hate the sbox documentation on these net flags

The player's health component

The player's inventory, items, etc.

The player's ammo.

Component describing which team the player is on.

How long since the player last respawned?

Host-authored life snapshot (life, health, respawn, lifecycle) sent as a single synchronized value.

Host-authored lifecycle state for play/spectate. Derived from LifeSnapshot.

Whether the death camera is currently active

Host only: Called when a player joins mid-round. Create the player they'll need for next round, but posture only. No death pipeline stuff or in-game state changes.

Host-only: Prepare the player's pawn for live play and control. Posture only!

Initialize the player pawn.

Host-only kill.

Host-only: apply death effects without re-authoring life state.

Activates the dead camera (camera follows head bone), then switches to spectate mode after 5 seconds or on click/space down.

If we're controlling this, ask the host to start spectating

Call the host and have them put us in spectator, because we died

Visual/posture reset that must run everywhere Host-only call, but executes on all receipients

Host-authored spawn transform (sequence + position/rotation) for spawn and respawn recovery.

Host-only canonical teleport entrypoint. Every normal teleport path should end here.

Host-only: apply a spawn/respawn transform before the player is network spawned.

Host-only: apply a spawn/respawn transform and replicate it through the canonical teleport path.

Owner-authored active weapon for this pawn. Individual weapons derive deployment from this reference.

This is the networked truth of who owns this pawn.

This is OwnerClient, satisfying IPawn.Owner. Same value.

A shorthand accessor to say if we're controlling this player.

Is this player the currently possessed controller? TODO change for spectating

The player's body

A reference to the player's head (the GameObject)

A reference to the animation helper. Keep this lookup-only so cloned player prefabs don't carry hotloaded base-package component refs across map changes.

The current character controller for this player.

The current player mover for this player.

Apply a push force to this player (called via RPC to the owner)

The current camera controller for this player. ???? - 55

The player's voice

The current camera for this player.

The outline effect for this player.

A reference to the View Model's camera. This will be disabled by the View Model.

Handles the player's outfit

Handles radar pings for a player

A that will hold our ViewModel.

Finds the first on

An accessor to get the camera controller's aim ray.

Called when the player jumps.

How far can we use stuff?

Unique ID of this Bot

Is this a player or a bot

Called when YOU inflict damage on something

Tracks the last identifiable living player locally, then submits one death record for corpse forensics. Looking away preserves the last known target, as in classic TTT.

The player.

Assigns the player's clothing. Anything commented out is available but not being used, unless it's in the "not working" up here.

Cached "no custom model" body model, captured the first time we apply an outfit so we can restore it when the player un-equips.

Destroy any SkinnedModelRenderer GameObjects that previously spawned as bone-merged children of the body renderer. Used when a custom model is equipped and we're skipping Clothing.Apply - otherwise the citizen-skin / clothing meshes from a prior apply linger and overlap the swapped model.

Resolve the published model ident to a loaded . Verifies it's still in the manifest as Type=Model and is mountable. Returns null on any failure so the caller falls back to the default citizen body.

Apply this player's current outfit to an arbitrary renderer (e.g., a corpse spawned by PlayerBody on death). Handles the custom-model case the same way live applies do - skips entirely and stamps the model directly - so a corpse doesn't end up with the engine's censoring underwear on top of the custom body.

All this component does is lie

Are we allowed to identify this body? (WaitingForPlayers only for testing)

Local-only client state for per-player scoreboard tags (Gmod-TTT style). Cleared at the start of each round via .

Call each frame from any client-side ticker. Detects round transitions and clears tags at the start of a new round (entry into ).

Why a spawn was requested. Used for diagnostics and policy branching.

Shared player-placement helper used by spawning and map-authored teleports.

Host-side physical spawn authority (point selection, teleport, and movement safety).

Host-side combined inventory reset + respawn pass with unique spawn reservations.

Host-side spawn point chooser with safety checks and reservation support.

Select the best available spawn transform for this player.

Centralized spawn orchestration for participation, round start spawns, and warmup auto-respawns.

Traces forward from the freecam and returns the alive player under the aim, or null. Shared by the Use-to-spectate action and the on-screen hint.

Which spectator prefab should we spawn?

Called each frame and determines the camera's position based on the mode

Formats keybind origin strings for display (e.g. "return" → "ENTER").

Open the dropdown.

Normalizes paths for use in CSS url() so the Sandbox style parser (Zio) accepts them on Windows. Windows paths must be in the form /mnt/<drive>/... for the virtual filesystem.

Converts a path to the form expected by the style parser on Windows. If the path is already game-relative (e.g. "ui/icon.png") or null/empty, returns it unchanged. If it is a Windows absolute path (e.g. "C:\..."), converts to /mnt/c/...

Single source of truth for HUD/UI as far as "who am I showing" and "what do I know (based on what team I am)" Target = whoever the camera is anchored to (spectated player or me) Local = our owned session player (our own team alignment/perms/etc) Shitload of computed values we can use throughout the UI

Local client's owned player pawn, this needs to be and should be stable through the session

Player we're currently viewing (Spectate target or our own pawn when playing). This is allowed to be null for freecam

What team the local user should perceive the target as. For example, traitors only appear as traitors to their teammates

Changes whenever requester/target identity or role-visibility phase context changes. Use in BuildHash for role-sensitive panels to avoid stale display during handoff churn.

Client-side award computation for the end-of-round Highlights panel. Pure - operates on already-synced round data (kill feed + scoreboard snapshot). Kill counters are derived from the per-round kill feed so they reflect only this round, while team membership / alive state come from the (cumulative, real-time) scoreboard snapshot.

The player the award is attached to. for round-level awards.

The player's inventory

Reset the timer to default when opening the panel

Returns just the 4 digits (no colon) for grid display

Adjust the appearance of the crosshair

The weapon we're currently holding, if there is one

Fill percent in range [0..1]. 1 = full, 0 = empty.

Optional overlay text shown centered over the bar.

Game-relative texture path, for example: /ui/dnafinal.png

Vertical texture scale. 1 = fit bar bounds.

Vertical texture position offset in percentage points from center.

Width (in percent of bar width) of the soft edge blend.

Opacity multiplier for the soft edge. 0 = hard edge, 1 = strongest falloff.

0 to 100

Checks the current button and updates the glyph.

Fetches a page from sbox.game. For "All" type, runs clothing + model queries in parallel and merges them.

Sort priority for category labels. Default first, then admin-curated categories in their listed order, then anything else (typically Auto-derived sandbox labels) at the tail.

Slot key based on the clothing's actual rendered category. Routes through PointshopSystem.NormalizeCategoryToSlot so e.g. TrousersCargo and TrousersShorts both land at "Trousers" - the loadout's radio toggle and the outfitter's overriddenGroups must agree on this, otherwise pants and shorts can both equip at once.

0 to 100

The player's weapon.

The player's weapon.

Is this selected or being hovered over?

Target object that owns the setting property.

Current setting value for , read/write via reflection.

Metadata for the setting property being rendered.

Range and UI metadata used by the slider/option row.

Supports both modern [Range(min,max)] + [Step(x)] and legacy Range step overloads.

Whether the value label should render for this entry.

Whether a text entry field should render for this entry.

Resolves an override state to a concrete bool.

Current settings group selected by the top bar.

Grouped settings metadata used for layout and rendering.

Widget metadata resolved from .

Main settings column slot containing one or more subgroups.

Serialized property wrapper used by .

Builds subgroup definitions from the current group's settings metadata.

Resolves layout preset metadata for a settings group.

Resolves column layout metadata for the current group.

Generates inline style for a column based on layout attributes.

Resolves explicitly configured column widths from the selected group preset.

Resolves compact-mode fallback column widths when no explicit width is configured.

Resolves how many main column slots should render for the selected group.

Resolves width behavior for the area that contains main columns.

Builds ordered main column slots and injects empty slots when requested.

Resolves a display label for a column.

Maps area mode enum to CSS suffix.

Builds fixed-width column style.

Builds evenly spaced fill-width column style.

Resolves widget anchors into renderable widget metadata.

Normalizes a subgroup name for lookup keys.

Inline shell style resolved from the group preset.

CSS class for shell and group/preset targeting.

Maps preset enum to CSS suffix.

Generates inline width/height for a widget container.

Maps a widget key to a concrete render fragment.

Crosshair preview widget (preview + color control).

Returns properties visible for the current settings surface (main menu vs in-game).

Applies optional filtering for a property.

Where the popup renders on screen.

Top of the screen, horizontally centered.

Dead center of the screen.

Just above the crosshair.

Just below the crosshair.

Bottom-right corner of the HUD.

Bottom-left of the HUD, sitting just above the role/health display.

Follows the mouse cursor (updated each Tick).

Optional heading line, rendered above the body.

Main text. Supports [ActionName] tokens (e.g. [BuyMenu]) that are replaced with the live keybind via .

Auto-fade duration in seconds. 0 = sticky mode: stays visible while is true. Set by / .

Only used in sticky mode (DurationSeconds == 0). Caller toggles to show/hide.

Theme suffix - "neutral" (default), "traitor", "detective". Maps to a CSS class.

Where the popup anchors on the screen.

Smaller padding / font for tight hint-style popups.

If true, [ActionName] tokens render as styled key-cap labels (used by the role onboarding popup). Default false: tokens render inline as plain bracketed text.

Show the popup for seconds then auto-fade.

Show the popup until is called or is set false.

Update the popup's text without altering visibility. Useful for sticky popups whose text depends on state.

Hide immediately, canceling any auto-fade timer.

Inline form: replaces `[ActionName]` with `[Prettified]` (or the literal name for known keyboard keys like Tab/Enter) and returns the result as a single string. Used when UseKeyCaps is false so tokens render as bracketed text in the body label. Walk the body and return alternating text / key-cap chunks. Unmapped tokens fall back to the literal "[ActionName]" text.

The weapon's slot

The weapon instance we're listing

Is this selected or being hovered over?

Owns continuous and listener-wide audio presentation for the local camera. Gameplay objects remain responsible for positional one-shots.

Local-only camera rig. Owns the single main camera and routes pose based on local state.

When enabled, the main camera excludes the viewmodel tag and we explicitly draw viewmodels via (CommandList). This avoids relying on multi-camera rendering, and is useful for diagnosing cases where viewmodels exist but aren't visible.

Editor-visible entry point for the local camera rig prefab.

Pawn's camera. Reacts to "Am I the Viewer pawn?" and "What spectate mode?" Decisions are driven by PlayerLifecycleState

Now on LocalCameraRig, created and assigned locally. ///

GameObject the Viewmodel Camera is attached to, child of Camera GameObject. Weapon viewmodels are children of this object.

Viewmodel CameraComponent. Currently not in use

Reference to the player component on the player GameObject.

Reference the head on the player for reparenting the camera during death cutscenes, etc.

Reference to the player's body for setting visibility, etc.

The main model renderer for the player.

Our pawn's current CameraMode

Apply the correct CameraMode based on what pawn we are Indirectly set via ConnectedClient.Viewer

What kind of pawn are we? Used to determine CameraMode

Don't run the camera unless we are possessing this pawn

External FOV override (e.g., from scope or other visual FX). If not null, this value is used instead of the calculated FOV.

LocalPosition offset for the camera in first person

LocalPosition offset for the camera in third person

Wrapper(?) for UpdateCameraMode that authorities send modes to

Initial setup for a given pawn

Change the body visibility for the local player, depending on the camera mode. Only world models are children of the body, all viewmodels will be children of the ViewmodelCameraGameObject We call SetBodyRenderType which iterates through the body to show everything, shadows only, or nothing, depending on the need.

Local-only visual transition state for spawn/respawn events.

A weapon's viewmodel. It's responsibility is to listen to events from a weapon. It should only exist on the client for the currently possessed pawn.

A reference to the we want to listen to.

A reference to the viewmodel's arms.

Is this a throwable?

Looks up the tree to find the player controller.

The View Model camera

Cosmetic-only first-person wall tuck. Lowers/tilts the viewmodel near world geometry. This does not affect damage, traces, or weapon gameplay.

Raw access

Data in the frame

Are we overriding the type here?

This purely exists as a wrapper for a real lobby, so we can display fake lobbies in the UI.

A reference to our internal lobby type.

Is this lobby a dev env?

Test-only override so fake lobbies can render as dedicated for UI preview.

Is this lobby a dedicated server?

Stores which cosmetic items the local player has hidden from their loadout.

Stores the single player-model ident the local user has picked from pointshop. Empty / null means "no custom model - use the default citizen body". Persisted to a cookie so the choice survives reconnects. Selection only takes visual effect at round start (the outfitter commits it via OwnerLocalSelectedModelIdent at the same cadence as cosmetic JSON).

Clear the selection - equivalent to picking the "None" tile in the loadout.

Clears chat on first join only, not on map changes.

Clears chat and resets session flag when disconnecting.

Returns true if the local player can use team chat (is Traitor-aligned or Detective).

Returns true if the local player can send + receive mod chat (Moderator+).

Returns true if the local player can delete chat messages for everyone.

Tracks whether chat input is currently open/focused to arbitrate shared key input (for example Esc).

Requests that the chat UI closes from an external input owner (for example Pause menu Esc arbitration).

Returns true once when an external close request is pending, then clears it.

Returns the registered chat command names sorted alphabetically.

Returns up to command names that match the typed prefix.

Returns up to connected player display names that start with the typed prefix. Empty prefix returns the empty list (we don't dump the entire roster on a bare Tab).

Populates the with methods that have the attribute

Attempts to parse the message of its command and parameters.

The users message to process as a command

Mods+ delete a chat message for everyone by its Guid Id. Validated host-side.

Adds a message that only the local player can see with the server as the author.

The content of the message

Local-only ban-warning chat entry. Distinct red/warning styling so users can tell a real dev warning apart from a host-faked server message. Host RPCs have no path to produce this.

Adds a message that only the local player can see with them as the author.

Compatibility wrapper over the session-backed gimp sanction helpers.

Hides a user setting unless the local player can use developer tools.

Display override state used by settings UI attributes.

Use the default behavior for the control.

Force-enable the display option.

Force-disable the display option.

Attribute for tuning how a setting entry renders in the UI.

Use a compact row layout for this entry.

Show a value label for this entry.

Show a text entry field for this entry.

Horizontal alignment for a settings group shell within the viewport.

Preset sizing behavior for a settings category.

Fully fluid layout that uses available container width.

Narrower layout useful for short categories.

Width behavior for the area that contains settings columns.

Uses preset defaults (Compact = fit content, Fluid = fill available width).

Expands to available width.

Sizes to the content width of rendered columns.

Declarative per-group layout preset with optional shell and column width overrides.

Settings group name this preset applies to.

Preset key used for style hooks and default behavior.

Left-to-right display order for top-level category tabs. Lower values appear first.

Optional max width for the group shell in pixels. Zero keeps it fluid.

Optional fallback width for main dock columns in pixels.

Optional fallback width for sidebar dock columns in pixels.

Number of evenly spaced main column slots to reserve when using fill mode.

Width behavior for the area that contains main columns.

When true, renders the subgroup name as a top label for each main column slot.

Declares layout hints for a settings group in the settings UI.

Settings group name this layout applies to.

Max width in pixels for the settings shell when this group is selected.

Alignment for the settings shell when this group is selected.

Declares fixed width for a column in a settings group.

Settings group name this column layout applies to.

Column index within the dock.

Fixed column width in pixels.

Dock target for the column definition.

Placement for a widget relative to its anchor subgroup.

Renders the widget in the next column to the right of the anchor subgroup.

Renders the widget below subgroup sections in the anchor subgroup's column.

Anchors a widget panel to a subgroup, allowing preview/extra UI placement.

Settings group name this widget applies to.

Subgroup name this widget anchors to.

Widget key used by SettingsPage to render a widget fragment.

Placement relative to the anchor subgroup.

Sort order within the widget area.

Preferred widget width in pixels.

Preferred widget height in pixels.

Dock target used for resolving the anchor column.

Provides discrete option values (and optional labels) for a numeric setting.

Values displayed in the option selector.

Optional labels aligned with .

Optional Material icon names aligned with .

Placement for a settings sub-group within the settings UI.

Attribute for grouping settings into sub-sections within a category.

Subgroup title shown in the settings UI.

Sort order within the group.

Column index this subgroup should render into.

Dock target used to split main/sidebar columns.

Visibility surface for settings entries.

Restricts where a setting is visible in the in-game settings page.

The surface where this setting should be visible.

Enables a text entry field for a setting value.

Whether the text entry field should be shown.

Lightweight local cookie cache for UI/tutorial state that doesn't belong in gameplay settings.

Compatibility wrapper around for client-side UI state.

Declares who owns each persisted TTT user setting.

TTT owns persistence and runtime application.

Native cookies own lightweight local UI state.

Runtime surface affected by a setting.

Typed presentation/ownership metadata for a TTT user setting.

Small ownership registry used as a source of truth while the settings UI is simplified.

Persist AFK preference and notify host of the local player's desired AFK baseline.

Handles loading, saving, and applying .

Current settings instance (lazy-loaded from disk).

Data file path for serialized settings.

Writes settings to disk and applies runtime values.

Applies runtime values that need to take effect immediately. Returns true only when every expected mixer was ready and all volumes were applied.

Loads settings from disk (or defaults) and applies them.

Resets settings to defaults and applies them.

Returns true when current settings differ from the last loaded/saved state.

Resolves a property's default value from a fresh instance.

Compares a value against the default value for the same property.

Returns whether the current settings value for a property equals the default.

Resets one setting to its default value and persists settings.

Persist AFK preference to disk and push it to the host so it survives map changes.

Persist developer badge preference and publish the current local scoreboard state.

Keeps main menu stems in sync by only changing volume while all emitters keep playing.

Produces footstep sounds for the player.

Handles certain events and plays radio sounds.

A simple component that plays a sound.

How long until we destroy the GameObject.

Playback volume for this emitter.

Shoulud we follow the current GameObject?

Creates a GameObject that plays a sound.

Take damage.

Creates a which will deferred delete the .

Creates a which will deferred delete the .

One in a scene, used by to dictate rules around who can broadcast their voices to who.

Should we exclude this potential listener from hearing our voice?

Client-side spectator voice-mute cycle (OG TTT style). While the local player is dead/spectating, the current mode filters incoming voices: hear all, mute living, mute spectators, or mute everyone. Persists across rounds and launches via .

Adds casing spin and impact audio around the engine's native particle collision. Retains the legacy type name so existing casing prefabs remain compatible.

Editor-only bridge for playing a scene directly with the TTT system scene enabled. It lets authored scene maps use the same bootstrap/reset path as loaded maps without requiring the engine scene or Hammer map loader.

Centralized owner of . Hides are debounced so rapid show/hide races during a join don't flicker the panel.

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

The axis the door rotates/moves on.

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.

Can we open the door at all?

Interface for components that can reset their state without being destroyed/recreated

Reset this component to its initial state

Promotes authored map primitives that rely on Sync/host-owned transforms into real network objects. These objects already exist in the authored scene; we bootstrap networking in-place after map load.

Restores map-authored tool components to the immutable baseline captured from the loaded map so host migration does not preserve transient motion state from the old host.

Host-side registry for map-authored IResettable components. Captures once and reuses stable references during round cleanup to reduce scene-wide churn.

A map instance that can be reset to its initial state, inspired by Source 1's map reset methodology.

A list of tags for GameObjects that should be preserved during a map reset. This is analogous to Source 1's s_PreserveEnts list.

Stores the serialized data of all non-preserved objects from the initial map load.

Stores the Ids of all objects we have captured for reset.

Captures the initial state of all resettable GameObjects in the scene. Objects without IResettable are serialized for recreation.

Resets the map to its captured initial state.

Destroys all GameObjects that have a TemporaryEffect component.

Marks a GameObject as a temporary effect and destroys it after a short delay. Used by prefabs for transient particles/tracers.

How long until we destroy the GameObject.

If true, stop child particle emitters first, then destroy after a short delay.

Generic map-facing signal receiver contract used by mapper-authored primitives.

Generic signal payload passed between mapper-authored tools.

Shared positive-state alias check. Start is the preferred map-tool verb; Open remains a compatibility alias for door- or mover-shaped senders.

Shared negative-state alias check. Stop is the preferred map-tool verb; Close remains a compatibility alias for door- or mover-shaped senders.

Wiring entry for mapper-authored outputs.

Shared map-IO vocabulary and dispatch helpers. Keeping these in a dedicated core file makes the other mapping-tool folders read more like authored behaviors than infrastructure.

Shared activator resolution helpers so map tools can translate direct use, RPC callers, and signal activators into the same player-aware runtime objects.

Authoring-time and editor-friendly helpers shared by mapper-facing tools.

Common direct-use behaviors for mapper-authored buttons and binary movers.

Spawns a specific ammo box on round start.

Spawns a specific grenade on round start.

Converts directly-authored ammo pickups in maps into backend ammo spawner markers. This keeps old maps playable while moving round lifecycle ownership to the pooled pickup director.

Converts directly-authored weapon objects in maps into backend fixed spawner markers. This avoids carrying stale serialized weapon component data forward after weapon prefab refactors.

Spawns one map-authored weapon or prefab when activated by mapper I/O.

Marks a map-spawned pickup as reset-managed by a spawner or director.

Spawns a random box of ammo with full ammo.

Spawns a random grenade on round start.

Spawns a random weapon on round start. Can specify how much of its ammo spawns with it.

Coordinates map pickup spawners once per map reset generation.

Spawns a specific weapon on round start. Can specify how much of its ammo spawns with it.

Opt-in diagnostics for tracking down persistent idle SyncVar traffic.

Conservative network visibility for world objects that do not need to always transmit.

Track who damaged this barrel (for karma tracking when it explodes)

Host-only registry for authoritative explosive barrel spawn points. Keeps barrel respawn deterministic even if a barrel GameObject is destroyed mid-round.

This system exists to collect pending collision sounds and filter them into a unique set, to avoid unnesssary sounds playing, when they're going to be making the same sound anyway.

Register this physics collision with the sound system

Add a collision sound for this shape

Add a collision sound for this shape

Create the pending sounds

Host-authored policy for ordinary player-vs-loose-prop contact. Keeps per-prop state on TerrorTownProp while centralizing contact push rules.

Marks this prop as having been physically influenced by a player-authored action. Host-only. This deliberately does not change network ownership; ownership stays with the system that needs smooth control, while this records attribution and a short intentional-launch collision window.

Check if this prop is currently being held by a magneto stick (ObjectGrabberComponent)

Reset this prop to its initial state for map reset

Host-side failsafe for pickups that fall out of the playable world and keep replicating physics.

A physics surface replacement that controls the physical properties and sounds applied to physics shapes.

A simple component that destroys its GameObject.

How long until we destroy the GameObject.

The real time until we destroy the GameObject.

Destroys the GameObject after a delay, optionally tied to a legacy particle system.

Optional particle system to stop before destruction.

How long until we destroy the GameObject.

The real time until we destroy the GameObject.

Bridge our baseline water tag + trigger collider into Atmokinetic's local camera presentation

Water audio for TTT The interaction events are owned by .

Host-simulated corpses -> one-shot emitters for localized water surface tint The water shader still owns diffusion after stains get made

Reliable late-join snapshot for a fixed GPU stain record. After creation, age and local ripple presentation drive its diffusion without further corpse or network updates.

Applies TTT-specific policy to e8 water without coupling the library to our player controller

TTT presentation and gameplay integration for Atmokinetic water Also attempt @ bullets hits/splashes, leaving this in for now. Tries to keep high-frequency hitscan handling local and bounded

Called from the already-broadcast tracer path. This needs to be local, broadcasting here would duplicate traffic for every bullet

Player entry/exit is an infrequent owner-detected presentation event 1 discardable broadcast lets remote observers see the splash without syncing continuous water state or creating a networked particle object, which are uglier options

Gets the angle (in degrees) between two Vector2s

P2P/listen-host migration recovery. Dedicated servers have a stable server host and use GameNetworkManager.Dedicated for empty-server baseline resets instead.

Handles the main game loop, using components that listen to state change events to handle game logic.

Gets all game modes referenced by a scene.

Current game state (controlled by the host.)

Current game time (controlled by the host.)

Current round number, starting at 1.

Enables owner-requested snapshot resync when local life/lifecycle state diverges.

Minimum seconds between resync requests from the same client. Default: 1

Host-only: if > 0, broadcast authoritative state every N seconds.

Enable verbose resync request/apply logs.

Host-only: toggling true will dump lobby state once and then reset.

Called on the host at the end of a round to determine if the game should end.

Called on the host every update during a round to determine if it should end. TODO: perhaps CheckRoundEnd should return a team?

Game start is when "Preparing..." pops up on the screen, after at least 2 players have joined.

Called on the host before .

Called on the host when a game is starting.

Called on the host after completes.

Game end is when the ROUND is over, AFTER the 5 seconds or so post-team winning

Called on the host before .

Called on the host when a game is ending.

Called on the host after completes.

Round start is when the round formally begins and the roles are assigned to players that are participating

Called on the host before .

Called on the host when a round is starting.

Called on the host after completes.

Round end is when a team is determined to have won, the toast pops up and the 5ish seconds of "Game Over" begin

Called on the host before .

Called on the host when a round is ending.

Called on the host after completes.

Called on the host before .

Called on the host when respawns.

Called on the host after .

Called on the host when a new player joins, before NetworkSpawn is called.

Called on the host when a new player joins, after NetworkSpawn is called.

Called on the host when a player is assigned to a team.

Never start the game, useful for testing weapons.

Split players into two balanced teams.

Check team win conditions.

Ammo resource metadata used to describe an ammo type as an asset.

The prefab to create and attach to the player when spawning it in.

The Ammo's model

The optional legacy Entity name for this weapon, for map compatibility reasons.

Knives etc.

Pistols.

Non-pistol guns.

Grenades etc.

Magneto Stick etc.

Traitor items etc.

Do not use.

A resource containing basic information about a weapon.

If true, randomly spawns throughout the map

Local offset applied when this weapon is spawned as a map-authored world pickup. This replaces model-level spawn-only translation without affecting held weapon presentation.

If true, owner will drop this weapon if they disconnect.

The weapon's icon

Is this weapon shown in the buy menu

The tab this weapon is shown in the buy menu

The tab this weapon is shown in the buy menu

How much is this weapon to buy in the buy menu?

If true, once purchased, this item can't be bought again until the next round.

The prefab to create and attach to the player when spawning it in.

The prefab to create when making a viewmodel for this weapon.

Ragdoll impulse scale for this weapon. Higher values throw bodies more.

Extra upward bias for ragdoll impulse (0-1 recommended).

If true, body armor does not reduce this weapon's headshots. Intended for classic one-shot headshot weapons like the Deagle and M24.

If true, this weapon suppresses the victim's death scream/audio cue. This is separate from corpse/death-camera flow and is intended for silent-kill behavior.

If true, text generators will use 'an' instead of 'a' before this weapon's name. Examples: an Uzi, an M24, a Glock.

Rotation override for this weapon's model preview. Useful when a world model faces an awkward direction by default.

Additional offset applied to the model preview camera look-at target. Use this to nudge tall or asymmetrical models back into frame.

Multiplies the auto-fit camera distance for the model preview. Values above 1 pull the camera back; below 1 push it closer.

Field of view override for this weapon's model preview camera.

The optional legacy Entity name for this weapon, for map compatibility reasons.

Emits particles evenly along a defined line.

The starting point of the line in local space.

The ending point of the line in local space.

If true, the Start/End Point properties will be ignored, and GameObjects will be used instead.

The GameObject to use as the starting point of the line.

The GameObject to use as the ending point of the line.

Renders a single continuous rope between all particles in the system using a LineRenderer.

The colour of the rope over its length.

The width of the rope over its length.

How the texture is applied to the rope.

A generic, configurable operator that performs a mathematical operation on a particle property every frame.

Destroy this object before a round starts if the current game mode has a component.

Destroy this object before a round starts if the current game mode has a component.

Implement this interface on components that need to reset their state before map state capture.