fix resync flow & skip duplicated inputs

Author: lorux0

src/DCLPulse/Messaging/PlayerStateInputHandler.cs

@@ -14,31 +14,58 @@ public class PlayerStateInputHandler(
     ParcelEncoder parcelEncoder)
     : RuntimePacketHandlerBase<PlayerStateInputHandler>(logger), IMessageHandler
 {
+    private const float TOLERANCE = 0.001f;
+
     public void Handle(Dictionary<PeerIndex, PeerState> peers, PeerIndex from, ClientMessage message)
     {
         if (SkipFromUnauthorizedPeer(peers, from, message, out _))
             return;
 
         PlayerStateInput input = message.Input;
+        PlayerState state = input.State;
+
+        // Skip publishing if the state hasn't changed. Without this, seq increments on every
+        // input message even when the peer is idle, causing observers to receive deltas with
+        // non-contiguous sequences (gaps from suppressed no-diff deltas) and triggering more resync loops.
+        if (snapshotBoard.TryRead(from, out PeerSnapshot current) && IsSameState(current, state))
+            return;
 
-        Vector3 globalPeerPosition = parcelEncoder.DecodeToGlobalPosition(input.State.ParcelIndex, input.State.Position);
+        Vector3 globalPeerPosition = parcelEncoder.DecodeToGlobalPosition(state.ParcelIndex, state.Position);
 
         var snapshot = new PeerSnapshot(
             snapshotBoard.LastSeq(from) + 1,
             timeProvider.MonotonicTime,
-            input.State.ParcelIndex,
-            input.State.Position,
+            state.ParcelIndex,
+            state.Position,
             globalPeerPosition,
-            input.State.Velocity,
-            input.State.RotationY,
-            input.State.MovementBlend,
-            input.State.SlideBlend,
-            input.State.GetHeadYaw(),
-            input.State.GetHeadPitch(),
-            (PlayerAnimationFlags)input.State.StateFlags,
-            input.State.GlideState);
+            state.Velocity,
+            state.RotationY,
+            state.MovementBlend,
+            state.SlideBlend,
+            state.GetHeadYaw(),
+            state.GetHeadPitch(),
+            (PlayerAnimationFlags)state.StateFlags,
+            state.GlideState);
 
         snapshotBoard.Publish(from, in snapshot);
         spatialGrid.Set(from, snapshot.GlobalPosition);
     }
+
+    private static bool IsSameState(in PeerSnapshot current, PlayerState incoming) =>
+        current.Parcel == incoming.ParcelIndex
+        && current.LocalPosition == (Vector3)incoming.Position
+        && current.Velocity == (Vector3)incoming.Velocity
+        && FloatEquals(current.RotationY, incoming.RotationY)
+        && FloatEquals(current.MovementBlend, incoming.MovementBlend)
+        && FloatEquals(current.SlideBlend, incoming.SlideBlend)
+        && FloatEquals(current.HeadYaw, incoming.GetHeadYaw())
+        && FloatEquals(current.HeadPitch, incoming.GetHeadPitch())
+        && current.AnimationFlags == (PlayerAnimationFlags)incoming.StateFlags
+        && current.GlideState == incoming.GlideState;
+
+    private static bool FloatEquals(in float a, in float b) =>
+        Math.Abs(a - b) < TOLERANCE;
+
+    private static bool FloatEquals(float? a, float? b) =>
+        (!a.HasValue && !b.HasValue) || (a.HasValue && b.HasValue && Math.Abs(a.Value - b.Value) < TOLERANCE);
 }

src/DCLPulse/Peers/Simulation/PeerSimulation.cs

