feat: support scene named spawn points

Explorer/Assets/DCL/Character/CharacterMotion/Components/PlayerTeleportIntent.cs

@@ -35,6 +35,12 @@ public JustTeleported(int expireFrame, Vector2Int parcel)
         /// </summary>
         public bool LandOnParcel;
 
+        /// <summary>
+        ///     When set, land at the scene's spawn point with this name (case-insensitive) instead of
+        ///     the default/closest one; an unmatched name falls back to the default selection.
+        /// </summary>
+        public readonly string? SpawnPointName;
+
         /// <summary>
         ///     Strictly it's the same report added to "SceneReadinessReportQueue" <br />
         ///     Teleport operation will wait for this report to be resolved before finishing the teleport operation <br />
@@ -44,7 +50,7 @@ public JustTeleported(int expireFrame, Vector2Int parcel)
 
         public bool TimedOut => UnityEngine.Time.realtimeSinceStartup - creationTime > TIMEOUT.TotalSeconds;
 
-        public PlayerTeleportIntent(SceneEntityDefinition? sceneDef, Vector2Int parcel, Vector3 position, CancellationToken cancellationToken, AsyncLoadProcessReport? assetsResolution = null, bool isPositionSet = false, bool landOnParcel = false)
+        public PlayerTeleportIntent(SceneEntityDefinition? sceneDef, Vector2Int parcel, Vector3 position, CancellationToken cancellationToken, AsyncLoadProcessReport? assetsResolution = null, bool isPositionSet = false, bool landOnParcel = false, string? spawnPointName = null)
         {
             Parcel = parcel;
             CancellationToken = cancellationToken;
@@ -54,6 +60,7 @@ public PlayerTeleportIntent(SceneEntityDefinition? sceneDef, Vector2Int parcel,
             IsPositionSet = isPositionSet;
             Position = position;
             LandOnParcel = landOnParcel;
+            SpawnPointName = spawnPointName;
         }
     }
 }

Explorer/Assets/DCL/Character/CharacterMotion/Systems/TeleportPositionCalculationSystem.cs

@@ -69,14 +69,14 @@ private void CalculateTeleportPosition(in Entity playerEntity, ref PlayerTelepor
                 // Anchor the height on the scene's spawn point as a best guess: the exact parcel floor
                 // isn't knowable yet (the scene's colliders load later), so TeleportCharacterSystem
                 // snaps the avatar onto the floor once the scene is ready.
-                (Vector3 spawnTarget, _) = TeleportUtils.PickTargetWithOffset(sceneDef, parcel);
+                (Vector3 spawnTarget, _) = TeleportUtils.PickTargetWithOffset(sceneDef, parcel, teleportIntent.SpawnPointName);
                 targetWorldPosition.y = spawnTarget.y;
 
                 teleportIntent.Position = targetWorldPosition;
             }
             else
             {
-                (Vector3 targetWorldPosition, Vector3? cameraTarget) = TeleportUtils.PickTargetWithOffset(sceneDef, parcel);
+                (Vector3 targetWorldPosition, Vector3? cameraTarget) = TeleportUtils.PickTargetWithOffset(sceneDef, parcel, teleportIntent.SpawnPointName);
 
                 var originalTargetPosition = targetWorldPosition;
 

Explorer/Assets/DCL/Chat/Commands/ChatParamUtils.cs

@@ -29,5 +29,49 @@ public static Vector2Int ParseRawPosition(string param)
             string[] coords = param.Split(',');
             return new Vector2Int(int.Parse(coords[0]), int.Parse(coords[1]));
         }
