Merge remote-tracking branch 'origin/main'

Author: mikhail-dcl

src/DCLPulse/InterestManagement/ParcelEncoder.cs

@@ -21,6 +21,14 @@ public ParcelEncoder(IOptions<ParcelEncoderOptions> optionsContainer)
         parcelSize =  options.ParcelSize;
     }
 
+    public int EncodeFromGlobalPosition(Vector3 globalPosition, out Vector3 localPosition)
+    {
+        int x = (int)MathF.Floor(globalPosition.X / parcelSize);
+        int z = (int)MathF.Floor(globalPosition.Z / parcelSize);
+        localPosition = new Vector3(globalPosition.X - (x * parcelSize), globalPosition.Y, globalPosition.Z - (z * parcelSize));
+        return Encode(x, z);
+    }
+
     public int Encode(int x, int z) =>
         x - minX + ((z - minZ) * width);
 

src/DCLPulse/Messaging/EmoteStartHandler.cs

@@ -18,6 +18,6 @@ public void Handle(Dictionary<PeerIndex, PeerState> peers, PeerIndex from, Clien
 
         emoteBoard.Start(from, emoteStart.EmoteId, timeProvider.MonotonicTime, durationMs);
 
-        logger.LogDebug("Peer {Peer} started emote {EmoteId}", from.Value, emoteStart.EmoteId);
+        logger.LogInformation("Peer {Peer} started emote {EmoteId}", from.Value, emoteStart.EmoteId);
     }
-}
+}

src/DCLPulse/Messaging/EmoteStopHandler.cs

@@ -18,8 +18,8 @@ public void Handle(Dictionary<PeerIndex, PeerState> peers, PeerIndex from, Clien
             return;
         }
 
-        logger.LogDebug("Peer {Peer} stopped emote", from.Value);
+        logger.LogInformation("Peer {Peer} stopped emote", from.Value);
 
         emoteBoard.Stop(from, timeProvider.MonotonicTime);
     }
-}
+}

src/DCLPulse/Messaging/PlayerStateInputHandler.cs

@@ -50,6 +50,9 @@ public void Handle(Dictionary<PeerIndex, PeerState> peers, PeerIndex from, Clien
 
         snapshotBoard.Publish(from, in snapshot);
         spatialGrid.Set(from, snapshot.GlobalPosition);
+
+        logger.LogDebug("Received input from {Peer} with position {GlobalPosition}, rotation {RotationY}, velocity {Velocity}, movement blend {MovementBlend}, anim state {AnimationFlags}",
+            from.Value, snapshot.GlobalPosition, snapshot.RotationY, snapshot.Velocity, snapshot.MovementBlend, snapshot.AnimationFlags);
     }
 
     private static bool IsSameState(in PeerSnapshot current, PlayerState incoming) =>
@@ -62,7 +65,10 @@ private static bool IsSameState(in PeerSnapshot current, PlayerState incoming) =
         && FloatEquals(current.HeadYaw, incoming.GetHeadYaw())
         && FloatEquals(current.HeadPitch, incoming.GetHeadPitch())
         && current.AnimationFlags == (PlayerAnimationFlags)incoming.StateFlags
-        && current.GlideState == incoming.GlideState;
+        && current.GlideState == incoming.GlideState
+        // Ensures that the first movement input after a teleport is always published,
+        // even if the position/state values happen to be identical
+        && !current.IsTeleport;
 
     private static bool FloatEquals(in float a, in float b) =>
         Math.Abs(a - b) < TOLERANCE;

src/DCLPulse/Messaging/ProfileAnnouncementHandler.cs

@@ -4,10 +4,13 @@
 
 namespace Pulse.Messaging;
 
-public class ProfileAnnouncementHandler(ProfileBoard profileBoard) : IMessageHandler
+public class ProfileAnnouncementHandler(ILogger<ProfileAnnouncementHandler> logger,
+    ProfileBoard profileBoard) : IMessageHandler
 {
     public void Handle(Dictionary<PeerIndex, PeerState> peers, PeerIndex from, ClientMessage message)
     {
         profileBoard.Set(from, message.ProfileAnnouncement.Version);
+
+        logger.LogInformation("Received profile announcement from {Peer}", from.Value);
     }
 }

src/DCLPulse/Messaging/ResyncRequestHandler.cs

@@ -11,5 +11,8 @@ public void Handle(Dictionary<PeerIndex, PeerState> peers, PeerIndex from, Clien
 
         state.ResyncRequests ??= new Dictionary<PeerIndex, uint>();
         state.ResyncRequests[new PeerIndex(message.Resync.SubjectId)] = message.Resync.KnownSeq;
+
+        logger.LogWarning("Received resync request from {Peer} for subject {SubjectId} with known sequence {KnownSeq}",
+            from.Value, message.Resync.SubjectId, message.Resync.KnownSeq);
     }
 }

src/DCLPulse/Messaging/TeleportHandler.cs

