Écran de progression (#/progression) : courbe du taux d'erreur, parties, exercices
La ligne de progression de l'accueil y mène. Les taux viennent des analyses rangées ; les parties non analysées le sont en arrière-plan. « Créer des exercices » ouvre le prompt du gabarit exercices, avec les thèmes des erreurs comptés sur les faits du moteur. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Pierre MARTIN
co-authored by
Claude Opus 5.5
Claude Opus 5.5
parent
0493858c1a
commit
fdbbff50ea
@@ -17,6 +17,7 @@ import {
|
||||
} from "../game/advice.js";
|
||||
import type { CubeAction, LuckRating } from "../game/engine.js";
|
||||
import type { GameSummary } from "./game-analysis.js";
|
||||
import type { ProgressionTrend } from "./progression.js";
|
||||
|
||||
/** Les gabarits, par clé de section (« coup.meilleur »…). */
|
||||
export type MasterPhrases = ReadonlyMap<string, readonly string[]>;
|
||||
@@ -103,6 +104,10 @@ export const PHRASE_KEYS: readonly string[] = [
|
||||
"bilan.des.contre",
|
||||
"bilan.des.tres-contre",
|
||||
"bilan.aucun-coup",
|
||||
"progression.baisse",
|
||||
"progression.hausse",
|
||||
"progression.stable",
|
||||
"progression.attente",
|
||||
];
|
||||
|
||||
const DICE_KEYS: Readonly<Record<LuckRating, string>> = {
|
||||
@@ -140,6 +145,26 @@ export function nothingToReview(phrases: MasterPhrases): string {
|
||||
return pick(phrases, "bilan.aucun-coup", "0");
|
||||
}
|
||||
|
||||
const TREND_KEYS: Readonly<Record<ProgressionTrend["kind"], string>> = {
|
||||
down: "progression.baisse",
|
||||
up: "progression.hausse",
|
||||
steady: "progression.stable",
|
||||
waiting: "progression.attente",
|
||||
};
|
||||
|
||||
/** La phrase de l'écran de progression (étape 1h) : la tendance du taux
|
||||
* d'erreur, en faits (nombre de parties, moyennes en millièmes). */
|
||||
export function progressionSentence(phrases: MasterPhrases, trend: ProgressionTrend): string {
|
||||
const template = pick(phrases, TREND_KEYS[trend.kind], "0");
|
||||
return trend.kind === "waiting"
|
||||
? template
|
||||
: fillIn(template, {
|
||||
parties: String(trend.games),
|
||||
debut: String(trend.from),
|
||||
fin: String(trend.to),
|
||||
});
|
||||
}
|
||||
|
||||
/** Ce que le maître dit d'un conseil du moteur. */
|
||||
export function masterWords(phrases: MasterPhrases, advice: Advice): MasterWords {
|
||||
return advice.kind === "move" ? moveWords(phrases, advice) : cubeWords(phrases, advice);
|
||||
|
||||
@@ -0,0 +1,122 @@
|
||||
// La progression du joueur (étape 1h ; charte, ecrans-etape-1.md, « 1h ») :
|
||||
// le taux d'erreur de chaque partie terminée, tel que le bilan le calcule
|
||||
// (summarizeAnalysis), sa courbe partie après partie et la tendance que dit
|
||||
// la phrase du maître. Fonctions pures, testées sous Node
|
||||
// (app/tests/progression.test.ts).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Rien n'est recalculé ici : le taux d'une partie vient des analyses
|
||||
// rangées dans son journal (1e). Une partie dont l'analyse n'est pas finie
|
||||
// n'a pas encore de taux ; l'application l'analyse en arrière-plan.
|
||||
|
||||
import type { Level } from "../game/engine.js";
|
||||
import type { GameJournal } from "../game/events.js";
|
||||
import type { GameResult } from "../game/state.js";
|
||||
import { type ErrorRate, readyForSummary, summarizeAnalysis } from "./game-analysis.js";
|
||||
|
||||
/** Les parties prises en compte au plus : les plus récentes. Au-delà, la
|
||||
* courbe devient illisible sur un téléphone, et il faudrait relire tous
|
||||
* les journaux à chaque visite. */
|
||||
export const PROGRESSION_MAX_GAMES = 20;
|
||||
|
||||
/** Parties analysées qu'il faut pour tracer la courbe (charte : « Votre
|
||||
* courbe apparaîtra après trois parties »). */
|
||||
export const CURVE_MIN_GAMES = 3;
|
||||
|
||||
/** Une partie terminée, telle que le stockage la donne. */
|
||||
export interface FinishedGame {
|
||||
readonly id: string;
|
||||
/** Début de la partie, en millisecondes depuis 1970. */
|
||||
readonly startedAt: number;
|
||||
/** Le niveau de l'ordinateur. */
|
||||
readonly level: Level;
|
||||
readonly result: GameResult | null;
|
||||
readonly journal: GameJournal;
|
||||
}
|
||||
|
||||
/** Une ligne de la progression : une partie terminée et son taux
|
||||
* d'erreur (null : analyse pas encore finie). */
|
||||
export interface ProgressionEntry {
|
||||
readonly id: string;
|
||||
readonly startedAt: number;
|
||||
readonly level: Level;
|
||||
readonly result: GameResult | null;
|
||||
readonly errorRate: ErrorRate | null;
|
||||
}
|
||||
|
||||
/** Les lignes de la progression, de la plus ancienne à la plus récente.
|
||||
* Le taux d'erreur est celui du bilan, sur les analyses déjà rangées. */
|
||||
export function progressionEntries(games: readonly FinishedGame[]): ProgressionEntry[] {
|
||||
return [...games]
|
||||
.sort((a, b) => a.startedAt - b.startedAt)
|
||||
.map((game) => ({
|
||||
id: game.id,
|
||||
startedAt: game.startedAt,
|
||||
level: game.level,
|
||||
result: game.result,
|
||||
errorRate: readyForSummary(game.journal)
|
||||
? summarizeAnalysis(game.journal).player.errorRate
|
||||
: null,
|
||||
}));
|
||||
}
|
||||
|
||||
/** Un point de la courbe : une partie analysée. */
|
||||
export interface ProgressionPoint {
|
||||
readonly id: string;
|
||||
/** Équité perdue par décision (ErrorRate.perDecision). */
|
||||
readonly perDecision: number;
|
||||
}
|
||||
|
||||
/** Les points de la courbe, de la plus ancienne partie analysée à la plus
|
||||
* récente. */
|
||||
export function progressionCurve(entries: readonly ProgressionEntry[]): ProgressionPoint[] {
|
||||
return entries.flatMap((entry) =>
|
||||
entry.errorRate === null
|
||||
? []
|
||||
: [{ id: entry.id, perDecision: entry.errorRate.perDecision }],
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Le taux d'erreur tel que l'écran l'écrit : en millièmes d'équité par
|
||||
* décision, arrondi (0,014 s'écrit 14), comme les « mEMG » de GNU
|
||||
* Backgammon. Le glossaire le dit (docs/glossaire/taux-d-erreur.md).
|
||||
*/
|
||||
export function errorRateMillis(perDecision: number): number {
|
||||
return Math.round(perDecision * 1000);
|
||||
}
|
||||
|
||||
/** Ce que dit la phrase de la progression. */
|
||||
export type ProgressionTrend =
|
||||
/** Moins de CURVE_MIN_GAMES parties analysées. */
|
||||
| { readonly kind: "waiting" }
|
||||
/** Le taux baisse, monte ou ne change pas : moyenne de la première
|
||||
* moitié des parties (from) et de la seconde (to), en millièmes. */
|
||||
| {
|
||||
readonly kind: "down" | "up" | "steady";
|
||||
readonly games: number;
|
||||
readonly from: number;
|
||||
readonly to: number;
|
||||
};
|
||||
|
||||
/**
|
||||
* La tendance de la courbe : la moyenne des taux de la plus ancienne moitié
|
||||
* des parties, comparée à celle de la plus récente (la partie du milieu,
|
||||
* quand leur nombre est impair, n'entre dans aucune). Les deux moyennes
|
||||
* sont arrondies en millièmes avant d'être comparées : la phrase ne dit
|
||||
* jamais « passé de 9 à 9 ».
|
||||
*/
|
||||
export function progressionTrend(points: readonly ProgressionPoint[]): ProgressionTrend {
|
||||
if (points.length < CURVE_MIN_GAMES) {
|
||||
return { kind: "waiting" };
|
||||
}
|
||||
const half = Math.floor(points.length / 2);
|
||||
const mean = (part: readonly ProgressionPoint[]) =>
|
||||
part.reduce((sum, p) => sum + p.perDecision, 0) / part.length;
|
||||
const from = errorRateMillis(mean(points.slice(0, half)));
|
||||
const to = errorRateMillis(mean(points.slice(points.length - half)));
|
||||
const kind = to < from ? "down" : to > from ? "up" : "steady";
|
||||
return { kind, games: points.length, from, to };
|
||||
}
|
||||
@@ -446,6 +446,42 @@ export async function exercisesPosition(
|
||||
return worst === undefined ? null : positionBefore(engine, worst.journal, worst.advice.eventId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Ce qui revient dans les imprécisions et erreurs de plusieurs parties,
|
||||
* compté sur les faits que le moteur donne de chaque coup (pions frappés,
|
||||
* points faits, lus sur les plateaux qu'il décode) : jamais une
|
||||
* explication stratégique. Une ligne par fait présent au moins une fois.
|
||||
*/
|
||||
export function mistakeThemes(mistakes: readonly { readonly advice: Advice }[]): string[] {
|
||||
const moves = mistakes.flatMap((m) => (m.advice.kind === "move" ? [m.advice] : []));
|
||||
const cubes = mistakes.length - moves.length;
|
||||
const times = (n: number) => `${n} fois`;
|
||||
const masterHits = moves.filter((a) => a.bestFacts.hits > 0 && a.playedFacts.hits === 0);
|
||||
const masterPoints = moves.filter((a) =>
|
||||
a.bestFacts.madePoints.some((p) => !a.playedFacts.madePoints.includes(p)),
|
||||
);
|
||||
const playerHits = moves.filter((a) => a.playedFacts.hits > 0 && a.bestFacts.hits === 0);
|
||||
const lines = [
|
||||
`- ${plural(moves.length, "coup", "coups")} et ${plural(cubes, "décision de videau", "décisions de videau")}`,
|
||||
];
|
||||
if (masterHits.length > 0) {
|
||||
lines.push(
|
||||
`- ${times(masterHits.length)}, le coup de GNU Backgammon frappait un pion et le mien non`,
|
||||
);
|
||||
}
|
||||
if (masterPoints.length > 0) {
|
||||
lines.push(
|
||||
`- ${times(masterPoints.length)}, le coup de GNU Backgammon faisait un point que le mien ne faisait pas`,
|
||||
);
|
||||
}
|
||||
if (playerHits.length > 0) {
|
||||
lines.push(
|
||||
`- ${times(playerHits.length)}, mon coup frappait un pion et celui de GNU Backgammon non`,
|
||||
);
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
/** Ce que demande le prompt des exercices. */
|
||||
export interface ExercisesPromptData {
|
||||
/** Les parties analysées, de la plus ancienne à la plus récente. */
|
||||
@@ -484,6 +520,7 @@ export function exercisesPrompt(
|
||||
niveau_eval: plyText(worst.advice.ply),
|
||||
parties: String(data.journals.length),
|
||||
erreurs: listed.join("\n"),
|
||||
themes: mistakeThemes(mistakes).join("\n"),
|
||||
position_titre: `La plus coûteuse (partie ${worst.game}, coup ${worst.turn}) : la position avant ma décision`,
|
||||
});
|
||||
}
|
||||
|
||||
+2
-1
@@ -18,7 +18,7 @@ import {
|
||||
tutorialBoard,
|
||||
} from "./domain/learning/tutorial.js";
|
||||
import { positionBefore } from "./domain/prompts/position.js";
|
||||
import { conceptExample, summaryPosition } from "./domain/prompts/prompts.js";
|
||||
import { conceptExample, exercisesPosition, summaryPosition } from "./domain/prompts/prompts.js";
|
||||
import { createWasmEngine } from "./engine/wasm-engine.js";
|
||||
import { type EngineWorker, startEngineWorker } from "./engine/worker-run.js";
|
||||
import { createGameSession } from "./storage/game-session.js";
|
||||
@@ -180,6 +180,7 @@ startApp({
|
||||
before: (journal, eventId) => positionBefore(engine, journal, eventId),
|
||||
summary: (journal) => summaryPosition(engine, journal),
|
||||
concept: (journal) => conceptExample(engine, journal, ANALYSIS_PLY),
|
||||
exercises: (journals) => exercisesPosition(engine, journals),
|
||||
},
|
||||
startUpdates: (onAvailable) =>
|
||||
startUpdates(new URL("../sw.js", import.meta.url), worker.ready, onAvailable),
|
||||
|
||||
+174
-16
@@ -34,6 +34,11 @@ import {
|
||||
masterWords,
|
||||
parsePhrases,
|
||||
} from "../domain/analysis/phrases.js";
|
||||
import {
|
||||
type FinishedGame,
|
||||
PROGRESSION_MAX_GAMES,
|
||||
progressionEntries,
|
||||
} from "../domain/analysis/progression.js";
|
||||
import type { Advice } from "../domain/game/advice.js";
|
||||
import type { Cube } from "../domain/game/cube.js";
|
||||
import type { MoveNotation } from "../domain/game/engine.js";
|
||||
@@ -99,6 +104,7 @@ import { MATCH_TEXTS } from "./match-texts.js";
|
||||
import { replacingLink, startNavigation } from "./navigation.js";
|
||||
import { createNewGameView } from "./new-game-view.js";
|
||||
import { showWithNotation } from "./notation.js";
|
||||
import { createProgressionView } from "./progression-view.js";
|
||||
import { createPromptSource, type PromptsAccess } from "./prompt-source.js";
|
||||
import { createReviewRunner, type RunAnalysis } from "./review-runner.js";
|
||||
import {
|
||||
@@ -282,6 +288,7 @@ export function startApp(options: AppOptions): void {
|
||||
summaryVeil: byId("summary-veil"),
|
||||
promptVeil: byId("prompt-veil"),
|
||||
analysis: byId("analysis"),
|
||||
progression: byId("progression"),
|
||||
menuAdvice: byId<HTMLButtonElement>("menu-advice"),
|
||||
prompt: byId("prompt"),
|
||||
strips: { computer: stripOf("strip-computer"), player: stripOf("strip-player") },
|
||||
@@ -1467,6 +1474,18 @@ export function startApp(options: AppOptions): void {
|
||||
}
|
||||
case "glossary":
|
||||
return promptSource.concept(route.term ?? "", game?.journal ?? null);
|
||||
case "progression": {
|
||||
// Les parties analysées de l'écran, de la plus ancienne à la
|
||||
// plus récente : rien n'est analysé pour le prompt.
|
||||
const games = progressionGames ?? (await loadProgression());
|
||||
const journals = [...games]
|
||||
.sort((a, b) => a.startedAt - b.startedAt)
|
||||
.map((g) => g.journal)
|
||||
.filter((journal) => readyForSummary(journal));
|
||||
return journals.length === 0
|
||||
? { message: ASK_AI_TEXTS.noAnalysedGame }
|
||||
: promptSource.exercises(journals);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1504,20 +1523,142 @@ export function startApp(options: AppOptions): void {
|
||||
if (missingAnalyses(journal).length === 0) {
|
||||
return;
|
||||
}
|
||||
reviewRunner.start(id, journal, (analysed) => {
|
||||
const live = liveGame(id);
|
||||
if (live !== null) {
|
||||
live.recordAnalyses(analysed);
|
||||
save();
|
||||
} else {
|
||||
options.games.saveAnalyses(id, analysed);
|
||||
}
|
||||
if (reviewed?.id === id) {
|
||||
reviewed = { ...reviewed, journal: live?.journal ?? analysed };
|
||||
}
|
||||
showReview(id, false);
|
||||
render();
|
||||
});
|
||||
reviewRunner.start(
|
||||
id,
|
||||
journal,
|
||||
(analysed) => {
|
||||
const live = liveGame(id);
|
||||
if (live !== null) {
|
||||
live.recordAnalyses(analysed);
|
||||
save();
|
||||
} else {
|
||||
options.games.saveAnalyses(id, analysed);
|
||||
}
|
||||
if (reviewed?.id === id) {
|
||||
reviewed = { ...reviewed, journal: live?.journal ?? analysed };
|
||||
}
|
||||
progressionAnalysed(id, live?.journal ?? analysed);
|
||||
showReview(id, false);
|
||||
render();
|
||||
},
|
||||
// L'écran de progression attend peut-être cette analyse pour
|
||||
// lancer celle de la partie suivante.
|
||||
() => reviewProgression(),
|
||||
);
|
||||
}
|
||||
|
||||
// ------------------------------------------------ Progression (1h)
|
||||
|
||||
// L'écran #/progression : les parties terminées (les plus récentes),
|
||||
// relues à chaque visite, avec leurs analyses rangées. Celles qui n'en
|
||||
// ont pas encore sont analysées en arrière-plan, une à une, la plus
|
||||
// récente d'abord ; rien n'est recalculé pour les autres.
|
||||
const progressionView = createProgressionView({
|
||||
section: ui.progression,
|
||||
back: (link) => leavingLink(link, (route) => route.screen === "progression"),
|
||||
});
|
||||
let progressionGames: FinishedGame[] | null = null;
|
||||
// Chaque lecture a son numéro : une lecture dépassée n'est pas dessinée.
|
||||
let progressionRequest = 0;
|
||||
// Les parties dont l'analyse a été lancée depuis l'ouverture de l'écran.
|
||||
const progressionTried = new Set<string>();
|
||||
|
||||
/** Les parties terminées les plus récentes, avec leur journal (celui
|
||||
* de la partie à l'écran, s'il s'agit d'elle). */
|
||||
async function loadProgression(): Promise<FinishedGame[]> {
|
||||
const list = await options.games.list();
|
||||
const over = list
|
||||
.filter((summary) => summary.status === "over")
|
||||
.sort((a, b) => b.startedAt - a.startedAt)
|
||||
.slice(0, PROGRESSION_MAX_GAMES);
|
||||
const games = await Promise.all(
|
||||
over.map(async (summary) => {
|
||||
const journal =
|
||||
liveGame(summary.id)?.journal ?? (await options.games.journal(summary.id));
|
||||
return journal === null
|
||||
? null
|
||||
: {
|
||||
id: summary.id,
|
||||
startedAt: summary.startedAt,
|
||||
level: summary.level,
|
||||
result: summary.result,
|
||||
journal,
|
||||
};
|
||||
}),
|
||||
);
|
||||
return games.filter((g): g is FinishedGame => g !== null);
|
||||
}
|
||||
|
||||
/** Ouvre l'écran : ce qui est déjà lu, puis les parties relues. */
|
||||
function showProgression(): void {
|
||||
const request = ++progressionRequest;
|
||||
progressionTried.clear();
|
||||
renderProgression();
|
||||
options.engineReady
|
||||
.then(() => loadProgression())
|
||||
.then(
|
||||
(games) => {
|
||||
if (request !== progressionRequest) {
|
||||
return;
|
||||
}
|
||||
progressionGames = games;
|
||||
renderProgression();
|
||||
reviewProgression();
|
||||
},
|
||||
() => {
|
||||
if (request === progressionRequest && progressionGames === null) {
|
||||
progressionView.render(null, true);
|
||||
}
|
||||
},
|
||||
);
|
||||
if (phrases === null) {
|
||||
phrasesLoading.then(
|
||||
() => renderProgression(),
|
||||
() => undefined,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function renderProgression(): void {
|
||||
if (navigation.route.screen !== "progression") {
|
||||
return;
|
||||
}
|
||||
progressionView.render(
|
||||
progressionGames === null
|
||||
? null
|
||||
: { entries: progressionEntries(progressionGames), phrases },
|
||||
);
|
||||
}
|
||||
|
||||
/** Une analyse rangée : la partie, si l'écran la montre, se met à
|
||||
* jour. */
|
||||
function progressionAnalysed(id: string, journal: GameJournal): void {
|
||||
if (progressionGames?.some((g) => g.id === id)) {
|
||||
progressionGames = progressionGames.map((g) => (g.id === id ? { ...g, journal } : g));
|
||||
renderProgression();
|
||||
}
|
||||
}
|
||||
|
||||
/** Lance l'analyse de la prochaine partie de l'écran qui n'est pas
|
||||
* analysée (rien si une analyse tourne déjà : à sa fin, elle rappelle
|
||||
* cette fonction). */
|
||||
function reviewProgression(): void {
|
||||
if (
|
||||
navigation.route.screen !== "progression" ||
|
||||
progressionGames === null ||
|
||||
reviewRunner.running !== null
|
||||
) {
|
||||
return;
|
||||
}
|
||||
// Une partie dont l'analyse a échoué n'est pas relancée sans fin :
|
||||
// une fois par visite de l'écran.
|
||||
const next = progressionGames.find(
|
||||
(g) => !progressionTried.has(g.id) && missingAnalyses(g.journal).length > 0,
|
||||
);
|
||||
if (next !== undefined) {
|
||||
progressionTried.add(next.id);
|
||||
review(next.id, next.journal);
|
||||
}
|
||||
}
|
||||
|
||||
/** L'analyse en cours d'une partie qui n'est ni regardée ni à l'écran
|
||||
@@ -1763,6 +1904,8 @@ export function startApp(options: AppOptions): void {
|
||||
navigation.leave((r) => r.screen === "lesson" || r.screen === "lessonEnd");
|
||||
} else if (route.screen === "lessons") {
|
||||
navigation.leave((r) => r.screen === "lessons");
|
||||
} else if (route.screen === "progression") {
|
||||
navigation.leave((r) => r.screen === "progression");
|
||||
}
|
||||
},
|
||||
};
|
||||
@@ -1924,8 +2067,17 @@ export function startApp(options: AppOptions): void {
|
||||
const lesson = below.screen === "lesson" || below.screen === "lessonEnd";
|
||||
const choosing = below.screen === "newGame";
|
||||
const analysing = below.screen === "analysis";
|
||||
const progression = below.screen === "progression";
|
||||
const page =
|
||||
help || position || home || tutorial || lessonList || lesson || choosing || analysing;
|
||||
help ||
|
||||
position ||
|
||||
home ||
|
||||
tutorial ||
|
||||
lessonList ||
|
||||
lesson ||
|
||||
choosing ||
|
||||
analysing ||
|
||||
progression;
|
||||
const wasPage = ui.game.hidden;
|
||||
const wasScreen = ui.root.dataset.screen;
|
||||
ui.game.hidden = page;
|
||||
@@ -1936,6 +2088,7 @@ export function startApp(options: AppOptions): void {
|
||||
ui.lessons.hidden = !lessonList;
|
||||
ui.lesson.hidden = !lesson;
|
||||
ui.analysis.hidden = !analysing;
|
||||
ui.progression.hidden = !progression;
|
||||
const opening = choosing && ui.newGameSection.hidden;
|
||||
ui.newGameSection.hidden = !choosing;
|
||||
ui.root.classList.toggle("page-open", page);
|
||||
@@ -1978,6 +2131,11 @@ export function startApp(options: AppOptions): void {
|
||||
if (home) {
|
||||
homeProgress = null;
|
||||
}
|
||||
// La progression se relit à chaque arrivée sur l'écran (pas en
|
||||
// ouvrant ou en fermant la feuille « Créer des exercices »).
|
||||
if (progression && wasScreen !== "progression") {
|
||||
showProgression();
|
||||
}
|
||||
|
||||
// La marche à suivre pour installer : une feuille, comme le menu.
|
||||
if (route.screen === "install" && ui.installVeil.hidden) {
|
||||
@@ -2038,7 +2196,7 @@ export function startApp(options: AppOptions): void {
|
||||
() => openReview(id),
|
||||
() => undefined,
|
||||
);
|
||||
} else {
|
||||
} else if (route.screen !== "progression") {
|
||||
stopForeignReview();
|
||||
}
|
||||
if (route.screen === "games") {
|
||||
|
||||
@@ -21,10 +21,15 @@ export const ASK_AI_TEXTS = {
|
||||
summary: "Bilan",
|
||||
analysis: "Analyse",
|
||||
glossary: "Glossaire",
|
||||
progression: "Progression",
|
||||
},
|
||||
failed: "Le prompt n'a pas pu être préparé.",
|
||||
noAdvice: "Pas de prompt pour cette décision : le maître ne l'a pas encore analysée.",
|
||||
notReady: "Le maître analyse encore la partie : le prompt sera prêt avec le bilan.",
|
||||
missingGame: "Cette partie n'est plus sur ce téléphone.",
|
||||
missingTerm: "Ce terme n'est pas dans le glossaire.",
|
||||
noAnalysedGame:
|
||||
"Pas encore d'exercices : le maître n'a analysé aucune partie terminée. Ils seront prêts avec la première.",
|
||||
noMistake:
|
||||
"Pas d'exercices à proposer : sur vos parties analysées, vous avez joué comme le maître.",
|
||||
} as const;
|
||||
|
||||
@@ -36,6 +36,7 @@ export const FEATURES = [
|
||||
"docs/scenarios/demander-a-une-ia.feature",
|
||||
"docs/scenarios/apprendre-les-regles.feature",
|
||||
"docs/scenarios/suivre-une-lecon.feature",
|
||||
"docs/scenarios/suivre-ma-progression.feature",
|
||||
"docs/scenarios/mes-parties.feature",
|
||||
"docs/scenarios/partager-une-position.feature",
|
||||
"docs/scenarios/regler-l-application.feature",
|
||||
|
||||
@@ -42,6 +42,8 @@ export const HOME_TEXTS = {
|
||||
rulesAgain: "Revoir",
|
||||
progress: (played: number, won: number) =>
|
||||
`${plural(played, "partie jouée", "parties jouées")} · ${plural(won, "gagnée", "gagnées")}`,
|
||||
/** La ligne de progression, lien vers l'écran de progression (1h). */
|
||||
progressLink: (line: string) => `Votre progression : ${line}`,
|
||||
footer: "Né à l'Atelier du Huit, à Cugnaux. Logiciel libre, sans publicité ni mise.",
|
||||
|
||||
// Installation
|
||||
|
||||
+10
-4
@@ -6,8 +6,8 @@
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// La progression détaillée (1h) n'existe pas encore : l'accueil n'affiche
|
||||
// que ce qui existe.
|
||||
// La ligne de progression résumée mène à l'écran de progression
|
||||
// (#/progression, étape 1h).
|
||||
|
||||
import type { SideBoards } from "../domain/game/game.js";
|
||||
import { boardModel, OPENING_BOARDS } from "./board-model.js";
|
||||
@@ -219,10 +219,14 @@ export function createHomeView(options: HomeViewOptions): HomeView {
|
||||
element(rulesText, "span", { className: "muted", text: HOME_TEXTS.rulesDetail });
|
||||
const rulesAction = element(rules, "span", { className: "pill" });
|
||||
|
||||
const progress = element(main, "p", {
|
||||
// La ligne de progression mène à l'écran de progression (1h).
|
||||
const progress = element(main, "a", {
|
||||
id: "home-progress",
|
||||
className: "caption home-progress",
|
||||
});
|
||||
progress.href = "#/progression";
|
||||
const progressText = element(progress, "span", { className: "home-progress-text" });
|
||||
progress.append(icon("chevron"));
|
||||
const footer = element(main, "footer", { className: "home-footer" });
|
||||
const footerSymbol = element(footer, "img");
|
||||
footerSymbol.src = "icons/symbole-couleur.svg";
|
||||
@@ -293,7 +297,9 @@ export function createHomeView(options: HomeViewOptions): HomeView {
|
||||
if (state.progress !== null && state.progress.played > 0) {
|
||||
parts.push(HOME_TEXTS.progress(state.progress.played, state.progress.won));
|
||||
}
|
||||
progress.textContent = parts.join(" · ");
|
||||
progressText.textContent = parts.join(" · ");
|
||||
progress.hidden = parts.length === 0;
|
||||
progress.setAttribute("aria-label", HOME_TEXTS.progressLink(parts.join(" · ")));
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
// Les textes de l'écran de progression (étape 1h ; ADR 0007, point 5). La
|
||||
// phrase de synthèse, elle, est une phrase du maître : elle vit dans
|
||||
// docs/maitre/phrases.md (sections progression.…, une seule source,
|
||||
// ADR 0008).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import type { GameResult } from "../domain/game/state.js";
|
||||
|
||||
const plural = (n: number, one: string, many: string) => `${n} ${n > 1 ? many : one}`;
|
||||
|
||||
const RESULT_KIND = {
|
||||
single: "partie simple",
|
||||
gammon: "gammon",
|
||||
backgammon: "backgammon",
|
||||
} as const;
|
||||
|
||||
export const PROGRESSION_TEXTS = {
|
||||
title: "Votre progression",
|
||||
back: "Retour",
|
||||
loading: "Lecture de vos parties…",
|
||||
failed: "Vos parties n'ont pas pu être lues.",
|
||||
/** Aucune partie terminée. */
|
||||
empty: "Aucune partie terminée pour l'instant : votre progression commencera avec la première.",
|
||||
newGame: "Nouvelle partie",
|
||||
curveTitle: "Votre taux d'erreur · plus bas, c'est mieux",
|
||||
curveLabel: (rates: readonly number[]) =>
|
||||
`Votre taux d'erreur, partie après partie, de la plus ancienne à la plus récente : ${rates.join(", ")}.`,
|
||||
whatIsIt: "Qu'est-ce que le taux d'erreur ?",
|
||||
analysing: (n: number) =>
|
||||
`Le maître analyse ${plural(n, "partie", "parties")} : ${n > 1 ? "elles apparaîtront" : "elle apparaîtra"} ici une fois ${n > 1 ? "analysées" : "analysée"}.`,
|
||||
exercises: "Créer des exercices",
|
||||
listTitle: "Vos parties",
|
||||
/** « Gagnée, gammon (2 points) ». */
|
||||
result: (result: GameResult | null) => {
|
||||
if (result === null) {
|
||||
return "Partie terminée";
|
||||
}
|
||||
const who = result.winner === "player" ? "Gagnée" : "Perdue";
|
||||
return `${who}, ${RESULT_KIND[result.kind]} (${plural(result.points, "point", "points")})`;
|
||||
},
|
||||
level: (name: string) => `contre ${name}`,
|
||||
rateLabel: "taux d'erreur",
|
||||
rateLoading: "en analyse",
|
||||
openSummary: (result: string, date: string) => `Bilan de la partie du ${date} : ${result}`,
|
||||
analysis: "Analyse",
|
||||
analysisLabel: (date: string) => `Analyse de la partie du ${date}`,
|
||||
/** La date d'une partie : « 3 nov. 2026 ». */
|
||||
date: (ms: number) => new Date(ms).toLocaleDateString("fr-FR", { dateStyle: "medium" }),
|
||||
} as const;
|
||||
@@ -0,0 +1,319 @@
|
||||
// L'écran de progression (#/progression, étape 1h ; charte,
|
||||
// ecrans-etape-1.md, « 1h ») : une phrase du maître, la courbe du taux
|
||||
// d'erreur partie après partie (SVG fait main), « Créer des exercices », et
|
||||
// la liste des parties terminées, chacune menant à son bilan et à son
|
||||
// analyse.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// La vue ne connaît ni le stockage ni le moteur : l'écran de jeu (app.ts)
|
||||
// lui passe les parties et leur taux, lus dans les analyses rangées
|
||||
// (domain/analysis/progression.ts), et la redessine quand une analyse en
|
||||
// arrière-plan se termine.
|
||||
|
||||
import type { MasterPhrases } from "../domain/analysis/phrases.js";
|
||||
import { progressionSentence } from "../domain/analysis/phrases.js";
|
||||
import {
|
||||
CURVE_MIN_GAMES,
|
||||
errorRateMillis,
|
||||
type ProgressionEntry,
|
||||
progressionCurve,
|
||||
progressionTrend,
|
||||
} from "../domain/analysis/progression.js";
|
||||
import { computerLevelOf } from "../domain/game/level.js";
|
||||
import { icon } from "./icons.js";
|
||||
import { MATCH_TEXTS } from "./match-texts.js";
|
||||
import { PROGRESSION_TEXTS } from "./progression-texts.js";
|
||||
import { routeHash } from "./router.js";
|
||||
|
||||
/** Ce que montre l'écran. */
|
||||
export interface ProgressionData {
|
||||
/** Les parties terminées, de la plus ancienne à la plus récente. */
|
||||
readonly entries: readonly ProgressionEntry[];
|
||||
/** Les phrases du maître (null : pas encore lues). */
|
||||
readonly phrases: MasterPhrases | null;
|
||||
}
|
||||
|
||||
export interface ProgressionViewOptions {
|
||||
readonly section: HTMLElement;
|
||||
/** Branche le lien « Retour » (il revient dans l'historique). */
|
||||
readonly back: (link: HTMLAnchorElement) => void;
|
||||
}
|
||||
|
||||
export interface ProgressionView {
|
||||
/** Dessine l'écran (null : les parties se lisent ; failed : échec). */
|
||||
render(data: ProgressionData | null, failed?: boolean): void;
|
||||
}
|
||||
|
||||
const SVG_NS = "http://www.w3.org/2000/svg";
|
||||
/** Hauteur de la courbe, et ses marges intérieures (étiquettes de l'axe à
|
||||
* gauche, valeurs au-dessus des points). */
|
||||
const CURVE_HEIGHT = 168;
|
||||
const PAD = { left: 34, right: 16, top: 24, bottom: 12 };
|
||||
/** Au-delà, les valeurs ne s'écrivent plus au-dessus des points. */
|
||||
const LABELLED_POINTS = 10;
|
||||
|
||||
function element<K extends keyof HTMLElementTagNameMap>(
|
||||
parent: HTMLElement,
|
||||
tag: K,
|
||||
options: { id?: string; className?: string; text?: string } = {},
|
||||
): HTMLElementTagNameMap[K] {
|
||||
const child = document.createElement(tag);
|
||||
if (options.id !== undefined) {
|
||||
child.id = options.id;
|
||||
}
|
||||
if (options.className !== undefined) {
|
||||
child.className = options.className;
|
||||
}
|
||||
if (options.text !== undefined) {
|
||||
child.textContent = options.text;
|
||||
}
|
||||
parent.append(child);
|
||||
return child;
|
||||
}
|
||||
|
||||
function svgElement<K extends keyof SVGElementTagNameMap>(
|
||||
parent: Element,
|
||||
tag: K,
|
||||
attributes: Record<string, string | number>,
|
||||
): SVGElementTagNameMap[K] {
|
||||
const child = document.createElementNS(SVG_NS, tag);
|
||||
for (const [name, value] of Object.entries(attributes)) {
|
||||
child.setAttribute(name, String(value));
|
||||
}
|
||||
parent.append(child);
|
||||
return child;
|
||||
}
|
||||
|
||||
/** Le nom du niveau de l'ordinateur d'une partie. */
|
||||
function levelName(entry: ProgressionEntry): string {
|
||||
const level = computerLevelOf(entry.level);
|
||||
return level === null ? entry.level : MATCH_TEXTS.levels[level].name;
|
||||
}
|
||||
|
||||
export function createProgressionView(options: ProgressionViewOptions): ProgressionView {
|
||||
const { section } = options;
|
||||
section.replaceChildren();
|
||||
const head = element(section, "div", { className: "analysis-head" });
|
||||
const back = element(head, "a", {
|
||||
id: "progression-back",
|
||||
className: "button secondary",
|
||||
text: PROGRESSION_TEXTS.back,
|
||||
});
|
||||
back.href = "#/accueil";
|
||||
options.back(back);
|
||||
element(head, "h2", {
|
||||
id: "progression-title",
|
||||
className: "analysis-title",
|
||||
text: PROGRESSION_TEXTS.title,
|
||||
});
|
||||
const summary = element(section, "p", {
|
||||
id: "progression-summary",
|
||||
className: "progression-summary",
|
||||
});
|
||||
summary.setAttribute("role", "status");
|
||||
const body = element(section, "div", { className: "progression-body" });
|
||||
// La courbe se redessine à la largeur de la page (rotation).
|
||||
let drawnCurve: (() => void) | null = null;
|
||||
window.addEventListener("resize", () => {
|
||||
if (!section.hidden) {
|
||||
drawnCurve?.();
|
||||
}
|
||||
});
|
||||
|
||||
// Ce qui est dessiné : chaque analyse rangée en arrière-plan redemande
|
||||
// l'écran, qui ne change que quand le taux d'une partie arrive.
|
||||
let drawn = "";
|
||||
|
||||
function render(data: ProgressionData | null, failed = false): void {
|
||||
const key = JSON.stringify(
|
||||
data === null
|
||||
? { failed }
|
||||
: {
|
||||
phrases: data.phrases !== null,
|
||||
entries: data.entries.map((e) => [
|
||||
e.id,
|
||||
e.result,
|
||||
e.level,
|
||||
e.errorRate?.perDecision ?? null,
|
||||
]),
|
||||
},
|
||||
);
|
||||
if (key === drawn) {
|
||||
return;
|
||||
}
|
||||
drawn = key;
|
||||
body.replaceChildren();
|
||||
drawnCurve = null;
|
||||
delete section.dataset.ready;
|
||||
if (data === null) {
|
||||
summary.textContent = failed ? PROGRESSION_TEXTS.failed : PROGRESSION_TEXTS.loading;
|
||||
return;
|
||||
}
|
||||
if (data.entries.length === 0) {
|
||||
summary.textContent = PROGRESSION_TEXTS.empty;
|
||||
const actions = element(body, "div", { className: "progression-actions" });
|
||||
const start = element(actions, "a", {
|
||||
id: "progression-new-game",
|
||||
className: "button",
|
||||
text: PROGRESSION_TEXTS.newGame,
|
||||
});
|
||||
start.href = routeHash({ screen: "newGame" });
|
||||
section.dataset.ready = "true";
|
||||
return;
|
||||
}
|
||||
const points = progressionCurve(data.entries);
|
||||
summary.textContent =
|
||||
data.phrases === null
|
||||
? ""
|
||||
: progressionSentence(data.phrases, progressionTrend(points));
|
||||
|
||||
if (points.length >= CURVE_MIN_GAMES) {
|
||||
const card = element(body, "section", {
|
||||
id: "progression-curve-card",
|
||||
className: "analysis-card",
|
||||
});
|
||||
element(card, "h3", { className: "overline", text: PROGRESSION_TEXTS.curveTitle });
|
||||
const svg = document.createElementNS(SVG_NS, "svg");
|
||||
svg.id = "progression-curve";
|
||||
svg.setAttribute("class", "progression-curve");
|
||||
svg.setAttribute("role", "img");
|
||||
svg.setAttribute(
|
||||
"aria-label",
|
||||
PROGRESSION_TEXTS.curveLabel(points.map((p) => errorRateMillis(p.perDecision))),
|
||||
);
|
||||
card.append(svg);
|
||||
const link = element(card, "a", {
|
||||
id: "progression-glossary",
|
||||
className: "link-button",
|
||||
text: PROGRESSION_TEXTS.whatIsIt,
|
||||
});
|
||||
link.href = routeHash({ screen: "glossary", term: "taux-d-erreur" });
|
||||
drawnCurve = () => drawCurve(svg, points);
|
||||
drawnCurve();
|
||||
}
|
||||
|
||||
const waiting = data.entries.filter((e) => e.errorRate === null).length;
|
||||
if (waiting > 0) {
|
||||
element(body, "p", {
|
||||
id: "progression-analysing",
|
||||
className: "muted",
|
||||
text: PROGRESSION_TEXTS.analysing(waiting),
|
||||
}).setAttribute("role", "status");
|
||||
}
|
||||
|
||||
// « Créer des exercices » : la feuille du prompt (1f), secondaire.
|
||||
if (points.length > 0) {
|
||||
const actions = element(body, "div", { className: "progression-actions" });
|
||||
const exercises = element(actions, "a", {
|
||||
id: "progression-exercises",
|
||||
className: "button secondary ask-ai",
|
||||
});
|
||||
exercises.href = routeHash({ screen: "progression", ai: true });
|
||||
exercises.append(icon("copy"), PROGRESSION_TEXTS.exercises);
|
||||
}
|
||||
|
||||
element(body, "h3", { className: "overline", text: PROGRESSION_TEXTS.listTitle });
|
||||
const list = element(body, "ol", { id: "progression-list", className: "progression-list" });
|
||||
// La plus récente d'abord, comme « Mes parties ».
|
||||
for (const entry of [...data.entries].reverse()) {
|
||||
list.append(item(entry));
|
||||
}
|
||||
section.dataset.ready = String(waiting === 0);
|
||||
}
|
||||
|
||||
function item(entry: ProgressionEntry): HTMLElement {
|
||||
const li = document.createElement("li");
|
||||
li.className = "progression-item";
|
||||
li.dataset.id = entry.id;
|
||||
const date = PROGRESSION_TEXTS.date(entry.startedAt);
|
||||
const result = PROGRESSION_TEXTS.result(entry.result);
|
||||
const game = element(li, "a", { className: "progression-game" });
|
||||
game.href = routeHash({ screen: "summary", game: entry.id });
|
||||
game.setAttribute("aria-label", PROGRESSION_TEXTS.openSummary(result, date));
|
||||
const text = element(game, "span", { className: "progression-text" });
|
||||
element(text, "strong", { text: result });
|
||||
element(text, "span", {
|
||||
className: "muted",
|
||||
text: `${date} · ${PROGRESSION_TEXTS.level(levelName(entry))}`,
|
||||
});
|
||||
const rate = element(game, "span", { className: "progression-rate" });
|
||||
if (entry.errorRate === null) {
|
||||
rate.classList.add("pending");
|
||||
rate.textContent = PROGRESSION_TEXTS.rateLoading;
|
||||
} else {
|
||||
rate.dataset.rate = String(entry.errorRate.perDecision);
|
||||
element(rate, "strong", { text: String(errorRateMillis(entry.errorRate.perDecision)) });
|
||||
element(rate, "span", { className: "caption", text: PROGRESSION_TEXTS.rateLabel });
|
||||
}
|
||||
const analysis = element(li, "a", {
|
||||
className: "button secondary progression-analysis",
|
||||
text: PROGRESSION_TEXTS.analysis,
|
||||
});
|
||||
analysis.href = routeHash({ screen: "analysis", game: entry.id, turn: null });
|
||||
analysis.setAttribute("aria-label", PROGRESSION_TEXTS.analysisLabel(date));
|
||||
return li;
|
||||
}
|
||||
|
||||
return { render };
|
||||
}
|
||||
|
||||
/** La courbe : un point par partie analysée, de gauche (la plus ancienne)
|
||||
* à droite ; l'axe va de 0 au plus haut taux, en millièmes ; le dernier
|
||||
* point en verdict-good (charte). */
|
||||
function drawCurve(
|
||||
svg: SVGSVGElement,
|
||||
points: readonly { readonly id: string; readonly perDecision: number }[],
|
||||
): void {
|
||||
const width = Math.round(svg.getBoundingClientRect().width || 360);
|
||||
const height = CURVE_HEIGHT;
|
||||
svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
|
||||
svg.replaceChildren();
|
||||
const millis = points.map((p) => errorRateMillis(p.perDecision));
|
||||
// Le haut de l'axe : le plus haut taux, arrondi à la dizaine au-dessus.
|
||||
const top = Math.max(10, Math.ceil(Math.max(...millis) / 10) * 10);
|
||||
const inner = width - PAD.left - PAD.right;
|
||||
const step = points.length > 1 ? inner / (points.length - 1) : 0;
|
||||
const x = (i: number) => PAD.left + i * step;
|
||||
const y = (value: number) => PAD.top + (1 - value / top) * (height - PAD.top - PAD.bottom);
|
||||
for (const level of [top, 0]) {
|
||||
svgElement(svg, "line", {
|
||||
x1: PAD.left,
|
||||
x2: width - PAD.right,
|
||||
y1: y(level),
|
||||
y2: y(level),
|
||||
class: "curve-axis",
|
||||
});
|
||||
const label = svgElement(svg, "text", {
|
||||
x: PAD.left - 6,
|
||||
y: y(level) + 4,
|
||||
class: "curve-label",
|
||||
"text-anchor": "end",
|
||||
});
|
||||
label.textContent = String(level);
|
||||
}
|
||||
const line = points.map((p, i) => `${x(i)},${y(p.perDecision * 1000)}`).join(" ");
|
||||
svgElement(svg, "polyline", { points: line, class: "curve-line" });
|
||||
points.forEach((point, i) => {
|
||||
const last = i === points.length - 1;
|
||||
const dot = svgElement(svg, "circle", {
|
||||
cx: x(i),
|
||||
cy: y(point.perDecision * 1000),
|
||||
r: last ? 6 : 4,
|
||||
class: last ? "progression-dot last" : "progression-dot",
|
||||
"data-id": point.id,
|
||||
"data-rate": String(point.perDecision),
|
||||
});
|
||||
dot.setAttribute("aria-hidden", "true");
|
||||
if (points.length <= LABELLED_POINTS) {
|
||||
const value = svgElement(svg, "text", {
|
||||
x: x(i),
|
||||
y: y(point.perDecision * 1000) - 10,
|
||||
class: last ? "progression-value last" : "progression-value",
|
||||
"text-anchor": "middle",
|
||||
});
|
||||
value.textContent = String(millis[i]);
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -15,6 +15,7 @@ import {
|
||||
type ConceptExample,
|
||||
conceptPrompt,
|
||||
decisionPrompt,
|
||||
exercisesPrompt,
|
||||
summaryPrompt,
|
||||
} from "../domain/prompts/prompts.js";
|
||||
import {
|
||||
@@ -40,6 +41,9 @@ export interface PromptsAccess {
|
||||
readonly summary: (journal: GameJournal) => Promise<PromptPosition>;
|
||||
/** La position d'exemple d'un concept et son évaluation. */
|
||||
readonly concept: (journal: GameJournal | null) => Promise<ConceptExample>;
|
||||
/** La position de la plus coûteuse des erreurs de ces parties (null :
|
||||
* aucune imprécision ni erreur). */
|
||||
readonly exercises: (journals: readonly GameJournal[]) => Promise<PromptPosition | null>;
|
||||
}
|
||||
|
||||
export interface PromptSourceOptions {
|
||||
@@ -56,6 +60,9 @@ export interface PromptSource {
|
||||
summary(journal: GameJournal): Promise<PromptResult>;
|
||||
/** Le prompt d'un terme du glossaire (nom de sa fiche, sans .md). */
|
||||
concept(term: string, journal: GameJournal | null): Promise<PromptResult>;
|
||||
/** Le prompt « Créer des exercices » (progression, étape 1h), sur les
|
||||
* parties analysées, de la plus ancienne à la plus récente. */
|
||||
exercises(journals: readonly GameJournal[]): Promise<PromptResult>;
|
||||
}
|
||||
|
||||
async function fetchText(url: string): Promise<string> {
|
||||
@@ -109,6 +116,17 @@ export function createPromptSource(options: PromptSourceOptions): PromptSource {
|
||||
]);
|
||||
return { text: summaryPrompt(all, phrases, { journal, position }) };
|
||||
},
|
||||
async exercises(journals) {
|
||||
const [all, phrases, position] = await Promise.all([
|
||||
templates(),
|
||||
options.phrases(),
|
||||
options.access.exercises(journals),
|
||||
]);
|
||||
if (position === null) {
|
||||
return { message: ASK_AI_TEXTS.noMistake };
|
||||
}
|
||||
return { text: exercisesPrompt(all, phrases, { journals, position }) };
|
||||
},
|
||||
async concept(term, journal) {
|
||||
const [all, entry, example] = await Promise.all([
|
||||
templates(),
|
||||
|
||||
+14
-1
@@ -54,6 +54,10 @@ export type Route =
|
||||
readonly turn: number | null;
|
||||
readonly ai?: boolean;
|
||||
}
|
||||
/** #/progression : l'historique des parties et la courbe du taux
|
||||
* d'erreur (étape 1h) ; le prompt « Créer des exercices » :
|
||||
* #/progression/ia. */
|
||||
| { readonly screen: "progression"; readonly ai?: boolean }
|
||||
/** #/menu. */
|
||||
| { readonly screen: "menu" }
|
||||
/** #/nouvelle-partie : le choix de la partie (type, niveau, conseil). */
|
||||
@@ -130,6 +134,12 @@ export function parseRoute(hash: string): Route {
|
||||
return name === null ? { screen: "about" } : unknown;
|
||||
case "menu":
|
||||
return name === null ? { screen: "menu" } : unknown;
|
||||
case "progression":
|
||||
return name === null
|
||||
? { screen: "progression" }
|
||||
: name === "ia"
|
||||
? { screen: "progression", ai: true }
|
||||
: unknown;
|
||||
case "nouvelle-partie":
|
||||
return name === null ? { screen: "newGame" } : unknown;
|
||||
case "explication":
|
||||
@@ -146,7 +156,7 @@ export function parseRoute(hash: string): Route {
|
||||
/** Les écrans qui ont une feuille de prompt pour une IA. */
|
||||
export type AiRoute = Extract<
|
||||
Route,
|
||||
{ screen: "explanation" | "summary" | "analysis" | "glossary" }
|
||||
{ screen: "explanation" | "summary" | "analysis" | "glossary" | "progression" }
|
||||
>;
|
||||
|
||||
/** L'écran, avec sa feuille de prompt ouverte (null : écran sans prompt). */
|
||||
@@ -155,6 +165,7 @@ function aiRoute(route: Route): AiRoute | null {
|
||||
case "explanation":
|
||||
case "summary":
|
||||
case "analysis":
|
||||
case "progression":
|
||||
return route.ai === true ? null : { ...route, ai: true };
|
||||
case "glossary":
|
||||
return route.term === null || route.ai === true ? null : { ...route, ai: true };
|
||||
@@ -303,6 +314,8 @@ function screenHash(route: Route): string {
|
||||
return route.turn === null
|
||||
? `#/parties/${route.game}/analyse`
|
||||
: `#/parties/${route.game}/analyse/${route.turn}`;
|
||||
case "progression":
|
||||
return "#/progression";
|
||||
case "menu":
|
||||
return "#/menu";
|
||||
case "newGame":
|
||||
|
||||
@@ -225,6 +225,9 @@ export function createSummaryView(options: SummaryViewOptions): SummaryView {
|
||||
const play = element(box, "div", { id: "gauge-play", className: "gauge" });
|
||||
play.setAttribute("aria-label", REVIEW_TEXTS.playGauge(levelName));
|
||||
play.setAttribute("role", "img");
|
||||
// Le taux d'erreur du bilan, que la courbe de la progression (1h)
|
||||
// reprend tel quel (vérifié par tests/browser/progression.mjs).
|
||||
play.dataset.errorRate = String(summary.player.errorRate.perDecision);
|
||||
element(play, "span", { className: "gauge-name", text: REVIEW_TEXTS.yourPlay });
|
||||
const track = element(play, "span", { className: "gauge-track" });
|
||||
element(track, "span", {
|
||||
|
||||
@@ -0,0 +1,245 @@
|
||||
// Tests de la progression (étape 1h) : le taux d'erreur de chaque partie
|
||||
// terminée est celui du bilan, lu dans les analyses rangées sans rien
|
||||
// recalculer ; la courbe, sa tendance et la phrase du maître ; le prompt
|
||||
// « Créer des exercices » sur plusieurs parties (thèmes des erreurs, niveau
|
||||
// du joueur à partir de 20 décisions cumulées).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import assert from "node:assert/strict";
|
||||
import { readFileSync } from "node:fs";
|
||||
import { test } from "node:test";
|
||||
import {
|
||||
missingAnalyses,
|
||||
readyForSummary,
|
||||
runAnalysis,
|
||||
summarizeAnalysis,
|
||||
} from "../src/domain/analysis/game-analysis.js";
|
||||
import { PHRASE_KEYS, progressionSentence } from "../src/domain/analysis/phrases.js";
|
||||
import {
|
||||
CURVE_MIN_GAMES,
|
||||
errorRateMillis,
|
||||
type FinishedGame,
|
||||
progressionCurve,
|
||||
progressionEntries,
|
||||
progressionTrend,
|
||||
} from "../src/domain/analysis/progression.js";
|
||||
import type { Engine } from "../src/domain/game/engine.js";
|
||||
import type { GameJournal } from "../src/domain/game/events.js";
|
||||
import { currentLine } from "../src/domain/game/events.js";
|
||||
import { Game } from "../src/domain/game/game.js";
|
||||
import { replay } from "../src/domain/game/state.js";
|
||||
import {
|
||||
exercisesPosition,
|
||||
exercisesPrompt,
|
||||
LEVEL_MIN_DECISIONS,
|
||||
LEVEL_NAMES,
|
||||
mistakeThemes,
|
||||
} from "../src/domain/prompts/prompts.js";
|
||||
import { PROMPT_FILES, parsePromptTemplate } from "../src/domain/prompts/templates.js";
|
||||
import { parseRoute, routeHash } from "../src/ui/router.js";
|
||||
import { loadPhrases } from "./support/advice.js";
|
||||
import { loadNodeEngine } from "./support/node-engine.js";
|
||||
import { playToTheEnd, seededDice } from "./support/play.js";
|
||||
|
||||
const root = new URL("../../../", import.meta.url);
|
||||
const phrases = loadPhrases();
|
||||
const point = (id: string, perDecision: number) => ({ id, perDecision });
|
||||
|
||||
async function analyseAll(engine: Engine, journal: GameJournal): Promise<GameJournal> {
|
||||
let current = journal;
|
||||
for (let i = 0; i < 500; i++) {
|
||||
const next = missingAnalyses(current)[0];
|
||||
if (next === undefined) {
|
||||
return current;
|
||||
}
|
||||
current = await runAnalysis(engine, current, next);
|
||||
}
|
||||
throw new Error("l'analyse ne finit pas");
|
||||
}
|
||||
|
||||
/** Une course courte jouée jusqu'au bout (le joueur prend le choice-ième
|
||||
* coup légal), non analysée. */
|
||||
async function race(engine: Engine, seed: number, choice: number): Promise<GameJournal> {
|
||||
const game = Game.start(engine, {
|
||||
setup: { position: "trsXAADs7mwAAA", firstTurn: "player" },
|
||||
level: "intermediate",
|
||||
dice: seededDice(seed),
|
||||
});
|
||||
await playToTheEnd(game, engine, choice);
|
||||
return game.journal;
|
||||
}
|
||||
|
||||
function finished(id: string, startedAt: number, journal: GameJournal): FinishedGame {
|
||||
return {
|
||||
id,
|
||||
startedAt,
|
||||
level: "intermediate",
|
||||
result: replay(currentLine(journal)).result,
|
||||
journal,
|
||||
};
|
||||
}
|
||||
|
||||
test("l'adresse #/progression et celle de « Créer des exercices »", () => {
|
||||
assert.deepEqual(parseRoute("#/progression"), { screen: "progression" });
|
||||
assert.equal(routeHash({ screen: "progression", ai: true }), "#/progression/ia");
|
||||
});
|
||||
|
||||
test("le taux d'erreur s'écrit en millièmes, comme les mEMG de GNU Backgammon", () => {
|
||||
assert.equal(errorRateMillis(0.0142), 14);
|
||||
assert.equal(errorRateMillis(0.0075), 8);
|
||||
assert.equal(errorRateMillis(0), 0);
|
||||
});
|
||||
|
||||
test("la tendance : moyennes des deux moitiés, arrondies en millièmes", () => {
|
||||
assert.deepEqual(progressionTrend([]), { kind: "waiting" });
|
||||
assert.deepEqual(progressionTrend([point("a", 0.02), point("b", 0.01)]), { kind: "waiting" });
|
||||
assert.equal(CURVE_MIN_GAMES, 3);
|
||||
// Trois parties : la première contre la dernière, celle du milieu ne
|
||||
// compte pas.
|
||||
assert.deepEqual(progressionTrend([point("a", 0.014), point("b", 0.05), point("c", 0.007)]), {
|
||||
kind: "down",
|
||||
games: 3,
|
||||
from: 14,
|
||||
to: 7,
|
||||
});
|
||||
assert.deepEqual(
|
||||
progressionTrend([
|
||||
point("a", 0.01),
|
||||
point("b", 0.012),
|
||||
point("c", 0.02),
|
||||
point("d", 0.016),
|
||||
]),
|
||||
{ kind: "up", games: 4, from: 11, to: 18 },
|
||||
);
|
||||
// 0,0101 et 0,0104 s'écrivent tous deux 10 : stable.
|
||||
assert.equal(
|
||||
progressionTrend([point("a", 0.0101), point("b", 0.03), point("c", 0.0104)]).kind,
|
||||
"steady",
|
||||
);
|
||||
});
|
||||
|
||||
test("la phrase du maître : des faits, sans point d'exclamation, sous 140 caractères", () => {
|
||||
for (const key of ["progression.baisse", "progression.hausse", "progression.stable"]) {
|
||||
assert.ok(PHRASE_KEYS.includes(key), key);
|
||||
}
|
||||
assert.equal(
|
||||
progressionSentence(phrases, { kind: "down", games: 8, from: 14, to: 7 }),
|
||||
"Sur vos 8 dernières parties, vous faites moins d'erreurs : votre taux d'erreur est passé de 14 à 7.",
|
||||
);
|
||||
assert.equal(
|
||||
progressionSentence(phrases, { kind: "waiting" }),
|
||||
"Votre courbe apparaîtra après trois parties.",
|
||||
);
|
||||
for (const trend of [
|
||||
{ kind: "down", games: 20, from: 140, to: 70 },
|
||||
{ kind: "up", games: 20, from: 70, to: 140 },
|
||||
{ kind: "steady", games: 20, from: 12, to: 12 },
|
||||
] as const) {
|
||||
const sentence = progressionSentence(phrases, trend);
|
||||
assert.ok(sentence.length < 140, sentence);
|
||||
assert.ok(!sentence.includes("!"), sentence);
|
||||
assert.ok(sentence.includes(String(trend.to)), sentence);
|
||||
}
|
||||
assert.ok(
|
||||
progressionSentence(phrases, { kind: "up", games: 5, from: 7, to: 9 }).includes(
|
||||
"Les leçons sont là",
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
test("la progression lit le taux du bilan, sans rien recalculer ; une partie non analysée attend", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const raw = [await race(engine, 3, 3), await race(engine, 7, 2), await race(engine, 11, 1)];
|
||||
const analysed = await Promise.all(raw.map((j) => analyseAll(engine, j)));
|
||||
// Données dans le désordre : la progression les range par date.
|
||||
const games = [
|
||||
finished("c", 3000, analysed[2] as GameJournal),
|
||||
finished("a", 1000, analysed[0] as GameJournal),
|
||||
finished("b", 2000, analysed[1] as GameJournal),
|
||||
finished("d", 4000, raw[0] as GameJournal),
|
||||
];
|
||||
const entries = progressionEntries(games);
|
||||
assert.deepEqual(
|
||||
entries.map((e) => e.id),
|
||||
["a", "b", "c", "d"],
|
||||
);
|
||||
for (const [i, entry] of entries.slice(0, 3).entries()) {
|
||||
assert.deepEqual(
|
||||
entry.errorRate,
|
||||
summarizeAnalysis(analysed[i] as GameJournal).player.errorRate,
|
||||
);
|
||||
}
|
||||
assert.equal(readyForSummary(raw[0] as GameJournal), false);
|
||||
assert.equal(entries[3]?.errorRate, null, "partie non analysée : pas de taux");
|
||||
const curve = progressionCurve(entries);
|
||||
assert.deepEqual(
|
||||
curve.map((p) => p.id),
|
||||
["a", "b", "c"],
|
||||
);
|
||||
assert.equal(progressionTrend(curve).kind === "waiting", false);
|
||||
});
|
||||
|
||||
test("« Créer des exercices » : erreurs, thèmes comptés sur les faits du moteur, niveau à 20 décisions cumulées", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const template = parsePromptTemplate(
|
||||
readFileSync(new URL(`docs/prompts/${PROMPT_FILES.exercises}`, root), "utf8"),
|
||||
);
|
||||
const templates = { move: "", cube: "", summary: "", concept: "", exercises: template };
|
||||
const journals: GameJournal[] = [];
|
||||
for (const [seed, choice] of [
|
||||
[3, 3],
|
||||
[7, 2],
|
||||
[11, 1],
|
||||
[5, 4],
|
||||
[9, 3],
|
||||
] as const) {
|
||||
journals.push(await analyseAll(engine, await race(engine, seed, choice)));
|
||||
}
|
||||
const decisions = journals.map((j) => summarizeAnalysis(j).player.errorRate.decisions);
|
||||
assert.ok((decisions[0] ?? 0) < LEVEL_MIN_DECISIONS, `décisions : ${decisions.join()}`);
|
||||
let cumulated = 0;
|
||||
for (let n = 1; n <= journals.length; n++) {
|
||||
const some = journals.slice(0, n);
|
||||
cumulated += decisions[n - 1] ?? 0;
|
||||
const position = await exercisesPosition(engine, some);
|
||||
if (position === null) {
|
||||
continue;
|
||||
}
|
||||
const prompt = exercisesPrompt(templates, phrases, { journals: some, position });
|
||||
assert.ok(!/[{}]/.test(prompt), prompt);
|
||||
assert.ok(prompt.includes("Ce qui revient dans ces erreurs"), prompt);
|
||||
assert.match(prompt, /- \d+ coups? et \d+ décisions? de videau/);
|
||||
if (cumulated >= LEVEL_MIN_DECISIONS) {
|
||||
assert.match(prompt, /Je suis un joueur de niveau /);
|
||||
assert.ok(Object.values(LEVEL_NAMES).some((name) => prompt.includes(name)));
|
||||
} else {
|
||||
assert.ok(prompt.includes("Je débute au backgammon."), prompt);
|
||||
}
|
||||
}
|
||||
assert.ok(cumulated >= LEVEL_MIN_DECISIONS, `décisions cumulées : ${cumulated}`);
|
||||
});
|
||||
|
||||
test("les thèmes des erreurs : faits du moteur seulement, une ligne par fait présent", () => {
|
||||
const facts = (hits: number, madePoints: number[]) => ({ hits, madePoints });
|
||||
const move = (best: ReturnType<typeof facts>, played: ReturnType<typeof facts>) => ({
|
||||
advice: { kind: "move", bestFacts: best, playedFacts: played } as never,
|
||||
});
|
||||
const cube = { advice: { kind: "cube" } as never };
|
||||
assert.deepEqual(
|
||||
mistakeThemes([
|
||||
move(facts(1, []), facts(0, [])),
|
||||
move(facts(0, [5]), facts(0, [])),
|
||||
move(facts(0, []), facts(1, [])),
|
||||
cube,
|
||||
]),
|
||||
[
|
||||
"- 3 coups et 1 décision de videau",
|
||||
"- 1 fois, le coup de GNU Backgammon frappait un pion et le mien non",
|
||||
"- 1 fois, le coup de GNU Backgammon faisait un point que le mien ne faisait pas",
|
||||
"- 1 fois, mon coup frappait un pion et celui de GNU Backgammon non",
|
||||
],
|
||||
);
|
||||
assert.deepEqual(mistakeThemes([cube]), ["- 0 coup et 1 décision de videau"]);
|
||||
});
|
||||
@@ -46,6 +46,9 @@ const TABLE: [string, Route][] = [
|
||||
["#/parties/mh2k3x-a1b2c3/bilan", { screen: "summary", game: "mh2k3x-a1b2c3" }],
|
||||
["#/parties/mh2k3x-a1b2c3/analyse", { screen: "analysis", game: "mh2k3x-a1b2c3", turn: null }],
|
||||
["#/parties/mh2k3x-a1b2c3/analyse/7", { screen: "analysis", game: "mh2k3x-a1b2c3", turn: 7 }],
|
||||
// La progression (étape 1h) et son prompt « Créer des exercices ».
|
||||
["#/progression", { screen: "progression" }],
|
||||
["#/progression/ia", { screen: "progression", ai: true }],
|
||||
["#/menu", { screen: "menu" }],
|
||||
["#/nouvelle-partie", { screen: "newGame" }],
|
||||
["#/explication/12", { screen: "explanation", event: "12" }],
|
||||
@@ -127,6 +130,8 @@ test("une adresse inconnue est reconnue comme telle", () => {
|
||||
"#/menu/ia",
|
||||
"#/parties/ab/ia",
|
||||
"#/explication/12/ia/ia",
|
||||
"#/progression/x",
|
||||
"#/progression/ia/ia",
|
||||
]) {
|
||||
assert.equal(parseRoute(hash).screen, "unknown", hash);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,243 @@
|
||||
// Étapes du scénario docs/scenarios/suivre-ma-progression.feature (ADR
|
||||
// 0008) : des courses courtes jouées par le domaine sur le vrai moteur, avec
|
||||
// des dés reproductibles, enregistrées dans le stockage des parties (sur un
|
||||
// localStorage simulé), analysées par l'analyse en arrière-plan de
|
||||
// l'interface (review-runner.ts, sans DOM) ; l'écran de progression lit
|
||||
// ensuite le stockage comme app.ts (domain/analysis/progression.ts).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import assert from "node:assert/strict";
|
||||
import { readFileSync } from "node:fs";
|
||||
import { Before, BeforeAll, Given, setDefaultTimeout, Then, When } from "@cucumber/cucumber";
|
||||
import {
|
||||
readyForSummary,
|
||||
runAnalysis,
|
||||
summarizeAnalysis,
|
||||
} from "../../src/domain/analysis/game-analysis.js";
|
||||
import { progressionSentence } from "../../src/domain/analysis/phrases.js";
|
||||
import {
|
||||
CURVE_MIN_GAMES,
|
||||
type FinishedGame,
|
||||
type ProgressionEntry,
|
||||
progressionCurve,
|
||||
progressionEntries,
|
||||
progressionTrend,
|
||||
} from "../../src/domain/analysis/progression.js";
|
||||
import type { Engine } from "../../src/domain/game/engine.js";
|
||||
import type { GameJournal } from "../../src/domain/game/events.js";
|
||||
import { Game } from "../../src/domain/game/game.js";
|
||||
import { levelOf } from "../../src/domain/game/saved-game.js";
|
||||
import {
|
||||
exercisesPosition,
|
||||
exercisesPrompt,
|
||||
LEVEL_MIN_DECISIONS,
|
||||
} from "../../src/domain/prompts/prompts.js";
|
||||
import { PROMPT_FILES, parsePromptTemplate } from "../../src/domain/prompts/templates.js";
|
||||
import type { GameLibrary } from "../../src/storage/game-library.js";
|
||||
import { memoryStorage, openGameLibrary } from "../../src/storage/open-library.js";
|
||||
import { createReviewRunner } from "../../src/ui/review-runner.js";
|
||||
import { loadPhrases } from "../support/advice.js";
|
||||
import { loadNodeEngine } from "../support/node-engine.js";
|
||||
import { playToTheEnd, seededDice } from "../support/play.js";
|
||||
|
||||
setDefaultTimeout(120_000);
|
||||
|
||||
const root = new URL("../../../../", import.meta.url);
|
||||
const phrases = loadPhrases();
|
||||
/** Les courses jouées : graine des dés et choix du joueur. */
|
||||
const RACES = [
|
||||
[3, 3],
|
||||
[7, 2],
|
||||
[11, 1],
|
||||
] as const;
|
||||
|
||||
let engine: Engine;
|
||||
let library: GameLibrary;
|
||||
/** Les identifiants des parties enregistrées, dans l'ordre où elles ont
|
||||
* été jouées. */
|
||||
let ids: string[];
|
||||
let entries: ProgressionEntry[];
|
||||
/** Les analyses demandées au moteur, par partie. */
|
||||
let analyses: Map<string, number>;
|
||||
let prompt: string;
|
||||
let clock: number;
|
||||
|
||||
BeforeAll(async () => {
|
||||
engine = await loadNodeEngine();
|
||||
});
|
||||
|
||||
Before(async () => {
|
||||
clock = 1_000_000;
|
||||
library = (await openGameLibrary({ localStorage: memoryStorage() }, { now: () => clock }))
|
||||
.library;
|
||||
ids = [];
|
||||
analyses = new Map();
|
||||
});
|
||||
|
||||
/** Analyse en arrière-plan ce qui manque à la partie id, comme
|
||||
* l'application, et l'enregistre. */
|
||||
async function analyse(id: string): Promise<void> {
|
||||
const saved = await library.load(id);
|
||||
assert.ok(saved !== null);
|
||||
const runner = createReviewRunner((journal, task) => {
|
||||
analyses.set(id, (analyses.get(id) ?? 0) + 1);
|
||||
return runAnalysis(engine, journal, task);
|
||||
});
|
||||
let latest = saved.journal;
|
||||
await new Promise<void>((resolve) => {
|
||||
runner.start(id, saved.journal, (j) => (latest = j), resolve);
|
||||
});
|
||||
await library.saveAnalyses(id, latest, { level: levelOf(latest) });
|
||||
}
|
||||
|
||||
/** Ce que lit l'écran de progression : les parties terminées et leur
|
||||
* journal enregistré. */
|
||||
async function openProgression(): Promise<void> {
|
||||
const games: FinishedGame[] = [];
|
||||
for (const summary of await library.list()) {
|
||||
const saved = await library.load(summary.id);
|
||||
if (summary.status === "over" && saved !== null) {
|
||||
games.push({ ...summary, journal: saved.journal });
|
||||
}
|
||||
}
|
||||
entries = progressionEntries(games);
|
||||
}
|
||||
|
||||
Given("vous avez terminé {word} parties contre l'ordinateur", async (count: string) => {
|
||||
const n = { deux: 2, trois: 3 }[count] ?? Number(count);
|
||||
for (const [seed, choice] of RACES.slice(0, n)) {
|
||||
const game = Game.start(engine, {
|
||||
setup: { position: "trsXAADs7mwAAA", firstTurn: "player" },
|
||||
level: "intermediate",
|
||||
dice: seededDice(seed),
|
||||
});
|
||||
await playToTheEnd(game, engine, choice);
|
||||
clock += 60_000;
|
||||
const summary = await library.save(`partie-${seed}`, game.journal, {
|
||||
level: "intermediate",
|
||||
});
|
||||
assert.equal(summary.status, "over");
|
||||
ids.push(summary.id);
|
||||
}
|
||||
});
|
||||
|
||||
Given("le maître les a analysées", async () => {
|
||||
for (const id of ids) {
|
||||
await analyse(id);
|
||||
}
|
||||
});
|
||||
|
||||
Given("le maître n'a analysé que les deux premières", async () => {
|
||||
for (const id of ids.slice(0, 2)) {
|
||||
await analyse(id);
|
||||
}
|
||||
analyses.clear();
|
||||
});
|
||||
|
||||
When("vous ouvrez votre progression", async () => {
|
||||
await openProgression();
|
||||
});
|
||||
|
||||
Then("la courbe a trois points, chacun égal au taux d'erreur du bilan de sa partie", async () => {
|
||||
const curve = progressionCurve(entries);
|
||||
assert.equal(curve.length, 3);
|
||||
// De la plus ancienne partie à la plus récente.
|
||||
assert.deepEqual(
|
||||
curve.map((p) => p.id),
|
||||
ids,
|
||||
);
|
||||
for (const point of curve) {
|
||||
const saved = await library.load(point.id);
|
||||
assert.ok(saved !== null && readyForSummary(saved.journal));
|
||||
assert.equal(
|
||||
point.perDecision,
|
||||
summarizeAnalysis(saved.journal).player.errorRate.perDecision,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
Then("la phrase du maître compare vos premières parties aux dernières", () => {
|
||||
const trend = progressionTrend(progressionCurve(entries));
|
||||
assert.notEqual(trend.kind, "waiting");
|
||||
const sentence = progressionSentence(phrases, trend);
|
||||
assert.ok(sentence.startsWith("Sur vos 3 dernières parties"), sentence);
|
||||
assert.ok(!sentence.includes("!"), sentence);
|
||||
});
|
||||
|
||||
Then("il n'y a pas encore de courbe", () => {
|
||||
assert.equal(entries.length, 2);
|
||||
assert.ok(
|
||||
entries.every((e) => e.errorRate !== null),
|
||||
"les deux parties ont leur taux",
|
||||
);
|
||||
assert.ok(progressionCurve(entries).length < CURVE_MIN_GAMES);
|
||||
});
|
||||
|
||||
Then(/^la phrase de votre progression est « (.+) »$/, (sentence: string) => {
|
||||
assert.equal(
|
||||
progressionSentence(phrases, progressionTrend(progressionCurve(entries))),
|
||||
sentence,
|
||||
);
|
||||
});
|
||||
|
||||
Then("la troisième partie attend son analyse, sans taux d'erreur", () => {
|
||||
assert.equal(entries.length, 3);
|
||||
assert.equal(entries[2]?.id, ids[2]);
|
||||
assert.equal(entries[2]?.errorRate, null);
|
||||
assert.equal(progressionCurve(entries).length, 2);
|
||||
});
|
||||
|
||||
When("son analyse en arrière-plan est finie", async () => {
|
||||
// Comme l'écran : les parties qui en ont besoin, une à une.
|
||||
for (const entry of entries) {
|
||||
if (entry.errorRate === null) {
|
||||
await analyse(entry.id);
|
||||
}
|
||||
}
|
||||
await openProgression();
|
||||
});
|
||||
|
||||
Then("les deux premières parties n'ont pas été analysées de nouveau", () => {
|
||||
assert.deepEqual([...analyses.keys()], [ids[2]]);
|
||||
});
|
||||
|
||||
When("vous demandez des exercices", async () => {
|
||||
await openProgression();
|
||||
const journals: GameJournal[] = [];
|
||||
for (const entry of entries) {
|
||||
const saved = await library.load(entry.id);
|
||||
assert.ok(saved !== null);
|
||||
journals.push(saved.journal);
|
||||
}
|
||||
const position = await exercisesPosition(engine, journals);
|
||||
assert.ok(position !== null, "aucune erreur dans ces parties");
|
||||
const exercises = parsePromptTemplate(
|
||||
readFileSync(new URL(`docs/prompts/${PROMPT_FILES.exercises}`, root), "utf8"),
|
||||
);
|
||||
prompt = exercisesPrompt({ move: "", cube: "", summary: "", concept: "", exercises }, phrases, {
|
||||
journals,
|
||||
position,
|
||||
});
|
||||
});
|
||||
|
||||
Then("la question cite vos erreurs avec leur coût et ce qui y revient", () => {
|
||||
assert.match(prompt, /- Partie \d, coup \d+.*écart −\d,\d{3}/);
|
||||
assert.ok(prompt.includes("Ce qui revient dans ces erreurs"), prompt);
|
||||
assert.match(prompt, /- \d+ coups? et \d+ décisions? de videau/);
|
||||
assert.ok(prompt.includes("Voici mes 3 dernières parties"), prompt);
|
||||
});
|
||||
|
||||
Then(
|
||||
"elle ne donne votre niveau que si vos parties comptent au moins {int} décisions",
|
||||
(min: number) => {
|
||||
assert.equal(min, LEVEL_MIN_DECISIONS);
|
||||
const decisions = entries.reduce((sum, e) => sum + (e.errorRate?.decisions ?? 0), 0);
|
||||
if (decisions >= min) {
|
||||
assert.match(prompt, /Je suis un joueur de niveau /);
|
||||
} else {
|
||||
assert.ok(prompt.includes("Je débute au backgammon."), prompt);
|
||||
}
|
||||
},
|
||||
);
|
||||
Reference in New Issue
Block a user