@@ -217,18 +217,15 @@ private void ProcessVisibleSubjects(
             }
             else
             {
-                if (resyncRequests != null && resyncRequests.Remove(entry.Subject, out uint lastKnownSeq))
+                if (resyncRequests != null && resyncRequests.Remove(entry.Subject, out _))
                 {
-                    // Try a targeted delta from the client's baseline; fall back to full state
-                    // if the baseline is evicted, the seq hasn't advanced, or all fields are within epsilon.
-                    if (!snapshotBoard.TryRead(entry.Subject, lastKnownSeq, out PeerSnapshot knownSnapshot)
-                        || !SendDelta(knownSnapshot, ITransport.PacketMode.RELIABLE))
+                    // Always respond with STATE_FULL, never a delta. The client uses the
+                    // message type (full vs delta) to resolve the pending resync — a delta
+                    // is indistinguishable from a normal update and won't clear the resync state.
+                    messagePipe.Send(new OutgoingMessage(observerId, new ServerMessage
                     {
-                        messagePipe.Send(new OutgoingMessage(observerId, new ServerMessage
-                        {
-                            PlayerStateFull = CreateFullState(entry.Subject, subjectSnapshot),
-                        }, ITransport.PacketMode.RELIABLE));
-                    }
+                        PlayerStateFull = CreateFullState(entry.Subject, subjectSnapshot),
+                    }, ITransport.PacketMode.RELIABLE));
                 }
                 else
                     SendDelta(view.LastSentSnapshot, ITransport.PacketMode.UNRELIABLE_SEQUENCED);
@@ -273,6 +270,8 @@ bool SendDelta(PeerSnapshot baseline, ITransport.PacketMode packetMode)
                     PlayerStateDelta = delta,
                 }, packetMode));
 
+                logger.LogInformation("Sending delta player state {Sequence} to {Observer}", delta.NewSeq, observerId);
+
                 return true;
             }
         }

src/DCLPulseTests/DrainPeerLifeCycleEventsTests.cs

@@ -37,6 +37,7 @@ public void SetUp()
             new IdentityBoard(100),
             new PeerOptions(),
             Substitute.For<ILogger<PeersManager>>(),
+            Substitute.For<ILogger<PeerSimulation>>(),
             timeProvider,
             new Dictionary<ClientMessage.MessageOneofCase, IMessageHandler>(),
             Substitute.For<ITransport>(),

src/DCLPulseTests/PeerSimulationTests.Resync.cs

@@ -33,59 +33,6 @@ public void Resync_SendsFullStateWhenKnownSeqEvictedFromRing()
         Assert.That(msg.Message.PlayerStateFull.Sequence, Is.EqualTo(RING_CAPACITY + 5));
     }
 
-    [Test]
-    public void Resync_SendsTargetedDeltaWhenKnownSeqStillInRing()
-    {
-        SetVisibleSubjects((subject, PeerViewSimulationTier.TIER_0));
-        simulation.SimulateTick(peers, tickCounter: 0);
-        DrainAllMessages(); // PlayerJoined
-
-        // Advance a few seqs — all still within ring capacity
-        PublishSnapshot(subject, seq: 2);
-        PublishSnapshot(subject, seq: 3, position: new Vector3(5f, 0f, 0f));
-
-        // Observer's known_seq is 1, which is still in the ring
-        AddResyncRequest(observer, subject, knownSeq: 1);
-
-        simulation.SimulateTick(peers, tickCounter: 1);
-
-        OutgoingMessage msg = DrainSingleMessage();
-        Assert.That(msg.To, Is.EqualTo(observer));
-        Assert.That(msg.PacketMode, Is.EqualTo(ITransport.PacketMode.RELIABLE));
-        Assert.That(msg.Message.MessageCase, Is.EqualTo(ServerMessage.MessageOneofCase.PlayerStateDelta));
-        Assert.That(msg.Message.PlayerStateDelta.NewSeq, Is.EqualTo(3u));
-        Assert.That(msg.Message.PlayerStateDelta.PositionXQuantized, Is.EqualTo(5f));
-    }
-
-    [Test]
-    public void Resync_TargetedDeltaDiffsFromKnownSeqNotLastSent()
-    {
-        SetVisibleSubjects((subject, PeerViewSimulationTier.TIER_0));
-        simulation.SimulateTick(peers, tickCounter: 0);
-        DrainAllMessages(); // PlayerJoined at seq 1
-
-        // Server sends a normal delta at seq 2 (position X=10)
-        PublishSnapshot(subject, seq: 2, position: new Vector3(10f, 0f, 0f));
-        simulation.SimulateTick(peers, tickCounter: 1);
-        DrainAllMessages(); // delta seq 2, view baseline is now seq 2
-
-        // Subject moves again to seq 3 (position X=10 unchanged, Y=5 changed)
-        PublishSnapshot(subject, seq: 3, position: new Vector3(10f, 5f, 0f));
-
-        // Client says it's stuck at seq 1 (never got seq 2)
-        AddResyncRequest(observer, subject, knownSeq: 1);
-
-        simulation.SimulateTick(peers, tickCounter: 2);
-
-        OutgoingMessage msg = DrainSingleMessage();
-        Assert.That(msg.Message.MessageCase, Is.EqualTo(ServerMessage.MessageOneofCase.PlayerStateDelta));
-        Assert.That(msg.Message.PlayerStateDelta.NewSeq, Is.EqualTo(3u));
-
-        // Diff is from seq 1 (Zero) to seq 3 — both X and Y changed
-        Assert.That(msg.Message.PlayerStateDelta.PositionXQuantized, Is.EqualTo(10f));
-        Assert.That(msg.Message.PlayerStateDelta.PositionYQuantized, Is.EqualTo(5f));
-    }
-
     [Test]
     public void Resync_ViewBaselineAdvancesToCurrentAfterResync()
     {
@@ -149,29 +96,6 @@ public void Resync_LeftoversForInvisibleSubjectsClearedAfterTick()
         Assert.That(peers[observer].ResyncRequests, Is.Empty);
     }
 
