Compile-time identity of the binary behind this server, surfaced on
/info so tooling can prove which sources a running process was built
from. Adapters stamp it via ServerBuilder::build_identity; unset
fields stay UNKNOWN_BUILD_IDENTITY.
A one-shot modifier for a body’s contact response, consumed by the next
physics tick like forces and impulses: game systems set it before
physics runs, integration applies it to any impact that tick, and it is
cleared whether or not a contact happened — a stale response is
unrepresentable. Powers soft surfaces (deadened rims, mud, gel pads)
without the engine learning what any of those are.
The single choke-point damage predicate. Every damage path — hitscan,
projectile, melee, contact — must call Self::try_apply; there is no other
way to reduce HP. Each guard (spawn grace/shield, post-hit invuln, dash
i-frames, per-tick cap) is enforced here exactly once, so anti-instagib holds
no matter how many attackers cluster into one tick.
The immutable damage rules a DamageGate enforces. All windows are in
ticks and the cap is a fraction of max HP so it survives damage retuning:
change any damage number and a single tick still cannot remove more than
per_tick_cap_frac of a target’s max HP.
The per-target damage state the single predicate reads and updates. Engine-
generic: it is just HP plus the timing windows every guard needs. There is
deliberately no second way to mutate HP — all damage flows through
DamageGate::try_apply.
Tear down a world. force = false respects in-flight-tick safety and may
return TeardownInFlight; force = true schedules teardown to run after
the in-flight tick completes (never mid-borrow).
A single seeded, deterministic PRNG (mulberry32). This is the only
randomness allowed on the sim path — the server is the single roller, and
its state is carried in sim state so a replay from the same seed reproduces
every roll.
Per-client sets of entity ids currently streaming to that client. Each entry
remembers the tick of the last message sent for the entity so unchanged
entities can receive periodic keep-alive updates.
Fixed-timestep accumulator. Decouples sim advancement from wall-clock
delivery: real elapsed time is intaken, whole DT slices are peeled off as
steps (bounded by max_catchup_steps), and the leftover fraction becomes
alpha — a client render-interpolation factor that never feeds back into
the sim.
Per-world knob enabling the deterministic fixed-step tick. None on a
crate::WorldConfig (the default) means the world keeps today’s exact
wall-clock cadence and pays nothing; Some opts the world into the
accumulator + determinism rules and makes it eligible for golden tests.
A cheap, copyable snapshot of the deterministic clock for observation /
replication sampling (see design §6: the snapshot accumulator samples the
sim clock). Contains only render/observability inputs, never anything the
sim reads back.
Deterministic sim state carried on an opted-in world as an ECS resource.
Bundles the authoritative clock and the single seeded roller so every
system on the sim path reads sim time and randomness from one place.
The inbound half of the state channel: peer (client position) packets
staged by the network layer and applied by the world at the start of every
tick, before the system dispatch.
A WsSessionPolicy that cannot drive a session: some duration is zero
(which would spin or panic timers) or the timings contradict each other.
The message names the offending field and observed value(s).
The lag-compensation resource carried on an opted-in world: the config, the
derived tick length, the position-history ring, and the per-client server-
measured RTT trackers. This is the one place a game asks “how far do I rewind
this client’s shot?” and “where was this target then?”.
Per-world knob enabling server-side lag-compensation. None on a
crate::WorldConfig (the default) means the world keeps no history ring
and pays nothing; Some opts the world into recording poses and answering
rewound queries. Requires the fixed-step tick (rewind is tick-anchored), so
Some(..) without a fixed_timestep is rejected at config-build time.
Compact per-block facts consulted for every voxel in the lighting hot
paths. Indexed by block ID so Lights can skip the full Block hashmap
lookup, rotation decode, and dynamic-pattern probing for the overwhelming
majority of voxels. Values mirror Block exactly; blocks that need the
slow path (dynamic light patterns, rotatable transparency) are flagged.
Aggregated wall-clock motion-gap distribution for one client over one
reporting window: how long each tracked entity’s consecutive
motion-carrying flushes were apart. Quantiles are bucket upper bounds
(conservative), the max is exact.
A recorded pose: position plus a look direction (orientation as needed). The
engine stores whatever the recorder hands it; the meaning of the vectors is
the game’s, not the engine’s.
A MotionSample quantized to wire resolution. Equality of two quantized
samples means the wire payloads would be identical, which is what the
sending system uses to decide whether an entity’s motion “changed”.
A collection of blocks to use in a Voxelize server. One server has one
registry and one registry only. Once a registry is added to a server, it cannot be changed.
The outbound half of the latest-wins state channel: per-client, per-item
latest-value slots for all high-frequency replicated state (entity motion
and metadata, peer positions/metadata). See the module docs for why this
must never become a FIFO.
A fire-time rewind anchor: the tick a shot was created and the rewind depth
to apply for the shooter who fired it (already double-clamped when built via
LagComp::anchor).
Marker component: this entity’s pose is recorded into the world’s
position-history ring at the start of each fixed tick and is a candidate for
rewound hit queries.
A hit resolved against historical positions: which entity, the tick its pose
was read from, and the distance along the query (ray parameter or center
distance).
The server’s exponentially-weighted moving average of a client’s measured
round-trip time, in milliseconds. This is the load-bearing anti-cheat input:
rewind depth is sized from this (server-measured), never from anything the
client asserts. Non-finite or negative samples are ignored.
A data structure used in Voxelize to access voxel data of multiple chunks at
the same time. Centered with one chunk, a Space allows developers to know what’s
around a chunk.
The result of intaking real elapsed time into the accumulator: how many
fixed steps to run this delivered tick, and whether the catch-up clamp
fired (backlog was dropped).
A layer to the terrain. Consists of two spline graphs: height bias and height offset graphs.
Height bias is how much terrain should be compressed as y-coordinate increases, and height offset is
by how much should the entire terrain shift up and down.
Deterministic splitmix64 parameter stream. One instance is seeded per
generated tree, and every stochastic decision (rule selection, turtle
jitter) pulls from it in walk order, so the same seed always grows the
same tree.
Per-individual variation ranges for a tree species. Every draw comes
from the tree’s position-seeded stream, so the same world seed always
grows the same forest. The neutral defaults are bit-exact no-ops:
species that configure nothing generate exactly as before.
Immutable, cheaply-cloneable descriptor of a live world, snapshotted at
query time. The authoritative player count lives in the world; this is a
server-side snapshot derived from the connection registry.
Why a protocol handshake was refused. The engine turns this into a terminal
close (PROTOCOL_MISMATCH_CLOSE_CODE) so the client can treat it as
non-retryable.
Default smoothing factor for the server’s per-client RTT EWMA. Passed as a
constructor parameter to LagComp::new so it can be overridden per world;
this documented default is used by the world wiring. A moderate value tracks
genuine latency shifts without letting a single spiky sample swing the
rewind depth.
Hard cap on inbound state packets buffered per client between ticks. At a
16ms tick and a typical 20-60Hz client send rate this holds 1-4 entries;
the cap only bites on a misbehaving client, where dropping the oldest
packets is safe because newer ones supersede them.
Hard cap on latest-value slots per client. The structure is already bounded
by the client’s interest set, so this is a backstop against pathological
interest sizes; overflowing entity updates are dropped (the keep-alive
cycle re-sends them) and a counter is exposed through perf tracing.
Wall-clock max age of a pending METADATA-lane slot. Metadata is
low-frequency (paths, text, game JSON), so it tolerates more staleness
than motion, but it is still bounded — a changed path must not hide
behind a busy motion lane forever.
WebSocket close code sent when a client is refused for a protocol mismatch.
In the 4000–4999 application range. The client treats it as terminal
(client_outdated): it never retries and never burns reconnect grace.
Derived from the same shared protocol-version.json.
Wire protocol version. Snapshot + delta replication and the deterministic
join handshake are pinned to this. Bump it once in protocol-version.json;
both the Rust server and the TS client pick the new value up automatically. A
deterministic world rejects any client that does not match exactly.
Metadata key that marks an entity as owned by a test scenario (stamped by
test:spawn-style methods). Scenario entities are live-only: they spawn
and despawn normally, but persisting them would litter the world save
with one orphaned JSON file per test run, so spawn_entity_with_metadata
hands them a DoNotPersistComp and the saving system never sees them.
How many messages may sit unread in a client’s WebSocket channel before the
state flush for that client is skipped for the tick. Reliable events are
unaffected (they must queue); state simply keeps coalescing in its slots
and the client receives one fresh snapshot once the socket drains. A small
value keeps a slow client’s view of the world current instead of
complete-but-late.
Value reported on /info for any build-identity fact that could not be
established. A visible “unknown” — never a fabricated stand-in — so a
binary without a stamped identity is unmistakable to tooling.
The voxel offset a rotation-mounted block leans on, matching the rotation
that placement derives from the clicked face normal: a block placed against
the +x face of a wall carries PX, so its support sits at -x.
Fail-closed, strict-equality protocol assert for a deterministic world’s
join. There is deliberately no0/missing bypass: an absent version is
a reject, not a pass. This is the load-bearing lesson of the motion field-5
silent-skip incident — never silently accept an unknown/absent field on the
deterministic path.
The first dly clamp (§2.3): clamp a client-reported render delay to
[floor_ms, ceil_ms] on receipt. Non-finite input clamps to the floor. This
bounds the only value a client contributes to lag comp before it is used;
the window clamp then bounds it again.
Decode a motion.v1 payload back into world-space floats. The server only
needs this for tests; the shipping decoder is the client’s, in
packages/core/src/core/network/workers/decode-utils.ts (kept in sync
with this layout by the round-trip tests below).
The default client metadata parser, parses PositionComp and DirectionComp, and updates RigidBodyComp.
Position updates are clamped to a maximum per-message delta so clients cannot
teleport past server reach checks (mine/place/stations).
Whether a peer’s state should replicate to a client, given the squared
distance between them. None (the default) replicates every peer to every
client — there is no wire-level “peer left your view” signal, so games must
opt into radius culling via WorldConfig::peer_visible_radius, knowingly
accepting that out-of-range players freeze at their last known position on
the client.
Proximity-scaled motion max age: the nearest entities refresh twice as
fast as the configured bound, scaling linearly out to the full bound at
(and beyond) the visible radius. Distance modulates PRIORITY, never
eligibility — the far edge still holds the configured wall-clock bound.
Per-client flush budget in (approximate payload) bytes, derived from the
socket’s live state. Returns None when the socket is genuinely backed
up and the flush must be skipped for the tick.
Distance along direction to the first face of anything a swept body
collides with, or None when max_d of open space lies ahead. The cell
filter is sweep’s own — fluid, empty, and
passable blocks never collide — and inside a surviving cell the ray is
tested against the block’s actual rotated AABBs. Cell flags alone cannot
answer this question: the water beside a waterlogged wave-maker housing
or between coral pillar columns is open to a body while the furniture
itself is not, and both truths live in one cell. Panics on a zero
direction, like trace.