Double toucher sans coup évident : un toucher simple ; tests navigateur adaptés aux raccourcis

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

app/src/domain/analysis/analyse.ts

@@ -102,10 +102,9 @@ export async function analyseDecision(
         if (analysis === null) {
             return null;
         }
-        const ranking =
-            options.ranking === false
-                ? []
-                : await engine.rankMoves(before.position, cube, before.roll, ply);
+        // Le classement est celui de l'analyse même : mêmes coups, mêmes
+        // niveaux et mêmes équités que le coup joué et le meilleur coup.
+        const ranking = options.ranking === false ? [] : analysis.ranking;
         const start = await engine.board(before.position, cube);
         const facts = async (move: EvaluatedMove) =>
             factsOf(start.onRoll, start.opponent, await engine.board(move.position, cube));

app/src/domain/analysis/numbers.ts

@@ -7,6 +7,7 @@
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
 
 import type { AdvisedMove, MoveAdvice } from "../game/advice.js";
+import type { Ply } from "../game/engine.js";
 
 /** Un nombre à la française, signé, à trois décimales : « −0,123 ». */
 export function formatEquity(value: number): string {
@@ -34,18 +35,21 @@ export interface RankingRow {
 
 /**
  * Le classement d'un conseil tel que l'affiche la feuille du maître : les
- * coups du classement du moteur, chacun avec son écart par rapport au
- * premier ; puis le coup joué, s'il n'y figure pas, avec l'écart de
- * l'analyse du coup joué.
+ * coups du classement de l'analyse, chacun avec son écart par rapport au
+ * premier ; puis le coup joué, s'il n'y figure pas. Le coup joué a toujours
+ * l'écart de l'analyse (equityLoss), celui que dit le maître.
  */
 export function rankingRows(advice: MoveAdvice): RankingRow[] {
     const first = advice.ranking[0]?.equity ?? advice.best.equity;
-    const rows = advice.ranking.map((move, i) => ({
-        move,
-        rank: i + 1,
-        loss: move.equity - first,
-        played: move.notation === advice.played.notation,
-    }));
+    const rows = advice.ranking.map((move, i) => {
+        const played = move.notation === advice.played.notation;
+        return {
+            move,
+            rank: i + 1,
+            loss: played ? advice.equityLoss : move.equity - first,
+            played,
+        };
+    });
     if (!rows.some((row) => row.played)) {
         rows.push({
             move: advice.played,
@@ -56,3 +60,18 @@ export function rankingRows(advice: MoveAdvice): RankingRow[] {
     }
     return rows;
 }
+
+/**
+ * Le niveau du classement d'un conseil : celui auquel le moteur a évalué le
+ * meilleur coup. C'est le niveau demandé (advice.ply), sauf quand gnubg
+ * s'arrête avant, parce qu'un seul coup a passé ses filtres : tout le
+ * classement reste alors au niveau inférieur.
+ */
+export function rankingPly(advice: MoveAdvice): Ply {
+    return advice.best.ply;
+}
+
+/** « 1 pli », « 2 plis » : gnubg compte les plis à partir de 0. */
+export function pliesText(ply: Ply): string {
+    return `${ply} ${ply > 1 ? "plis" : "pli"}`;
+}

app/src/domain/game/advice.ts

@@ -15,8 +15,10 @@ import type { HalfMove, PositionId } from "./position.js";
 import type { Roll } from "./roll.js";
 
 /** Version du format d'un conseil enregistré. Un conseil d'une autre
- * version est ignoré à la reprise (il peut être recalculé). */
-export const ADVICE_VERSION = 1;
+ * version est ignoré à la reprise (il peut être recalculé). Version 2 : le
+ * classement des coups vient de l'analyse du coup joué, et non plus d'un
+ * second classement comme la commande « hint » de gnubg. */
+export const ADVICE_VERSION = 2;
 
 /**
  * Le conseil du maître sur une décision du joueur : un coup ou une décision
@@ -66,8 +68,8 @@ export interface MoveAdvice {
     readonly best: AdvisedMove;
     readonly playedFacts: MoveFacts;
     readonly bestFacts: MoveFacts;
-    /** Les meilleurs coups du classement du moteur, du meilleur au moins
-     * bon (cinq au plus). */
+    /** Les meilleurs coups du classement de l'analyse, du meilleur au
+     * moins bon (cinq au plus), chacun au niveau où le moteur l'a évalué. */
     readonly ranking: readonly AdvisedMove[];
     /** Équité du coup joué moins celle du meilleur : 0 ou négative. */
     readonly equityLoss: number;

app/src/domain/game/engine.ts

@@ -80,17 +80,6 @@ export interface Engine {
         ply: Ply,
     ): Promise<MoveAnalysis | null>;
 
-    /** Les coups légaux d'un jet classés du meilleur au moins bon, au
-     * niveau ply, comme la commande « hint » de gnubg (les coups écartés
-     * par ses filtres gardent l'évaluation d'un niveau inférieur, voir leur
-     * ply). */
-    rankMoves(
-        position: PositionId,
-        cube: EngineCube,
-        roll: Roll,
-        ply: Ply,
-    ): Promise<EvaluatedMove[]>;
-
     /** L'analyse d'une décision de videau, position vue du joueur au trait
      * (celui qui double ou non ; take et pass sont la réponse de son
      * adversaire). */
@@ -222,6 +211,12 @@ export interface MoveAnalysis {
     /** Équité du coup joué moins celle du meilleur : 0 ou négative. */
     readonly equityLoss: number;
     readonly skill: Skill;
+    /** Le classement de l'analyse, du meilleur au moins bon (dix coups au
+     * plus) : la liste de l'analyse de partie de gnubg, chaque coup au
+     * niveau où gnubg l'a évalué (ply). Les coups écartés par ses filtres
+     * gardent l'évaluation d'un niveau inférieur ; le meilleur coup et le
+     * coup joué y ont les évaluations de best et played. */
+    readonly ranking: readonly EvaluatedMove[];
 }
 
 /** Décision de videau : doubler ou non (joueur au trait), prendre ou passer

app/src/domain/game/game.ts

@@ -365,6 +365,83 @@ export class Game {
         return moves.filter((_, i) => checks[i]?.valid === true);
     }
 
+    /**
+     * Le coup évident qui commence par le pion de from (une case du joueur,
+     * ou la barre : BAR), après les demi-coups already (par défaut, ceux
+     * déjà saisis) : les demi-coups qui le complètent, ou null s'il n'y en
+     * a pas
+     * (charte, ecrans-etape-1.md, 1i : le double toucher). Il existe quand
+     * un seul coup légal complet commence par ce pion, ou quand le moteur ne
+     * propose qu'un coup. Deux coups sont différents s'ils mènent à des
+     * positions différentes, comme dans la liste des coups de gnubg.
+     *
+     * Aucune règle n'est jugée ici : chaque demi-coup essayé est soumis au
+     * moteur (checkHalfMoves), qui dit s'il commence un coup légal et si le
+     * coup est complet. On parcourt ses réponses et on s'arrête dès que deux
+     * coups complets différents apparaissent.
+     */
+    async obviousMove(
+        from: number,
+        already: readonly HalfMove[] = this.pendingHalfMoves,
+    ): Promise<HalfMove[] | null> {
+        // Lus avant toute attente : la réponse vaut pour l'état de l'appel.
+        const state = this.state;
+        const pending = [...already];
+        if (state.turn !== "player" || state.phase !== "moving") {
+            return null;
+        }
+        const roll = rollToPlay(state);
+        const limit = (roll[0] === roll[1] ? 4 : 2) - pending.length;
+        if (limit <= 0) {
+            return null;
+        }
+        let displayed = state.position;
+        if (pending.length > 0) {
+            const check = await this.#engine.checkHalfMoves(state.position, roll, pending);
+            if (!check.valid || check.position === null) {
+                return null;
+            }
+            displayed = check.position;
+        }
+        const legal = await this.#engine.legalMoves(state.position, roll);
+        // Un seul coup légal : il est évident, quel que soit le pion.
+        const anyChecker = legal.length === 1;
+        const found = new Map<PositionId, HalfMove[]>();
+        const explore = async (sequence: HalfMove[], position: PositionId): Promise<void> => {
+            if (found.size > 1 || sequence.length >= limit) {
+                return;
+            }
+            const { player } = await this.#sideBoards(position, "player", state);
+            const starts = sequence.length === 0 && !anyChecker ? [from] : occupiedPoints(player);
+            const candidates = new Map<string, HalfMove>();
+            for (const start of starts) {
+                for (const die of roll) {
+                    const to = Math.max(start - die, OFF);
+                    candidates.set(`${start}/${to}`, { from: start, to });
+                }
+            }
+            for (const halfMove of candidates.values()) {
+                if (found.size > 1) {
+                    return;
+                }
+                const next = [...sequence, halfMove];
+                const check = await this.#engine.checkHalfMoves(state.position, roll, [
+                    ...pending,
+                    ...next,
+                ]);
+                if (!check.valid || check.position === null) {
+                    continue;
+                }
+                if (check.complete && !found.has(check.position)) {
+                    found.set(check.position, next);
+                }
+                await explore(next, check.position);
+            }
+        };
+        await explore([], displayed);
+        return found.size === 1 ? ([...found.values()][0] ?? null) : null;
+    }
+
     /** Le joueur peut-il doubler maintenant ? (Le moteur dit si le videau le
      * permet.) */
     async canDouble(): Promise<boolean> {

app/src/domain/prompts/prompts.ts

@@ -20,7 +20,13 @@ import {
     type ReviewedDecision,
     summarizeAnalysis,
 } from "../analysis/game-analysis.js";
-import { formatEquity, formatPercent, rankingRows } from "../analysis/numbers.js";
+import {
+    formatEquity,
+    formatPercent,
+    pliesText,
+    rankingPly,
+    rankingRows,
+} from "../analysis/numbers.js";
 import { diceWords, type MasterPhrases, masterWords } from "../analysis/phrases.js";
 import {
     type Advice,
@@ -83,7 +89,7 @@ const plural = (n: number, one: string, many: string) => `${n} ${n > 1 ? many :
 
 /** « analyse à 2 plis ». */
 export function plyText(ply: Ply): string {
-    return `analyse à ${ply} ${ply > 1 ? "plis" : "pli"}`;
+    return `analyse à ${pliesText(ply)}`;
 }
 
 /** Nombre de décisions analysées à partir duquel le niveau du joueur se
@@ -146,8 +152,14 @@ export function decisionPrompt(
         niveau_eval: plyText(data.advice.ply),
         appreciation: masterWords(phrases, data.advice).word,
     };
+    // Le niveau d'un classement de coups : celui de son meilleur coup, que
+    // le moteur a pu évaluer moins profondément que demandé.
     return data.advice.kind === "move"
-        ? fillPrompt(templates.move, { ...common, ...moveValues(data.advice) })
+        ? fillPrompt(templates.move, {
+              ...common,
+              niveau_eval: plyText(rankingPly(data.advice)),
+              ...moveValues(data.advice),
+          })
         : fillPrompt(templates.cube, { ...common, ...cubeValues(data.advice) });
 }
 
@@ -163,7 +175,10 @@ function moveValues(advice: MoveAdvice): Record<string, string> {
     // de « Voir les chiffres du moteur », avec les mêmes chiffres.
     const rows = rankingRows(advice).filter((row) => row.rank <= 3 || row.played);
     const ranking = rows.map((row) => {
-        const ply = row.move.ply === advice.ply ? "" : `, évalué à ${row.move.ply} pli`;
+        // Un coup écarté par les filtres du moteur garde l'évaluation d'un
+        // niveau inférieur à celui du classement : la ligne le dit.
+        const ply =
+            row.move.ply === rankingPly(advice) ? "" : `, évalué à ${pliesText(row.move.ply)}`;
         const mine = row.played ? " (mon coup)" : "";
         return `${row.rank}. ${row.move.notation}${mine} : équité ${formatEquity(row.move.equity)}, écart ${formatEquity(row.loss)}${ply}`;
     });

app/src/engine/wasm-engine.ts

@@ -182,6 +182,7 @@ export function createWasmEngine(run: RunCommand): Engine {
                 best: CliEvaluatedMove | null;
                 equity_loss: number;
                 skill: CliSkill;
+                ranking: CliEvaluatedMove[];
             };
             if (answer.rank === null || answer.played === null || answer.best === null) {
                 return null;
@@ -193,17 +194,10 @@ export function createWasmEngine(run: RunCommand): Engine {
                 best: toEvaluatedMove(answer.best),
                 equityLoss: answer.equity_loss,
                 skill: toSkill(answer.skill),
+                ranking: answer.ranking.map(toEvaluatedMove),
             };
         },
 
-        async rankMoves(position: PositionId, cube: EngineCube, roll: Roll, ply: Ply) {
-            const args = ["--ply", String(ply), "moves", position, await matchId(cube)];
-            const answer = (await run([...args, diceText(roll)])) as {
-                moves: CliEvaluatedMove[];
-            };
-            return answer.moves.map(toEvaluatedMove);
-        },
-
         async analyseCube(
             position: PositionId,
             cube: EngineCube,

app/src/ui/advice-texts.ts

@@ -26,8 +26,8 @@ export const ADVICE_TEXTS = {
     replay: "Rejouer le coup",
     numbers: "Voir les chiffres du moteur",
     you: "(vous)",
-    moveNote: (ply: number) =>
-        `Écart d'équité à ${ply} plis, par rapport au meilleur coup. Un écart de 0,03 ou moins reste un bon coup.`,
+    moveNote: (plies: string) =>
+        `Écart d'équité à ${plies}, par rapport au meilleur coup. Un écart de 0,03 ou moins reste un bon coup.`,
     cubeNote: (ply: number) =>
         `Équités de celui qui double, pour un videau de 1, à ${ply} plis. Écart de votre décision : `,
     cubeRows: {

app/src/ui/advice-view.ts

@@ -7,7 +7,7 @@
 // Copyright (C) 2026 les auteurs d'Ustagammon.
 // Licence : GPLv3 ou ultérieure (voir LICENSE).
 
-import { rankingRows } from "../domain/analysis/numbers.js";
+import { pliesText, rankingPly, rankingRows } from "../domain/analysis/numbers.js";
 import { type MasterPhrases, masterWords } from "../domain/analysis/phrases.js";
 import {
     type Advice,
@@ -304,7 +304,7 @@ export function createAdviceView(options: AdviceViewOptions): AdviceView {
             }
             element(details, "p", {
                 className: "explain-note",
-                text: ADVICE_TEXTS.moveNote(advice.ply),
+                text: ADVICE_TEXTS.moveNote(pliesText(rankingPly(advice))),
             });
         } else {
             // Les lignes de votre décision, en gras : doubler mène à l'une des

app/src/ui/app.ts

@@ -39,7 +39,7 @@ import type { Cube } from "../domain/game/cube.js";
 import type { MoveNotation } from "../domain/game/engine.js";
 import type { GameJournal } from "../domain/game/events.js";
 import type { Game, MoveSteps, NewGame, SideBoards } from "../domain/game/game.js";
-import type { HalfMove } from "../domain/game/position.js";
+import { BAR, type HalfMove } from "../domain/game/position.js";
 import { type PositionLink, type SharedPosition, setupOf } from "../domain/game/position-link.js";
 import type { SavedGameSummary } from "../domain/game/saved-game.js";
 import { otherSide, type Side } from "../domain/game/side.js";
@@ -50,6 +50,7 @@ import { createAdviceView, VERDICT_ICONS } from "./advice-view.js";
 import { createAnalysisView } from "./analysis-view.js";
 import { createPromptView, type PromptResult } from "./ask-ai.js";
 import { ASK_AI_TEXTS } from "./ask-ai-texts.js";
+import { attachDrag, createDoubleTap, nextPlace } from "./board-gestures.js";
 import {
     boardModel,
     moveTargets,
@@ -63,12 +64,16 @@ import {
 import {
     type BoardAdvice,
     type BoardDecor,
+    type BoardDrag,
     checkerSpot,
     type DiceAction,
     type MatchScore,
+    moveDraggedChecker,
     NO_MARKS,
     renderBoard,
+    returnDraggedChecker,
     type ShownDie,
+    type Spot,
     slideChecker,
 } from "./board-view.js";
 import { GAMES_TEXTS } from "./games-texts.js";
@@ -226,6 +231,20 @@ type ActionName =
     | "fullscreen"
     | "close";
 
+/** Le premier toucher d'un double toucher : la partie, le pion touché et
+ * les demi-coups saisis à ce moment-là. */
+interface ObviousTap {
+    readonly game: Game;
+    readonly place: Place;
+    readonly pending: readonly HalfMove[];
+}
+
+/** Le numéro, pour le domaine, d'un endroit du joueur : la barre (BAR) ou
+ * une case de 1 à 24. */
+function pointOf(place: Place): number {
+    return place === "bar-player" ? BAR : Number(place.slice(1));
+}
+
 /** Démarre l'écran de jeu dans la page (index.html). */
 export function startApp(options: AppOptions): void {
     const stripOf = (id: string) => {
@@ -375,7 +394,57 @@ export function startApp(options: AppOptions): void {
     ui.confirm.textContent = TEXTS.confirm;
     label(ui.cancel, TEXTS.cancel, "undo");
     ui.skip.textContent = TEXTS.skip;
-    ui.again.textContent = MATCH_TEXTS.replay;
+    const againLabel = document.createElement("span");
+    againLabel.textContent = MATCH_TEXTS.replay;
+    ui.again.replaceChildren(againLabel);
+    // Les raccourcis du clavier (interaction.md), en petite touche sur
+    // chaque bouton ; visibles seulement quand un clavier est détecté.
+    const shortcuts: [HTMLElement, string, string][] = [
+        [ui.roll, "Espace", "Space"],
+        [ui.confirm, "Espace", "Space"],
+        [ui.skip, "Espace", "Space"],
+        [ui.again, "Espace", "Space"],
+        [ui.double, "D", "D"],
+        [ui.take, "P", "P"],
+        [ui.drop, "N", "N"],
+        [ui.cancel, "Z", "Z"],
+        [ui.helpButton, "?", "?"],
+        [ui.fullscreenButton, "F", "F"],
+        [ui.menuButton, "M", "M"],
+    ];
+    for (const [button, key, aria] of shortcuts) {
+        const kbd = document.createElement("kbd");
+        kbd.className = "shortcut";
+        kbd.textContent = key;
+        kbd.setAttribute("aria-hidden", "true");
+        button.append(kbd);
+        button.setAttribute("aria-keyshortcuts", aria);
+    }
+    // Un clavier est détecté : sur un ordinateur (pointeur fin, écran
+    // large), ou dès qu'une touche est frappée ; un toucher du doigt les
+    // cache de nouveau.
+    const desktop = window.matchMedia("(hover: hover) and (pointer: fine) and (min-width: 64rem)");
+    const showShortcuts = (on: boolean) =>
+        document.documentElement.classList.toggle("keyboard", on);
+    showShortcuts(desktop.matches);
+    document.addEventListener(
+        "keydown",
+        (event) => {
+            if (!event.ctrlKey && !event.metaKey && !event.altKey && event.key !== "Unidentified") {
+                showShortcuts(true);
+            }
+        },
+        { capture: true },
+    );
+    document.addEventListener(
+        "pointerdown",
+        (event) => {
+            if (event.pointerType === "touch") {
+                showShortcuts(false);
+            }
+        },
+        { capture: true },
+    );
     ui.moveHint.textContent = TEXTS.moveHint;
     ui.doubleConfirm.textContent = TEXTS.double;
     ui.doubleCancel.textContent = TEXTS.cancel;
@@ -440,6 +509,20 @@ export function startApp(options: AppOptions): void {
     let sides: SideBoards | null = null;
     let targets = new Map<Place, Map<Place, HalfMove>>();
     let selected: Place | null = null;
+    // Le pion qu'on fait glisser (charte, 1i), et celui qui vient d'être
+    // lâché sur une case permise : il reste dessiné là où le doigt l'a
+    // posé jusqu'à ce que le moteur ait accepté le demi-coup, puis glisse
+    // à sa place (to).
+    let drag: BoardDrag | null = null;
+    let dropped: (BoardDrag & { readonly to: Place }) | null = null;
+    // Le pion lâché hors d'une case permise rentre à sa place.
+    let returning = false;
+    // Clavier : la case d'arrivée choisie aux flèches haut et bas, pour le
+    // pion choisi (selected) aux flèches gauche et droite.
+    let keyTarget: Place | null = null;
+    // Ceux qui attendent que l'écran soit libre (le double toucher qui suit
+    // un pion parti dès le premier toucher).
+    let idleWaiters: (() => void)[] = [];
     let canDouble = false;
     // Le joueur a lancé les dés mais ne peut pas jouer : il doit passer.
     let stuck = false;
@@ -636,6 +719,8 @@ export function startApp(options: AppOptions): void {
                         : null,
                 controls: landscape ? controls() : null,
                 advice: landscape && !panelShown ? boardAdvice(shownAdvice()) : null,
+                drag: drag ?? dropped,
+                focus: selected !== null && keyTarget !== null ? keyTarget : null,
             });
         }
         renderStrips(model.pipCount, state.phase === "over" ? null : state.turn);
@@ -681,7 +766,7 @@ export function startApp(options: AppOptions): void {
         show(ui.take, doubled);
         show(ui.drop, doubled);
         show(ui.again, over && panelDismissed);
-        ui.again.textContent = afterGameLabel(game);
+        againLabel.textContent = afterGameLabel(game);
         show(ui.replay, shownMove !== null);
         // Le coup de l'ordinateur montré : sa position se copie en lien.
         show(ui.copyLink, shownMove !== null && currentLink !== null);
@@ -1122,15 +1207,40 @@ export function startApp(options: AppOptions): void {
     async function settle(animate: boolean): Promise<void> {
         try {
             await update();
+            await settleDropped();
             if (animate && shownMove !== null) {
                 await animateMove(shownMove);
             }
         } finally {
             busy = false;
+            dropped = null;
             render();
+            const waiters = idleWaiters;
+            idleWaiters = [];
+            for (const resolve of waiters) {
+                resolve();
+            }
         }
     }
 
+    /** Le pion lâché sur une case permise : une fois le demi-coup accepté,
+     * il glisse de là où le doigt l'a posé jusqu'à sa place (duration-fast),
+     * ou y apparaît, si le système demande moins de mouvement. */
+    async function settleDropped(): Promise<void> {
+        const landing = dropped;
+        dropped = null;
+        if (landing === null || reducedMotion.matches) {
+            return;
+        }
+        render();
+        await slideChecker(ui.board, landing.to, landing.at, SLIDE_MS);
+    }
+
+    /** Résolue quand l'écran ne travaille plus (moteur, animation). */
+    function whenIdle(): Promise<void> {
+        return busy ? new Promise((resolve) => idleWaiters.push(resolve)) : Promise.resolve();
+    }
+
     /** Une action du joueur, puis le tour de l'ordinateur. Les touches sont
      * ignorées pendant ce temps. */
     async function act(action: (game: Game) => Promise<void> | void): Promise<void> {
@@ -1139,6 +1249,8 @@ export function startApp(options: AppOptions): void {
         }
         busy = true;
         selected = null;
+        keyTarget = null;
+        drag = null;
         targets = new Map();
         shownMove = null;
         bubbleSide = null;
@@ -1600,10 +1712,64 @@ export function startApp(options: AppOptions): void {
             if (await g.playHalfMove(halfMove)) {
                 const after = (await g.displayedBoard()).computer.bar;
                 haptic(after > before ? "checkerHit" : "checkerPlaced");
+            } else {
+                dropped = null;
             }
         });
     }
 
+    /**
+     * Double toucher (charte, 1i) : joue le coup évident (le domaine le
+     * cherche, le moteur le juge) qui commence par le pion touché, depuis
+     * l'état du premier toucher. Ce premier toucher a pu faire partir le
+     * pion tout de suite (une seule case d'arrivée) : il ne reste alors que
+     * la suite du coup. Sans coup évident, le second toucher n'est qu'un
+     * toucher : touchers rapides sur une même pile (un double, par exemple)
+     * et pion repris (touché deux fois : plus rien de choisi).
+     * L'appelant a pris l'écran (busy) : le moteur est seul à travailler.
+     */
+    async function playObvious(tap: ObviousTap): Promise<void> {
+        const g = game;
+        const now = g?.pendingHalfMoves ?? [];
+        const same = (a: HalfMove | undefined, b: HalfMove | undefined) =>
+            a !== undefined && b !== undefined && a.from === b.from && a.to === b.to;
+        let rest: HalfMove[] = [];
+        if (
+            g === tap.game &&
+            g.state.phase === "moving" &&
+            now.length >= tap.pending.length &&
+            tap.pending.every((h, i) => same(h, now[i]))
+        ) {
+            // Demandé seulement maintenant : un toucher simple ne coûte rien
+            // au moteur.
+            const obvious = await g.obviousMove(pointOf(tap.place), tap.pending).catch(() => null);
+            const done = now.slice(tap.pending.length);
+            if (obvious !== null && done.every((h, i) => same(h, obvious[i]))) {
+                rest = obvious.slice(done.length);
+            }
+        }
+        busy = false;
+        if (game !== g || g === null) {
+            render();
+            return;
+        }
+        if (rest.length === 0) {
+            tapPlace(tap.place);
+            return;
+        }
+        void act(async (g) => {
+            info = "";
+            const before = (await g.displayedBoard()).computer.bar;
+            for (const halfMove of rest) {
+                if (!(await g.playHalfMove(halfMove))) {
+                    break;
+                }
+            }
+            const after = (await g.displayedBoard()).computer.bar;
+            haptic(after > before ? "checkerHit" : "checkerPlaced");
+        });
+    }
+
     const canAct = (): Game | null => (busy || game === null ? null : game);
 
     const actions: Record<ActionName, () => void> = {
@@ -2412,10 +2578,75 @@ export function startApp(options: AppOptions): void {
     ui.replay.onclick = actions.replay;
     ui.again.onclick = actions.again;
 
+    // Glisser un pion (charte, 1i) : il suit le doigt, agrandi et un peu
+    // au-dessus ; un fantôme reste à son départ et ses cases d'arrivée (du
+    // moteur) sont marquées. Lâché sur l'une d'elles, il s'y pose ; ailleurs,
+    // il rentre à sa place, sans vibration ni message.
+    const dragging = attachDrag(ui.board, {
+        canStart: (place) =>
+            !busy && !animating && !returning && game !== null && targets.has(place),
+        start: (place, at) => {
+            closeTransient();
+            selected = place;
+            keyTarget = null;
+            shownMove = null;
+            drag = { place, at };
+            render();
+        },
+        move: (at) => {
+            if (drag !== null) {
+                drag = { place: drag.place, at };
+                moveDraggedChecker(ui.board, at);
+            }
+        },
+        drop: (over, at) => {
+            if (drag === null) {
+                return;
+            }
+            const from = drag.place;
+            const halfMove = over === null ? undefined : targets.get(from)?.get(over);
+            if (halfMove === undefined || over === null || busy) {
+                void dragBack(at);
+                return;
+            }
+            dropped = { place: from, at, to: over };
+            drag = null;
+            playHalfMove(halfMove);
+        },
+        cancel: (at) => void dragBack(at),
+    });
+
+    /** Le pion glissé rentre à sa place (duration-fast), puis le plateau
+     * redevient celui d'avant le glissement. */
+    async function dragBack(at: Spot): Promise<void> {
+        if (drag === null) {
+            return;
+        }
+        drag = { place: drag.place, at };
+        returning = true;
+        try {
+            if (!reducedMotion.matches) {
+                await returnDraggedChecker(ui.board, at, SLIDE_MS);
+            }
+        } finally {
+            returning = false;
+            drag = null;
+            selected = null;
+            render();
+        }
+    }
+
+    // Double toucher : le premier toucher fait ce que fait un toucher, et
+    // demande déjà au domaine le coup évident de ce pion ; le second le joue.
+    const doubleTap = createDoubleTap<ObviousTap | null>();
+
     // Toucher le plateau : une commande (dés, videau, colonne de gauche), ou
     // un pion jouable puis une de ses cases d'arrivée (ou aucune, s'il n'en a
     // qu'une : il y va tout de suite).
     ui.board.addEventListener("click", (event) => {
+        if (dragging.takeClick()) {
+            return;
+        }
         const target = event.target as Element | null;
         if (!ui.bubble.hidden) {
             closeOverlays();
@@ -2431,9 +2662,29 @@ export function startApp(options: AppOptions): void {
             return;
         }
         const place = target?.closest("[data-place]")?.getAttribute("data-place") as Place | null;
-        if (busy || place == null) {
+        if (place == null || game === null) {
             return;
         }
+        const current = game;
+        const second = doubleTap.tap(place, performance.now(), () =>
+            busy || !targets.has(place)
+                ? null
+                : { game: current, place, pending: [...current.pendingHalfMoves] },
+        );
+        if (second !== null) {
+            doubleTapped(second);
+            return;
+        }
+        if (!busy) {
+            tapPlace(place);
+        }
+    });
+
+    /** Un toucher simple sur un endroit du plateau : le pion choisi va sur
+     * cette case d'arrivée ; ou ce pion part tout de suite, s'il n'a qu'une
+     * case d'arrivée ; ou il est choisi (touché de nouveau : plus rien). */
+    function tapPlace(place: Place): void {
+        keyTarget = null;
         const halfMove = selected === null ? undefined : targets.get(selected)?.get(place);
         if (halfMove !== undefined) {
             playHalfMove(halfMove);
@@ -2449,7 +2700,83 @@ export function startApp(options: AppOptions): void {
             shownMove = null; // toucher un pion : le coup de l'ordinateur s'efface
         }
         render();
-    });
+    }
+
+    /** Le second toucher d'un double toucher : l'écran le prend tout de
+     * suite (réponse immédiate), ou dès qu'il a fini l'effet du premier. */
+    function doubleTapped(tap: ObviousTap): void {
+        const claim = () => {
+            if (busy) {
+                return;
+            }
+            busy = true;
+            render();
+            void playObvious(tap);
+        };
+        if (busy) {
+            void whenIdle().then(claim);
+        } else {
+            claim();
+        }
+    }
+
+    /**
+     * Le plateau au clavier (interaction.md) : les flèches gauche et droite
+     * choisissent un pion jouable (dans le sens de la course), haut et bas
+     * une de ses cases d'arrivée (anneau focus), Entrée l'y pose. Les cases
+     * sont celles que le moteur a données. Renvoie vrai si la touche a
+     * servi.
+     */
+    function boardKey(key: string, onButton: boolean): boolean {
+        const g = game;
+        const open =
+            !ui.game.hidden &&
+            ui.menuVeil.hidden &&
+            ui.doubleVeil.hidden &&
+            ui.explainVeil.hidden &&
+            g !== null &&
+            g.state.turn === "player" &&
+            g.state.phase === "moving";
+        if (!open || targets.size === 0) {
+            return false;
+        }
+        const landings = selected === null ? undefined : targets.get(selected);
+        switch (key) {
+            case "ArrowLeft":
+            case "ArrowRight": {
+                if (busy) {
+                    return true;
+                }
+                selected = nextPlace(targets.keys(), selected, key === "ArrowRight" ? 1 : -1);
+                const tos = selected === null ? undefined : targets.get(selected);
+                keyTarget = tos === undefined ? null : nextPlace(tos.keys(), null, 1);
+                shownMove = null;
+                render();
+                return true;
+            }
+            case "ArrowUp":
+            case "ArrowDown":
+                if (busy || landings === undefined) {
+                    return landings !== undefined;
+                }
+                keyTarget = nextPlace(landings.keys(), keyTarget, key === "ArrowDown" ? 1 : -1);
+                render();
+                return true;
+            case "Enter": {
+                const halfMove =
+                    keyTarget === null || landings === undefined
+                        ? undefined
+                        : landings.get(keyTarget);
+                if (onButton || halfMove === undefined || busy) {
+                    return false;
+                }
+                keyTarget = null;
+                playHalfMove(halfMove);
+                return true;
+            }
+        }
+        return false;
+    }
 
     // Clavier (interaction.md) : les mêmes actions que les touchers.
     document.addEventListener("keydown", (event) => {
@@ -2476,6 +2803,10 @@ export function startApp(options: AppOptions): void {
             analysisView.step(event.key === "ArrowLeft" ? -1 : 1);
             return;
         }
+        if (boardKey(event.key, onButton)) {
+            event.preventDefault();
+            return;
+        }
         let name: ActionName | null = null;
         switch (event.key) {
             case " ":

app/src/ui/board-gestures.ts

@@ -0,0 +1,212 @@
+// Les gestes sur le plateau : glisser-déposer et double toucher (charte,
+// docs/identite/charte/ecrans-etape-1.md, 1i), et l'ordre des pions et des
+// cases au clavier (interaction.md).
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Un seul code pour la souris, le doigt et le stylet : les Pointer Events.
+// Ce module ne connaît ni la partie ni le moteur : il dit où le pion est
+// pris, où il passe et où il est lâché ; l'écran décide (app.ts), avec les
+// cases d'arrivée que le moteur a données.
+
+import type { Place } from "./board-model.js";
+import type { Spot } from "./board-view.js";
+
+/** Au-delà de cette distance (px à l'écran), un appui devient un glissement :
+ * en deçà, c'est un toucher. */
+const DRAG_THRESHOLD_PX = 8;
+/** Le pion glissé est dessiné au-dessus du doigt, pour rester visible
+ * (charte, 1i). */
+const LIFT_PX = 12;
+/** Deux touchers sur le même pion à moins de tant de ms : un double
+ * toucher. */
+export const DOUBLE_TAP_MS = 350;
+/** Après un glissement, le « click » que le navigateur envoie au lâcher
+ * n'est pas un toucher. */
+const CLICK_AFTER_DRAG_MS = 400;
+
+/** Ce que l'écran fait d'un glissement. */
+export interface DragHandlers {
+    /** Ce pion peut-il partir maintenant (pion jouable, moteur libre) ? */
+    canStart(place: Place): boolean;
+    /** Le pion de place commence à glisser ; at : son centre, dans le repère
+     * du dessin. */
+    start(place: Place, at: Spot): void;
+    move(at: Spot): void;
+    /** Le pion est lâché en at, au-dessus de over (null : hors de toute
+     * zone du plateau). */
+    drop(over: Place | null, at: Spot): void;
+    /** Le glissement est interrompu par le navigateur (appel, geste du
+     * système) : le pion rentre. */
+    cancel(at: Spot): void;
+}
+
+/** L'endroit du plateau sous un élément touché (sa zone data-place). */
+function placeOf(target: EventTarget | null): Place | null {
+    if (!(target instanceof Element)) {
+        return null;
+    }
+    return (target.closest("[data-place]")?.getAttribute("data-place") as Place | null) ?? null;
+}
+
+/** Le point du dessin sous le pointeur, remonté de LIFT_PX vers le haut du
+ * plateau (null si le dessin n'est pas affiché). */
+function liftedPoint(svg: SVGSVGElement, event: PointerEvent): Spot | null {
+    const matrix = svg.getScreenCTM();
+    if (matrix === null) {
+        return null;
+    }
+    const point = new DOMPoint(event.clientX, event.clientY).matrixTransform(matrix.inverse());
+    const unit = 1 / (Math.hypot(matrix.a, matrix.b) || 1);
+    return { x: point.x, y: point.y - LIFT_PX * unit };
+}
+
+/** La zone du plateau (data-place) qui contient at, dans le repère du
+ * dessin (null : aucune). */
+export function placeAtSpot(svg: SVGSVGElement, at: Spot): Place | null {
+    for (const hit of svg.querySelectorAll(".hit[data-place]")) {
+        const number = (name: string) => Number(hit.getAttribute(name));
+        const x = number("x");
+        const y = number("y");
+        if (at.x >= x && at.x <= x + number("width") && at.y >= y && at.y <= y + number("height")) {
+            return hit.getAttribute("data-place") as Place;
+        }
+    }
+    return null;
+}
+
+/**
+ * Branche le glisser-déposer sur le plateau svg. Renvoie takeClick : vrai
+ * si le « click » reçu suit un glissement (il faut alors l'ignorer).
+ */
+export function attachDrag(svg: SVGSVGElement, handlers: DragHandlers): { takeClick(): boolean } {
+    let press: { id: number; place: Place; x: number; y: number } | null = null;
+    let dragging = false;
+    let clickIgnoredUntil = 0;
+    svg.addEventListener("pointerdown", (event) => {
+        if (!event.isPrimary || event.button !== 0) {
+            return;
+        }
+        const place = placeOf(event.target);
+        press =
+            place !== null && handlers.canStart(place)
+                ? { id: event.pointerId, place, x: event.clientX, y: event.clientY }
+                : null;
+        dragging = false;
+    });
+    svg.addEventListener("pointermove", (event) => {
+        if (press === null || event.pointerId !== press.id) {
+            return;
+        }
+        const at = liftedPoint(svg, event);
+        if (at === null) {
+            return;
+        }
+        if (dragging) {
+            handlers.move(at);
+            return;
+        }
+        const distance = Math.hypot(event.clientX - press.x, event.clientY - press.y);
+        if (distance < DRAG_THRESHOLD_PX) {
+            return;
+        }
+        if (!handlers.canStart(press.place)) {
+            press = null;
+            return;
+        }
+        dragging = true;
+        // Le plateau est redessiné pendant le glissement : c'est lui, et non
+        // la zone touchée, qui reçoit la suite du geste.
+        try {
+            svg.setPointerCapture(event.pointerId);
+        } catch {
+            // Sans capture, les événements remontent quand même au plateau.
+        }
+        handlers.start(press.place, at);
+    });
+    const end = (event: PointerEvent, cancelled: boolean) => {
+        if (press === null || event.pointerId !== press.id) {
+            return;
+        }
+        const wasDragging = dragging;
+        press = null;
+        dragging = false;
+        if (!wasDragging) {
+            return;
+        }
+        clickIgnoredUntil = performance.now() + CLICK_AFTER_DRAG_MS;
+        const at = liftedPoint(svg, event) ?? { x: 0, y: 0 };
+        if (cancelled) {
+            handlers.cancel(at);
+        } else {
+            handlers.drop(placeAtSpot(svg, at), at);
+        }
+    };
+    svg.addEventListener("pointerup", (event) => end(event, false));
+    svg.addEventListener("pointercancel", (event) => end(event, true));
+    return {
+        takeClick: () => {
+            const ignored = performance.now() < clickIgnoredUntil;
+            clickIgnoredUntil = 0;
+            return ignored;
+        },
+    };
+}
+
+/**
+ * Reconnaît le double toucher : tap(place, now, first) renvoie ce que first
+ * a produit au premier toucher quand celui-ci est le second, sur le même
+ * endroit, à moins de DOUBLE_TAP_MS ; sinon null, et ce toucher devient le
+ * premier (first() n'est appelé que pour lui).
+ */
+export function createDoubleTap<T>(): {
+    tap(place: Place, now: number, first: () => T): T | null;
+} {
+    let last: { place: Place; time: number; data: T } | null = null;
+    return {
+        tap(place, now, first) {
+            if (last !== null && last.place === place && now - last.time < DOUBLE_TAP_MS) {
+                const data = last.data;
+                last = null;
+                return data;
+            }
+            last = { place, time: now, data: first() };
+            return null;
+        },
+    };
+}
+
+/** Le numéro d'un endroit dans le sens de la course du joueur : la barre
+ * (25), les cases de 24 à 1, la sortie (0). */
+function raceOrder(place: Place): number {
+    if (place.startsWith("bar-")) {
+        return 25;
+    }
+    if (place.startsWith("off-")) {
+        return 0;
+    }
+    return Number(place.slice(1));
+}
+
+/**
+ * Clavier : l'endroit suivant (step 1) ou précédent (step -1) de places
+ * après current, dans le sens de la course du joueur (de la barre vers la
+ * sortie), en bouclant. Sans current (ou s'il n'en fait pas partie), le
+ * premier dans ce sens. null si places est vide.
+ */
+export function nextPlace(
+    places: Iterable<Place>,
+    current: Place | null,
+    step: 1 | -1,
+): Place | null {
+    const sorted = [...places].sort((a, b) => raceOrder(b) - raceOrder(a));
+    if (sorted.length === 0) {
+        return null;
+    }
+    const index = current === null ? -1 : sorted.indexOf(current);
+    if (index === -1) {
+        return (step === 1 ? sorted[0] : sorted.at(-1)) ?? null;
+    }
+    return sorted[(index + step + sorted.length) % sorted.length] ?? null;
+}

app/src/ui/board-view.ts

@@ -86,8 +86,23 @@ export interface BoardDecor {
     /** Paysage : le conseil du maître, une pastille avant la consigne dans
      * la bande centrale (absent ou null : rien). */
     readonly advice?: BoardAdvice | null;
+    /** Le pion qu'on fait glisser (absent ou null : aucun). */
+    readonly drag?: BoardDrag | null;
+    /** Clavier : l'endroit qui a le focus (anneau focus ; absent ou null :
+     * aucun). */
+    readonly focus?: Place | null;
 }
 
+/** Un pion qu'on fait glisser : il a quitté place (un fantôme en
+ * pointillés y reste) et son centre est en at, dans le repère du dessin. */
+export interface BoardDrag {
+    readonly place: Place;
+    readonly at: Spot;
+}
+
+/** Le pion qu'on fait glisser est agrandi (charte, 1i : 115 %). */
+export const DRAG_SCALE = 1.15;
+
 /** Le conseil du maître en paysage : son mot, sur une pastille qui mène à
  * la feuille d'explication. */
 export interface BoardAdvice {
@@ -203,6 +218,9 @@ export function renderBoard(
     }
     svg.append(pieces);
     drawLandings(svg, g, board, decor.targets);
+    if (decor.focus != null) {
+        drawFocus(svg, g, board, decor.focus, decor.targets.has(decor.focus));
+    }
     const advice = decor.band !== null ? (decor.advice ?? null) : null;
     const chip = advice === null ? 0 : adviceChipWidth(g, advice) + 8;
     if (decor.band !== null) {
@@ -235,6 +253,9 @@ export function renderBoard(
     if (advice !== null) {
         drawAdviceChip(svg, g, hits, advice);
     }
+    if (decor.drag != null) {
+        drawDrag(svg, g, decor.drag);
+    }
     // Les zones à toucher passent devant tout le reste.
     svg.append(hits);
 }
@@ -359,18 +380,13 @@ function drawStack(
             classes.push("movable");
         }
         const { x, y } = slotCenter(g, place, i);
-        const checker = add(svg, "circle", {
-            class: classes.join(" "),
-            cx: x,
-            cy: y,
-            r: g.radius,
-        });
+        const piece = addPiece(svg, g, side, classes.join(" "), { x, y });
         if (last) {
-            checker.setAttribute("data-checker", place);
+            piece.setAttribute("data-checker", place);
         }
         if (last && count > limit) {
             add(
-                svg,
+                piece,
                 "text",
                 {
                     class: `checker-count count-${side}`,
@@ -481,6 +497,23 @@ function drawTray(
     });
 }
 
+/**
+ * Un pion vu de dessus, centré en spot : son disque (classes cssClass) et
+ * son filet intérieur, l'écho du logo (charte, board.js : rayon 12 pour un
+ * pion de 20). Les deux sont groupés : c'est le groupe qui glisse.
+ */
+function addPiece(svg: Element, g: Geometry, side: Side, cssClass: string, spot: Spot): SVGElement {
+    const piece = add(svg, "g", { class: "piece" });
+    add(piece, "circle", { class: cssClass, cx: spot.x, cy: spot.y, r: g.radius });
+    add(piece, "circle", {
+        class: `checker-ring ring-${side}`,
+        cx: spot.x,
+        cy: spot.y,
+        r: g.radius * 0.6,
+    });
+    return piece;
+}
+
 /** Une tranche de pion sorti, centrée en spot. */
 function addSlab(svg: Element, g: Geometry, cssClass: string, spot: Spot): SVGElement {
     return add(svg, "rect", {
@@ -810,13 +843,87 @@ export function checkerSpot(svg: SVGSVGElement, place: Place): Spot | null {
     if (checker === null) {
         return null;
     }
-    const number = (name: string) => Number(checker.getAttribute(name));
-    if (checker.tagName === "circle") {
+    return shapeCenter(checker.tagName === "g" ? (checker.firstElementChild ?? checker) : checker);
+}
+
+/** Le centre d'un disque (cx, cy) ou d'un rectangle (x, y, largeur, hauteur). */
+function shapeCenter(shape: Element): Spot {
+    const number = (name: string) => Number(shape.getAttribute(name));
+    if (shape.tagName === "circle") {
         return { x: number("cx"), y: number("cy") };
     }
     return { x: number("x") + number("width") / 2, y: number("y") + number("height") / 2 };
 }
 
+/**
+ * Le pion qu'on fait glisser : le pion de départ devient un fantôme en
+ * pointillés, et un pion agrandi est dessiné en drag.at, devant les autres.
+ * Il se déplace par son attribut transform (moveDraggedChecker), sans
+ * redessiner le plateau.
+ */
+function drawDrag(svg: SVGSVGElement, g: Geometry, drag: BoardDrag): void {
+    svg.querySelector(`[data-checker="${drag.place}"]`)?.classList.add("drag-origin");
+    const group = add(svg, "g", {
+        class: "drag-piece",
+        id: "drag-piece",
+        transform: dragTransform(drag.at, DRAG_SCALE),
+    });
+    addPiece(group, g, "player", "checker checker-player dragged", { x: 0, y: 0 });
+}
+
+function dragTransform(at: Spot, scale: number): string {
+    return `translate(${at.x} ${at.y}) scale(${scale})`;
+}
+
+/** Déplace le pion qu'on fait glisser en at (repère du dessin). */
+export function moveDraggedChecker(svg: SVGSVGElement, at: Spot): void {
+    svg.querySelector("#drag-piece")?.setAttribute("transform", dragTransform(at, DRAG_SCALE));
+}
+
+/**
+ * Ramène le pion qu'on fait glisser à son départ (le centre du fantôme), en
+ * ms millisecondes, et à sa taille ; résolue à la fin (animation du
+ * navigateur, sans bibliothèque).
+ */
+export async function returnDraggedChecker(
+    svg: SVGSVGElement,
+    from: Spot,
+    ms: number,
+): Promise<void> {
+    const piece = svg.querySelector("#drag-piece");
+    const origin = svg.querySelector(".drag-origin");
+    if (piece === null || origin === null || typeof piece.animate !== "function") {
+        return;
+    }
+    const to = shapeCenter(origin.firstElementChild ?? origin);
+    const animation = piece.animate(
+        [
+            { transform: `translate(${from.x}px, ${from.y}px) scale(${DRAG_SCALE})` },
+            { transform: `translate(${to.x}px, ${to.y}px) scale(1)` },
+        ],
+        { duration: ms, easing: EASING_STANDARD, fill: "forwards" },
+    );
+    await animation.finished.catch(() => undefined);
+}
+
+/** Clavier : l'anneau focus autour de l'endroit choisi, sur la case
+ * d'arrivée (target) ou sur le pion du dessus. */
+function drawFocus(
+    svg: SVGSVGElement,
+    g: Geometry,
+    board: BoardModel,
+    place: Place,
+    target: boolean,
+): void {
+    const count = countAt(board, "player", place);
+    const index = target
+        ? place.startsWith("off-")
+            ? count
+            : Math.min(count, MAX_STACK - 1)
+        : Math.max(topIndex(g, board, "player", place), 0);
+    addRing(svg, g, "key-focus", place, slotCenter(g, place, index), g.radius + 5);
+}
+
 /** Courbe de tout ce qui se déplace (interaction.md, easing-standard). */
 export const EASING_STANDARD = "cubic-bezier(0.2, 0, 0, 1)";
 

app/tests/board-gestures.test.ts

@@ -0,0 +1,45 @@
+// Les gestes du plateau qui se vérifient sans navigateur : le double toucher
+// et l'ordre des pions et des cases au clavier. Le glisser-déposer lui-même
+// est joué dans un navigateur (tests/browser/plateau.mjs).
+//
+// 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 { createDoubleTap, DOUBLE_TAP_MS, nextPlace } from "../src/ui/board-gestures.js";
+import type { Place } from "../src/ui/board-model.js";
+
+test("double toucher : deux touchers rapprochés sur le même endroit", () => {
+    const taps = createDoubleTap<string>();
+    let firsts = 0;
+    const first = () => {
+        firsts++;
+        return `premier ${firsts}`;
+    };
+    assert.equal(taps.tap("p8", 0, first), null);
+    assert.equal(taps.tap("p8", DOUBLE_TAP_MS - 1, first), "premier 1");
+    // Le troisième toucher recommence un double toucher.
+    assert.equal(taps.tap("p8", DOUBLE_TAP_MS, first), null);
+    // Trop lent : un nouveau premier toucher.
+    assert.equal(taps.tap("p8", 3 * DOUBLE_TAP_MS, first), null);
+    // Un autre endroit : un nouveau premier toucher.
+    assert.equal(taps.tap("p6", 3 * DOUBLE_TAP_MS + 10, first), null);
+    assert.equal(taps.tap("p6", 3 * DOUBLE_TAP_MS + 20, first), "premier 4");
+    assert.equal(firsts, 4);
+});
+
+test("clavier : les pions dans le sens de la course, en boucle", () => {
+    const places: Place[] = ["p6", "bar-player", "p13", "p8"];
+    assert.equal(nextPlace(places, null, 1), "bar-player");
+    assert.equal(nextPlace(places, null, -1), "p6");
+    assert.equal(nextPlace(places, "bar-player", 1), "p13");
+    assert.equal(nextPlace(places, "p8", 1), "p6");
+    assert.equal(nextPlace(places, "p6", 1), "bar-player");
+    assert.equal(nextPlace(places, "bar-player", -1), "p6");
+    // Un endroit qui n'est plus jouable : on repart du début.
+    assert.equal(nextPlace(places, "p24", 1), "bar-player");
+    assert.equal(nextPlace([], null, 1), null);
+    // Les cases d'arrivée, sortie comprise.
+    assert.equal(nextPlace(["off-player", "p2"], "p2", 1), "off-player");
+});

app/tests/engine-analysis.test.ts

@@ -35,6 +35,35 @@ test("ouverture 3-1 : 24/23 13/10 est une erreur très mauvaise, 8/5 6/5 le meil
         Math.abs(analysis.equityLoss - (analysis.played.equity - analysis.best.equity)) < 1e-6,
     );
     assert.ok(analysis.equityLoss < -SKILL_THRESHOLDS.veryBad);
+    // Le classement de l'analyse, comme gnubg de bureau
+    // (tests/reference/analysis/move-opening-31-error.json) : le meilleur
+    // coup et le coup joué, une erreur, réévalués à 2 plis ; les suivants
+    // restés à 1 pli, puis à 0, écartés par les filtres.
+    assert.deepEqual(analysis.ranking[0], analysis.best);
+    assert.deepEqual(analysis.ranking[1], analysis.played);
+    assert.deepEqual(
+        analysis.ranking.map((move) => move.ply),
+        [2, 2, 1, 1, 1, 0, 0, 0, 0, 0],
+    );
+});
+
+test("ouverture 3-1 jouée 8/5 6/5 : un seul coup passe le filtre, tout reste à 1 pli", async () => {
+    const engine = await loadNodeEngine();
+    const analysis = await engine.analyseMove(
+        START_POSITION,
+        centered,
+        [3, 1],
+        "4HPwATCwZ/ABMA",
+        2,
+    );
+    assert.ok(analysis !== null);
+    assert.equal(analysis.rank, 1);
+    assert.deepEqual(analysis.ranking[0], analysis.best);
+    assert.deepEqual(analysis.best, analysis.played);
+    assert.deepEqual(
+        analysis.ranking.slice(0, 5).map((move) => move.ply),
+        [1, 1, 1, 1, 1],
+    );
 });
 
 test("sans coup possible, il n'y a rien à analyser", async () => {

app/tests/game.test.ts

@@ -73,7 +73,6 @@ function fakeEngine(overrides: Partial<Engine> = {}): Engine {
             };
         },
         analyseMove: async () => null,
-        rankMoves: async () => [],
         analyseCube: async () => ({
             analysed: false,
             equities: null,

app/tests/obvious-move.test.ts

@@ -0,0 +1,82 @@
+// Le coup évident du double toucher (charte, ecrans-etape-1.md, 1i), sur le
+// vrai moteur WebAssembly : un seul coup légal complet commence par le pion
+// touché, ou le moteur ne propose qu'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 type { Engine } from "../src/domain/game/engine.js";
+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 : un pion sur sa case 6, un sur sa case 1.
+const SIX_AND_ONE = "BQAACAIAAAAAAA";
+// Le joueur, au trait : deux pions, sur ses cases 6 et 5.
+const PLAYER_ALMOST_DONE = "/38AAABQAAAAAA";
+
+let engine: Engine | null = null;
+async function loaded(): Promise<Engine> {
+    engine ??= await loadNodeEngine();
+    return engine;
+}
+
+/** Une partie à partir d'une position, joueur au trait, dés lancés. */
+async function from(position: string, dice: [number, number]): Promise<Game> {
+    const game = Game.start(await loaded(), {
+        setup: { position, firstTurn: "player" },
+        dice: fixedDice(dice),
+    });
+    await game.roll();
+    return game;
+}
+
+function text(halfMoves: readonly HalfMove[] | null): string | null {
+    return halfMoves === null ? null : formatHalfMoves(halfMoves);
+}
+
+test("au départ avec 3-1 : plusieurs coups commencent par chaque pion, rien d'évident", async () => {
+    const game = Game.start(await loaded(), { dice: fixedDice([3, 1]) });
+    for (const point of [24, 13, 8, 6]) {
+        assert.equal(await game.obviousMove(point), null, `pion de la ${point}`);
+    }
+    // Rien n'a été saisi.
+    assert.deepEqual(game.pendingHalfMoves, []);
+});
+
+test("6-1 avec des pions sur 6 et 1 : seul le pion de la 1 a un coup évident", async () => {
+    const game = await from(SIX_AND_ONE, [6, 1]);
+    // 1/off, puis le 6 sort l'autre pion : un seul coup.
+    assert.equal(text(await game.obviousMove(1)), "1/off 6/off");
+    // Depuis la 6 : 6/off 1/off, ou 6/5/off (le pion de la 1 reste).
+    assert.equal(await game.obviousMove(6), null);
+    // Une case sans pion n'a pas de coup.
+    assert.equal(await game.obviousMove(3), null);
+});
+
+test("un seul coup légal : il est évident depuis chaque pion, même à moitié saisi", async () => {
+    const game = await from(PLAYER_ALMOST_DONE, [6, 6]);
+    assert.equal((await (await loaded()).legalMoves(game.state.position, [6, 6])).length, 1);
+    const fromFive = await game.obviousMove(5);
+    const fromSix = await game.obviousMove(6);
+    assert.ok(fromFive !== null && fromSix !== null);
+    assert.equal(fromFive.length, 2);
+    assert.equal(fromSix.length, 2);
+    // Une fois 6/off saisi, il ne reste que 5/off.
+    assert.equal(await game.playHalfMove({ from: 6, to: 0 }), true);
+    assert.equal(text(await game.obviousMove(5)), "5/off");
+    // Le coup évident se joue tel quel, demi-coup par demi-coup.
+    for (const halfMove of (await game.obviousMove(5)) ?? []) {
+        assert.equal(await game.playHalfMove(halfMove), true);
+    }
+    assert.equal(game.moveComplete, true);
+});
+
+test("hors du tour de jeu du joueur, aucun coup évident", async () => {
+    const game = Game.start(await loaded(), { dice: fixedDice([1, 3]) });
+    assert.equal(game.state.turn, "computer");
+    assert.equal(await game.obviousMove(13), null);
+});

app/tests/prompts.test.ts

@@ -239,7 +239,97 @@ test("prompt d'un coup : la position, les identifiants et le top 3 du moteur, m
             assert.ok(shown.includes(`${row.move.notation}|${formatEquity(row.loss)}`));
         }
         assert.ok(prompt.includes(`1. ${advice.best.notation}`), prompt);
-        assert.ok(prompt.includes("analyse à 2 plis"), prompt);
+        assert.match(prompt, /\(analyse à [12] plis?\)/);
+    }
+});
+
+/** Une équité écrite (« −0,212 ») proche d'une équité de gnubg de bureau :
+ * à l'arrondi près, plus la tolérance des positions de référence (0,002 ;
+ * tests/reference/README.md), le moteur WebAssembly ne calculant pas au
+ * bit près comme gnubg de bureau (ADR 0005). */
+function assertNear(text: string, value: number, message: string): void {
+    const written = Number(text.replace("−", "-").replace("+", "").replace(",", "."));
+    assert.ok(Math.abs(written - value) <= 0.0005 + 0.002, `${text} ≠ ${value}\n${message}`);
+}
+
+/** Le niveau du titre du classement, et chaque ligne du classement : coup,
+ * équité, écart, niveau propre (null : celui du titre). */
+function rankingOfPrompt(prompt: string) {
+    const title = /^Classement de GNU Backgammon \(analyse à (\d) plis?\)/m.exec(prompt);
+    assert.ok(title, prompt);
+    const lines = [
+        ...prompt.matchAll(
+            /^(\d+)\. (.+?)( \(mon coup\))? : équité (\S+), écart (\S+?)(?:, évalué à (\d) plis?)?$/gm,
+        ),
+    ].map((m) => ({
+        rank: Number(m[1]),
+        notation: m[2],
+        mine: m[3] !== undefined,
+        equity: m[4],
+        loss: m[5],
+        ply: m[6] === undefined ? null : Number(m[6]),
+    }));
+    return { ply: Number(title[1]), lines };
+}
+
+test("prompt d'un coup : le niveau du titre est celui des lignes, les équités celles de l'analyse", async () => {
+    const engine = await loadNodeEngine();
+    // gnubg de bureau, analyse de partie à 2 plis (tests/reference/analysis/).
+    const reference = (id: string) =>
+        JSON.parse(readFileSync(new URL(`tests/reference/analysis/${id}.json`, root), "utf8"))
+            .plies["2"];
+    for (const [dice, move, id] of [
+        // Erreur : gnubg réévalue à 2 plis le meilleur coup et le coup joué ;
+        // les autres restent au niveau où ses filtres les ont laissés.
+        [[3, 1], "24/23 13/10", "move-opening-31-error"],
+        // Meilleur coup : un seul coup passe le filtre de 1 pli, gnubg
+        // s'arrête là, tout le classement est à 1 pli.
+        [[3, 1], "8/5 6/5", "move-opening-31-best"],
+        [[6, 5], "13/8 13/7", "move-opening-65-error"],
+    ] as const) {
+        const played = await playOpening(engine, dice, move);
+        const advice = await adviceOn(engine, played);
+        assert.ok(advice.kind === "move");
+        played.game.recordAdvice(advice);
+        const position = await positionBefore(engine, played.game.journal, played.eventId);
+        const prompt = decisionPrompt(templates, phrases, {
+            journal: played.game.journal,
+            advice,
+            position,
+        });
+        const { ply, lines } = rankingOfPrompt(prompt);
+        const expected = reference(id);
+
+        // Le titre dit le niveau du meilleur coup, celui que gnubg de bureau
+        // donne ; une ligne sans niveau propre est à ce niveau, une ligne
+        // avec un niveau propre, à un niveau inférieur.
+        assert.equal(ply, expected.ranking[0].ply, prompt);
+        assert.equal(ply, advice.best.ply);
+        assert.ok(lines.length >= 3, prompt);
+        for (const line of lines) {
+            const reference = expected.ranking.find(
+                (m: { move: string }) => m.move === line.notation,
+            );
+            assert.ok(reference, `${line.notation} absent du classement de gnubg`);
+            assert.equal(line.ply ?? ply, reference.ply, `${line.notation}\n${prompt}`);
+            assert.ok(line.ply === null || line.ply < ply, prompt);
+            assertNear(line.equity, reference.equity, `${line.notation}\n${prompt}`);
+        }
+
+        // Les équités et l'écart du meilleur coup et du vôtre sont ceux de
+        // l'analyse, que disent la feuille du maître et l'écran d'analyse.
+        const best = lines[0];
+        const mine = lines.find((line) => line.mine);
+        assert.ok(best && mine, prompt);
+        assert.equal(best.notation, advice.best.notation);
+        assert.equal(best.equity, formatEquity(advice.best.equity));
+        assert.equal(best.loss, formatEquity(0));
+        assert.equal(mine.notation, advice.played.notation);
+        assert.equal(mine.rank, advice.rank);
+        assert.equal(mine.equity, formatEquity(advice.played.equity));
+        assert.equal(mine.loss, formatEquity(advice.equityLoss));
+        assertNear(mine.loss, expected.equity_loss, prompt);
+        assert.ok(shownRanking(advice).includes(`${mine.notation}|${mine.loss}`));
     }
 });
 

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

@@ -511,3 +511,20 @@ Then("le résultat indique le gagnant et les points gagnés", () => {
     // règle Jacoby, le videau n'a pas bougé.
     assert.deepEqual(game.state.result, { winner: "player", kind: "gammon", points: 1 });
 });
+
+// ------------------------------------------------- Glisser, double toucher
+
+When("vous demandez le coup évident de votre pion de la flèche {int}", async (point: number) => {
+    positionBefore = game.displayedPosition;
+    const obvious = await game.obviousMove(point);
+    accepted = obvious !== null;
+    for (const halfMove of obvious ?? []) {
+        accepted &&= await game.playHalfMove(halfMove);
+    }
+});
+
+Then("aucun pion n'a bougé", () => {
+    assert.equal(accepted, false);
+    assert.deepEqual(game.pendingHalfMoves, []);
+    assert.equal(game.displayedPosition, positionBefore);
+});

app/tests/storage.test.ts

@@ -222,6 +222,57 @@ test("les identifiants de partie sont distincts", () => {
     assert.match(newGameId(), /^[0-9a-z]+-[0-9a-z]{6}$/);
 });
 
+// Régression du test navigateur « mes parties » sous Firefox (disque lent) :
+// la nouvelle partie n'est pas perdue quand son enregistrement attend
+// derrière ceux, lents, de l'analyse de la partie finie ; seule une lecture
+// directe du stockage, hors de la file, peut la précéder.
+test("stockage lent : la nouvelle partie est enregistrée après l'analyse de l'ancienne", async () => {
+    const storage = memoryStorage();
+    const raw = createKeyValueBackend(storage);
+    const pause = () => new Promise((resolve) => setTimeout(resolve, 30));
+    const slow = {
+        ...raw,
+        write: async (...args: Parameters<typeof raw.write>) => {
+            await pause();
+            await raw.write(...args);
+        },
+        setCurrentId: async (id: string) => {
+            await pause();
+            await raw.setCurrentId(id);
+        },
+    };
+    const games = createGameLibrary(slow, { now: clock() });
+    const engine = {} as Engine;
+    const session = createGameSession(games, {
+        start: () => Game.start(engine, { dice: fixedDice([5, 2]) }),
+        resume: (j) => Game.resume(engine, j),
+    });
+    const finished = session.newGame();
+    const finishedId = session.shownId as string;
+    session.save(finished.journal);
+    assert.equal((await games.current())?.summary.id, finishedId);
+
+    // L'analyse de la partie finie s'enregistre en arrière-plan, puis
+    // « Rejouer » : nouvelle partie, enregistrée sans attendre.
+    for (let i = 0; i < 5; i++) {
+        void games.saveAnalyses(finishedId, finished.journal, { level: "2ply" });
+    }
+    const next = session.newGame();
+    session.save(next.journal);
+    const nextId = session.shownId as string;
+    assert.notEqual(nextId, finishedId);
+
+    // Lue directement, tout de suite : encore l'ancienne partie.
+    assert.equal(await raw.currentId(), finishedId);
+    // Lue par la bibliothèque, après les écritures en attente : la nouvelle,
+    // avec son journal ; l'ancienne reste là.
+    const current = await games.current();
+    assert.equal(current?.summary.id, nextId);
+    assert.deepEqual(current?.journal, next.journal);
+    assert.equal(await raw.currentId(), nextId);
+    assert.deepEqual((await games.load(finishedId))?.journal, finished.journal);
+});
+
 test("session : « Reprendre l'ancienne » par l'identifiant, et reprise d'une branche", async () => {
     const games = library();
     // Game.start et Game.resume n'interrogent pas le moteur.

docs/adr/0007-architecture-et-conventions-de-code.md

@@ -184,3 +184,21 @@ a plus besoin (`app/src/ui/review-runner.ts`).
   La bibliothèque gagne `saveAnalyses`, qui enregistre le journal analysé
   d'une partie sans en faire la partie en cours ni changer la date de sa
   dernière action (l'ordre de « Mes parties »).
+
+### 2026-11-11 — Version 2 des conseils : le classement de l'analyse
+
+Le classement des coups d'un conseil (`ranking`) venait d'un second appel au
+moteur, comme la commande « hint » de gnubg, alors que le coup joué et le
+meilleur coup venaient de l'analyse de partie. Les deux listes diffèrent :
+quand le coup joué est une erreur, l'analyse réévalue le meilleur coup et le
+coup joué au niveau demandé, ce que « hint » ne fait pas quand un seul coup
+passe ses filtres (ouverture 3-1 jouée 24/23 13/10 : 8/5 6/5 à +0,200 à
+2 plis dans l'analyse, +0,204 à 1 pli dans « hint »). Le classement vient
+désormais de l'analyse même (`engine_analyse_move`, champ `ranking`), comme
+le panneau d'analyse de gnubg de bureau.
+
+- `ADVICE_VERSION` passe à 2 (`app/src/domain/game/advice.ts`). Selon la
+  règle de l'amendement du 2026-11-10, un conseil de la version 1 est oublié
+  à la reprise et recalculé en arrière-plan ; les analyses de l'ordinateur
+  (`review.computer`), du même format, aussi.
+- Ni les événements (version 2) ni le schéma IndexedDB ne changent.

docs/etape-1.md

@@ -25,7 +25,7 @@ Repris du cadrage (modules, écrans clés, IA générative en V1) et des ADR 001
 | 1f. Prompts à copier (fait) | Gabarits versionnés et testés (`docs/prompts/` ou équivalent, source unique), bouton « Demander à une IA » sur le plateau, le conseil du maître, l'analyse et la fin de partie ; le moteur décide, l'IA explique | 1d, 1e |
 | 1g. Accueil, tutoriel et leçons | Accueil (reprendre, nouvelle partie, prochaine leçon, progression résumée), tutoriel des règles interactif et illustré (0e.5), cinq premières leçons numérotées (ADR 0011) avec positions et « à vous de jouer », progression locale ; contenus CC BY-SA 4.0 en brouillon, à relire par un joueur fort | 0e.5, 1a |
 | 1h. Progression | Historique des parties et courbe du taux d'erreur | 1b, 1e |
-| 1i. Plateau soigné | Dessin du plateau aligné sur la charte (`docs/identite/charte/board.js`), animations des pions, glisser-déposer en plus du toucher, double toucher pour le seul coup évident | 0e.3 |
+| 1i. Plateau soigné (fait) | Dessin du plateau aligné sur la charte (`docs/identite/charte/board.js`), animations des pions, glisser-déposer en plus du toucher, double toucher pour le seul coup évident | 0e.3 |
 | 1j. Plan de test | `docs/guide-test-etape-1.md` : parcours du débutant et du joueur de club sur le téléphone, avec ce qu'il faut rapporter | toutes |
 
 ## Orientation donnée par Pierre

docs/identite/charte/recette-ux.md

@@ -47,3 +47,6 @@ Référence : `interaction.md`, maquettes « Révision UX » du canevas.
 - [ ] « Nouvelle partie » depuis le menu : effet immédiat, bandeau « Reprendre l'ancienne » 10 s, et la reprise restaure la partie exacte.
 - [ ] Vibrations aux quatre moments, coupées par l'interrupteur du menu (test unitaire sur `haptic()` ; ressenti à la main).
 - [ ] Écran maintenu allumé pendant une partie, interrupteur dans le menu.
+- [ ] Glisser-déposer : le pion suit le doigt, agrandi et au-dessus de lui, un fantôme en pointillés à son départ ; lâché hors d'une case permise, il revient à sa place sans vibration ni message (`tests/browser/plateau.mjs`, captures `plateau/glissement-*`).
+- [ ] Double toucher : le coup évident seulement (un seul coup commence par ce pion, ou un seul coup possible) ; sinon rien de plus qu'un toucher.
+- [ ] Clavier : `←` `→` choisissent un pion, `↑` `↓` sa case (anneau `focus`), `Entrée` le pose ; les raccourcis s'affichent en `kbd` sur les boutons dès qu'un clavier est détecté (capture `plateau/clavier-*`).

docs/plans/2026-11-03-plateau-soigne.md

@@ -1,32 +0,0 @@
-# Plateau soigné : gestes et finitions (1i)
-
-- **Date** : 2026-11-03
-- **Étape** : 1i (`docs/etape-1.md`)
-- **Statut** : prévu
-- **Exécutant** : sous-agent general-purpose, dans un worktree
-
-## Objectif
-
-Terminer le plateau soigné du cadrage, une fois la révision UX en place :
-- les gestes naturels (principe d'expérience 2) ;
-- les écarts restants avec `docs/identite/charte/board.js`.
-
-## Consignes
-
-1. **Glisser-déposer.** On peut glisser un pion en plus du toucher pion puis destination. Le pion suit le doigt, et le lâcher hors d'une case permise le ramène à sa place. Les cibles restent celles du moteur.
-2. **Double toucher.** Un double toucher sur un pion joue le seul coup évident (cadrage). Un « coup évident » est défini ainsi : un seul coup légal complet commence par ce pion, ou le moteur ne propose qu'un coup. Sinon, rien ne se passe.
-3. **Écarts restants avec board.js.** Les relever par comparaison visuelle (filet des pions, numéros sur le cadre, videau…) et les corriger.
-4. **Clavier.** Faire ce que la révision UX a laissé :
-   - le choix des pions aux flèches ;
-   - l'affichage des raccourcis en `kbd` quand un clavier est détecté (interaction.md).
-5. **Tests.**
-   - Scénarios Gherkin si un nouveau comportement est visible.
-   - `make lint`, `make test`, `make test-browser` (glisser-déposer simulé, double toucher), avec captures pour la recette design.
-
-## Critères de réussite
-
-Un coup se joue entièrement au glisser-déposer. Le double toucher joue le coup évident. Les trois commandes passent.
-
-## Résultat
-
-À remplir à la clôture.

docs/prompts/README.md

@@ -54,5 +54,5 @@ Repères communs à plusieurs gabarits :
 | `{diagramme}` | le plateau en texte : vos pions X, ceux de l'ordinateur O, dans votre numérotation |
 | `{score}` | « partie libre » ou le score du match |
 | `{videau}` | sa valeur et qui le possède |
-| `{niveau_eval}` | le niveau d'évaluation de GNU Backgammon, « analyse à 2 plis » |
+| `{niveau_eval}` | le niveau d'évaluation de GNU Backgammon, « analyse à 2 plis » ; pour un classement de coups, celui auquel le moteur a évalué le meilleur coup (voir [coup.md](coup.md)) |
 | `{langue}` | la langue de la réponse : « français » |

docs/prompts/coup.md

@@ -12,7 +12,15 @@ Repères propres à ce gabarit :
 | `{coup_joue}` | votre coup, dans la notation de GNU Backgammon |
 | `{appreciation}` | le mot du maître : « Bon coup », « Imprécision », « Erreur » ou « Grosse erreur » |
 | `{rang}` | « le meilleur coup » ou « le 4e choix sur 15 coups possibles » |
-| `{classement}` | le classement du moteur : les trois meilleurs coups, et le vôtre s'il n'en est pas, avec leur équité et leur écart au meilleur, comme dans « Voir les chiffres du moteur » |
+| `{classement}` | le classement de l'analyse de votre coup : les trois meilleurs coups, et le vôtre s'il n'en est pas, avec leur équité et leur écart au meilleur, comme dans « Voir les chiffres du moteur » |
+
+Le niveau du titre (`{niveau_eval}`) est celui auquel GNU Backgammon a
+évalué le meilleur coup. C'est d'ordinaire le niveau de l'analyse (2 plis),
+mais le moteur s'arrête plus tôt quand un seul coup passe ses filtres : à
+l'ouverture 3-1 jouée 8/5 6/5, tout le classement est à 1 pli. Les coups que
+ses filtres ont écartés gardent l'évaluation d'un niveau inférieur, et leur
+ligne le dit (« évalué à 1 pli »). Les équités et l'écart de votre coup sont
+ceux de l'analyse, que disent la feuille du maître et l'écran d'analyse.
 
 ## Gabarit
 

docs/scenarios/jouer-une-partie.feature

@@ -40,6 +40,24 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
     Alors seul votre 3 est marqué comme joué
     Et chacun de vos pions jouables n'a plus qu'une case d'arrivée
 
+  @position:BQAACAIAAAAAAA
+  Scénario: Puis-je faire glisser un pion, ou jouer au clavier ?
+    Vous pouvez aussi faire glisser un pion jusqu'à sa case d'arrivée : il
+    suit votre doigt, juste au-dessus pour rester visible, et un pion en
+    pointillés marque sa place de départ. Lâché ailleurs que sur une case
+    permise, il revient à sa place. Touchez deux fois de suite un pion pour
+    jouer le coup évident : quand un seul coup commence par ce pion, ou que
+    vous n'avez qu'un coup possible. Sinon, rien de plus ne se passe. Votre
+    coup attend ensuite votre validation, comme d'habitude. Au clavier, les
+    flèches gauche et droite choisissent un pion, les flèches haut et bas sa
+    case d'arrivée, et Entrée le pose.
+
+    Étant donné que vous avez un pion sur la flèche 6 et un sur la flèche 1, avec le jet 6-1
+    Quand vous demandez le coup évident de votre pion de la flèche 6
+    Alors aucun pion n'a bougé
+    Quand vous demandez le coup évident de votre pion de la flèche 1
+    Alors vos deux pions sont sortis
+
   Scénario: Je me suis trompé de pion
     Tant que vous n'avez pas validé votre coup, « Annuler » reprend le
     dernier pion déplacé ; touchez-le encore pour reprendre le précédent.

engine-cli/main.c

@@ -43,7 +43,8 @@
  *                                       analyse du coup joué (POSITION_JOUÉE :
  *                                       position après le coup, vue du joueur
  *                                       qui l'a joué, comme position_id dans
- *                                       moves et legal)
+ *                                       moves et legal), avec le classement
+ *                                       de l'analyse (dix coups au plus)
  *   analysecube POSITION_ID MATCH_ID DÉCISION
  *                                       analyse d'une décision de videau :
  *                                       no_double ou double (joueur au trait),
@@ -684,7 +685,7 @@ run_analyse_move_command(const options *opt)
     const char *played_id = opt->args[3];
     engine_move_analysis a;
     engine_status status;
-    int die1, die2;
+    int die1, die2, i;
 
     if (opt->arg_count != 4)
         return usage_error("arguments attendus : POSITION_ID MATCH_ID DÉS POSITION_JOUÉE");
@@ -705,6 +706,13 @@ run_analyse_move_command(const options *opt)
         printf(", \"best\": ");
         print_move(&a.best, 1);
     }
+    printf(", \"ranking\": [");
+    for (i = 0; i < a.ranking_count; i++) {
+        if (i > 0)
+            printf(", ");
+        print_move(&a.ranking[i], 1);
+    }
+    printf("]");
     printf(", \"equity_loss\": " NUMBER ", \"skill\": \"%s\"}\n", a.equity_loss,
            skill_names[a.skill]);
     return EXIT_SUCCESS;

engine/engine.c

@@ -512,6 +512,8 @@ engine_level_best_moves(const char *position_id, const char *match_id, int die1,
 
 /* ------------------------------------------------- Analyse d'un coup joué */
 
+static float luck_analysis(const char *position_id, position *pos, int die1, int die2);
+
 engine_status
 engine_analyse_move(const char *position_id, const char *match_id, int die1, int die2,
                     const char *played_position_id, int ply, engine_move_analysis *analysis)
@@ -546,6 +548,17 @@ engine_analyse_move(const char *position_id, const char *match_id, int die1, int
      * premier.
      */
     memset(analysis, 0, sizeof *analysis);
+    /*
+     * gnubg analyse la chance du jet juste avant le coup (AnalyzeMove,
+     * l. 679-682), à 0 pli sans élagage, et garde ces évaluations dans son
+     * cache, qui ne distingue pas une évaluation à 0 pli avec ou sans
+     * réseaux d'élagage : le tri à 0 pli de FindnSaveBestMoves les reprend
+     * ensuite, ce qui change l'équité des coups restés à 0 pli, et parfois
+     * ceux que les filtres retiennent. Faire de même, sans garder le
+     * résultat, donne le classement de gnubg de bureau.
+     */
+    if (luck_analysis(position_id, &pos, die1, die2) == ERR_VAL)
+        return ENGINE_ERROR_INTERNAL;
     if (FindnSaveBestMoves(&list, die1, die2, (ConstTanBoard) pos.board, &played_key, TRUE,
                            DOUBTFUL_THRESHOLD, &pos.cube, &context,
                            aaamfMoveFilterSettings[0]) < 0)
@@ -565,6 +578,10 @@ engine_analyse_move(const char *position_id, const char *match_id, int die1, int
             status = ENGINE_OK;
             break;
         }
+    /* Le classement : le début de la même liste, dans l'ordre de gnubg. */
+    for (i = 0; i < list.cMoves && i < ENGINE_ANALYSIS_RANKING; i++)
+        fill_move(&analysis->ranking[i], &list.amMoves[i], &pos, 1);
+    analysis->ranking_count = (int) i;
     g_free(list.amMoves);
     return status;
 }
@@ -1005,13 +1022,25 @@ luck_first(ConstTanBoard board, int i0, int j0, cubeinfo *cube)
     return equities[i0][j0] - mean / 30.0f;
 }
 
+/* LuckAnalysis (analysis.c l. 252-268) : dés rangés du plus fort au plus
+ * faible ; LuckFirst à la position de départ hors doubles. */
+static float
+luck_analysis(const char *position_id, position *pos, int die1, int die2)
+{
+    int high = (die1 > die2 ? die1 : die2) - 1;
+    int low = (die1 > die2 ? die2 : die1) - 1;
+
+    if (strcmp(position_id, START_POSITION_ID) == 0 && high != low)
+        return luck_first((ConstTanBoard) pos->board, high, low, &pos->cube);
+    return luck_normal((ConstTanBoard) pos->board, high, low, &pos->cube);
+}
+
 engine_status
 engine_luck_of(const char *position_id, const char *match_id, int die1, int die2,
                engine_luck *luck)
 {
     position pos;
     engine_status status;
-    int high, low;
     float value;
 
     status = decode_position(position_id, match_id, &pos);
@@ -1021,14 +1050,7 @@ engine_luck_of(const char *position_id, const char *match_id, int die1, int die2
         return status;
     start_evaluation();
 
-    /* LuckAnalysis (analysis.c l. 252-268) : dés rangés du plus fort au plus
-     * faible ; LuckFirst à la position de départ hors doubles. */
-    high = (die1 > die2 ? die1 : die2) - 1;
-    low = (die1 > die2 ? die2 : die1) - 1;
-    if (strcmp(position_id, START_POSITION_ID) == 0 && high != low)
-        value = luck_first((ConstTanBoard) pos.board, high, low, &pos.cube);
-    else
-        value = luck_normal((ConstTanBoard) pos.board, high, low, &pos.cube);
+    value = luck_analysis(position_id, &pos, die1, die2);
     if (value == ERR_VAL)
         return ENGINE_ERROR_INTERNAL;
     luck->luck = value;

engine/include/engine.h

@@ -207,6 +207,10 @@ typedef struct {
                              * (double_take <= double_pass) */
 } engine_cube;
 
+/* Coups gardés dans le classement d'une analyse : les dix premiers, comme
+ * les positions de référence (tests/reference/README.md). */
+#define ENGINE_ANALYSIS_RANKING 10
+
 /* Analyse d'un coup joué, comme l'analyse de partie de gnubg. */
 typedef struct {
     int move_count;         /* nombre de coups légaux (0 : aucun coup
@@ -218,6 +222,14 @@ typedef struct {
     float equity_loss;      /* équité du coup joué moins celle du meilleur :
                              * 0 ou négative */
     engine_skill skill;     /* appréciation de gnubg pour cette perte */
+    /* Le classement de l'analyse, du meilleur au moins bon : les premiers
+     * coups de la liste que gnubg garde pour l'analyse de partie (ce que
+     * montre son panneau d'analyse), chacun au niveau où gnubg l'a
+     * évalué. Le meilleur coup et le coup joué y ont les mêmes évaluations
+     * que best et played ; le coup joué n'y figure que s'il est parmi les
+     * premiers. */
+    engine_move ranking[ENGINE_ANALYSIS_RANKING];
+    int ranking_count;
 } engine_move_analysis;
 
 /* Analyse d'une décision de videau, comme l'analyse de partie de gnubg. */
@@ -452,7 +464,15 @@ engine_luck_rating engine_luck_rating_of(float luck);
  * Analyse le coup joué par le joueur au trait avec le jet die1, die2, au
  * niveau ply, comme l'analyse de partie de gnubg (AnalyzeMove dans
  * analysis.c : FindnSaveBestMoves avec le coup joué, seuil « douteux »,
- * filtre « Normal », sans RefreshMoveList). played_position_id est la
+ * filtre « Normal », sans RefreshMoveList), classement compris.
+ *
+ * Niveaux : gnubg n'évalue au niveau ply que les coups retenus par ses
+ * filtres ; les autres gardent l'évaluation d'un niveau inférieur (champ
+ * ply de chaque coup, même convention que gnubg de bureau : 0 = statique).
+ * Si un seul coup passe le filtre du niveau ply - 1, gnubg s'arrête là, et
+ * tout le classement reste à ce niveau, sauf quand le coup joué est une
+ * erreur (écart au meilleur supérieur au seuil « douteux ») : le meilleur
+ * coup et le coup joué sont alors réévalués au niveau ply. played_position_id est la
  * position après le coup, vue du joueur qui vient de le jouer (champ
  * position_id d'engine_move). ENGINE_ERROR_MOVE si ce n'est pas un coup
  * légal ; si aucun coup n'est possible, move_count vaut 0.

tests/browser.sh

@@ -18,10 +18,12 @@
 # build/browser-shots/nouvelle-partie/. Les retours des premiers joueurs
 # (tests/browser/retours-joueurs.mjs : pions sur la barre, numéros sur le
 # cadre, flèches du tutoriel, en thème clair et sombre), captures dans
-# build/browser-shots/retours-joueurs/.
+# build/browser-shots/retours-joueurs/. Les gestes du plateau soigné
+# (tests/browser/plateau.mjs : glisser-déposer, pion lâché hors cible, double
+# toucher, clavier, filet des pions), captures dans build/browser-shots/plateau/.
 #
 # BROWSERS=chromium et SCRIPTS=accueil (ou play, match, maitre, bilan,
-# prompts, nouvelle-partie, retours-joueurs) restreignent le test.
+# prompts, nouvelle-partie, retours-joueurs, plateau) restreignent le test.
 #
 # Outils : l'image de Playwright (navigateurs) et le paquet playwright,
 # installé une fois par npm dans build/browser-tools/ (réseau nécessaire la
@@ -34,7 +36,7 @@ cd "$(dirname "$0")/.."
 image="${PLAYWRIGHT_IMAGE:?lancer via make test-browser}"
 browsers="${BROWSERS:-chromium firefox}"
 # Les scripts à lancer (tests/browser/<nom>.mjs), tous par défaut.
-scripts="${SCRIPTS:-play accueil match maitre bilan prompts nouvelle-partie retours-joueurs}"
+scripts="${SCRIPTS:-play accueil match maitre bilan prompts nouvelle-partie retours-joueurs plateau}"
 
 unset MAKEFLAGS MFLAGS MAKELEVEL
 make -s package >/dev/null
@@ -73,7 +75,7 @@ rm -rf build/browser-shots
 mkdir -p build/browser-shots
 cp tests/browser/play.mjs tests/browser/accueil.mjs tests/browser/match.mjs tests/browser/recette.mjs \
 	tests/browser/maitre.mjs tests/browser/bilan.mjs tests/browser/prompts.mjs tests/browser/nouvelle-partie.mjs \
-	tests/browser/retours-joueurs.mjs "$tools/"
+	tests/browser/retours-joueurs.mjs tests/browser/plateau.mjs "$tools/"
 status=0
 for browser in $browsers; do
 	# Réseau de l'hôte : le site est sur 127.0.0.1. Le service worker
@@ -136,5 +138,12 @@ for browser in $browsers; do
 			-v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -w /tools "$image" \
 			node retours-joueurs.mjs "http://localhost:$port/" "$browser" /shots || status=1
 	fi
+	if [[ " $scripts " == *" plateau "* ]]; then
+		# Gestes du plateau : glisser-déposer, lâcher hors cible, double
+		# toucher, clavier ; captures dans build/browser-shots/plateau/.
+		docker run --rm --init --ipc=host --network host --user "$(id -u):$(id -g)" -e HOME=/tmp \
+			-v "$PWD/$tools:/tools" -v "$PWD/build/browser-shots:/shots" -w /tools "$image" \
+			node plateau.mjs "http://localhost:$port/" "$browser" /shots || status=1
+	fi
 done
 exit "$status"

tests/browser/match.mjs

@@ -329,8 +329,8 @@ for (;;) {
             await page.click("#summary-close");
             await until("retour au résultat du match", () => location.hash === "#/" &&
                 !document.getElementById("again").hidden);
-            check((await page.textContent("#again")) === "Rejouer",
-                `après le match, barre d'actions : « ${await page.textContent("#again")} »`);
+            check((await page.textContent("#again > span")) === "Rejouer",
+                `après le match, barre d'actions : « ${await page.textContent("#again > span")} »`);
             log(`match ${matches} fini : ${games} parties, ${crawfordGames} Crawford au total`);
             await page.click("#again");
             await until("match rejoué", () => location.hash === "#/" &&

tests/browser/plateau.mjs

@@ -0,0 +1,328 @@
+// plateau.mjs -- les gestes du plateau soigné (étape 1i ; charte,
+// ecrans-etape-1.md, 1i ; interaction.md), joués dans un vrai navigateur sans
+// écran (Playwright), sur le site servi par l'image de production :
+//
+// - un coup joué entièrement au glisser-déposer (pion fantôme au départ, pion
+//   glissé agrandi, cases d'arrivée du moteur) ;
+// - un pion lâché hors d'une case permise revient à sa place, sans rien
+//   jouer ;
+// - le double toucher : rien quand plusieurs coups commencent par le pion,
+//   le coup évident sinon ;
+// - un coup joué au clavier (flèches, Entrée, Espace), raccourcis en kbd
+//   affichés une fois le clavier détecté ;
+// - le filet intérieur des pions ;
+// - aucune erreur, aucune violation de la politique de sécurité.
+//
+// Copyright (C) 2026 les auteurs d'Ustagammon.
+// Licence : GPLv3 ou ultérieure (voir LICENSE).
+//
+// Usage : node plateau.mjs <adresse du site> <chromium|firefox> <dossier des captures>
+// Lancé par tests/browser.sh. Les dés viennent de Math.random, remplacé ici
+// par une file de valeurs choisies (window.__dice), puis par un générateur à
+// graine. Captures de la recette design (Chromium) dans
+// <dossier des captures>/plateau/, en 412×915 et 915×412.
+
+import { mkdirSync } from "node:fs";
+import { chromium, firefox } from "playwright";
+
+const [base, browserName, shots] = process.argv.slice(2);
+const browserType = { chromium, firefox }[browserName];
+if (!base || !browserType || !shots) {
+    console.error("usage : node plateau.mjs <adresse> <chromium|firefox> <dossier des captures>");
+    process.exit(2);
+}
+const full = browserName === "chromium";
+const dir = `${shots}/plateau`;
+mkdirSync(dir, { recursive: true });
+const PORTRAIT = { width: 412, height: 915 };
+const LANDSCAPE = { width: 915, height: 412 };
+// Positions de gnubg, vues du joueur : le départ ; un pion sur la 6 et un
+// sur la 1 (avec 6-1, seul le pion de la 1 a un coup évident).
+const START = "4HPwATDgc/ABMA";
+const SIX_AND_ONE = "BQAACAIAAAAAAA";
+
+const problems = [];
+const log = (text) => console.log(`[${browserName}] ${text}`);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+let captures = 0;
+
+function check(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+
+const browser = await browserType.launch();
+const context = await browser.newContext({
+    viewport: PORTRAIT,
+    deviceScaleFactor: 1,
+    locale: "fr-FR",
+});
+await context.addInitScript(() => {
+    window.__dice = [];
+    let state = 7;
+    Math.random = () => {
+        const die = window.__dice.shift();
+        if (die !== undefined) {
+            return (die - 0.5) / 6;
+        }
+        state = (state * 1103515245 + 12345) % 2147483648;
+        return state / 2147483648;
+    };
+    window.__csp = [];
+    document.addEventListener("securitypolicyviolation", (e) =>
+        window.__csp.push(`${e.effectiveDirective} ${e.blockedURI}`),
+    );
+    if (localStorage.getItem("ustagammon.settings") === null) {
+        localStorage.setItem("ustagammon.settings", JSON.stringify({ tutorialSeen: 1 }));
+    }
+});
+const page = await context.newPage();
+page.on("pageerror", (error) => problems.push(`erreur de la page : ${error.message}`));
+page.on("console", (message) => {
+    if (message.type() === "error") {
+        problems.push(`console : ${message.text()}`);
+    }
+});
+
+/** Attend une condition dans la page (sans page.waitForFunction, qui passe
+ * par eval, interdit par la politique de sécurité du site). */
+async function until(what, fn, arg, ms = 60_000) {
+    for (let waited = 0; waited < ms; waited += 100) {
+        if (await page.evaluate(fn, arg).catch(() => false)) {
+            return;
+        }
+        await sleep(100);
+    }
+    await page.screenshot({ path: `${dir}/${browserName}-bloque.png` }).catch(() => {});
+    throw new Error(`attente trop longue : ${what}`);
+}
+
+const idle = () => until("écran libre", () => !document.body.classList.contains("busy"));
+
+/** Une nouvelle partie à partir d'une position, joueur au trait, puis les
+ * dés imposés lancés. */
+async function startFrom(position, dice) {
+    await page.goto(`${base}#/position/${encodeURIComponent(position)}`);
+    await until("position lue", () => {
+        const play = document.getElementById("position-play");
+        return !play.hidden && !play.disabled;
+    });
+    await page.click("#position-play");
+    await until(
+        "partie commencée",
+        () =>
+            location.hash === "#/" &&
+            !document.body.classList.contains("busy") &&
+            !document.getElementById("roll").hidden,
+    );
+    await page.evaluate((d) => window.__dice.push(...d), dice);
+    await page.click("#roll");
+    await idle();
+}
+
+/** L'état du plateau : pions par endroit (pion du dessus marqué), pion
+ * choisi, cases d'arrivée, glissement en cours, dés joués. */
+function boardState() {
+    return page.evaluate(() => {
+        const board = document.getElementById("board");
+        const at = (place) => board.querySelector(`[data-checker="${place}"]`) !== null;
+        return {
+            at: Object.fromEntries(
+                ["p1", "p5", "p6", "p7", "p8", "p13", "p24", "off-player"].map((p) => [p, at(p)]),
+            ),
+            selected: board.querySelector(".checker.selected")?.closest("[data-checker]")
+                ?.getAttribute("data-checker") ?? null,
+            landing: [...board.querySelectorAll(".hit.can-land")].map((e) =>
+                e.getAttribute("data-place"),
+            ),
+            dragging: board.querySelector("#drag-piece") !== null,
+            ghost: board.querySelector(".drag-origin")?.getAttribute("data-checker") ?? null,
+            used: board.querySelectorAll(".die-used").length,
+            focus: board.querySelector(".key-focus") !== null,
+            rings: board.querySelectorAll(".checker-ring").length,
+            checkers: board.querySelectorAll("circle.checker").length,
+            confirm: !document.getElementById("confirm").hidden,
+        };
+    });
+}
+
+/** Le centre, à l'écran, de la zone à toucher d'un endroit. */
+async function center(place) {
+    const box = await page.locator(`#board .hit[data-place="${place}"]`).boundingBox();
+    check(box !== null, `zone ${place} introuvable`);
+    return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+}
+
+/** Le centre, à l'écran, du pion du dessus d'un endroit. */
+async function checkerCenter(place) {
+    const box = await page.locator(`#board [data-checker="${place}"] circle.checker`).boundingBox();
+    check(box !== null, `pion ${place} introuvable`);
+    return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+}
+
+/** Prend le pion de from et le fait glisser au-dessus de la zone de to,
+ * sans le lâcher ; renvoie l'état du plateau pendant le glissement. */
+async function dragOver(from, to) {
+    const start = await checkerCenter(from);
+    const end = await center(to);
+    await page.mouse.move(start.x, start.y);
+    await page.mouse.down();
+    await page.mouse.move(start.x + 4, start.y + 12, { steps: 3 });
+    await page.mouse.move(end.x, end.y, { steps: 8 });
+    await sleep(100);
+    return boardState();
+}
+
+/** Lâche le pion glissé, puis attend que le plateau soit de nouveau libre
+ * et sans glissement (le pion rentré ou posé). */
+async function release() {
+    await page.mouse.up();
+    await until("glissement fini", () => document.getElementById("drag-piece") === null);
+    await idle();
+}
+
+/** Une capture de la recette, à la taille du moment (Chromium seulement). */
+async function capture(name) {
+    if (!full) {
+        return;
+    }
+    const size = page.viewportSize();
+    await page.screenshot({ path: `${dir}/${name}-${size.width}x${size.height}.png` });
+    captures++;
+}
+
+// ------------------------------------------------- Le filet des pions
+
+await startFrom(START, [3, 1]);
+let state = await boardState();
+check(state.checkers >= 28 && state.rings === state.checkers,
+    `filet : ${state.rings} filets pour ${state.checkers} pions`);
+await until("bandeau parti", () => document.getElementById("banner").hidden, null, 15_000);
+for (const size of [PORTRAIT, LANDSCAPE]) {
+    await page.setViewportSize(size);
+    await sleep(300);
+    await capture("plateau-filet");
+}
+await page.setViewportSize(PORTRAIT);
+await sleep(300);
+log(`filet intérieur sur chaque pion (${state.rings})`);
+
+// ------------------------------------- Un coup entier au glisser-déposer
+
+state = await dragOver("p8", "p5");
+check(state.dragging && state.ghost === "p8" && state.selected === "p8",
+    `glissement de 8 : ${JSON.stringify(state)}`);
+check(state.landing.includes("p5") && state.landing.includes("p7"),
+    `glissement de 8 : cases d'arrivée ${state.landing}`);
+await capture("glissement");
+await release();
+state = await boardState();
+check(state.used === 1 && state.at.p5 && !state.dragging && state.ghost === null,
+    `8/5 lâché sur la 5 : ${JSON.stringify(state)}`);
+await dragOver("p6", "p5");
+await release();
+state = await boardState();
+check(state.used === 2 && state.confirm, `6/5 lâché sur la 5 : ${JSON.stringify(state)}`);
+await page.click("#confirm");
+await idle();
+log("un coup entier joué au glisser-déposer (8/5 6/5)");
+
+// Le glissement en paysage, pour la recette.
+if (full) {
+    await startFrom(START, [3, 1]);
+    await until("bandeau parti", () => document.getElementById("banner").hidden, null, 15_000);
+    await page.setViewportSize(LANDSCAPE);
+    await sleep(300);
+    state = await dragOver("p13", "p10");
+    check(state.dragging && state.ghost === "p13", `paysage : ${JSON.stringify(state)}`);
+    await capture("glissement");
+    await release();
+    await page.setViewportSize(PORTRAIT);
+    await sleep(300);
+}
+
+// ------------------------------------------- Lâché hors d'une case permise
+
+await startFrom(START, [3, 1]);
+const before = await boardState();
+// La 12 est tenue par l'ordinateur : 13/12 n'est pas permis.
+state = await dragOver("p13", "p12");
+check(state.dragging && !state.landing.includes("p12"), `13 vers 12 : ${JSON.stringify(state)}`);
+await release();
+state = await boardState();
+check(state.used === 0 && state.at.p13 && state.selected === null && !state.dragging &&
+    state.checkers === before.checkers,
+    `lâché sur la 12 : le pion n'est pas revenu ${JSON.stringify(state)}`);
+log("lâché hors d'une case permise : le pion revient à sa place, rien n'est joué");
+
+// ----------------------------------------------------------- Double toucher
+
+await startFrom(SIX_AND_ONE, [6, 1]);
+// Depuis la 6 : 6/off 1/off ou 6/5/off, deux coups : rien.
+await page.dblclick('#board .hit[data-place="p6"]');
+await sleep(500);
+await idle();
+state = await boardState();
+check(state.used === 0 && state.at.p6 && state.at.p1, `double toucher sur la 6 : ${JSON.stringify(state)}`);
+// Depuis la 1 : 1/off puis 6/off, le seul coup.
+await page.dblclick('#board .hit[data-place="p1"]');
+await until("coup évident joué", () => !document.getElementById("confirm").hidden);
+await idle();
+state = await boardState();
+check(state.used === 2 && !state.at.p6 && !state.at.p1 && state.at["off-player"],
+    `double toucher sur la 1 : ${JSON.stringify(state)}`);
+log("double toucher : rien sur la 6 (deux coups), le coup évident sur la 1");
+
+// ------------------------------------------------------------------ Clavier
+
+await startFrom(START, [3, 1]);
+await page.locator("body").focus().catch(() => {});
+// Les pions jouables dans le sens de la course : 24, 13, 8, 6.
+for (let i = 0; i < 3; i++) {
+    await page.keyboard.press("ArrowRight");
+}
+state = await boardState();
+check(state.selected === "p8" && state.focus, `flèches : pion ${state.selected}`);
+// Les cases d'arrivée de la 8 : la 7, puis la 5.
+await page.keyboard.press("ArrowDown");
+await page.keyboard.press("Enter");
+await idle();
+state = await boardState();
+check(state.used === 1 && state.at.p5, `Entrée : 8/5 non joué ${JSON.stringify(state)}`);
+// En arrière depuis la fin : 5, puis 6 ; sa seule case, la 5.
+await page.keyboard.press("ArrowLeft");
+await page.keyboard.press("ArrowLeft");
+state = await boardState();
+check(state.selected === "p6" && state.focus, `flèche gauche : pion ${state.selected}`);
+await page.keyboard.press("Enter");
+await idle();
+state = await boardState();
+check(state.used === 2 && state.confirm, `Entrée : 6/5 non joué ${JSON.stringify(state)}`);
+const keys = await page.evaluate(() => {
+    const kbd = document.querySelector("#confirm kbd.shortcut");
+    return {
+        keyboard: document.documentElement.classList.contains("keyboard"),
+        shown: kbd !== null && kbd.getBoundingClientRect().width > 0,
+        text: kbd?.textContent ?? null,
+    };
+});
+check(keys.keyboard && keys.shown && keys.text === "Espace", `raccourci : ${JSON.stringify(keys)}`);
+await capture("clavier");
+await page.keyboard.press(" ");
+await until("coup validé", () => document.getElementById("confirm").hidden);
+await idle();
+log("un coup joué au clavier (flèches, Entrée, Espace), raccourcis affichés");
+
+const csp = await page.evaluate(() => window.__csp);
+for (const violation of csp) {
+    problems.push(`politique de sécurité : ${violation}`);
+}
+await browser.close();
+if (problems.length > 0) {
+    for (const problem of problems) {
+        console.error(`[${browserName}] ${problem}`);
+    }
+    process.exit(1);
+}
+log(`plateau soigné : tout est conforme (${captures} captures)`);

tests/browser/play.mjs

@@ -164,6 +164,45 @@ async function readJournal() {
     );
 }
 
+/** L'identifiant de la partie en cours enregistrée dans IndexedDB
+ * (magasin settings, clé « current »), ou null. */
+async function savedGameId() {
+    return page.evaluate(
+        () =>
+            new Promise((resolve, reject) => {
+                const open = indexedDB.open("ustagammon");
+                open.onerror = () => reject(open.error);
+                open.onsuccess = () => {
+                    const db = open.result;
+                    const current = db.transaction("settings").objectStore("settings").get("current");
+                    current.onsuccess = () => {
+                        db.close();
+                        resolve(current.result?.value ?? null);
+                    };
+                };
+            }),
+    );
+}
+
+/**
+ * Attend que la partie en cours enregistrée ne soit plus oldId, et renvoie
+ * le temps d'attente en ms (null au bout de 30 s). L'application enregistre
+ * sans attendre l'écriture, dans une file (app/src/storage/game-library.ts) :
+ * sous Firefox, sur un disque lent et chargé, l'enregistrement de la
+ * nouvelle partie peut attendre derrière ceux de l'analyse de la partie
+ * finie, et une lecture directe d'IndexedDB trouver encore l'ancienne.
+ */
+async function waitForSavedGameOtherThan(oldId) {
+    const start = Date.now();
+    while (Date.now() - start < 30_000) {
+        if ((await savedGameId()) !== oldId) {
+            return Date.now() - start;
+        }
+        await sleep(100);
+    }
+    return null;
+}
+
 /** Le nombre de parties enregistrées dans IndexedDB. */
 async function savedGameCount() {
     await savedJournal(); // les enregistrements en cours terminés
@@ -314,7 +353,8 @@ async function checkStable(when) {
 }
 
 /** Les boutons visibles d'une page dont le texte passe à la ligne : un
- * bouton tient sur une ligne et fait 48 px de haut (charte). Un bouton plus
+ * bouton tient sur une ligne et fait 48 px de haut (charte), touche de son
+ * raccourci comprise. Un bouton plus
  * haut que 48 px n'est refusé que si son texte occupe plusieurs lignes ;
  * un texte coupé par le bord (white-space: nowrap) est refusé aussi. */
 async function wrappedButtons(target) {
@@ -329,7 +369,9 @@ async function wrappedButtons(target) {
             const tops = new Set();
             const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
             for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) {
-                if (node.textContent.trim() === "") {
+                // La touche du raccourci (kbd, quand un clavier est détecté)
+                // est un badge en coin, pas une ligne du libellé.
+                if (node.textContent.trim() === "" || node.parentElement?.closest("kbd.shortcut")) {
                     continue;
                 }
                 const range = document.createRange();
@@ -587,17 +629,41 @@ async function checkTraces() {
  * (les dés en ont une de chaque côté du plateau), chacune un bouton
  * accessible d'au moins 44 px de côté. Renvoie le locator de la zone index. */
 async function touchTarget(action, label, count = 1, index = 0) {
-    const zones = page.locator(`[data-action="${action}"]`);
-    check((await zones.count()) === count,
-        `zone ${action} : ${await zones.count()} sur le plateau, ${count} attendues`);
-    for (const zone of await zones.all()) {
-        check((await zone.getAttribute("role")) === (action === "menu" ? "link" : "button") &&
-            (await zone.getAttribute("aria-label")) === label, `zone ${action} sans rôle accessible`);
-        const box = await zone.boundingBox();
-        check(box.width >= 44 && box.height >= 44,
-            `zone ${action} trop petite : ${Math.round(box.width)} x ${Math.round(box.height)} px`);
+    // Les zones sont relevées d'un coup dans la page, où le plateau ne peut
+    // pas se redessiner entre deux lectures : mesurées une à une depuis
+    // Playwright (boundingBox), une zone remplacée entre-temps par un
+    // nouveau dessin du plateau n'avait plus de boîte (null, vu sous
+    // Firefox). On attend l'état observable : le nombre de zones attendu,
+    // toutes dessinées (5 s au plus).
+    const read = () =>
+        page.evaluate(
+            (name) =>
+                [...document.querySelectorAll(`[data-action="${name}"]`)].map((zone) => {
+                    const box = zone.getBoundingClientRect();
+                    return {
+                        role: zone.getAttribute("role"),
+                        label: zone.getAttribute("aria-label"),
+                        width: box.width,
+                        height: box.height,
+                    };
+                }),
+            action,
+        );
+    let zones = await read();
+    const start = Date.now();
+    while ((zones.length !== count || zones.some((z) => z.width === 0 && z.height === 0)) &&
+        Date.now() - start < 5000) {
+        await sleep(100);
+        zones = await read();
     }
-    return zones.nth(index);
+    check(zones.length === count, `zone ${action} : ${zones.length} sur le plateau, ${count} attendues`);
+    for (const zone of zones) {
+        check(zone.role === (action === "menu" ? "link" : "button") && zone.label === label,
+            `zone ${action} sans rôle accessible`);
+        check(zone.width >= 44 && zone.height >= 44,
+            `zone ${action} trop petite : ${Math.round(zone.width)} x ${Math.round(zone.height)} px`);
+    }
+    return page.locator(`[data-action="${action}"]`).nth(index);
 }
 
 /** Le nombre de dés montrés, et de dés estompés (déjà joués). */
@@ -1026,6 +1092,7 @@ async function rematch() {
  * immédiat, bandeau 10 s. Renvoie le journal de la partie quittée. */
 async function newGameFromMenu() {
     const before = await savedJournal();
+    const beforeId = await savedGameId();
     const started = () =>
         page.evaluate(() => JSON.parse(localStorage.getItem("ustagammon.settings") ?? "{}").gamesStarted);
     const startedBefore = await started();
@@ -1038,6 +1105,8 @@ async function newGameFromMenu() {
         `bandeau : « ${await page.textContent("#banner")} »`);
     check(!(await page.isVisible("#menu")), "le menu reste ouvert après « Nouvelle partie »");
     await waitForPlayer();
+    check((await waitForSavedGameOtherThan(beforeId)) !== null,
+        "« Nouvelle partie » : la partie n'a pas été enregistrée (30 s)");
     const after = await savedJournal();
     // (Les identifiants d'événements se suivent : une partie neuve peut avoir
     // la même tête que la précédente ; on compte les parties commencées.)
@@ -1127,6 +1196,7 @@ let resumed = false;
 let landscapeTurn = false;
 let rotatedChecked = false;
 let vibrationsChecked = false;
+let lastTouch = 0;
 let tracesSeen = 0;
 let replays = 0;
 let skips = 0;
@@ -1354,7 +1424,7 @@ for (let actions = 0; ; actions++) {
             const confirm = document.getElementById("confirm");
             const cancel = document.getElementById("cancel");
             return {
-                text: confirm.textContent,
+                text: confirm.firstChild.textContent,
                 primary: !confirm.classList.contains("secondary"),
                 right: confirm.getBoundingClientRect().x > cancel.getBoundingClientRect().x,
                 inBar: confirm.closest("#actions .slot.primary") !== null,
@@ -1430,9 +1500,14 @@ for (let actions = 0; ; actions++) {
             check(!(await page.isVisible("#menu")), "Échap ne ferme pas le menu");
         }
         const vibrationsBefore = (await vibrations()).length;
+        // Deux touchers rapprochés sur la même pile seraient un double
+        // toucher (coup évident, tests/browser/plateau.mjs) : ici, un
+        // toucher à la fois, un demi-coup à la fois.
+        await sleep(Math.max(0, lastTouch + 500 - Date.now()));
         // Un pion à destination unique avance dès qu'on le touche ; sinon,
         // ses cases d'arrivée s'allument. Le premier toucher est mesuré :
         // l'écran répond dans le gestionnaire du toucher.
+        lastTouch = Date.now();
         const ms = await page.evaluate(() => {
             const hit = document.querySelector(".hit.can-move");
             const t0 = performance.now();
@@ -1607,7 +1682,7 @@ await shot("4-fin-de-partie");
 // reste dans la barre d'actions.
 await page.click("#summary-close");
 await page.waitForSelector("#summary-veil", { state: "hidden" });
-check(!(await page.isVisible("#panel")) && (await page.textContent("#again")) === "Rejouer" &&
+check(!(await page.isVisible("#panel")) && (await page.textContent("#again > span")) === "Rejouer" &&
     (await page.isVisible("#again")),
     "bilan fermé : panneau toujours là, ou pas de « Rejouer »");
 
@@ -1617,11 +1692,17 @@ step("mes parties");
 // recharger la page.
 {
     const finished = await savedJournal();
+    const finishedId = await savedGameId();
     await rematch();
     await waitForPlayer();
+    // L'état observable, et non un délai : la nouvelle partie devient la
+    // partie en cours enregistrée.
+    const waited = await waitForSavedGameOtherThan(finishedId);
+    check(waited !== null, "la nouvelle partie n'a pas été enregistrée (30 s)");
+    log(`nouvelle partie enregistrée ${waited} ms après la main au joueur`);
     const second = await savedJournal();
     check(second.head !== finished.head || second.events.length !== finished.events.length,
-        "la nouvelle partie n'a pas été enregistrée");
+        "la nouvelle partie enregistrée a le journal de la partie finie");
     await openMenu();
     await page.click("#menu-games");
     await page.waitForSelector("#games-veil:not([hidden]) .games-item");
@@ -1744,6 +1825,12 @@ if (offline === "roll") {
     await page.click("#roll");
     await waitForPlayer();
 }
+// Si la partie reprise est finie, son bilan se rouvre au rechargement et
+// couvre l'écran (c'est voulu) : on le ferme avant d'ouvrir l'aide.
+if (await page.locator("#summary-veil").isVisible()) {
+    await page.click("#summary-close");
+    await page.waitForSelector("#summary-veil", { state: "hidden" });
+}
 await page.click("#help-button");
 await page.waitForSelector(".glossary dt", { state: "attached" });
 await page.click("#help-back");

tests/reference/README.md

@@ -256,7 +256,11 @@ Un fichier de résultat reprend le cas, avec `type` (`move`, `cube` ou
   gnubg plus 1), `played_equity`, `best_move`, `best_equity`, `equity_loss`
   (perte du coup joué, 0 ou négative : statistique « error-skill » de gnubg
   changée de signe), `skill` (`none`, `doubtful`, `bad`, `very_bad`) et
-  `ranking` (les dix premiers coups, et jusqu'au coup joué) ; plus, une fois
+  `ranking` (les dix premiers coups, et jusqu'au coup joué, chacun avec
+  `move`, `ply` et `equity` : comme pour `hint`, `ply` est le niveau auquel
+  gnubg a réellement évalué le coup ; à la différence de `hint`, l'analyse
+  réévalue au niveau demandé le meilleur coup et le coup joué quand celui-ci
+  est une erreur, au-delà du seuil « douteux ») ; plus, une fois
   pour toutes, `luck` : `value` (chance du jet) et `rating`
   (`very_unlucky`, `unlucky`, `none`, `lucky`, `very_lucky`) ;
 - **videau** : `analysed` (gnubg analyse-t-il cette décision ? pas à la
@@ -337,6 +341,10 @@ Pour chaque analyse (`engine-cli analysemove`, `analysecube`, `luck`, et
   équité que le coup joué, à la tolérance près : remarque), même meilleur coup
   sauf égalité, et `played_equity`, `best_equity`, `equity_loss` à la
   tolérance près ;
+- classement de l'analyse (`ranking`, dix coups au plus) : chaque coup de
+  gnubg présent (sauf égalité avec le dixième), au même `ply` et à la même
+  équité à la tolérance près ; son premier coup et le coup joué y sont
+  exactement `best` et `played` ;
 - chance : `value` à la tolérance près ;
 - videau : même `analysed`, même décision et équités à la tolérance près,
   `equity_loss` à la tolérance près ;

tests/reference/analysis/move-bearoff-doubles.json

@@ -25,6 +25,7 @@
       "ranking": [
         {
           "move": "6/off(2) 4/off 1/off",
+          "ply": 0,
           "equity": 0.8888838
         }
       ]
@@ -42,6 +43,7 @@
       "ranking": [
         {
           "move": "6/off(2) 4/off 1/off",
+          "ply": 0,
           "equity": 0.8888838
         }
       ]

tests/reference/analysis/move-blitz-doubles.json

@@ -25,438 +25,547 @@
       "ranking": [
         {
           "move": "13/10 6/3 4/1*(2)",
+          "ply": 0,
           "equity": 0.9465638
         },
         {
           "move": "8/5 6/3 4/1*(2)",
+          "ply": 0,
           "equity": 0.9422797
         },
         {
           "move": "13/7 13/10 6/3",
+          "ply": 0,
           "equity": 0.94128984
         },
         {
           "move": "13/7 8/5 6/3",
+          "ply": 0,
           "equity": 0.9370698
         },
         {
           "move": "13/10(2) 7/4 6/3",
+          "ply": 0,
           "equity": 0.93615985
         },
         {
           "move": "13/10(2) 8/5 6/3",
+          "ply": 0,
           "equity": 0.9330082
         },
         {
           "move": "13/10 8/5 7/4 6/3",
+          "ply": 0,
           "equity": 0.932737
         },
         {
           "move": "13/10 7/1* 6/3",
+          "ply": 0,
           "equity": 0.9313148
         },
         {
           "move": "8/5 7/1* 6/3",
+          "ply": 0,
           "equity": 0.93129885
         },
         {
           "move": "13/4 6/3",
+          "ply": 0,
           "equity": 0.92980635
         },
         {
           "move": "13/10 8/5(2) 6/3",
+          "ply": 0,
           "equity": 0.9264537
         },
         {
           "move": "13/10(3) 6/3",
+          "ply": 0,
           "equity": 0.9262361
         },
         {
           "move": "13/10(2) 4/1*(2)",
+          "ply": 0,
           "equity": 0.92529553
         },
         {
           "move": "8/5(2) 7/4 6/3",
+          "ply": 0,
           "equity": 0.9252107
         },
         {
           "move": "7/1* 6/3 4/1",
+          "ply": 0,
           "equity": 0.92395884
         },
         {
           "move": "13/10 6/3 5/2(2)",
+          "ply": 0,
           "equity": 0.9204093
         },
         {
           "move": "13/7 4/1*(2)",
+          "ply": 0,
           "equity": 0.9190106
         },
         {
           "move": "13/7(2)",
+          "ply": 0,
           "equity": 0.9184398
         },
         {
           "move": "13/10 8/5 4/1*(2)",
+          "ply": 0,
           "equity": 0.9182539
         },
         {
           "move": "7/4 6/3 5/2(2)",
+          "ply": 0,
           "equity": 0.91752934
         },
         {
           "move": "13/7 13/10(2)",
+          "ply": 0,
           "equity": 0.91483337
         },
         {
           "move": "13/10 8/2 6/3",
+          "ply": 0,
           "equity": 0.912639
         },
         {
           "move": "13/7 13/10 8/5",
+          "ply": 0,
           "equity": 0.91152656
         },
         {
           "move": "13/10(2) 7/1*",
+          "ply": 0,
           "equity": 0.9115156
         },
         {
           "move": "13/1*",
+          "ply": 0,
           "equity": 0.9111869
         },
         {
           "move": "13/10(2) 6/3 4/1*",
+          "ply": 0,
           "equity": 0.91055506
         },
         {
           "move": "8/2 8/5 6/3",
+          "ply": 0,
           "equity": 0.9091699
         },
         {
           "move": "8/2 7/4 6/3",
+          "ply": 0,
           "equity": 0.90897554
         },
         {
           "move": "13/7 8/5(2)",
+          "ply": 0,
           "equity": 0.90817225
         },
         {
           "move": "13/7 6/3 4/1*",
+          "ply": 0,
           "equity": 0.90714073
         },
         {
           "move": "13/10(2) 8/5 7/4",
+          "ply": 0,
           "equity": 0.9070756
         },
         {
           "move": "8/2(2)",
+          "ply": 0,
           "equity": 0.9065211
         },
         {
           "move": "13/10 8/5 7/1*",
+          "ply": 0,
           "equity": 0.90571
         },
         {
           "move": "13/10(3) 7/4",
+          "ply": 0,
           "equity": 0.9040942
         },
         {
           "move": "13/10 8/5 6/3 4/1*",
+          "ply": 0,
           "equity": 0.90343916
         },
         {
           "move": "8/5(2) 4/1*(2)",
+          "ply": 0,
           "equity": 0.90325713
         },
         {
           "move": "5/2(2) 4/1*(2)",
+          "ply": 0,
           "equity": 0.90183336
         },
         {
           "move": "13/10 7/1* 4/1",
+          "ply": 0,
           "equity": 0.9013542
         },
         {
           "move": "13/4 7/4",
+          "ply": 0,
           "equity": 0.9010268
         },
         {
           "move": "13/7 5/2(2)",
+          "ply": 0,
           "equity": 0.90037674
         },
         {
           "move": "8/5(2) 7/1*",
+          "ply": 0,
           "equity": 0.89956194
         },
         {
           "move": "13/10 8/5(2) 7/4",
+          "ply": 0,
           "equity": 0.8988826
         },
         {
           "move": "8/2 6/3 5/2",
+          "ply": 0,
           "equity": 0.8984738
         },
         {
           "move": "13/4 13/10",
+          "ply": 0,
           "equity": 0.89749956
         },
         {
           "move": "6/3(2) 4/1*(2)",
+          "ply": 0,
           "equity": 0.8951012
         },
         {
           "move": "13/10(2) 8/5(2)",
+          "ply": 0,
           "equity": 0.89493525
         },
         {
           "move": "13/7 8/2",
+          "ply": 0,
           "equity": 0.8946096
         },
         {
           "move": "13/7 6/3(2)",
+          "ply": 0,
           "equity": 0.89403474
         },
         {
           "move": "7/1* 5/2(2)",
+          "ply": 0,
           "equity": 0.8924208
         },
         {
           "move": "8/5 7/1* 4/1",
+          "ply": 0,
           "equity": 0.891961
         },
         {
           "move": "13/10(2) 6/3(2)",
+          "ply": 0,
           "equity": 0.89077055
         },
         {
           "move": "13/4 8/5",
+          "ply": 0,
           "equity": 0.8907301
         },
         {
           "move": "8/5(2) 6/3 4/1*",
+          "ply": 0,
           "equity": 0.8900244
         },
         {
           "move": "13/10(2) 5/2(2)",
+          "ply": 0,
           "equity": 0.8890666
         },
         {
           "move": "7/4 6/3(3)",
+          "ply": 0,
           "equity": 0.8890004
         },
         {
           "move": "13/10 7/4 5/2(2)",
+          "ply": 0,
           "equity": 0.8888954
         },
         {
           "move": "8/2 8/5 7/4",
+          "ply": 0,
           "equity": 0.8876569
         },
         {
           "move": "13/10(4)",
+          "ply": 0,
           "equity": 0.88716996
         },
         {
           "move": "7/1* 6/3(2)",
+          "ply": 0,
           "equity": 0.8856077
         },
         {
           "move": "8/2 4/1*(2)",
+          "ply": 0,
           "equity": 0.8853629
         },
         {
           "move": "13/10 6/3(3)",
+          "ply": 0,
           "equity": 0.8853096
         },
         {
           "move": "13/7 6/3 5/2",
+          "ply": 0,
           "equity": 0.8831558
         },
         {
           "move": "13/10 8/2 7/4",
+          "ply": 0,
           "equity": 0.8819176
         },
         {
           "move": "7/1* 4/1(2)",
+          "ply": 0,
           "equity": 0.88113916
         },
         {
           "move": "13/10 7/4 6/3(2)",
+          "ply": 0,
           "equity": 0.88064635
         },
         {
           "move": "13/10(3) 8/5",
+          "ply": 0,
           "equity": 0.88049895
         },
         {
           "move": "6/3 5/2(2) 4/1*",
+          "ply": 0,
           "equity": 0.8790827
         },
         {
           "move": "13/10(2) 8/2",
+          "ply": 0,
           "equity": 0.8782023
         },
         {
           "move": "6/3 5/2 4/1*(2)",
+          "ply": 0,
           "equity": 0.8774586
         },
         {
           "move": "8/5 6/3(3)",
+          "ply": 0,
           "equity": 0.8774268
         },
         {
           "move": "8/2 7/1*",
+          "ply": 0,
           "equity": 0.8772669
         },
         {
           "move": "13/7 13/10 4/1*",
+          "ply": 0,
           "equity": 0.87700987
         },
         {
           "move": "13/10 8/5 6/3(2)",
+          "ply": 0,
           "equity": 0.8757389
         },
         {
           "move": "13/10 8/2 8/5",
+          "ply": 0,
           "equity": 0.87530077
         },
         {
           "move": "13/10(2) 6/3 5/2",
+          "ply": 0,
           "equity": 0.87215745
         },
         {
           "move": "13/7 8/5 4/1*",
+          "ply": 0,
           "equity": 0.87202764
         },
         {
           "move": "8/5 7/4 6/3(2)",
+          "ply": 0,
           "equity": 0.86896765
         },
         {
           "move": "7/1* 6/3 5/2",
+          "ply": 0,
           "equity": 0.8687051
         },
         {
           "move": "13/10 7/4 6/3 5/2",
+          "ply": 0,
           "equity": 0.8679464
         },
         {
           "move": "8/2 6/3 4/1*",
+          "ply": 0,
           "equity": 0.86750233
         },
         {
           "move": "13/10(2) 8/5 4/1*",
+          "ply": 0,
           "equity": 0.86701244
         },
         {
           "move": "8/5(2) 6/3(2)",
+          "ply": 0,
           "equity": 0.86167765
         },
         {
           "move": "13/10(3) 4/1*",
+          "ply": 0,
           "equity": 0.8568015
         },
         {
           "move": "6/3(2) 5/2(2)",
+          "ply": 0,
           "equity": 0.85501754
         },
         {
           "move": "8/2 7/4 5/2",
+          "ply": 0,
           "equity": 0.8537997
         },
         {
           "move": "8/2 5/2(2)",
+          "ply": 0,
           "equity": 0.8524791
         },
         {
           "move": "13/10 8/5(2) 4/1*",
+          "ply": 0,
           "equity": 0.84969926
         },
         {
           "move": "13/10 8/2 5/2",
+          "ply": 0,
           "equity": 0.8466199
         },
         {
           "move": "8/2 6/3(2)",
+          "ply": 0,
           "equity": 0.80814815
         },
         {
           "move": "13/10 5/2(2) 4/1*",
+          "ply": 0,
           "equity": 0.8037353
         },
         {
           "move": "13/10 5/2 4/1*(2)",
+          "ply": 0,
           "equity": 0.77350885
         },
         {
           "move": "13/10 6/3(2) 4/1*",
+          "ply": 0,
           "equity": 0.74067366
         },
         {
           "move": "13/7 13/10 5/2",
+          "ply": 0,
           "equity": 0.72703636
         },
         {
           "move": "13/10(2) 7/4 5/2",
+          "ply": 0,
           "equity": 0.7053956
         },
         {
           "move": "6/3(3) 4/1*",
+          "ply": 0,
           "equity": 0.66575944
         },
         {
           "move": "13/10 7/1* 5/2",
+          "ply": 0,
           "equity": 0.6462204
         },
         {
           "move": "8/5 6/3(2) 4/1*",
+          "ply": 0,
           "equity": 0.6374039
         },
         {
           "move": "8/2 8/5 4/1*",
+          "ply": 0,
           "equity": 0.62353325
         },
         {
           "move": "13/10 8/2 4/1*",
+          "ply": 0,
           "equity": 0.61257124
         },
         {
           "move": "13/10 6/3 5/2 4/1*",
+          "ply": 0,
           "equity": 0.5349428
         },
         {
           "move": "7/1* 5/2 4/1",
+          "ply": 0,
           "equity": 0.45721298
         },
         {
           "move": "8/2 5/2 4/1*",
+          "ply": 0,
           "equity": 0.44362232
         },
         {
           "move": "13/4 5/2",
+          "ply": 0,
           "equity": 0.43828273
         },
         {
           "move": "13/10(3) 5/2",
+          "ply": 0,
           "equity": 0.2798175
         },
         {
           "move": "13/10 6/3(2) 5/2",
+          "ply": 0,
           "equity": 0.24207813
         },
         {
           "move": "6/3(3) 5/2",
+          "ply": 0,
           "equity": 0.23385207
         },
         {
           "move": "7/4 6/3(2) 5/2",
+          "ply": 0,
           "equity": 0.22096781
         },
         {
           "move": "13/7 5/2 4/1*",
+          "ply": 0,
           "equity": 0.18849733
         },
         {
           "move": "13/10(2) 5/2 4/1*",
+          "ply": 0,
           "equity": 0.084023334
         }
       ]
@@ -474,42 +583,52 @@
       "ranking": [
         {
           "move": "13/10 7/1* 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/7 13/10 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/10(2) 8/5 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/7 8/5 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/10(2) 7/4 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/10 8/5 7/4 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/10(2) 5/2 4/1*",
+          "ply": 2,
           "equity": -0.022027964
         },
         {
           "move": "13/10 8/5(2) 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/4 6/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/10 6/3 4/1*(2)",
+          "ply": 2,
           "equity": 0.99692726
         }
       ]

tests/reference/analysis/move-crawford.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "8/5 6/2",
+          "ply": 0,
           "equity": 0.7345603
         },
         {
           "move": "5/2 5/1*",
+          "ply": 0,
           "equity": 0.7229391
         },
         {
           "move": "8/1*",
+          "ply": 0,
           "equity": 0.71705425
         },
         {
           "move": "13/10 6/2",
+          "ply": 0,
           "equity": 0.7142835
         },
         {
           "move": "13/9 8/5",
+          "ply": 0,
           "equity": 0.6963019
         },
         {
           "move": "8/5 8/4",
+          "ply": 0,
           "equity": 0.68610644
         },
         {
           "move": "13/10 8/4",
+          "ply": 0,
           "equity": 0.6855368
         },
         {
           "move": "13/10 13/9",
+          "ply": 0,
           "equity": 0.6818689
         },
         {
           "move": "13/6",
+          "ply": 0,
           "equity": 0.6633271
         },
         {
           "move": "13/9 5/2",
+          "ply": 0,
           "equity": 0.6538005
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "8/5 6/2",
+          "ply": 2,
           "equity": 0.7697691
         },
         {
           "move": "13/10 6/2",
+          "ply": 2,
           "equity": 0.7615671
         },
         {
           "move": "13/9 8/5",
+          "ply": 2,
           "equity": 0.69608325
         },
         {
           "move": "5/2 5/1*",
+          "ply": 2,
           "equity": 0.6911188
         },
         {
           "move": "8/1*",
+          "ply": 2,
           "equity": 0.6836242
         },
         {
           "move": "13/10 13/9",
+          "ply": 2,
           "equity": 0.6807338
         },
         {
           "move": "13/10 8/4",
+          "ply": 1,
           "equity": 0.6733323
         },
         {
           "move": "13/6",
+          "ply": 1,
           "equity": 0.66055346
         },
         {
           "move": "8/5 8/4",
+          "ply": 1,
           "equity": 0.6556259
         },
         {
           "move": "13/9 5/2",
+          "ply": 1,
           "equity": 0.645951
         }
       ]

tests/reference/analysis/move-forced.json

@@ -25,6 +25,7 @@
       "ranking": [
         {
           "move": "bar/24",
+          "ply": 0,
           "equity": -1.0
         }
       ]
@@ -42,6 +43,7 @@
       "ranking": [
         {
           "move": "bar/24",
+          "ply": 0,
           "equity": -1.0
         }
       ]

tests/reference/analysis/move-jacoby.json

@@ -25,58 +25,72 @@
       "ranking": [
         {
           "move": "13/3",
+          "ply": 0,
           "equity": 0.9328213
         },
         {
           "move": "13/9 13/7",
+          "ply": 0,
           "equity": 0.9175232
         },
         {
           "move": "8/2 7/3",
+          "ply": 0,
           "equity": 0.91263336
         },
         {
           "move": "13/7 8/4",
+          "ply": 0,
           "equity": 0.90736973
         },
         {
           "move": "13/9 7/1*",
+          "ply": 0,
           "equity": 0.9053596
         },
         {
           "move": "8/2 6/2",
+          "ply": 0,
           "equity": 0.9017469
         },
         {
           "move": "8/4 7/1*",
+          "ply": 0,
           "equity": 0.89993495
         },
         {
           "move": "13/7 6/2",
+          "ply": 0,
           "equity": 0.8962312
         },
         {
           "move": "7/1* 5/1",
+          "ply": 0,
           "equity": 0.8907822
         },
         {
           "move": "7/1* 6/2",
+          "ply": 0,
           "equity": 0.87481093
         },
         {
           "move": "13/9 8/2",
+          "ply": 0,
           "equity": 0.87251335
         },
         {
           "move": "8/4 8/2",
+          "ply": 0,
           "equity": 0.8716274
         },
         {
           "move": "13/7 5/1*",
+          "ply": 0,
           "equity": 0.87005275
         },
         {
           "move": "8/2 5/1*",
+          "ply": 0,
           "equity": 0.50889754
         }
       ]
@@ -94,42 +108,52 @@
       "ranking": [
         {
           "move": "13/3",
+          "ply": 2,
           "equity": 1.0
         },
         {
           "move": "13/9 13/7",
+          "ply": 2,
           "equity": 0.99894416
         },
         {
           "move": "8/2 7/3",
+          "ply": 2,
           "equity": 0.99641544
         },
         {
           "move": "13/7 8/4",
+          "ply": 2,
           "equity": 0.98718643
         },
         {
           "move": "13/7 6/2",
+          "ply": 2,
           "equity": 0.9808178
         },
         {
           "move": "13/9 7/1*",
+          "ply": 2,
           "equity": 0.9452111
         },
         {
           "move": "8/2 5/1*",
+          "ply": 2,
           "equity": 0.3304975
         },
         {
           "move": "8/4 7/1*",
+          "ply": 1,
           "equity": 0.93114305
         },
         {
           "move": "7/1* 5/1",
+          "ply": 1,
           "equity": 0.91711015
         },
         {
           "move": "8/2 6/2",
+          "ply": 1,
           "equity": 0.9160911
         }
       ]

tests/reference/analysis/move-luck-lucky.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "13/5 11/3",
+          "ply": 0,
           "equity": 0.16933289
         },
         {
           "move": "13/9(2) 11/3",
+          "ply": 0,
           "equity": 0.16701066
         },
         {
           "move": "13/5 9/5 7/3",
+          "ply": 0,
           "equity": 0.16552198
         },
         {
           "move": "13/5(2)",
+          "ply": 0,
           "equity": 0.16473158
         },
         {
           "move": "13/5 13/9 11/7",
+          "ply": 0,
           "equity": 0.16365689
         },
         {
           "move": "13/5 13/9 7/3",
+          "ply": 0,
           "equity": 0.16245355
         },
         {
           "move": "13/5 11/7 9/5",
+          "ply": 0,
           "equity": 0.16167049
         },
         {
           "move": "11/3 9/5(2)",
+          "ply": 0,
           "equity": 0.16043647
         },
         {
           "move": "13/9 11/3 11/7",
+          "ply": 0,
           "equity": 0.1603657
         },
         {
           "move": "13/5 11/7(2)",
+          "ply": 0,
           "equity": 0.1602792
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "13/5 11/3",
+          "ply": 2,
           "equity": 0.15129912
         },
         {
           "move": "13/5 13/9 11/7",
+          "ply": 2,
           "equity": 0.15059008
         },
         {
           "move": "13/9(2) 11/3",
+          "ply": 2,
           "equity": 0.14950007
         },
         {
           "move": "13/5 11/7 9/5",
+          "ply": 2,
           "equity": 0.14858595
         },
         {
           "move": "11/3 11/7 9/5",
+          "ply": 2,
           "equity": 0.14829463
         },
         {
           "move": "13/9 11/3 11/7",
+          "ply": 2,
           "equity": 0.1463402
         },
         {
           "move": "13/5 9/5 7/3",
+          "ply": 1,
           "equity": 0.13938732
         },
         {
           "move": "13/5 11/7(2)",
+          "ply": 1,
           "equity": 0.13921705
         },
         {
           "move": "13/9(2) 11/7(2)",
+          "ply": 1,
           "equity": 0.13873637
         },
         {
           "move": "13/5 13/9 6/2",
+          "ply": 1,
           "equity": 0.13852078
         }
       ]

tests/reference/analysis/move-luck-unlucky-bearoff.json

@@ -25,18 +25,22 @@
       "ranking": [
         {
           "move": "3/off",
+          "ply": 0,
           "equity": -0.8607614
         },
         {
           "move": "2/off 1/off",
+          "ply": 0,
           "equity": -0.8607614
         },
         {
           "move": "2/1 2/off",
+          "ply": 0,
           "equity": -0.95561147
         },
         {
           "move": "3/1 2/1",
+          "ply": 0,
           "equity": -1.0
         }
       ]
@@ -54,18 +58,22 @@
       "ranking": [
         {
           "move": "3/off",
+          "ply": 2,
           "equity": -0.8607614
         },
         {
           "move": "2/off 1/off",
+          "ply": 2,
           "equity": -0.8607614
         },
         {
           "move": "2/1 2/off",
+          "ply": 2,
           "equity": -0.95561147
         },
         {
           "move": "3/1 2/1",
+          "ply": 1,
           "equity": -1.0
         }
       ]

tests/reference/analysis/move-luck-unlucky.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "18/9",
+          "ply": 0,
           "equity": 0.2544027
         },
         {
           "move": "18/14 13/8",
+          "ply": 0,
           "equity": 0.22496489
         },
         {
           "move": "24/20 18/13",
+          "ply": 0,
           "equity": 0.20747662
         },
         {
           "move": "24/20 13/8",
+          "ply": 0,
           "equity": 0.1158272
         },
         {
           "move": "13/9 13/8",
+          "ply": 0,
           "equity": 0.09201278
         },
         {
           "move": "24/15",
+          "ply": 0,
           "equity": 0.061017293
         },
         {
           "move": "18/13 6/2",
+          "ply": 0,
           "equity": 0.03581623
         },
         {
           "move": "13/4",
+          "ply": 0,
           "equity": -0.028887823
         },
         {
           "move": "13/8 6/2",
+          "ply": 0,
           "equity": -0.033572298
         },
         {
           "move": "18/13 8/4",
+          "ply": 0,
           "equity": -0.09662818
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "18/9",
+          "ply": 2,
           "equity": 0.27687487
         },
         {
           "move": "18/14 13/8",
+          "ply": 2,
           "equity": 0.21801135
         },
         {
           "move": "24/20 18/13",
+          "ply": 2,
           "equity": 0.21000355
         },
         {
           "move": "24/20 13/8",
+          "ply": 2,
           "equity": 0.1144446
         },
         {
           "move": "13/9 13/8",
+          "ply": 2,
           "equity": 0.09412725
         },
         {
           "move": "24/15",
+          "ply": 2,
           "equity": 0.07892294
         },
         {
           "move": "18/13 6/2",
+          "ply": 1,
           "equity": -0.020656409
         },
         {
           "move": "13/4",
+          "ply": 0,
           "equity": -0.028887823
         },
         {
           "move": "13/8 6/2",
+          "ply": 0,
           "equity": -0.033572298
         },
         {
           "move": "18/13 8/4",
+          "ply": 0,
           "equity": -0.09662818
         }
       ]

tests/reference/analysis/move-match.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "13/5",
+          "ply": 0,
           "equity": 0.7553502
         },
         {
           "move": "18/13 8/5",
+          "ply": 0,
           "equity": 0.5814649
         },
         {
           "move": "24/16*",
+          "ply": 0,
           "equity": 0.4581785
         },
         {
           "move": "18/10",
+          "ply": 0,
           "equity": 0.31719947
         },
         {
           "move": "8/5 8/3",
+          "ply": 0,
           "equity": 0.31371918
         },
         {
           "move": "18/15 13/8",
+          "ply": 0,
           "equity": 0.26037523
         },
         {
           "move": "24/21 18/13",
+          "ply": 0,
           "equity": 0.23547156
         },
         {
           "move": "8/3 6/3",
+          "ply": 0,
           "equity": 0.15432969
         },
         {
           "move": "13/10 13/8",
+          "ply": 0,
           "equity": 0.13837479
         },
         {
           "move": "18/13 5/2",
+          "ply": 0,
           "equity": 0.12815686
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "13/5",
+          "ply": 2,
           "equity": 0.85497326
         },
         {
           "move": "24/16*",
+          "ply": 2,
           "equity": 0.46805125
         },
         {
           "move": "18/13 8/5",
+          "ply": 1,
           "equity": 0.6511238
         },
         {
           "move": "18/10",
+          "ply": 0,
           "equity": 0.31719947
         },
         {
           "move": "8/5 8/3",
+          "ply": 0,
           "equity": 0.31371918
         },
         {
           "move": "18/15 13/8",
+          "ply": 0,
           "equity": 0.26037523
         },
         {
           "move": "24/21 18/13",
+          "ply": 0,
           "equity": 0.23547156
         },
         {
           "move": "8/3 6/3",
+          "ply": 0,
           "equity": 0.15432969
         },
         {
           "move": "13/10 13/8",
+          "ply": 0,
           "equity": 0.13837479
         },
         {
           "move": "18/13 5/2",
+          "ply": 0,
           "equity": 0.12815686
         }
       ]

tests/reference/analysis/move-middlegame-blunder.json

@@ -25,58 +25,72 @@
       "ranking": [
         {
           "move": "24/14",
+          "ply": 0,
           "equity": 0.15439394
         },
         {
           "move": "8/2 6/2",
+          "ply": 0,
           "equity": 0.10821653
         },
         {
           "move": "24/18 13/9",
+          "ply": 0,
           "equity": 0.10337136
         },
         {
           "move": "24/20 24/18",
+          "ply": 0,
           "equity": 0.072762795
         },
         {
           "move": "13/9 13/7",
+          "ply": 0,
           "equity": 0.0029048775
         },
         {
           "move": "24/20 13/7",
+          "ply": 0,
           "equity": 9.1438415e-05
         },
         {
           "move": "13/3",
+          "ply": 0,
           "equity": -0.012697897
         },
         {
           "move": "24/18 6/2",
+          "ply": 0,
           "equity": -0.075399
         },
         {
           "move": "24/18 8/4",
+          "ply": 0,
           "equity": -0.088734664
         },
         {
           "move": "24/20 8/2",
+          "ply": 0,
           "equity": -0.095189385
         },
         {
           "move": "13/9 8/2",
+          "ply": 0,
           "equity": -0.09528468
         },
         {
           "move": "13/7 8/4",
+          "ply": 0,
           "equity": -0.12819159
         },
         {
           "move": "13/7 6/2",
+          "ply": 0,
           "equity": -0.14467186
         },
         {
           "move": "8/4 8/2",
+          "ply": 0,
           "equity": -0.35321844
         }
       ]
@@ -94,42 +108,52 @@
       "ranking": [
         {
           "move": "24/14",
+          "ply": 2,
           "equity": 0.13111727
         },
         {
           "move": "8/2 6/2",
+          "ply": 2,
           "equity": 0.11303549
         },
         {
           "move": "24/18 13/9",
+          "ply": 2,
           "equity": 0.105096616
         },
         {
           "move": "24/20 24/18",
+          "ply": 2,
           "equity": 0.049068402
         },
         {
           "move": "13/3",
+          "ply": 2,
           "equity": -0.0040049786
         },
         {
           "move": "8/4 8/2",
+          "ply": 2,
           "equity": -0.36824828
         },
         {
           "move": "13/9 13/7",
+          "ply": 2,
           "equity": -0.014309813
         },
         {
           "move": "24/20 13/7",
+          "ply": 1,
           "equity": -0.029367238
         },
         {
           "move": "24/18 8/4",
+          "ply": 1,
           "equity": -0.081171095
         },
         {
           "move": "24/18 6/2",
+          "ply": 1,
           "equity": -0.09313507
         }
       ]

tests/reference/analysis/move-middlegame-close.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "24/14",
+          "ply": 0,
           "equity": 0.15439394
         },
         {
           "move": "8/2 6/2",
+          "ply": 0,
           "equity": 0.10821653
         },
         {
           "move": "24/18 13/9",
+          "ply": 0,
           "equity": 0.10337136
         },
         {
           "move": "24/20 24/18",
+          "ply": 0,
           "equity": 0.072762795
         },
         {
           "move": "13/9 13/7",
+          "ply": 0,
           "equity": 0.0029048775
         },
         {
           "move": "24/20 13/7",
+          "ply": 0,
           "equity": 9.1438415e-05
         },
         {
           "move": "13/3",
+          "ply": 0,
           "equity": -0.012697897
         },
         {
           "move": "24/18 6/2",
+          "ply": 0,
           "equity": -0.075399
         },
         {
           "move": "24/18 8/4",
+          "ply": 0,
           "equity": -0.088734664
         },
         {
           "move": "24/20 8/2",
+          "ply": 0,
           "equity": -0.095189385
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "24/14",
+          "ply": 2,
           "equity": 0.13111727
         },
         {
           "move": "8/2 6/2",
+          "ply": 2,
           "equity": 0.11303549
         },
         {
           "move": "24/18 13/9",
+          "ply": 2,
           "equity": 0.105096616
         },
         {
           "move": "24/20 24/18",
+          "ply": 2,
           "equity": 0.049068402
         },
         {
           "move": "13/3",
+          "ply": 2,
           "equity": -0.0040049786
         },
         {
           "move": "13/9 13/7",
+          "ply": 2,
           "equity": -0.014309813
         },
         {
           "move": "24/20 13/7",
+          "ply": 1,
           "equity": -0.029367238
         },
         {
           "move": "24/18 8/4",
+          "ply": 1,
           "equity": -0.081171095
         },
         {
           "move": "24/18 6/2",
+          "ply": 1,
           "equity": -0.09313507
         },
         {
           "move": "24/20 8/2",
+          "ply": 0,
           "equity": -0.095189385
         }
       ]

tests/reference/analysis/move-opening-31-best.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "8/5 6/5",
+          "ply": 0,
           "equity": 0.21258597
         },
         {
           "move": "24/23 13/10",
+          "ply": 0,
           "equity": -0.010789523
         },
         {
           "move": "24/20",
+          "ply": 0,
           "equity": -0.017392516
         },
         {
           "move": "24/23 24/21",
+          "ply": 0,
           "equity": -0.023609947
         },
         {
           "move": "13/9",
+          "ply": 0,
           "equity": -0.027675275
         },
         {
           "move": "24/21 6/5",
+          "ply": 0,
           "equity": -0.04369401
         },
         {
           "move": "13/10 6/5",
+          "ply": 0,
           "equity": -0.04984435
         },
         {
           "move": "24/23 8/5",
+          "ply": 0,
           "equity": -0.104100645
         },
         {
           "move": "24/23 6/3",
+          "ply": 0,
           "equity": -0.10542354
         },
         {
           "move": "24/21 8/7",
+          "ply": 0,
           "equity": -0.107585564
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "8/5 6/5",
+          "ply": 1,
           "equity": 0.20373425
         },
         {
           "move": "24/23 13/10",
+          "ply": 1,
           "equity": -0.022293653
         },
         {
           "move": "24/20",
+          "ply": 1,
           "equity": -0.031027086
         },
         {
           "move": "24/23 24/21",
+          "ply": 1,
           "equity": -0.03213631
         },
         {
           "move": "13/9",
+          "ply": 1,
           "equity": -0.040205758
         },
         {
           "move": "24/21 6/5",
+          "ply": 0,
           "equity": -0.04369401
         },
         {
           "move": "13/10 6/5",
+          "ply": 0,
           "equity": -0.04984435
         },
         {
           "move": "24/23 8/5",
+          "ply": 0,
           "equity": -0.104100645
         },
         {
           "move": "24/23 6/3",
+          "ply": 0,
           "equity": -0.10542354
         },
         {
           "move": "24/21 8/7",
+          "ply": 0,
           "equity": -0.107585564
         }
       ]

tests/reference/analysis/move-opening-31-error.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "8/5 6/5",
+          "ply": 0,
           "equity": 0.21258597
         },
         {
           "move": "24/23 13/10",
+          "ply": 0,
           "equity": -0.010789523
         },
         {
           "move": "24/20",
+          "ply": 0,
           "equity": -0.017392516
         },
         {
           "move": "24/23 24/21",
+          "ply": 0,
           "equity": -0.023609947
         },
         {
           "move": "13/9",
+          "ply": 0,
           "equity": -0.027675275
         },
         {
           "move": "24/21 6/5",
+          "ply": 0,
           "equity": -0.04369401
         },
         {
           "move": "13/10 6/5",
+          "ply": 0,
           "equity": -0.04984435
         },
         {
           "move": "24/23 8/5",
+          "ply": 0,
           "equity": -0.104100645
         },
         {
           "move": "24/23 6/3",
+          "ply": 0,
           "equity": -0.10542354
         },
         {
           "move": "24/21 8/7",
+          "ply": 0,
           "equity": -0.107585564
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "8/5 6/5",
+          "ply": 2,
           "equity": 0.1998143
         },
         {
           "move": "24/23 13/10",
+          "ply": 2,
           "equity": -0.0118339015
         },
         {
           "move": "24/20",
+          "ply": 1,
           "equity": -0.031027086
         },
         {
           "move": "24/23 24/21",
+          "ply": 1,
           "equity": -0.03213631
         },
         {
           "move": "13/9",
+          "ply": 1,
           "equity": -0.040205758
         },
         {
           "move": "24/21 6/5",
+          "ply": 0,
           "equity": -0.04369401
         },
         {
           "move": "13/10 6/5",
+          "ply": 0,
           "equity": -0.04984435
         },
         {
           "move": "24/23 8/5",
+          "ply": 0,
           "equity": -0.104100645
         },
         {
           "move": "24/23 6/3",
+          "ply": 0,
           "equity": -0.10542354
         },
         {
           "move": "24/21 8/7",
+          "ply": 0,
           "equity": -0.107585564
         }
       ]

tests/reference/analysis/move-opening-65-error.json

@@ -25,30 +25,37 @@
       "ranking": [
         {
           "move": "24/13",
+          "ply": 0,
           "equity": 0.082985915
         },
         {
           "move": "24/18 13/8",
+          "ply": 0,
           "equity": 0.03631018
         },
         {
           "move": "13/8 13/7",
+          "ply": 0,
           "equity": -0.05142035
         },
         {
           "move": "13/2",
+          "ply": 0,
           "equity": -0.13522762
         },
         {
           "move": "24/18 8/3",
+          "ply": 0,
           "equity": -0.14635906
         },
         {
           "move": "13/7 8/3",
+          "ply": 0,
           "equity": -0.17384717
         },
         {
           "move": "8/3 8/2",
+          "ply": 0,
           "equity": -0.37779096
         }
       ]
@@ -66,30 +73,37 @@
       "ranking": [
         {
           "move": "24/13",
+          "ply": 2,
           "equity": 0.07996891
         },
         {
           "move": "24/18 13/8",
+          "ply": 2,
           "equity": 0.03882884
         },
         {
           "move": "13/8 13/7",
+          "ply": 2,
           "equity": -0.061850794
         },
         {
           "move": "13/2",
+          "ply": 1,
           "equity": -0.12083713
         },
         {
           "move": "24/18 8/3",
+          "ply": 1,
           "equity": -0.13999933
         },
         {
           "move": "13/7 8/3",
+          "ply": 0,
           "equity": -0.17384717
         },
         {
           "move": "8/3 8/2",
+          "ply": 0,
           "equity": -0.37779096
         }
       ]

tests/reference/analysis/move-opening-double.json

@@ -25,42 +25,52 @@
       "ranking": [
         {
           "move": "24/18(2) 13/7(2)",
+          "ply": 0,
           "equity": 0.539388
         },
         {
           "move": "24/18 13/7(3)",
+          "ply": 0,
           "equity": 0.33099693
         },
         {
           "move": "24/18(2) 8/2(2)",
+          "ply": 0,
           "equity": 0.27119082
         },
         {
           "move": "13/7(2) 8/2(2)",
+          "ply": 0,
           "equity": 0.1563462
         },
         {
           "move": "24/18 13/7(2) 8/2",
+          "ply": 0,
           "equity": 0.14750561
         },
         {
           "move": "13/7(4)",
+          "ply": 0,
           "equity": 0.14310652
         },
         {
           "move": "24/18(2) 13/7 8/2",
+          "ply": 0,
           "equity": 0.12353878
         },
         {
           "move": "13/7(3) 8/2",
+          "ply": 0,
           "equity": 0.101389736
         },
         {
           "move": "24/18 13/7 8/2(2)",
+          "ply": 0,
           "equity": -0.05435923
         },
         {
           "move": "24/18 8/2(3)",
+          "ply": 0,
           "equity": -0.12482335
         }
       ]
@@ -78,42 +88,52 @@
       "ranking": [
         {
           "move": "24/18(2) 13/7(2)",
+          "ply": 1,
           "equity": 0.5886327
         },
         {
           "move": "24/18 13/7(3)",
+          "ply": 1,
           "equity": 0.33312234
         },
         {
           "move": "24/18(2) 8/2(2)",
+          "ply": 0,
           "equity": 0.27119082
         },
         {
           "move": "13/7(2) 8/2(2)",
+          "ply": 0,
           "equity": 0.1563462
         },
         {
           "move": "24/18 13/7(2) 8/2",
+          "ply": 0,
           "equity": 0.14750561
         },
         {
           "move": "13/7(4)",
+          "ply": 0,
           "equity": 0.14310652
         },
         {
           "move": "24/18(2) 13/7 8/2",
+          "ply": 0,
           "equity": 0.12353878
         },
         {
           "move": "13/7(3) 8/2",
+          "ply": 0,
           "equity": 0.101389736
         },
         {
           "move": "24/18 13/7 8/2(2)",
+          "ply": 0,
           "equity": -0.05435923
         },
         {
           "move": "24/18 8/2(3)",
+          "ply": 0,
           "equity": -0.12482335
         }
       ]

tests/reference/analysis/move-race.json

@@ -25,118 +25,147 @@
       "ranking": [
         {
           "move": "13/9 11/6",
+          "ply": 0,
           "equity": -0.22230339
         },
         {
           "move": "11/6 9/5",
+          "ply": 0,
           "equity": -0.22993731
         },
         {
           "move": "13/8 9/5",
+          "ply": 0,
           "equity": -0.23005769
         },
         {
           "move": "13/9 13/8",
+          "ply": 0,
           "equity": -0.23073325
         },
         {
           "move": "13/8 11/7",
+          "ply": 0,
           "equity": -0.23153114
         },
         {
           "move": "11/7 11/6",
+          "ply": 0,
           "equity": -0.2335976
         },
         {
           "move": "13/8 7/3",
+          "ply": 0,
           "equity": -0.23374501
         },
         {
           "move": "11/6 7/3",
+          "ply": 0,
           "equity": -0.23394687
         },
         {
           "move": "13/4",
+          "ply": 0,
           "equity": -0.23507257
         },
         {
           "move": "13/9 7/2",
+          "ply": 0,
           "equity": -0.23529215
         },
         {
           "move": "7/3 7/2",
+          "ply": 0,
           "equity": -0.23544219
         },
         {
           "move": "11/2",
+          "ply": 0,
           "equity": -0.235758
         },
         {
           "move": "11/7 9/4",
+          "ply": 0,
           "equity": -0.23589191
         },
         {
           "move": "13/8 6/2",
+          "ply": 0,
           "equity": -0.24026787
         },
         {
           "move": "9/5 7/2",
+          "ply": 0,
           "equity": -0.24087214
         },
         {
           "move": "13/8 5/1",
+          "ply": 0,
           "equity": -0.24252185
         },
         {
           "move": "9/5 9/4",
+          "ply": 0,
           "equity": -0.2440444
         },
         {
           "move": "9/4 6/2",
+          "ply": 0,
           "equity": -0.24487257
         },
         {
           "move": "9/4 7/3",
+          "ply": 0,
           "equity": -0.24512678
         },
         {
           "move": "11/6 5/1",
+          "ply": 0,
           "equity": -0.25016445
         },
         {
           "move": "9/4 5/1",
+          "ply": 0,
           "equity": -0.25572774
         },
         {
           "move": "7/2 5/1",
+          "ply": 0,
           "equity": -0.258138
         },
         {
           "move": "7/3 6/1",
+          "ply": 0,
           "equity": -0.25878713
         },
         {
           "move": "7/2 6/2",
+          "ply": 0,
           "equity": -0.26088732
         },
         {
           "move": "13/9 6/1",
+          "ply": 0,
           "equity": -0.26104733
         },
         {
           "move": "9/5 6/1",
+          "ply": 0,
           "equity": -0.26680842
         },
         {
           "move": "11/7 6/1",
+          "ply": 0,
           "equity": -0.2670043
         },
         {
           "move": "6/2 6/1",
+          "ply": 0,
           "equity": -0.27360544
         },
         {
           "move": "6/1 5/1",
+          "ply": 0,
           "equity": -0.31466243
         }
       ]
@@ -154,42 +183,52 @@
       "ranking": [
         {
           "move": "13/9 11/6",
+          "ply": 2,
           "equity": -0.21922025
         },
         {
           "move": "13/9 13/8",
+          "ply": 2,
           "equity": -0.2202243
         },
         {
           "move": "11/6 9/5",
+          "ply": 2,
           "equity": -0.22022447
         },
         {
           "move": "13/8 9/5",
+          "ply": 2,
           "equity": -0.22088149
         },
         {
           "move": "11/7 11/6",
+          "ply": 2,
           "equity": -0.22277355
         },
         {
           "move": "13/4",
+          "ply": 2,
           "equity": -0.2230124
         },
         {
           "move": "6/1 5/1",
+          "ply": 2,
           "equity": -0.29347342
         },
         {
           "move": "11/7 9/4",
+          "ply": 1,
           "equity": -0.22985312
         },
         {
           "move": "13/8 11/7",
+          "ply": 1,
           "equity": -0.23169218
         },
         {
           "move": "13/9 7/2",
+          "ply": 1,
           "equity": -0.23561361
         }
       ]

tests/reference/compare.py

@@ -210,6 +210,36 @@ def compare_move_analysis(report, cli, case):
         report.number(where, "equity_loss", expected["equity_loss"], actual["equity_loss"])
         same_label(report, where, "skill", expected["skill"], actual["skill"],
                    expected["equity_loss"], SKILL_THRESHOLDS)
+        compare_analysis_ranking(report, where, expected, actual)
+
+
+def compare_analysis_ranking(report, where, expected, actual):
+    """Classement de l'analyse : les dix premiers coups de gnubg (le moteur
+    n'en rend pas plus), au même niveau et à la même équité, à la tolérance
+    près ; le meilleur coup et le coup joué y ont exactement les évaluations
+    de best et played."""
+    engine = actual["ranking"]
+    reference = expected["ranking"][:10]
+    report.same(where, "taille du classement", len(reference), len(engine))
+    by_move = {m["move"]: m for m in engine}
+    for m in reference:
+        other = by_move.get(m["move"])
+        here = "%s classement %s" % (where, m["move"])
+        if other is None:
+            # Un coup à égalité avec le dixième peut changer de côté.
+            tied = abs(m["equity"] - reference[-1]["equity"]) <= report.tolerance
+            if not tied:
+                report.same(here, "présent", True, False)
+            continue
+        report.same(here, "ply", m["ply"], other["ply"])
+        report.number(here, "equity", m["equity"], other["equity"])
+    if engine:
+        report.same(where, "classement, meilleur coup", actual["best"], engine[0])
+    for m in engine:
+        if m["move"] == actual["played"]["move"]:
+            report.same(where, "classement, coup joué", actual["played"], m)
+            report.same(where, "classement, rang du coup joué", actual["rank"],
+                        engine.index(m) + 1)
 
 
 def compare_cube_analysis(report, cli, case):

tests/reference/generate.py

@@ -221,15 +221,25 @@ def set_analysis(ply):
 
 
 def analyse_game():
-    """Analyse la partie en cours ; renvoie ses enregistrements et ses
-    statistiques par joueur (« X », « O »). Le cache est vidé avant : les
+    """Analyse la partie en cours ; renvoie ses enregistrements, ses
+    statistiques par joueur (« X », « O ») et les informations du match. Le cache est vidé avant : les
     évaluations à 2 plis faites pour choisir un coup y laissent des
     résultats à 0 pli des réseaux d'élagage, que l'analyse à 0 pli
     reprendrait (voir analyse_move)."""
     gnubg.command("clear cache")
     gnubg.command("analyse game")
-    game = gnubg.match(analysis=1, verbose=1, statistics=1, boards=1)["games"][-1]
-    return game["game"], game["stats"]
+    match = gnubg.match(analysis=1, verbose=1, statistics=1, boards=1)
+    game = match["games"][-1]
+    return game["game"], game["stats"], match["match-info"]
+
+
+def move_plies(match_info, move):
+    """Niveau auquel gnubg a évalué un coup de l'analyse : gnubg.match ne
+    donne le réglage d'un coup (« evalcontext ») que s'il diffère du réglage
+    par défaut de la partie (« default-eval-context », celui du premier coup
+    évalué rencontré)."""
+    context = move.get("evalcontext", {})
+    return context.get("plies", match_info["default-eval-context"]["plies"])
 
 
 def last_record(records, action):
@@ -280,7 +290,7 @@ def analyse_move(case, ply):
     # vient de jouer est la position retournée.
     played_id = gnubg.positionid(swapped(gnubg.board()))
     set_analysis(ply)
-    records, stats = analyse_game()
+    records, stats, match_info = analyse_game()
     record = last_record(records, "move")
     analysis = record["analysis"]
     moves, index = analysis["moves"], analysis["imove"]
@@ -304,7 +314,10 @@ def analyse_move(case, ply):
         # comptée en positif.
         "equity_loss": f32(-stats[record["player"]]["moves"]["error-skill"]),
         "skill": SKILLS[analysis.get("skill")],
-        "ranking": [{"move": notation(m["move"]), "equity": f32(m["score"])} for m in kept],
+        # Avec le niveau de chaque coup : les coups écartés par les filtres
+        # gardent celui d'un niveau inférieur (voir README.md).
+        "ranking": [{"move": notation(m["move"]), "ply": move_plies(match_info, m),
+                     "equity": f32(m["score"])} for m in kept],
     }
     luck = {"value": f32(analysis["luck-value"]), "rating": LUCKS[analysis.get("luck")]}
     return level, luck
@@ -322,7 +335,7 @@ def analyse_cube(case, ply):
         # meilleur coup, l'analyse du videau portant sur la position avant.
         gnubg.command("set dice 2 1")
         gnubg.command("move " + best_move())
-        records, stats = analyse_game()
+        records, stats, _ = analyse_game()
         record = last_record(records, "move")
         analysed = "nd-cubeful-eq" in record["analysis"]
         skill = record["analysis"].get("cube-skill")
@@ -332,7 +345,7 @@ def analyse_cube(case, ply):
         # du double.
         gnubg.command("double")
         gnubg.command("drop" if action == "pass" else "take")
-        records, stats = analyse_game()
+        records, stats, _ = analyse_game()
         analysed = "nd-cubeful-eq" in last_record(records, "double").get("analysis", {})
         record = last_record(records, {"double": "double", "take": "take", "pass": "drop"}[action])
         skill = record.get("analysis", {}).get("skill")

tests/test_reference.sh

@@ -130,7 +130,8 @@ if .type == "move" then
 			and (.played_position_id | test("^[A-Za-z0-9+/]{14}$")) and (.played_equity | nombre)
 			and (.best_move | type) == "string" and (.best_equity | nombre)
 			and (.equity_loss | nombre) and .equity_loss <= 0 and (.skill | skill)
-			and (.ranking | length) >= ([.rank, ([.move_count, 10] | min)] | max))
+			and (.ranking | length) >= ([.rank, ([.move_count, 10] | min)] | max)
+			and all(.ranking[]; (.move | type) == "string" and (.ply | nombre) and (.equity | nombre)))
 	 then empty else "analyse de coup incomplète" end)
 elif .type == "cube" then
 	(if (.plies | keys) == ["0", "2"] and (.action | IN("no_double", "double", "take", "pass"))

web/app.css

@@ -412,10 +412,42 @@ button:disabled {
 }
 
 .icon-button.labelled {
+  position: relative;
   width: 60px;
   height: 52px;
 }
 
+/* Raccourci clavier d'un bouton, en petite touche (interaction.md) :
+ * seulement quand un clavier est détecté (classe keyboard, app.ts). */
+.shortcut {
+  display: none;
+}
+
+.keyboard .shortcut {
+  display: inline-block;
+  min-width: 1.6em;
+  padding: 0 4px;
+  font: inherit;
+  font-size: 13px;
+  font-weight: 500;
+  line-height: 18px;
+  text-align: center;
+  border: 1px solid currentColor;
+  border-radius: 4px;
+  opacity: 0.8;
+}
+
+/* Barre haute : la touche en coin, sans changer la taille du bouton. */
+.keyboard .icon-button.labelled .shortcut {
+  position: absolute;
+  top: 0;
+  right: 2px;
+  min-width: 0;
+  padding: 0 3px;
+  line-height: 15px;
+  background: var(--background);
+}
+
 .icon-button .label {
   font-size: 13px;
   line-height: 15px;
@@ -966,6 +998,13 @@ a.notation {
   font-variant-numeric: tabular-nums lining-nums;
 }
 
+/* Le plateau de la partie : le doigt y fait glisser les pions, il ne fait
+ * ni défiler ni zoomer la page (glisser-déposer, double toucher ; charte,
+ * 1i). Les autres plateaux (accueil, tutoriel, position) laissent défiler. */
+#board {
+  touch-action: none;
+}
+
 .board-frame { fill: var(--frame); }
 .board-bed { fill: var(--bed); }
 .board-bar { fill: var(--bar); }
@@ -996,8 +1035,8 @@ a.notation {
   stroke: var(--checker-computer-edge);
 }
 
-/* Filet intérieur des pions (bundle.css), prêt pour le jour où le plateau
- * le dessine. */
+/* Filet intérieur des pions (bundle.css), l'écho du logo : un cercle aux
+ * trois cinquièmes du rayon, dessiné avec chaque pion (board-view.ts). */
 .checker-ring {
   fill: none;
   stroke-width: 1.5;
@@ -1016,6 +1055,34 @@ a.notation {
   stroke-width: 6;
 }
 
+/* Glisser-déposer (charte, 1i) : le pion parti laisse un fantôme en
+ * pointillés ; le pion glissé, agrandi, passe devant tout. */
+.drag-origin .checker {
+  fill: none;
+  stroke: var(--highlight);
+  stroke-width: 2.5;
+  stroke-dasharray: 5 4;
+}
+
+.drag-origin .checker-ring,
+.drag-origin .checker-count {
+  display: none;
+}
+
+.drag-piece { pointer-events: none; }
+
+.checker.dragged {
+  stroke: var(--highlight);
+  stroke-width: 4;
+}
+
+/* Clavier : le pion ou la case d'arrivée choisis aux flèches. */
+.key-focus {
+  fill: none;
+  stroke: var(--focus);
+  stroke-width: 3;
+}
+
 /* Tailles des chiffres du plateau : attribut font-size, calculé par
  * geometry.ts (13 px au moins à l'écran). */
 .checker-count {