fix(table): keep deadlines running in river view (#89)

Author: TypeThe0ry

src/main/java/top/ellan/mahjong/table/core/SessionActionDeadlineCoordinator.java

@@ -38,8 +38,6 @@ final class SessionActionDeadlineCoordinator {
     private final LongSupplier currentTimeMillis;
     private final Map<UUID, Long> remainingExtraMillis = new HashMap<>();
     private final Map<UUID, ActorDeadline> actorDeadlines = new HashMap<>();
-    private final Map<UUID, SuspendedDeadline> suspendedDeadlines = new HashMap<>();
-    private final Set<UUID> suspendedActors = new HashSet<>();
     private final Map<UUID, Integer> consecutiveAutomaticDiscards = new HashMap<>();
     private final Set<UUID> automaticDiscardActors = new HashSet<>();
     private String armedFingerprint;
@@ -54,10 +52,6 @@ final class SessionActionDeadlineCoordinator {
     }
 
     synchronized void beginRound() {
-        // An overhead river view may legitimately span the short gap between hands.
-        // Reset hand-scoped clocks and idle history without dropping the explicit
-        // suspension; the first action window of the new hand must remain frozen
-        // until the player returns with Shift.
         this.resetRoundState();
         long extraMillis = this.thinkingBudget().extraMillis();
         for (UUID playerId : this.session.players()) {
@@ -121,10 +115,6 @@ synchronized void recordAction(UUID playerId) {
         if (deadline != null) {
             this.consumeExtra(playerId, deadline, now);
         }
-        SuspendedDeadline suspended = this.suspendedDeadlines.remove(playerId);
-        if (suspended != null) {
-            this.consumeExtra(playerId, suspended.deadline(), suspended.suspendedAtMillis());
-        }
         ActionWindow currentWindow = this.captureWindow();
         if (currentWindow == null) {
             this.reset();
@@ -148,91 +138,18 @@ synchronized long secondsRemaining(UUID playerId) {
             return 0L;
         }
         ActorDeadline deadline = this.actorDeadlines.get(playerId);
-        if (deadline != null) {
-            return secondsFromMillis(deadline.deadlineMillis() - this.currentTimeMillis.getAsLong());
-        }
-        SuspendedDeadline suspended = this.suspendedDeadlines.get(playerId);
-        return suspended == null
+        return deadline == null
             ? 0L
-            : secondsFromMillis(suspended.deadline().deadlineMillis() - suspended.suspendedAtMillis());
-    }
-
-    /** Freezes this player's current and subsequent action windows until explicitly resumed. */
-    synchronized void suspend(UUID playerId) {
-        if (playerId == null || !this.suspendedActors.add(playerId)) {
-            return;
-        }
-        ActionWindow window = this.captureWindow();
-        if (window == null) {
-            return;
-        }
-        long now = this.currentTimeMillis.getAsLong();
-        if (!window.fingerprint().equals(this.armedFingerprint)) {
-            this.armWindow(window, now);
-        } else {
-            this.ensureActorDeadlines(window, now);
-        }
-    }
-
-    /** Restores the frozen action with exactly the time that remained on entry. */
-    synchronized void resume(UUID playerId) {
-        if (playerId == null || !this.suspendedActors.remove(playerId)) {
-            return;
-        }
-        long now = this.currentTimeMillis.getAsLong();
-        SuspendedDeadline suspended = this.suspendedDeadlines.remove(playerId);
-        ActionWindow window = this.captureWindow();
-        if (window == null) {
-            return;
-        }
-        if (!window.fingerprint().equals(this.armedFingerprint)) {
-            if (suspended != null) {
-                this.consumeExtra(playerId, suspended.deadline(), suspended.suspendedAtMillis());
-            }
-            this.armWindow(window, now);
-            return;
-        }
-        if (suspended != null
-            && suspended.fingerprint().equals(window.fingerprint())
-            && window.actors().contains(playerId)) {
-            ActorDeadline frozen = suspended.deadline();
-            long elapsedBeforeSuspension = Math.max(0L, suspended.suspendedAtMillis() - frozen.startedAtMillis());
-            long remainingMillis = Math.max(0L, frozen.deadlineMillis() - suspended.suspendedAtMillis());
-            this.actorDeadlines.put(
-                playerId,
-                new ActorDeadline(
-                    Math.max(0L, now - elapsedBeforeSuspension),
-                    frozen.baseMillis(),
-                    frozen.extraAtStartMillis(),
-                    saturatedAdd(now, remainingMillis)
-                )
-            );
-        } else {
-            if (suspended != null) {
-                this.consumeExtra(playerId, suspended.deadline(), suspended.suspendedAtMillis());
-            }
-            this.ensureActorDeadlines(window, now);
-        }
-    }
-
-    /** Drops a frozen action without restoring it, for disconnect/removal/table teardown. */
-    synchronized void discardSuspension(UUID playerId) {
-        if (playerId == null) {
-            return;
-        }
-        this.suspendedActors.remove(playerId);
-        this.suspendedDeadlines.remove(playerId);
+            : secondsFromMillis(deadline.deadlineMillis() - this.currentTimeMillis.getAsLong());
     }
 
     synchronized void reset() {
         this.armedFingerprint = null;
         this.actorDeadlines.clear();
-        this.suspendedDeadlines.clear();
     }
 
     synchronized void clear() {
         this.resetRoundState();
-        this.suspendedActors.clear();
     }
 
     private void resetRoundState() {
@@ -249,12 +166,7 @@ private void armWindow(ActionWindow window, long now) {
         for (Map.Entry<UUID, ActorDeadline> entry : List.copyOf(this.actorDeadlines.entrySet())) {
             this.consumeExtra(entry.getKey(), entry.getValue(), now);
         }
-        for (Map.Entry<UUID, SuspendedDeadline> entry : List.copyOf(this.suspendedDeadlines.entrySet())) {
-            SuspendedDeadline suspended = entry.getValue();
-            this.consumeExtra(entry.getKey(), suspended.deadline(), suspended.suspendedAtMillis());
-        }
         this.actorDeadlines.clear();
-        this.suspendedDeadlines.clear();
         this.armedFingerprint = window.fingerprint();
         this.ensureActorDeadlines(window, now);
     }
@@ -271,27 +183,6 @@ private void ensureActorDeadlines(ActionWindow window, long now) {
             long extraMillis = window.phase() == ActionPhase.TURN
                 ? 0L
                 : this.remainingExtraMillis.computeIfAbsent(playerId, ignored -> budget.extraMillis());
-            if (this.suspendedActors.contains(playerId)) {
-                ActorDeadline active = this.actorDeadlines.remove(playerId);
-                this.suspendedDeadlines.compute(
-                    playerId,
-                    (ignored, current) -> current != null && current.fingerprint().equals(window.fingerprint())
-                        ? current
-                        : new SuspendedDeadline(
-                            window.fingerprint(),
-                            active == null
-                                ? new ActorDeadline(
-                                    now,
-                                    budget.baseMillis(),
-                                    extraMillis,
-                                    saturatedAdd(now, saturatedAdd(budget.baseMillis(), extraMillis))
-                                )
-                                : active,
-                            now
-                        )
-                );
-                continue;
-            }
             this.actorDeadlines.computeIfAbsent(
                 playerId,
                 ignored -> new ActorDeadline(
@@ -583,13 +474,6 @@ private record ActorDeadline(
     ) {
     }
 
-    private record SuspendedDeadline(
-        String fingerprint,
-        ActorDeadline deadline,
-        long suspendedAtMillis
-    ) {
-    }
-
     private record ActionWindow(ActionPhase phase, String fingerprint, List<UUID> actors) {
     }
 }

src/main/java/top/ellan/mahjong/table/core/TableActionDeadlines.java

@@ -19,7 +19,6 @@
 import top.ellan.mahjong.config.PluginSettings;
 import top.ellan.mahjong.model.SeatWind;
 import top.ellan.mahjong.table.core.MahjongTableSession;
-import top.ellan.mahjong.table.core.TableActionDeadlines;
 import top.ellan.mahjong.table.core.TableOverheadViews;
 import top.ellan.mahjong.table.core.TableRuntimeServices;
 
@@ -74,13 +73,7 @@ public void discard(UUID playerId) {
         if (playerId == null) {
             return;
         }
-        ActiveView view = this.activeViews.remove(playerId);
-        if (view != null) {
-            // A disconnected player may retain their active seat. Restore the
-            // action clock before unattended handling takes over on the next
-            // table tick instead of leaving an orphaned camera suspension.
-            TableActionDeadlines.resume(view.session(), playerId);
-        }
+        this.activeViews.remove(playerId);
     }
 
     @Override
@@ -96,8 +89,6 @@ public void closeTable(String tableId) {
             Player player = Bukkit.getPlayer(entry.getKey());
             if (player != null && player.isOnline()) {
                 this.plugin.scheduler().runEntity(player, () -> this.finishExit(player, view, false, true));
-            } else {
-                TableActionDeadlines.discardSuspension(view.session(), entry.getKey());
             }
         }
     }
@@ -112,8 +103,6 @@ public void closeAll() {
             Player player = Bukkit.getPlayer(entry.getKey());
             if (player != null && player.isOnline()) {
                 this.plugin.scheduler().runEntity(player, () -> this.finishExit(player, view, false, true));
-            } else {
-                TableActionDeadlines.discardSuspension(view.session(), entry.getKey());
             }
         }
     }
@@ -131,8 +120,6 @@ public void shutdown() {
                 // perform one direct best-effort restore without touching a
                 // Bukkit world entity.
                 this.finishExit(player, view, false, false);
-            } else {
-                TableActionDeadlines.discardSuspension(view.session(), entry.getKey());
             }
         }
         this.activeViews.clear();
@@ -183,10 +170,8 @@ private boolean enter(Player player, MahjongTableSession session, SeatWind wind)
                 this.destroyCamera(player, camera);
                 return false;
             }
-            TableActionDeadlines.suspend(session, player.getUniqueId());
             if (!this.cameraBridge.setCamera(player, camera.entityID())) {
                 this.activeViews.remove(player.getUniqueId(), view);
-                TableActionDeadlines.resume(session, player.getUniqueId());
                 this.restoreCameraAndDestroy(player, camera, true, 3, null);
                 this.plugin.messages().send(player, "table.overhead.unavailable");
                 return false;
@@ -197,9 +182,7 @@ private boolean enter(Player player, MahjongTableSession session, SeatWind wind)
             return true;
         } catch (Throwable throwable) {
             if (view != null) {
-                if (this.activeViews.remove(player.getUniqueId(), view)) {
-                    TableActionDeadlines.resume(view.session(), player.getUniqueId());
-                }
+                this.activeViews.remove(player.getUniqueId(), view);
             }
             ActiveView current = this.activeViews.get(player.getUniqueId());
             if (camera != null && (current == null || current.camera() != camera)) {
@@ -256,15 +239,10 @@ private void finishExit(Player player, ActiveView view, boolean notify, boolean
         Runnable restored = () -> {
             ActiveView current = this.activeViews.get(player.getUniqueId());
             if (current == null) {
-                TableActionDeadlines.resume(view.session(), player.getUniqueId());
                 if (notify) {
                     view.session().flushViewerActionsNow(player.getUniqueId());
                     this.plugin.messages().send(player, "table.overhead.restored");
                 }
-            } else if (current.session() != view.session()) {
-                // A new table may have acquired the player's camera while the
-                // old restore retried. Do not resume the old table's action.
-                TableActionDeadlines.discardSuspension(view.session(), player.getUniqueId());
             }
         };
         this.restoreCameraAndDestroy(player, view.camera(), retry, retry ? 3 : 0, restored);

src/main/java/top/ellan/mahjong/table/runtime/TableOverheadViewCoordinator.java

@@ -293,7 +293,7 @@ class SessionActionDeadlineCoordinatorTest {
     }
 
     @Test
-    fun `viewing river freezes dingque fallback and shift return resumes exact remaining time`() {
+    fun `viewing river leaves dingque deadline running`() {
         val clock = AtomicLong(3_000L)
         val session = baseSession(MahjongVariant.SICHUAN)
         `when`(session.players()).thenReturn(listOf(east))
@@ -323,25 +323,20 @@ class SessionActionDeadlineCoordinatorTest {
         clock.addAndGet(2_000L)
         assertEquals(6L, coordinator.secondsRemaining(east))
 
-        coordinator.suspend(east)
-        clock.addAndGet(60_000L)
-        coordinator.tick()
-
-        verify(session, never()).chooseSichuanMissingSuit(east, "suo")
-        assertEquals(6L, coordinator.secondsRemaining(east))
-
-        coordinator.resume(east)
+        // Entering the client-only river camera does not alter the action clock.
         clock.addAndGet(5_999L)
         coordinator.tick()
+
         verify(session, never()).chooseSichuanMissingSuit(east, "suo")
+        assertEquals(1L, coordinator.secondsRemaining(east))
 
         clock.addAndGet(1L)
         coordinator.tick()
         verify(session).chooseSichuanMissingSuit(east, "suo")
     }
 
     @Test
-    fun `river suspension also freezes a new action window until the player returns`() {
+    fun `new action window created while viewing river keeps its normal deadline`() {
         val clock = AtomicLong(3_000L)
         val dingquePending = AtomicBoolean(true)
         val session = turnSession(MahjongVariant.SICHUAN, east)
@@ -351,7 +346,6 @@ class SessionActionDeadlineCoordinatorTest {
         val coordinator = SessionActionDeadlineCoordinator(session, clock::get)
 
         coordinator.tick()
-        coordinator.suspend(east)
 
         // Another seat's action advances the table from dingque to this player's turn
         // while the player is still inspecting the river.
@@ -360,19 +354,18 @@ class SessionActionDeadlineCoordinatorTest {
         coordinator.tick()
         assertEquals(60L, coordinator.secondsRemaining(east))
 
-        clock.addAndGet(120_000L)
+        clock.addAndGet(59_999L)
         coordinator.tick()
         verify(session, never()).discard(east, 13)
-        assertEquals(60L, coordinator.secondsRemaining(east))
+        assertEquals(1L, coordinator.secondsRemaining(east))
 
-        coordinator.resume(east)
-        clock.addAndGet(60_000L)
+        clock.addAndGet(1L)
         coordinator.tick()
         verify(session).discard(east, 13)
     }
 
     @Test
-    fun `river suspension survives begin round and freezes the next hand until return`() {
+    fun `new hand started while viewing river keeps its normal deadline`() {
         val clock = AtomicLong(3_000L)
         val round = AtomicInteger(0)
         val session = turnSession(MahjongVariant.RIICHI, east)
@@ -383,22 +376,16 @@ class SessionActionDeadlineCoordinatorTest {
 
         coordinator.tick()
         clock.addAndGet(2_000L)
-        coordinator.suspend(east)
         assertEquals(58L, coordinator.secondsRemaining(east))
 
         round.incrementAndGet()
         coordinator.beginRound()
         assertEquals(60L, coordinator.secondsRemaining(east))
 
-        clock.addAndGet(120_000L)
-        coordinator.tick()
-        verify(session, never()).discard(east, 13)
-        assertEquals(60L, coordinator.secondsRemaining(east))
-
-        coordinator.resume(east)
         clock.addAndGet(59_999L)
         coordinator.tick()
         verify(session, never()).discard(east, 13)
+        assertEquals(1L, coordinator.secondsRemaining(east))
 
         clock.addAndGet(1L)
         coordinator.tick()