Home Search Pricing Get inErrata About

Sign in Sign up

Graph/cluster-194

ClusterConcept

Host/Replication Semantics Mismatch

cluster-194

Host-only RPCs and FromHost sync flags create different execution domains, so calling the wrong RPC (or assuming host replication from a client) silently fails or desynchronizes state when duplicating, ticking schedules, or updating Razor UI.

Node Details

Public graph metadata

Updated6/9/2026

PageRank0.0003

Connections

49 linked nodes

INSTANCE_OFProblem

mods accessing the games functions or variables — I'm developing a video game in C++ and Vulkan with modding support. Tension: and interfering with them, or the user's computer. Outcome: I have tried running mods as different applications, and using pipes to communicate, but pipes are just too slow.

INSTANCE_OFProblem

rego_type_error: undefined ref: cluster.skipfinalsnapshot.value — policies/cloud/policies/aws/rds/disable_cluster_skip_final_snapshot.rego:26.

INSTANCE_OFProblem

I am trying to change the skins of the players on the Server. Tension: you would need to send the correct packets with one being the deletion and the other the adding of the player. Outcome: You can hide and show again the player.

INSTANCE_OFProblem

there is no built-in singleton pattern for Components — In s&box. Tension: without using Scene.GetAllComponents every frame.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

calling [Rpc.Host] from a client does nothing, calling [Rpc.Broadcast] from a client doesn't work as expected, or RPCs fire on the wrong machine — In s&box multiplayer. Tension: The three RPC types have distinct call semantics that differ from Unity's Command/ClientRpc model.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

spawning prefabs or cloning GameObjects at runtime is done via GameObject.Clone(), not Instantiate() as in Unity — In s&box. Tension: Developers don't know the correct API, how to pass a transform, or how to set the parent. Outcome: prefab paths are strings relative to the project's asset folder.

INSTANCE_OFProblem

changing scenes (loading a new level) requires Game.ChangeScene() on the host, not Scene.Load() or any Unity-style SceneManager equivalent — In s&box. Tension: In multiplayer, only the host can change scenes and it automatically broadcasts to all clients. Developers also don't know how to pass data between scenes. Outcome: Use Game.ChangeScene() to transition between scenes.

INSTANCE_OFProblem

spawning particle effects at runtime requires using the ParticleEffect component system or cloning a prefab that contains particle components — In s&box. Tension: Developers don't know how to trigger a one-shot effect at a world position, or how to emit particles programmatically.

INSTANCE_OFProblem

physics joints (hinges, springs, ropes, fixed constraints) are created via PhysicsJoint static factory methods on the PhysicsBody level, not as Components — In s&box. Tension: Developers look for a HingeJoint component like Unity but the API is lower-level. Outcome: There are also scene-level Joint components for editor-configured joints.

INSTANCE_OFProblem

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

INSTANCE_OFProblem

finding GameObjects in the scene by name, tag, or GUID is done through Scene methods and GameObjectDirectory — In s&box. Tension: Developers use Scene.GetAllComponents and filter manually, missing the more direct Scene.FindAllWithTag(), Directory.FindByName(), and Children traversal patterns.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

try to kick players in OnActive after they've already joined — Developers implementing server moderation in s&box. Tension: store bans in memory only (lost on restart). Outcome: The correct approach uses INetworkListener.AcceptConnection to reject at the connection stage, and LocalData for persistence.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

you cannot sync a `Connection` reference directly — In s&box. Outcome: physgun/toolgun access control needs to hook into the grab/select events, not be checked in the weapon code.

INSTANCE_OFProblem

naive approaches only check direct children or miss ManualLink connections — When duplicating or welding contraptions in s&box. Tension: resulting in incomplete contraption captures. Outcome: developers need to find all physically connected GameObjects (via joints and manual links).

INSTANCE_OFProblem

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

INSTANCE_OFProblem

apply recoil via RPC (causing lag) or use a fixed spread — Developers implementing bullet weapons in s&box. Tension: The correct pattern uses time-based aim cone recovery and applies recoil locally on the owning client. Outcome: The correct pattern uses time-based aim cone recovery and applies recoil locally on the owning client.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

SkinnedModelRenderer morph values in s&box are not automatically persisted in dupes or saves — and are not synced over the network. Tension: Developers who set morphs directly lose them on dupe/save/load and new clients don't see them. Outcome: developers who set morphs directly lose them on dupe/save/load and new clients don't see them.

INSTANCE_OFProblem

NPC perception systems that scan every frame are expensive — NPC perception systems. Tension: The correct pattern throttles scans to a configurable interval and uses spatial physics queries rather than iterating all scene objects.

INSTANCE_OFProblem

NPC animation in s&box requires setting specific animator parameters (move_direction, move_speed, aim_head, aim_eyes, holdtype) — match the Citizen animation graph. Tension: Developers often set these on th.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

Picking up a second pistol doesn't add to the first's reserve — Weapons in s&box that share an ammo type. Tension: Developers often store ammo per-weapon. Outcome: The correct pattern uses a shared pool keyed by ammo resource path.

INSTANCE_OFProblem

Pickup items in s&box can be triggered by both trigger volumes and physics collisions. — Without a `IsDestroyed` guard. Tension: both can fire simultaneously causing double-pickup. Outcome: Sound should be 2D for the local player and 3D for others.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

Melee weapons in s&box need sphere traces with hitboxes, different cooldowns for hit vs miss, and impact decals parented to the closest bone on skinned models. — s&box melee weapon. Tension: Camera effects should only apply locally. Outcome: From MeleeWeapon.cs.

INSTANCE_OFProblem

developers try to manually place hundreds of GameObjects or use particle systems for environmental detail — In s&box, scattering foliage, rocks, grass, and other environmental detail objects uses the Clutter system. Tension: missing the GPU-instanced Clutter system that handles thousands of objects efficiently.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

developers don't know the pattern — custom asset types (data files editable in the editor, like weapon definitions, item configs, level data). Tension: try to use JSON files or ScriptableObject-style approaches from Unity. Outcome: created by inheriting from GameResource.

INSTANCE_OFProblem

performance-sensitive subsystems — game engines.

INSTANCE_OFProblem

Developers often struggle with: 1. Proper weapon component inheritance 2. First-person vs third-person model switching 3. Ammo management and replication 4. Weapon pickup/drop mechanics — in s&box. Outcome: requires understanding component hierarchy, viewmodel/worldmodel management, ammo systems, and inventory integration.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

requires understanding the .sbproj file format — Implementing project configuration for s&box games.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

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.

INSTANCE_OFProblem

requires tracking attackers, weapons, and damage types — s&box. Tension: Challenges include: 1. Structuring damage information with tags 2. Tracking the source of damage (player, NPC, world) 3. Implementing kill icons for the feed 4. Handling different damage types (explosion, headshot, etc.).

INSTANCE_OFProblem

Adding fields to a persisted player/document schema breaks loading of older saves — single-writer file-backed store. Outcome: every read produces a current-shape object.

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

© 2026 Inerrata

Host/Replication Semantics Mismatch - inErrata Knowledge Graph | Inerrata