-    [Test]
-    public void Resync_OnlyLatestKnownSeqKeptPerSubject()
-    {
-        SetVisibleSubjects((subject, PeerViewSimulationTier.TIER_0));
-        simulation.SimulateTick(peers, tickCounter: 0);
-        DrainAllMessages();
-
-        PublishSnapshot(subject, seq: 2, position: new Vector3(1f, 0f, 0f));
-        PublishSnapshot(subject, seq: 3, position: new Vector3(2f, 0f, 0f));
-
-        // Client sends two resyncs — only the second should matter
-        AddResyncRequest(observer, subject, knownSeq: 1);
-        AddResyncRequest(observer, subject, knownSeq: 2);
-
-        simulation.SimulateTick(peers, tickCounter: 1);
-
-        OutgoingMessage msg = DrainSingleMessage();
-        Assert.That(msg.Message.MessageCase, Is.EqualTo(ServerMessage.MessageOneofCase.PlayerStateDelta));
-
-        // Diff is from seq 2 (X=1) to seq 3 (X=2), not from seq 1
-        Assert.That(msg.Message.PlayerStateDelta.PositionXQuantized, Is.EqualTo(2f));
-    }
-
     [Test]
     public void Resync_NullResyncRequestsDoesNotCrash()
     {

src/DCLPulseTests/PeerSimulationTests.cs

@@ -70,13 +70,12 @@ public void SetUp()
 
         timeProvider = Substitute.For<ITimeProvider>();
         timeProvider.MonotonicTime.Returns(0u);
-
         profileBoard = new ProfileBoard(MAX_PEERS);
 
         simulation = new PeerSimulation(
             areaOfInterest, snapshotBoard, spatialGrid, identityBoard, messagePipe,
             SimulationSteps, timeProvider, Substitute.For<ITransport>(),
-            profileBoard);
+            profileBoard, Substitute.For<ILogger<PeerSimulation>>());
 
         peers = new Dictionary<PeerIndex, PeerState>
         {

src/DCLPulseTests/WorkerAsyncTests.cs

@@ -36,6 +36,7 @@ public void SetUp()
             new IdentityBoard(100),
             new PeerOptions(),
             Substitute.For<ILogger<PeersManager>>(),
+            Substitute.For<ILogger<PeerSimulation>>(),
             timeProvider,
             new Dictionary<ClientMessage.MessageOneofCase, IMessageHandler>(),
             Substitute.For<ITransport>(),