Aucun coup possible : le joueur continue lui-même

Le tour du joueur ne passe plus tout seul quand son jet ne permet aucun
coup : le domaine le dit (cannotMove) et le joueur laisse passer son tour
(skipTurn, bouton « Continuer »). Les dés d'un jet sans coup, du joueur
comme de l'ordinateur, restent affichés barrés avec un message jusqu'à
l'action suivante. Scénario « Aucun coup possible avec votre jet ».

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

app/tests/full-game.test.ts

@@ -36,7 +36,12 @@ async function playToTheEnd(game: Game, engine: Awaited<ReturnType<typeof loadNo
         } else {
             assert.ok(state.roll !== null);
             const [first] = await engine.legalMoves(state.position, state.roll);
-            assert.ok(first !== undefined, "le joueur devrait avoir un coup");
+            if (first === undefined) {
+                // Aucun coup possible : le joueur laisse passer son tour.
+                assert.equal(await game.cannotMove(), true);
+                await game.skipTurn();
+                continue;
+            }
             for (const halfMove of first.halfMoves) {
                 assert.equal(await game.playHalfMove(halfMove), true);
             }

app/tests/game.test.ts

@@ -86,19 +86,40 @@ test("un coup se saisit demi-coup par demi-coup ; un demi-coup refusé ne change
     assert.equal(game.state.position, "SWAPPED");
 });
 
-test("sans coup possible, le tour passe", async () => {
+test("sans coup possible, le tour passe quand le joueur le laisse passer", async () => {
     const engine = fakeEngine({ legalMoves: async () => [] });
     const game = Game.start(engine, {
         dice: fixedDice([6, 6]),
         setup: { position: "BLOCKED", firstTurn: "player" },
     });
     await game.roll();
+    // Le tour ne passe pas tout seul : le jet reste à « jouer ».
+    assert.equal(game.state.phase, "moving");
+    assert.equal(game.state.turn, "player");
+    assert.equal(await game.cannotMove(), true);
+    await game.skipTurn();
     const last = game.events.at(-1);
     assert.ok(last?.type === "MovePlayed");
     assert.deepEqual(last.halfMoves, []);
     assert.equal(game.state.turn, "computer");
 });
 
+test("le joueur ne peut pas laisser passer son tour s'il a un coup", async () => {
+    const engine = fakeEngine({
+        legalMoves: async () => [
+            { notation: "8/5", halfMoves: [{ from: 8, to: 5 }], position: "P" },
+        ],
+    });
+    const game = Game.start(engine, {
+        dice: fixedDice([3, 1]),
+        setup: { position: "X", firstTurn: "player" },
+    });
+    await game.roll();
+    assert.equal(await game.cannotMove(), false);
+    await assert.rejects(game.skipTurn(), /coup possible/);
+    assert.equal(game.state.phase, "moving");
+});
+
 test("l'ordinateur double si le moteur le recommande ; le joueur prend", async () => {
     const engine = fakeEngine({
         cubeDecision: async () => ({ available: true, double: true, take: true }),

app/tests/steps/jouer-une-partie.steps.ts

@@ -33,6 +33,11 @@ const COMPUTER_DOUBLES = "6O5uAAC4uzsAAA";
 // l'ordinateur n'en a sorti aucun.
 const PLAYER_ALMOST_DONE = "/38AAABQAAAAAA";
 
+// Le joueur, au trait : un pion sur la barre, quatorze sur sa case 6.
+// L'ordinateur tient ses six premières cases (vos cases 19 à 24), où votre
+// pion devrait rentrer.
+const PLAYER_SHUT_OUT = "t+0OAADg/wcAQA";
+
 // L'ordinateur, au trait : un pion sur sa case 13, quatorze sur sa case 1.
 // Vous : un blot sur votre case 15 (sa case 10), deux pions sur votre case
 // 13 (sa case 12), douze sur votre case 6. Avec 3-1, son seul coup permis
@@ -193,6 +198,39 @@ Then(
     },
 );
 
+// ------------------------------------------------- Aucun coup possible
+
+Given("votre pion sur la barre ne peut pas rentrer", () => {
+    // Les six cases où il pourrait rentrer sont tenues par l'ordinateur.
+    game = Game.start(engine, {
+        setup: { position: PLAYER_SHUT_OUT, firstTurn: "player" },
+        dice: fixedDice([6, 5]),
+    });
+});
+
+When("vous lancez les dés", async () => {
+    await game.roll();
+});
+
+Then("aucun coup n'est possible avec votre jet", async () => {
+    assert.deepEqual(game.state.roll, [6, 5]);
+    assert.equal(await game.cannotMove(), true);
+    assert.deepEqual(await game.nextHalfMoves(), []);
+});
+
+Then("c'est toujours à vous", () => {
+    assert.equal(game.state.turn, "player");
+    assert.equal(game.state.phase, "moving");
+    assert.equal(lastEvent().type, "DiceRolled");
+});
+
+When("vous continuez", async () => {
+    await game.skipTurn();
+    const event = lastEvent();
+    assert.ok(event.type === "MovePlayed" && event.side === "player");
+    assert.deepEqual(event.halfMoves, []);
+});
+
 // ---------------------------------------------- Voir le coup de l'ordinateur
 
 Given("un de vos pions est seul à portée de l'ordinateur", () => {