+
+        /// <summary>
+        /// Parses the single /goto argument into a <see cref="GotoTarget" />.
+        /// Grammar: "random" | "crowd" | "x,y" | "x,y/spawn" | "world" | "world/x,y" | "world/spawn" | "world/x,y/spawn".
+        /// A spawn point name contains neither ',' nor '/'.
+        /// Anything that matches none of the forms is treated verbatim as a world name.
+        /// </summary>
+        public static GotoTarget ParseGotoTarget(string param)
+        {
+            if (param == PARAMETER_RANDOM)
+                return new GotoTarget(world: null, parcel: null, spawnPoint: null, isRandom: true);
+
+            if (param == PARAMETER_CROWD)
+                return new GotoTarget(world: null, parcel: null, spawnPoint: null, isCrowd: true);
+
+            if (IsPositionParameter(param, false))
+                return new GotoTarget(world: null, parcel: ParseRawPosition(param), spawnPoint: null);
+
+            string[] segments = param.Split('/');
+
+            if (segments.Length == 2 && segments[0].Length > 0)
+            {
+                string head = segments[0];
+                string tail = segments[1];
+
+                if (IsPositionParameter(head, false) && IsSpawnPointName(tail))
+                    return new GotoTarget(world: null, parcel: ParseRawPosition(head), spawnPoint: tail);
+
+                if (IsPositionParameter(tail, false))
+                    return new GotoTarget(world: head, parcel: ParseRawPosition(tail), spawnPoint: null);
+
+                if (IsSpawnPointName(tail))
+                    return new GotoTarget(world: head, parcel: null, spawnPoint: tail);
+            }
+
+            if (segments.Length == 3 && segments[0].Length > 0
+                && IsPositionParameter(segments[1], false) && IsSpawnPointName(segments[2]))
+                return new GotoTarget(world: segments[0], parcel: ParseRawPosition(segments[1]), spawnPoint: segments[2]);
+
+            return new GotoTarget(world: param, parcel: null, spawnPoint: null);
+        }
+
+        public static bool IsSpawnPointName(string segment) =>
+            segment.Length > 0 && segment.IndexOf(',') < 0 && segment.IndexOf('/') < 0;
     }
 }

Explorer/Assets/DCL/Chat/Commands/ChatTeleporter.cs

@@ -3,6 +3,7 @@
 using DCL.CommunicationData.URLHelpers;
 using DCL.Multiplayer.Connections.DecentralandUrls;
 using DCL.Utility.Types;
+using ECS.SceneLifeCycle;
 using ECS.SceneLifeCycle.Realm;
 using System;
 using System.Collections.Generic;
@@ -19,13 +20,15 @@ public class ChatTeleporter
         private const string WORLD_SUFFIX = ".dcl.eth";
 
         private readonly IRealmNavigator realmNavigator;
+        private readonly IScenesCache scenesCache;
         private readonly Dictionary<string, string> paramUrls;
         private readonly ChatEnvironmentValidator environmentValidator;
         private readonly URLDomain worldDomain;
 
-        public ChatTeleporter(IRealmNavigator realmNavigator, ChatEnvironmentValidator environmentValidator, IDecentralandUrlsSource decentralandUrlsSource)
+        public ChatTeleporter(IRealmNavigator realmNavigator, ChatEnvironmentValidator environmentValidator, IDecentralandUrlsSource decentralandUrlsSource, IScenesCache scenesCache)
         {
             this.realmNavigator = realmNavigator;
+            this.scenesCache = scenesCache;
             this.environmentValidator = environmentValidator;
             worldDomain = URLDomain.FromString(decentralandUrlsSource.Url(DecentralandUrl.WorldServer));
 
@@ -40,17 +43,22 @@ public ChatTeleporter(IRealmNavigator realmNavigator, ChatEnvironmentValidator e
             };
         }
 
