fix: report live player presence from game servers

api/src/main/java/app/simplecloud/api/internal/integration/presence/ProxyPresenceResponder.java → api/src/main/java/app/simplecloud/api/internal/integration/presence/PresenceResponder.java

@@ -1,7 +1,7 @@
 package app.simplecloud.api.internal.integration.presence;
 
-import app.simplecloud.api.presence.ProxyPresencePlayer;
-import app.simplecloud.api.presence.ProxyPresencePlayerProvider;
+import app.simplecloud.api.presence.PresencePlayer;
+import app.simplecloud.api.presence.PresencePlayerProvider;
 import build.buf.gen.simplecloud.controller.v2.PresenceCompareRequest;
 import build.buf.gen.simplecloud.controller.v2.ProxyPresenceCompareResponse;
 import io.nats.client.Connection;
@@ -18,35 +18,35 @@
 import java.util.logging.Logger;
 
 /**
- * Responds to controller presence-compare requests for a single proxy.
+ * Responds to controller presence-compare requests for a single proxy or game server.
  */
-public final class ProxyPresenceResponder {
+public final class PresenceResponder {
 
-    private static final Logger LOGGER = Logger.getLogger(ProxyPresenceResponder.class.getName());
+    private static final Logger LOGGER = Logger.getLogger(PresenceResponder.class.getName());
     private static final int FNV_32A_OFFSET_BASIS = 0x811c9dc5;
     private static final int FNV_32A_PRIME = 0x01000193;
 
     private final Connection natsConnection;
     private final String serverId;
     private final String subject;
     private final AtomicBoolean running = new AtomicBoolean(false);
-    private volatile ProxyPresencePlayerProvider playerProvider;
+    private volatile PresencePlayerProvider playerProvider;
 
     private Dispatcher dispatcher;
 
-    public ProxyPresenceResponder(
+    public PresenceResponder(
             Connection natsConnection,
             String networkId,
             String serverId,
-            ProxyPresencePlayerProvider playerProvider
+            PresencePlayerProvider playerProvider
     ) {
         this.natsConnection = Objects.requireNonNull(natsConnection, "natsConnection");
         this.serverId = serverId == null ? "" : serverId;
         this.subject = Objects.requireNonNull(networkId, "networkId") + ".server." + this.serverId + ".presence.compare";
         this.playerProvider = playerProvider;
     }
 
-    public ProxyPresenceResponder(
+    public PresenceResponder(
             Connection natsConnection,
             String networkId,
             String serverId
@@ -67,7 +67,7 @@ public void start() {
         dispatcher.subscribe(subject, this::handleCompareRequest);
     }
 
-    public void registerPlayerProvider(ProxyPresencePlayerProvider playerProvider) {
+    public void registerPlayerProvider(PresencePlayerProvider playerProvider) {
         this.playerProvider = Objects.requireNonNull(playerProvider, "playerProvider");
     }
 
@@ -92,52 +92,65 @@ private void handleCompareRequest(Message message) {
 
         try {
             PresenceCompareRequest request = PresenceCompareRequest.parseFrom(message.getData());
-            List<ProxyPresencePlayer> players = currentPlayers();
-            int localHash = computeHash(players);
-            boolean match = localHash == request.getHash();
-
-            ProxyPresenceCompareResponse.Builder response = ProxyPresenceCompareResponse.newBuilder()
-                    .setMatch(match);
-
-            if (!match) {
-                response.addAllPlayers(players.stream().map(ProxyPresencePlayer::toProto).toList());
-            }
-
-            natsConnection.publish(replyTo, response.build().toByteArray());
+            List<PresencePlayer> players = currentPlayers();
+            natsConnection.publish(replyTo, buildResponse(request, players).toByteArray());
         } catch (Exception e) {
             LOGGER.log(Level.WARNING, "Failed to process presence compare request for " + subject, e);
         }
     }
 
-    private List<ProxyPresencePlayer> currentPlayers() {
-        ProxyPresencePlayerProvider currentProvider = playerProvider;
+    private List<PresencePlayer> currentPlayers() {
+        PresencePlayerProvider currentProvider = playerProvider;
         if (currentProvider == null) {
             return List.of();
         }
 
-        Collection<ProxyPresencePlayer> suppliedPlayers = currentProvider.getProxyPresencePlayers();
+        Collection<PresencePlayer> suppliedPlayers = currentProvider.getPresencePlayers();
         if (suppliedPlayers == null || suppliedPlayers.isEmpty()) {
             return List.of();
         }
 
         return suppliedPlayers.stream()
                 .filter(Objects::nonNull)
-                .sorted(Comparator.comparing(ProxyPresencePlayer::hashRecord))
+                .sorted(Comparator.comparing(PresencePlayer::hashRecord))
                 .toList();
     }
 
-    static int computeHash(Collection<ProxyPresencePlayer> players) {
+    static ProxyPresenceCompareResponse buildResponse(
+            PresenceCompareRequest request,
+            Collection<PresencePlayer> players
+    ) {
+        Objects.requireNonNull(request, "request");
+        List<PresencePlayer> currentPlayers = (players == null ? List.<PresencePlayer>of() : players).stream()
+                .filter(Objects::nonNull)
+                .sorted(Comparator.comparing(PresencePlayer::hashRecord))
+                .toList();
+        boolean match = computeHash(currentPlayers) == request.getHash();
+
+        ProxyPresenceCompareResponse.Builder response = ProxyPresenceCompareResponse.newBuilder()
+                .setMatch(match);
+        if (!match) {
+            response.addAllPlayers(currentPlayers.stream().map(PresencePlayer::toProto).toList());
+        }
+        return response.build();
+    }
+
+    static int computeHash(Collection<PresencePlayer> players) {
         if (players == null || players.isEmpty()) {
             return 0;
         }
 
+        List<String> records = players.stream()
+                .filter(Objects::nonNull)
+                .map(PresencePlayer::hashRecord)
+                .sorted()
+                .toList();
+        String payload = records.size() + "\u001e" + String.join("\u001e", records);
+
         int hash = FNV_32A_OFFSET_BASIS;
-        for (ProxyPresencePlayer player : players) {
-            byte[] bytes = player.hashRecord().getBytes(StandardCharsets.UTF_8);
-            for (byte currentByte : bytes) {
-                hash ^= currentByte & 0xff;
-                hash *= FNV_32A_PRIME;
-            }
+        for (byte currentByte : payload.getBytes(StandardCharsets.UTF_8)) {
+            hash ^= currentByte & 0xff;
+            hash *= FNV_32A_PRIME;
         }
         return hash;
     }

api/src/main/java/app/simplecloud/api/internal/integration/presence/ProxyPresenceTracker.java

@@ -1,6 +1,6 @@
 package app.simplecloud.api.internal.integration.presence;
 
-import app.simplecloud.api.presence.ProxyPresencePlayer;
+import app.simplecloud.api.presence.PresencePlayer;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -32,7 +32,7 @@ public void remove(String playerId) {
         players.remove(normalize(playerId));
     }
 
-    public ProxyPresencePlayer createSnapshot(
+    public PresencePlayer createSnapshot(
             String playerId,
             String name,
             String displayName,
@@ -44,7 +44,7 @@ public ProxyPresencePlayer createSnapshot(
         String normalizedPlayerId = normalize(playerId);
         TrackedPlayerMetadata metadata = players.get(normalizedPlayerId);
 
-        return new ProxyPresencePlayer(
+        return new PresencePlayer(
                 normalizedPlayerId,
                 name,
                 displayName,

api/src/main/java/app/simplecloud/api/presence/ProxyPresencePlayer.java → api/src/main/java/app/simplecloud/api/presence/PresencePlayer.java

@@ -3,9 +3,9 @@
 import build.buf.gen.simplecloud.controller.v2.ProxyPresencePlayerSnapshot;
 
 /**
- * Immutable player snapshot used for proxy presence reconciliation.
+ * Immutable player snapshot used for proxy and game-server presence reconciliation.
  */
-public final class ProxyPresencePlayer {
+public final class PresencePlayer {
 
     private final String playerId;
     private final String name;
@@ -18,7 +18,7 @@ public final class ProxyPresencePlayer {
     private final boolean onlineMode;
     private final String sessionId;
 
-    public ProxyPresencePlayer(
+    public PresencePlayer(
             String playerId,
             String name,
             String displayName,

api/src/main/java/app/simplecloud/api/presence/PresencePlayerProvider.java

@@ -0,0 +1,11 @@
+package app.simplecloud.api.presence;
+
+import java.util.Collection;
+
+/**
+ * Supplies the current set of players visible to this proxy or game server.
+ */
+public interface PresencePlayerProvider {
+
+    Collection<PresencePlayer> getPresencePlayers();
+}

api/src/test/java/app/simplecloud/api/internal/integration/presence/PresenceResponderTest.java

@@ -0,0 +1,96 @@
+package app.simplecloud.api.internal.integration.presence;
+
+import app.simplecloud.api.presence.PresencePlayer;
+import build.buf.gen.simplecloud.controller.v2.PresenceCompareRequest;
+import build.buf.gen.simplecloud.controller.v2.ProxyPresenceCompareResponse;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class PresenceResponderTest {
+
+    @Test
+    void returnsMatchWithoutSnapshotWhenSummaryMatches() {
+        ProxyPresenceCompareResponse response = PresenceResponder.buildResponse(
+                PresenceCompareRequest.newBuilder().setHash(0).build(),
+                List.of()
+        );
+
+        assertTrue(response.getMatch());
+        assertTrue(response.getPlayersList().isEmpty());
+    }
+
+    @Test
+    void returnsEveryLivePlayerWhenSummaryDiffers() {
+        PresencePlayer player = new PresencePlayer(
+                "player-1",
+                "PlayerOne",
+                "PlayerOne",
+                "",
+                "Proxy-1",
+                1L,
+                "en_US",
+                765,
+                true,
+                "session-1"
+        );
+
+        ProxyPresenceCompareResponse response = PresenceResponder.buildResponse(
+                PresenceCompareRequest.newBuilder().setHash(0).build(),
+                List.of(player)
+        );
+
+        assertFalse(response.getMatch());
+        assertTrue(response.getPlayersList().stream().anyMatch(snapshot -> snapshot.getPlayerId().equals("player-1")));
+    }
+
+    @Test
+    void equalCountsWithDifferentPlayersProduceDifferentHashes() {
+        PresencePlayer first = player("player-1");
+        PresencePlayer second = player("player-2");
+
+        assertNotEquals(
+                PresenceResponder.computeHash(List.of(first)),
+                PresenceResponder.computeHash(List.of(second))
+        );
+        assertEquals(0, PresenceResponder.computeHash(List.of()));
+    }
+
+    @Test
+    void hashMatchesControllerWireContract() {
+        PresencePlayer player = new PresencePlayer(
+                "player-1",
+                "PlayerOne",
+                "PlayerOne",
+                "Lobby-1",
+                "",
+                0L,
+                "",
+                0,
+                true,
+                ""
+        );
+
+        assertEquals(1745198624, PresenceResponder.computeHash(List.of(player)));
+    }
+
+    private static PresencePlayer player(String playerId) {
+        return new PresencePlayer(
+                playerId,
+                playerId,
+                playerId,
+                "",
+                "Proxy-1",
+                1L,
+                "en_US",
+                765,
+                true,
+                "session-1"
+        );
+    }
+}

platform/bungeecord/src/main/java/app/simplecloud/api/platform/bungeecord/BungeeCordApiProvider.java

@@ -3,10 +3,10 @@
 import app.simplecloud.api.CloudApi;
 import app.simplecloud.api.internal.CloudApiImpl;
 import app.simplecloud.api.internal.integration.player.PlayerIntegration;
-import app.simplecloud.api.internal.integration.presence.ProxyPresenceResponder;
+import app.simplecloud.api.internal.integration.presence.PresenceResponder;
 import app.simplecloud.api.internal.integration.presence.ProxyPresenceTracker;
-import app.simplecloud.api.presence.ProxyPresencePlayer;
-import app.simplecloud.api.presence.ProxyPresencePlayerProvider;
+import app.simplecloud.api.presence.PresencePlayer;
+import app.simplecloud.api.presence.PresencePlayerProvider;
 import app.simplecloud.api.player.CloudPlayer;
 import app.simplecloud.api.runtime.SimpleCloudRuntime;
 import app.simplecloud.api.platform.shared.LuckPermsPlayerPropertySynchronizer;
@@ -26,7 +26,7 @@
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
-public class BungeeCordApiProvider extends Plugin implements ProxyPresencePlayerProvider {
+public class BungeeCordApiProvider extends Plugin implements PresencePlayerProvider {
 
     private final BungeeContext fastStatsContext = new BungeeContext.Factory(
             this,
@@ -37,7 +37,7 @@ public class BungeeCordApiProvider extends Plugin implements ProxyPresencePlayer
     private PlayerSynchronizer playerSynchronizer;
     private PlayerIntegration playerIntegration;
     private ProxyPresenceTracker proxyPresenceTracker;
-    private ProxyPresenceResponder proxyPresenceResponder;
+    private PresenceResponder presenceResponder;
     private LuckPermsPlayerPropertySynchronizer luckPermsSynchronizer;
 
     private BungeeAudiences bungeeAudiences;
@@ -55,7 +55,7 @@ public void onEnable() {
         );
         this.playerIntegration = new PlayerIntegration(cloudApi);
         this.proxyPresenceTracker = new ProxyPresenceTracker(proxyName);
-        this.proxyPresenceResponder = new ProxyPresenceResponder(
+        this.presenceResponder = new PresenceResponder(
                 cloudApi.getNatsConnection(),
                 cloudApi.getNetworkId(),
                 SimpleCloudRuntime.serverId(),
@@ -81,14 +81,14 @@ public void onEnable() {
 
         playerSynchronizer.start();
         playerIntegration.start();
-        proxyPresenceResponder.start();
+        presenceResponder.start();
         fastStatsContext.ready();
     }
 
     @Override
     public void onDisable() {
         getLogger().info("SimpleCloud v3 API provider uninitialized!");
-        proxyPresenceResponder.stop();
+        presenceResponder.stop();
         if (luckPermsSynchronizer != null) {
             luckPermsSynchronizer.stop();
         }
@@ -135,13 +135,13 @@ private void forgetLuckPermsProperties(UUID uniqueId) {
     }
 
     @Override
-    public List<ProxyPresencePlayer> getProxyPresencePlayers() {
+    public List<PresencePlayer> getPresencePlayers() {
         return getProxy().getPlayers().stream()
                 .map(this::toPresencePlayer)
                 .toList();
     }
 
-    private ProxyPresencePlayer toPresencePlayer(ProxiedPlayer player) {
+    private PresencePlayer toPresencePlayer(ProxiedPlayer player) {
         String connectedServerName = player.getServer() != null ? player.getServer().getInfo().getName() : "";
         Locale locale = player.getLocale();
         var pendingConnection = player.getPendingConnection();