@@ -0,0 +1,49 @@
+using Decentraland.Common;
+using Decentraland.Pulse;
+using Pulse.InterestManagement;
+using Pulse.Peers;
+using Pulse.Peers.Simulation;
+
+namespace Pulse.Messaging;
+
+public class TeleportHandler(ILogger<TeleportHandler> logger,
+    ITimeProvider timeProvider,
+    SnapshotBoard snapshotBoard,
+    ParcelEncoder parcelEncoder)
+    : RuntimePacketHandlerBase<TeleportHandler>(logger), IMessageHandler
+{
+    public void Handle(Dictionary<PeerIndex, PeerState> peers, PeerIndex from, ClientMessage message)
+    {
+        if (SkipFromUnauthorizedPeer(peers, from, message, out _))
+            return;
+
+        Vector3 localPosition = message.Teleport.Position;
+        int parcelIndex = message.Teleport.ParcelIndex;
+        System.Numerics.Vector3 globalPosition = parcelEncoder.DecodeToGlobalPosition(parcelIndex, localPosition);
+
+        float rotationY = 0;
+        float? headYaw = null, headPitch = null;
+
+        if (snapshotBoard.TryRead(from, out PeerSnapshot prevSnapshot))
+        {
+            rotationY = prevSnapshot.RotationY;
+            headYaw = prevSnapshot.HeadYaw;
+            headPitch = prevSnapshot.HeadPitch;
+        }
+
+        var snapshot = new PeerSnapshot(snapshotBoard.LastSeq(from) + 1,
+            timeProvider.MonotonicTime,
+            parcelIndex, localPosition, globalPosition,
+            System.Numerics.Vector3.Zero,
+            rotationY,
+            JumpCount: 0, MovementBlend: 0, SlideBlend: 0,
+            headYaw, headPitch,
+            PlayerAnimationFlags.Grounded,
+            GlideState.PropClosed,
+            IsTeleport: true);
+
+        snapshotBoard.Publish(from, snapshot);
+
+        logger.LogInformation("Teleport requested by {Peer} at {Position}", from, globalPosition);
+    }
+}

src/DCLPulse/Peers/PeerSnapshot.cs

@@ -26,5 +26,8 @@ public record struct PeerSnapshot(
     float? HeadYaw,
     float? HeadPitch,
     PlayerAnimationFlags AnimationFlags,
-    GlideState GlideState
+    GlideState GlideState,
+
+    // Flags
+    bool IsTeleport = false
 );

src/DCLPulse/Peers/PeerToPeerView.cs

@@ -40,4 +40,10 @@ public struct PeerToPeerView
     ///     Compared against <see cref="Simulation.EmoteBoard" /> each tick to detect transitions.
     /// </summary>
     public string? LastSentEmoteId;
+
+    /// <summary>
+    ///     The sequence number of the last teleport snapshot sent to the observer for this subject.
+    ///     Prevents duplicate teleport broadcasts and supports consecutive teleports.
+    /// </summary>
+    public uint? LastSentTeleportSeq;
 }

src/DCLPulse/Peers/Simulation/PeerSimulation.cs

@@ -29,7 +29,6 @@ public sealed class PeerSimulation : IPeerSimulation
     private readonly SpatialGrid spatialGrid;
     private readonly IdentityBoard identityBoard;
     private readonly MessagePipe messagePipe;
-    private readonly uint[] simulationSteps;
     private readonly ITimeProvider timeProvider;
     private readonly ITransport transport;
     private readonly ProfileBoard profileBoard;
@@ -84,7 +83,6 @@ public PeerSimulation(
         this.spatialGrid = spatialGrid;
         this.identityBoard = identityBoard;
         this.messagePipe = messagePipe;
-        this.simulationSteps = simulationSteps;
         this.timeProvider = timeProvider;
         this.transport = transport;
         this.profileBoard = profileBoard;
@@ -244,7 +242,30 @@ private void ProcessVisibleSubjects(
             }
             else
             {
-                if (resyncRequests != null && resyncRequests.Remove(entry.Subject, out uint lastKnownSeq))
+                // Only announce on delta because PlayerJoined is considered as an announcement
+                TryAnnounceProfile();
+
+                if (subjectSnapshot.IsTeleport && view.LastSentTeleportSeq != subjectSnapshot.Seq)
+                {
+                    // Clear the resync since the teleport has the full player state and can fulfill it
+                    resyncRequests?.Remove(entry.Subject);
+
+                    messagePipe.Send(new OutgoingMessage(observerId, new ServerMessage
+                    {
+                        Teleported = new TeleportPerformed
+                        {
+                            SubjectId = entry.Subject,
+                            Sequence = subjectSnapshot.Seq,
+                            ServerTick = subjectSnapshot.ServerTick,
+                            State = CreatePlayerState(subjectSnapshot),
+                        }
+                    }, ITransport.PacketMode.RELIABLE));
+
+                    view.LastSentTeleportSeq = subjectSnapshot.Seq;
+
+                    logger.LogInformation($"Broadcasting teleport from {entry.Subject} to {observerId} at {subjectSnapshot.GlobalPosition}");
+                }
+                else if (resyncRequests != null && resyncRequests.Remove(entry.Subject, out uint lastKnownSeq))
                 {
                     // 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.
@@ -259,9 +280,6 @@ private void ProcessVisibleSubjects(
                 }
                 else
                     SendDelta(view.LastSentSnapshot, ITransport.PacketMode.UNRELIABLE_SEQUENCED);
-
-                // Only announce on delta because PlayerJoined is considered as an announcement
-                TryAnnounceProfile();
             }
 
             SyncEmoteState();