diff --git a/docs/cultnet-transport-parity.md b/docs/cultnet-transport-parity.md index 786f72bb..80548ceb 100644 --- a/docs/cultnet-transport-parity.md +++ b/docs/cultnet-transport-parity.md @@ -180,6 +180,11 @@ Current progress: dropped data packet in both directions between TypeScript and C#/Kotlin/Python/Rust. The drops happen below the transport connection through a UDP bridge, so the recovery is RUDP resend/ack behavior, not application-level retry. +- The same harness now proves reliable ordered `schema` delivery survives + reordered data packets in both directions between TypeScript and + C#/Kotlin/Python/Rust. The bridge delays one packet below the transport, sends + the following packet first, and then releases the held packet; delivered frames + still surface in sequence. - TypeScript, C#, Rust, Python, and Kotlin now share the first RUDP fragmentation implementation: the session can split oversized reliable ordered payloads into fragment packets, reassemble them before delivery, and @@ -190,8 +195,8 @@ Current progress: C#/Kotlin/Python/Rust one-shot UDP peers. - The remaining parity work is to deepen Python's server-side use of its port and move each runtime's existing TCP/LiteNetLib/WebSocket bodies behind those - ports, then broaden RUDP interop into the full loss, reordering, - reconnect, backpressure, and schema-message matrix. + ports, then broaden RUDP interop into reconnect, backpressure, and the wider + schema-message matrix. ## RUDP Packet Contract V0 diff --git a/packages/cultcache-py/src/cultnet_py/transport.py b/packages/cultcache-py/src/cultnet_py/transport.py index 2874c74a..ca7331af 100644 --- a/packages/cultcache-py/src/cultnet_py/transport.py +++ b/packages/cultcache-py/src/cultnet_py/transport.py @@ -320,6 +320,11 @@ class CultNetRudpSession: del now_ms self._require_connection(packet) self._apply_acknowledgements(packet) + expected_sequence_if_uninitialized = ( + packet.sequence + if self._highest_received_sequence is None + else self._highest_received_sequence + 1 + ) if packet.packet_type == CultNetRudpPacketType.ACCEPT: self._remember_received(packet.sequence) @@ -350,7 +355,11 @@ class CultNetRudpSession: frame, ordered, next_sequence = reassembled if not ordered: return CultNetRudpReceiveResult(delivered=(frame,)) - return CultNetRudpReceiveResult(delivered=tuple(self._deliver_ordered(frame, next_sequence))) + return CultNetRudpReceiveResult( + delivered=tuple( + self._deliver_ordered(frame, next_sequence, expected_sequence_if_uninitialized) + ) + ) def create_ack(self) -> CultNetRudpPacket: return self._create_packet(CultNetRudpPacketType.ACK, "control", b"") @@ -472,11 +481,16 @@ class CultNetRudpSession: max(sequences) + 1, ) - def _deliver_ordered(self, frame: CultNetRudpDeliveredFrame, next_after_frame: int) -> list[CultNetRudpDeliveredFrame]: + def _deliver_ordered( + self, + frame: CultNetRudpDeliveredFrame, + next_after_frame: int, + expected_sequence_if_uninitialized: int, + ) -> list[CultNetRudpDeliveredFrame]: next_sequence = self._ordered_next_sequence_by_channel.get(frame.channel_id) if next_sequence is None: - self._ordered_next_sequence_by_channel[frame.channel_id] = next_after_frame - return [frame, *self._drain_ordered(frame.channel_id)] + next_sequence = min(expected_sequence_if_uninitialized, frame.sequence) + self._ordered_next_sequence_by_channel[frame.channel_id] = next_sequence if frame.sequence < next_sequence: return [] if frame.sequence > next_sequence: diff --git a/packages/cultmesh-kotlin/src/main/kotlin/org/gamecult/cultmesh/CultMesh.kt b/packages/cultmesh-kotlin/src/main/kotlin/org/gamecult/cultmesh/CultMesh.kt index de7e8e64..d64a6e80 100644 --- a/packages/cultmesh-kotlin/src/main/kotlin/org/gamecult/cultmesh/CultMesh.kt +++ b/packages/cultmesh-kotlin/src/main/kotlin/org/gamecult/cultmesh/CultMesh.kt @@ -256,6 +256,7 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) { val ignoredNow = nowMs requireConnection(packet) applyAcknowledgements(packet) + val expectedSequenceIfUninitialized = (highestReceivedSequence ?: (packet.sequence - 1)) + 1 when (packet.packetType) { CultNetRudpPacketType.Accept -> { rememberReceived(packet.sequence) @@ -278,7 +279,7 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) { rememberReceived(packet.sequence) if (duplicate) return CultNetRudpReceiveResult() val reassembled = reassemble(packet) ?: return CultNetRudpReceiveResult() - return CultNetRudpReceiveResult(delivered = if (reassembled.ordered) deliverOrdered(reassembled.frame, reassembled.nextSequence) else listOf(reassembled.frame)) + return CultNetRudpReceiveResult(delivered = if (reassembled.ordered) deliverOrdered(reassembled.frame, reassembled.nextSequence, expectedSequenceIfUninitialized) else listOf(reassembled.frame)) } fun createAck(): CultNetRudpPacket = createPacket(CultNetRudpPacketType.Ack, "control", ByteArray(0)) @@ -364,11 +365,13 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) { return ReassembledFrame(CultNetRudpDeliveredFrame(buffer.channelId, payload, sequences.minOrNull() ?: packet.sequence), buffer.ordered, (sequences.maxOrNull() ?: packet.sequence) + 1) } - private fun deliverOrdered(frame: CultNetRudpDeliveredFrame, nextSequenceAfterFrame: Long): List { - val next = orderedNextSequenceByChannel[frame.channelId] - if (next == null) { - orderedNextSequenceByChannel[frame.channelId] = nextSequenceAfterFrame - return listOf(frame) + drainOrdered(frame.channelId) + private fun deliverOrdered( + frame: CultNetRudpDeliveredFrame, + nextSequenceAfterFrame: Long, + expectedSequenceIfUninitialized: Long, + ): List { + val next = orderedNextSequenceByChannel[frame.channelId] ?: minOf(expectedSequenceIfUninitialized, frame.sequence).also { + orderedNextSequenceByChannel[frame.channelId] = it } if (frame.sequence < next) return emptyList() if (frame.sequence > next) { @@ -596,6 +599,7 @@ private fun rudpServeOnce(options: Map) { val bindPort = options["bind-port"]?.toInt() ?: 0 val expectedClientPayload = (options["client-payload"] ?: "ts-kotlin-client-state").toByteArray(StandardCharsets.UTF_8) val serverPayload = (options["server-payload"] ?: "kotlin-server-state").toByteArray(StandardCharsets.UTF_8) + val serverExtraPayload = options["server-extra-payload"]?.toByteArray(StandardCharsets.UTF_8) val maxFragmentBytes = options["max-fragment-bytes"]?.toInt() val socket = DatagramSocket(bindPort, InetAddress.getByName(bindHost)).also { it.soTimeout = 20 } CultNetRudpSocketTransportConnection( @@ -614,6 +618,9 @@ private fun rudpServeOnce(options: Map) { if (frame != null) { requireRudpFrame(frame, "schema", expectedClientPayload) transport.send("schema", serverPayload) + if (serverExtraPayload != null) { + transport.send("schema", serverExtraPayload) + } pollRudpAfterSend(transport, 250) println("""{"status":"ok"}""") return diff --git a/packages/cultnet-rs/examples/cultnet_interop_peer.rs b/packages/cultnet-rs/examples/cultnet_interop_peer.rs index 6bc5dbe8..a9ed210e 100644 --- a/packages/cultnet-rs/examples/cultnet_interop_peer.rs +++ b/packages/cultnet-rs/examples/cultnet_interop_peer.rs @@ -466,6 +466,9 @@ fn rudp_serve_once(options: &BTreeMap) -> Result<()> { .get("server-payload") .map(|value| value.as_bytes().to_vec()) .unwrap_or_else(|| b"rust-server-state".to_vec()); + let server_extra_payload = options + .get("server-extra-payload") + .map(|value| value.as_bytes().to_vec()); let max_fragment_bytes = options .get("max-fragment-bytes") .map(|value| value.parse::()) @@ -498,6 +501,9 @@ fn rudp_serve_once(options: &BTreeMap) -> Result<()> { )); } transport.send("schema", server_payload.clone())?; + if let Some(extra_payload) = &server_extra_payload { + transport.send("schema", extra_payload.clone())?; + } poll_rudp_after_send(&mut transport, Duration::from_millis(250))?; print_json(&serde_json::json!({ "status": "ok" }))?; return Ok(()); diff --git a/packages/cultnet-rs/src/rudp.rs b/packages/cultnet-rs/src/rudp.rs index 22c5e8c4..edacae61 100644 --- a/packages/cultnet-rs/src/rudp.rs +++ b/packages/cultnet-rs/src/rudp.rs @@ -277,6 +277,10 @@ impl CultNetRudpSession { ) -> Result { self.require_connection(packet)?; self.apply_acknowledgements(packet); + let expected_sequence_if_uninitialized = self + .highest_received_sequence + .map(|sequence| sequence + 1) + .unwrap_or(packet.sequence); if packet.packet_type == CultNetRudpPacketType::Accept { self.remember_received(packet.sequence); @@ -335,7 +339,7 @@ impl CultNetRudpSession { }); }; let delivered = if ordered { - self.deliver_ordered(frame, next_sequence) + self.deliver_ordered(frame, next_sequence, expected_sequence_if_uninitialized) } else { vec![frame] }; @@ -548,18 +552,21 @@ impl CultNetRudpSession { &mut self, frame: CultNetRudpDeliveredFrame, next_sequence_after_frame: u32, + expected_sequence_if_uninitialized: u32, ) -> Vec { let channel_id = frame.channel_id.clone(); - let Some(next) = self + let next = if let Some(next) = self .ordered_next_sequence_by_channel .get(&channel_id) .copied() - else { - self.ordered_next_sequence_by_channel - .insert(channel_id.clone(), next_sequence_after_frame); - let mut delivered = vec![frame]; - delivered.extend(self.drain_ordered(&channel_id)); - return delivered; + { + next + } else { + self.ordered_next_sequence_by_channel.insert( + channel_id.clone(), + expected_sequence_if_uninitialized.min(frame.sequence), + ); + expected_sequence_if_uninitialized.min(frame.sequence) }; if frame.sequence < next { diff --git a/packages/cultnet-ts/src/rudp.ts b/packages/cultnet-ts/src/rudp.ts index e32081d4..4502309d 100644 --- a/packages/cultnet-ts/src/rudp.ts +++ b/packages/cultnet-ts/src/rudp.ts @@ -240,6 +240,9 @@ export class CultNetRudpSession { receive(packet: CultNetRudpPacket, nowMs = 0): CultNetRudpReceiveResult { this.#requireConnection(packet); this.#applyAcknowledgements(packet); + const expectedSequenceIfUninitialized = this.#highestReceivedSequence === undefined + ? packet.sequence + : this.#highestReceivedSequence + 1; if (packet.packetType === "accept") { this.#rememberReceived(packet.sequence); @@ -283,7 +286,7 @@ export class CultNetRudpSession { return { delivered: [reassembled.frame] }; } - return { delivered: this.#deliverOrdered(reassembled.frame, reassembled.nextSequence) }; + return { delivered: this.#deliverOrdered(reassembled.frame, reassembled.nextSequence, expectedSequenceIfUninitialized) }; } createAck(): CultNetRudpPacket { @@ -449,14 +452,15 @@ export class CultNetRudpSession { }; } - #deliverOrdered(frame: CultNetRudpDeliveredFrame, nextSequence: number): CultNetRudpDeliveredFrame[] { - const next = this.#orderedNextSequenceByChannel.get(frame.channelId); + #deliverOrdered( + frame: CultNetRudpDeliveredFrame, + nextSequence: number, + expectedSequenceIfUninitialized: number, + ): CultNetRudpDeliveredFrame[] { + let next = this.#orderedNextSequenceByChannel.get(frame.channelId); if (next === undefined) { - this.#orderedNextSequenceByChannel.set(frame.channelId, nextSequence); - return [ - frame, - ...this.#drainOrdered(frame.channelId), - ]; + next = Math.min(expectedSequenceIfUninitialized, frame.sequence); + this.#orderedNextSequenceByChannel.set(frame.channelId, next); } if (frame.sequence < next) { diff --git a/packages/cultnet-ts/test/interop/cultnet-interop.test.ts b/packages/cultnet-ts/test/interop/cultnet-interop.test.ts index a8117a87..422f948a 100644 --- a/packages/cultnet-ts/test/interop/cultnet-interop.test.ts +++ b/packages/cultnet-ts/test/interop/cultnet-interop.test.ts @@ -81,6 +81,7 @@ interface RudpServerInteropPeerSpec { interface RudpServerSpawnOptions { clientPayload?: string; serverPayload?: string; + serverExtraPayload?: string; maxFragmentBytes?: number; } @@ -138,6 +139,8 @@ from cultnet_py import ( expected_client_payload = os.environ.get("RUDP_CLIENT_PAYLOAD", "client-state").encode() server_payload = os.environ.get("RUDP_SERVER_PAYLOAD", "python-state").encode() +server_extra_payload_raw = os.environ.get("RUDP_SERVER_EXTRA_PAYLOAD") +server_extra_payload = server_extra_payload_raw.encode() if server_extra_payload_raw else None max_fragment_bytes_raw = os.environ.get("RUDP_MAX_FRAGMENT_BYTES") max_fragment_bytes = int(max_fragment_bytes_raw) if max_fragment_bytes_raw else None @@ -166,6 +169,8 @@ while time.time() < deadline: transport.close() raise SystemExit(f"unexpected RUDP frame: {frame.channel_id!r} {frame.payload!r}") transport.send("schema", server_payload) + if server_extra_payload is not None: + transport.send("schema", server_extra_payload) print("OK", flush=True) ack_deadline = time.time() + 0.25 while time.time() < ack_deadline: @@ -1166,6 +1171,123 @@ test("CultNet RUDP reliable schema response survives one dropped server data pac } }); +test("CultNet RUDP reliable schema delivery survives reordered client data packets across runtimes", async () => { + for (const peer of rudpServerInteropPeers()) { + await peer.build(); + const serverPeer = peer.spawn(); + const clientSocket = await bindUdpSocket(); + const lossyBridge = await createRudpLossyBridge({ + remoteHost: "127.0.0.1", + remotePort: await serverPeer.ready, + shouldDelayClientPacket: (wire) => { + const packet = decodeRudpPacket(wire); + return packet.packetType === "data" + && packet.channelId === "schema" + && Buffer.from(packet.payload ?? []).equals(Buffer.from(peer.clientPayload)); + }, + }); + let client: CultNetRudpSocketTransportConnection | undefined; + + try { + client = new CultNetRudpSocketTransportConnection({ + runtimeId: `ts-reordered-${peer.name.replace(/\W/g, "").toLowerCase()}-rudp-interop`, + socket: clientSocket, + mode: "client", + remoteHost: "127.0.0.1", + remotePort: lossyBridge.port, + connectionId: peer.connectionId, + initialSequence: 1, + resendDelayMs: 25, + resendPollMs: 5, + }); + + const receivedFrame = once(client, "frame"); + client.connect(Buffer.from(peer.joinPayload)); + await waitFor(() => client?.connected === true, `TypeScript RUDP client to complete ${peer.name} handshake through reorder bridge`); + client.send("schema", Buffer.from(peer.clientPayload)); + client.send("schema", Buffer.from(`${peer.clientPayload}:second`)); + + const [frame] = await withTimeout(receivedFrame, 2_000, `${peer.name} RUDP response frame after reordered client data packets`); + assert.equal(frame.channelId, "schema"); + assert.deepEqual(Buffer.from(frame.payload), Buffer.from(peer.expectedPayload)); + assert.equal(lossyBridge.delayedClientPackets, 1, `${peer.name} bridge should delay exactly one client data packet`); + + const [exitCode] = await withTimeout(once(serverPeer.child, "exit"), 2_000, `${peer.name} RUDP peer exit after reordered delivery`); + assert.equal(exitCode, 0, serverPeer.stderr.join("")); + } finally { + if (client) { + client.close(); + } else { + clientSocket.close(); + } + lossyBridge.close(); + if (serverPeer.child.exitCode === null && !serverPeer.child.killed) { + serverPeer.child.kill("SIGTERM"); + await once(serverPeer.child, "exit").catch(() => undefined); + } + } + } +}); + +test("CultNet RUDP reliable schema response survives reordered server data packets across runtimes", async () => { + for (const peer of rudpServerInteropPeers()) { + await peer.build(); + const serverPeer = peer.spawn({ + serverExtraPayload: `${peer.expectedPayload}:second`, + }); + const clientSocket = await bindUdpSocket(); + const lossyBridge = await createRudpLossyBridge({ + remoteHost: "127.0.0.1", + remotePort: await serverPeer.ready, + shouldDelayServerPacket: (wire) => { + const packet = decodeRudpPacket(wire); + return packet.packetType === "data" + && packet.channelId === "schema" + && Buffer.from(packet.payload ?? []).equals(Buffer.from(peer.expectedPayload)); + }, + }); + let client: CultNetRudpSocketTransportConnection | undefined; + + try { + client = new CultNetRudpSocketTransportConnection({ + runtimeId: `ts-server-reordered-${peer.name.replace(/\W/g, "").toLowerCase()}-rudp-interop`, + socket: clientSocket, + mode: "client", + remoteHost: "127.0.0.1", + remotePort: lossyBridge.port, + connectionId: peer.connectionId, + initialSequence: 1, + resendDelayMs: 25, + resendPollMs: 5, + }); + + const receivedFrame = once(client, "frame"); + client.connect(Buffer.from(peer.joinPayload)); + await waitFor(() => client?.connected === true, `TypeScript RUDP client to complete ${peer.name} handshake through server reorder bridge`); + client.send("schema", Buffer.from(peer.clientPayload)); + + const [frame] = await withTimeout(receivedFrame, 2_000, `${peer.name} RUDP response frame after reordered server data packets`); + assert.equal(frame.channelId, "schema"); + assert.deepEqual(Buffer.from(frame.payload), Buffer.from(peer.expectedPayload)); + assert.equal(lossyBridge.delayedServerPackets, 1, `${peer.name} bridge should delay exactly one server data packet`); + + const [exitCode] = await withTimeout(once(serverPeer.child, "exit"), 2_000, `${peer.name} RUDP peer exit after server reorder`); + assert.equal(exitCode, 0, serverPeer.stderr.join("")); + } finally { + if (client) { + client.close(); + } else { + clientSocket.close(); + } + lossyBridge.close(); + if (serverPeer.child.exitCode === null && !serverPeer.child.killed) { + serverPeer.child.kill("SIGTERM"); + await once(serverPeer.child, "exit").catch(() => undefined); + } + } + } +}); + test("CultNet RUDP fragmented schema frames cross runtime boundaries", async () => { for (const peer of rudpServerInteropPeers()) { await peer.build(); @@ -1378,6 +1500,7 @@ function spawnPythonRudpPeer(options: RudpServerSpawnOptions = {}): RunningPytho PYTHONPATH: cultcachePySrc, ...(options.clientPayload ? { RUDP_CLIENT_PAYLOAD: options.clientPayload } : {}), ...(options.serverPayload ? { RUDP_SERVER_PAYLOAD: options.serverPayload } : {}), + ...(options.serverExtraPayload ? { RUDP_SERVER_EXTRA_PAYLOAD: options.serverExtraPayload } : {}), ...(options.maxFragmentBytes ? { RUDP_MAX_FRAGMENT_BYTES: String(options.maxFragmentBytes) } : {}), }, stdio: ["ignore", "pipe", "pipe"], @@ -1430,6 +1553,7 @@ function spawnRustRudpServer(options: RudpServerSpawnOptions = {}): RunningPytho "--bind-host", "127.0.0.1", ...(options.clientPayload ? ["--client-payload", options.clientPayload] : []), ...(options.serverPayload ? ["--server-payload", options.serverPayload] : []), + ...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []), ...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []), ], { cwd: cultnetRsRoot, @@ -1487,6 +1611,7 @@ function spawnCSharpRudpServer(options: RudpServerSpawnOptions = {}): RunningPyt "--bind-host", "127.0.0.1", ...(options.clientPayload ? ["--client-payload", options.clientPayload] : []), ...(options.serverPayload ? ["--server-payload", options.serverPayload] : []), + ...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []), ...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []), ], { cwd: cultLibRoot, @@ -1545,6 +1670,7 @@ function spawnKotlinRudpServer(options: RudpServerSpawnOptions = {}): RunningPyt "--bind-host", "127.0.0.1", ...(options.clientPayload ? ["--client-payload", options.clientPayload] : []), ...(options.serverPayload ? ["--server-payload", options.serverPayload] : []), + ...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []), ...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []), ], { cwd: cultLibRoot, @@ -1686,6 +1812,8 @@ interface RudpLossyBridge { port: number; readonly droppedClientPackets: number; readonly droppedServerPackets: number; + readonly delayedClientPackets: number; + readonly delayedServerPackets: number; close(): void; } @@ -1694,12 +1822,46 @@ async function createRudpLossyBridge(options: { remotePort: number; shouldDropClientPacket?: (wire: Buffer) => boolean; shouldDropServerPacket?: (wire: Buffer) => boolean; + shouldDelayClientPacket?: (wire: Buffer) => boolean; + shouldDelayServerPacket?: (wire: Buffer) => boolean; }): Promise { const socket = dgram.createSocket("udp4"); const remote = { address: options.remoteHost, port: options.remotePort }; let client: { address: string; port: number } | undefined; let droppedClientPackets = 0; let droppedServerPackets = 0; + let delayedClientPackets = 0; + let delayedServerPackets = 0; + let heldClientWire: Buffer | undefined; + let heldServerWire: Buffer | undefined; + let heldClientTimer: NodeJS.Timeout | undefined; + let heldServerTimer: NodeJS.Timeout | undefined; + + const flushHeldClient = () => { + if (!heldClientWire) { + return; + } + const wire = heldClientWire; + heldClientWire = undefined; + if (heldClientTimer) { + clearTimeout(heldClientTimer); + heldClientTimer = undefined; + } + socket.send(wire, remote.port, remote.address); + }; + + const flushHeldServer = () => { + if (!heldServerWire || !client) { + return; + } + const wire = heldServerWire; + heldServerWire = undefined; + if (heldServerTimer) { + clearTimeout(heldServerTimer); + heldServerTimer = undefined; + } + socket.send(wire, client.port, client.address); + }; socket.on("message", (wire, sender) => { if (sender.address === remote.address && sender.port === remote.port) { @@ -1707,8 +1869,15 @@ async function createRudpLossyBridge(options: { droppedServerPackets += 1; return; } + if (delayedServerPackets === 0 && options.shouldDelayServerPacket?.(wire)) { + delayedServerPackets += 1; + heldServerWire = Buffer.from(wire); + heldServerTimer = setTimeout(flushHeldServer, 25); + return; + } if (client) { socket.send(wire, client.port, client.address); + flushHeldServer(); } return; } @@ -1718,8 +1887,15 @@ async function createRudpLossyBridge(options: { droppedClientPackets += 1; return; } + if (delayedClientPackets === 0 && options.shouldDelayClientPacket?.(wire)) { + delayedClientPackets += 1; + heldClientWire = Buffer.from(wire); + heldClientTimer = setTimeout(flushHeldClient, 25); + return; + } socket.send(wire, remote.port, remote.address); + flushHeldClient(); }); await new Promise((resolveBind, rejectBind) => { @@ -1738,7 +1914,19 @@ async function createRudpLossyBridge(options: { get droppedServerPackets() { return droppedServerPackets; }, + get delayedClientPackets() { + return delayedClientPackets; + }, + get delayedServerPackets() { + return delayedServerPackets; + }, close() { + if (heldClientTimer) { + clearTimeout(heldClientTimer); + } + if (heldServerTimer) { + clearTimeout(heldServerTimer); + } socket.close(); }, }; diff --git a/src/GameCult.Networking/CultNetTransport.cs b/src/GameCult.Networking/CultNetTransport.cs index 5a8b9ec3..912bc851 100644 --- a/src/GameCult.Networking/CultNetTransport.cs +++ b/src/GameCult.Networking/CultNetTransport.cs @@ -724,6 +724,9 @@ namespace GameCult.Networking { RequireConnection(packet); ApplyAcknowledgements(packet); + var expectedSequenceIfUninitialized = _highestReceivedSequence.HasValue + ? _highestReceivedSequence.Value + 1 + : packet.Sequence; if (packet.PacketType == CultNetRudpPacketType.Accept) { @@ -774,7 +777,7 @@ namespace GameCult.Networking return new CultNetRudpReceiveResult { Delivered = reassembled.Ordered - ? DeliverOrdered(reassembled.Frame, reassembled.NextSequence) + ? DeliverOrdered(reassembled.Frame, reassembled.NextSequence, expectedSequenceIfUninitialized) : new[] { reassembled.Frame } }; } @@ -972,12 +975,15 @@ namespace GameCult.Networking }; } - private IReadOnlyList DeliverOrdered(CultNetRudpDeliveredFrame frame, uint nextSequenceAfterFrame) + private IReadOnlyList DeliverOrdered( + CultNetRudpDeliveredFrame frame, + uint nextSequenceAfterFrame, + uint expectedSequenceIfUninitialized) { if (!_orderedNextSequenceByChannel.TryGetValue(frame.ChannelId, out var next)) { - _orderedNextSequenceByChannel[frame.ChannelId] = nextSequenceAfterFrame; - return new[] { frame }.Concat(DrainOrdered(frame.ChannelId)).ToArray(); + next = Math.Min(expectedSequenceIfUninitialized, frame.Sequence); + _orderedNextSequenceByChannel[frame.ChannelId] = next; } if (frame.Sequence < next) diff --git a/tests/GameCult.Networking.InteropPeer/Program.cs b/tests/GameCult.Networking.InteropPeer/Program.cs index 88e30097..bf11cf4f 100644 --- a/tests/GameCult.Networking.InteropPeer/Program.cs +++ b/tests/GameCult.Networking.InteropPeer/Program.cs @@ -589,6 +589,9 @@ static void RudpServeOnce(Dictionary options) var serverPayload = Ascii(options.TryGetValue("server-payload", out var configuredServerPayload) ? configuredServerPayload : "csharp-server-state"); + var serverExtraPayload = options.TryGetValue("server-extra-payload", out var configuredServerExtraPayload) + ? Ascii(configuredServerExtraPayload) + : null; var maxFragmentBytes = options.TryGetValue("max-fragment-bytes", out var configuredMaxFragmentBytes) ? int.Parse(configuredMaxFragmentBytes, CultureInfo.InvariantCulture) : (int?)null; @@ -622,6 +625,10 @@ static void RudpServeOnce(Dictionary options) { RequireRudpFrameBytes(frame, "schema", expectedClientPayload); transport.Send("schema", serverPayload); + if (serverExtraPayload != null) + { + transport.Send("schema", serverExtraPayload); + } PollRudpAfterSend(transport, TimeSpan.FromMilliseconds(250)); WriteJsonLine(new { status = "ok" }); return;