Networking: assemble the server-authoritative multiplayer loop + playable 2-client demo #636

Problem

OloEngine's networking subsystem contains ~20 replication/prediction/interest/lag-comp classes and a working GameNetworkingSockets transport — all unit-tested in isolation — but they are never assembled into a running server-authoritative loop. The pieces exist; the game does not.

Verified dead seams (grep + read, 2026-07-11):

• NetworkManager::TickSnapshots() has zero call sites. NetworkThread::ThreadFunc (NetworkThread.cpp:78) only runs GNS callbacks + named-thread tasks. The header comment claiming it "invokes TickSnapshots()" is false. The server-side capture+delta+broadcast never runs.
• NetworkManager::SetActiveScene() is never called in production. OloServer/src/OloServerApp.cpp loads a scene and ticks OnUpdateRuntimeFixed, but never registers it with networking. s_ActiveScene is always null, so TickSnapshots would early-out anyway.
• SnapshotInterpolator::Interpolate(scene, dt) is called only from tests. Received snapshots pile into the buffer and are never applied to the client ECS — remote entities never move.
• Prediction/reconciliation never fires end-to-end. No InputApplyCallback is registered in production; the server never sends InputAck, so ClientPrediction::Reconcile is dead.
• RPC is a bare ENetworkMessageType enum value (NetworkMessage.h:21). No registry, marshalling, authority routing, or script bindings exist (RegisterRPC/InvokeRPC/RpcDispatcher = no matches anywhere).
• Interest management is wired only into the separate MMO ZoneServer, not the core loop — TickSnapshots broadcasts one shared delta to all clients with no per-connection baseline or relevance culling.
• LagCompensator is never invoked by the input/hit path (ServerInputHandler::ProcessInput does no rewind).
• EntitySpawn/EntityDespawn are enum tokens with no lifecycle replication — snapshots assume a static entity set; server-spawned entities never appear on clients.

No open GitHub issue tracks this.

Why it matters

The engine advertises networking (dedicated OloServer target, MMO/lobby/P2P classes, Lua Network.* table) but cannot run a single authoritative multiplayer match. This is the highest-decay area in the codebase: a large, well-tested stack that produces nothing playable because the last-mile assembly and several keystone systems (RPC, spawn/despawn, interest-scoped replication, lag-comp integration) were never built. Bringing it to life turns a dead stack into the engine's flagship differentiator.

What EXISTS today

• Transport: NetworkServer/NetworkClient/NetworkConnection (GNS), live-tested by tests/Networking/NetworkIntegrationTest.cpp.
• Replication: EntitySnapshot (Capture/CaptureDelta/Apply), ComponentReplicator, ComponentInterpolationRegistry, SnapshotBuffer, SnapshotInterpolator.
• Prediction: ClientPrediction, ServerInputHandler, NetworkInputBuffer.
• Lag comp: LagCompensator (rewind primitive).
• Interest: NetworkInterestManager, SpatialGrid, NetworkPriorityQueue, RelevanceTier.
• Components: NetworkIdentityComponent + ENetworkAuthority{Server,Client,Shared} (Components.h:3509), NetworkInterestComponent, NetworkLODComponent.
• Facade: NetworkManager (server capture+broadcast in TickSnapshots, SendInput, reconcile handlers in Connect).
• Lua: Network.isServer/connect/startServer/… (LuaScriptGlue.cpp:2385).

Proposed approach

1. Core loop driver — drive TickSnapshots() from the NetworkThread (or a dedicated fixed-rate replication tick); register the active scene via SetActiveScene() from OloServerApp and the editor host; drive SnapshotInterpolator::Interpolate() per client frame.
2. Authoritative ECS replication + entity lifecycle — replicate spawn/despawn (wire the existing tokens), server-UUID→client-entity mapping, authority-gated writes.
3. Client prediction + reconciliation end-to-end — real InputApplyCallback, per-tick input sampling, server InputAck, replay-on-divergence.
4. Registered RPC system — typed marshalling over FArchive, authority routing (Server/Client/Multicast/target), reliability, dispatch over the RPC message type.
5. RPC script bindings — RegisterRPC/InvokeRPC in Lua (LuaScriptGlue.cpp) and C# (ScriptGlue.cpp).
6. Interest-scoped core replication — per-connection scoping via NetworkInterestManager/SpatialGrid/RelevanceTier + per-client delta baselines.
7. Lag compensation integration — rewind to the client's RTT-adjusted tick before authoritative hit checks, then restore.
8. Dedicated-server integration — OloServerApp registers its scene, spawns/despawns a player entity per connection, drives the replication tick.
9. Playable 2-client demo + functional tests — a SandboxProject scene running the full loop, plus Functional-axis convergence/authority/RPC/interest/lag-comp tests.

Acceptance criteria

• TickSnapshots() is driven and SetActiveScene() is wired from both OloServerApp and the editor host; a connected client's remote entities move via SnapshotInterpolator::Interpolate().
• Server spawns/despawns replicate to clients with a stable server-UUID→client-entity mapping; client writes to server-authoritative entities are rejected.
• Client prediction + server InputAck + reconciliation converge end-to-end (replay of unacknowledged inputs on divergence).
• A registered RPC system marshals typed args, routes by authority (Server/Client/Multicast/target), and selects reliability — no longer a bare enum.
• RPCs are callable from Lua and C# scripts.
• The core replication loop scopes snapshots per connection with per-client baselines and relevance culling (not one shared broadcast).
• LagCompensator is invoked from the server input/hit path (rewind → check → restore).
• OloServer runs the full authoritative loop: player-per-connection lifecycle + replication tick.
• A playable 2-client demo scene exists under SandboxProject, plus Functional tests asserting cross-client convergence, authority rejection under the live loop, RPC round-trips, interest culling, and lag-comp hit registration.

capability: 5
craft: 4
stability: 2
decay: 5
effort: 13
confidence: 0.92
learning: 4
fun: 5
kano: delighter
blocked_by: []
blocks: []