Domaine : reprise d'une partie, plateau affiché, demi-coups possibles, droit de doubler

Ce dont l'interface a besoin, sans règle réimplémentée : le plateau vu de
chaque camp, les demi-coups que le moteur accepte à la suite de ceux déjà
saisis, le droit de doubler selon le moteur, et la reprise d'une partie
depuis son journal enregistré. Les types du navigateur sont ajoutés à
l'application ; le domaine reste vérifié sans eux.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app/tests/next-half-moves.test.ts

@@ -0,0 +1,65 @@
+// Ce que l'interface propose au joueur, sur le vrai moteur WebAssembly : les
+// demi-coups possibles (mis en évidence quand il touche un pion) et le
+// plateau affiché pendant la saisie d'un coup.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { Game } from "../src/domain/game/game.js";
+import { formatHalfMoves, type HalfMove } from "../src/domain/game/position.js";
+import { fixedDice } from "../src/domain/game/roll.js";
+import { loadNodeEngine } from "./support/node-engine.js";
+
+// Le joueur, au trait, n'a plus que deux pions, sur ses cases 6 et 5
+// (même position que dans les étapes du scénario).
+const PLAYER_ALMOST_DONE = "/38AAABQAAAAAA";
+
+/** Les demi-coups en notation, triés : « 13/10 13/12… ». */
+function text(halfMoves: readonly HalfMove[]): string {
+    return halfMoves
+        .map((h) => formatHalfMoves([h]))
+        .sort()
+        .join(" ");
+}
+
+test("au départ avec 3-1 : chaque pion jouable, avec chaque dé", async () => {
+    const engine = await loadNodeEngine();
+    const game = Game.start(engine, { dice: fixedDice([3, 1]) });
+    assert.equal(text(await game.nextHalfMoves()), "13/10 24/21 24/23 6/3 6/5 8/5 8/7");
+    // 13/12 manque : votre case 12 est tenue par l'ordinateur. Après 8/5,
+    // il ne reste que le 1.
+    assert.equal(await game.playHalfMove({ from: 8, to: 5 }), true);
+    assert.equal(text(await game.nextHalfMoves()), "24/23 5/4 6/5 8/7");
+});
+
+test("en fin de partie, les demi-coups vers la sortie viennent du moteur", async () => {
+    const engine = await loadNodeEngine();
+    const game = Game.start(engine, {
+        dice: fixedDice([6, 5]),
+        setup: { position: PLAYER_ALMOST_DONE, firstTurn: "player" },
+    });
+    await game.roll();
+    assert.equal(text(await game.nextHalfMoves()), "5/off 6/1 6/off");
+});
+
+test("hors du tour de jeu du joueur, rien n'est proposé", async () => {
+    const engine = await loadNodeEngine();
+    const game = Game.start(engine, { dice: fixedDice([1, 3]) });
+    assert.equal(game.state.turn, "computer");
+    assert.deepEqual(await game.nextHalfMoves(), []);
+});
+
+test("le plateau affiché suit les demi-coups saisis", async () => {
+    const engine = await loadNodeEngine();
+    const game = Game.start(engine, { dice: fixedDice([3, 1]) });
+    const before = await game.displayedBoard();
+    assert.equal(before.player.points[7], 3);
+    assert.equal(before.computer.points[23], 2);
+    await game.playHalfMove({ from: 8, to: 5 });
+    const after = await game.displayedBoard();
+    assert.equal(after.player.points[7], 2);
+    assert.equal(after.player.points[4], 1);
+    assert.equal(after.player.pipCount, before.player.pipCount - 3);
+});