powergrid-viewer 1.11.22 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powergrid-viewer",
-  "version": "1.11.22",
+  "version": "2.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/boardgamers/powergrid.git",
@@ -18,7 +18,7 @@
     "vue": "^2.6.11",
     "vue-class-component": "^7.2.3",
     "vue-property-decorator": "^8.4.2",
-    "powergrid-engine": "1.15.23"
+    "powergrid-engine": "2.0.0"
   },
   "devDependencies": {
     "@types/assert": "^1.4.7",

package/src/components/Game.vue

@@ -549,8 +549,9 @@
 <script lang="ts">
 import { Vue, Component, Prop, Watch, Provide, ProvideReactive, Ref } from 'vue-property-decorator';
 import { MoveName, ended, playersSortedByScore, reconstructState } from 'powergrid-engine';
-import type { GameState, Player } from 'powergrid-engine';
+import type { GameState, LogItem, Move, Player } from 'powergrid-engine';
 import { EventEmitter } from 'events';
+import { matchesTurnBuffer, rebaseTurnBuffer, replayTurnBuffer as replayBuffer } from '../util/turn-buffer';
 import { UIData, Preferences } from '../types/ui-data';
 import { Card, House, Coal, Oil, Garbage, Uranium } from './pieces';
 import { Button, PassButton, UndoButton, LogButton, SoundButton, HelpButton, RulesButton } from './buttons';
@@ -696,11 +697,75 @@ export default class Game extends Vue {
     @Ref() map!: Map;
     @Ref() resources!: Resources;
 
+    // Tentative-turn buffer: the moves of the current, not-yet-committed turn. The
+    // full buffer is (re)sent to the platform on every action and replayed
+    // server-side from the last committed state; undo simply shortens it.
+    turnMoves: Move[] = [];
+
+    // Last committed state received from the platform. Undo replays the shortened
+    // turn buffer from this state; when the buffer empties, the preview resets to it
+    // without any server call (the platform's saved state IS the turn start).
+    committedState: GameState | null = null;
+
     @Watch('state', { immediate: true })
     onStateChanged(state: GameState) {
+        if (state && state.newTurn !== false) {
+            // Committed state. Usually this clears the turn buffer (our own turn came
+            // back committed), but during the simultaneous Bureaucracy phase it can be
+            // ANOTHER player's commit landing while our turn is still tentative — then
+            // our buffer must be REBASED onto the new state, not discarded.
+            const previousLog: LogItem[] | null = this.committedState ? this.committedState.log : null;
+            this.committedState = JSON.parse(JSON.stringify(state));
+
+            if (this.turnMoves.length > 0) {
+                this.turnMoves = rebaseTurnBuffer(this.committedState!, previousLog, this.turnMoves, this.player);
+            }
+
+            if (this.turnMoves.length > 0) {
+                // Preview the rebased buffer locally (dropping any move the new base
+                // no longer allows) and re-send it so the server echoes the matching
+                // tentative state.
+                const preview = this.replayTurnBuffer();
+                if (this.turnMoves.length > 0) {
+                    this.emitter.emit('move', [...this.turnMoves]);
+                    // Only show the preview while it is still tentative. A rebased
+                    // buffer ending in a COMMITTING move (e.g. Bureaucracy
+                    // [UsePowerPlant, Pass] racing another player's commit) replays
+                    // hidden outcomes (deck draws, upkeep) on the STRIPPED committed
+                    // state — empty deck, secret seed — so its preview would flash
+                    // bogus results. Fall through to the new committed base instead;
+                    // the server's echo of the real committed result of the re-sent
+                    // buffer lands next and clears the buffer via the rebase above.
+                    if (preview.newTurn === false) {
+                        // The replay scrubber still needs the newest committed state
+                        this._futureState = state;
+                        this.replaceState(preview, false);
+                        return;
+                    }
+                }
+            }
+        } else if (state && !matchesTurnBuffer(state, this.committedState, this.turnMoves, this.player)) {
+            // Stale tentative echo: server responses can arrive after the buffer has
+            // changed (a move was undone — possibly down to an empty buffer, which
+            // re-emits nothing — or another move was made before the echo landed).
+            // Applying it would transiently show a phantom or regressed move; the
+            // echo for the current buffer (if any) will follow, so just drop this one.
+            return;
+        }
+
         this.replaceState(state);
     }
 
+    /**
+     * Replays the turn buffer on the last committed state (dropping any move the
+     * engine now rejects — possible after a rebase) and returns the preview.
+     */
+    replayTurnBuffer(): GameState {
+        const { state, applied } = replayBuffer(this.committedState!, this.turnMoves, this.player!);
+        this.turnMoves = applied;
+        return state;
+    }
+
     replaceState(state: GameState, replaceState = true) {
         if (replaceState) {
             this._futureState = state;
@@ -821,7 +886,29 @@ export default class Game extends Vue {
     }
 
     undo() {
-        this.sendMove({ name: MoveName.Undo, data: this.preferences.undoWholeTurn });
+        if (this.paused || this.turnMoves.length === 0 || !this.committedState) {
+            return;
+        }
+
+        // Honor the preference locally — the engine has no Undo move anymore: pop the
+        // last move from the turn buffer, or scrap the whole tentative turn.
+        if (this.preferences.undoWholeTurn) {
+            this.turnMoves = [];
+        } else {
+            this.turnMoves.pop();
+        }
+
+        if (this.turnMoves.length > 0) {
+            // Preview the shortened turn locally and re-send it so the server echoes
+            // the matching tentative state.
+            const preview = this.replayTurnBuffer();
+            this.emitter.emit('move', [...this.turnMoves]);
+            this.replaceState(preview, false);
+        } else {
+            // Empty buffer: nothing to send — nothing was ever persisted for this
+            // turn, so the last committed state IS the turn start.
+            this.replaceState(this.committedState, false);
+        }
     }
 
     choosePowerPlant(powerPlant: PowerPlant) {
@@ -1096,12 +1183,19 @@ export default class Game extends Vue {
     }
 
     sendMove(move) {
-        if (!this.paused) {
-            // Stamp the move so the engine can advance the per-player clocks. The
-            // engine never reads the system clock itself — the timestamp lives in the
-            // log so replaying a game reproduces the same times.
-            this.emitter.emit('move', { ...move, time: Date.now() });
+        if (this.paused) {
+            return;
         }
+
+        // Stamp the move ONCE, when it enters the turn buffer, so the engine can
+        // advance the per-player clocks. The engine never reads the system clock
+        // itself — the stamp travels with the move on every resend of the buffer, so
+        // replays (and the eventual committed log) reproduce the same times.
+        this.turnMoves.push({ ...move, time: Date.now() });
+
+        // Send the WHOLE turn so far: the platform is stateless between calls and
+        // replays the buffer from the last committed (saved) state.
+        this.emitter.emit('move', [...this.turnMoves]);
     }
 
     gameEnded(G: GameState) {
@@ -1132,10 +1226,8 @@ export default class Game extends Vue {
     canUndo() {
         if (!this.canMove()) return false;
 
-        const currentPlayer = this.G!.players[this.player!];
-        const availableMoves = currentPlayer.availableMoves!;
-
-        return !!availableMoves[MoveName.Undo];
+        // Undo scope = the current tentative turn: anything still in the buffer
+        return this.turnMoves.length > 0;
     }
 
     canBid() {

package/src/launch.ts

@@ -31,7 +31,9 @@ function launch(selector: string) {
     const item: EventEmitter = new EventEmitter();
     let replaying = false;
 
-    params.emitter.on('move', (move: Move) => item.emit('move', move));
+    // The move payload is the whole current turn so far (an array of atomic moves),
+    // replayed by the engine wrapper from the last committed state.
+    params.emitter.on('move', (moves: Move[]) => item.emit('move', moves));
     params.emitter.on('fetchState', () => item.emit('fetchState'));
     params.emitter.on('addLog', (data: string[]) => item.emit('addLog', data));
     params.emitter.on('replaceLog', (data: string[]) => item.emit('replaceLog', data));
@@ -60,12 +62,20 @@ function launch(selector: string) {
         params.preferences = { ...params.preferences, ...data };
         app.$forceUpdate();
     });
-    item.addListener('gamelog', (_) => {
+    item.addListener('gamelog', (logData) => {
         if (replaying) {
             return;
         }
 
-        item.emit('fetchState');
+        if (logData?.data?.state) {
+            // Move responses carry the (possibly tentative) resulting state. Tentative
+            // states are never persisted or broadcast by the platform — this is the
+            // only way they reach the acting player's viewer.
+            params.state = logData.data.state;
+            app.$forceUpdate();
+        } else {
+            item.emit('fetchState');
+        }
     });
 
     item.addListener('replay:start', () => {

package/src/self-contained.ts

@@ -42,12 +42,25 @@ function launchSelfContained(selector = '#app') {
         if (player.id != playerIndex) player.isAI = true;
     }
 
-    emitter.on('move', async (move: Move) => {
+    emitter.on('move', async (moves: Move | Move[]) => {
         setTimeout(() => {
-            console.log('move received', move);
-            gameState = execMove(gameState, move, playerIndex);
-            console.log('new game state', gameState);
-
+            console.log('moves received', moves);
+
+            // Mimic the platform: replay the whole turn buffer from the last committed
+            // state; only keep (persist) the result once the turn is committed.
+            let newState = cloneDeep(gameState);
+            for (const move of Array.isArray(moves) ? moves : [moves]) {
+                newState = execMove(newState, move, playerIndex);
+            }
+            console.log('new game state', newState);
+
+            if (newState.newTurn === false) {
+                // Tentative: just echo the state back to the acting player
+                emitter.emit('state', cloneDeep(strip ? stripSecret(newState, playerIndex) : newState));
+                return;
+            }
+
+            gameState = newState;
             emitter.emit('state', cloneDeep(strip ? stripSecret(gameState, playerIndex) : gameState));
 
             let delay = delayBase;
@@ -57,9 +70,13 @@ function launchSelfContained(selector = '#app') {
                         gameState,
                         gameState.players.findIndex((pl) => pl.isAI && pl.availableMoves)
                     );
-                    let newState = cloneDeep(strip ? stripSecret(gameState, playerIndex) : gameState);
-                    console.log('new game state', newState);
-                    emitter.emit('state', newState);
+                    // Only broadcast committed states: the human viewer discards
+                    // tentative states that don't match its own turn buffer.
+                    if (gameState.newTurn !== false) {
+                        let newAIState = cloneDeep(strip ? stripSecret(gameState, playerIndex) : gameState);
+                        console.log('new game state', newAIState);
+                        emitter.emit('state', newAIState);
+                    }
                     setTimeout(moveAIAux, gameState.phase == Phase.Bureaucracy ? delay : 0);
                 }
             };
@@ -83,9 +100,12 @@ function launchSelfContained(selector = '#app') {
             gameState,
             gameState.players.findIndex((pl) => pl.isAI && pl.availableMoves)
         );
-        let newState = cloneDeep(strip ? stripSecret(gameState, playerIndex) : gameState);
-        setTimeout(() => emitter.emit('state', newState), delay);
-        delay += delayBase;
+        // Only broadcast committed states (see moveAIAux above).
+        if (gameState.newTurn !== false) {
+            let newState = cloneDeep(strip ? stripSecret(gameState, playerIndex) : gameState);
+            setTimeout(() => emitter.emit('state', newState), delay);
+            delay += delayBase;
+        }
     }
 
     console.log('available moves', gameState.players[playerIndex].availableMoves);

package/src/util/turn-buffer.ts

@@ -0,0 +1,127 @@
+import { isEqual } from 'lodash';
+import type { GameState, LogItem, LogMove, Move } from 'powergrid-engine';
+import { move as engineMove } from 'powergrid-engine';
+
+/**
+ * Pure helpers for the viewer's tentative-turn buffer.
+ *
+ * The platform persists only COMMITTED states (engine `newTurn !== false`); a turn in
+ * progress lives solely in the acting viewer's buffer, which is (re)sent whole on every
+ * action and replayed server-side from the last committed state. These helpers decide
+ * how an incoming state relates to that buffer and how to preview the buffer locally.
+ */
+
+/**
+ * Compare a move echoed in a log entry with a buffered one. The engine may annotate
+ * the logged copy (`usedPlantDiscount`, `fromSupply`), so only the identity fields
+ * count: name, payload, and the stamp given when the move entered the buffer.
+ */
+export function moveMatches(logged: Move, buffered?: Move): boolean {
+    return (
+        !!buffered &&
+        logged.name === buffered.name &&
+        logged.time === buffered.time &&
+        isEqual(logged.data, buffered.data)
+    );
+}
+
+/**
+ * A tentative state is a valid preview only if it is the server's replay of exactly
+ * the current turn buffer: the visible log must extend the committed log by precisely
+ * the buffered moves, in order. (Tentative moves are always visible log entries —
+ * fastBid bids go to the hidden log but commit immediately.) Anything else is a stale
+ * echo — a response that raced a local undo or a newer move — and must be dropped.
+ */
+export function matchesTurnBuffer(
+    state: GameState,
+    committedState: GameState | null,
+    turnMoves: Move[],
+    player: number | undefined
+): boolean {
+    if (!committedState) {
+        return false;
+    }
+
+    const committedLength = committedState.log.length;
+
+    if (state.log.length !== committedLength + turnMoves.length) {
+        return false;
+    }
+
+    return state.log
+        .slice(committedLength)
+        .every((item, i) => item.type === 'move' && item.player === player && moveMatches(item.move, turnMoves[i]));
+}
+
+/**
+ * Adjust the turn buffer to an incoming COMMITTED state.
+ *
+ * - Our own commit echoed back: the new log contains the buffered moves — drop them
+ *   (usually emptying the buffer; a racing extra move may survive if we can still act).
+ * - Someone else's commit (simultaneous Bureaucracy): the new log contains no moves of
+ *   ours — keep the whole buffer, to be replayed on the new base.
+ * - Anything else (our turn superseded, e.g. auto-played after a drop, a leftover whose
+ *   effect is already committed hidden — a fastBid bid — or a log that did not grow
+ *   monotonically): scrap the buffer.
+ */
+export function rebaseTurnBuffer(
+    committed: GameState,
+    previousLog: LogItem[] | null,
+    turnMoves: Move[],
+    player: number | undefined
+): Move[] {
+    if (!previousLog || committed.log.length < previousLog.length) {
+        return [];
+    }
+
+    const appendedOurs = committed.log
+        .slice(previousLog.length)
+        .filter((item) => item.type === 'move' && item.player === player)
+        .map((item) => (item as LogMove).move);
+
+    if (!appendedOurs.every((move, i) => moveMatches(move, turnMoves[i]))) {
+        return [];
+    }
+
+    const remaining = turnMoves.slice(appendedOurs.length);
+
+    // A leftover move is only replayable if we can still act on the new base. This is
+    // how buffered moves whose effect is HIDDEN get dropped: a fastBid bid goes to the
+    // engine's hidden log and commits immediately, so a chooser's [choose, bid] buffer
+    // echoes back with only the choose visible — the bid is already reflected in the
+    // committed state, and the mover has left `currentPlayers`. Scrap the rest
+    // silently instead of letting the replay reject it with an error.
+    if (remaining.length > 0 && (player === undefined || !committed.currentPlayers.includes(player))) {
+        return [];
+    }
+
+    return remaining;
+}
+
+/**
+ * Replays the turn buffer on the last committed state, truncating it at the first
+ * move the engine rejects (possible after a rebase), and returns the preview plus the
+ * moves that survived. Tentative moves never touch the power-plant deck or the seed —
+ * any move with hidden side effects commits, ending the buffer — so replaying them on
+ * the STRIPPED committed state is exact.
+ */
+export function replayTurnBuffer(
+    committedState: GameState,
+    turnMoves: Move[],
+    player: number
+): { state: GameState; applied: Move[] } {
+    let state: GameState = JSON.parse(JSON.stringify(committedState));
+    const applied: Move[] = [];
+
+    for (const move of turnMoves) {
+        try {
+            state = engineMove(state, move, player);
+        } catch (err) {
+            console.error('dropping turn-buffer tail no longer legal on the committed state', move, err);
+            break;
+        }
+        applied.push(move);
+    }
+
+    return { state, applied };
+}