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/game.test.ts

@@ -218,3 +218,57 @@ test("lecture et écriture des demi-coups", () => {
     assert.throws(() => parseHalfMoves("8-5"), /mal formé/);
     assert.throws(() => parseHalfMoves("30/5"), /case invalide/);
 });
+
+test("une partie se reprend depuis son journal ; un journal d'une autre version est refusé", async () => {
+    const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1]) });
+    await game.playHalfMove({ from: 8, to: 5 });
+    await game.playHalfMove({ from: 6, to: 5 });
+    const saved = JSON.parse(JSON.stringify(game.journal));
+
+    const resumed = Game.resume(fakeEngine(), saved);
+    assert.deepEqual(resumed.state, game.state);
+    assert.deepEqual(resumed.events, game.events);
+
+    const other = { ...saved, events: saved.events.map((e: object) => ({ ...e, version: 99 })) };
+    assert.throws(() => Game.resume(fakeEngine(), other), /version/);
+    assert.throws(() => Game.resume(fakeEngine(), EMPTY_JOURNAL), /mal formé/);
+    assert.throws(() => Game.resume(fakeEngine(), { ...saved, head: "inconnu" }), /introuvable/);
+});
+
+test("le droit de doubler vient du moteur, seulement avant de lancer les dés", async () => {
+    let available = true;
+    const engine = fakeEngine({
+        cubeDecision: async () => ({ available, double: false, take: true }),
+    });
+    const game = Game.start(engine, {
+        dice: fixedDice([3, 1]),
+        setup: { position: "X", firstTurn: "player" },
+    });
+    assert.equal(await game.canDouble(), true);
+    available = false;
+    assert.equal(await game.canDouble(), false);
+    available = true;
+    await game.roll();
+    assert.equal(game.state.phase, "moving");
+    assert.equal(await game.canDouble(), false);
+});
+
+test("le plateau affiché est donné du point de vue de chaque camp", async () => {
+    const side = (pipCount: number) => ({ points: [], bar: 0, off: 0, pipCount });
+    const engine = fakeEngine({
+        board: async () => ({
+            onRoll: side(1),
+            opponent: side(2),
+            swappedPosition: "SWAPPED",
+            result: null,
+        }),
+    });
+    const playerTurn = Game.start(engine, { setup: { position: "X", firstTurn: "player" } });
+    const sides = await playerTurn.displayedBoard();
+    assert.equal(sides.player.pipCount, 1);
+    assert.equal(sides.computer.pipCount, 2);
+    const computerTurn = Game.start(engine, { setup: { position: "X", firstTurn: "computer" } });
+    const swapped = await computerTurn.displayedBoard();
+    assert.equal(swapped.player.pipCount, 2);
+    assert.equal(swapped.computer.pipCount, 1);
+});