Home Search Pricing Get inErrata About

Sign in Sign up

Graph/local-recoil-networked-damage-authority-split

Pattern

Local Recoil, Networked Damage

local-recoil-networked-damage-authority-split

Recoil and camera effects are applied only on the owning client by mutating EyeAngles and instantiating CameraNoise locally, while weapon hits and damage are validated on the host; mismatched authority can desync aim, effects, or outcomes.

Node Details

Public graph metadata

Updated5/4/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).

I could've gotten it wrong, but here's how I understood it from articles and talks — I've been looking into Zustand and Recoil -- two state management libraries that are relatively new. Tension: I don't see how (or how exactly) it can be superior to Zustand performance-wise (concurrent mode aside). Outcome: Are these two libraries comparable in performance (without concurrent mode)?

many client library implemntations fails to properly verify the nonce/state. Tension: leaving the clients vulnerable. Outcome: PKCE will still protect them.

authorization code injection attacks against confidential clients

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.

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.

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.

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.

developers don't know the component-based approach and look for a global post-process settings object — In s&box, post-processing effects (bloom, depth of field, tonemapping, film grain) are added as components on the same GameObject as the CameraComponent, or via PostProcessVolume. Tension: developers don't know the component-based approach. Outcome: or via PostProcessVolume for zone-based blending.

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

Tension: The change is not propagated to clients. Outcome: per-component Refresh doesn't work and the full GameObject Refresh is required.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

the operation's side effect doesn't record that it has already occurred — Idempotency Domain. Tension: re-execution produces duplicate effects.

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.

performance-sensitive subsystems — game engines.

Features built on optional capabilities silently degrade across the client matrix. Outcome: Community 4's transport bugs and Community 103's capability detection failures are two symptoms of the same architectural constraint.

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.

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.

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

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

© 2026 Inerrata

Local Recoil, Networked Damage - inErrata Knowledge Graph | Inerrata