powergrid-viewer 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powergrid-viewer",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "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": "2.0.0"
+    "powergrid-engine": "2.0.2"
   },
   "devDependencies": {
     "@types/assert": "^1.4.7",

package/src/components/Game.vue

@@ -838,9 +838,16 @@ export default class Game extends Vue {
                     return;
                 }
                 if (this.G.phase == Phase.Resources && !this.canPowerAllPlants(player)) {
-                    this.confirmMessage = 'Are you sure you want to skip buying resources without enough to power all your plants?';
-                    this.confirmVisible = true;
-                    return;
+                    // India's resource market is restrictive (per-step price caps,
+                    // price tiers, one purchase at a time), so a player often can't
+                    // buy enough even when trying. Only warn there when they bought
+                    // nothing this turn — buying some but not enough is a deliberate
+                    // choice, not a slip.
+                    if (this.G.map.name !== 'India' || !this.playerBoughtResourceThisTurn()) {
+                        this.confirmMessage = 'Are you sure you want to skip buying resources without enough to power all your plants?';
+                        this.confirmVisible = true;
+                        return;
+                    }
                 }
 
                 if (
@@ -1411,6 +1418,20 @@ export default class Game extends Vue {
         return true;
     }
 
+    // Whether this player has bought at least one resource during their current
+    // resource-buying turn — i.e. the consecutive run of their own moves at the tail
+    // of the log includes a BuyResource. (In the Resources phase only the current
+    // player acts, so their turn is exactly that tail run.)
+    playerBoughtResourceThisTurn(): boolean {
+        const log = this.G!.log;
+        for (let i = log.length - 1; i >= 0; i--) {
+            const entry = log[i];
+            if (entry.type !== 'move' || entry.player !== this.player) return false;
+            if (entry.move.name === MoveName.BuyResource) return true;
+        }
+        return false;
+    }
+
     toggleSound() {
         const newSound = !this.preferences.sound;
 

package/src/launch.ts

@@ -3,6 +3,7 @@ import type { GameState, Move } from 'powergrid-engine';
 import Vue from 'vue';
 import Game from './components/Game.vue';
 import type { Preferences } from './types/ui-data';
+import { shouldAdoptLogState } from './util/turn-buffer';
 
 function launch(selector: string) {
     let params: {
@@ -67,10 +68,11 @@ function launch(selector: string) {
             return;
         }
 
-        if (logData?.data?.state) {
+        if (shouldAdoptLogState(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.
+            // only way they reach the acting player's viewer. Committed states are
+            // refetched; see shouldAdoptLogState for why adopting them is unsafe.
             params.state = logData.data.state;
             app.$forceUpdate();
         } else {

package/src/util/turn-buffer.ts

@@ -11,6 +11,28 @@ import { move as engineMove } from 'powergrid-engine';
  * how an incoming state relates to that buffer and how to preview the buffer locally.
  */
 
+/**
+ * Should a state arriving on the `gamelog` channel be applied directly, rather than
+ * refetched?
+ *
+ * Only while it is TENTATIVE. That is the single reason this channel exists: tentative
+ * states are never persisted or broadcast, so the move response is the only way one can
+ * reach the acting player's viewer.
+ *
+ * A committed state is refetched instead, exactly as it was before the tentative-turn
+ * model. The same `gamelog` channel also carries the plain log fetch, and
+ * `GET /gameplay/:id/log` is not logged-in: it resolves the player with `findIndex`,
+ * which yields -1 when there is no user, and `stripSecret` then blanks EVERY player's
+ * `availableMoves`. Adopting that state left the acting player looking at a fully
+ * rendered board with nothing clickable after a page refresh, recovering only by
+ * re-entering the game. `fetchState` asks a route that knows who is asking.
+ */
+export function shouldAdoptLogState(state?: GameState | null): boolean {
+    // Written without optional chaining on purpose: webpack 4's parser rejects `?.` in
+    // this module under the unit-test pipeline.
+    return !!state && state.newTurn === false;
+}
+
 /**
  * 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