-        public async UniTask<string> TeleportToRealmAsync(string realm, CancellationToken ct)
+        public async UniTask<string> TeleportToRealmAsync(string realm, CancellationToken ct, string? spawnPointName = null)
         {
             ExtractWorldData(realm, out URLDomain realmURL, out bool isWorld);
 
             if(!ValidEnvironment(realmURL, out string errorMessage))
                 return errorMessage;
 
             if (realmNavigator.IsAlreadyOnRealm(realmURL))
-                return $"🟡 You are already in {realm}!";
+            {
+                if (spawnPointName == null)
+                    return $"🟡 You are already in {realm}!";
+
+                return await TeleportToParcelAsync(scenesCache.CurrentParcel.Value, true, ct, spawnPointName);
+            }
 
-            var result = await realmNavigator.TryChangeRealmAsync(realmURL, ct, default, isWorld, true);
+            var result = await realmNavigator.TryChangeRealmAsync(realmURL, ct, default, isWorld, true, spawnPointName: spawnPointName);
 
             if (result.Success)
                 return $"🟢 Welcome to the {realm} world!";
@@ -75,17 +83,17 @@ public async UniTask<string> TeleportToRealmAsync(string realm, CancellationToke
         /// <summary>
         /// Parses the realm and teleports the player to it, with an optional target position.
         /// </summary>
-        public async UniTask<string> TeleportToRealmAsync(string realm, Vector2Int targetPosition, CancellationToken ct)
+        public async UniTask<string> TeleportToRealmAsync(string realm, Vector2Int targetPosition, CancellationToken ct, string? spawnPointName = null)
         {
             ExtractWorldData(realm, out URLDomain realmURL, out bool isWorld);
 
             if(!ValidEnvironment(realmURL, out string errorMessage))
                 return errorMessage;
 
             if(realmNavigator.IsAlreadyOnRealm(realmURL))
-                return await TeleportToParcelAsync(targetPosition, true, ct);
+                return await TeleportToParcelAsync(targetPosition, true, ct, spawnPointName);
 
-            var result = await realmNavigator.TryChangeRealmAsync(realmURL, ct, targetPosition, isWorld, false);
+            var result = await realmNavigator.TryChangeRealmAsync(realmURL, ct, targetPosition, isWorld, false, spawnPointName: spawnPointName);
 
             if (result.Success)
                 return $"🟢 Welcome to the {realm} world!";
@@ -154,9 +162,9 @@ private void ExtractWorldData(string realm, out URLDomain realmURL, out bool isW
         /// <summary>
         /// Teleports the player to a parcel.
         /// </summary>
-        public async UniTask<string> TeleportToParcelAsync(Vector2Int targetPosition, bool local, CancellationToken ct)
+        public async UniTask<string> TeleportToParcelAsync(Vector2Int targetPosition, bool local, CancellationToken ct, string? spawnPointName = null)
         {
-            var result = await realmNavigator.TeleportToParcelAsync(targetPosition, ct, local);
+            var result = await realmNavigator.TeleportToParcelAsync(targetPosition, ct, local, spawnPointName: spawnPointName);
 
             if (result.Success)
                 return $"🟢 You teleported to {targetPosition.x},{targetPosition.y}.";

Explorer/Assets/DCL/Chat/Commands/GoToChatCommand.cs

@@ -15,15 +15,18 @@ namespace DCL.Chat.Commands
     ///
     /// Usage:
     ///     /goto *x,y*          — teleport to parcel
+    ///     /goto *x,y/name*     — teleport to parcel, landing at the named spawn point
     ///     /goto random         — teleport to a random parcel
     ///     /goto crowd          — teleport to the most populated scene
     ///     /goto *world*        — teleport to a world
     ///     /goto *world/x,y*    — teleport to a world at specific parcel
+    ///     /goto *world/name*   — teleport to a world, landing at the named spawn point
+    ///     /goto *world/x,y/name* — teleport to a world at specific parcel, landing at the named spawn point
     /// </summary>
     public class GoToChatCommand : IChatCommand
     {
         public string Command => "goto";
-        public string Description => "<b>/goto <i><x,y | random | crowd | world | world/x,y></i></b>\n  Teleport inside of Genesis or World";
+        public string Description => "<b>/goto <i><x,y | x,y/spawn | random | crowd | world | world/x,y | world/spawn | world/x,y/spawn></i></b>\n  Teleport inside of Genesis or World";
 
         private readonly ChatTeleporter chatTeleporter;
         private readonly IWebRequestController webRequestController;
@@ -41,43 +44,29 @@ public bool ValidateParameters(string[] parameters) =>
 
         public async UniTask<string> ExecuteCommandAsync(string[] parameters, CancellationToken ct)
         {
-            if (ChatParamUtils.IsPositionParameter(parameters[0], true))
-                return await chatTeleporter.TeleportToParcelAsync(await GetPositionAsync(parameters[0], ct), false, ct);
+            GotoTarget target = ChatParamUtils.ParseGotoTarget(parameters[0]);
 
-            if (TryParseWorldWithPosition(parameters[0], out string world, out string position))
-                return await chatTeleporter.TeleportToRealmAsync(world, ChatParamUtils.ParseRawPosition(position), ct);
+            if (target.IsRandom)
+                return await chatTeleporter.TeleportToParcelAsync(GetRandomParcel(), false, ct);
 
-            return await chatTeleporter.TeleportToRealmAsync(parameters[0], ct);
-        }
+            if (target.IsCrowd)
+                return await chatTeleporter.TeleportToParcelAsync(await FindCrowdAsync(ct), false, ct);
 
-        private static bool TryParseWorldWithPosition(string param, out string world, out string position)
-        {
-            int slashIndex = param.IndexOf('/');
+            if (target.World != null)
+                return target.Parcel.HasValue
+                    ? await chatTeleporter.TeleportToRealmAsync(target.World, target.Parcel.Value, ct, target.SpawnPoint)
+                    : await chatTeleporter.TeleportToRealmAsync(target.World, ct, target.SpawnPoint);
 
-            if (slashIndex > 0 && slashIndex < param.Length - 1)
-            {
-                world = param.Substring(0, slashIndex);
-                position = param.Substring(slashIndex + 1);
-                return ChatParamUtils.IsPositionParameter(position, false);
-            }
+            if (target.Parcel is { } parcel)
+                return await chatTeleporter.TeleportToParcelAsync(parcel, false, ct, target.SpawnPoint);
 
-            world = null;
-            position = null;
-            return false;
+            return $"🔴 Invalid parameters, usage:\n{Description}";
         }
 
-        private UniTask<Vector2Int> GetPositionAsync(string positionParameter, CancellationToken ct)
-        {
-            return positionParameter switch
-                   {
-                       ChatParamUtils.PARAMETER_RANDOM => UniTask.FromResult(new Vector2Int(
-                           Random.Range(GenesisCityData.MIN_PARCEL.x, GenesisCityData.MAX_SQUARE_CITY_PARCEL.x),
-                           Random.Range(GenesisCityData.MIN_PARCEL.y, GenesisCityData.MAX_SQUARE_CITY_PARCEL.y))
-                       ),
-                       ChatParamUtils.PARAMETER_CROWD => FindCrowdAsync(ct),
-                       _ => UniTask.FromResult(ChatParamUtils.ParseRawPosition(positionParameter))
-                   };
-        }
+        private static Vector2Int GetRandomParcel() =>
+            new (
+                Random.Range(GenesisCityData.MIN_PARCEL.x, GenesisCityData.MAX_SQUARE_CITY_PARCEL.x),
+                Random.Range(GenesisCityData.MIN_PARCEL.y, GenesisCityData.MAX_SQUARE_CITY_PARCEL.y));
 
         private async UniTask<Vector2Int> FindCrowdAsync(CancellationToken ct)
         {

Explorer/Assets/DCL/Chat/Commands/GoToLocalChatCommand.cs

@@ -1,4 +1,5 @@
 using Cysharp.Threading.Tasks;
+using ECS.SceneLifeCycle;
 using System.Threading;
 
 namespace DCL.Chat.Commands
@@ -7,24 +8,45 @@ namespace DCL.Chat.Commands
     /// Teleports the player to a specific position inside the current realm.
     ///
     /// Usage:
-    ///     /goto-local *x,y*
+    ///     /goto-local *x,y*        — teleport to parcel
+    ///     /goto-local *x,y/name*   — teleport to parcel, landing at the named spawn point
+    ///     /goto-local *name*       — teleport to the named spawn point of the current scene
     /// </summary>
     public class GoToLocalChatCommand : IChatCommand
     {
         public string Command => "goto-local";
-        public string Description => "<b>/goto-local <i><x,y></i></b>\n  Teleport inside of the current realm";
+        public string Description => "<b>/goto-local <i><x,y | x,y/spawn | spawn></i></b>\n  Teleport inside of the current realm";
 
         private readonly ChatTeleporter chatTeleporter;
+        private readonly IScenesCache scenesCache;
 
-        public GoToLocalChatCommand(ChatTeleporter chatTeleporter)
+        public GoToLocalChatCommand(ChatTeleporter chatTeleporter, IScenesCache scenesCache)
         {
             this.chatTeleporter = chatTeleporter;
+            this.scenesCache = scenesCache;
         }
 
-        public bool ValidateParameters(string[] parameters) =>
-            parameters.Length == 1 && ChatParamUtils.IsPositionParameter(parameters[0], false);
+        public bool ValidateParameters(string[] parameters)
+        {
+            if (parameters.Length != 1)
+                return false;
+
+            GotoTarget target = ChatParamUtils.ParseGotoTarget(parameters[0]);
+
+            if (target.World == null)
+                return target.Parcel.HasValue;
+
+            // A bare name (parsed as a world) targets a spawn point of the scene the player stands in
+            return target.Parcel == null && target.SpawnPoint == null && ChatParamUtils.IsSpawnPointName(target.World);
+        }
+
+        public UniTask<string> ExecuteCommandAsync(string[] parameters, CancellationToken ct)
+        {
+            GotoTarget target = ChatParamUtils.ParseGotoTarget(parameters[0]);
 
-        public UniTask<string> ExecuteCommandAsync(string[] parameters, CancellationToken ct) =>
-            chatTeleporter.TeleportToParcelAsync(ChatParamUtils.ParseRawPosition(parameters[0]), true, ct);
+            return target.Parcel.HasValue
+                ? chatTeleporter.TeleportToParcelAsync(target.Parcel.Value, true, ct, target.SpawnPoint)
+                : chatTeleporter.TeleportToParcelAsync(scenesCache.CurrentParcel.Value, true, ct, target.World);
+        }
     }
 }

Explorer/Assets/DCL/Chat/Commands/GotoTarget.cs

@@ -0,0 +1,28 @@
+using UnityEngine;
+
+namespace DCL.Chat.Commands
+{
+    /// <summary>
+    /// Parsed target of the /goto command, produced by <see cref="ChatParamUtils.ParseGotoTarget" />.
+    /// Exactly one shape is set: a Genesis parcel (<see cref="Parcel" />, optionally with
+    /// <see cref="SpawnPoint" />), a world (<see cref="World" />, optionally with <see cref="Parcel" />
+    /// and/or <see cref="SpawnPoint" />), or one of the special flags <see cref="IsRandom" /> / <see cref="IsCrowd" />.
+    /// </summary>
+    public readonly struct GotoTarget
+    {
+        public readonly string? World;
+        public readonly Vector2Int? Parcel;
+        public readonly string? SpawnPoint;
+        public readonly bool IsRandom;
+        public readonly bool IsCrowd;
+
+        public GotoTarget(string? world, Vector2Int? parcel, string? spawnPoint, bool isRandom = false, bool isCrowd = false)
+        {
+            World = world;
+            Parcel = parcel;
+            SpawnPoint = spawnPoint;
+            IsRandom = isRandom;
+            IsCrowd = isCrowd;
+        }
+    }
+}