Prompt d'un coup : le classement de l'analyse, au niveau calculé

Le classement du conseil vient de l'analyse du coup joué (conseils en version 2) : mêmes équités que la feuille du maître et l'analyse. Le titre dit le niveau du meilleur coup ; une ligne plus basse le dit aussi. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 02:47:38 +01:00
parent 1d21ac15d2
commit 99294900a0
14 changed files with 216 additions and 48 deletions
@@ -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));
@@ -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"}`;
+}
@@ -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;
@@ -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
@@ -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}`;
    });
@@ -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,
@@ -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: {
@@ -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