fix: presence, profile edits, outfit menu and RecNetResult writes for the 2023 client

Every change below was checked against the 2023-03-21 client disassembly; file:line evidence is in the code comments and in docs/recroom-2023-client-api-complete.md. Presence - matchmake/none means "online, in no room" (its only caller is TryGoToOfflineRoom, which ignores the reply). The server used to keep the old room or invent a dorm, so the next heartbeat looked out of sync and the client cancelled its load to chase that room. - The join watchdog no longer clears presence 30 s into a long room load; it is a 3 minute backstop that drops the room only. - One fan-out (PresenceBroadcastService) for every transition: deferred joins, matchmake/none, logout, failed joins, visibility changes, SignalR connect/disconnect. isOnline is sent on its own; pushes never go to the subject, because a self push moves the player. - Online-status visibility (Public / Friends / Favorites / Appear offline) is stored and honoured by GET /player and by the live pushes. Profile - PUT account/me/{emoji,personalpronouns,identityflags,bannerimage} were 404; added with the client's real form keys and persisted (new Players columns plus migration). Every account read now returns them, and edits push AccountUpdate to everyone. Outfit menu - Saved outfits kept OutfitSelectionsV2 and CustomAvatarItems, so loading a slot restores what was saved instead of a stale outfit. - isCreationAllowedForAccount answers the {Success, Error} envelope the client parses; minPriceForPublicItem is a bare int; gifts/generate accepts form bodies; lockeditems returns the full owned-item shape; colourways no longer share their base item's AvatarItemId. RecNetResult writes - About 40 writes look status-only but parse the body as {Success, Error}. An empty 200 showed "Failed to ..." after the server applied the change, and a body without Success threw "Error message cannot be null". Clubs, announcements, keepsakes, comments/read, subscriptions, purchase offers and privacy settings now answer RecNetResult. - Login token and device-code grants are real; remoteauth approves the device code; createlogintoken returns a bare string. - New: incentivizedreferrals/referrals, account/bulk/{email,phone}, GET strings, account/me/confirmphone, PlayMenuCarouselOrdering_1. Route inventory and coverage test extended to match. README now describes the 2023 branch.
2026-10-25 23:18:44 -07:00 · 2026-10-15 14:08:11 +03:00
parent 36e64e99ba
commit 6ee1d6f9b3
45 changed files with 6666 additions and 448 deletions
@@ -41,6 +41,7 @@ public class GoToController(
    NotificationService notifications,
    JoinTimeoutService joinTimeouts,
    ServerSettingsService serverSettings,
+    PresenceBroadcastService presenceFanout,
    ILogger<GoToController> logger) : ControllerBase
 {
    [HttpPost("/goto/room/{roomName}")]
@@ -1294,15 +1295,14 @@ public class GoToController(

    private async Task NotifyFriendsOfMoveAsync(long playerId, RoomInstanceDto room)
    {
-        // Honors the global-friends toggle: with it on, every other player is
-        // a "friend" and gets the presence ping (so the whole small server
-        // sees each other's room moves).
-        var friendIds = await RelationshipQueries.EffectiveFriendIdsAsync(db, serverSettings, playerId);
+        // Honors the global-friends toggle (every other player is a "friend"
+        // when it is on). Goes through the shared fan-out so the frame
+        // carries the player's real status visibility and the same
+        // online/room state every other presence transition reports.
        logger.LogInformation(
-            "[goto-fanout] player={PlayerId} moved to room={RoomId}/{RoomName} → notifying {FriendCount} friend(s)",
-            playerId, room.RoomId, room.Name, friendIds.Count);
-        if (friendIds.Count == 0) return;
-        await notifications.PlayerEnteredRoom(friendIds, playerId, room);
+            "[goto-fanout] player={PlayerId} moved to room={RoomId}/{RoomName}",
+            playerId, room.RoomId, room.Name);
+        await presenceFanout.PublishCurrentAsync(playerId);
    }

    private async Task<MatchmakingResponseDto> BuildResponseAsync(string roomName)
@@ -22,6 +22,7 @@ public class MatchController(
    PlayerPresenceService presence,
    PrivateInstanceService privateInstances,
    JoinTimeoutService joinTimeouts,
+    PresenceBroadcastService presenceFanout,
    RoomService rooms,
    DorkNetDbContext db,
    ILogger<MatchController> logger) : ControllerBase
@@ -67,6 +68,12 @@ public class MatchController(
                    completed.Value.TargetRoom.Name,
                    completed.Value.TargetRoom.RoomInstanceId,
                    completed.Value.DeferPresenceCommit);
+                // A deferred join (matchmake/dorm, private-instance hop)
+                // commits HERE, not at matchmake time, so this is the only
+                // point friends can learn about the move. Immediate commits
+                // were already announced by /goto.
+                if (completed.Value.DeferPresenceCommit)
+                    await presenceFanout.PublishCurrentAsync(pid);
            }
            else
            {
@@ -88,36 +95,48 @@ public class MatchController(
        return Ok();
    }

+    /// <summary>POST <c>matchmake/none</c> — "leave room". The 2023 client's
+    /// only caller is TryGoToOfflineRoom
+    /// (RecNet.Runtime/RecNet/Matchmaking.txt:12677-13279): it has already
+    /// switched its own cached presence to the local offline instance
+    /// (RoomInstanceId -1) before posting this, and it discards the reply
+    /// (<c>&lt;TryGoToOfflineRoom&gt;b__119_0</c> returns a constant).
+    ///
+    /// So the player is now online in no room, and that is what presence must
+    /// say. This used to re-commit the previous room (or the dorm) instead:
+    /// the next heartbeat then answered with a room while the client held the
+    /// offline instance, the client logged "presence heartbeat response
+    /// indicates local presence is out-of-sync", cancelled its offline load
+    /// ("OnPlayerPresenceUpdate is cancelling room load for -1") and chased the
+    /// server's room — and friends kept seeing the room the player had left.
+    ///
+    /// A join still pending is abandoned too: the client only goes offline
+    /// after giving up on it (fallback chain after a Photon timeout), and
+    /// echoing its target from the heartbeat would pull the player back.</summary>
    [HttpPost("/matchmake/none")]
    public async Task<IActionResult> MatchmakeNone()
    {
        var pid = this.CurrentPlayerId() ?? 0;
        if (pid == 0) return Unauthorized();

+        var previous = presence.GetRoom(pid);
        var pending = joinTimeouts.GetPending(pid);
-        if (pending is { DeferPresenceCommit: true })
-        {
-            presence.MarkActive(pid);
-            logger.LogInformation(
-                "[matchmake-none] player={Player} has deferred pending room={Room} instance={Instance}; not committing presence",
-                pid,
-                pending.Value.TargetRoom.RoomId,
-                pending.Value.TargetRoom.RoomInstanceId);
-            return Ok(new MatchmakingResponseDto
-            {
-                ErrorCode = 0,
-                RoomInstance = pending.Value.TargetRoom,
-            });
-        }
-
-        var current = presence.GetRoom(pid) ?? await BuildDormRoomInstanceAsync(pid);
-        presence.SetRoom(pid, current);
+        joinTimeouts.Cancel(pid, "matchmake-none");
+        presence.SetNoRoom(pid);
        presence.MarkActive(pid);
-        logger.LogInformation("[matchmake-none] player={Player}", pid);
+        presence.EndBootDormGrace(pid);
+        logger.LogInformation(
+            "[matchmake-none] player={Player} left room={Room} instance={Instance} abandonedPending={Pending}; online with no room",
+            pid, previous?.RoomId, previous?.RoomInstanceId, pending?.TargetRoom.RoomInstanceId);
+
+        await presenceFanout.PublishCurrentAsync(pid);
+
+        // The client ignores this body; keep a well-formed instance in it so
+        // the shared MatchmakingResponse reader never sees a null object.
        return Ok(new MatchmakingResponseDto
        {
            ErrorCode = 0,
-            RoomInstance = current,
+            RoomInstance = previous ?? pending?.TargetRoom ?? await BuildDormRoomInstanceAsync(pid),
        });
    }

@@ -24,6 +24,7 @@ public class MatchPlayerController(
    RoomService rooms,
    PrivateInstanceService privateInstances,
    JoinTimeoutService joinTimeouts,
+    PresenceBroadcastService presenceFanout,
    IConfiguration config,
    DorkNetDbContext db,
    ILogger<MatchPlayerController> log) : ControllerBase
@@ -87,13 +88,20 @@ public class MatchPlayerController(
    /// <summary>
    /// POST /player/logout — fires when the client gives up on a session
    /// (e.g. Photon connection couldn't be established, client aborts).
-    /// Clear the cached presence so the next /goto starts fresh.
+    /// Clear the cached presence so the next /goto starts fresh, and tell
+    /// friends right away — otherwise they keep seeing the player in their
+    /// last room until a bulk poll happens to notice.
    /// </summary>
    [HttpPost("/player/logout")]
-    public IActionResult PlayerLogout()
+    public async Task<IActionResult> PlayerLogout()
    {
        var playerId = TryGetCurrentPlayerId();
-        if (playerId != 0) presence.Clear(playerId);
+        if (playerId != 0)
+        {
+            joinTimeouts.Cancel(playerId, "logout");
+            presence.Clear(playerId);
+            await presenceFanout.PublishOfflineAsync(playerId);
+        }
        return Ok(new { success = true, error = "" });
    }

@@ -178,7 +186,15 @@ public class MatchPlayerController(
    public async Task<ActionResult<PresenceDto>> SetStatusVisibility([FromForm(Name = "statusVisibility")] int? value)
    {
        var playerId = TryGetCurrentPlayerId();
-        if (value is int v) await SetPlayerPrefAsync(playerId, PrefStatusVisibility, v.ToString());
+        if (value is int v)
+        {
+            await SetPlayerPrefAsync(playerId, PrefStatusVisibility, v.ToString());
+            // Friends only. The client does not apply this response to its own
+            // cached presence, and a PresenceUpdate about the local player runs
+            // the same apply-and-rejoin path as an out-of-sync heartbeat
+            // (Matchmaking.EGPABEDPEJO -> FLAOOBNJAAD, Matchmaking.txt:6917), so no self push.
+            await presenceFanout.PublishCurrentAsync(playerId);
+        }
        var room = await GetPresenceRoomForResponseAsync(playerId);
        return Ok(new PresenceDto
        {
@@ -212,7 +228,7 @@ public class MatchPlayerController(
    // back in the response and was then dropped, so the setting reverted on the
    // next heartbeat and never survived a restart. They live in PlayerSettings
    // (no schema change needed) and are read back wherever presence is built.
-    private const string PrefStatusVisibility = "pref:statusVisibility";
+    private const string PrefStatusVisibility = PresenceBroadcastService.StatusVisibilityPrefKey;
    private const string PrefVrMovementMode   = "pref:vrMovementMode";
    private const string PrefAvoidJuniors     = "pref:avoidJuniors";

@@ -395,6 +411,21 @@ public class MatchPlayerController(

        if (room is null)
        {
+            // The player went to the offline room (matchmake/none). Their
+            // client now holds RoomInstanceId -1, which the heartbeat compare
+            // treats as "no room" (HCHDEHIGEBE.GIICPDHJOOH, sign bit of the id;
+            // RecNet.Runtime/RecNet/Matchmaking.txt:18415-18437) and is only in
+            // sync with a null roomInstance. The dorm fallback below would
+            // read as out-of-sync and drag the player out of the offline room.
+            if (presence.IsInNoRoom(playerId))
+            {
+                presence.TouchNoRoom(playerId);
+                log.LogInformation(
+                    "[player-heartbeat] player={PlayerId} online in no room (left via matchmake/none); returning null roomInstance",
+                    playerId);
+                return null;
+            }
+
            if (presence.IsBootDormGraceActive(playerId))
            {
                log.LogInformation(
@@ -426,6 +457,7 @@ public class MatchPlayerController(
                    playerId, fallback.RoomId, fallback.DataBlob);
                presence.SetRoom(playerId, fallback);
                presence.MarkActive(playerId);
+                await presenceFanout.PublishCurrentAsync(playerId);
                return fallback;
            }
            log.LogInformation("[player-heartbeat] player={PlayerId} room=null", playerId);
@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.Mvc;
 using System.Text.Json.Serialization;
+using Microsoft.EntityFrameworkCore;
 using DorkNet.Server.Auth;
+using DorkNet.Server.Data;
 using DorkNet.Server.Services;

 namespace DorkNet.Server.Controllers.Match;
@@ -36,10 +38,19 @@ namespace DorkNet.Server.Controllers.Match;
 /// </summary>
 [ApiController]
 public class PlayerPresenceController(
-    PlayerPresenceService presence) : ControllerBase
+    PlayerPresenceService presence,
+    PresenceBroadcastService presenceFanout,
+    JoinTimeoutService joinTimeouts,
+    DorkNetDbContext db,
+    ServerSettingsService settings) : ControllerBase
 {
+    /// <summary>PlayerSettings key written by <c>PUT /player/statusvisibility</c>
+    /// (MatchPlayerController.PrefStatusVisibility — same literal; the
+    /// round-trip is pinned by a regression test).</summary>
+    public const string PrefStatusVisibility = PresenceBroadcastService.StatusVisibilityPrefKey;
+
    [HttpGet("/player")]
-    public ActionResult<List<PlayerPresenceDto>> GetPresences()
+    public async Task<ActionResult<List<PlayerPresenceDto>>> GetPresences()
    {
        // The watch sends two URL flavours for this endpoint:
        //   1. Bulk: <c>/player?{id1}&amp;{id2}&amp;{id3}</c> — bare keys,
@@ -81,31 +92,39 @@ public class PlayerPresenceController(
        // mid-coroutine. Only redact for OTHER players where the
        // privacy concern actually applies.
        var callerId = this.CurrentPlayerId();
-        var callerRoom = callerId is long cid ? presence.GetRoom(cid) : null;
+        var callerRoom = callerId is long cid ? SelfRoom(cid) : null;
+        var visibility = await LoadVisibilityAsync(ids);
+        var hiddenFromCaller = await ResolveHiddenAsync(callerId, ids, visibility);
        var result = ids.Select(id =>
        {
-            var room = presence.GetRoom(id);
-            // Other players need both a room presence and an active
-            // live signal. Use the recent-heartbeat marker as the
-            // truth source: SignalR can drop while the player is still
-            // heartbeating, or linger after the game is gone. Presence
-            // keys intentionally live for minutes to survive long room
-            // loads, so using them alone leaves friends stuck online
-            // after a graceful disconnect.
            var isSelf = callerId == id;
-            var active = isSelf || presence.IsRecentlyActive(id);
-            var isOnline = room is not null && active;
+            // The caller's own row must say exactly what their heartbeat
+            // says (pending-join target, or null in the offline room): the
+            // client compares its cached self presence field by field
+            // (HCHDEHIGEBE.DCIJHIPJHOB) and treats any difference as
+            // out-of-sync.
+            var room = isSelf ? callerRoom : presence.GetRoom(id);
+            // Online = a live signal (recent heartbeat, or a SignalR
+            // connection), NOT "has a room". Presence keys live for minutes
+            // to survive long room loads, so a room alone would leave friends
+            // stuck online after the game is gone; and a player in the offline
+            // room after matchmake/none has no room but is very much online
+            // (the 2023 DTO carries isOnline on its own; see
+            // NotificationService.BuildPresenceUpdatePayload).
+            // A player who chose "appear offline" (or friends/favorites
+            // only, when the caller doesn't qualify) is reported exactly
+            // like a genuinely offline player: no room, isOnline=false.
+            var isOnline = (isSelf || presenceFanout.IsOnline(id)) && !hiddenFromCaller.Contains(id);
+            if (!isOnline) room = null;
            return new PlayerPresenceDto
            {
                PlayerId         = (int)id,
-                // StatusVisibility is the player's *preference* for who may
-                // see them online. The enum is Everyone=0 / FriendsOnly=1 /
-                // Nobody=2 — so the previous value 1 (mislabeled "Visible")
-                // actually meant FriendsOnly, and anyone who wasn't your
-                // friend saw you as OFFLINE. On a private server everyone
-                // should see everyone, so report Everyone (0). IsOnline=false
-                // still gates the "Online" badge for offline players.
-                StatusVisibility = 0,           // Everyone
+                // The player's stored online-status visibility. Self MUST
+                // see its own stored value: the profile dialog's current
+                // selection is read from the cached self presence, and a
+                // hard-coded 0 here snapped it back to Public after every
+                // presence refresh.
+                StatusVisibility = visibility.GetValueOrDefault(id, PresenceVisibility.Public),
                DeviceClass      = 0,           // Desktop / unknown — not VR
                VrMovementMode   = 0,
                // Full instance details are safe, and necessary, when the
@@ -124,6 +143,58 @@ public class PlayerPresenceController(
        return Ok(result);
    }

+    /// <summary>The caller's own room as their heartbeat reports it.</summary>
+    private RoomInstanceDto? SelfRoom(long playerId)
+    {
+        if (joinTimeouts.GetPending(playerId) is { DeferPresenceCommit: true } pending)
+            return pending.TargetRoom;
+        if (presence.IsInNoRoom(playerId)) return null;
+        return presence.GetRoom(playerId);
+    }
+
+    private Task<Dictionary<long, int>> LoadVisibilityAsync(HashSet<long> ids) =>
+        PresenceBroadcastService.GetStatusVisibilitiesAsync(db, ids);
+
+    /// <summary>Ids whose online status the caller may not see. The caller
+    /// always sees itself; anonymous callers only see Public players.</summary>
+    private async Task<HashSet<long>> ResolveHiddenAsync(
+        long? callerId, HashSet<long> ids, Dictionary<long, int> visibility)
+    {
+        var hidden = new HashSet<long>();
+        var restricted = visibility
+            .Where(kv => kv.Value != PresenceVisibility.Public && kv.Key != callerId)
+            .ToList();
+        if (restricted.Count == 0) return hidden;
+
+        if (callerId is not long me)
+        {
+            foreach (var kv in restricted) hidden.Add(kv.Key);
+            return hidden;
+        }
+
+        HashSet<long>? friends = null;
+        HashSet<long>? favoritedMe = null;
+        foreach (var (target, vis) in restricted)
+        {
+            if (vis == PresenceVisibility.Offline) { hidden.Add(target); continue; }
+
+            friends ??= (await RelationshipQueries.EffectiveFriendIdsAsync(db, settings, me)).ToHashSet();
+            if (!friends.Contains(target)) { hidden.Add(target); continue; }
+
+            if (vis == PresenceVisibility.FavoriteFriendsOnly)
+            {
+                // Favorited lives on the favoriter's own row
+                // (RequesterId = favoriter), as RelationshipsController.BuildMerged reads it.
+                favoritedMe ??= (await db.Relationships
+                    .Where(r => r.TargetId == me && r.Favorited && ids.Contains(r.RequesterId))
+                    .Select(r => r.RequesterId)
+                    .ToListAsync()).ToHashSet();
+                if (!favoritedMe.Contains(target)) hidden.Add(target);
+            }
+        }
+        return hidden;
+    }
+
    private static bool ShouldExposeFullRoom(
        long? callerId,
        RoomInstanceDto? callerRoom,
@@ -151,8 +222,8 @@ public class PlayerPresenceDto
    [JsonPropertyName("playerId")]
    public int PlayerId { get; set; }

-    /// <summary>PlayerStatusVisibility enum (int):
-    /// 0 = Hidden / Offline-appearing, 1 = Visible, 2 = FriendsOnly.</summary>
+    /// <summary>Online-status visibility enum (int, 2023 client):
+    /// 0 = Public, 1 = FriendsOnly, 2 = FavoriteFriendsOnly, 3 = Offline.</summary>
    [JsonPropertyName("statusVisibility")]
    public int StatusVisibility { get; set; }