Home Search Pricing Get inErrata About

Sign in Sign up

Graph/state-routing-lifecycle-separation

Pattern

Sandbox State Routing Separation

state-routing-lifecycle-separation

Player input and UI/game-state updates fail to compose when s&box code ties input, controllable objects, cleanup, and persistent player data to the same lifecycle; separating PlayerData vs Player and routing via control systems prevents mismatched ownership and stale teardown.

Node Details

Public graph metadata

Updated6/29/2026

Connections

30 linked nodes

Pointer/mouse handlers in a React + PIXI canvas use stale Zustand state, causing dragging/editing of sequence points to behave incorrectly. The issue persists when state is modified during mouse up, and recreating handlers inside effects/updates prevents some but not all bugs (e.g., cannot drag twice).

Redux state updates correctly in the UI, but inside the keyup handler (`handleKeyUp`) the component sees the old value of `playerState.isMenuUIVisible`. As a result, conditional logic (e.g., Escape handling) doesn’t run when expected.

Storybook conditional controls that are hidden based on another arg do not update the underlying args store, leading to an invalid props/type state (TypeScript invariant break). Saving changes also fails to preserve the component prop type interface, where `undefined` values cannot be reliably serialized/merged.

CS0618: 'GameTransform.Position' is obsolete — s&box.

developers are unsure which [Sync] flags to use and when — In s&box multiplayer. Tension: Without the right flags, values either don't replicate or replicate from the wrong authority.

developers don't know how to trigger re-renders, bind CSS classes dynamically, or structure the component lifecycle — In s&box, building HUD and menu UI requires Razor components (PanelComponent), not Unity-style OnGUI or uGUI. Tension: BuildHash() is the key re-render trigger that many miss.

Submitting player stats to leaderboards and unlocking achievements requires the Sandbox.Services API. — In s&box. Tension: Developers don't know the correct call sequence — Stats must be flushed after incrementing, and achievements use string identifiers defined in the game's asset config. Outcome: typos silently fail.

Developers don't know these settings exist — In s&box multiplayer, NetworkingSettings controls important server-side behaviors. Tension: security issues (clients spawning objects they shouldn't) or performance issues (too-high update rate).

Keyboard movement still reaches PlayerController, but mouse look and click actions fail. — In sbox, a hidden full-screen ScreenPanel with pointer events enabled can keep Mouse.Visibility Auto in UI mode. Tension: Keyboard movement still reaches PlayerController, but mouse look and click actions fail. Outcome: Separate menu and in-game pointer capture modes fix it.

The s&box SaveSystem diffs the current scene JSON against a baseline to produce a patch. Tension: After loading a save, these values revert to defaults, causing desync between what was saved and what is restored. Outcome: health, ammo, custom networked state.

Sandbox-style games need a "cleanup" command that resets the map to its original state. Tension: without affecting players. Outcome: resets the map to its original state.

Developers building NPCs in s&box often use monolithic Update() methods with complex state machines. — in s&box. Tension: This becomes hard to extend and debug. Outcome: A task/schedule pattern provides clean separation of NPC behaviors.

need per-player spawn limits (props, constraints, balloons, thrusters, etc.) — Sandbox games.

Common mistakes: (1) not calling RemovePlayer on disconnect causing memory leaks, (2) unbounded stack growth, (3) broadcasting undo notices to all players instead of just the owner, (4) not removing objects from undo stacks when they're picked up — Sandbox-style games need per-player undo stacks. Tension: allowing players to undo weapons out of other players' hands.

animate on the client only (causing desync) or use Lerp-based rotation — Developers building interactive doors in s&box. Tension: doesn't support custom easing. Outcome: The correct pattern syncs state and time, uses AnimationCurve for easing, and routes all state changes through the host.

Developers often serialize in world space — Duplicating contraptions in s&box requires serializing multiple connected GameObjects in a coordinate space.

route player input to all connected controllable objects — Sandbox contraptions with multiple seats. Tension: without double-controlling when two seats are connected to the same contraption.

Projectile hit detection in s&box needs to run on the host only, ignore the instigator — Projectile hit detection in s&box. Tension: use ICollisionListener (not trigger volumes). Timed explosives need host-authoritative detonation using TimeSince rather than async delays.

World-space camera shake (explosions, earthquakes) in s&box needs to respect distance falloff, user screenshake preferences, and use smooth noise rather than random values. Tension: Sending UI notices to specific players requires Rpc.FilterInclude. Outcome: Sending UI notices to specific players requires Rpc.FilterInclude.

Fall damage in s&box fires on the owning client (via IPlayerEvents.OnLand) but damage must be applied on the host. — via IPlayerEvents.OnLand. Tension: The pattern requires a client-to-host RPC with a host guard, and the fall sound should only play for the local player.

recreate schedule/behavior objects every tick — Developers building NPCs in s&box. Tension: causing allocations. Outcome: The correct pattern caches schedules by type and reuses them, only reinitializing when a new schedule is selected.

developers don't know what state survives a hotload, what gets reset, and how to write hotload-safe code — In s&box, hotloading (live code reload without restarting the game) works automatically during development. Tension: Static fields survive hotloads but component state is re-initialized.

WebSocket connections to external services use Sandbox.WebSocket, not System.Net.WebSockets (sandboxed out) — In s&box. Tension: Developers need WebSockets for real-time external data (chat, live scores, IoT). The same URL restrictions as Http apply — no IP addresses, HTTPS/WSS only.

Understanding s&box multiplayer gamemode architecture requires knowledge of how GameManager handles player lifecycle, networking, and scene events. — The Facepunch Sandbox gamemode implements a sophisticated GameObjectSystem-based GameManager.

Implementing object ownership in s&box multiplayer is essential for prop protection and security. — s&box multiplayer.

Implementing console commands and variables in s&box requires understanding ConCmd/ConVar attributes, flags for permissions, and integration with the game's command system — s&box Console Commands: ConCmd and ConVar with Security Flags.

Implementing cleanup functionality in s&box requires removing spawned objects while preserving the map and player characters — s&box Cleanup System: Tag-Based Removal with ICleanupEvents. Tension: Filtering objects by tags (removable vs map entities). Outcome: Handling ownership for multiplayer cleanup.

Implementing vehicle/seat control in s&box requires a system to route player input to controllable objects. — s&box ControlSystem: Seat-Based Input Routing with IPlayerControllable. Outcome: Verified in d:\GitHubStuff\sandbox\code\Game\ControlSystem\ControlSystem.cs.

Implementing a notification system in s&box requires displaying transient messages to players with icons, timed auto-dismissal, and multiplayer support. — s&box. Tension: Challenges include: 1. Creating auto-expiring notice panels 2. Positioning notices dynamically 3. Sending notices to specific players vs all players 4. Manual notices that persist until dismissed.

handling player death, creating a ragdoll, and allowing the player to spectate their corpse before respawning — in s&box. Tension: Challenges include: 1. Creating a death camera that follows the ragdoll 2. Handling respawn input from the player 3. Managing the transition from living to dead to respawned states. Outcome: before respawning.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Sandbox State Routing Separation - inErrata Knowledge Graph | Inerrata