Compare commits
52
Commits
+30
-1
@@ -21,6 +21,22 @@ Les contenus pédagogiques (leçons, textes) sont sous licence CC BY-SA 4.0.
|
||||
https://github.com/clavierhaus/gnubg-android ; son fichier
|
||||
`jni-bridge/src/stubs.c` a servi de repère pour isoler le cœur de gnubg.
|
||||
|
||||
## Identité visuelle
|
||||
|
||||
- **Alegreya Sans**, Copyright 2013 The Alegreya Sans Project Authors
|
||||
(Juan Pablo del Peral, Huerta Tipográfica), licence
|
||||
SIL Open Font License 1.1 — https://github.com/google/fonts/tree/main/ofl/alegreyasans
|
||||
Ses tracés (graisse Bold) composent le logotype, dans `docs/identite/logo/`.
|
||||
Cinq graisses (Regular, Italic, Medium, Bold, ExtraBold) sont embarquées
|
||||
dans l'application (`web/fonts/`, avec la licence `OFL.txt`), réduites aux
|
||||
caractères latins et converties en woff2 par fontTools (143 Ko en tout).
|
||||
- **Logo et icônes d'Ustagammon** (`docs/identite/logo/`), licence
|
||||
CC BY-SA 4.0 ; publiés dans `icons/` du site (favicon, icônes de la PWA,
|
||||
logo de la barre haute).
|
||||
- **fontTools** (MIT), utilisé par `docs/identite/generer-logo.py` pour
|
||||
convertir le texte du logotype en tracés, et pour produire les fichiers
|
||||
woff2 de la police ; avec **Brotli** (MIT), qui les compresse.
|
||||
|
||||
## Outils de développement
|
||||
|
||||
- **ShellCheck** (GPLv3), analyse des scripts shell, utilisé via Docker.
|
||||
@@ -41,7 +57,7 @@ Les contenus pédagogiques (leçons, textes) sont sous licence CC BY-SA 4.0.
|
||||
**Python 3** (licence PSF, compatible GPL), qui exécute le comparateur
|
||||
`tests/reference/compare.py`, et **jq** (licence MIT), qui lit les JSON
|
||||
dans `tests/test_reference.sh`. Aucun des deux n'est utilisé sur le PC.
|
||||
Le serveur HTTP de Python sert aussi la page de test (`make deploy-web`).
|
||||
Le serveur HTTP de Python sert aussi le site sur le réseau local (`make deploy`).
|
||||
- **Emscripten** (licence MIT et University of Illinois/NCSA), image Docker
|
||||
`emscripten/emsdk:3.1.64`, compile le moteur en WebAssembly
|
||||
(`make engine-wasm`). Le code JavaScript qu'il génère
|
||||
@@ -49,6 +65,19 @@ Les contenus pédagogiques (leçons, textes) sont sous licence CC BY-SA 4.0.
|
||||
inclus dans le moteur WebAssembly, licences compatibles GPLv3. L'image
|
||||
fournit aussi **Node.js** (MIT), qui rejoue la suite de contrat sur le
|
||||
moteur WebAssembly et lance `make bench`.
|
||||
- **Image `ustagammon/web`** (`docker/web/Dockerfile`), construite sur
|
||||
`node:22.11.0-alpine3.20` : **TypeScript** 6.0.3 (Apache-2.0), qui compile
|
||||
`app/` ; **@types/node** 22.20.5 (MIT), types de Node pour les tests ;
|
||||
**Biome** 2.5.15 (MIT ou Apache-2.0), lint et formatage ;
|
||||
**@cucumber/cucumber** 12.9.0 (MIT), qui exécute les scénarios de
|
||||
`docs/scenarios/` ; **dependency-cruiser** 18.6.0 (MIT), qui vérifie les
|
||||
règles d'architecture. Ces outils et leurs dépendances servent seulement à
|
||||
compiler et tester : rien n'est embarqué dans l'application.
|
||||
- **Playwright** 1.48.2 (Apache-2.0), image Docker
|
||||
`mcr.microsoft.com/playwright:v1.48.2-noble` (Chromium, Firefox, WebKit,
|
||||
sous leurs licences libres) et paquet npm `playwright`, installé dans
|
||||
`build/browser-tools/` : joue une partie dans des navigateurs sans écran
|
||||
(`make test-browser`). Outil de test seulement, hors de `make test`.
|
||||
|
||||
## Serveur de production
|
||||
|
||||
|
||||
@@ -20,19 +20,25 @@ REFERENCE_IMAGE := ustagammon/gnubg-reference:14b6798
|
||||
BUILD_C_IMAGE := ustagammon/build-c:2
|
||||
# Emscripten (compilation WebAssembly ; contient aussi Node et Python 3).
|
||||
WASM_IMAGE := emscripten/emsdk:3.1.64
|
||||
# Port de la page de test servie sur le réseau local (make deploy-web).
|
||||
# Outils de l'application web (docker/web/) : TypeScript, Biome, Cucumber,
|
||||
# dependency-cruiser. Changer l'étiquette à chaque modification du Dockerfile.
|
||||
WEB_IMAGE := ustagammon/web:1
|
||||
# Port du site servi sur le réseau local (make deploy).
|
||||
WEB_PORT := 8080
|
||||
# Serveur statique de production (deploy/Dockerfile) : même version ici.
|
||||
CADDY_IMAGE := caddy:2.8.4-alpine
|
||||
# Navigateurs sans écran pour make test-browser (Playwright, Apache-2.0).
|
||||
PLAYWRIGHT_IMAGE := mcr.microsoft.com/playwright:v1.48.2-noble
|
||||
|
||||
export SHELLCHECK_IMAGE GHERKIN_IMAGE BUILD_C_IMAGE WASM_IMAGE CADDY_IMAGE
|
||||
export SHELLCHECK_IMAGE GHERKIN_IMAGE BUILD_C_IMAGE WASM_IMAGE CADDY_IMAGE WEB_IMAGE PLAYWRIGHT_IMAGE
|
||||
|
||||
# Lance une commande dans la chaîne C, sous l'utilisateur courant pour que
|
||||
# build/ lui appartienne.
|
||||
DOCKER_C := docker run --rm --user "$$(id -u):$$(id -g)" -v "$(CURDIR):/src" -w /src $(BUILD_C_IMAGE)
|
||||
DOCKER_WASM := docker run --rm --user "$$(id -u):$$(id -g)" -e HOME=/tmp -v "$(CURDIR):/src" -w /src $(WASM_IMAGE)
|
||||
DOCKER_WEB := docker run --rm --user "$$(id -u):$$(id -g)" -v "$(CURDIR):/src" -w /src $(WEB_IMAGE)
|
||||
|
||||
.PHONY: help setup build engine engine-wasm bench test lint deploy deploy-web site package deploy-prod clean reference-image reference
|
||||
.PHONY: help setup build engine engine-wasm web bench test test-browser lint deploy deploy-web site package deploy-prod clean reference-image reference
|
||||
|
||||
help: ## Liste les commandes disponibles
|
||||
@echo "Ustagammon : commandes disponibles"
|
||||
@@ -52,9 +58,11 @@ setup: ## Installe la chaîne d'outils (images Docker) ; sans effet si déjà fa
|
||||
|| docker pull $(WASM_IMAGE)
|
||||
@docker image inspect $(CADDY_IMAGE) >/dev/null 2>&1 \
|
||||
|| docker pull $(CADDY_IMAGE)
|
||||
@docker image inspect $(WEB_IMAGE) >/dev/null 2>&1 \
|
||||
|| docker build -t $(WEB_IMAGE) docker/web
|
||||
@echo "Chaîne d'outils prête."
|
||||
|
||||
build: engine ## Compile le moteur (si nécessaire) puis l'application
|
||||
build: engine-wasm web ## Compile le moteur (si nécessaire) puis l'application
|
||||
|
||||
engine: ## Compile le moteur, ses données et build/engine-cli (dans Docker)
|
||||
@docker image inspect $(BUILD_C_IMAGE) >/dev/null 2>&1 \
|
||||
@@ -66,46 +74,77 @@ engine-wasm: engine ## Compile le moteur en WebAssembly dans build/wasm/ (dans D
|
||||
|| { echo "Emscripten absent : lancer d'abord make setup"; exit 1; }
|
||||
@$(DOCKER_WASM) make -f engine-wasm/wasm.mk -j2 --no-print-directory
|
||||
|
||||
# L'application est recompilée entièrement (quelques secondes) : build/web/
|
||||
# ne garde ainsi aucun fichier dont la source a disparu. Le package.json
|
||||
# indique à Node que les .js produits sont des modules ES.
|
||||
web: ## Compile l'application TypeScript (app/) dans build/web/ (dans Docker)
|
||||
@docker image inspect $(WEB_IMAGE) >/dev/null 2>&1 \
|
||||
|| { echo "Outils web absents : lancer d'abord make setup"; exit 1; }
|
||||
@rm -rf $(BUILD_DIR)/web
|
||||
@$(DOCKER_WEB) tsc -p app/tsconfig.json
|
||||
@cp app/package.json $(BUILD_DIR)/web/package.json
|
||||
|
||||
bench: engine-wasm ## Mesure le moteur WebAssembly sous Node, sur ce PC (rapport texte)
|
||||
@$(DOCKER_WASM) node engine-wasm/bench.mjs
|
||||
|
||||
test: ## Lance tous les tests
|
||||
@tests/run.sh
|
||||
|
||||
# Hors de make test : plusieurs minutes, et une image de 3 Go, récupérée ici
|
||||
# à la première utilisation plutôt que par make setup.
|
||||
test-browser: ## Joue une partie dans Chromium et Firefox sans écran (lent)
|
||||
@docker image inspect $(PLAYWRIGHT_IMAGE) >/dev/null 2>&1 || docker pull $(PLAYWRIGHT_IMAGE)
|
||||
@tests/browser.sh
|
||||
|
||||
lint: ## Vérifie le style et les erreurs courantes
|
||||
@tests/lint.sh
|
||||
|
||||
deploy: ## Installe l'application sur le téléphone (pas encore disponible)
|
||||
@echo "Pas encore disponible : le socle (PWA ou Android) sera choisi à la fin de l'étape 0."
|
||||
@echo "Page de test du moteur WebAssembly : make deploy-web"
|
||||
@exit 1
|
||||
|
||||
# Sert web/ à la racine et build/wasm/ sous /wasm/ avec le serveur HTTP de
|
||||
# Python (types MIME corrects, dont application/wasm). Les deux dossiers sont
|
||||
# montés en lecture seule puis copiés dans le conteneur au démarrage : relancer
|
||||
# après une modification.
|
||||
# L'adresse affichée est celle du PC sur l'interface de sa route par défaut,
|
||||
# c'est-à-dire sur le réseau local (Wi-Fi ou câble).
|
||||
deploy-web: engine-wasm ## Sert la page de test WebAssembly sur le réseau local (Ctrl+C pour arrêter)
|
||||
# Sert le site assemblé (build/site/, voir make site) avec le serveur HTTP de
|
||||
# Python. L'adresse affichée est celle du PC sur l'interface de sa route par
|
||||
# défaut, c'est-à-dire sur le réseau local (Wi-Fi ou câble). En http sur le
|
||||
# réseau local, le navigateur refuse le service worker : l'application
|
||||
# fonctionne, mais pas hors ligne (il faut https, comme en production).
|
||||
deploy: site ## Sert l'application sur le réseau local (Ctrl+C pour arrêter)
|
||||
@ip="$$(ip -4 route get 1.1.1.1 2>/dev/null | awk '{ for (i = 1; i < NF; i++) if ($$i == "src") print $$(i + 1) }')"; \
|
||||
echo "Page de test : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/"; \
|
||||
echo "Page de mesure : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/bench.html"; \
|
||||
echo "Application : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/"; \
|
||||
echo "Test du moteur : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/moteur/"; \
|
||||
echo "Page de mesure : http://$${ip:-ADRESSE-DU-PC}:$(WEB_PORT)/moteur/bench.html"; \
|
||||
echo "À ouvrir depuis le téléphone, sur le même Wi-Fi. Ctrl+C pour arrêter."
|
||||
@docker run --rm --init -p $(WEB_PORT):8080 \
|
||||
-v "$(CURDIR)/web:/web:ro" -v "$(CURDIR)/build/wasm:/wasm:ro" $(BUILD_C_IMAGE) \
|
||||
sh -c 'cp -r /web /tmp/site && cp -r /wasm /tmp/site/wasm \
|
||||
&& exec python3 -m http.server 8080 --directory /tmp/site'
|
||||
@docker run --rm --init -p $(WEB_PORT):8080 -v "$(CURDIR)/$(BUILD_DIR)/site:/site:ro" \
|
||||
$(BUILD_C_IMAGE) python3 -m http.server 8080 --directory /site
|
||||
|
||||
# Le site tel qu'il sera publié : web/ à la racine, le moteur sous wasm/, et
|
||||
# version.json (commit déployé). Reconstruit entièrement à chaque appel.
|
||||
site: engine-wasm ## Assemble le site publié dans build/site/
|
||||
deploy-web: deploy ## Comme make deploy (ancien nom, étape 0b)
|
||||
|
||||
# Fichiers de docs/identite/logo/ publiés dans icons/ (manifeste, favicon,
|
||||
# barre haute).
|
||||
SITE_ICONS := icone.svg icone-192.png icone-512.png icone-maskable-192.png icone-maskable-512.png \
|
||||
apple-touch-icon-180.png favicon.svg favicon-32.png \
|
||||
logo-horizontal-couleur.svg logo-horizontal-sombre.svg symbole-couleur.svg symbole-sombre.svg
|
||||
|
||||
# Le site tel qu'il sera publié, reconstruit entièrement à chaque appel :
|
||||
# - web/ à la racine : la page de l'application, son style, sa police, le
|
||||
# manifeste, le Web Worker du moteur, et les pages de test sous moteur/ ;
|
||||
# - sous icons/, le logo et les icônes de la charte, copiés depuis
|
||||
# docs/identite/logo/ (une seule source, ADR 0010) ;
|
||||
# - l'application compilée (build/web/src/) sous app/ ;
|
||||
# - le moteur sous wasm/ ;
|
||||
# - les copies du glossaire et des scénarios sous docs/, lues par l'aide de
|
||||
# l'application (ADR 0008 : jamais commitées ailleurs) ;
|
||||
# - version.json (commit publié) ;
|
||||
# - sw.js, complété par la liste de tous ces fichiers (scripts/service-worker.sh).
|
||||
site: engine-wasm web ## Assemble le site publié dans build/site/
|
||||
rm -rf $(BUILD_DIR)/site
|
||||
mkdir -p $(BUILD_DIR)/site/wasm
|
||||
mkdir -p $(BUILD_DIR)/site/wasm $(BUILD_DIR)/site/docs
|
||||
cp -r web/. $(BUILD_DIR)/site/
|
||||
mkdir -p $(BUILD_DIR)/site/icons
|
||||
cp $(addprefix docs/identite/logo/,$(SITE_ICONS)) $(BUILD_DIR)/site/icons/
|
||||
cp -r $(BUILD_DIR)/web/src $(BUILD_DIR)/site/app
|
||||
cp $(BUILD_DIR)/wasm/engine.mjs $(BUILD_DIR)/wasm/engine.wasm $(BUILD_DIR)/wasm/engine.data \
|
||||
$(BUILD_DIR)/wasm/positions.json $(BUILD_DIR)/site/wasm/
|
||||
cp -r docs/glossaire docs/scenarios $(BUILD_DIR)/site/docs/
|
||||
printf '{"commit": "%s", "dirty": %s}\n' "$$(git rev-parse HEAD)" \
|
||||
"$$(git diff --quiet HEAD && echo false || echo true)" > $(BUILD_DIR)/site/version.json
|
||||
scripts/service-worker.sh $(BUILD_DIR)/site
|
||||
|
||||
# L'archive envoyée à CapRover : captain-definition, Dockerfile, Caddyfile et
|
||||
# le site. CapRover construit l'image (une simple copie) sur le serveur.
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
// Règles d'architecture de l'application (ADR 0007, point 2 ; ADR 0009),
|
||||
// vérifiées par dependency-cruiser dans make test (tests/test_web.sh).
|
||||
// Les chemins sont relatifs au dossier app/.
|
||||
|
||||
/** @type {import('dependency-cruiser').IConfiguration} */
|
||||
module.exports = {
|
||||
forbidden: [
|
||||
{
|
||||
name: "domain-is-pure",
|
||||
comment:
|
||||
"Le domaine n'importe que le domaine : ni le moteur (src/engine), ni " +
|
||||
"l'interface (src/ui), ni Node, ni bibliothèque, ni code du navigateur. " +
|
||||
"Il décrit ce dont il a besoin (interface Engine) ; les adaptateurs " +
|
||||
"l'implémentent.",
|
||||
severity: "error",
|
||||
from: { path: "^src/domain/" },
|
||||
to: { pathNot: "^src/domain/" },
|
||||
},
|
||||
{
|
||||
name: "ui-does-not-call-engine",
|
||||
comment:
|
||||
"Aucun écran n'appelle le moteur directement : l'interface passe par le domaine.",
|
||||
severity: "error",
|
||||
from: { path: "^src/ui/" },
|
||||
to: { path: "^src/engine/" },
|
||||
},
|
||||
{
|
||||
name: "only-main-assembles",
|
||||
comment:
|
||||
"Seul le point d'entrée (src/main.ts) assemble l'application : hors de " +
|
||||
"leur propre dossier, le moteur (src/engine), le stockage (src/storage) " +
|
||||
"et l'interface (src/ui) ne sont importés que par lui, et par les tests.",
|
||||
severity: "error",
|
||||
// $1 : le dossier de l'importateur (correspondance de groupe).
|
||||
from: { path: "^src/([^/]+)/" },
|
||||
to: { path: "^src/(engine|storage|ui)/", pathNot: "^src/$1/" },
|
||||
},
|
||||
{
|
||||
name: "nothing-imports-main",
|
||||
comment: "Le point d'entrée n'est importé par personne.",
|
||||
severity: "error",
|
||||
from: {},
|
||||
to: { path: "^src/main\\.ts$" },
|
||||
},
|
||||
{
|
||||
name: "no-circular",
|
||||
comment: "Pas de dépendance circulaire.",
|
||||
severity: "error",
|
||||
from: {},
|
||||
to: { circular: true },
|
||||
},
|
||||
],
|
||||
options: {
|
||||
// Les imports de types comptent aussi : ils disparaissent à la
|
||||
// compilation, mais créent bien une dépendance dans le code source.
|
||||
tsPreCompilationDeps: true,
|
||||
// Résolution des imports comme TypeScript : « ./events.js » désigne
|
||||
// le fichier events.ts. Le tsconfig.json est celui du dossier courant.
|
||||
tsConfig: { fileName: "tsconfig.json" },
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"files": {
|
||||
"includes": ["**", "!**/node_modules"]
|
||||
},
|
||||
"formatter": {
|
||||
"indentStyle": "space",
|
||||
"indentWidth": 4,
|
||||
"lineWidth": 100
|
||||
},
|
||||
"linter": {
|
||||
"rules": {
|
||||
"preset": "recommended"
|
||||
}
|
||||
},
|
||||
"javascript": {
|
||||
"formatter": {
|
||||
"quoteStyle": "double"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"name": "ustagammon-app",
|
||||
"private": true,
|
||||
"license": "GPL-3.0-or-later",
|
||||
"type": "module"
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
// Le videau.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import type { Side } from "./side.js";
|
||||
|
||||
/**
|
||||
* Le videau : sa valeur (1, 2, 4…) et le camp qui le possède, seul à pouvoir
|
||||
* redoubler (null : au centre, les deux peuvent doubler).
|
||||
*
|
||||
* Glossaire : docs/glossaire/videau.md
|
||||
*/
|
||||
export interface Cube {
|
||||
readonly value: number;
|
||||
readonly owner: Side | null;
|
||||
}
|
||||
|
||||
export const CENTERED_CUBE: Cube = { value: 1, owner: null };
|
||||
@@ -0,0 +1,119 @@
|
||||
// Ce que le domaine demande au moteur (ADR 0007, point 2).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Le domaine définit cette interface ; un adaptateur par plateforme
|
||||
// l'implémente (src/engine/ pour le moteur WebAssembly). Toutes les règles du
|
||||
// jeu viennent d'ici : le domaine n'en réimplémente aucune.
|
||||
//
|
||||
// Les positions sont toujours vues du joueur au trait, celui qui joue ou
|
||||
// double. Les méthodes sont asynchrones : dans le navigateur, le moteur
|
||||
// calcule dans un Web Worker.
|
||||
|
||||
import type { HalfMove, PositionId } from "./position.js";
|
||||
import type { Roll } from "./roll.js";
|
||||
|
||||
/**
|
||||
* Le moteur de jeu : GNU Backgammon.
|
||||
*
|
||||
* Glossaire : docs/glossaire/moteur.md
|
||||
*/
|
||||
export interface Engine {
|
||||
/** Les coups légaux d'un jet (liste vide : le joueur ne peut pas jouer). */
|
||||
legalMoves(position: PositionId, roll: Roll): Promise<Move[]>;
|
||||
|
||||
/** Le meilleur coup au niveau ply, ou null si aucun coup n'est possible. */
|
||||
bestMove(position: PositionId, cube: EngineCube, roll: Roll, ply: Ply): Promise<Move | null>;
|
||||
|
||||
/** La décision de videau du joueur au trait, avant de lancer les dés. */
|
||||
cubeDecision(position: PositionId, cube: EngineCube, ply: Ply): Promise<CubeDecision>;
|
||||
|
||||
/** Où en est un coup saisi demi-coup par demi-coup. */
|
||||
checkHalfMoves(
|
||||
position: PositionId,
|
||||
roll: Roll,
|
||||
halfMoves: readonly HalfMove[],
|
||||
): Promise<HalfMovesCheck>;
|
||||
|
||||
/** Le plateau d'une position, et le résultat si la partie y est finie. */
|
||||
board(position: PositionId, cube: EngineCube): Promise<Board>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Niveau de réflexion du moteur, en plis : 0 (évaluation directe) à 4.
|
||||
*
|
||||
* Glossaire : docs/glossaire/pli.md
|
||||
*/
|
||||
export type Ply = number;
|
||||
|
||||
/** Le videau vu du joueur au trait. */
|
||||
export interface EngineCube {
|
||||
readonly value: number;
|
||||
readonly owner: "centered" | "onRoll" | "opponent";
|
||||
}
|
||||
|
||||
/**
|
||||
* Un coup légal complet.
|
||||
*
|
||||
* Glossaire : docs/glossaire/coup.md
|
||||
*/
|
||||
export interface Move {
|
||||
/** Notation de gnubg, par exemple « 8/5 6/5 ». */
|
||||
readonly notation: string;
|
||||
/** Ses demi-coups, dans un ordre jouable. */
|
||||
readonly halfMoves: readonly HalfMove[];
|
||||
/** La position après le coup, vue du joueur qui vient de jouer. */
|
||||
readonly position: PositionId;
|
||||
}
|
||||
|
||||
export interface CubeDecision {
|
||||
/** Le joueur au trait a le droit de doubler. */
|
||||
readonly available: boolean;
|
||||
/** Le moteur lui recommande de doubler. */
|
||||
readonly double: boolean;
|
||||
/** S'il double, le moteur recommande à l'adversaire de prendre. */
|
||||
readonly take: boolean;
|
||||
}
|
||||
|
||||
export interface HalfMovesCheck {
|
||||
/** Les demi-coups commencent un coup légal. */
|
||||
readonly valid: boolean;
|
||||
/** Ils forment un coup légal complet. */
|
||||
readonly complete: boolean;
|
||||
/** La position après eux, vue du joueur qui joue (null si refusés). */
|
||||
readonly position: PositionId | null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Un plateau décodé, pour l'affichage et pour savoir si la partie est finie.
|
||||
*
|
||||
* Glossaire : docs/glossaire/plateau.md
|
||||
*/
|
||||
export interface Board {
|
||||
readonly onRoll: BoardSide;
|
||||
readonly opponent: BoardSide;
|
||||
/** La même position vue de l'adversaire. */
|
||||
readonly swappedPosition: PositionId;
|
||||
/** null tant que la partie n'est pas finie. */
|
||||
readonly result: BoardResult | null;
|
||||
}
|
||||
|
||||
/** Un camp, vu de lui-même : sa case 1 est la plus proche de sa sortie. */
|
||||
export interface BoardSide {
|
||||
/** Nombre de pions sur les cases 1 à 24 (indices 0 à 23). */
|
||||
readonly points: readonly number[];
|
||||
readonly bar: number;
|
||||
readonly off: number;
|
||||
readonly pipCount: number;
|
||||
}
|
||||
|
||||
/** Simple, gammon ou backgammon. */
|
||||
export type ResultKind = "single" | "gammon" | "backgammon";
|
||||
|
||||
export interface BoardResult {
|
||||
readonly winner: "onRoll" | "opponent";
|
||||
readonly kind: ResultKind;
|
||||
/** Points gagnés, videau et règle Jacoby compris. */
|
||||
readonly points: number;
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
// Les événements d'une partie et leur journal (ADR 0007, point 3).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Une partie est la suite de ce qui s'est passé. Un événement n'est jamais
|
||||
// modifié ; chacun pointe vers le précédent (parent). Les événements forment
|
||||
// donc un arbre : une branche est un nouvel événement accroché à un ancien,
|
||||
// et annuler revient à repartir du parent. Le format des événements est un
|
||||
// contrat durable : le changer demande une migration et un ADR.
|
||||
//
|
||||
// Chaque événement contient tout ce qu'il faut pour rejouer la partie sans
|
||||
// le moteur : l'état se recalcule par une simple boucle (state.ts).
|
||||
|
||||
import type { Cube } from "./cube.js";
|
||||
import type { ResultKind } from "./engine.js";
|
||||
import type { HalfMove, PositionId } from "./position.js";
|
||||
import type { Roll } from "./roll.js";
|
||||
import type { Side } from "./side.js";
|
||||
|
||||
/** Version du format des événements. */
|
||||
export const EVENT_VERSION = 1;
|
||||
|
||||
interface EventBase {
|
||||
/** Identifiant, unique dans la partie. */
|
||||
readonly id: string;
|
||||
/** L'événement précédent ; null pour le premier. */
|
||||
readonly parent: string | null;
|
||||
readonly version: number;
|
||||
}
|
||||
|
||||
/** Début de partie : la position, le videau, et qui commence (null : le jet
|
||||
* d'ouverture le dira). La position est vue de celui qui commence ; celle de
|
||||
* départ est la même pour les deux. */
|
||||
export interface GameStarted extends EventBase {
|
||||
readonly type: "GameStarted";
|
||||
readonly position: PositionId;
|
||||
readonly cube: Cube;
|
||||
readonly firstTurn: Side | null;
|
||||
}
|
||||
|
||||
/** Des dés tirés. Pour le jet d'ouverture, side vaut null et chacun lance un
|
||||
* dé : roll[0] est celui du joueur, roll[1] celui de l'ordinateur. */
|
||||
export interface DiceRolled extends EventBase {
|
||||
readonly type: "DiceRolled";
|
||||
readonly side: Side | null;
|
||||
readonly roll: Roll;
|
||||
}
|
||||
|
||||
/** Un coup joué (aucun demi-coup si le jet ne permettait pas de jouer). La
|
||||
* position est celle d'après le coup, vue de l'adversaire, qui a la main. */
|
||||
export interface MovePlayed extends EventBase {
|
||||
readonly type: "MovePlayed";
|
||||
readonly side: Side;
|
||||
readonly halfMoves: readonly HalfMove[];
|
||||
readonly position: PositionId;
|
||||
}
|
||||
|
||||
/** side propose de doubler. */
|
||||
export interface CubeOffered extends EventBase {
|
||||
readonly type: "CubeOffered";
|
||||
readonly side: Side;
|
||||
}
|
||||
|
||||
/** side prend le double : le videau double de valeur et passe chez lui. */
|
||||
export interface CubeTaken extends EventBase {
|
||||
readonly type: "CubeTaken";
|
||||
readonly side: Side;
|
||||
}
|
||||
|
||||
/** side passe le double : il perd la partie (GameEnded suit). */
|
||||
export interface CubeDropped extends EventBase {
|
||||
readonly type: "CubeDropped";
|
||||
readonly side: Side;
|
||||
}
|
||||
|
||||
/** Fin de partie. */
|
||||
export interface GameEnded extends EventBase {
|
||||
readonly type: "GameEnded";
|
||||
readonly winner: Side;
|
||||
readonly kind: ResultKind;
|
||||
readonly points: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ce qui s'est passé à un moment de la partie.
|
||||
*
|
||||
* Glossaire : docs/glossaire/evenement-de-partie.md
|
||||
*/
|
||||
export type GameEvent =
|
||||
| GameStarted
|
||||
| DiceRolled
|
||||
| MovePlayed
|
||||
| CubeOffered
|
||||
| CubeTaken
|
||||
| CubeDropped
|
||||
| GameEnded;
|
||||
|
||||
/** Un événement avant son ajout au journal (sans id, parent ni version). */
|
||||
export type NewGameEvent = WithoutBase<GameEvent>;
|
||||
|
||||
// Omit appliqué à chaque sorte d'événement séparément (et non à leur union,
|
||||
// qui ne garderait que les champs communs).
|
||||
type WithoutBase<E> = E extends unknown ? Omit<E, keyof EventBase> : never;
|
||||
|
||||
/** Tous les événements d'une partie, branches comprises, et l'événement
|
||||
* courant (head) : la partie en est là. */
|
||||
export interface GameJournal {
|
||||
readonly events: readonly GameEvent[];
|
||||
readonly head: string | null;
|
||||
}
|
||||
|
||||
export const EMPTY_JOURNAL: GameJournal = { events: [], head: null };
|
||||
|
||||
/** Ajoute un événement après l'événement courant, qui devient le nouveau. */
|
||||
export function appendEvent(journal: GameJournal, event: NewGameEvent): GameJournal {
|
||||
const added = Object.freeze({
|
||||
...event,
|
||||
id: String(journal.events.length + 1),
|
||||
parent: journal.head,
|
||||
version: EVENT_VERSION,
|
||||
}) as GameEvent;
|
||||
return { events: [...journal.events, added], head: added.id };
|
||||
}
|
||||
|
||||
/** Les événements du début jusqu'à l'événement courant, dans l'ordre. */
|
||||
export function currentLine(journal: GameJournal): GameEvent[] {
|
||||
const byId = new Map(journal.events.map((event) => [event.id, event]));
|
||||
const line: GameEvent[] = [];
|
||||
let id = journal.head;
|
||||
while (id !== null) {
|
||||
const event = byId.get(id);
|
||||
if (event === undefined) {
|
||||
throw new Error(`événement introuvable : ${id}`);
|
||||
}
|
||||
line.push(event);
|
||||
id = event.parent;
|
||||
}
|
||||
return line.reverse();
|
||||
}
|
||||
|
||||
/** Revient à un événement passé ; le prochain ajout ouvrira une branche. */
|
||||
export function goBackTo(journal: GameJournal, id: string): GameJournal {
|
||||
if (!journal.events.some((event) => event.id === id)) {
|
||||
throw new Error(`événement introuvable : ${id}`);
|
||||
}
|
||||
return { events: journal.events, head: id };
|
||||
}
|
||||
@@ -0,0 +1,482 @@
|
||||
// Une partie libre contre l'ordinateur.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Le joueur et l'ordinateur agissent chacun leur tour ; chaque action ajoute
|
||||
// des événements au journal (events.ts), d'où l'état est recalculé
|
||||
// (state.ts). Les règles viennent toutes du moteur : coups légaux, coup de
|
||||
// l'ordinateur, videau, fin de partie et points.
|
||||
|
||||
import { CENTERED_CUBE, type Cube } from "./cube.js";
|
||||
import type { BoardSide, Engine, EngineCube, Ply } from "./engine.js";
|
||||
import {
|
||||
appendEvent,
|
||||
currentLine,
|
||||
EMPTY_JOURNAL,
|
||||
EVENT_VERSION,
|
||||
type GameEvent,
|
||||
type GameJournal,
|
||||
goBackTo,
|
||||
type NewGameEvent,
|
||||
} from "./events.js";
|
||||
import { BAR, type HalfMove, OFF, type PositionId, START_POSITION } from "./position.js";
|
||||
import { type DiceSource, type Roll, randomDice, rollDice } from "./roll.js";
|
||||
import { otherSide, type Side } from "./side.js";
|
||||
import { type GameState, replay } from "./state.js";
|
||||
|
||||
/**
|
||||
* Niveau « standard » de l'ordinateur : 2 plis. Sur le Fairphone 4 (Chrome),
|
||||
* le meilleur coup à ce niveau prend au plus 348 ms (ADR 0009).
|
||||
*/
|
||||
export const STANDARD_PLY: Ply = 2;
|
||||
|
||||
/** Une partie qui ne commence pas à la position de départ. */
|
||||
export interface GameSetup {
|
||||
/** La position, vue de firstTurn. */
|
||||
readonly position: PositionId;
|
||||
/** Le camp qui a la main ; il n'y a pas de jet d'ouverture. */
|
||||
readonly firstTurn: Side;
|
||||
readonly cube?: Cube;
|
||||
}
|
||||
|
||||
/** Le plateau vu de chaque camp, chacun avec sa propre numérotation des
|
||||
* cases (sa case 1 est la plus proche de sa sortie). */
|
||||
export interface SideBoards {
|
||||
readonly player: BoardSide;
|
||||
readonly computer: BoardSide;
|
||||
}
|
||||
|
||||
/**
|
||||
* Un coup joué, demi-coup par demi-coup, pour le montrer : les plateaux
|
||||
* successifs, tels que le moteur les donne.
|
||||
*/
|
||||
export interface MoveSteps {
|
||||
readonly side: Side;
|
||||
readonly halfMoves: readonly HalfMove[];
|
||||
/** boards[0] : avant le coup ; boards[i + 1] : après le demi-coup i. */
|
||||
readonly boards: readonly SideBoards[];
|
||||
/** hits[i] : le demi-coup i a frappé un pion adverse, envoyé sur la barre
|
||||
* (lu sur les plateaux du moteur, pas déduit des règles). */
|
||||
readonly hits: readonly boolean[];
|
||||
}
|
||||
|
||||
export interface GameOptions {
|
||||
/** Source des dés ; le hasard ordinaire par défaut. */
|
||||
readonly dice?: DiceSource;
|
||||
/** Niveau de l'ordinateur ; STANDARD_PLY par défaut. */
|
||||
readonly ply?: Ply;
|
||||
readonly setup?: GameSetup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Une partie contre l'ordinateur.
|
||||
*
|
||||
* Glossaire : docs/glossaire/partie.md
|
||||
*/
|
||||
export class Game {
|
||||
readonly #engine: Engine;
|
||||
readonly #dice: DiceSource;
|
||||
readonly #ply: Ply;
|
||||
#journal: GameJournal = EMPTY_JOURNAL;
|
||||
// Coup du joueur en cours de saisie : pas encore dans le journal.
|
||||
#pending: HalfMove[] = [];
|
||||
#pendingPosition: PositionId | null = null;
|
||||
|
||||
private constructor(engine: Engine, options: GameOptions) {
|
||||
this.#engine = engine;
|
||||
this.#dice = options.dice ?? randomDice;
|
||||
this.#ply = options.ply ?? STANDARD_PLY;
|
||||
}
|
||||
|
||||
/** Commence une partie : à la position de départ avec le jet d'ouverture,
|
||||
* ou à la position de options.setup. */
|
||||
static start(engine: Engine, options: GameOptions = {}): Game {
|
||||
const game = new Game(engine, options);
|
||||
const setup = options.setup;
|
||||
game.#append({
|
||||
type: "GameStarted",
|
||||
position: setup?.position ?? START_POSITION,
|
||||
cube: setup?.cube ?? CENTERED_CUBE,
|
||||
firstTurn: setup?.firstTurn ?? null,
|
||||
});
|
||||
while (game.state.phase === "opening") {
|
||||
game.#append({ type: "DiceRolled", side: null, roll: rollDice(game.#dice) });
|
||||
}
|
||||
return game;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reprend une partie enregistrée, à partir de son journal. Erreur si le
|
||||
* journal est d'un autre format ou incohérent.
|
||||
*/
|
||||
static resume(engine: Engine, journal: GameJournal, options: GameOptions = {}): Game {
|
||||
const first = journal.events[0];
|
||||
if (first?.type !== "GameStarted" || journal.head === null) {
|
||||
throw new Error("journal de partie vide ou mal formé");
|
||||
}
|
||||
if (journal.events.some((event) => event.version !== EVENT_VERSION)) {
|
||||
throw new Error("journal de partie d'une autre version");
|
||||
}
|
||||
const game = new Game(engine, options);
|
||||
game.#journal = journal;
|
||||
// Vérifie que chaque événement de la ligne courante existe.
|
||||
currentLine(journal);
|
||||
return game;
|
||||
}
|
||||
|
||||
/** Tous les événements, branches comprises, et l'événement courant. */
|
||||
get journal(): GameJournal {
|
||||
return this.#journal;
|
||||
}
|
||||
|
||||
/** Les événements du début jusqu'à maintenant. */
|
||||
get events(): GameEvent[] {
|
||||
return currentLine(this.#journal);
|
||||
}
|
||||
|
||||
get state(): GameState {
|
||||
return replay(this.events);
|
||||
}
|
||||
|
||||
/** Les demi-coups déjà saisis du coup en cours. */
|
||||
get pendingHalfMoves(): readonly HalfMove[] {
|
||||
return this.#pending;
|
||||
}
|
||||
|
||||
/** La position à afficher : après les demi-coups déjà saisis. */
|
||||
get displayedPosition(): PositionId {
|
||||
return this.#pendingPosition ?? this.state.position;
|
||||
}
|
||||
|
||||
/** Le plateau affiché (après les demi-coups déjà saisis), décodé par le
|
||||
* moteur. */
|
||||
async displayedBoard(): Promise<SideBoards> {
|
||||
const state = this.state;
|
||||
// La position est vue du camp qui a la main (le joueur pendant le jet
|
||||
// d'ouverture : la position de départ est la même pour les deux).
|
||||
return this.#sideBoards(this.displayedPosition, state.turn ?? "player", state.cube);
|
||||
}
|
||||
|
||||
/**
|
||||
* Le dernier coup joué de la partie, demi-coup par demi-coup (null s'il
|
||||
* n'y en a pas). Les plateaux intermédiaires viennent du moteur
|
||||
* (checkHalfMoves, puis board) : aucune règle n'est rejouée ici.
|
||||
*/
|
||||
async lastMoveSteps(): Promise<MoveSteps | null> {
|
||||
const events = this.events;
|
||||
const index = events.findLastIndex((e) => e.type === "MovePlayed");
|
||||
const played = events[index];
|
||||
if (played?.type !== "MovePlayed") {
|
||||
return null;
|
||||
}
|
||||
// L'état juste avant le coup : la position vue de celui qui joue, et
|
||||
// son jet.
|
||||
const before = replay(events.slice(0, index));
|
||||
const roll = rollToPlay(before);
|
||||
const positions = [before.position];
|
||||
for (let i = 1; i <= played.halfMoves.length; i++) {
|
||||
const check = await this.#engine.checkHalfMoves(
|
||||
before.position,
|
||||
roll,
|
||||
played.halfMoves.slice(0, i),
|
||||
);
|
||||
if (check.position === null) {
|
||||
throw new Error("coup enregistré refusé par le moteur");
|
||||
}
|
||||
positions.push(check.position);
|
||||
}
|
||||
const boards = await Promise.all(
|
||||
positions.map((p) => this.#sideBoards(p, played.side, before.cube)),
|
||||
);
|
||||
const opponent = otherSide(played.side);
|
||||
const hits = played.halfMoves.map(
|
||||
(_, i) => (boards[i + 1]?.[opponent].bar ?? 0) > (boards[i]?.[opponent].bar ?? 0),
|
||||
);
|
||||
return { side: played.side, halfMoves: played.halfMoves, boards, hits };
|
||||
}
|
||||
|
||||
/**
|
||||
* Les demi-coups que le joueur peut saisir maintenant, à la suite de ceux
|
||||
* déjà saisis (liste vide hors de son tour de jeu). Chaque candidat
|
||||
* déplace un de ses pions de la valeur d'un dé (vers la sortie si le dé
|
||||
* dépasse la case 1) ; seuls restent ceux que le moteur déclare menant à
|
||||
* un coup légal. Aucune règle n'est jugée ici.
|
||||
*/
|
||||
async nextHalfMoves(): Promise<HalfMove[]> {
|
||||
const state = this.state;
|
||||
if (state.turn !== "player" || state.phase !== "moving") {
|
||||
return [];
|
||||
}
|
||||
const roll = rollToPlay(state);
|
||||
const { player } = await this.displayedBoard();
|
||||
const candidates = new Map<string, HalfMove>();
|
||||
for (const from of occupiedPoints(player)) {
|
||||
for (const die of roll) {
|
||||
const to = Math.max(from - die, OFF);
|
||||
candidates.set(`${from}/${to}`, { from, to });
|
||||
}
|
||||
}
|
||||
const moves = [...candidates.values()];
|
||||
const checks = await Promise.all(
|
||||
moves.map((h) =>
|
||||
this.#engine.checkHalfMoves(state.position, roll, [...this.#pending, h]),
|
||||
),
|
||||
);
|
||||
return moves.filter((_, i) => checks[i]?.valid === true);
|
||||
}
|
||||
|
||||
/** Le joueur peut-il doubler maintenant ? (Le moteur dit si le videau le
|
||||
* permet.) */
|
||||
async canDouble(): Promise<boolean> {
|
||||
const state = this.state;
|
||||
if (state.turn !== "player" || state.phase !== "rolling") {
|
||||
return false;
|
||||
}
|
||||
// Le droit de doubler ne dépend pas du niveau : 0 pli suffit.
|
||||
const decision = await this.#engine.cubeDecision(
|
||||
state.position,
|
||||
engineCube(state.cube, "player"),
|
||||
0,
|
||||
);
|
||||
return decision.available;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------- Joueur
|
||||
|
||||
/** Le joueur lance les dés. S'il ne peut pas jouer (cannotMove), son
|
||||
* tour ne passe qu'une fois qu'il l'a constaté (skipTurn). */
|
||||
async roll(): Promise<void> {
|
||||
this.#expect("player", "rolling");
|
||||
this.#append({ type: "DiceRolled", side: "player", roll: rollDice(this.#dice) });
|
||||
}
|
||||
|
||||
/** Le joueur a lancé les dés, mais le moteur ne lui donne aucun coup
|
||||
* légal : il ne peut que laisser passer son tour. */
|
||||
async cannotMove(): Promise<boolean> {
|
||||
const state = this.state;
|
||||
if (state.turn !== "player" || state.phase !== "moving") {
|
||||
return false;
|
||||
}
|
||||
const moves = await this.#engine.legalMoves(state.position, rollToPlay(state));
|
||||
return moves.length === 0;
|
||||
}
|
||||
|
||||
/** Le joueur, qui ne peut pas jouer son jet, laisse passer son tour.
|
||||
* Erreur s'il a un coup possible. */
|
||||
async skipTurn(): Promise<void> {
|
||||
this.#expect("player", "moving");
|
||||
if (!(await this.cannotMove())) {
|
||||
throw new Error("vous avez un coup possible : jouez-le");
|
||||
}
|
||||
await this.#playMove("player", [], null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Le joueur déplace un pion (un dé). Renvoie false si ce demi-coup ne
|
||||
* mène à aucun coup légal : il est refusé et rien ne change. Quand les
|
||||
* demi-coups forment un coup complet, le coup est joué.
|
||||
*/
|
||||
async playHalfMove(halfMove: HalfMove): Promise<boolean> {
|
||||
const state = this.#expect("player", "moving");
|
||||
const halfMoves = [...this.#pending, halfMove];
|
||||
const check = await this.#engine.checkHalfMoves(
|
||||
state.position,
|
||||
rollToPlay(state),
|
||||
halfMoves,
|
||||
);
|
||||
if (!check.valid || check.position === null) {
|
||||
return false;
|
||||
}
|
||||
if (check.complete) {
|
||||
this.cancelHalfMoves();
|
||||
await this.#playMove("player", halfMoves, check.position);
|
||||
} else {
|
||||
this.#pending = halfMoves;
|
||||
this.#pendingPosition = check.position;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Oublie les demi-coups saisis du coup en cours. */
|
||||
cancelHalfMoves(): void {
|
||||
this.#pending = [];
|
||||
this.#pendingPosition = null;
|
||||
}
|
||||
|
||||
/** Le joueur double, avant de lancer les dés ; l'ordinateur prend ou passe
|
||||
* selon le moteur. */
|
||||
async double(): Promise<void> {
|
||||
const state = this.#expect("player", "rolling");
|
||||
const decision = await this.#engine.cubeDecision(
|
||||
state.position,
|
||||
engineCube(state.cube, "player"),
|
||||
this.#ply,
|
||||
);
|
||||
if (!decision.available) {
|
||||
throw new Error("vous ne pouvez pas doubler : le videau est chez l'ordinateur");
|
||||
}
|
||||
this.#append({ type: "CubeOffered", side: "player" });
|
||||
this.#answerDouble("computer", decision.take);
|
||||
}
|
||||
|
||||
/** Le joueur prend le double de l'ordinateur. */
|
||||
take(): void {
|
||||
this.#expect("computer", "doubled");
|
||||
this.#answerDouble("player", true);
|
||||
}
|
||||
|
||||
/** Le joueur passe le double de l'ordinateur : il perd la partie. */
|
||||
drop(): void {
|
||||
this.#expect("computer", "doubled");
|
||||
this.#answerDouble("player", false);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------- Ordinateur
|
||||
|
||||
/**
|
||||
* Le tour de l'ordinateur : il double si le moteur le recommande (le
|
||||
* tour s'arrête alors, en attendant la réponse du joueur), sinon il lance
|
||||
* les dés et joue le meilleur coup du moteur.
|
||||
*/
|
||||
async playComputerTurn(): Promise<void> {
|
||||
let state = this.#expect("computer", "rolling", "moving");
|
||||
if (state.phase === "rolling") {
|
||||
const decision = await this.#engine.cubeDecision(
|
||||
state.position,
|
||||
engineCube(state.cube, "computer"),
|
||||
this.#ply,
|
||||
);
|
||||
if (decision.double) {
|
||||
this.#append({ type: "CubeOffered", side: "computer" });
|
||||
return;
|
||||
}
|
||||
this.#append({ type: "DiceRolled", side: "computer", roll: rollDice(this.#dice) });
|
||||
state = this.state;
|
||||
}
|
||||
const best = await this.#engine.bestMove(
|
||||
state.position,
|
||||
engineCube(state.cube, "computer"),
|
||||
rollToPlay(state),
|
||||
this.#ply,
|
||||
);
|
||||
await this.#playMove("computer", best?.halfMoves ?? [], best?.position ?? null);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ Retour
|
||||
|
||||
/** Revient à un événement passé (« Rejouer d'ici ») : la suite reste dans
|
||||
* le journal, et la prochaine action ouvre une nouvelle branche. */
|
||||
goBackTo(eventId: string): void {
|
||||
this.cancelHalfMoves();
|
||||
this.#journal = goBackTo(this.#journal, eventId);
|
||||
}
|
||||
|
||||
/** Annule le dernier événement : la partie repart de son parent. */
|
||||
undo(): void {
|
||||
const last = this.events.at(-1);
|
||||
if (last?.parent == null) {
|
||||
throw new Error("rien à annuler");
|
||||
}
|
||||
this.goBackTo(last.parent);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ Interne
|
||||
|
||||
#append(event: NewGameEvent): void {
|
||||
this.#journal = appendEvent(this.#journal, event);
|
||||
}
|
||||
|
||||
/** Le plateau d'une position vue de onRoll, décodé par le moteur. */
|
||||
async #sideBoards(position: PositionId, onRoll: Side, cube: Cube): Promise<SideBoards> {
|
||||
const board = await this.#engine.board(position, engineCube(cube, onRoll));
|
||||
return onRoll === "player"
|
||||
? { player: board.onRoll, computer: board.opponent }
|
||||
: { player: board.opponent, computer: board.onRoll };
|
||||
}
|
||||
|
||||
/** Vérifie que c'est bien à side d'agir, dans l'une des phases. */
|
||||
#expect(side: Side, ...phases: GameState["phase"][]): GameState {
|
||||
const state = this.state;
|
||||
if (state.turn !== side || !phases.includes(state.phase)) {
|
||||
throw new Error(
|
||||
`action impossible : la main est à ${state.turn ?? "personne"}, phase ${state.phase}`,
|
||||
);
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enregistre un coup. after est la position après le coup, vue de celui
|
||||
* qui joue (null s'il ne pouvait pas jouer). Le moteur dit si la partie
|
||||
* est finie et donne la position vue de l'adversaire.
|
||||
*/
|
||||
async #playMove(
|
||||
side: Side,
|
||||
halfMoves: readonly HalfMove[],
|
||||
after: PositionId | null,
|
||||
): Promise<void> {
|
||||
const state = this.state;
|
||||
const board = await this.#engine.board(
|
||||
after ?? state.position,
|
||||
engineCube(state.cube, side),
|
||||
);
|
||||
this.#append({
|
||||
type: "MovePlayed",
|
||||
side,
|
||||
halfMoves: halfMoves.map((h) => ({ from: h.from, to: h.to })),
|
||||
position: board.swappedPosition,
|
||||
});
|
||||
if (board.result !== null) {
|
||||
this.#append({
|
||||
type: "GameEnded",
|
||||
winner: board.result.winner === "onRoll" ? side : otherSide(side),
|
||||
kind: board.result.kind,
|
||||
points: board.result.points,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** taker prend ou passe le double proposé par l'autre camp. */
|
||||
#answerDouble(taker: Side, take: boolean): void {
|
||||
if (take) {
|
||||
this.#append({ type: "CubeTaken", side: taker });
|
||||
return;
|
||||
}
|
||||
// Passer : on perd la partie à la valeur du videau d'avant le double.
|
||||
this.#append({ type: "CubeDropped", side: taker });
|
||||
this.#append({
|
||||
type: "GameEnded",
|
||||
winner: otherSide(taker),
|
||||
kind: "single",
|
||||
points: this.state.cube.value,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** Le jet à jouer, en phase moving. */
|
||||
function rollToPlay(state: GameState): Roll {
|
||||
if (state.roll === null) {
|
||||
throw new Error("aucun jet à jouer");
|
||||
}
|
||||
return state.roll;
|
||||
}
|
||||
|
||||
/** Les cases d'où un camp a des pions à jouer : la barre, puis 24 à 1. */
|
||||
function occupiedPoints(side: BoardSide): number[] {
|
||||
const points = side.bar > 0 ? [BAR] : [];
|
||||
for (let point = 24; point >= 1; point--) {
|
||||
if ((side.points[point - 1] ?? 0) > 0) {
|
||||
points.push(point);
|
||||
}
|
||||
}
|
||||
return points;
|
||||
}
|
||||
|
||||
/** Le videau vu du camp au trait, pour le moteur. */
|
||||
function engineCube(cube: Cube, onRoll: Side): EngineCube {
|
||||
if (cube.owner === null) {
|
||||
return { value: cube.value, owner: "centered" };
|
||||
}
|
||||
return { value: cube.value, owner: cube.owner === onRoll ? "onRoll" : "opponent" };
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
// Positions et demi-coups.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
/**
|
||||
* Identifiant d'une position (Position ID de gnubg, 14 caractères). Il code le
|
||||
* plateau vu du joueur au trait. Le domaine ne le décode jamais lui-même : il
|
||||
* le passe au moteur.
|
||||
*
|
||||
* Glossaire : docs/glossaire/identifiant-de-position.md
|
||||
*/
|
||||
export type PositionId = string;
|
||||
|
||||
/** La position de départ, identique pour les deux joueurs. */
|
||||
export const START_POSITION: PositionId = "4HPwATDgc/ABMA";
|
||||
|
||||
/** Case de la barre et de la sortie dans un demi-coup. */
|
||||
export const BAR = 25;
|
||||
export const OFF = 0;
|
||||
|
||||
/**
|
||||
* Un pion déplacé avec un seul dé, d'une case à une autre. Les cases sont
|
||||
* vues du joueur qui joue : 1 à 24, BAR (25) pour la barre, OFF (0) pour la
|
||||
* sortie.
|
||||
*
|
||||
* Glossaire : docs/glossaire/demi-coup.md
|
||||
*/
|
||||
export interface HalfMove {
|
||||
readonly from: number;
|
||||
readonly to: number;
|
||||
}
|
||||
|
||||
/** Lit un coup noté « 8/5 6/5 », « bar/22 » ou « 6/off » (un dé par demi-coup). */
|
||||
export function parseHalfMoves(text: string): HalfMove[] {
|
||||
return text
|
||||
.trim()
|
||||
.split(/\s+/)
|
||||
.filter((part) => part !== "")
|
||||
.map((part) => {
|
||||
const [from, to, ...rest] = part.split("/");
|
||||
if (from === undefined || to === undefined || rest.length > 0) {
|
||||
throw new Error(`demi-coup mal formé : ${part}`);
|
||||
}
|
||||
return { from: parsePoint(from), to: parsePoint(to) };
|
||||
});
|
||||
}
|
||||
|
||||
/** Écrit des demi-coups sous la forme « 8/5 6/5 ». */
|
||||
export function formatHalfMoves(halfMoves: readonly HalfMove[]): string {
|
||||
return halfMoves.map((h) => `${formatPoint(h.from)}/${formatPoint(h.to)}`).join(" ");
|
||||
}
|
||||
|
||||
function parsePoint(text: string): number {
|
||||
if (text === "bar") {
|
||||
return BAR;
|
||||
}
|
||||
if (text === "off") {
|
||||
return OFF;
|
||||
}
|
||||
const point = Number(text);
|
||||
if (!Number.isInteger(point) || point < 1 || point > 24) {
|
||||
throw new Error(`case invalide : ${text}`);
|
||||
}
|
||||
return point;
|
||||
}
|
||||
|
||||
function formatPoint(point: number): string {
|
||||
if (point === BAR) {
|
||||
return "bar";
|
||||
}
|
||||
return point === OFF ? "off" : String(point);
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
// Jets de dés et source du hasard.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
/**
|
||||
* Un jet : les deux dés, chacun de 1 à 6.
|
||||
*
|
||||
* Glossaire : docs/glossaire/jet.md
|
||||
*/
|
||||
export type Roll = readonly [number, number];
|
||||
|
||||
/**
|
||||
* Source de dés : chaque appel renvoie un dé, de 1 à 6. Elle est passée au
|
||||
* domaine (ADR 0007, point 4) : hasard véritable dans l'application, dés
|
||||
* imposés dans les tests.
|
||||
*/
|
||||
export type DiceSource = () => number;
|
||||
|
||||
/** Le hasard ordinaire. */
|
||||
export const randomDice: DiceSource = () => 1 + Math.floor(Math.random() * 6);
|
||||
|
||||
/** Des dés imposés, dans l'ordre ; erreur s'il n'en reste plus. */
|
||||
export function fixedDice(values: readonly number[]): DiceSource {
|
||||
let next = 0;
|
||||
return () => {
|
||||
const value = values[next];
|
||||
if (value === undefined) {
|
||||
throw new Error("plus de dés imposés");
|
||||
}
|
||||
next++;
|
||||
return value;
|
||||
};
|
||||
}
|
||||
|
||||
/** Tire un jet de deux dés. */
|
||||
export function rollDice(dice: DiceSource): Roll {
|
||||
return [checkDie(dice()), checkDie(dice())];
|
||||
}
|
||||
|
||||
function checkDie(value: number): number {
|
||||
if (!Number.isInteger(value) || value < 1 || value > 6) {
|
||||
throw new Error(`dé invalide : ${value}`);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
// Les deux camps d'une partie contre l'ordinateur.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
/** Le joueur humain (« vous ») ou l'ordinateur. */
|
||||
export type Side = "player" | "computer";
|
||||
|
||||
export function otherSide(side: Side): Side {
|
||||
return side === "player" ? "computer" : "player";
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
// L'état d'une partie, recalculé en rejouant ses événements.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import { CENTERED_CUBE, type Cube } from "./cube.js";
|
||||
import type { ResultKind } from "./engine.js";
|
||||
import type { GameEvent } from "./events.js";
|
||||
import { type PositionId, START_POSITION } from "./position.js";
|
||||
import type { Roll } from "./roll.js";
|
||||
import { otherSide, type Side } from "./side.js";
|
||||
|
||||
/**
|
||||
* Où en est la partie :
|
||||
* - opening : jet d'ouverture, chacun lance un dé ;
|
||||
* - rolling : turn peut doubler, puis lance les dés ;
|
||||
* - moving : turn joue le jet roll ;
|
||||
* - doubled : turn a proposé de doubler, l'adversaire doit prendre ou passer ;
|
||||
* - over : partie finie, voir result.
|
||||
*/
|
||||
export type Phase = "opening" | "rolling" | "moving" | "doubled" | "over";
|
||||
|
||||
export interface GameResult {
|
||||
readonly winner: Side;
|
||||
readonly kind: ResultKind;
|
||||
readonly points: number;
|
||||
}
|
||||
|
||||
export interface GameState {
|
||||
readonly phase: Phase;
|
||||
/** Le camp qui a la main (null pendant le jet d'ouverture). */
|
||||
readonly turn: Side | null;
|
||||
/** La position, vue du camp qui a la main. */
|
||||
readonly position: PositionId;
|
||||
/** Le jet à jouer (phase moving). */
|
||||
readonly roll: Roll | null;
|
||||
readonly cube: Cube;
|
||||
readonly result: GameResult | null;
|
||||
}
|
||||
|
||||
/** Avant le premier événement. */
|
||||
const NOT_STARTED: GameState = {
|
||||
phase: "opening",
|
||||
turn: null,
|
||||
position: START_POSITION,
|
||||
roll: null,
|
||||
cube: CENTERED_CUBE,
|
||||
result: null,
|
||||
};
|
||||
|
||||
/** Rejoue des événements, du premier au dernier. */
|
||||
export function replay(events: readonly GameEvent[]): GameState {
|
||||
return events.reduce(applyEvent, NOT_STARTED);
|
||||
}
|
||||
|
||||
/** L'état après un événement. */
|
||||
export function applyEvent(state: GameState, event: GameEvent): GameState {
|
||||
switch (event.type) {
|
||||
case "GameStarted":
|
||||
return {
|
||||
...NOT_STARTED,
|
||||
position: event.position,
|
||||
cube: event.cube,
|
||||
turn: event.firstTurn,
|
||||
phase: event.firstTurn === null ? "opening" : "rolling",
|
||||
};
|
||||
case "DiceRolled":
|
||||
if (event.side !== null) {
|
||||
return { ...state, phase: "moving", roll: event.roll };
|
||||
}
|
||||
// Jet d'ouverture : le plus fort dé commence et joue les deux
|
||||
// dés ; en cas d'égalité, on relance.
|
||||
if (event.roll[0] === event.roll[1]) {
|
||||
return state;
|
||||
}
|
||||
return {
|
||||
...state,
|
||||
phase: "moving",
|
||||
turn: event.roll[0] > event.roll[1] ? "player" : "computer",
|
||||
roll: event.roll,
|
||||
};
|
||||
case "MovePlayed":
|
||||
return {
|
||||
...state,
|
||||
phase: "rolling",
|
||||
turn: otherSide(event.side),
|
||||
position: event.position,
|
||||
roll: null,
|
||||
};
|
||||
case "CubeOffered":
|
||||
return { ...state, phase: "doubled" };
|
||||
case "CubeTaken":
|
||||
return {
|
||||
...state,
|
||||
phase: "rolling",
|
||||
cube: { value: state.cube.value * 2, owner: event.side },
|
||||
};
|
||||
case "CubeDropped":
|
||||
return state;
|
||||
case "GameEnded":
|
||||
return {
|
||||
...state,
|
||||
phase: "over",
|
||||
roll: null,
|
||||
result: { winner: event.winner, kind: event.kind, points: event.points },
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"extends": "../../tsconfig.json",
|
||||
"compilerOptions": {
|
||||
"lib": ["ES2023"],
|
||||
"types": [],
|
||||
"noEmit": true
|
||||
},
|
||||
"include": ["."]
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
// L'interface Engine du domaine, implémentée avec le moteur WebAssembly.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Le moteur WebAssembly répond aux mêmes commandes qu'engine-cli, en JSON
|
||||
// (web/engine-wasm.mjs). Cet adaptateur traduit chaque méthode en commande et
|
||||
// chaque réponse en types du domaine. Il ne sait pas comment la commande est
|
||||
// exécutée : directement sous Node, dans un Web Worker dans le navigateur.
|
||||
|
||||
import type {
|
||||
Board,
|
||||
BoardResult,
|
||||
BoardSide,
|
||||
CubeDecision,
|
||||
Engine,
|
||||
EngineCube,
|
||||
HalfMovesCheck,
|
||||
Move,
|
||||
Ply,
|
||||
} from "../domain/game/engine.js";
|
||||
import { formatHalfMoves, type HalfMove, type PositionId } from "../domain/game/position.js";
|
||||
import type { Roll } from "../domain/game/roll.js";
|
||||
|
||||
/** Exécute une commande d'engine-cli et renvoie son JSON décodé ; la
|
||||
* promesse est rejetée si le moteur signale une erreur. */
|
||||
export type RunCommand = (args: string[]) => Promise<unknown>;
|
||||
|
||||
// Les réponses d'engine-cli utilisées ici (voir engine-cli/main.c).
|
||||
interface CliMove {
|
||||
move: string;
|
||||
position_id: string;
|
||||
half_moves: [number, number][];
|
||||
}
|
||||
interface CliSide {
|
||||
points: number[];
|
||||
bar: number;
|
||||
off: number;
|
||||
pip_count: number;
|
||||
}
|
||||
interface CliBoard {
|
||||
on_roll: CliSide;
|
||||
opponent: CliSide;
|
||||
swapped_position_id: string;
|
||||
result: { winner: "on_roll" | "opponent"; kind: BoardResult["kind"]; points: number } | null;
|
||||
}
|
||||
|
||||
export function createWasmEngine(run: RunCommand): Engine {
|
||||
// Un Match ID par état du videau : le moteur les code une fois.
|
||||
const matchIds = new Map<string, string>();
|
||||
|
||||
async function matchId(cube: EngineCube): Promise<string> {
|
||||
// Partie libre, joueur 0 au trait : le propriétaire 0 est le joueur au
|
||||
// trait, 1 son adversaire, -1 le centre.
|
||||
const owner = { centered: -1, onRoll: 0, opponent: 1 }[cube.owner];
|
||||
const key = `${cube.value} ${owner}`;
|
||||
let id = matchIds.get(key);
|
||||
if (id === undefined) {
|
||||
const answer = (await run(["matchid", String(cube.value), String(owner)])) as {
|
||||
match_id: string;
|
||||
};
|
||||
id = answer.match_id;
|
||||
matchIds.set(key, id);
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
return {
|
||||
async legalMoves(position: PositionId, roll: Roll): Promise<Move[]> {
|
||||
// Le Match ID n'a pas d'effet sur les coups légaux.
|
||||
const answer = (await run(["legal", position, "MAEAAAAAAAAA", diceText(roll)])) as {
|
||||
moves: CliMove[];
|
||||
};
|
||||
return answer.moves.map(toMove);
|
||||
},
|
||||
|
||||
async bestMove(position: PositionId, cube: EngineCube, roll: Roll, ply: Ply) {
|
||||
const args = ["--ply", String(ply), "bestmove", position, await matchId(cube)];
|
||||
const answer = (await run([...args, diceText(roll)])) as { best_move: CliMove | null };
|
||||
return answer.best_move === null ? null : toMove(answer.best_move);
|
||||
},
|
||||
|
||||
async cubeDecision(
|
||||
position: PositionId,
|
||||
cube: EngineCube,
|
||||
ply: Ply,
|
||||
): Promise<CubeDecision> {
|
||||
const args = ["--ply", String(ply), "cube", position, await matchId(cube)];
|
||||
const answer = (await run(args)) as CubeDecision;
|
||||
return { available: answer.available, double: answer.double, take: answer.take };
|
||||
},
|
||||
|
||||
async checkHalfMoves(
|
||||
position: PositionId,
|
||||
roll: Roll,
|
||||
halfMoves: readonly HalfMove[],
|
||||
): Promise<HalfMovesCheck> {
|
||||
const args = ["halfmoves", position, diceText(roll), formatHalfMoves(halfMoves)];
|
||||
const answer = (await run(args)) as {
|
||||
valid: boolean;
|
||||
complete: boolean;
|
||||
result_position_id: string | null;
|
||||
};
|
||||
return {
|
||||
valid: answer.valid,
|
||||
complete: answer.complete,
|
||||
position: answer.result_position_id,
|
||||
};
|
||||
},
|
||||
|
||||
async board(position: PositionId, cube: EngineCube): Promise<Board> {
|
||||
const answer = (await run(["position", position, await matchId(cube)])) as CliBoard;
|
||||
return {
|
||||
onRoll: toSide(answer.on_roll),
|
||||
opponent: toSide(answer.opponent),
|
||||
swappedPosition: answer.swapped_position_id,
|
||||
result:
|
||||
answer.result === null
|
||||
? null
|
||||
: {
|
||||
winner: answer.result.winner === "on_roll" ? "onRoll" : "opponent",
|
||||
kind: answer.result.kind,
|
||||
points: answer.result.points,
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function diceText(roll: Roll): string {
|
||||
return `${roll[0]}${roll[1]}`;
|
||||
}
|
||||
|
||||
function toMove(move: CliMove): Move {
|
||||
return {
|
||||
notation: move.move,
|
||||
halfMoves: move.half_moves.map(([from, to]) => ({ from, to })),
|
||||
position: move.position_id,
|
||||
};
|
||||
}
|
||||
|
||||
function toSide(side: CliSide): BoardSide {
|
||||
return { points: side.points, bar: side.bar, off: side.off, pipCount: side.pip_count };
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
// Les commandes du moteur exécutées dans un Web Worker (web/engine-worker.mjs),
|
||||
// pour que le calcul ne bloque jamais l'affichage.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Messages du Worker (voir engine-worker.mjs) : une fois au chargement
|
||||
// { type: "ready" } ou { type: "failed", message } ; puis, pour chaque
|
||||
// commande { id, args } envoyée, { id, result } ou { id, error }. Le Worker
|
||||
// traite les commandes une à une, dans l'ordre d'arrivée.
|
||||
|
||||
import type { RunCommand } from "./wasm-engine.js";
|
||||
|
||||
export interface EngineWorker {
|
||||
/** Résolue quand le moteur est chargé ; rejetée s'il ne peut pas l'être. */
|
||||
readonly ready: Promise<void>;
|
||||
readonly run: RunCommand;
|
||||
}
|
||||
|
||||
interface Pending {
|
||||
resolve(result: unknown): void;
|
||||
reject(error: Error): void;
|
||||
}
|
||||
|
||||
export function startEngineWorker(url: URL): EngineWorker {
|
||||
const worker = new Worker(url, { type: "module" });
|
||||
const pending = new Map<number, Pending>();
|
||||
let nextId = 1;
|
||||
let failure: Error | null = null;
|
||||
let markReady: () => void = () => {};
|
||||
let markFailed: (error: Error) => void = () => {};
|
||||
const ready = new Promise<void>((resolve, reject) => {
|
||||
markReady = resolve;
|
||||
markFailed = reject;
|
||||
});
|
||||
|
||||
// Le moteur est inutilisable : toutes les commandes échouent.
|
||||
function fail(error: Error): void {
|
||||
failure = error;
|
||||
markFailed(error);
|
||||
for (const { reject } of pending.values()) {
|
||||
reject(error);
|
||||
}
|
||||
pending.clear();
|
||||
}
|
||||
|
||||
worker.onmessage = (event: MessageEvent) => {
|
||||
const message = event.data;
|
||||
if (message.type === "ready") {
|
||||
markReady();
|
||||
} else if (message.type === "failed") {
|
||||
fail(new Error(message.message));
|
||||
} else {
|
||||
const request = pending.get(message.id);
|
||||
pending.delete(message.id);
|
||||
if (message.error !== undefined) {
|
||||
request?.reject(new Error(message.error));
|
||||
} else {
|
||||
request?.resolve(message.result);
|
||||
}
|
||||
}
|
||||
};
|
||||
// Le Worker lui-même n'a pas démarré (fichier absent, navigateur trop
|
||||
// ancien pour les Workers en module ES…).
|
||||
worker.onerror = (event: ErrorEvent) => {
|
||||
fail(new Error(event.message || "le Web Worker du moteur n'a pas démarré"));
|
||||
};
|
||||
|
||||
function run(args: string[]): Promise<unknown> {
|
||||
if (failure !== null) {
|
||||
return Promise.reject(failure);
|
||||
}
|
||||
const id = nextId++;
|
||||
return new Promise((resolve, reject) => {
|
||||
pending.set(id, { resolve, reject });
|
||||
worker.postMessage({ id, args });
|
||||
});
|
||||
}
|
||||
|
||||
return { ready, run };
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
// Point d'entrée de l'application dans le navigateur (index.html) : le seul
|
||||
// endroit qui assemble le domaine, le moteur, le stockage et l'interface
|
||||
// (ADR 0007, vérifié par dependency-cruiser).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import { Game } from "./domain/game/game.js";
|
||||
import { createWasmEngine } from "./engine/wasm-engine.js";
|
||||
import { startEngineWorker } from "./engine/worker-run.js";
|
||||
import { createGameStore } from "./storage/game-store.js";
|
||||
import { startApp } from "./ui/app.js";
|
||||
|
||||
// Ce fichier est servi sous app/ ; le Worker et le service worker sont à la
|
||||
// racine du site.
|
||||
const worker = startEngineWorker(new URL("../engine-worker.mjs", import.meta.url));
|
||||
const engine = createWasmEngine(worker.run);
|
||||
const store = createGameStore(window.localStorage);
|
||||
|
||||
startApp({
|
||||
engineReady: worker.ready,
|
||||
newGame: () => Game.start(engine),
|
||||
savedGame: () => {
|
||||
const journal = store.load();
|
||||
if (journal === null) {
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
return Game.resume(engine, journal);
|
||||
} catch {
|
||||
return null; // partie illisible : on en commence une nouvelle
|
||||
}
|
||||
},
|
||||
saveGame: (journal) => store.save(journal),
|
||||
confirm: (question) => window.confirm(question),
|
||||
});
|
||||
|
||||
// Hors ligne : le service worker met tout le site en cache. Le navigateur le
|
||||
// refuse hors https (sauf localhost) : l'application marche alors sans.
|
||||
// Il est enregistré une fois le moteur chargé : si le Worker et le service
|
||||
// worker téléchargent les données du moteur (8,7 Mo) en même temps, Chromium
|
||||
// fait échouer l'installation (« Cache.add() encountered a network error »),
|
||||
// et l'application n'est pas disponible hors ligne. Cela évite aussi de
|
||||
// télécharger deux fois ces données à la première visite.
|
||||
if ("serviceWorker" in navigator) {
|
||||
const sw = new URL("../sw.js", import.meta.url);
|
||||
worker.ready.then(() => navigator.serviceWorker.register(sw)).catch(() => {});
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
// L'enregistrement de la partie en cours, pour la reprendre après fermeture
|
||||
// de la page : son journal d'événements, en JSON, dans un stockage clé-valeur
|
||||
// (localStorage dans le navigateur).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import type { GameJournal } from "../domain/game/events.js";
|
||||
|
||||
/** Ce qu'il faut d'un stockage clé-valeur (localStorage en a davantage). */
|
||||
export interface KeyValueStorage {
|
||||
getItem(key: string): string | null;
|
||||
setItem(key: string, value: string): void;
|
||||
}
|
||||
|
||||
export interface GameStore {
|
||||
/** Le journal enregistré, ou null s'il n'y en a pas de lisible. */
|
||||
load(): GameJournal | null;
|
||||
save(journal: GameJournal): void;
|
||||
}
|
||||
|
||||
const KEY = "ustagammon.current-game";
|
||||
|
||||
export function createGameStore(storage: KeyValueStorage): GameStore {
|
||||
return {
|
||||
load() {
|
||||
try {
|
||||
const journal = JSON.parse(storage.getItem(KEY) ?? "null");
|
||||
const valid =
|
||||
journal !== null &&
|
||||
Array.isArray(journal.events) &&
|
||||
(journal.head === null || typeof journal.head === "string");
|
||||
return valid ? journal : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
},
|
||||
save(journal) {
|
||||
try {
|
||||
storage.setItem(KEY, JSON.stringify(journal));
|
||||
} catch {
|
||||
// Stockage plein ou interdit (navigation privée) : la partie
|
||||
// continue, elle ne pourra seulement pas être reprise.
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,526 @@
|
||||
// L'écran de jeu : le plateau, les boutons et les messages, branchés sur une
|
||||
// partie du domaine.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Tout passe par la partie (Game) : l'interface ne connaît ni le moteur ni le
|
||||
// stockage, qu'elle reçoit déjà branchés (main.ts). Après chaque action du
|
||||
// joueur, la partie est enregistrée, puis l'ordinateur joue tant que c'est
|
||||
// son tour ; le plateau est ensuite redessiné à partir de l'état de la partie.
|
||||
|
||||
import type { GameJournal } from "../domain/game/events.js";
|
||||
import type { Game, MoveSteps, SideBoards } from "../domain/game/game.js";
|
||||
import { formatHalfMoves, type HalfMove } from "../domain/game/position.js";
|
||||
import { otherSide, type Side } from "../domain/game/side.js";
|
||||
import { boardModel, moveTargets, moveTrace, type Place, placeOf } from "./board-model.js";
|
||||
import { checkerSpot, NO_MARKS, renderBoard, type ShownDie, slideChecker } from "./board-view.js";
|
||||
import { showHelp } from "./help.js";
|
||||
import { TEXTS } from "./texts.js";
|
||||
|
||||
/** Durée du glissement d'un pion, pour chaque demi-coup de l'ordinateur. */
|
||||
const SLIDE_MS = 400;
|
||||
|
||||
export interface AppOptions {
|
||||
/** Résolue quand le moteur est chargé, rejetée s'il ne peut pas l'être. */
|
||||
readonly engineReady: Promise<unknown>;
|
||||
/** Une nouvelle partie (le jet d'ouverture est déjà tiré). */
|
||||
readonly newGame: () => Game;
|
||||
/** La partie enregistrée, ou null s'il n'y en a pas. */
|
||||
readonly savedGame: () => Game | null;
|
||||
readonly saveGame: (journal: GameJournal) => void;
|
||||
readonly confirm: (question: string) => boolean;
|
||||
}
|
||||
|
||||
function byId<T extends HTMLElement>(id: string): T {
|
||||
const element = document.getElementById(id);
|
||||
if (element === null) {
|
||||
throw new Error(`élément #${id} absent de la page`);
|
||||
}
|
||||
return element as T;
|
||||
}
|
||||
|
||||
/** Démarre l'écran de jeu dans la page (index.html). */
|
||||
export function startApp(options: AppOptions): void {
|
||||
const ui = {
|
||||
board: byId("board") as unknown as SVGSVGElement,
|
||||
info: byId("info"),
|
||||
prompt: byId("prompt"),
|
||||
pips: byId("pips"),
|
||||
roll: byId<HTMLButtonElement>("roll"),
|
||||
double: byId<HTMLButtonElement>("double"),
|
||||
take: byId<HTMLButtonElement>("take"),
|
||||
drop: byId<HTMLButtonElement>("drop"),
|
||||
cancel: byId<HTMLButtonElement>("cancel"),
|
||||
skip: byId<HTMLButtonElement>("skip"),
|
||||
replay: byId<HTMLButtonElement>("replay"),
|
||||
again: byId<HTMLButtonElement>("again"),
|
||||
newGame: byId<HTMLButtonElement>("new-game"),
|
||||
helpButton: byId<HTMLButtonElement>("help-button"),
|
||||
helpBack: byId<HTMLButtonElement>("help-back"),
|
||||
game: byId("game"),
|
||||
help: byId("help"),
|
||||
helpContent: byId("help-content"),
|
||||
};
|
||||
ui.board.setAttribute("aria-label", TEXTS.boardLabel);
|
||||
ui.roll.textContent = TEXTS.roll;
|
||||
ui.double.textContent = TEXTS.double;
|
||||
ui.take.textContent = TEXTS.take;
|
||||
ui.drop.textContent = TEXTS.drop;
|
||||
ui.cancel.textContent = TEXTS.cancel;
|
||||
ui.skip.textContent = TEXTS.skip;
|
||||
ui.replay.textContent = TEXTS.replay;
|
||||
ui.replay.title = TEXTS.replayTitle;
|
||||
ui.again.textContent = TEXTS.newGame;
|
||||
ui.newGame.textContent = TEXTS.newGame;
|
||||
ui.helpButton.textContent = TEXTS.help;
|
||||
ui.helpBack.textContent = TEXTS.back;
|
||||
|
||||
// État de l'écran, en plus de la partie elle-même.
|
||||
let game: Game | null = null;
|
||||
let sides: SideBoards | null = null;
|
||||
let targets = new Map<Place, Map<Place, HalfMove>>();
|
||||
let selected: Place | null = null;
|
||||
let canDouble = false;
|
||||
// Le joueur a lancé les dés mais ne peut pas jouer : il doit continuer.
|
||||
let stuck = false;
|
||||
let busy = true;
|
||||
let info = "";
|
||||
// Le dernier coup de l'ordinateur, montré (traces, bouton « Revoir »)
|
||||
// jusqu'à la prochaine action du joueur ; null : rien à montrer.
|
||||
let shownMove: MoveSteps | null = null;
|
||||
// Pendant l'animation d'un coup, render() laisse le plateau à l'animation.
|
||||
let animating = false;
|
||||
|
||||
// ------------------------------------------------------------ Dessin
|
||||
|
||||
/** Recalcule ce qui demande le moteur, sans redessiner. */
|
||||
async function update(): Promise<void> {
|
||||
if (game === null) {
|
||||
return;
|
||||
}
|
||||
sides = await game.displayedBoard();
|
||||
targets = moveTargets(await game.nextHalfMoves());
|
||||
canDouble = await game.canDouble();
|
||||
stuck = await game.cannotMove();
|
||||
if (selected !== null && !targets.has(selected)) {
|
||||
selected = null;
|
||||
}
|
||||
}
|
||||
|
||||
/** Recalcule ce qui demande le moteur, puis redessine. */
|
||||
async function refresh(): Promise<void> {
|
||||
await update();
|
||||
render();
|
||||
}
|
||||
|
||||
function render(): void {
|
||||
if (game === null || sides === null) {
|
||||
return;
|
||||
}
|
||||
const state = game.state;
|
||||
const model = boardModel(sides);
|
||||
if (!animating) {
|
||||
renderBoard(ui.board, model, {
|
||||
dice: shownDice(game, stuck),
|
||||
cube: state.cube,
|
||||
movable: new Set(targets.keys()),
|
||||
selected,
|
||||
targets: new Set(selected === null ? [] : (targets.get(selected)?.keys() ?? [])),
|
||||
trace:
|
||||
shownMove === null
|
||||
? null
|
||||
: moveTrace(shownMove.side, shownMove.halfMoves, shownMove.hits),
|
||||
// Mêmes conditions que les boutons « Lancer les dés » et
|
||||
// « Doubler ».
|
||||
canRoll: !busy && state.turn === "player" && state.phase === "rolling",
|
||||
canDouble: !busy && canDouble,
|
||||
});
|
||||
}
|
||||
ui.pips.textContent = TEXTS.pipCounts(model.pipCount.player, model.pipCount.computer);
|
||||
// Un jet sans coup possible reste annoncé jusqu'à l'action suivante,
|
||||
// même après un rechargement de la page.
|
||||
if (stuck && state.roll !== null) {
|
||||
ui.info.textContent = TEXTS.youCannotMove(state.roll);
|
||||
} else if (computerCouldNotMove(game)) {
|
||||
ui.info.textContent = TEXTS.computerCannotMove(rollBefore(game));
|
||||
} else {
|
||||
ui.info.textContent = info;
|
||||
}
|
||||
ui.prompt.textContent = stuck
|
||||
? TEXTS.pressContinue
|
||||
: prompt(game, selected !== null, canDouble);
|
||||
ui.prompt.classList.toggle("thinking", state.turn === "computer" && isPlaying(game));
|
||||
|
||||
const player = state.turn === "player";
|
||||
show(ui.roll, player && state.phase === "rolling");
|
||||
show(ui.double, player && state.phase === "rolling");
|
||||
ui.double.disabled = busy || !canDouble;
|
||||
show(ui.cancel, player && state.phase === "moving" && !stuck);
|
||||
show(ui.skip, stuck);
|
||||
ui.cancel.disabled = busy || game.pendingHalfMoves.length === 0;
|
||||
const doubled = state.turn === "computer" && state.phase === "doubled";
|
||||
show(ui.take, doubled);
|
||||
show(ui.drop, doubled);
|
||||
show(ui.again, state.phase === "over");
|
||||
show(ui.replay, shownMove !== null);
|
||||
for (const button of [
|
||||
ui.roll,
|
||||
ui.take,
|
||||
ui.drop,
|
||||
ui.skip,
|
||||
ui.replay,
|
||||
ui.again,
|
||||
ui.newGame,
|
||||
]) {
|
||||
button.disabled = busy;
|
||||
}
|
||||
// Pour le style et pour les tests dans un navigateur : l'écran
|
||||
// attend le moteur.
|
||||
document.body.classList.toggle("busy", busy);
|
||||
}
|
||||
|
||||
function show(button: HTMLButtonElement, visible: boolean): void {
|
||||
button.hidden = !visible;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------- Actions
|
||||
|
||||
function save(): void {
|
||||
if (game !== null) {
|
||||
options.saveGame(game.journal);
|
||||
}
|
||||
}
|
||||
|
||||
/** L'ordinateur joue tant que c'est son tour (il s'arrête s'il double).
|
||||
* Son dernier coup, s'il est la dernière chose jouée, devient le coup à
|
||||
* montrer. Renvoie vrai si l'ordinateur a joué. */
|
||||
async function computerTurns(): Promise<boolean> {
|
||||
let played = false;
|
||||
while (game !== null && game.state.turn === "computer" && isPlaying(game)) {
|
||||
await refresh();
|
||||
const start = performance.now();
|
||||
await game.playComputerTurn();
|
||||
info = describeComputerTurn(game, performance.now() - start);
|
||||
save();
|
||||
played = true;
|
||||
}
|
||||
if (game !== null) {
|
||||
shownMove = await computerMoveToShow(game);
|
||||
}
|
||||
return played;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fait glisser les pions du coup de l'ordinateur, un demi-coup après
|
||||
* l'autre, à partir des plateaux intermédiaires donnés par le domaine. Rien
|
||||
* si le système demande moins d'animations : les traces suffisent.
|
||||
*/
|
||||
async function animateMove(steps: MoveSteps): Promise<void> {
|
||||
if (game === null || window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
|
||||
return;
|
||||
}
|
||||
const decor = { dice: shownDice(game, false), cube: game.state.cube, ...NO_MARKS };
|
||||
const draw = (i: number) => {
|
||||
const boards = steps.boards[i];
|
||||
if (boards !== undefined) {
|
||||
renderBoard(ui.board, boardModel(boards), decor);
|
||||
}
|
||||
};
|
||||
animating = true;
|
||||
render(); // messages et boutons ; le plateau est à l'animation
|
||||
try {
|
||||
for (const [i, halfMove] of steps.halfMoves.entries()) {
|
||||
const from = placeOf(steps.side, halfMove.from);
|
||||
const to = placeOf(steps.side, halfMove.to);
|
||||
draw(i);
|
||||
const start = checkerSpot(ui.board, from);
|
||||
const victim = steps.hits[i] === true ? checkerSpot(ui.board, to) : null;
|
||||
draw(i + 1);
|
||||
await Promise.all([
|
||||
start && slideChecker(ui.board, to, start, SLIDE_MS),
|
||||
victim &&
|
||||
slideChecker(ui.board, `bar-${otherSide(steps.side)}`, victim, SLIDE_MS),
|
||||
]);
|
||||
}
|
||||
} finally {
|
||||
animating = false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Rend la main au joueur : recalcule, anime le coup à montrer (si
|
||||
* animate), puis redessine avec ses traces. */
|
||||
async function settle(animate: boolean): Promise<void> {
|
||||
try {
|
||||
await update();
|
||||
if (animate && shownMove !== null) {
|
||||
await animateMove(shownMove);
|
||||
}
|
||||
} finally {
|
||||
busy = false;
|
||||
render();
|
||||
}
|
||||
}
|
||||
|
||||
/** 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> {
|
||||
if (busy || game === null) {
|
||||
return;
|
||||
}
|
||||
busy = true;
|
||||
selected = null;
|
||||
targets = new Map();
|
||||
shownMove = null;
|
||||
render();
|
||||
try {
|
||||
await action(game);
|
||||
save();
|
||||
await computerTurns();
|
||||
} catch (error) {
|
||||
info = TEXTS.actionFailed(error instanceof Error ? error.message : String(error));
|
||||
} finally {
|
||||
await settle(true);
|
||||
}
|
||||
}
|
||||
|
||||
function startNewGame(): void {
|
||||
game = options.newGame();
|
||||
const opening = game.events.findLast((e) => e.type === "DiceRolled");
|
||||
info =
|
||||
opening?.type === "DiceRolled" ? TEXTS.opening(opening.roll[0], opening.roll[1]) : "";
|
||||
}
|
||||
|
||||
ui.roll.onclick = () =>
|
||||
act(async (g) => {
|
||||
info = "";
|
||||
await g.roll();
|
||||
});
|
||||
|
||||
// Aucun coup possible : le joueur laisse passer son tour.
|
||||
ui.skip.onclick = () =>
|
||||
act(async (g) => {
|
||||
info = "";
|
||||
await g.skipTurn();
|
||||
});
|
||||
|
||||
ui.double.onclick = () =>
|
||||
act(async (g) => {
|
||||
await g.double();
|
||||
info = g.state.phase === "over" ? "" : TEXTS.computerTakes(g.state.cube.value);
|
||||
});
|
||||
|
||||
ui.take.onclick = () =>
|
||||
act((g) => {
|
||||
g.take();
|
||||
info = TEXTS.youTook(g.state.cube.value);
|
||||
});
|
||||
|
||||
ui.drop.onclick = () =>
|
||||
act((g) => {
|
||||
g.drop();
|
||||
info = "";
|
||||
});
|
||||
|
||||
ui.cancel.onclick = () => {
|
||||
if (!busy && game !== null) {
|
||||
game.cancelHalfMoves();
|
||||
selected = null;
|
||||
shownMove = null;
|
||||
void refresh();
|
||||
}
|
||||
};
|
||||
|
||||
const newGame = () => {
|
||||
if (busy) {
|
||||
return;
|
||||
}
|
||||
const inProgress = game !== null && game.state.phase !== "over";
|
||||
if (inProgress && !options.confirm(TEXTS.confirmNewGame)) {
|
||||
return;
|
||||
}
|
||||
void act(() => startNewGame());
|
||||
};
|
||||
ui.newGame.onclick = newGame;
|
||||
ui.again.onclick = newGame;
|
||||
|
||||
// Toucher le plateau : un pion jouable, puis une de ses cases d'arrivée.
|
||||
ui.board.addEventListener("click", (event) => {
|
||||
const target = event.target as Element | null;
|
||||
// Toucher les dés en attente ou le videau : comme leurs boutons.
|
||||
const action = target?.closest("[data-action]")?.getAttribute("data-action");
|
||||
if (action === "roll" && !ui.roll.hidden && !ui.roll.disabled) {
|
||||
ui.roll.click();
|
||||
return;
|
||||
}
|
||||
if (action === "double" && !ui.double.hidden && !ui.double.disabled) {
|
||||
ui.double.click();
|
||||
return;
|
||||
}
|
||||
const place = target?.closest("[data-place]")?.getAttribute("data-place") as Place | null;
|
||||
if (busy || place == null) {
|
||||
return;
|
||||
}
|
||||
const halfMove = selected === null ? undefined : targets.get(selected)?.get(place);
|
||||
if (halfMove !== undefined) {
|
||||
void act(async (g) => {
|
||||
info = "";
|
||||
await g.playHalfMove(halfMove);
|
||||
});
|
||||
return;
|
||||
}
|
||||
selected = targets.has(place) && place !== selected ? place : null;
|
||||
if (selected !== null) {
|
||||
shownMove = null; // toucher un pion : le coup de l'ordinateur s'efface
|
||||
}
|
||||
render();
|
||||
});
|
||||
|
||||
// Revoir le dernier coup de l'ordinateur, puis ses traces.
|
||||
ui.replay.onclick = async () => {
|
||||
if (busy || shownMove === null) {
|
||||
return;
|
||||
}
|
||||
busy = true;
|
||||
selected = null;
|
||||
await settle(true);
|
||||
};
|
||||
|
||||
ui.helpButton.onclick = () => {
|
||||
ui.game.hidden = true;
|
||||
ui.help.hidden = false;
|
||||
window.scrollTo(0, 0);
|
||||
void showHelp(ui.helpContent);
|
||||
};
|
||||
ui.helpBack.onclick = () => {
|
||||
ui.help.hidden = true;
|
||||
ui.game.hidden = false;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------- Démarrage
|
||||
|
||||
ui.prompt.textContent = TEXTS.loading;
|
||||
for (const button of [
|
||||
ui.roll,
|
||||
ui.double,
|
||||
ui.take,
|
||||
ui.drop,
|
||||
ui.cancel,
|
||||
ui.skip,
|
||||
ui.replay,
|
||||
ui.again,
|
||||
]) {
|
||||
button.hidden = true;
|
||||
}
|
||||
ui.newGame.disabled = true;
|
||||
options.engineReady.then(
|
||||
async () => {
|
||||
game = options.savedGame();
|
||||
if (game === null) {
|
||||
startNewGame();
|
||||
save();
|
||||
}
|
||||
// Comme après une action du joueur : l'ordinateur joue si c'est
|
||||
// à lui (partie nouvelle ou reprise pendant son tour). Une partie
|
||||
// reprise juste après son coup le montre, sans l'animer.
|
||||
let played = false;
|
||||
try {
|
||||
played = await computerTurns();
|
||||
} finally {
|
||||
await settle(played);
|
||||
}
|
||||
},
|
||||
(error: unknown) => {
|
||||
ui.prompt.textContent = TEXTS.engineFailed(
|
||||
error instanceof Error ? error.message : String(error),
|
||||
);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
// ------------------------------------------------- Lecture de la partie
|
||||
|
||||
/** La partie attend-elle encore un coup ou un jet (ni double, ni fin) ? */
|
||||
function isPlaying(game: Game): boolean {
|
||||
const phase = game.state.phase;
|
||||
return phase === "rolling" || phase === "moving";
|
||||
}
|
||||
|
||||
/** Le jet du dernier DiceRolled. */
|
||||
function rollBefore(game: Game): readonly number[] {
|
||||
const rolled = game.events.findLast((e) => e.type === "DiceRolled");
|
||||
return rolled?.type === "DiceRolled" ? rolled.roll : [];
|
||||
}
|
||||
|
||||
/** Les dés à montrer : le dernier jet, de la couleur de qui l'a lancé
|
||||
* (au jet d'ouverture, un dé chacun). Ils sont barrés si le jet ne permet
|
||||
* aucun coup : le joueur est bloqué (stuck), ou l'ordinateur vient de passer
|
||||
* son tour sans bouger. */
|
||||
function shownDice(game: Game, stuck: boolean): ShownDie[] {
|
||||
const rolled = game.events.findLast((e) => e.type === "DiceRolled");
|
||||
if (rolled?.type !== "DiceRolled") {
|
||||
return [];
|
||||
}
|
||||
const blocked = stuck || computerCouldNotMove(game);
|
||||
const sides: Side[] =
|
||||
rolled.side === null ? ["player", "computer"] : [rolled.side, rolled.side];
|
||||
return rolled.roll.map((value, i) => ({ value, side: sides[i] ?? "player", blocked }));
|
||||
}
|
||||
|
||||
/** La dernière chose jouée (fin de partie mise à part) est un tour de
|
||||
* l'ordinateur qui n'a pas pu jouer son jet. */
|
||||
function computerCouldNotMove(game: Game): boolean {
|
||||
const last = game.events.findLast((e) => e.type !== "GameEnded");
|
||||
return last?.type === "MovePlayed" && last.side === "computer" && last.halfMoves.length === 0;
|
||||
}
|
||||
|
||||
/** Le dernier coup de l'ordinateur, demi-coup par demi-coup, s'il est la
|
||||
* dernière chose jouée (fin de partie mise à part) et qu'il a déplacé des
|
||||
* pions ; sinon null. */
|
||||
async function computerMoveToShow(game: Game): Promise<MoveSteps | null> {
|
||||
const last = game.events.findLast((e) => e.type !== "GameEnded");
|
||||
if (last?.type !== "MovePlayed" || last.side !== "computer" || last.halfMoves.length === 0) {
|
||||
return null;
|
||||
}
|
||||
return game.lastMoveSteps();
|
||||
}
|
||||
|
||||
/** Ce qu'a fait l'ordinateur pendant son tour. */
|
||||
function describeComputerTurn(game: Game, ms: number): string {
|
||||
const last = game.events.at(-1);
|
||||
if (last?.type === "CubeOffered") {
|
||||
return "";
|
||||
}
|
||||
const played = game.events.findLast((e) => e.type === "MovePlayed");
|
||||
if (played?.type !== "MovePlayed") {
|
||||
return "";
|
||||
}
|
||||
const dice = rollBefore(game);
|
||||
if (played.halfMoves.length === 0) {
|
||||
return TEXTS.computerCannotMove(dice);
|
||||
}
|
||||
return TEXTS.computerMoved(dice, formatHalfMoves(played.halfMoves), ms);
|
||||
}
|
||||
|
||||
/** Ce que le joueur doit faire maintenant, ou le résultat. */
|
||||
function prompt(game: Game, selecting: boolean, canDouble: boolean): string {
|
||||
const state = game.state;
|
||||
if (state.phase === "over" && state.result !== null) {
|
||||
const { winner, kind, points } = state.result;
|
||||
const dropped = game.events.find((e) => e.type === "CubeDropped");
|
||||
if (dropped !== undefined) {
|
||||
return winner === "player" ? TEXTS.computerDropped(points) : TEXTS.youDropped(points);
|
||||
}
|
||||
return winner === "player" ? TEXTS.youWin(kind, points) : TEXTS.youLose(kind, points);
|
||||
}
|
||||
if (state.turn === "computer") {
|
||||
return state.phase === "doubled" ? TEXTS.computerDoubles : TEXTS.thinking;
|
||||
}
|
||||
if (state.phase === "rolling") {
|
||||
return canDouble ? TEXTS.yourRoll : TEXTS.yourRollNoDouble;
|
||||
}
|
||||
if (state.phase === "moving" && state.roll !== null) {
|
||||
return selecting ? TEXTS.pickTarget : TEXTS.yourMove(state.roll);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
// Ce que dessine le plateau, calculé sans le navigateur (testé sous Node).
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Le plateau est toujours dessiné du point de vue du joueur : ses cases 1 à 6
|
||||
// en bas à droite, 7 à 12 en bas à gauche, 13 à 18 en haut à gauche, 19 à 24
|
||||
// en haut à droite ; ses pions vont de 24 vers 1, puis sortent à droite, en
|
||||
// bas. La case 1 de l'ordinateur est la case 24 du joueur.
|
||||
|
||||
import type { SideBoards } from "../domain/game/game.js";
|
||||
import { BAR, type HalfMove, OFF } from "../domain/game/position.js";
|
||||
import type { Side } from "../domain/game/side.js";
|
||||
|
||||
/**
|
||||
* Un endroit du plateau où l'on peut toucher : une case (« p1 » à « p24 »,
|
||||
* numérotée du point de vue du joueur), la barre ou la sortie d'un camp.
|
||||
*/
|
||||
export type Place = `p${number}` | `bar-${Side}` | `off-${Side}`;
|
||||
|
||||
/** L'endroit désigné par une case d'un demi-coup de side, dans sa propre
|
||||
* numérotation (BAR, OFF ou 1 à 24). */
|
||||
export function placeOf(side: Side, point: number): Place {
|
||||
if (point === BAR) {
|
||||
return `bar-${side}`;
|
||||
}
|
||||
if (point === OFF) {
|
||||
return `off-${side}`;
|
||||
}
|
||||
return side === "player" ? `p${point}` : `p${25 - point}`;
|
||||
}
|
||||
|
||||
/** Une case du plateau, et les pions de chaque camp qui s'y trouvent. */
|
||||
export interface PointModel {
|
||||
readonly place: Place;
|
||||
/** Numéro de la case pour le joueur, 1 à 24. */
|
||||
readonly number: number;
|
||||
/** Le camp qui l'occupe (null : vide) et son nombre de pions. */
|
||||
readonly owner: Side | null;
|
||||
readonly count: number;
|
||||
}
|
||||
|
||||
export interface BoardModel {
|
||||
/** Les cases 1 à 24 du joueur, dans l'ordre. */
|
||||
readonly points: readonly PointModel[];
|
||||
readonly bar: Readonly<Record<Side, number>>;
|
||||
readonly off: Readonly<Record<Side, number>>;
|
||||
readonly pipCount: Readonly<Record<Side, number>>;
|
||||
}
|
||||
|
||||
/** Le plateau à dessiner, à partir du plateau vu de chaque camp. */
|
||||
export function boardModel(sides: SideBoards): BoardModel {
|
||||
const points: PointModel[] = [];
|
||||
for (let number = 1; number <= 24; number++) {
|
||||
const player = sides.player.points[number - 1] ?? 0;
|
||||
const computer = sides.computer.points[24 - number] ?? 0;
|
||||
// Une case n'a jamais de pions des deux camps à la fois.
|
||||
const owner = player > 0 ? "player" : computer > 0 ? "computer" : null;
|
||||
points.push({ place: `p${number}`, number, owner, count: player || computer });
|
||||
}
|
||||
return {
|
||||
points,
|
||||
bar: { player: sides.player.bar, computer: sides.computer.bar },
|
||||
off: { player: sides.player.off, computer: sides.computer.off },
|
||||
pipCount: { player: sides.player.pipCount, computer: sides.computer.pipCount },
|
||||
};
|
||||
}
|
||||
|
||||
/** Les cases de départ des demi-coups possibles, et pour chacune ses cases
|
||||
* d'arrivée : ce que l'interface met en évidence. */
|
||||
export function moveTargets(halfMoves: readonly HalfMove[]): Map<Place, Map<Place, HalfMove>> {
|
||||
const targets = new Map<Place, Map<Place, HalfMove>>();
|
||||
for (const halfMove of halfMoves) {
|
||||
const from = placeOf("player", halfMove.from);
|
||||
let tos = targets.get(from);
|
||||
if (tos === undefined) {
|
||||
tos = new Map();
|
||||
targets.set(from, tos);
|
||||
}
|
||||
tos.set(placeOf("player", halfMove.to), halfMove);
|
||||
}
|
||||
return targets;
|
||||
}
|
||||
|
||||
/** Ce qui reste dessiné d'un coup une fois joué. */
|
||||
export interface MoveTrace {
|
||||
/** Le camp qui a joué. */
|
||||
readonly side: Side;
|
||||
/** Une flèche par demi-coup, de sa case de départ à sa case d'arrivée. */
|
||||
readonly arrows: readonly { readonly from: Place; readonly to: Place }[];
|
||||
/** Par endroit, le nombre de pions arrivés et restés là (entourés). */
|
||||
readonly landed: ReadonlyMap<Place, number>;
|
||||
/** Par endroit, le nombre de pions partis (un pion fantôme chacun). */
|
||||
readonly left: ReadonlyMap<Place, number>;
|
||||
/** Le nombre de pions adverses frappés, envoyés sur la barre. */
|
||||
readonly hits: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Les traces d'un coup de side : ses demi-coups, et pour chacun s'il a frappé.
|
||||
* Un pion qui fait étape sur une case (13/7 7/4) n'y laisse ni fantôme ni
|
||||
* cercle : seuls comptent le départ et l'arrivée de chaque pion.
|
||||
*/
|
||||
export function moveTrace(
|
||||
side: Side,
|
||||
halfMoves: readonly HalfMove[],
|
||||
hits: readonly boolean[],
|
||||
): MoveTrace {
|
||||
const balance = new Map<Place, number>();
|
||||
const arrows = halfMoves.map((h) => {
|
||||
const from = placeOf(side, h.from);
|
||||
const to = placeOf(side, h.to);
|
||||
balance.set(from, (balance.get(from) ?? 0) - 1);
|
||||
balance.set(to, (balance.get(to) ?? 0) + 1);
|
||||
return { from, to };
|
||||
});
|
||||
const landed = new Map<Place, number>();
|
||||
const left = new Map<Place, number>();
|
||||
for (const [place, n] of balance) {
|
||||
if (n > 0) {
|
||||
landed.set(place, n);
|
||||
} else if (n < 0) {
|
||||
left.set(place, -n);
|
||||
}
|
||||
}
|
||||
return { side, arrows, landed, left, hits: hits.filter(Boolean).length };
|
||||
}
|
||||
|
||||
/** Où se trouve une case sur le dessin : rangée du haut ou du bas, et
|
||||
* colonne de 0 (à gauche) à 11 (à droite), sans compter la barre. */
|
||||
export function pointSlot(number: number): { top: boolean; column: number } {
|
||||
if (number <= 12) {
|
||||
return { top: false, column: 12 - number };
|
||||
}
|
||||
return { top: true, column: number - 13 };
|
||||
}
|
||||
@@ -0,0 +1,598 @@
|
||||
// Le dessin du plateau, en SVG.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Le plateau est redessiné en entier à chaque changement : c'est rapide, et
|
||||
// il n'y a aucun état caché dans le dessin. Les couleurs viennent des
|
||||
// variables CSS (app.css), par des classes : aucun style dans le SVG. Chaque
|
||||
// endroit qu'on peut toucher est un rectangle transparent, posé par-dessus
|
||||
// le reste, qui porte son nom dans data-place.
|
||||
|
||||
import type { Cube } from "../domain/game/cube.js";
|
||||
import type { Side } from "../domain/game/side.js";
|
||||
import { type BoardModel, type MoveTrace, type Place, pointSlot } from "./board-model.js";
|
||||
import { TEXTS } from "./texts.js";
|
||||
|
||||
/** Un dé affiché, de la couleur du camp qui l'a lancé. */
|
||||
export interface ShownDie {
|
||||
readonly value: number;
|
||||
readonly side: Side;
|
||||
/** Le jet ne permet aucun coup : le dé est estompé et barré. */
|
||||
readonly blocked: boolean;
|
||||
}
|
||||
|
||||
/** Ce qui s'ajoute aux pions : dés, videau, mises en évidence. */
|
||||
export interface BoardDecor {
|
||||
readonly dice: readonly ShownDie[];
|
||||
readonly cube: Cube;
|
||||
/** Les pions que le joueur peut déplacer. */
|
||||
readonly movable: ReadonlySet<Place>;
|
||||
/** Le pion touché, dont on montre les cases d'arrivée. */
|
||||
readonly selected: Place | null;
|
||||
readonly targets: ReadonlySet<Place>;
|
||||
/** Les traces du dernier coup de l'ordinateur, tant qu'on les montre. */
|
||||
readonly trace: MoveTrace | null;
|
||||
/** Le joueur peut lancer les dés : ses dés en attente se touchent. */
|
||||
readonly canRoll: boolean;
|
||||
/** Le joueur peut doubler : le videau se touche. */
|
||||
readonly canDouble: boolean;
|
||||
}
|
||||
|
||||
/** Ce qui ne s'ajoute pas aux pions pendant l'animation d'un coup. */
|
||||
export const NO_MARKS = {
|
||||
movable: new Set<Place>(),
|
||||
selected: null,
|
||||
targets: new Set<Place>(),
|
||||
trace: null,
|
||||
canRoll: false,
|
||||
canDouble: false,
|
||||
} as const;
|
||||
|
||||
/** Taille minimale d'une cible à toucher, en unités du dessin : au moins
|
||||
* 44 px sur un téléphone de 360 px de large, où le plateau en fait 344
|
||||
* (640 unités). */
|
||||
const MIN_TARGET = 88;
|
||||
|
||||
// Géométrie, en unités du viewBox (le SVG s'adapte à la largeur de l'écran).
|
||||
const WIDTH = 640;
|
||||
const HEIGHT = 520;
|
||||
const FRAME = 8;
|
||||
const POINT_WIDTH = 44;
|
||||
const HALF_WIDTH = 6 * POINT_WIDTH;
|
||||
const BAR_LEFT = FRAME + HALF_WIDTH;
|
||||
const BAR_WIDTH = 40;
|
||||
const RIGHT_HALF = BAR_LEFT + BAR_WIDTH;
|
||||
const TRAY_LEFT = RIGHT_HALF + HALF_WIDTH + FRAME;
|
||||
const TRAY_WIDTH = 48;
|
||||
const POINT_HEIGHT = 190;
|
||||
const MIDDLE = HEIGHT / 2;
|
||||
const RADIUS = 20;
|
||||
const STEP = 42; // d'un pion au suivant dans une pile
|
||||
const MAX_STACK = 5; // au-delà, un nombre sur le dernier pion
|
||||
const OFF_SLAB = 12; // épaisseur d'un pion sorti
|
||||
const DIE = 36;
|
||||
const CUBE = 34;
|
||||
|
||||
const SVG_NS = "http://www.w3.org/2000/svg";
|
||||
|
||||
type Attributes = Record<string, string | number>;
|
||||
|
||||
function add(parent: Element, name: string, attributes: Attributes, text?: string): SVGElement {
|
||||
const element = document.createElementNS(SVG_NS, name);
|
||||
for (const [key, value] of Object.entries(attributes)) {
|
||||
element.setAttribute(key, String(value));
|
||||
}
|
||||
if (text !== undefined) {
|
||||
element.textContent = text;
|
||||
}
|
||||
parent.append(element);
|
||||
return element;
|
||||
}
|
||||
|
||||
/** Abscisse du bord gauche d'une colonne (0 à 11). */
|
||||
function columnLeft(column: number): number {
|
||||
return column < 6 ? FRAME + column * POINT_WIDTH : RIGHT_HALF + (column - 6) * POINT_WIDTH;
|
||||
}
|
||||
|
||||
/** Un point du dessin. */
|
||||
export interface Spot {
|
||||
readonly x: number;
|
||||
readonly y: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Centre du pion numéro index (0 : le premier posé) d'un endroit : sur une
|
||||
* case, depuis le bord du plateau ; sur la barre, depuis le milieu (le
|
||||
* joueur dans la moitié haute, où il rentre, l'ordinateur en bas) ; dans la
|
||||
* sortie, une tranche de pion vu de profil (l'ordinateur en haut).
|
||||
*/
|
||||
function slotCenter(place: Place, index: number): Spot {
|
||||
if (place === "bar-player" || place === "bar-computer") {
|
||||
const offset = RADIUS + 4 + Math.min(index, MAX_STACK) * STEP;
|
||||
return {
|
||||
x: BAR_LEFT + BAR_WIDTH / 2,
|
||||
y: place === "bar-player" ? MIDDLE - offset : MIDDLE + offset,
|
||||
};
|
||||
}
|
||||
if (place === "off-player" || place === "off-computer") {
|
||||
const y =
|
||||
place === "off-computer"
|
||||
? FRAME + index * OFF_SLAB
|
||||
: HEIGHT - FRAME - (index + 1) * OFF_SLAB;
|
||||
return { x: TRAY_LEFT + TRAY_WIDTH / 2, y: y + OFF_SLAB / 2 };
|
||||
}
|
||||
const { top, column } = pointSlot(Number(place.slice(1)));
|
||||
const offset = RADIUS + 1 + Math.min(index, MAX_STACK) * STEP;
|
||||
return {
|
||||
x: columnLeft(column) + POINT_WIDTH / 2,
|
||||
y: top ? FRAME + offset : HEIGHT - FRAME - offset,
|
||||
};
|
||||
}
|
||||
|
||||
/** Le nombre de pions de side à un endroit. */
|
||||
function countAt(board: BoardModel, side: Side, place: Place): number {
|
||||
if (place === `bar-${side}`) {
|
||||
return board.bar[side];
|
||||
}
|
||||
if (place === `off-${side}`) {
|
||||
return board.off[side];
|
||||
}
|
||||
const point = board.points.find((p) => p.place === place);
|
||||
return point?.owner === side ? point.count : 0;
|
||||
}
|
||||
|
||||
/** Redessine tout le plateau dans svg. */
|
||||
export function renderBoard(svg: SVGSVGElement, board: BoardModel, decor: BoardDecor): void {
|
||||
svg.replaceChildren();
|
||||
svg.setAttribute("viewBox", `0 0 ${WIDTH} ${HEIGHT}`);
|
||||
drawFrame(svg);
|
||||
const hits = add(svg, "g", {});
|
||||
for (const point of board.points) {
|
||||
drawPoint(svg, hits, board, point.number, decor);
|
||||
}
|
||||
drawBar(svg, hits, board, decor);
|
||||
drawTray(svg, hits, board, decor);
|
||||
drawDice(svg, decor.dice);
|
||||
const cube = drawCube(svg, decor.cube);
|
||||
if (decor.trace !== null) {
|
||||
drawTrace(svg, board, decor.trace);
|
||||
}
|
||||
if (decor.canRoll) {
|
||||
const center = waitingDice(svg);
|
||||
addAction(hits, "roll", TEXTS.roll, center, 2 * DIE + 8 + MIN_TARGET / 2);
|
||||
}
|
||||
if (decor.canDouble) {
|
||||
cube.classList.add("can-double");
|
||||
addAction(hits, "double", TEXTS.double, cubeCenter(decor.cube), MIN_TARGET);
|
||||
}
|
||||
// Les zones à toucher passent devant tout le reste.
|
||||
svg.append(hits);
|
||||
}
|
||||
|
||||
function drawFrame(svg: SVGSVGElement): void {
|
||||
add(svg, "rect", { class: "board-frame", x: 0, y: 0, width: WIDTH, height: HEIGHT, rx: 6 });
|
||||
for (const left of [FRAME, RIGHT_HALF]) {
|
||||
add(svg, "rect", {
|
||||
class: "board-bed",
|
||||
x: left,
|
||||
y: FRAME,
|
||||
width: HALF_WIDTH,
|
||||
height: HEIGHT - 2 * FRAME,
|
||||
});
|
||||
}
|
||||
add(svg, "rect", {
|
||||
class: "board-tray",
|
||||
x: TRAY_LEFT,
|
||||
y: FRAME,
|
||||
width: TRAY_WIDTH,
|
||||
height: HEIGHT - 2 * FRAME,
|
||||
});
|
||||
}
|
||||
|
||||
function drawPoint(
|
||||
svg: SVGSVGElement,
|
||||
hits: Element,
|
||||
board: BoardModel,
|
||||
number: number,
|
||||
decor: BoardDecor,
|
||||
): void {
|
||||
const point = board.points[number - 1];
|
||||
if (point === undefined) {
|
||||
return;
|
||||
}
|
||||
const { top, column } = pointSlot(number);
|
||||
const left = columnLeft(column);
|
||||
const center = left + POINT_WIDTH / 2;
|
||||
const base = top ? FRAME : HEIGHT - FRAME;
|
||||
const tip = top ? FRAME + POINT_HEIGHT : HEIGHT - FRAME - POINT_HEIGHT;
|
||||
add(svg, "polygon", {
|
||||
class: column % 2 === 0 ? "point-a" : "point-b",
|
||||
points: `${left},${base} ${left + POINT_WIDTH},${base} ${center},${tip}`,
|
||||
});
|
||||
add(
|
||||
svg,
|
||||
"text",
|
||||
{ class: "point-number", x: center, y: top ? MIDDLE - 26 : MIDDLE + 34 },
|
||||
String(number),
|
||||
);
|
||||
if (decor.targets.has(point.place)) {
|
||||
add(svg, "rect", {
|
||||
class: "target-zone",
|
||||
x: left + 2,
|
||||
y: top ? FRAME : MIDDLE,
|
||||
width: POINT_WIDTH - 4,
|
||||
height: HEIGHT / 2 - FRAME,
|
||||
rx: 4,
|
||||
});
|
||||
}
|
||||
if (point.owner !== null) {
|
||||
drawStack(svg, point.owner, point.count, point.place, decor);
|
||||
}
|
||||
addHit(hits, point.place, decor, {
|
||||
x: left,
|
||||
y: top ? 0 : MIDDLE,
|
||||
width: POINT_WIDTH,
|
||||
height: MIDDLE,
|
||||
});
|
||||
}
|
||||
|
||||
/** Une pile de pions ; le dernier porte le nombre total s'il y en a trop
|
||||
* pour les montrer tous. Le pion du dessus porte son endroit dans
|
||||
* data-checker : c'est lui qu'on fait glisser quand un pion arrive. */
|
||||
function drawStack(
|
||||
svg: SVGSVGElement,
|
||||
side: Side,
|
||||
count: number,
|
||||
place: Place,
|
||||
decor: BoardDecor,
|
||||
): void {
|
||||
const shown = Math.min(count, MAX_STACK);
|
||||
for (let i = 0; i < shown; i++) {
|
||||
const last = i === shown - 1;
|
||||
const classes = [`checker checker-${side}`];
|
||||
if (last && decor.selected === place) {
|
||||
classes.push("selected");
|
||||
} else if (last && decor.movable.has(place)) {
|
||||
classes.push("movable");
|
||||
}
|
||||
const { x, y } = slotCenter(place, i);
|
||||
const checker = add(svg, "circle", { class: classes.join(" "), cx: x, cy: y, r: RADIUS });
|
||||
if (last) {
|
||||
checker.setAttribute("data-checker", place);
|
||||
}
|
||||
if (last && count > MAX_STACK) {
|
||||
add(svg, "text", { class: `checker-count count-${side}`, x, y: y + 6 }, String(count));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function drawBar(svg: SVGSVGElement, hits: Element, board: BoardModel, decor: BoardDecor): void {
|
||||
add(svg, "rect", {
|
||||
class: "board-bar",
|
||||
x: BAR_LEFT,
|
||||
y: 0,
|
||||
width: BAR_WIDTH,
|
||||
height: HEIGHT,
|
||||
});
|
||||
// Les pions du joueur sur la barre entrent en haut à droite : on les met
|
||||
// dans la moitié haute, en partant du milieu ; ceux de l'ordinateur en bas.
|
||||
for (const side of ["player", "computer"] as const) {
|
||||
drawStack(svg, side, board.bar[side], `bar-${side}`, decor);
|
||||
}
|
||||
addHit(hits, "bar-player", decor, { x: BAR_LEFT, y: 0, width: BAR_WIDTH, height: MIDDLE });
|
||||
}
|
||||
|
||||
function drawTray(svg: SVGSVGElement, hits: Element, board: BoardModel, decor: BoardDecor): void {
|
||||
// Pions sortis, vus de profil : l'ordinateur en haut, le joueur en bas.
|
||||
for (const side of ["player", "computer"] as const) {
|
||||
const count = board.off[side];
|
||||
for (let i = 0; i < count; i++) {
|
||||
const slab = addSlab(svg, `checker checker-${side}`, slotCenter(`off-${side}`, i));
|
||||
if (i === count - 1) {
|
||||
slab.setAttribute("data-checker", `off-${side}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (decor.targets.has("off-player")) {
|
||||
add(svg, "rect", {
|
||||
class: "target-zone",
|
||||
x: TRAY_LEFT + 2,
|
||||
y: MIDDLE,
|
||||
width: TRAY_WIDTH - 4,
|
||||
height: MIDDLE - FRAME,
|
||||
rx: 4,
|
||||
});
|
||||
}
|
||||
addHit(hits, "off-player", decor, {
|
||||
x: TRAY_LEFT,
|
||||
y: MIDDLE,
|
||||
width: TRAY_WIDTH,
|
||||
height: MIDDLE,
|
||||
});
|
||||
}
|
||||
|
||||
/** Une tranche de pion sorti, centrée en spot. */
|
||||
function addSlab(svg: Element, cssClass: string, spot: Spot): SVGElement {
|
||||
return add(svg, "rect", {
|
||||
class: cssClass,
|
||||
x: TRAY_LEFT + 4,
|
||||
y: spot.y - OFF_SLAB / 2 + 1,
|
||||
width: TRAY_WIDTH - 8,
|
||||
height: OFF_SLAB - 2,
|
||||
rx: 3,
|
||||
});
|
||||
}
|
||||
|
||||
/** Un cercle de rayon r autour d'un pion (un cadre pour un pion sorti). */
|
||||
function addRing(svg: Element, cssClass: string, place: Place, spot: Spot, r: number): void {
|
||||
if (place.startsWith("off-")) {
|
||||
addSlab(svg, cssClass, spot);
|
||||
} else {
|
||||
add(svg, "circle", { class: cssClass, cx: spot.x, cy: spot.y, r });
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------ Coup de l'ordinateur
|
||||
|
||||
/**
|
||||
* Les traces d'un coup : un pion fantôme (contour seul) là où chaque pion
|
||||
* est parti, un cercle autour de chaque pion arrivé et de chaque pion frappé
|
||||
* (sur la barre), et une flèche par demi-coup.
|
||||
*/
|
||||
function drawTrace(svg: SVGSVGElement, board: BoardModel, trace: MoveTrace): void {
|
||||
const side = trace.side;
|
||||
for (const [place, n] of trace.left) {
|
||||
// Au-dessus des pions restés sur la case.
|
||||
const remaining = countAt(board, side, place);
|
||||
for (let k = 0; k < n; k++) {
|
||||
addRing(svg, "trace-ghost", place, slotCenter(place, remaining + k), RADIUS - 1);
|
||||
}
|
||||
}
|
||||
for (const [place, n] of trace.landed) {
|
||||
const top = topIndex(board, side, place);
|
||||
for (let k = 0; k < n && top - k >= 0; k++) {
|
||||
addRing(svg, "trace-landed", place, slotCenter(place, top - k), RADIUS + 3);
|
||||
}
|
||||
}
|
||||
const opponent: Side = side === "player" ? "computer" : "player";
|
||||
const bar: Place = `bar-${opponent}`;
|
||||
const top = topIndex(board, opponent, bar);
|
||||
for (let k = 0; k < trace.hits && top - k >= 0; k++) {
|
||||
addRing(svg, "trace-hit", bar, slotCenter(bar, top - k), RADIUS + 3);
|
||||
}
|
||||
const defs = add(svg, "defs", {});
|
||||
const marker = add(defs, "marker", {
|
||||
id: "trace-head",
|
||||
viewBox: "0 0 10 10",
|
||||
refX: 8,
|
||||
refY: 5,
|
||||
markerWidth: 3.5,
|
||||
markerHeight: 3.5,
|
||||
orient: "auto",
|
||||
});
|
||||
add(marker, "path", { class: "trace-head", d: "M0,0 L10,5 L0,10 z" });
|
||||
const departures = new Map<Place, number>();
|
||||
for (const { from, to } of trace.arrows) {
|
||||
// De la place libre laissée par le pion (son fantôme) à son pion
|
||||
// d'arrivée.
|
||||
const k = departures.get(from) ?? 0;
|
||||
departures.set(from, k + 1);
|
||||
const start = slotCenter(from, countAt(board, side, from) + k);
|
||||
const end = slotCenter(to, Math.max(topIndex(board, side, to), 0));
|
||||
drawArrow(svg, start, end, to.startsWith("off-") ? OFF_SLAB : RADIUS + 4);
|
||||
}
|
||||
}
|
||||
|
||||
/** L'indice du pion du dessus dessiné à un endroit (-1 s'il n'y en a pas). */
|
||||
function topIndex(board: BoardModel, side: Side, place: Place): number {
|
||||
const count = countAt(board, side, place);
|
||||
return place.startsWith("off-") ? count - 1 : Math.min(count, MAX_STACK) - 1;
|
||||
}
|
||||
|
||||
/** Une flèche de start vers end, arrêtée à gap du centre d'arrivée. */
|
||||
function drawArrow(svg: SVGSVGElement, start: Spot, end: Spot, gap: number): void {
|
||||
const dx = end.x - start.x;
|
||||
const dy = end.y - start.y;
|
||||
const length = Math.hypot(dx, dy);
|
||||
const keep = length > 2 * gap ? (length - gap) / length : 0.5;
|
||||
add(svg, "line", {
|
||||
class: "trace-arrow",
|
||||
x1: start.x,
|
||||
y1: start.y,
|
||||
x2: start.x + dx * keep,
|
||||
y2: start.y + dy * keep,
|
||||
"marker-end": "url(#trace-head)",
|
||||
});
|
||||
}
|
||||
|
||||
/** Le centre du pion du dessus d'un endroit, sur le plateau tel qu'il est
|
||||
* dessiné (null s'il n'y a pas de pion). */
|
||||
export function checkerSpot(svg: SVGSVGElement, place: Place): Spot | null {
|
||||
const checker = svg.querySelector(`[data-checker="${place}"]`);
|
||||
if (checker === null) {
|
||||
return null;
|
||||
}
|
||||
const number = (name: string) => Number(checker.getAttribute(name));
|
||||
if (checker.tagName === "circle") {
|
||||
return { x: number("cx"), y: number("cy") };
|
||||
}
|
||||
return { x: number("x") + number("width") / 2, y: number("y") + number("height") / 2 };
|
||||
}
|
||||
|
||||
/**
|
||||
* Fait glisser le pion du dessus de place depuis from jusqu'à sa position
|
||||
* dessinée, en ms millisecondes (animation du navigateur, sans bibliothèque).
|
||||
* Résolue à la fin du glissement.
|
||||
*/
|
||||
export async function slideChecker(
|
||||
svg: SVGSVGElement,
|
||||
place: Place,
|
||||
from: Spot,
|
||||
ms: number,
|
||||
): Promise<void> {
|
||||
const checker = svg.querySelector(`[data-checker="${place}"]`);
|
||||
const to = checkerSpot(svg, place);
|
||||
if (checker === null || to === null || typeof checker.animate !== "function") {
|
||||
return;
|
||||
}
|
||||
// Devant les autres pions pendant le trajet, mais derrière les zones à
|
||||
// toucher, toujours dessinées en dernier.
|
||||
svg.insertBefore(checker, svg.lastChild);
|
||||
const animation = checker.animate(
|
||||
[
|
||||
{ transform: `translate(${from.x - to.x}px, ${from.y - to.y}px)` },
|
||||
{ transform: "translate(0px, 0px)" },
|
||||
],
|
||||
{ duration: ms, easing: "ease-in-out" },
|
||||
);
|
||||
await animation.finished.catch(() => undefined);
|
||||
}
|
||||
|
||||
// Position des points d'un dé, en fractions de son côté.
|
||||
const PIPS: Record<number, [number, number][]> = {
|
||||
1: [[0.5, 0.5]],
|
||||
2: [
|
||||
[0.25, 0.25],
|
||||
[0.75, 0.75],
|
||||
],
|
||||
3: [
|
||||
[0.25, 0.25],
|
||||
[0.5, 0.5],
|
||||
[0.75, 0.75],
|
||||
],
|
||||
4: [
|
||||
[0.25, 0.25],
|
||||
[0.75, 0.25],
|
||||
[0.25, 0.75],
|
||||
[0.75, 0.75],
|
||||
],
|
||||
5: [
|
||||
[0.25, 0.25],
|
||||
[0.75, 0.25],
|
||||
[0.5, 0.5],
|
||||
[0.25, 0.75],
|
||||
[0.75, 0.75],
|
||||
],
|
||||
6: [
|
||||
[0.25, 0.25],
|
||||
[0.75, 0.25],
|
||||
[0.25, 0.5],
|
||||
[0.75, 0.5],
|
||||
[0.25, 0.75],
|
||||
[0.75, 0.75],
|
||||
],
|
||||
};
|
||||
|
||||
/** Les dés, au milieu de la moitié droite. */
|
||||
function drawDice(svg: SVGSVGElement, dice: readonly ShownDie[]): void {
|
||||
const center = RIGHT_HALF + HALF_WIDTH / 2;
|
||||
const gap = 8;
|
||||
const total = dice.length * DIE + (dice.length - 1) * gap;
|
||||
dice.forEach((die, i) => {
|
||||
const x = center - total / 2 + i * (DIE + gap);
|
||||
const y = MIDDLE - DIE / 2;
|
||||
const group = add(svg, "g", {
|
||||
class: die.blocked ? "die die-blocked" : "die",
|
||||
"data-value": die.value,
|
||||
});
|
||||
add(group, "rect", { class: `die-${die.side}`, x, y, width: DIE, height: DIE, rx: 6 });
|
||||
for (const [px, py] of PIPS[die.value] ?? []) {
|
||||
add(group, "circle", {
|
||||
class: `pip-${die.side}`,
|
||||
cx: x + px * DIE,
|
||||
cy: y + py * DIE,
|
||||
r: 3.5,
|
||||
});
|
||||
}
|
||||
if (die.blocked) {
|
||||
add(group, "line", { class: "die-strike", x1: x, y1: y + DIE, x2: x + DIE, y2: y });
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/** Le videau, dans le plateau de sortie : au milieu s'il est au centre,
|
||||
* sinon du côté de son propriétaire. Au centre, il montre 64. */
|
||||
function drawCube(svg: SVGSVGElement, cube: Cube): SVGElement {
|
||||
const center = cubeCenter(cube);
|
||||
const x = center.x - CUBE / 2;
|
||||
const y = center.y - CUBE / 2;
|
||||
const group = add(svg, "g", { class: "cube", "data-owner": cube.owner ?? "center" });
|
||||
add(group, "rect", { class: "cube-face", x, y, width: CUBE, height: CUBE, rx: 4 });
|
||||
add(
|
||||
group,
|
||||
"text",
|
||||
{ class: "cube-value", x: center.x, y: center.y + 6 },
|
||||
String(cube.owner === null ? 64 : cube.value),
|
||||
);
|
||||
return group;
|
||||
}
|
||||
|
||||
/** Le centre du videau dans le plateau de sortie. */
|
||||
function cubeCenter(cube: Cube): Spot {
|
||||
const shift = cube.owner === "computer" ? -48 : cube.owner === "player" ? 48 : 0;
|
||||
return { x: TRAY_LEFT + TRAY_WIDTH / 2, y: MIDDLE + shift };
|
||||
}
|
||||
|
||||
/** Les dés du joueur en attente d'être lancés, faces vides, au milieu de la
|
||||
* moitié gauche (la droite garde le dernier jet de l'ordinateur). Renvoie
|
||||
* leur centre. */
|
||||
function waitingDice(svg: SVGSVGElement): Spot {
|
||||
const center = { x: FRAME + HALF_WIDTH / 2, y: MIDDLE };
|
||||
const gap = 8;
|
||||
const group = add(svg, "g", { class: "die die-waiting" });
|
||||
for (const x of [center.x - gap / 2 - DIE, center.x + gap / 2]) {
|
||||
add(group, "rect", {
|
||||
class: "die-player",
|
||||
x,
|
||||
y: MIDDLE - DIE / 2,
|
||||
width: DIE,
|
||||
height: DIE,
|
||||
rx: 6,
|
||||
});
|
||||
}
|
||||
return center;
|
||||
}
|
||||
|
||||
/**
|
||||
* Une zone à toucher qui fait la même chose qu'un bouton (lancer les dés,
|
||||
* doubler) : au moins MIN_TARGET de côté, centrée sur ce qu'on touche, avec
|
||||
* un rôle et un nom accessibles. Les boutons restent pour le clavier.
|
||||
*/
|
||||
function addAction(
|
||||
hits: Element,
|
||||
action: string,
|
||||
label: string,
|
||||
center: Spot,
|
||||
width: number,
|
||||
): void {
|
||||
add(hits, "rect", {
|
||||
class: "hit action",
|
||||
"data-action": action,
|
||||
role: "button",
|
||||
"aria-label": label,
|
||||
// Sans déborder du dessin à droite (le videau est contre le bord).
|
||||
x: Math.min(center.x - width / 2, WIDTH - width),
|
||||
y: center.y - MIN_TARGET / 2,
|
||||
width,
|
||||
height: MIN_TARGET,
|
||||
});
|
||||
}
|
||||
|
||||
/** Une zone à toucher. Elle porte son état (can-move, can-land) pour les
|
||||
* tests dans un navigateur. */
|
||||
function addHit(
|
||||
hits: Element,
|
||||
place: Place,
|
||||
decor: BoardDecor,
|
||||
box: { x: number; y: number; width: number; height: number },
|
||||
): void {
|
||||
const classes = ["hit"];
|
||||
if (decor.movable.has(place)) {
|
||||
classes.push("can-move");
|
||||
}
|
||||
if (decor.targets.has(place)) {
|
||||
classes.push("can-land");
|
||||
}
|
||||
add(hits, "rect", { class: classes.join(" "), "data-place": place, ...box });
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
// Lecture des textes de l'aide : les scénarios (docs/scenarios/) et les
|
||||
// fiches du glossaire (docs/glossaire/), copiés tels quels dans le site par
|
||||
// make site (ADR 0008 : une seule source). Fonctions pures, testées sous Node.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
/** Un scénario, mis en forme comme une page d'aide. */
|
||||
export interface HelpFeature {
|
||||
readonly title: string;
|
||||
/** Paragraphes d'introduction. */
|
||||
readonly description: readonly string[];
|
||||
readonly scenarios: readonly HelpScenario[];
|
||||
}
|
||||
|
||||
export interface HelpScenario {
|
||||
readonly title: string;
|
||||
readonly description: readonly string[];
|
||||
/** Les étapes, mot-clé compris : « Quand vous prenez ». */
|
||||
readonly steps: readonly string[];
|
||||
}
|
||||
|
||||
const STEP = /^(Étant donnée?s?|Etant donnée?s?|Soit|Quand|Lorsque|Alors|Donc|Et|Mais)\s/;
|
||||
const SCENARIO = /^(Scénario|Exemple|Contexte)\s*:\s*(.*)$/;
|
||||
const FEATURE = /^Fonctionnalité\s*:\s*(.*)$/;
|
||||
|
||||
/**
|
||||
* Lit un fichier Gherkin en français (fichiers .feature). Les lignes de texte
|
||||
* libre consécutives forment un paragraphe ; les commentaires (#) sont
|
||||
* ignorés.
|
||||
*/
|
||||
export function parseFeature(text: string): HelpFeature {
|
||||
let title = "";
|
||||
const description: string[] = [];
|
||||
const scenarios: { title: string; description: string[]; steps: string[] }[] = [];
|
||||
let paragraph: string[] = [];
|
||||
|
||||
// Le paragraphe en cours rejoint la description de la fonctionnalité ou
|
||||
// du dernier scénario.
|
||||
const endParagraph = () => {
|
||||
if (paragraph.length > 0) {
|
||||
(scenarios.at(-1)?.description ?? description).push(paragraph.join(" "));
|
||||
paragraph = [];
|
||||
}
|
||||
};
|
||||
|
||||
for (const raw of text.split("\n")) {
|
||||
const line = raw.trim();
|
||||
const feature = FEATURE.exec(line);
|
||||
const scenario = SCENARIO.exec(line);
|
||||
if (line === "" || line.startsWith("#")) {
|
||||
endParagraph();
|
||||
} else if (feature) {
|
||||
endParagraph();
|
||||
title = feature[1] ?? "";
|
||||
} else if (scenario) {
|
||||
endParagraph();
|
||||
scenarios.push({ title: scenario[2] ?? "", description: [], steps: [] });
|
||||
} else if (STEP.test(line) && scenarios.length > 0) {
|
||||
endParagraph();
|
||||
scenarios.at(-1)?.steps.push(line);
|
||||
} else {
|
||||
paragraph.push(line);
|
||||
}
|
||||
}
|
||||
endParagraph();
|
||||
return { title, description, scenarios };
|
||||
}
|
||||
|
||||
/** Les fiches citées par l'index du glossaire (README.md), dans l'ordre :
|
||||
* les liens « [Terme](fichier.md) » de la section « Termes ». */
|
||||
export function parseGlossaryIndex(readme: string): string[] {
|
||||
const section = readme.split(/^## Termes$/m)[1] ?? "";
|
||||
return [...section.matchAll(/\]\(([a-z0-9-]+\.md)\)/g)].map((match) => match[1] ?? "");
|
||||
}
|
||||
|
||||
/** Une fiche du glossaire : le terme et sa phrase « En bref ». */
|
||||
export interface GlossaryEntry {
|
||||
readonly term: string;
|
||||
readonly brief: string;
|
||||
}
|
||||
|
||||
/** Lit une fiche du glossaire ; null si elle n'a pas la forme attendue. */
|
||||
export function parseGlossaryEntry(text: string): GlossaryEntry | null {
|
||||
const term = /^term: (.+)$/m.exec(text)?.[1]?.trim();
|
||||
const brief = /^\*\*En bref\*\* : (.+)$/m.exec(text)?.[1]?.trim();
|
||||
if (term === undefined || brief === undefined) {
|
||||
return null;
|
||||
}
|
||||
return { term, brief: brief.replaceAll("**", "") };
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
// La page d'aide : le scénario « Jouer une partie contre l'ordinateur » et le
|
||||
// glossaire, lus à l'exécution dans les copies de docs/ faites par make site
|
||||
// (ADR 0008). Rien n'est recopié dans le code.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import {
|
||||
type GlossaryEntry,
|
||||
type HelpFeature,
|
||||
parseFeature,
|
||||
parseGlossaryEntry,
|
||||
parseGlossaryIndex,
|
||||
} from "./help-text.js";
|
||||
import { TEXTS } from "./texts.js";
|
||||
|
||||
/** Les scénarios montrés dans l'aide, dans l'ordre. */
|
||||
const FEATURES = ["docs/scenarios/jouer-une-partie.feature"];
|
||||
const GLOSSARY = "docs/glossaire/";
|
||||
|
||||
async function fetchText(url: string): Promise<string> {
|
||||
const response = await fetch(url);
|
||||
if (!response.ok) {
|
||||
throw new Error(`${url} : ${response.status}`);
|
||||
}
|
||||
return response.text();
|
||||
}
|
||||
|
||||
async function loadGlossary(): Promise<GlossaryEntry[]> {
|
||||
const files = parseGlossaryIndex(await fetchText(`${GLOSSARY}README.md`));
|
||||
const texts = await Promise.all(files.map((file) => fetchText(GLOSSARY + file)));
|
||||
return texts.map(parseGlossaryEntry).filter((entry) => entry !== null);
|
||||
}
|
||||
|
||||
function element<K extends keyof HTMLElementTagNameMap>(
|
||||
parent: HTMLElement,
|
||||
tag: K,
|
||||
text?: string,
|
||||
): HTMLElementTagNameMap[K] {
|
||||
const child = document.createElement(tag);
|
||||
if (text !== undefined) {
|
||||
child.textContent = text;
|
||||
}
|
||||
parent.append(child);
|
||||
return child;
|
||||
}
|
||||
|
||||
function renderFeature(parent: HTMLElement, feature: HelpFeature): void {
|
||||
element(parent, "h2", feature.title);
|
||||
for (const paragraph of feature.description) {
|
||||
element(parent, "p", paragraph);
|
||||
}
|
||||
for (const scenario of feature.scenarios) {
|
||||
element(parent, "h3", scenario.title);
|
||||
for (const paragraph of scenario.description) {
|
||||
element(parent, "p", paragraph);
|
||||
}
|
||||
const steps = element(parent, "ul");
|
||||
steps.className = "steps";
|
||||
for (const step of scenario.steps) {
|
||||
element(steps, "li", step);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function renderGlossary(parent: HTMLElement, entries: readonly GlossaryEntry[]): void {
|
||||
element(parent, "h2", TEXTS.glossaryTitle);
|
||||
const list = element(parent, "dl");
|
||||
list.className = "glossary";
|
||||
for (const entry of entries) {
|
||||
element(list, "dt", entry.term);
|
||||
element(list, "dd", entry.brief);
|
||||
}
|
||||
}
|
||||
|
||||
/** Remplit container avec l'aide (une seule fois ; les appels suivants ne
|
||||
* font rien). */
|
||||
export async function showHelp(container: HTMLElement): Promise<void> {
|
||||
if (container.dataset.loaded === "true") {
|
||||
return;
|
||||
}
|
||||
container.replaceChildren();
|
||||
const status = element(container, "p", TEXTS.helpLoading);
|
||||
try {
|
||||
const [features, glossary] = await Promise.all([
|
||||
Promise.all(FEATURES.map(async (url) => parseFeature(await fetchText(url)))),
|
||||
loadGlossary(),
|
||||
]);
|
||||
status.remove();
|
||||
for (const feature of features) {
|
||||
renderFeature(container, feature);
|
||||
}
|
||||
renderGlossary(container, glossary);
|
||||
const about = element(container, "p", `${TEXTS.about} `);
|
||||
about.className = "about";
|
||||
const link = element(about, "a", TEXTS.engineTestLink);
|
||||
link.href = "moteur/";
|
||||
container.dataset.loaded = "true";
|
||||
} catch {
|
||||
status.textContent = TEXTS.helpFailed;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
// Les textes de l'interface (ADR 0007, point 5), en français, avec les mots
|
||||
// du glossaire (docs/glossaire/). Le code n'écrit aucun texte lui-même : il
|
||||
// prend tout ici.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import type { ResultKind } from "../domain/game/engine.js";
|
||||
|
||||
/** Un jet écrit « 6-4 ». */
|
||||
function roll(dice: readonly number[]): string {
|
||||
return dice.join("-");
|
||||
}
|
||||
|
||||
const RESULT_KIND: Record<ResultKind, string> = {
|
||||
single: "la partie simple",
|
||||
gammon: "un gammon",
|
||||
backgammon: "un backgammon",
|
||||
};
|
||||
|
||||
function points(n: number): string {
|
||||
return n > 1 ? `${n} points` : `${n} point`;
|
||||
}
|
||||
|
||||
/** Une durée en secondes, avec une décimale : « 0,3 s ». */
|
||||
function seconds(ms: number): string {
|
||||
return `${(ms / 1000).toFixed(1).replace(".", ",")} s`;
|
||||
}
|
||||
|
||||
export const TEXTS = {
|
||||
title: "Ustagammon",
|
||||
boardLabel: "Plateau de backgammon",
|
||||
|
||||
// Boutons
|
||||
roll: "Lancer les dés",
|
||||
double: "Doubler",
|
||||
take: "Prendre",
|
||||
drop: "Passer",
|
||||
cancel: "Annuler",
|
||||
skip: "Continuer",
|
||||
replay: "Revoir",
|
||||
replayTitle: "Revoir le dernier coup de l'ordinateur",
|
||||
newGame: "Nouvelle partie",
|
||||
help: "Aide",
|
||||
back: "Retour à la partie",
|
||||
|
||||
// Chargement
|
||||
loading: "Chargement du moteur…",
|
||||
engineFailed: (message: string) => `Le moteur n'a pas pu se charger : ${message}`,
|
||||
actionFailed: (message: string) => `Erreur : ${message}`,
|
||||
confirmNewGame: "Abandonner la partie en cours et en commencer une nouvelle ?",
|
||||
|
||||
// Déroulement
|
||||
opening: (player: number, computer: number) =>
|
||||
`Jet d'ouverture : vous ${player}, l'ordinateur ${computer}. ${
|
||||
player > computer ? "Vous commencez." : "L'ordinateur commence."
|
||||
}`,
|
||||
yourRoll: "À vous : doublez ou lancez les dés.",
|
||||
yourRollNoDouble: "À vous : lancez les dés.",
|
||||
yourMove: (dice: readonly number[]) =>
|
||||
`Jouez ${roll(dice)} : touchez un pion, puis sa case d'arrivée.`,
|
||||
pickTarget: "Touchez une case d'arrivée en surbrillance, ou un autre pion.",
|
||||
youCannotMove: (dice: readonly number[]) => `Aucun coup possible avec ${roll(dice)}.`,
|
||||
pressContinue: "Touchez « Continuer » : le tour passe à l'ordinateur.",
|
||||
thinking: "L'ordinateur réfléchit…",
|
||||
computerMoved: (dice: readonly number[], move: string, ms: number) =>
|
||||
`L'ordinateur a joué ${roll(dice)} : ${move} (${seconds(ms)}).`,
|
||||
computerCannotMove: (dice: readonly number[]) =>
|
||||
`L'ordinateur ne peut pas jouer ${roll(dice)}.`,
|
||||
computerDoubles: "L'ordinateur vous propose de doubler : prenez ou passez.",
|
||||
computerTakes: (value: number) =>
|
||||
`L'ordinateur prend : la partie vaut maintenant ${points(value)}.`,
|
||||
youTook: (value: number) =>
|
||||
`Vous prenez : la partie vaut maintenant ${points(value)}, et le videau est chez vous.`,
|
||||
|
||||
// Fin de partie
|
||||
youWin: (kind: ResultKind, n: number) => `Vous gagnez ${RESULT_KIND[kind]} : ${points(n)}.`,
|
||||
youLose: (kind: ResultKind, n: number) =>
|
||||
`L'ordinateur gagne ${RESULT_KIND[kind]} : ${points(n)} pour lui.`,
|
||||
computerDropped: (n: number) => `L'ordinateur passe : vous gagnez ${points(n)}.`,
|
||||
youDropped: (n: number) => `Vous passez : l'ordinateur gagne ${points(n)}.`,
|
||||
|
||||
// Sous le plateau
|
||||
pipCounts: (player: number, computer: number) =>
|
||||
`Compte de points : vous ${player}, l'ordinateur ${computer}`,
|
||||
|
||||
// Aide
|
||||
helpTitle: "Aide",
|
||||
glossaryTitle: "Glossaire",
|
||||
helpLoading: "Chargement de l'aide…",
|
||||
helpFailed: "L'aide n'a pas pu se charger.",
|
||||
about: "Ustagammon est un logiciel libre (GPLv3). L'ordinateur joue avec GNU Backgammon.",
|
||||
engineTestLink: "Test du moteur",
|
||||
} as const;
|
||||
@@ -0,0 +1,37 @@
|
||||
// Le moteur WebAssembly répond indéfiniment : une partie en navigateur
|
||||
// envoie des centaines de commandes au même moteur chargé une fois.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Régression : callMain (Emscripten) laisse ses arguments sur la pile du
|
||||
// WebAssembly (64 Ko). Sans remise en place après chaque commande
|
||||
// (web/engine-wasm.mjs), la pile débordait vers la 500e commande : erreur
|
||||
// « memory access out of bounds » sous Node, moteur muet dans Firefox,
|
||||
// onglet planté dans Chromium.
|
||||
|
||||
import assert from "node:assert/strict";
|
||||
import { test } from "node:test";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
// Compilé dans build/web/tests/ : la racine du dépôt est trois dossiers plus
|
||||
// haut.
|
||||
const root = new URL("../../../", import.meta.url);
|
||||
|
||||
interface RawEngine {
|
||||
runText(args: string[]): { text: string; exitCode: number };
|
||||
}
|
||||
|
||||
test("le moteur répond à 3000 commandes à la suite", async () => {
|
||||
const module = await import(new URL("build/wasm/engine.mjs", root).href);
|
||||
const wrapper = await import(new URL("web/engine-wasm.mjs", root).href);
|
||||
const engine: RawEngine = await wrapper.loadEngine(
|
||||
module.default,
|
||||
fileURLToPath(new URL("build/wasm/", root)),
|
||||
);
|
||||
for (let i = 0; i < 3000; i++) {
|
||||
const { text, exitCode } = engine.runText(["position", "4HPwATDgc/ABMA", "AQEAAAAAAAAA"]);
|
||||
assert.equal(exitCode, 0, `commande ${i}`);
|
||||
assert.match(text, /"pip_count": 167/, `commande ${i}`);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,73 @@
|
||||
// Une partie complète sur le vrai moteur WebAssembly, avec des dés imposés :
|
||||
// l'ordinateur contre une stratégie simple du joueur (toujours le premier
|
||||
// coup légal, saisi demi-coup par demi-coup, et toujours prendre).
|
||||
//
|
||||
// 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 { Game } from "../src/domain/game/game.js";
|
||||
import type { DiceSource } from "../src/domain/game/roll.js";
|
||||
import { replay } from "../src/domain/game/state.js";
|
||||
import { loadNodeEngine } from "./support/node-engine.js";
|
||||
|
||||
/** Des dés pseudo-aléatoires reproductibles (générateur congruentiel). */
|
||||
function seededDice(seed: number): DiceSource {
|
||||
let state = seed;
|
||||
return () => {
|
||||
state = (state * 1103515245 + 12345) % 2147483648;
|
||||
return 1 + (Math.floor(state / 65536) % 6);
|
||||
};
|
||||
}
|
||||
|
||||
/** Joue jusqu'à la fin ; renvoie le nombre d'actions. */
|
||||
async function playToTheEnd(game: Game, engine: Awaited<ReturnType<typeof loadNodeEngine>>) {
|
||||
let actions = 0;
|
||||
while (game.state.phase !== "over") {
|
||||
assert.ok(++actions < 2000, "la partie ne finit pas");
|
||||
const state = game.state;
|
||||
if (state.turn === "computer" && state.phase === "doubled") {
|
||||
game.take();
|
||||
} else if (state.turn === "computer") {
|
||||
await game.playComputerTurn();
|
||||
} else if (state.phase === "rolling") {
|
||||
await game.roll();
|
||||
} else {
|
||||
assert.ok(state.roll !== null);
|
||||
const [first] = await engine.legalMoves(state.position, state.roll);
|
||||
if (first === undefined) {
|
||||
// Aucun coup possible : le joueur laisse passer son tour.
|
||||
assert.equal(await game.cannotMove(), true);
|
||||
await game.skipTurn();
|
||||
continue;
|
||||
}
|
||||
for (const halfMove of first.halfMoves) {
|
||||
assert.equal(await game.playHalfMove(halfMove), true);
|
||||
}
|
||||
}
|
||||
}
|
||||
return actions;
|
||||
}
|
||||
|
||||
for (const [seed, ply] of [
|
||||
[1, 0],
|
||||
[7, 2],
|
||||
] as const) {
|
||||
test(`partie complète, dés ${seed}, ordinateur à ${ply} pli(s)`, async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, { dice: seededDice(seed), ply });
|
||||
await playToTheEnd(game, engine);
|
||||
|
||||
const events = game.events;
|
||||
const last = events.at(-1);
|
||||
assert.equal(last?.type, "GameEnded");
|
||||
const result = game.state.result;
|
||||
assert.ok(result !== null);
|
||||
assert.ok(result.points >= 1);
|
||||
assert.ok(events.some((e) => e.type === "MovePlayed" && e.side === "player"));
|
||||
assert.ok(events.some((e) => e.type === "MovePlayed" && e.side === "computer"));
|
||||
// Rejouer le journal redonne le même état.
|
||||
assert.deepEqual(replay(events), game.state);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,295 @@
|
||||
// Tests unitaires du domaine « partie », avec un faux moteur (ADR 0007,
|
||||
// point 7) : journal, rejeu, branches, déroulement des tours et du videau.
|
||||
//
|
||||
// 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 {
|
||||
Board,
|
||||
CubeDecision,
|
||||
Engine,
|
||||
HalfMovesCheck,
|
||||
Move,
|
||||
} from "../src/domain/game/engine.js";
|
||||
import { appendEvent, currentLine, EMPTY_JOURNAL, goBackTo } from "../src/domain/game/events.js";
|
||||
import { Game } from "../src/domain/game/game.js";
|
||||
import { formatHalfMoves, parseHalfMoves, START_POSITION } from "../src/domain/game/position.js";
|
||||
import { fixedDice } from "../src/domain/game/roll.js";
|
||||
import { replay } from "../src/domain/game/state.js";
|
||||
|
||||
/** Un faux moteur : chaque réponse est réglable, et les positions sont des
|
||||
* textes sans signification. */
|
||||
function fakeEngine(overrides: Partial<Engine> = {}): Engine {
|
||||
const move: Move = {
|
||||
notation: "8/5 6/5",
|
||||
halfMoves: parseHalfMoves("8/5 6/5"),
|
||||
position: "AFTER",
|
||||
};
|
||||
const notOver: Board = {
|
||||
onRoll: { points: [], bar: 0, off: 0, pipCount: 0 },
|
||||
opponent: { points: [], bar: 0, off: 0, pipCount: 0 },
|
||||
swappedPosition: "SWAPPED",
|
||||
result: null,
|
||||
};
|
||||
const noDouble: CubeDecision = { available: true, double: false, take: true };
|
||||
return {
|
||||
legalMoves: async () => [move],
|
||||
bestMove: async () => move,
|
||||
cubeDecision: async () => noDouble,
|
||||
checkHalfMoves: async (_position, _roll, halfMoves): Promise<HalfMovesCheck> => {
|
||||
const text = formatHalfMoves(halfMoves);
|
||||
if (text === "8/5") {
|
||||
return { valid: true, complete: false, position: "HALF" };
|
||||
}
|
||||
if (text === "8/5 6/5") {
|
||||
return { valid: true, complete: true, position: "AFTER" };
|
||||
}
|
||||
return { valid: false, complete: false, position: null };
|
||||
},
|
||||
board: async () => notOver,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
test("le jet d'ouverture se relance en cas d'égalité, puis le plus fort dé commence", () => {
|
||||
const game = Game.start(fakeEngine(), { dice: fixedDice([4, 4, 2, 5]) });
|
||||
const rolls = game.events.filter((e) => e.type === "DiceRolled");
|
||||
assert.deepEqual(
|
||||
rolls.map((e) => e.roll),
|
||||
[
|
||||
[4, 4],
|
||||
[2, 5],
|
||||
],
|
||||
);
|
||||
assert.equal(game.state.turn, "computer");
|
||||
assert.equal(game.state.phase, "moving");
|
||||
assert.deepEqual(game.state.roll, [2, 5]);
|
||||
assert.equal(game.state.position, START_POSITION);
|
||||
});
|
||||
|
||||
test("un coup se saisit demi-coup par demi-coup ; un demi-coup refusé ne change rien", async () => {
|
||||
const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1]) });
|
||||
assert.equal(await game.playHalfMove({ from: 13, to: 12 }), false);
|
||||
assert.equal(game.events.length, 2);
|
||||
assert.equal(await game.playHalfMove({ from: 8, to: 5 }), true);
|
||||
assert.equal(game.displayedPosition, "HALF");
|
||||
assert.deepEqual(game.pendingHalfMoves, [{ from: 8, to: 5 }]);
|
||||
assert.equal(await game.playHalfMove({ from: 6, to: 5 }), true);
|
||||
|
||||
const last = game.events.at(-1);
|
||||
assert.equal(last?.type, "MovePlayed");
|
||||
assert.deepEqual(game.pendingHalfMoves, []);
|
||||
assert.equal(game.state.turn, "computer");
|
||||
assert.equal(game.state.phase, "rolling");
|
||||
assert.equal(game.state.position, "SWAPPED");
|
||||
});
|
||||
|
||||
test("sans coup possible, le tour passe quand le joueur le laisse passer", async () => {
|
||||
const engine = fakeEngine({ legalMoves: async () => [] });
|
||||
const game = Game.start(engine, {
|
||||
dice: fixedDice([6, 6]),
|
||||
setup: { position: "BLOCKED", firstTurn: "player" },
|
||||
});
|
||||
await game.roll();
|
||||
// Le tour ne passe pas tout seul : le jet reste à « jouer ».
|
||||
assert.equal(game.state.phase, "moving");
|
||||
assert.equal(game.state.turn, "player");
|
||||
assert.equal(await game.cannotMove(), true);
|
||||
await game.skipTurn();
|
||||
const last = game.events.at(-1);
|
||||
assert.ok(last?.type === "MovePlayed");
|
||||
assert.deepEqual(last.halfMoves, []);
|
||||
assert.equal(game.state.turn, "computer");
|
||||
});
|
||||
|
||||
test("le joueur ne peut pas laisser passer son tour s'il a un coup", async () => {
|
||||
const engine = fakeEngine({
|
||||
legalMoves: async () => [
|
||||
{ notation: "8/5", halfMoves: [{ from: 8, to: 5 }], position: "P" },
|
||||
],
|
||||
});
|
||||
const game = Game.start(engine, {
|
||||
dice: fixedDice([3, 1]),
|
||||
setup: { position: "X", firstTurn: "player" },
|
||||
});
|
||||
await game.roll();
|
||||
assert.equal(await game.cannotMove(), false);
|
||||
await assert.rejects(game.skipTurn(), /coup possible/);
|
||||
assert.equal(game.state.phase, "moving");
|
||||
});
|
||||
|
||||
test("l'ordinateur double si le moteur le recommande ; le joueur prend", async () => {
|
||||
const engine = fakeEngine({
|
||||
cubeDecision: async () => ({ available: true, double: true, take: true }),
|
||||
});
|
||||
const game = Game.start(engine, { setup: { position: "X", firstTurn: "computer" } });
|
||||
await game.playComputerTurn();
|
||||
assert.equal(game.state.phase, "doubled");
|
||||
game.take();
|
||||
assert.deepEqual(game.state.cube, { value: 2, owner: "player" });
|
||||
assert.equal(game.state.phase, "rolling");
|
||||
assert.equal(game.state.turn, "computer");
|
||||
});
|
||||
|
||||
test("le joueur passe : il perd la partie à la valeur d'avant le double", async () => {
|
||||
const engine = fakeEngine({
|
||||
cubeDecision: async () => ({ available: true, double: true, take: true }),
|
||||
});
|
||||
const game = Game.start(engine, {
|
||||
setup: { position: "X", firstTurn: "computer", cube: { value: 2, owner: "computer" } },
|
||||
});
|
||||
await game.playComputerTurn();
|
||||
game.drop();
|
||||
assert.equal(game.state.phase, "over");
|
||||
assert.deepEqual(game.state.result, { winner: "computer", kind: "single", points: 2 });
|
||||
});
|
||||
|
||||
test("le joueur double : l'ordinateur passe si le moteur le dit", async () => {
|
||||
const engine = fakeEngine({
|
||||
cubeDecision: async () => ({ available: true, double: true, take: false }),
|
||||
});
|
||||
const game = Game.start(engine, { setup: { position: "X", firstTurn: "player" } });
|
||||
await game.double();
|
||||
assert.deepEqual(
|
||||
game.events.slice(-3).map((e) => e.type),
|
||||
["CubeOffered", "CubeDropped", "GameEnded"],
|
||||
);
|
||||
assert.deepEqual(game.state.result, { winner: "player", kind: "single", points: 1 });
|
||||
});
|
||||
|
||||
test("le joueur ne peut pas doubler si le videau est chez l'ordinateur", async () => {
|
||||
const engine = fakeEngine({
|
||||
cubeDecision: async () => ({ available: false, double: false, take: true }),
|
||||
});
|
||||
const game = Game.start(engine, {
|
||||
setup: { position: "X", firstTurn: "player", cube: { value: 2, owner: "computer" } },
|
||||
});
|
||||
await assert.rejects(game.double(), /videau/);
|
||||
assert.equal(game.events.length, 1);
|
||||
});
|
||||
|
||||
test("la fin de partie vient du moteur : gagnant, sorte et points", async () => {
|
||||
const engine = fakeEngine({
|
||||
board: async () => ({
|
||||
onRoll: { points: [], bar: 0, off: 15, pipCount: 0 },
|
||||
opponent: { points: [], bar: 0, off: 0, pipCount: 100 },
|
||||
swappedPosition: "SWAPPED",
|
||||
result: { winner: "onRoll", kind: "gammon", points: 2 },
|
||||
}),
|
||||
});
|
||||
const game = Game.start(engine, {
|
||||
setup: { position: "X", firstTurn: "computer" },
|
||||
dice: fixedDice([2, 1]),
|
||||
});
|
||||
await game.playComputerTurn();
|
||||
assert.deepEqual(game.state.result, { winner: "computer", kind: "gammon", points: 2 });
|
||||
assert.throws(() => game.take(), /action impossible/);
|
||||
});
|
||||
|
||||
test("annuler repart du parent ; l'action suivante ouvre une branche", async () => {
|
||||
const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1, 6, 5, 4, 2]) });
|
||||
await game.playHalfMove({ from: 8, to: 5 });
|
||||
await game.playHalfMove({ from: 6, to: 5 });
|
||||
const played = game.events.at(-1);
|
||||
assert.equal(played?.type, "MovePlayed");
|
||||
|
||||
game.undo();
|
||||
assert.equal(game.state.phase, "moving");
|
||||
assert.equal(game.state.turn, "player");
|
||||
await game.playHalfMove({ from: 8, to: 5 });
|
||||
await game.playHalfMove({ from: 6, to: 5 });
|
||||
|
||||
// Deux coups accrochés au même jet : l'ancien reste dans le journal.
|
||||
const moves = game.journal.events.filter((e) => e.type === "MovePlayed");
|
||||
assert.equal(moves.length, 2);
|
||||
assert.equal(moves[0]?.parent, moves[1]?.parent);
|
||||
assert.notEqual(game.events.at(-1)?.id, played?.id);
|
||||
|
||||
game.goBackTo(played?.id ?? "");
|
||||
assert.equal(game.events.at(-1)?.id, played?.id);
|
||||
});
|
||||
|
||||
test("les événements sont immuables et versionnés ; le rejeu est déterministe", () => {
|
||||
let journal = appendEvent(EMPTY_JOURNAL, {
|
||||
type: "GameStarted",
|
||||
position: START_POSITION,
|
||||
cube: { value: 1, owner: null },
|
||||
firstTurn: null,
|
||||
});
|
||||
journal = appendEvent(journal, { type: "DiceRolled", side: null, roll: [5, 2] });
|
||||
const [started, rolled] = currentLine(journal);
|
||||
assert.equal(started?.version, 1);
|
||||
assert.equal(started?.parent, null);
|
||||
assert.equal(rolled?.parent, started?.id);
|
||||
assert.throws(() => {
|
||||
(rolled as { parent: string | null }).parent = null;
|
||||
}, TypeError);
|
||||
assert.deepEqual(replay(currentLine(journal)), replay(currentLine(journal)));
|
||||
assert.equal(replay(currentLine(goBackTo(journal, "1"))).phase, "opening");
|
||||
});
|
||||
|
||||
test("lecture et écriture des demi-coups", () => {
|
||||
assert.deepEqual(parseHalfMoves("bar/22 6/off"), [
|
||||
{ from: 25, to: 22 },
|
||||
{ from: 6, to: 0 },
|
||||
]);
|
||||
assert.equal(formatHalfMoves(parseHalfMoves(" 8/5 6/5 ")), "8/5 6/5");
|
||||
assert.throws(() => parseHalfMoves("8-5"), /mal formé/);
|
||||
assert.throws(() => parseHalfMoves("30/5"), /case invalide/);
|
||||
});
|
||||
|
||||
test("une partie se reprend depuis son journal ; un journal d'une autre version est refusé", async () => {
|
||||
const game = Game.start(fakeEngine(), { dice: fixedDice([3, 1]) });
|
||||
await game.playHalfMove({ from: 8, to: 5 });
|
||||
await game.playHalfMove({ from: 6, to: 5 });
|
||||
const saved = JSON.parse(JSON.stringify(game.journal));
|
||||
|
||||
const resumed = Game.resume(fakeEngine(), saved);
|
||||
assert.deepEqual(resumed.state, game.state);
|
||||
assert.deepEqual(resumed.events, game.events);
|
||||
|
||||
const other = { ...saved, events: saved.events.map((e: object) => ({ ...e, version: 99 })) };
|
||||
assert.throws(() => Game.resume(fakeEngine(), other), /version/);
|
||||
assert.throws(() => Game.resume(fakeEngine(), EMPTY_JOURNAL), /mal formé/);
|
||||
assert.throws(() => Game.resume(fakeEngine(), { ...saved, head: "inconnu" }), /introuvable/);
|
||||
});
|
||||
|
||||
test("le droit de doubler vient du moteur, seulement avant de lancer les dés", async () => {
|
||||
let available = true;
|
||||
const engine = fakeEngine({
|
||||
cubeDecision: async () => ({ available, double: false, take: true }),
|
||||
});
|
||||
const game = Game.start(engine, {
|
||||
dice: fixedDice([3, 1]),
|
||||
setup: { position: "X", firstTurn: "player" },
|
||||
});
|
||||
assert.equal(await game.canDouble(), true);
|
||||
available = false;
|
||||
assert.equal(await game.canDouble(), false);
|
||||
available = true;
|
||||
await game.roll();
|
||||
assert.equal(game.state.phase, "moving");
|
||||
assert.equal(await game.canDouble(), false);
|
||||
});
|
||||
|
||||
test("le plateau affiché est donné du point de vue de chaque camp", async () => {
|
||||
const side = (pipCount: number) => ({ points: [], bar: 0, off: 0, pipCount });
|
||||
const engine = fakeEngine({
|
||||
board: async () => ({
|
||||
onRoll: side(1),
|
||||
opponent: side(2),
|
||||
swappedPosition: "SWAPPED",
|
||||
result: null,
|
||||
}),
|
||||
});
|
||||
const playerTurn = Game.start(engine, { setup: { position: "X", firstTurn: "player" } });
|
||||
const sides = await playerTurn.displayedBoard();
|
||||
assert.equal(sides.player.pipCount, 1);
|
||||
assert.equal(sides.computer.pipCount, 2);
|
||||
const computerTurn = Game.start(engine, { setup: { position: "X", firstTurn: "computer" } });
|
||||
const swapped = await computerTurn.displayedBoard();
|
||||
assert.equal(swapped.player.pipCount, 2);
|
||||
assert.equal(swapped.computer.pipCount, 1);
|
||||
});
|
||||
@@ -0,0 +1,143 @@
|
||||
// Un coup demi-coup par demi-coup (Game.lastMoveSteps), sur le vrai moteur
|
||||
// WebAssembly : les plateaux intermédiaires que l'interface anime, et les
|
||||
// pions frappés qu'elle signale.
|
||||
//
|
||||
// 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 { BoardSide } from "../src/domain/game/engine.js";
|
||||
import { Game } from "../src/domain/game/game.js";
|
||||
import {
|
||||
BAR,
|
||||
formatHalfMoves,
|
||||
type PositionId,
|
||||
parseHalfMoves,
|
||||
} 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 13, quatorze sur sa case 6.
|
||||
// L'ordinateur : un blot sur la case 10 du joueur (sa case 15), quatorze sur
|
||||
// sa case 6.
|
||||
const PLAYER_CAN_HIT = "4P8HEADg/wcEAA";
|
||||
|
||||
// Le joueur, au trait : un pion sur la barre, quatorze sur sa case 6.
|
||||
// L'ordinateur : un blot sur la case 21 du joueur (sa case 4), quatorze sur
|
||||
// sa case 6.
|
||||
const PLAYER_ON_BAR = "yP8PAADg/wcAQA";
|
||||
|
||||
// Le joueur, au trait, n'a plus que deux pions, sur ses cases 6 et 5.
|
||||
const PLAYER_ALMOST_DONE = "/38AAABQAAAAAA";
|
||||
|
||||
/** Une partie où le joueur, au trait, joue le jet dice à la position. */
|
||||
async function playerMove(position: PositionId, dice: [number, number], move: string) {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, {
|
||||
dice: fixedDice(dice),
|
||||
setup: { position, firstTurn: "player" },
|
||||
});
|
||||
await game.roll();
|
||||
for (const halfMove of parseHalfMoves(move)) {
|
||||
assert.equal(await game.playHalfMove(halfMove), true, formatHalfMoves([halfMove]));
|
||||
}
|
||||
return game;
|
||||
}
|
||||
|
||||
/** Le nombre de pions d'un camp sur une case (1 à 24), sur la barre ou sortis. */
|
||||
function at(side: BoardSide, point: number | "bar" | "off"): number {
|
||||
if (point === "bar") {
|
||||
return side.bar;
|
||||
}
|
||||
return point === "off" ? side.off : (side.points[point - 1] ?? 0);
|
||||
}
|
||||
|
||||
test("un coup simple : un plateau par demi-coup, sans pion frappé", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, { dice: fixedDice([3, 1]) });
|
||||
for (const halfMove of parseHalfMoves("8/5 6/5")) {
|
||||
await game.playHalfMove(halfMove);
|
||||
}
|
||||
const steps = await game.lastMoveSteps();
|
||||
assert.ok(steps !== null);
|
||||
assert.equal(steps.side, "player");
|
||||
assert.equal(formatHalfMoves(steps.halfMoves), "8/5 6/5");
|
||||
assert.deepEqual(steps.hits, [false, false]);
|
||||
const counts = steps.boards.map((b) => [at(b.player, 8), at(b.player, 6), at(b.player, 5)]);
|
||||
assert.deepEqual(counts, [
|
||||
[3, 5, 0],
|
||||
[2, 5, 1],
|
||||
[2, 4, 2],
|
||||
]);
|
||||
// Le dernier plateau est celui de la partie après le coup.
|
||||
assert.deepEqual(steps.boards[2], await game.displayedBoard());
|
||||
});
|
||||
|
||||
test("un pion frappé part sur la barre au demi-coup qui le frappe", async () => {
|
||||
const game = await playerMove(PLAYER_CAN_HIT, [3, 1], "13/10 10/9");
|
||||
const steps = await game.lastMoveSteps();
|
||||
assert.ok(steps !== null);
|
||||
assert.deepEqual(steps.hits, [true, false]);
|
||||
const bar = steps.boards.map((b) => at(b.computer, "bar"));
|
||||
assert.deepEqual(bar, [0, 1, 1]);
|
||||
// Le blot était sur la case 10 du joueur, la case 15 de l'ordinateur.
|
||||
assert.equal(at(steps.boards[0]?.computer as BoardSide, 15), 1);
|
||||
assert.equal(at(steps.boards[1]?.computer as BoardSide, 15), 0);
|
||||
assert.equal(at(steps.boards[2]?.player as BoardSide, 9), 1);
|
||||
});
|
||||
|
||||
test("un coup depuis la barre, qui frappe en rentrant", async () => {
|
||||
const game = await playerMove(PLAYER_ON_BAR, [4, 2], "bar/21 6/4");
|
||||
const steps = await game.lastMoveSteps();
|
||||
assert.ok(steps !== null);
|
||||
assert.deepEqual(steps.hits, [true, false]);
|
||||
assert.deepEqual(
|
||||
steps.boards.map((b) => [at(b.player, "bar"), at(b.player, 21), at(b.computer, "bar")]),
|
||||
[
|
||||
[1, 0, 0],
|
||||
[0, 1, 1],
|
||||
[0, 1, 1],
|
||||
],
|
||||
);
|
||||
});
|
||||
|
||||
test("une sortie de pions, jusqu'à la fin de la partie", async () => {
|
||||
const game = await playerMove(PLAYER_ALMOST_DONE, [6, 5], "6/off 5/off");
|
||||
assert.equal(game.state.phase, "over");
|
||||
const steps = await game.lastMoveSteps();
|
||||
assert.ok(steps !== null);
|
||||
assert.deepEqual(steps.hits, [false, false]);
|
||||
assert.deepEqual(
|
||||
steps.boards.map((b) => at(b.player, "off")),
|
||||
[13, 14, 15],
|
||||
);
|
||||
});
|
||||
|
||||
test("le coup de l'ordinateur, vu dans sa propre numérotation", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
// Vous commencez avec 3-1, puis l'ordinateur tire 6-4.
|
||||
const game = Game.start(engine, { dice: fixedDice([3, 1, 6, 4]) });
|
||||
for (const halfMove of parseHalfMoves("8/5 6/5")) {
|
||||
await game.playHalfMove(halfMove);
|
||||
}
|
||||
await game.playComputerTurn();
|
||||
const steps = await game.lastMoveSteps();
|
||||
assert.ok(steps !== null);
|
||||
assert.equal(steps.side, "computer");
|
||||
assert.equal(steps.boards.length, steps.halfMoves.length + 1);
|
||||
// Chaque demi-coup déplace un pion de l'ordinateur de sa case de départ.
|
||||
for (const [i, h] of steps.halfMoves.entries()) {
|
||||
const from = h.from === BAR ? "bar" : h.from;
|
||||
const before = steps.boards[i]?.computer as BoardSide;
|
||||
const after = steps.boards[i + 1]?.computer as BoardSide;
|
||||
assert.equal(at(after, from), at(before, from) - 1);
|
||||
}
|
||||
assert.deepEqual(steps.boards.at(-1), await game.displayedBoard());
|
||||
});
|
||||
|
||||
test("avant le premier coup, il n'y a rien à montrer", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, { dice: fixedDice([3, 1]) });
|
||||
assert.equal(await game.lastMoveSteps(), null);
|
||||
});
|
||||
@@ -0,0 +1,65 @@
|
||||
// Ce que l'interface propose au joueur, sur le vrai moteur WebAssembly : les
|
||||
// demi-coups possibles (mis en évidence quand il touche un pion) et le
|
||||
// plateau affiché pendant la saisie d'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 { 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, n'a plus que deux pions, sur ses cases 6 et 5
|
||||
// (même position que dans les étapes du scénario).
|
||||
const PLAYER_ALMOST_DONE = "/38AAABQAAAAAA";
|
||||
|
||||
/** Les demi-coups en notation, triés : « 13/10 13/12… ». */
|
||||
function text(halfMoves: readonly HalfMove[]): string {
|
||||
return halfMoves
|
||||
.map((h) => formatHalfMoves([h]))
|
||||
.sort()
|
||||
.join(" ");
|
||||
}
|
||||
|
||||
test("au départ avec 3-1 : chaque pion jouable, avec chaque dé", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, { dice: fixedDice([3, 1]) });
|
||||
assert.equal(text(await game.nextHalfMoves()), "13/10 24/21 24/23 6/3 6/5 8/5 8/7");
|
||||
// 13/12 manque : votre case 12 est tenue par l'ordinateur. Après 8/5,
|
||||
// il ne reste que le 1.
|
||||
assert.equal(await game.playHalfMove({ from: 8, to: 5 }), true);
|
||||
assert.equal(text(await game.nextHalfMoves()), "24/23 5/4 6/5 8/7");
|
||||
});
|
||||
|
||||
test("en fin de partie, les demi-coups vers la sortie viennent du moteur", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, {
|
||||
dice: fixedDice([6, 5]),
|
||||
setup: { position: PLAYER_ALMOST_DONE, firstTurn: "player" },
|
||||
});
|
||||
await game.roll();
|
||||
assert.equal(text(await game.nextHalfMoves()), "5/off 6/1 6/off");
|
||||
});
|
||||
|
||||
test("hors du tour de jeu du joueur, rien n'est proposé", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, { dice: fixedDice([1, 3]) });
|
||||
assert.equal(game.state.turn, "computer");
|
||||
assert.deepEqual(await game.nextHalfMoves(), []);
|
||||
});
|
||||
|
||||
test("le plateau affiché suit les demi-coups saisis", async () => {
|
||||
const engine = await loadNodeEngine();
|
||||
const game = Game.start(engine, { dice: fixedDice([3, 1]) });
|
||||
const before = await game.displayedBoard();
|
||||
assert.equal(before.player.points[7], 3);
|
||||
assert.equal(before.computer.points[23], 2);
|
||||
await game.playHalfMove({ from: 8, to: 5 });
|
||||
const after = await game.displayedBoard();
|
||||
assert.equal(after.player.points[7], 2);
|
||||
assert.equal(after.player.points[4], 1);
|
||||
assert.equal(after.player.pipCount, before.player.pipCount - 3);
|
||||
});
|
||||
@@ -0,0 +1,356 @@
|
||||
// Étapes du scénario docs/scenarios/jouer-une-partie.feature (ADR 0008) :
|
||||
// elles pilotent le domaine, branché sur le vrai moteur WebAssembly, avec des
|
||||
// dés imposés pour que chaque exécution soit identique.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
|
||||
import assert from "node:assert/strict";
|
||||
import { Before, BeforeAll, Given, setDefaultTimeout, Then, When } from "@cucumber/cucumber";
|
||||
import type { BoardSide, Engine, Move } from "../../src/domain/game/engine.js";
|
||||
import type { GameEvent } from "../../src/domain/game/events.js";
|
||||
import { Game, type MoveSteps, STANDARD_PLY } from "../../src/domain/game/game.js";
|
||||
import {
|
||||
BAR,
|
||||
OFF,
|
||||
type PositionId,
|
||||
parseHalfMoves,
|
||||
START_POSITION,
|
||||
} from "../../src/domain/game/position.js";
|
||||
import { fixedDice } from "../../src/domain/game/roll.js";
|
||||
import type { GameState } from "../../src/domain/game/state.js";
|
||||
import { loadNodeEngine } from "../support/node-engine.js";
|
||||
|
||||
// Le chargement du moteur prend une à deux secondes sur le PC de 2011.
|
||||
setDefaultTimeout(30_000);
|
||||
|
||||
// Course où l'ordinateur, au trait, mène nettement : le moteur lui recommande
|
||||
// de doubler, et au joueur de prendre (position de référence
|
||||
// « cube-double-take », tests/reference/positions.json).
|
||||
const COMPUTER_DOUBLES = "6O5uAAC4uzsAAA";
|
||||
|
||||
// Le joueur, au trait, n'a plus que deux pions, sur ses cases 6 et 5 ;
|
||||
// l'ordinateur n'en a sorti aucun.
|
||||
const PLAYER_ALMOST_DONE = "/38AAABQAAAAAA";
|
||||
|
||||
// Le joueur, au trait : un pion sur la barre, quatorze sur sa case 6.
|
||||
// L'ordinateur tient ses six premières cases (vos cases 19 à 24), où votre
|
||||
// pion devrait rentrer.
|
||||
const PLAYER_SHUT_OUT = "t+0OAADg/wcAQA";
|
||||
|
||||
// L'ordinateur, au trait : un pion sur sa case 13, quatorze sur sa case 1.
|
||||
// Vous : un blot sur votre case 15 (sa case 10), deux pions sur votre case
|
||||
// 13 (sa case 12), douze sur votre case 6. Avec 3-1, son seul coup permis
|
||||
// est 13/10* 10/9 : il frappe votre blot.
|
||||
const COMPUTER_MUST_HIT = "4P8BEwD/PwAEAA";
|
||||
|
||||
let engine: Engine;
|
||||
let game: Game;
|
||||
let accepted: boolean;
|
||||
let positionBefore: PositionId;
|
||||
let computerTurn: { before: GameState; ms: number };
|
||||
let computerMove: MoveSteps;
|
||||
|
||||
/** Le nombre de pions d'un camp à une case d'un demi-coup (barre, sortie ou
|
||||
* 1 à 24, dans sa numérotation). */
|
||||
function checkersAt(side: BoardSide, point: number): number {
|
||||
if (point === BAR) {
|
||||
return side.bar;
|
||||
}
|
||||
return point === OFF ? side.off : (side.points[point - 1] ?? 0);
|
||||
}
|
||||
|
||||
BeforeAll(async () => {
|
||||
engine = await loadNodeEngine();
|
||||
});
|
||||
|
||||
Before(() => {
|
||||
accepted = false;
|
||||
});
|
||||
|
||||
/** Joue les demi-coups un par un ; au premier refus, le coup est abandonné. */
|
||||
async function play(text: string): Promise<boolean> {
|
||||
positionBefore = game.displayedPosition;
|
||||
for (const halfMove of parseHalfMoves(text)) {
|
||||
if (!(await game.playHalfMove(halfMove))) {
|
||||
game.cancelHalfMoves();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function lastEvent(): GameEvent {
|
||||
const event = game.events.at(-1);
|
||||
assert.ok(event !== undefined, "aucun événement");
|
||||
return event;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------- Commencer une partie
|
||||
|
||||
When("vous commencez une nouvelle partie", () => {
|
||||
// Égalité au premier jet d'ouverture, puis 5 contre 2.
|
||||
game = Game.start(engine, { dice: fixedDice([4, 4, 5, 2]) });
|
||||
});
|
||||
|
||||
Then("les pions sont en position de départ", async () => {
|
||||
assert.equal(game.state.position, START_POSITION);
|
||||
const board = await engine.board(game.state.position, { value: 1, owner: "centered" });
|
||||
const start = Array.from({ length: 24 }, (_, i) => ({ 5: 5, 7: 3, 12: 5, 23: 2 })[i] ?? 0);
|
||||
for (const side of [board.onRoll, board.opponent]) {
|
||||
assert.deepEqual(side.points, start);
|
||||
assert.equal(side.bar, 0);
|
||||
assert.equal(side.off, 0);
|
||||
}
|
||||
});
|
||||
|
||||
Then("le premier jet de dés désigne qui commence", () => {
|
||||
const opening = game.events.filter((e) => e.type === "DiceRolled" && e.side === null);
|
||||
const last = opening.at(-1);
|
||||
assert.ok(last?.type === "DiceRolled");
|
||||
// Les jets d'ouverture égaux ont été relancés.
|
||||
for (const tie of opening.slice(0, -1)) {
|
||||
assert.ok(tie.type === "DiceRolled" && tie.roll[0] === tie.roll[1]);
|
||||
}
|
||||
const [playerDie, computerDie] = last.roll;
|
||||
assert.notEqual(playerDie, computerDie);
|
||||
assert.equal(game.state.turn, playerDie > computerDie ? "player" : "computer");
|
||||
assert.equal(game.state.phase, "moving");
|
||||
assert.deepEqual(game.state.roll, last.roll);
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------ Jouer un coup
|
||||
|
||||
Given("c'est à vous de jouer avec le jet {int}-{int}", (first: number, second: number) => {
|
||||
// Le jet d'ouverture : votre dé, puis celui de l'ordinateur.
|
||||
game = Game.start(engine, { dice: fixedDice([first, second]) });
|
||||
assert.equal(game.state.turn, "player");
|
||||
assert.deepEqual(game.state.roll, [first, second]);
|
||||
});
|
||||
|
||||
When(/^vous jouez (.+)$/, async (text: string) => {
|
||||
accepted = await play(text);
|
||||
});
|
||||
|
||||
When(/^vous essayez de jouer (.+)$/, async (text: string) => {
|
||||
accepted = await play(text);
|
||||
});
|
||||
|
||||
Then("votre coup est accepté", () => {
|
||||
assert.equal(accepted, true);
|
||||
const event = lastEvent();
|
||||
assert.ok(event.type === "MovePlayed");
|
||||
assert.equal(event.side, "player");
|
||||
});
|
||||
|
||||
Then("c'est ensuite au tour de l'ordinateur", () => {
|
||||
assert.equal(game.state.turn, "computer");
|
||||
assert.equal(game.state.phase, "rolling");
|
||||
});
|
||||
|
||||
Then("votre coup est refusé", () => {
|
||||
assert.equal(accepted, false);
|
||||
});
|
||||
|
||||
Then("la position n'a pas changé", () => {
|
||||
assert.equal(game.displayedPosition, positionBefore);
|
||||
assert.equal(game.state.position, positionBefore);
|
||||
assert.equal(game.state.turn, "player");
|
||||
assert.equal(game.state.phase, "moving");
|
||||
assert.equal(lastEvent().type, "DiceRolled");
|
||||
});
|
||||
|
||||
// ------------------------------------------------------- L'ordinateur joue
|
||||
|
||||
Given("c'est au tour de l'ordinateur", async () => {
|
||||
// Vous commencez avec 3-1, puis l'ordinateur tirera 6-4.
|
||||
game = Game.start(engine, { dice: fixedDice([3, 1, 6, 4]) });
|
||||
assert.equal(await play("8/5 6/5"), true);
|
||||
assert.equal(game.state.turn, "computer");
|
||||
});
|
||||
|
||||
When("ses dés sont tirés", async () => {
|
||||
const before = game.state;
|
||||
const start = performance.now();
|
||||
await game.playComputerTurn();
|
||||
computerTurn = { before, ms: performance.now() - start };
|
||||
});
|
||||
|
||||
Then(
|
||||
"il joue le coup recommandé par le moteur en moins de {int} secondes",
|
||||
async (seconds: number) => {
|
||||
const rolled = game.events.findLast((e) => e.type === "DiceRolled");
|
||||
const played = lastEvent();
|
||||
assert.ok(rolled?.type === "DiceRolled" && rolled.side === "computer");
|
||||
assert.ok(played.type === "MovePlayed" && played.side === "computer");
|
||||
const best: Move | null = await engine.bestMove(
|
||||
computerTurn.before.position,
|
||||
{ value: 1, owner: "centered" },
|
||||
rolled.roll,
|
||||
STANDARD_PLY,
|
||||
);
|
||||
assert.ok(best !== null);
|
||||
assert.deepEqual(played.halfMoves, best.halfMoves);
|
||||
assert.ok(
|
||||
computerTurn.ms < seconds * 1000,
|
||||
`tour de l'ordinateur en ${Math.round(computerTurn.ms)} ms`,
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// ------------------------------------------------- Aucun coup possible
|
||||
|
||||
Given("votre pion sur la barre ne peut pas rentrer", () => {
|
||||
// Les six cases où il pourrait rentrer sont tenues par l'ordinateur.
|
||||
game = Game.start(engine, {
|
||||
setup: { position: PLAYER_SHUT_OUT, firstTurn: "player" },
|
||||
dice: fixedDice([6, 5]),
|
||||
});
|
||||
});
|
||||
|
||||
When("vous lancez les dés", async () => {
|
||||
await game.roll();
|
||||
});
|
||||
|
||||
Then("aucun coup n'est possible avec votre jet", async () => {
|
||||
assert.deepEqual(game.state.roll, [6, 5]);
|
||||
assert.equal(await game.cannotMove(), true);
|
||||
assert.deepEqual(await game.nextHalfMoves(), []);
|
||||
});
|
||||
|
||||
Then("c'est toujours à vous", () => {
|
||||
assert.equal(game.state.turn, "player");
|
||||
assert.equal(game.state.phase, "moving");
|
||||
assert.equal(lastEvent().type, "DiceRolled");
|
||||
});
|
||||
|
||||
When("vous continuez", async () => {
|
||||
await game.skipTurn();
|
||||
const event = lastEvent();
|
||||
assert.ok(event.type === "MovePlayed" && event.side === "player");
|
||||
assert.deepEqual(event.halfMoves, []);
|
||||
});
|
||||
|
||||
// ---------------------------------------------- Voir le coup de l'ordinateur
|
||||
|
||||
Given("un de vos pions est seul à portée de l'ordinateur", () => {
|
||||
// L'ordinateur tirera 3-1. Le videau est chez vous : il ne peut pas
|
||||
// doubler, il joue.
|
||||
game = Game.start(engine, {
|
||||
setup: {
|
||||
position: COMPUTER_MUST_HIT,
|
||||
firstTurn: "computer",
|
||||
cube: { value: 2, owner: "player" },
|
||||
},
|
||||
dice: fixedDice([3, 1]),
|
||||
});
|
||||
});
|
||||
|
||||
When("l'ordinateur a joué", async () => {
|
||||
await game.playComputerTurn();
|
||||
const played = lastEvent();
|
||||
assert.ok(played.type === "MovePlayed" && played.side === "computer");
|
||||
const steps = await game.lastMoveSteps();
|
||||
assert.ok(steps !== null);
|
||||
computerMove = steps;
|
||||
});
|
||||
|
||||
Then("son coup vous est montré case par case", async () => {
|
||||
const { side, halfMoves, boards } = computerMove;
|
||||
assert.equal(side, "computer");
|
||||
assert.ok(halfMoves.length > 0);
|
||||
assert.equal(boards.length, halfMoves.length + 1);
|
||||
// Chaque plateau ne diffère du précédent que d'un pion de l'ordinateur,
|
||||
// parti de la case de départ du demi-coup pour sa case d'arrivée.
|
||||
for (const [i, h] of halfMoves.entries()) {
|
||||
const before = boards[i]?.computer;
|
||||
const after = boards[i + 1]?.computer;
|
||||
assert.ok(before !== undefined && after !== undefined);
|
||||
assert.equal(checkersAt(after, h.from), checkersAt(before, h.from) - 1);
|
||||
assert.equal(checkersAt(after, h.to), checkersAt(before, h.to) + 1);
|
||||
}
|
||||
// Le dernier est le plateau de la partie.
|
||||
assert.deepEqual(boards.at(-1), await game.displayedBoard());
|
||||
});
|
||||
|
||||
Then("votre pion frappé part sur la barre", () => {
|
||||
const { boards, hits } = computerMove;
|
||||
const hit = hits.indexOf(true);
|
||||
assert.ok(hit >= 0, "aucun pion frappé");
|
||||
assert.equal(boards[hit]?.player.bar, 0);
|
||||
assert.equal(boards[hit + 1]?.player.bar, 1);
|
||||
});
|
||||
|
||||
Then("vous pouvez revoir son coup", async () => {
|
||||
assert.deepEqual(await game.lastMoveSteps(), computerMove);
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------------ Videau
|
||||
|
||||
Given("l'ordinateur vous propose de doubler", async () => {
|
||||
game = Game.start(engine, { setup: { position: COMPUTER_DOUBLES, firstTurn: "computer" } });
|
||||
await game.playComputerTurn();
|
||||
const event = lastEvent();
|
||||
assert.ok(event.type === "CubeOffered" && event.side === "computer");
|
||||
assert.equal(game.state.phase, "doubled");
|
||||
});
|
||||
|
||||
When("vous prenez", () => {
|
||||
game.take();
|
||||
});
|
||||
|
||||
When("vous passez", () => {
|
||||
game.drop();
|
||||
});
|
||||
|
||||
Then("la partie continue à valeur doublée", () => {
|
||||
assert.equal(game.state.cube.value, 2);
|
||||
assert.equal(game.state.result, null);
|
||||
assert.equal(game.state.phase, "rolling");
|
||||
});
|
||||
|
||||
Then("le videau est de votre côté : vous seul pourrez redoubler", async () => {
|
||||
const { cube, position } = game.state;
|
||||
assert.equal(cube.owner, "player");
|
||||
// Le moteur le confirme : l'ordinateur, au trait, ne peut plus doubler…
|
||||
const computer = await engine.cubeDecision(
|
||||
position,
|
||||
{ value: 2, owner: "opponent" },
|
||||
STANDARD_PLY,
|
||||
);
|
||||
assert.equal(computer.available, false);
|
||||
// … alors que vous, à votre tour, le pourrez.
|
||||
const board = await engine.board(position, { value: 2, owner: "opponent" });
|
||||
const player = await engine.cubeDecision(
|
||||
board.swappedPosition,
|
||||
{ value: 2, owner: "onRoll" },
|
||||
STANDARD_PLY,
|
||||
);
|
||||
assert.equal(player.available, true);
|
||||
});
|
||||
|
||||
Then("la partie s'arrête", () => {
|
||||
assert.equal(game.state.phase, "over");
|
||||
assert.equal(lastEvent().type, "GameEnded");
|
||||
});
|
||||
|
||||
Then("vous perdez la partie à sa valeur d'avant le double", () => {
|
||||
assert.deepEqual(game.state.result, { winner: "computer", kind: "single", points: 1 });
|
||||
});
|
||||
|
||||
// --------------------------------------------------------- Fin de partie
|
||||
|
||||
Given("un joueur a sorti tous ses pions", async () => {
|
||||
game = Game.start(engine, {
|
||||
setup: { position: PLAYER_ALMOST_DONE, firstTurn: "player" },
|
||||
dice: fixedDice([6, 5]),
|
||||
});
|
||||
await game.roll();
|
||||
assert.equal(await play("6/off 5/off"), true);
|
||||
});
|
||||
|
||||
Then("le résultat indique le gagnant et les points gagnés", () => {
|
||||
// Gammon (l'ordinateur n'a sorti aucun pion), mais 1 point seulement :
|
||||
// règle Jacoby, le videau n'a pas bougé.
|
||||
assert.deepEqual(game.state.result, { winner: "player", kind: "gammon", points: 1 });
|
||||
});
|
||||
@@ -0,0 +1,37 @@
|
||||
// Le vrai moteur WebAssembly sous Node, pour les tests et les scénarios.
|
||||
//
|
||||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||||
//
|
||||
// Charge build/wasm/ (make engine-wasm) avec web/engine-wasm.mjs, comme la
|
||||
// page de test du moteur, et le branche sur l'adaptateur du domaine. Le moteur
|
||||
// n'est chargé qu'une fois par processus.
|
||||
|
||||
import { fileURLToPath } from "node:url";
|
||||
import type { Engine } from "../../src/domain/game/engine.js";
|
||||
import { createWasmEngine } from "../../src/engine/wasm-engine.js";
|
||||
|
||||
// Ce fichier est compilé dans build/web/tests/support/ : la racine du dépôt
|
||||
// est quatre dossiers plus haut.
|
||||
const root = new URL("../../../../", import.meta.url);
|
||||
|
||||
interface WasmEngine {
|
||||
run(args: string[]): { result: unknown; ms: number };
|
||||
}
|
||||
|
||||
let loading: Promise<Engine> | undefined;
|
||||
|
||||
export function loadNodeEngine(): Promise<Engine> {
|
||||
loading ??= load();
|
||||
return loading;
|
||||
}
|
||||
|
||||
async function load(): Promise<Engine> {
|
||||
const module = await import(new URL("build/wasm/engine.mjs", root).href);
|
||||
const wrapper = await import(new URL("web/engine-wasm.mjs", root).href);
|
||||
const wasm: WasmEngine = await wrapper.loadEngine(
|
||||
module.default,
|
||||
fileURLToPath(new URL("build/wasm/", root)),
|
||||
);
|
||||
return createWasmEngine(async (args) => wasm.run(args).result);
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
// Tests de ce qui, dans l'interface et le stockage, se vérifie sans
|
||||
// navigateur : le plateau à dessiner, les mises en évidence, la lecture de
|
||||
// l'aide, l'enregistrement de la partie.
|
||||
//
|
||||
// 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 type { BoardSide } from "../src/domain/game/engine.js";
|
||||
import { appendEvent, EMPTY_JOURNAL } from "../src/domain/game/events.js";
|
||||
import { parseHalfMoves, START_POSITION } from "../src/domain/game/position.js";
|
||||
import { createGameStore } from "../src/storage/game-store.js";
|
||||
import { boardModel, moveTargets, moveTrace, placeOf, pointSlot } from "../src/ui/board-model.js";
|
||||
import { parseFeature, parseGlossaryEntry, parseGlossaryIndex } from "../src/ui/help-text.js";
|
||||
import { TEXTS } from "../src/ui/texts.js";
|
||||
|
||||
// Compilé dans build/web/tests/ : la racine du dépôt est trois dossiers plus haut.
|
||||
const root = new URL("../../../", import.meta.url);
|
||||
const read = (path: string) => readFileSync(new URL(path, root), "utf8");
|
||||
|
||||
function side(points: Record<number, number>, extra: Partial<BoardSide> = {}): BoardSide {
|
||||
const all = Array.from({ length: 24 }, (_, i) => points[i + 1] ?? 0);
|
||||
return { points: all, bar: 0, off: 0, pipCount: 0, ...extra };
|
||||
}
|
||||
|
||||
test("le plateau est vu du joueur : la case q de l'ordinateur est sa case 25 - q", () => {
|
||||
const model = boardModel({
|
||||
player: side({ 6: 5, 8: 3 }, { bar: 1, pipCount: 100 }),
|
||||
computer: side({ 6: 5, 24: 2 }, { off: 3, pipCount: 90 }),
|
||||
});
|
||||
assert.equal(model.points.length, 24);
|
||||
assert.deepEqual(model.points[5], { place: "p6", number: 6, owner: "player", count: 5 });
|
||||
assert.deepEqual(model.points[18], { place: "p19", number: 19, owner: "computer", count: 5 });
|
||||
assert.deepEqual(model.points[0], { place: "p1", number: 1, owner: "computer", count: 2 });
|
||||
assert.deepEqual(model.points[1], { place: "p2", number: 2, owner: null, count: 0 });
|
||||
assert.deepEqual(model.bar, { player: 1, computer: 0 });
|
||||
assert.deepEqual(model.off, { player: 0, computer: 3 });
|
||||
assert.deepEqual(model.pipCount, { player: 100, computer: 90 });
|
||||
});
|
||||
|
||||
test("cases, barre et sortie de chaque camp", () => {
|
||||
assert.equal(placeOf("player", 8), "p8");
|
||||
assert.equal(placeOf("computer", 8), "p17");
|
||||
assert.equal(placeOf("player", 25), "bar-player");
|
||||
assert.equal(placeOf("computer", 0), "off-computer");
|
||||
});
|
||||
|
||||
test("disposition : 1 à 12 en bas de droite à gauche, 13 à 24 en haut de gauche à droite", () => {
|
||||
assert.deepEqual(pointSlot(1), { top: false, column: 11 });
|
||||
assert.deepEqual(pointSlot(7), { top: false, column: 5 });
|
||||
assert.deepEqual(pointSlot(12), { top: false, column: 0 });
|
||||
assert.deepEqual(pointSlot(13), { top: true, column: 0 });
|
||||
assert.deepEqual(pointSlot(24), { top: true, column: 11 });
|
||||
});
|
||||
|
||||
test("les demi-coups possibles donnent les pions jouables et leurs cases d'arrivée", () => {
|
||||
const targets = moveTargets([
|
||||
{ from: 8, to: 5 },
|
||||
{ from: 8, to: 7 },
|
||||
{ from: 25, to: 22 },
|
||||
{ from: 3, to: 0 },
|
||||
]);
|
||||
assert.deepEqual([...targets.keys()], ["p8", "bar-player", "p3"]);
|
||||
assert.deepEqual([...(targets.get("p8")?.keys() ?? [])], ["p5", "p7"]);
|
||||
assert.deepEqual(targets.get("p3")?.get("off-player"), { from: 3, to: 0 });
|
||||
});
|
||||
|
||||
test("traces d'un coup simple : une flèche par demi-coup, départs et arrivées", () => {
|
||||
// L'ordinateur joue 13/9 13/7 dans sa numérotation : ses cases 13, 9 et
|
||||
// 7 sont les cases 12, 16 et 18 du joueur.
|
||||
const trace = moveTrace("computer", parseHalfMoves("13/9 13/7"), [false, false]);
|
||||
assert.deepEqual(trace.arrows, [
|
||||
{ from: "p12", to: "p16" },
|
||||
{ from: "p12", to: "p18" },
|
||||
]);
|
||||
assert.deepEqual([...trace.left], [["p12", 2]]);
|
||||
assert.deepEqual(
|
||||
[...trace.landed],
|
||||
[
|
||||
["p16", 1],
|
||||
["p18", 1],
|
||||
],
|
||||
);
|
||||
assert.equal(trace.hits, 0);
|
||||
});
|
||||
|
||||
test("traces : un pion qui fait étape ne laisse ni fantôme ni cercle à l'étape", () => {
|
||||
const trace = moveTrace("computer", parseHalfMoves("24/18 18/14"), [false, true]);
|
||||
assert.equal(trace.arrows.length, 2);
|
||||
assert.deepEqual([...trace.left], [["p1", 1]]);
|
||||
assert.deepEqual([...trace.landed], [["p11", 1]]);
|
||||
assert.equal(trace.hits, 1);
|
||||
});
|
||||
|
||||
test("traces : rentrée depuis la barre avec un pion frappé, sortie de pions", () => {
|
||||
const entering = moveTrace("computer", parseHalfMoves("bar/22 6/4"), [true, false]);
|
||||
assert.deepEqual(entering.arrows[0], { from: "bar-computer", to: "p3" });
|
||||
assert.deepEqual(
|
||||
[...entering.left],
|
||||
[
|
||||
["bar-computer", 1],
|
||||
["p19", 1],
|
||||
],
|
||||
);
|
||||
assert.equal(entering.hits, 1);
|
||||
const bearingOff = moveTrace("computer", parseHalfMoves("6/off 5/off"), [false, false]);
|
||||
assert.deepEqual([...bearingOff.landed], [["off-computer", 2]]);
|
||||
assert.deepEqual(
|
||||
[...bearingOff.left],
|
||||
[
|
||||
["p19", 1],
|
||||
["p20", 1],
|
||||
],
|
||||
);
|
||||
});
|
||||
|
||||
test("l'aide lit le scénario tel qu'il est écrit dans docs/scenarios/", () => {
|
||||
const feature = parseFeature(read("docs/scenarios/jouer-une-partie.feature"));
|
||||
assert.equal(feature.title, "Jouer une partie contre l'ordinateur");
|
||||
assert.match(feature.description[0] ?? "", /^Vous jouez une partie complète/);
|
||||
assert.equal(feature.scenarios[0]?.title, "Commencer une partie");
|
||||
assert.deepEqual(feature.scenarios[0]?.steps, [
|
||||
"Quand vous commencez une nouvelle partie",
|
||||
"Alors les pions sont en position de départ",
|
||||
"Et le premier jet de dés désigne qui commence",
|
||||
]);
|
||||
const refused = feature.scenarios.find((s) => s.title === "Un coup interdit est refusé");
|
||||
assert.match(refused?.description[0] ?? "", /^La case 12 est tenue/);
|
||||
assert.equal(refused?.steps[0], "Étant donné que c'est à vous de jouer avec le jet 3-1");
|
||||
// Chaque scénario a des étapes : aucune n'a été prise pour du texte libre.
|
||||
for (const scenario of feature.scenarios) {
|
||||
assert.ok(scenario.steps.length >= 2, scenario.title);
|
||||
}
|
||||
});
|
||||
|
||||
test("l'aide lit chaque fiche de l'index du glossaire", () => {
|
||||
const files = parseGlossaryIndex(read("docs/glossaire/README.md"));
|
||||
assert.ok(files.includes("videau.md"));
|
||||
assert.ok(!files.includes("README.md"));
|
||||
for (const file of files) {
|
||||
const entry = parseGlossaryEntry(read(`docs/glossaire/${file}`));
|
||||
assert.ok(entry !== null, file);
|
||||
assert.ok(entry.brief.length > 10, file);
|
||||
}
|
||||
assert.deepEqual(parseGlossaryEntry(read("docs/glossaire/videau.md")), {
|
||||
term: "Videau",
|
||||
brief: "le dé à doubler, marqué 2, 4, 8, 16, 32 et 64 : il indique la valeur actuelle de la partie.",
|
||||
});
|
||||
assert.equal(parseGlossaryEntry("pas une fiche"), null);
|
||||
});
|
||||
|
||||
test("la partie enregistrée se relit ; un enregistrement illisible est ignoré", () => {
|
||||
const data = new Map<string, string>();
|
||||
const storage = {
|
||||
getItem: (key: string) => data.get(key) ?? null,
|
||||
setItem: (key: string, value: string) => void data.set(key, value),
|
||||
};
|
||||
const store = createGameStore(storage);
|
||||
assert.equal(store.load(), null);
|
||||
const journal = appendEvent(EMPTY_JOURNAL, {
|
||||
type: "GameStarted",
|
||||
position: START_POSITION,
|
||||
cube: { value: 1, owner: null },
|
||||
firstTurn: null,
|
||||
});
|
||||
store.save(journal);
|
||||
assert.deepEqual(store.load(), journal);
|
||||
for (const key of data.keys()) {
|
||||
data.set(key, "{pas du JSON");
|
||||
}
|
||||
assert.equal(store.load(), null);
|
||||
// Un stockage plein ou interdit ne casse pas la partie.
|
||||
const full = createGameStore({
|
||||
getItem: () => null,
|
||||
setItem: () => {
|
||||
throw new Error("plein");
|
||||
},
|
||||
});
|
||||
assert.doesNotThrow(() => full.save(journal));
|
||||
});
|
||||
|
||||
test("les textes de fin de partie emploient les mots du glossaire", () => {
|
||||
assert.equal(TEXTS.youWin("gammon", 2), "Vous gagnez un gammon : 2 points.");
|
||||
assert.equal(
|
||||
TEXTS.youLose("single", 1),
|
||||
"L'ordinateur gagne la partie simple : 1 point pour lui.",
|
||||
);
|
||||
assert.equal(
|
||||
TEXTS.computerMoved([6, 4], "24/18 13/9", 312),
|
||||
"L'ordinateur a joué 6-4 : 24/18 13/9 (0,3 s).",
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2023",
|
||||
"lib": ["ES2023", "DOM", "DOM.Iterable"],
|
||||
"module": "NodeNext",
|
||||
"moduleResolution": "NodeNext",
|
||||
"types": ["node"],
|
||||
"strict": true,
|
||||
"noUnusedLocals": true,
|
||||
"noUnusedParameters": true,
|
||||
"noFallthroughCasesInSwitch": true,
|
||||
"verbatimModuleSyntax": true,
|
||||
"skipLibCheck": true,
|
||||
"rootDir": ".",
|
||||
"outDir": "../build/web"
|
||||
},
|
||||
"include": ["src", "tests"]
|
||||
}
|
||||
@@ -30,10 +30,22 @@
|
||||
header X-Content-Type-Options "nosniff"
|
||||
header Referrer-Policy "no-referrer"
|
||||
|
||||
# Politique de sécurité du contenu : tout vient du site lui-même, sans
|
||||
# script ni style en ligne. 'wasm-unsafe-eval' autorise la compilation du
|
||||
# moteur WebAssembly (et rien d'autre : ni eval ni new Function). L'en-tête
|
||||
# s'applique aussi au Web Worker du moteur et au service worker.
|
||||
header Content-Security-Policy "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self'; img-src 'self'; connect-src 'self'; worker-src 'self'; manifest-src 'self'; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"
|
||||
|
||||
# Données du moteur (Emscripten) : extension inconnue de Caddy, qui
|
||||
# devinerait text/xml d'après le début du fichier.
|
||||
@engine_data path *.data
|
||||
header @engine_data Content-Type "application/octet-stream"
|
||||
|
||||
# Textes de l'aide (copies de docs/), lus par l'application.
|
||||
@markdown path *.md
|
||||
header @markdown Content-Type "text/markdown; charset=utf-8"
|
||||
@gherkin path *.feature
|
||||
header @gherkin Content-Type "text/plain; charset=utf-8"
|
||||
|
||||
file_server
|
||||
}
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
# Outils de l'application web (ADR 0009) : TypeScript, Biome, Cucumber et
|
||||
# dependency-cruiser, sous Node. Rien de tout cela n'est embarqué dans
|
||||
# l'application : ces outils compilent, vérifient et testent.
|
||||
#
|
||||
# Les modules sont installés dans /opt/tools, puis rendus visibles sous
|
||||
# /node_modules, à la racine du conteneur : Node et TypeScript les trouvent en
|
||||
# remontant depuis le dépôt monté sous /src, sans node_modules dans le dépôt.
|
||||
# (npm refuse d'installer directement à la racine.)
|
||||
#
|
||||
# Versions figées, publiées depuis plus de deux semaines au 2026-11-02.
|
||||
# Cucumber reste en 12.x : la 13 charge des modules ES avec require(), ce que
|
||||
# Node 22.11 ne fait pas sans option (il faut Node 22.12).
|
||||
FROM node:22.11.0-alpine3.20
|
||||
|
||||
WORKDIR /opt/tools
|
||||
RUN npm install --no-audit --no-fund --save-exact \
|
||||
typescript@6.0.3 \
|
||||
@types/node@22.20.5 \
|
||||
@biomejs/biome@2.5.15 \
|
||||
@cucumber/cucumber@12.9.0 \
|
||||
dependency-cruiser@18.6.0 \
|
||||
&& npm cache clean --force \
|
||||
&& ln -s /opt/tools/node_modules /node_modules
|
||||
|
||||
ENV PATH="/opt/tools/node_modules/.bin:${PATH}"
|
||||
@@ -46,3 +46,15 @@ construire ou tester ; rien n'est embarqué dans l'application.
|
||||
| Python 3 | PSF | `ustagammon/build-c` | Comparateur des références |
|
||||
| jq | MIT | `ustagammon/build-c` | Lecture du JSON dans les tests |
|
||||
| Emscripten | MIT / NCSA | `emscripten/emsdk:3.1.64` | Compilation du moteur en WebAssembly (étape 0b) |
|
||||
|
||||
### 2026-11-02 — Outils de l'application web (étape 0d)
|
||||
|
||||
Validés par Pierre avec l'ADR 0009, dans Docker, jamais embarqués :
|
||||
TypeScript (`tsc`, Apache-2.0), Biome (MIT ou Apache-2.0),
|
||||
`@cucumber/cucumber` (MIT), `dependency-cruiser` (MIT).
|
||||
|
||||
### 2026-11-03 — Playwright pour les tests dans le navigateur
|
||||
|
||||
Validé par Pierre : Playwright 1.48.2 (Apache-2.0), image
|
||||
`mcr.microsoft.com/playwright:v1.48.2-noble`, utilisé seulement par
|
||||
`make test-browser` (Chromium et Firefox sans écran). Rien n'est embarqué.
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
# 0009. Socle : PWA en TypeScript, moteur en WebAssembly
|
||||
|
||||
- **Statut** : accepté
|
||||
- **Date** : 2026-11-02
|
||||
- **Décideurs** : Pierre, sur proposition de Claude Code, après les mesures
|
||||
sur le Fairphone 4
|
||||
|
||||
## Contexte
|
||||
|
||||
L'étape 0 doit trancher entre une PWA (moteur en WebAssembly) et une
|
||||
application Android native (`docs/etape-0.md`). L'étape 0b a produit le moteur
|
||||
en WebAssembly (MR !9) : même suite de contrat qu'en natif (écart maximal
|
||||
9,5e-4 pour une tolérance de 0,002), 7,3 Mo compressés à télécharger (seuil
|
||||
40 Mo). Sur le PC de développement (i5-2450M, 2011), le meilleur coup à 2 plis
|
||||
prend au plus 0,3 s sous Chromium et 2,3 s sous Firefox (seuil sur le
|
||||
téléphone : 3 s).
|
||||
|
||||
Mesures sur le Fairphone 4 (Chrome 156, page `bench.html`, servie par
|
||||
`make deploy-web`), trois essais le 2026-11-02, maximum sur les positions de
|
||||
référence :
|
||||
|
||||
| Mesure | Fairphone 4 (pire des 3 essais) | Seuil | Marge |
|
||||
| --- | --- | --- | --- |
|
||||
| Meilleur coup, 0 pli | 21 ms | 300 ms | ×14 |
|
||||
| Meilleur coup, 2 plis (médiane 94 à 98 ms) | 348 ms (`race-2`) | 3 000 ms | ×8,6 |
|
||||
| Décision de videau, 2 plis | 148 ms | 3 000 ms | ×20 |
|
||||
| Chargement du moteur | 239 à 276 ms | – | – |
|
||||
| Téléchargement, gzip | 7,3 Mo | 40 Mo | ×5 |
|
||||
| Mémoire WebAssembly | 51,9 Mo | – | – |
|
||||
|
||||
Les trois essais diffèrent de moins de 10 %. Firefox n'a pas été mesuré sur le
|
||||
téléphone.
|
||||
|
||||
L'ADR 0007 renvoyait au choix du socle le langage de l'interface et l'outil de
|
||||
vérification des dépendances.
|
||||
|
||||
## Décision
|
||||
|
||||
- **Socle : PWA**, installable et utilisable hors ligne, moteur en WebAssembly
|
||||
dans un Web Worker. L'étape 0c (Android natif) n'est pas faite.
|
||||
- **Langage : TypeScript**, compilé par `tsc` en modules JavaScript standard,
|
||||
sans framework d'interface ni empaqueteur.
|
||||
- **Lint et formatage : Biome.**
|
||||
- **Scénarios exécutés** (ADR 0008) par `@cucumber/cucumber`, sous Node, sur le
|
||||
domaine branché au vrai moteur WebAssembly.
|
||||
- **Règles d'architecture vérifiées** (ADR 0007) par `dependency-cruiser` :
|
||||
le domaine n'importe ni l'interface, ni le stockage, ni le moteur ; aucun
|
||||
écran n'importe le moteur.
|
||||
- Tous ces outils tournent dans Docker et ne sont jamais embarqués dans
|
||||
l'application.
|
||||
|
||||
## Alternatives écartées
|
||||
|
||||
- **Android natif (Kotlin, NDK)** : un seul système, une chaîne de build lourde
|
||||
(Gradle, NDK) sur une machine de 2011, et aucun gain mesuré à ce stade sur
|
||||
les temps de calcul. Reste le plan B si les mesures du téléphone échouent.
|
||||
- **JavaScript annoté (JSDoc) vérifié par TypeScript** : pas d'étape de build,
|
||||
mais des types moins lisibles ; Pierre a choisi TypeScript.
|
||||
- **Un framework d'interface** (React, Vue…) : inutile pour un plateau et
|
||||
quelques écrans, et contraire à la règle de simplicité (ADR 0007).
|
||||
|
||||
## Conséquences
|
||||
|
||||
- La distribution sur F-Droid et le Play Store demandera plus tard une
|
||||
enveloppe Android minimale autour de la PWA (à décider à l'étape 1).
|
||||
- L'étape 0c (Android natif) est abandonnée.
|
||||
- Le critère de fin de l'étape 0 (« moins de 2 s par coup de l'IA en niveau
|
||||
standard ») est tenu même au niveau fort (2 plis) : c'est le niveau standard
|
||||
de l'ordinateur à l'étape 0d.
|
||||
- Firefox sur le téléphone reste à vérifier, sans bloquer.
|
||||
@@ -0,0 +1,62 @@
|
||||
# 0010. Identité visuelle : symbole, logotype, palette
|
||||
|
||||
- **Statut** : accepté
|
||||
- **Date** : 2026-11-03
|
||||
- **Décideurs** : Pierre
|
||||
|
||||
## Contexte
|
||||
|
||||
Le brief créatif (https://claude.ai/artifact/36WMwZWqvMxXvSSVBJTgwd) fixe la
|
||||
personnalité d'Ustagammon (transmission, chaleur, maîtrise), une palette de
|
||||
départ (bois sombre, ivoire, un accent unique à choisir entre rouge brique et
|
||||
turquoise) et quatre pistes de symbole, avec une contrainte : un 8 caché, clin
|
||||
d'œil à l'Atelier du Huit, qui se découvre au second regard.
|
||||
|
||||
Les propositions ont été faites en trois tours sur une planche de travail
|
||||
(https://claude.ai/artifact/Cck1SZCrKeYWbqJLhbwWNp), chacune testée en
|
||||
couleur, en monochrome et en taille réelle d'icône (48 et 24 px).
|
||||
|
||||
## Décision
|
||||
|
||||
- **Accent** : rouge brique, `#A8432B` en thème clair, `#D0694B` en thème
|
||||
sombre. La turquoise est écartée.
|
||||
- **Symbole** (variante « P3d ») : deux pions vus de trois quarts, avec leur
|
||||
tranche, posés sur une flèche du plateau en brique. Le maître (noyer) est
|
||||
devant, l'apprenti (ivoire, filet brique) derrière ; leurs silhouettes
|
||||
dessinent le 8.
|
||||
- **Logotype** (variante « L3 ») : « Ustagammon » en Alegreya Sans Bold, dont
|
||||
les deux « m » sont redessinés en quatre flèches au trait qui alternent
|
||||
noyer et brique, comme les flèches d'un plateau. En monochrome, les quatre
|
||||
flèches prennent la couleur du texte.
|
||||
- **Icône d'application** : symbole sur fond ivoire `#F3EAD8`.
|
||||
- **Police** : Alegreya Sans (SIL Open Font License 1.1), pour le logotype et
|
||||
pour l'interface. Pierre a validé cette dépendance, ainsi que fontTools
|
||||
(MIT), outil de développement qui sert à régénérer le logotype, le
|
||||
2026-11-03.
|
||||
- Les fichiers de référence sont dans `docs/identite/logo/`, produits par
|
||||
`docs/identite/generer-logo.py` ; ils sont sous licence CC BY-SA 4.0.
|
||||
|
||||
## Alternatives écartées
|
||||
|
||||
- **Accent turquoise** : plus froid ; la brique s'accorde mieux au bois et au
|
||||
café.
|
||||
- **Piste B (le videau)** : écartée au premier tour, au profit des pions.
|
||||
- **Pions vus de face (A1) ou en léger relief sans flèche (P1)** : appréciés,
|
||||
mais la flèche rattache le symbole au plateau et fait écho au logotype.
|
||||
- **Filets brique sur les deux pions (P3c)** : trop de brique dans un petit
|
||||
symbole.
|
||||
- **Logotype aux flèches pleines (L2)** : les « mm » s'y lisaient moins vite ;
|
||||
le trait (L1) garde la lisibilité, et l'alternance de couleur (L3) apporte
|
||||
le rappel du plateau.
|
||||
- **Fond d'icône noyer** : moins lumineux sur un écran d'accueil.
|
||||
|
||||
## Conséquences
|
||||
|
||||
- Le design system (couleurs des deux thèmes, typographie, composants) part de
|
||||
cette palette et de cette police.
|
||||
- La police Alegreya Sans devra être embarquée dans la PWA (fonctionnement hors
|
||||
ligne) ; sa licence OFL le permet, avec sa notice.
|
||||
- Le favicon utilise un dessin simplifié du symbole, sans filets, illisibles
|
||||
en dessous de 32 px.
|
||||
- Les icônes Android (premier plan, arrière-plan, monochrome) sont fournies en
|
||||
SVG ; leur conversion en `VectorDrawable` se fera avec l'application Android.
|
||||
@@ -0,0 +1,59 @@
|
||||
# 0011. Leçons numérotées, conseil du maître après le coup, bilan de fin de partie
|
||||
|
||||
- **Statut** : accepté
|
||||
- **Date** : 2026-11-03
|
||||
- **Décideurs** : Pierre
|
||||
|
||||
## Contexte
|
||||
|
||||
Le cadrage (`docs/cadrage.md`) prévoit pour la V1 un coach en direct, un écran
|
||||
de fin de partie et des leçons par concept, sans en fixer la forme. Les
|
||||
maquettes des écrans (https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe),
|
||||
faites avec la charte graphique (ADR 0010), en ont proposé une. Pierre en a
|
||||
retenu trois éléments le 2026-11-03.
|
||||
|
||||
Un point des maquettes contredisait le cadrage : le conseil apparaissait avant
|
||||
que le joueur ne joue, en donnant la réponse. Pierre a tranché pour un
|
||||
commentaire après le coup.
|
||||
|
||||
## Décision
|
||||
|
||||
- **Leçons numérotées** : un parcours de leçons dans un ordre fixe
|
||||
(« Leçon 1 », « Leçon 2 »…). Chaque leçon affiche son état (à commencer,
|
||||
« 3 exercices sur 5 », terminée) et sa progression. L'accueil propose de
|
||||
continuer la leçon en cours.
|
||||
- **Conseil du maître** : c'est la forme du coach en direct du cadrage. Il
|
||||
commente le coup **après** que le joueur l'a joué, jamais avant. Il donne
|
||||
l'appréciation du moteur avec un mot et une icône (bon coup, imprécision,
|
||||
erreur), puis une phrase du maître qui dit quel coup il aurait joué et
|
||||
pourquoi, avec un lien pour en savoir plus. L'écart d'équité n'apparaît que
|
||||
sur demande. Il reste désactivable, comme le prévoit le cadrage.
|
||||
- **Bilan de fin de partie** : le résultat, le décompte des coups par
|
||||
appréciation (bons coups, imprécisions, erreurs), « le coup à revoir »
|
||||
(la plus grosse erreur, avec sa position, le coup joué et le meilleur coup)
|
||||
et le prompt prêt à copier pour une IA.
|
||||
|
||||
Les maquettes de référence sont les écrans « Plateau de jeu », « Leçon et
|
||||
aide » et « Fin de partie » du canevas ci-dessus.
|
||||
|
||||
## Alternatives écartées
|
||||
|
||||
- **Conseil avant le coup, avec la réponse** : le joueur n'essaie plus par
|
||||
lui-même, et on n'apprend pas en recopiant.
|
||||
- **Indice avant le coup, sans la réponse, en plus du commentaire après** :
|
||||
écarté pour l'instant au profit d'un seul mécanisme simple. L'« indice » de
|
||||
la liste des fonctions du cadrage reste à concevoir séparément.
|
||||
|
||||
## Conséquences
|
||||
|
||||
- Le commentaire après le coup demande une analyse du coup joué par le moteur
|
||||
(classement des coups et écart avec le meilleur). Elle doit tenir dans le
|
||||
budget de temps du téléphone, en arrière-plan, sans retarder le tour
|
||||
suivant.
|
||||
- Les seuils entre « bon coup », « imprécision » et « erreur » sont à fixer,
|
||||
en s'appuyant sur ceux de GNU Backgammon (doubtful, bad, very bad).
|
||||
- Les phrases du maître doivent rester exactes : elles s'appuient sur les
|
||||
coups et les chiffres du moteur, jamais sur une explication inventée.
|
||||
- Les leçons sont des contenus sous CC BY-SA 4.0, à écrire et à faire relire
|
||||
par un joueur fort (cadrage, risque « contenus longs à produire ») ; leur
|
||||
progression est stockée localement.
|
||||
@@ -0,0 +1,55 @@
|
||||
# 0012. Mode immersif : le plateau en paysage, sur demande
|
||||
|
||||
- **Statut** : accepté
|
||||
- **Date** : 2026-11-03
|
||||
- **Décideurs** : Pierre
|
||||
|
||||
## Contexte
|
||||
|
||||
Sur l'écran de jeu en portrait, le plateau n'occupe qu'environ 35 % de l'écran
|
||||
d'un téléphone (pions de 24 px sur un écran de 390 px de large). Pierre le
|
||||
trouve peu immersif et a demandé un mode où le plateau prend le maximum de
|
||||
l'écran.
|
||||
|
||||
Deux pistes ont été maquettées
|
||||
(https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe, rangée « Mode immersif ») :
|
||||
le téléphone en paysage, plateau sur toute la hauteur ; ou le portrait avec le
|
||||
plateau tourné d'un quart de tour. Toutes deux donnent environ 57 % de l'écran
|
||||
au plateau et des pions de 30 px : le petit côté de l'écran limite la taille
|
||||
des pions dans les deux cas.
|
||||
|
||||
## Décision
|
||||
|
||||
- Un **mode immersif en paysage** : le plateau occupe toute la hauteur, dans
|
||||
son orientation habituelle. À gauche : le menu, les comptes de points et la
|
||||
consigne. À droite : l'aide et les actions. Le fond est en noyer jusqu'aux
|
||||
bords de l'écran.
|
||||
- On y entre **par un geste explicite** : un bouton « Plein écran » sur l'écran
|
||||
de jeu en portrait. On en sort par le menu ou par le retour du téléphone.
|
||||
- Le bouton force la vue paysage même si le téléphone est tenu droit ou si sa
|
||||
rotation automatique est verrouillée : passage en plein écran
|
||||
(`requestFullscreen`), puis verrouillage de l'orientation
|
||||
(`screen.orientation.lock("landscape")`).
|
||||
- Si le verrouillage est refusé (navigateur ou système qui ne le permet pas,
|
||||
iPhone), l'app affiche la vue paysage tournée d'un quart de tour dans l'écran
|
||||
portrait. Le résultat est le même en main.
|
||||
- L'écran de jeu en portrait reste la vue par défaut, pour jouer d'une main.
|
||||
|
||||
## Alternatives écartées
|
||||
|
||||
- **Plateau tourné en portrait** : il change la lecture du plateau (numéros de
|
||||
côté, camps à gauche et à droite) et risque de dérouter les débutants habitués
|
||||
à une vraie table.
|
||||
- **Bascule automatique quand on tourne le téléphone** : elle ne marche pas si
|
||||
la rotation est verrouillée, et elle surprend en cours de partie. Elle reste
|
||||
possible en plus du bouton, plus tard.
|
||||
|
||||
## Conséquences
|
||||
|
||||
- Le rendu du plateau doit s'adapter à deux mises en page (portrait et paysage)
|
||||
sans changer le domaine ni le moteur : seule la vue change (ADR 0007).
|
||||
- `screen.orientation.lock` n'est accepté qu'en plein écran, et pas partout :
|
||||
la solution de repli par rotation CSS est obligatoire, et elle doit être
|
||||
testée (`make test-browser`).
|
||||
- Le plein écran masque la barre d'état du téléphone, ce qui libère encore un
|
||||
peu de place.
|
||||
@@ -15,3 +15,7 @@ l'ancien passe au statut « remplacé par NNNN ». Voir l'ADR 0001.
|
||||
| [0006](0006-merge-requests-systematiques.md) | Merge requests systématiques, fusionnées par Claude Code | accepté |
|
||||
| [0007](0007-architecture-et-conventions-de-code.md) | Architecture et conventions de code | accepté |
|
||||
| [0008](0008-glossaire-et-scenarios-source-unique.md) | Glossaire et scénarios : une source unique pour le code, l'aide et les tests | accepté |
|
||||
| [0009](0009-socle-pwa-typescript.md) | Socle : PWA en TypeScript, moteur en WebAssembly | accepté |
|
||||
| [0010](0010-identite-visuelle.md) | Identité visuelle : symbole, logotype, palette | accepté |
|
||||
| [0011](0011-lecons-conseil-et-bilan.md) | Leçons numérotées, conseil du maître après le coup, bilan de fin de partie | accepté |
|
||||
| [0012](0012-mode-immersif.md) | Mode immersif : le plateau en paysage, sur demande | accepté |
|
||||
|
||||
+54
-11
@@ -1,7 +1,9 @@
|
||||
# Déploiement
|
||||
|
||||
Ustagammon est un site statique (PWA, ADR 0009) : des fichiers HTML,
|
||||
JavaScript, le moteur en WebAssembly et ses données. Il est publié sur
|
||||
JavaScript, le moteur en WebAssembly et ses données. L'application est à la
|
||||
racine ; les pages de test du moteur de l'étape 0b restent publiées sous
|
||||
`/moteur/` (test du moteur) et `/moteur/bench.html` (mesure). Il est publié sur
|
||||
CapRover, machine `sans-pub` (https://captain.cloud.sans.pub), app
|
||||
`ustagammon`, sur https://ustagammon.sans.pub.
|
||||
|
||||
@@ -46,31 +48,72 @@ make deploy-prod`.
|
||||
|
||||
## Ce qui est publié
|
||||
|
||||
- `make site` assemble `build/site/` : le contenu de `web/` à la racine, le
|
||||
moteur (`engine.mjs`, `engine.wasm`, `engine.data`, `positions.json`) sous
|
||||
`wasm/`, et `version.json` avec le commit publié.
|
||||
- `make site` assemble `build/site/` (9 Mo) :
|
||||
- le contenu de `web/` à la racine : la page de l'application
|
||||
(`index.html`, `app.css`), le manifeste (`manifest.webmanifest`), les
|
||||
icônes (`icons/`), le service worker (`sw.js`), le Web Worker du moteur
|
||||
(`engine-worker.mjs`, `engine-wasm.mjs`) et les pages de test sous
|
||||
`moteur/` ;
|
||||
- l'application TypeScript compilée (`build/web/src/`) sous `app/` ;
|
||||
- le moteur (`engine.mjs`, `engine.wasm`, `engine.data`, `positions.json`)
|
||||
sous `wasm/` ;
|
||||
- des copies de `docs/glossaire/` et `docs/scenarios/` sous `docs/`, lues
|
||||
par l'aide de l'application (ADR 0008) ;
|
||||
- `version.json` avec le commit publié ;
|
||||
- enfin, `scripts/service-worker.sh` écrit en tête de `sw.js` la liste de
|
||||
tous ces fichiers et une empreinte de leur contenu.
|
||||
- `make package` ajoute `deploy/` et produit `build/ustagammon.tar` (environ
|
||||
9 Mo).
|
||||
9 Mo, 7,3 Mo transférés grâce à la compression).
|
||||
- `tests/test_site.sh` (dans `make test`) construit l'image de production en
|
||||
local, la lance et vérifie ce que reçoit un navigateur : pages, types MIME
|
||||
(`application/wasm` pour le moteur), compression gzip des données, en-têtes,
|
||||
et commit de `version.json`.
|
||||
local, la lance et vérifie ce que reçoit un navigateur : application, pages
|
||||
de test, aide, manifeste et icônes, liste du service worker, types MIME
|
||||
(`application/wasm` pour le moteur), compression gzip des données,
|
||||
en-têtes dont la politique de sécurité, et commit de `version.json`.
|
||||
- `make test-browser` (hors de `make test`, plusieurs minutes) joue une
|
||||
partie complète par l'interface dans Chromium et Firefox sans écran, sur
|
||||
la même image, puis vérifie la reprise, l'aide, le hors ligne (Chromium
|
||||
seulement : Firefox sous Playwright refuse toute navigation « hors
|
||||
ligne », on y vérifie que le cache est complet et que la page rechargée
|
||||
est servie par le service worker) et la politique de sécurité. Captures
|
||||
d'écran dans `build/browser-shots/`.
|
||||
|
||||
**Hors ligne et mises à jour.** Le service worker met tous les fichiers du
|
||||
site en cache à la première visite (environ 9 Mo), puis sert tout depuis ce
|
||||
cache, avec ou sans réseau. À chaque publication, l'empreinte écrite dans
|
||||
`sw.js` change dès qu'un fichier a changé : le navigateur, qui revérifie
|
||||
`sw.js` à chaque ouverture, installe la nouvelle version (tout le site est
|
||||
retéléchargé), qui prend la main et efface l'ancien cache. La page déjà
|
||||
ouverte continue sur l'ancienne version ; le lancement suivant utilise la
|
||||
nouvelle. Une publication sans changement de fichier garde le même `sw.js` :
|
||||
rien n'est retéléchargé. Le service worker exige https (ou `localhost`) :
|
||||
avec `make deploy`, en http sur le réseau local, l'application fonctionne,
|
||||
mais pas hors ligne.
|
||||
|
||||
Réglages du serveur (`deploy/Caddyfile`) : compression zstd ou gzip, y compris
|
||||
pour les données du moteur ; `Cache-Control: no-cache` (les noms de fichiers ne
|
||||
changent pas d'une version à l'autre, le navigateur revalide chaque fichier) ;
|
||||
`X-Content-Type-Options: nosniff` ; `Referrer-Policy: no-referrer`.
|
||||
`X-Content-Type-Options: nosniff` ; `Referrer-Policy: no-referrer` ; et une
|
||||
politique de sécurité du contenu (`Content-Security-Policy`) : tout vient du
|
||||
site lui-même, aucun script ni style en ligne, aucun `eval`, seule la
|
||||
compilation du WebAssembly est permise (`'wasm-unsafe-eval'`). Elle est
|
||||
vérifiée par `tests/test_site.sh` (en-tête présent) et par
|
||||
`make test-browser` : aucune violation signalée par Chromium ni Firefox
|
||||
pendant toute une partie (moteur, Web Worker, service worker, aide), et un
|
||||
script en ligne ajouté exprès à la page est bien bloqué.
|
||||
|
||||
## Vérifier
|
||||
|
||||
```bash
|
||||
curl -s https://ustagammon.sans.pub/version.json # commit publié
|
||||
curl -sI https://ustagammon.sans.pub/wasm/engine.wasm # application/wasm
|
||||
curl -sI https://ustagammon.sans.pub/ | grep -i content-security # CSP
|
||||
curl -s https://ustagammon.sans.pub/sw.js | head -2 # version du cache
|
||||
ssh sans.pub 'sudo docker service ps srv-captain--ustagammon --format "{{.Image}} {{.CurrentState}}" | head -2'
|
||||
```
|
||||
|
||||
Puis ouvrir le site sur le téléphone : la page de test doit afficher « Moteur
|
||||
prêt ».
|
||||
Puis ouvrir le site sur le téléphone : le plateau s'affiche et une consigne
|
||||
remplace « Chargement du moteur… ». La page de test du moteur
|
||||
(https://ustagammon.sans.pub/moteur/) doit afficher « Moteur prêt ».
|
||||
|
||||
## Retour arrière
|
||||
|
||||
|
||||
@@ -13,14 +13,19 @@ Acquis : socle du dépôt, organisation (ADR 0001, 0003, 0006), source du moteur
|
||||
(ADR 0005 : gnubg officiel, commit 14b6798), gnubg de référence et 32 positions
|
||||
de référence (0a.2), moteur embarqué et `engine-cli` (0a.3), comparaison
|
||||
automatique aux références, tolérance 0,002 (0a.4), moteur en WebAssembly avec
|
||||
page de test, page de mesure et guide de test (0b).
|
||||
page de test, page de mesure et guide de test (0b), mesures sur le Fairphone 4 et
|
||||
socle PWA en TypeScript (ADR 0009 ; 0c Android natif abandonnée), domaine
|
||||
« partie » en journal d'événements avec scénario exécuté sur le vrai moteur et
|
||||
garde-fous d'architecture (0d.1), déploiement sur https://ustagammon.sans.pub.
|
||||
|
||||
| Sous-étape | Contenu | État | Plan |
|
||||
| --- | --- | --- | --- |
|
||||
| Mesures | Pierre relève les mesures sur le Fairphone 4, en suivant `docs/guide-test-etape-0.md` | 🔄 | |
|
||||
| Décision | Socle PWA ou Android natif, consigné dans un ADR — validation de Pierre | ⏳ | |
|
||||
| 0c | Android natif (NDK, Gradle en ligne de commande, `make deploy` via adb) | ⏸ si 0b échoue | |
|
||||
| 0d | Plateau minimal jouable sur le socle retenu ; vérifié avec Pierre en suivant `docs/scenarios/jouer-une-partie.feature` | ⏳ | |
|
||||
| 0d.2 | Plateau minimal jouable (PWA hors ligne), publié ; reste la vérification avec Pierre sur le Fairphone 4 (`docs/guide-test-etape-0.md`, section « Étape 0d ») | 🔄 | |
|
||||
| 0e.1 | Saisie du coup : pion à destination unique joué en un toucher, coup à valider et annulable demi-coup par demi-coup, dés joués marqués, dés des deux côtés touchables, videau confirmé ; pages de test du moteur retirées | 🔄 | `plans/2026-11-03-saisie-du-coup.md` |
|
||||
| 0e.2 | Revue UX par un designer UI : compte de points, fluidité (bouton « Nouvelle partie », interruptions), paysage ; propositions à valider par Pierre | 🔄 | `plans/2026-11-03-revue-ux.md` |
|
||||
| 0e.3 | Paysage sur téléphone : plateau sur presque tout l'écran, contrôles en pictogrammes (ADR 0012 à amender), selon la revue validée | ⏳ | |
|
||||
| 0e.4 | Position dans l'adresse : chaque position du plateau a un lien direct (nouvel ADR pour le format) | ⏳ | |
|
||||
| 0e.5 | Page d'accueil, installation en un toucher (« Ajouter à l'écran d'accueil », proposée par l'app), tutoriel des règles très didactique avec plateaux illustrés, aide réécrite sur un ton plus humain ; textes à valider par Pierre | ⏳ | |
|
||||
|
||||
**Critère de fin** : une partie complète jouée sur le Fairphone 4, moins de 2 s
|
||||
par coup de l'IA en niveau standard, tous les tests au vert.
|
||||
@@ -29,7 +34,7 @@ par coup de l'IA en niveau standard, tous les tests au vert.
|
||||
|
||||
| Étape | Contenu | État |
|
||||
| --- | --- | --- |
|
||||
| 1. V1 Jouer et comprendre | Plateau soigné, niveaux, coach, analyse, branches, tutoriel, prompts, sauvegarde | ⏳ |
|
||||
| 1. V1 Jouer et comprendre | Charte graphique appliquée à la PWA (ADR 0010, `docs/identite/charte/`), plateau soigné, niveaux, conseil du maître après le coup, bilan de fin de partie, premières leçons numérotées (ADR 0011), mode immersif en paysage (ADR 0012), analyse, branches, tutoriel, prompts, sauvegarde | ⏳ |
|
||||
| 2. V1.5 Apprendre | Parcours 2, exercices, progression | ⏳ |
|
||||
| 3. V2 Perfectionnement et IA | Parcours 3 et 4, rollouts, révision espacée | ⏳ |
|
||||
|
||||
|
||||
@@ -26,7 +26,10 @@ Voir aussi : [Doubler](doubler.md)
|
||||
|
||||
`code` est facultatif : il désigne le type du domaine qui implémente le terme,
|
||||
dès qu'il existe. Dans le code, ce type porte en commentaire le chemin de sa
|
||||
fiche (`Glossaire : docs/glossaire/videau.md`).
|
||||
fiche (`Glossaire : docs/glossaire/videau.md`), juste avant sa déclaration
|
||||
exportée. `make test` vérifie le lien dans les deux sens : chaque fiche avec
|
||||
`code` est reliée à ce type, chaque référence du code mène à une fiche dont le
|
||||
`code` est le type qui la porte.
|
||||
|
||||
## Termes
|
||||
|
||||
@@ -38,6 +41,7 @@ fiche (`Glossaire : docs/glossaire/videau.md`).
|
||||
| [Branche](branche.md) | Branch |
|
||||
| [Compte de points](compte-de-points.md) | Pip count |
|
||||
| [Coup](coup.md) | Move |
|
||||
| [Demi-coup](demi-coup.md) | Half-move |
|
||||
| [Course](course.md) | Race |
|
||||
| [Doubler](doubler.md) | Double |
|
||||
| [Équité](equite.md) | Equity |
|
||||
@@ -51,6 +55,7 @@ fiche (`Glossaire : docs/glossaire/videau.md`).
|
||||
| [Partie](partie.md) | Game |
|
||||
| [Passer](passer.md) | Drop |
|
||||
| [Pion](pion.md) | Checker |
|
||||
| [Plateau](plateau.md) | Board |
|
||||
| [Pli](pli.md) | Ply |
|
||||
| [Point](point.md) | Point |
|
||||
| [Prendre](prendre.md) | Take |
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Coup
|
||||
english: Move
|
||||
code: Move
|
||||
---
|
||||
# Coup
|
||||
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
---
|
||||
term: Demi-coup
|
||||
english: Half-move
|
||||
code: HalfMove
|
||||
---
|
||||
# Demi-coup
|
||||
|
||||
**En bref** : le déplacement d'un pion avec un seul dé, par exemple 8/5 avec un 3 ; un coup en compte deux, ou quatre avec un double.
|
||||
|
||||
On saisit son coup demi-coup par demi-coup : l'application n'accepte que ceux
|
||||
qui mènent à un coup permis. Pour un pion qui sort, la case d'arrivée se note
|
||||
« off » (6/off) ; pour un pion qui rentre depuis la barre, la case de départ se
|
||||
note « bar » (bar/22).
|
||||
|
||||
Voir aussi : [Coup](coup.md), [Jet](jet.md), [Barre](barre.md), [Sortie](sortie.md)
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Événement de partie
|
||||
english: Game event
|
||||
code: GameEvent
|
||||
---
|
||||
# Événement de partie
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Identifiant de position
|
||||
english: Position ID
|
||||
code: PositionId
|
||||
---
|
||||
# Identifiant de position
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Jet
|
||||
english: Roll
|
||||
code: Roll
|
||||
---
|
||||
# Jet
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Moteur
|
||||
english: Engine
|
||||
code: Engine
|
||||
---
|
||||
# Moteur
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Partie
|
||||
english: Game
|
||||
code: Game
|
||||
---
|
||||
# Partie
|
||||
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
---
|
||||
term: Plateau
|
||||
english: Board
|
||||
code: Board
|
||||
---
|
||||
# Plateau
|
||||
|
||||
**En bref** : la surface de jeu, avec ses 24 cases (les points), la barre au milieu, et les pions de chaque joueur.
|
||||
|
||||
Chaque joueur numérote les cases de son point de vue : sa case 1 est la plus
|
||||
proche de sa sortie, sa case 24 la plus éloignée, qui est la case 1 de
|
||||
l'adversaire.
|
||||
|
||||
Voir aussi : [Point](point.md), [Pion](pion.md), [Barre](barre.md), [Identifiant de position](identifiant-de-position.md)
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Pli
|
||||
english: Ply
|
||||
code: Ply
|
||||
---
|
||||
# Pli
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
---
|
||||
term: Videau
|
||||
english: Cube
|
||||
code: Cube
|
||||
---
|
||||
# Videau
|
||||
|
||||
|
||||
+100
-14
@@ -1,38 +1,124 @@
|
||||
# Guide de test : le moteur sur le Fairphone 4 (étape 0b)
|
||||
# Guide de test : Ustagammon sur le Fairphone 4 (étape 0)
|
||||
|
||||
Document temporaire de l'étape 0 : il sera supprimé avec `docs/etape-0.md`.
|
||||
|
||||
Deux tests sur le téléphone :
|
||||
|
||||
- **Étape 0d : jouer une partie** (section suivante), sur le site publié ;
|
||||
- **Étape 0b : mesurer le moteur** (fait le 2026-11-02), sur une page
|
||||
servie par le PC.
|
||||
|
||||
## Étape 0d : jouer une partie sur le téléphone
|
||||
|
||||
Le but : installer l'application sur le Fairphone 4, jouer une partie
|
||||
complète contre l'ordinateur, vérifier qu'elle marche sans réseau, et
|
||||
rapporter ce que vous avez constaté. Comptez une demi-heure.
|
||||
|
||||
### Ouvrir et installer l'application
|
||||
|
||||
1. Sur le Fairphone, ouvrez Chrome et allez sur https://ustagammon.sans.pub.
|
||||
2. Attendez que le plateau s'affiche et que le message « Chargement du
|
||||
moteur… » laisse place à une consigne (par exemple « À vous : lancez les
|
||||
dés. » ou « L'ordinateur réfléchit… »). La première fois, le moteur se
|
||||
télécharge (environ 7 Mo) : quelques secondes en Wi-Fi.
|
||||
3. Installez l'application : menu de Chrome (les trois points), puis
|
||||
« Installer l'application » ou « Ajouter à l'écran d'accueil ». Une icône
|
||||
(deux pions sur du bois) apparaît sur l'écran d'accueil.
|
||||
4. Fermez Chrome et ouvrez Ustagammon depuis cette icône : l'application
|
||||
s'ouvre en plein écran, sans barre d'adresse.
|
||||
|
||||
### Jouer une partie complète
|
||||
|
||||
Suivez le scénario « Jouer une partie contre l'ordinateur »
|
||||
(`docs/scenarios/jouer-une-partie.feature`), qui est aussi l'aide de
|
||||
l'application : bouton « Aide », en haut.
|
||||
|
||||
1. Une partie commence d'elle-même au premier lancement, par le jet
|
||||
d'ouverture (un dé chacun) : le message dit qui commence. « Nouvelle
|
||||
partie », en haut, en recommence une.
|
||||
2. Quand c'est à vous : touchez « Lancer les dés » (ou « Doubler », pour
|
||||
proposer de doubler avant de lancer).
|
||||
3. Pour jouer : touchez un pion entouré de vert, puis l'une des cases
|
||||
d'arrivée en surbrillance ; recommencez pour chaque dé. Pour sortir un
|
||||
pion, touchez le bac à droite, en bas. « Annuler » remet les pions du coup
|
||||
en cours à leur place.
|
||||
4. Le coup est envoyé dès qu'il est complet ; l'ordinateur joue ensuite, et
|
||||
le message dit son coup et son temps de calcul, par exemple
|
||||
« L'ordinateur a joué 6-4 : 24/18 13/9 (0,3 s) ». Les petits points
|
||||
orange marquent ses cases de départ et d'arrivée (dans sa numérotation :
|
||||
sa case 24 est votre case 1).
|
||||
5. Si l'ordinateur vous propose de doubler : « Prendre » ou « Passer ».
|
||||
Essayez au moins une fois de doubler vous-même.
|
||||
6. En fin de partie, le message donne le gagnant, la sorte de victoire
|
||||
(simple, gammon ou backgammon) et les points.
|
||||
|
||||
En cours de partie, fermez l'application (balayez-la dans la liste des
|
||||
applications ouvertes), puis rouvrez-la : la partie doit reprendre là où vous
|
||||
en étiez.
|
||||
|
||||
### Vérifier le hors ligne
|
||||
|
||||
1. Après avoir ouvert l'application au moins une fois (attendez une
|
||||
vingtaine de secondes après le premier chargement, le temps que tout soit
|
||||
mis de côté), fermez-la.
|
||||
2. Passez le téléphone en mode avion.
|
||||
3. Rouvrez Ustagammon depuis son icône : le plateau, l'ordinateur et l'aide
|
||||
doivent fonctionner comme avant.
|
||||
4. Repassez en mode normal.
|
||||
|
||||
### Ce qu'il faut rapporter
|
||||
|
||||
Dans la conversation avec Claude Code :
|
||||
|
||||
- les **temps des coups de l'ordinateur** : ceux affichés dans les messages
|
||||
(le plus long que vous avez vu), et votre ressenti (attente gênante ou
|
||||
non) ;
|
||||
- si la partie est allée **jusqu'au bout**, et son résultat ;
|
||||
- si la **reprise** après fermeture et le **mode avion** ont marché ;
|
||||
- tout ce qui gêne : plateau trop petit, case difficile à toucher, texte
|
||||
incompréhensible, bouton qui ne répond pas, couleurs peu lisibles (thème
|
||||
clair ou sombre du téléphone) ;
|
||||
- une **capture d'écran** (bouton marche + volume bas) de tout problème.
|
||||
|
||||
Si vous le pouvez, refaites l'essai dans Firefox sur le téléphone (sans
|
||||
l'installer) et dites si les temps de l'ordinateur sont nettement plus longs.
|
||||
|
||||
## Étape 0b : mesurer le moteur
|
||||
|
||||
Le but : ouvrir sur le téléphone une page web où le moteur de backgammon
|
||||
calcule, puis lancer une mesure et coller son rapport dans la conversation.
|
||||
Comptez un quart d'heure.
|
||||
|
||||
## 1. Préparer le PC
|
||||
### 1. Préparer le PC
|
||||
|
||||
1. Ouvrez un terminal dans le dossier du projet (`~/Code/ustagammon`).
|
||||
2. Si ce n'est pas déjà fait, tapez `make setup` puis Entrée. Cela prépare les
|
||||
outils. La première fois, c'est long ; ensuite, c'est immédiat.
|
||||
3. Le PC et le téléphone doivent être sur **le même Wi-Fi** (la même box).
|
||||
|
||||
## 2. Lancer la page
|
||||
### 2. Lancer la page
|
||||
|
||||
1. Tapez `make deploy-web` puis Entrée.
|
||||
1. Tapez `make deploy` puis Entrée.
|
||||
2. La première fois, le moteur se compile : quelques minutes.
|
||||
3. Le terminal affiche deux adresses, par exemple :
|
||||
|
||||
```
|
||||
Page de test : http://192.168.1.21:8080/
|
||||
Page de mesure : http://192.168.1.21:8080/bench.html
|
||||
Application : http://192.168.1.21:8080/
|
||||
Test du moteur : http://192.168.1.21:8080/moteur/
|
||||
Page de mesure : http://192.168.1.21:8080/moteur/bench.html
|
||||
```
|
||||
|
||||
Vos chiffres peuvent être différents : notez ceux de votre écran.
|
||||
4. Laissez ce terminal ouvert pendant tout le test. Pour arrêter la page à la
|
||||
fin : Ctrl+C dans le terminal.
|
||||
|
||||
## 3. Essayer un meilleur coup
|
||||
### 3. Essayer un meilleur coup
|
||||
|
||||
1. Sur le Fairphone, ouvrez le navigateur (Chrome ou Firefox).
|
||||
2. Tapez l'adresse de la **page de test** dans la barre d'adresse, exactement
|
||||
comme affichée (avec `http://` et `:8080`).
|
||||
2. Tapez l'adresse du **test du moteur** dans la barre d'adresse, exactement
|
||||
comme affichée (avec `http://` et `:8080`). Les pages de test sont aussi
|
||||
publiées : https://ustagammon.sans.pub/moteur/ et
|
||||
https://ustagammon.sans.pub/moteur/bench.html.
|
||||
3. Attendez le message « Moteur prêt, chargé en … ms ».
|
||||
4. Dans « Exemple », choisissez une position, par exemple « middlegame-1 ».
|
||||
5. Dans « Niveau », choisissez « fort (2 plis) ».
|
||||
@@ -40,7 +126,7 @@ Comptez un quart d'heure.
|
||||
7. La page affiche le coup conseillé et le **temps de calcul**. Notez ce temps
|
||||
si vous voulez, il sera aussi dans le rapport.
|
||||
|
||||
## 4. Lancer la mesure
|
||||
### 4. Lancer la mesure
|
||||
|
||||
1. En bas de la page, touchez « Page de mesure » (ou tapez l'adresse de la
|
||||
page de mesure).
|
||||
@@ -50,7 +136,7 @@ Comptez un quart d'heure.
|
||||
4. Un tableau résume les résultats : « OK » si le seuil est respecté,
|
||||
« dépassé » sinon.
|
||||
|
||||
## 5. Envoyer le rapport
|
||||
### 5. Envoyer le rapport
|
||||
|
||||
1. Touchez « Copier les résultats ».
|
||||
2. Si la page dit « Rapport copié », c'est bon.
|
||||
@@ -65,7 +151,7 @@ sont stables. Si les deux navigateurs sont installés, faites la mesure dans
|
||||
Chrome **et** dans Firefox : sur le PC, Firefox s'est montré nettement plus
|
||||
lent, et le rapport indique le navigateur utilisé.
|
||||
|
||||
## Si la page ne s'ouvre pas
|
||||
### Si la page ne s'ouvre pas
|
||||
|
||||
- **Vérifiez l'adresse** : `http://` (et non `https://`), les chiffres exacts,
|
||||
et `:8080` à la fin.
|
||||
@@ -73,7 +159,7 @@ lent, et le rapport indique le navigateur utilisé.
|
||||
pas sur la 4G ni sur un Wi-Fi invité.
|
||||
- **Vérifiez que la page tourne** : sur le PC, ouvrez
|
||||
`http://localhost:8080/` dans un navigateur. Si elle ne s'ouvre pas non
|
||||
plus, relancez `make deploy-web` et lisez le message d'erreur.
|
||||
plus, relancez `make deploy` et lisez le message d'erreur.
|
||||
- **Le pare-feu du PC** peut bloquer le téléphone. S'il est actif
|
||||
(`sudo ufw status` affiche « Status: active »), autorisez le port le temps
|
||||
du test : `sudo ufw allow 8080/tcp`, puis à la fin `sudo ufw delete allow
|
||||
@@ -82,4 +168,4 @@ lent, et le rapport indique le navigateur utilisé.
|
||||
collez-le dans la conversation. Essayez aussi l'autre navigateur (Chrome ou
|
||||
Firefox), à jour.
|
||||
- **Le port 8080 est déjà pris** : un autre programme l'utilise. Lancez
|
||||
`make deploy-web WEB_PORT=8081` et utilisez `:8081` dans l'adresse.
|
||||
`make deploy WEB_PORT=8081` et utilisez `:8081` dans l'adresse.
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
# Identité visuelle d'Ustagammon
|
||||
|
||||
Décision et historique des choix : ADR 0010 (`docs/adr/0010-identite-visuelle.md`).
|
||||
Brief créatif : https://claude.ai/artifact/36WMwZWqvMxXvSSVBJTgwd
|
||||
|
||||
Les dessins de ce dossier sont sous licence **CC BY-SA 4.0**. Le logotype
|
||||
utilise des tracés de la police **Alegreya Sans Bold** (Juan Pablo del Peral,
|
||||
Huerta Tipográfica), sous licence SIL Open Font License 1.1.
|
||||
|
||||
## Fichiers (`logo/`)
|
||||
|
||||
| Fichier | Usage |
|
||||
| --- | --- |
|
||||
| `symbole-couleur.svg` | Symbole seul, sur fond clair |
|
||||
| `symbole-sombre.svg` | Symbole seul, sur fond sombre |
|
||||
| `symbole-noir.svg`, `symbole-blanc.svg` | Monochromes, fond transparent |
|
||||
| `logotype-*.svg` | Le nom seul, mêmes quatre déclinaisons |
|
||||
| `logo-horizontal-*.svg` | Symbole et nom côte à côte, mêmes déclinaisons |
|
||||
| `icone.svg`, `icone-192.png`, `icone-512.png` | Icône de la PWA (`purpose: any`) |
|
||||
| `icone-maskable.svg`, `icone-maskable-192.png`, `icone-maskable-512.png` | Icône de la PWA (`purpose: maskable`), symbole dans la zone de sécurité |
|
||||
| `apple-touch-icon-180.png` | Ajout à l'écran d'accueil sur iPhone (via le navigateur) |
|
||||
| `favicon.svg`, `favicon-16.png`, `favicon-32.png`, `favicon-48.png` | Onglet du navigateur ; dessin simplifié, sans filets |
|
||||
| `android-premier-plan.svg`, `android-arriere-plan.svg`, `android-monochrome.svg` | Couches de l'icône adaptative Android (canevas 108 dp), pour plus tard |
|
||||
|
||||
## Couleurs du logo
|
||||
|
||||
| Rôle | Clair | Sombre |
|
||||
| --- | --- | --- |
|
||||
| Noyer (pion maître) | `#4A2E1F` | idem |
|
||||
| Ivoire (pion apprenti, fond d'icône) | `#F3EAD8` | idem |
|
||||
| Brique (flèche, filet, « mm ») | `#A8432B` | `#D0694B` (flèches du logotype), `#C9583C` (flèche du symbole) |
|
||||
| Texte du logotype | `#2B1D15` | `#F3EAD8` |
|
||||
|
||||
## Régénérer
|
||||
|
||||
Les fichiers sont versionnés ; il n'est utile de les régénérer qu'en cas de
|
||||
retouche du dessin. Il faut Python 3 avec fontTools (licence MIT) et la police
|
||||
Alegreya Sans Bold :
|
||||
|
||||
```sh
|
||||
mkdir -p build/police
|
||||
curl -sSLf -o build/police/AlegreyaSans-Bold.ttf \
|
||||
https://github.com/google/fonts/raw/main/ofl/alegreyasans/AlegreyaSans-Bold.ttf
|
||||
python3 -I docs/identite/generer-logo.py build/police/AlegreyaSans-Bold.ttf docs/identite/logo
|
||||
```
|
||||
|
||||
Les PNG sont des rendus des SVG par Chrome sans interface
|
||||
(`google-chrome --headless --screenshot`), à la taille indiquée dans leur nom.
|
||||
|
||||
## Police de l'application
|
||||
|
||||
`web/fonts/` contient Alegreya Sans en cinq graisses, réduite aux caractères
|
||||
latins (français compris) et convertie en woff2, soit 143 Ko au lieu de
|
||||
1,3 Mo en TTF. Pour la refaire, depuis les TTF de
|
||||
https://github.com/google/fonts/tree/main/ofl/alegreyasans (Python 3,
|
||||
fontTools et brotli, par exemple dans l'image `emscripten/emsdk`) :
|
||||
|
||||
```sh
|
||||
pip install fonttools brotli
|
||||
for f in Regular Italic Medium Bold ExtraBold; do
|
||||
python3 -m fontTools.subset AlegreyaSans-$f.ttf \
|
||||
--output-file=web/fonts/AlegreyaSans-$f.woff2 --flavor=woff2 \
|
||||
--unicodes="U+0020-007E,U+00A0-00FF,U+0152-0153,U+0178,U+02BC,U+02C6,U+02DC,U+2009,U+2011,U+2013-2014,U+2018-201E,U+2022,U+2026,U+202F,U+2039-203A,U+20AC,U+2192,U+2212" \
|
||||
--layout-features='*' --name-IDs='*' --name-languages='*'
|
||||
done
|
||||
```
|
||||
|
||||
## Charte graphique
|
||||
|
||||
La charte complète (couleurs des deux thèmes, typographie, composants) est dans
|
||||
`charte/`, avec les liens vers le design system et les maquettes d'écrans.
|
||||
@@ -0,0 +1,41 @@
|
||||
# Charte graphique d'Ustagammon
|
||||
|
||||
Copie de travail du design system, pour l'appliquer à la PWA sans dépendre
|
||||
d'un accès à claude.ai. La référence vivante, avec aperçus dans les deux thèmes :
|
||||
|
||||
- Design system : https://claude.ai/artifact/K2Z7MPE58XXJzv19n5r11M
|
||||
- Maquettes des écrans (accueil, plateau, leçon, fin de partie, thème sombre) :
|
||||
https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe
|
||||
|
||||
Décisions : ADR 0010. Fichiers du logo et des icônes : `../logo/`.
|
||||
|
||||
## Fichiers
|
||||
|
||||
| Fichier | Contenu |
|
||||
| --- | --- |
|
||||
| `guide-de-marque.md` | Règles d'usage : ton, couleurs, typographie, formes, mouvement, icônes, composants |
|
||||
| `tokens.json` | Toutes les valeurs, thèmes clair et sombre, avec une note d'usage par couleur |
|
||||
| `bundle.css` | Styles des composants ; mêmes noms de classes que `web/app.css` |
|
||||
| `board.js` | Dessin de référence du plateau (repère 640 × 520), pour comparaison |
|
||||
|
||||
## Appliquer la charte à `web/`
|
||||
|
||||
1. **Couleurs** : les variables du plateau de `web/app.css` (`--frame`, `--bed`,
|
||||
`--point-a`, `--checker-player`…) ont les mêmes noms dans `tokens.json` ;
|
||||
reprendre leurs valeurs, thème clair dans `:root`, thème sombre dans le bloc
|
||||
`prefers-color-scheme: dark`. Remplacer l'accent vert provisoire par la
|
||||
brique (`--accent`, `--highlight`, `--target`) et ajouter les couleurs
|
||||
nouvelles (`surface`, `accent-soft`, `verdict-*`, `focus`, `last-move` en laiton).
|
||||
2. **Police** : embarquer Alegreya Sans (Regular, Italic, Medium, Bold,
|
||||
ExtraBold) dans `web/`, avec sa licence OFL, en `@font-face`, et l'ajouter
|
||||
au cache du service worker (hors ligne).
|
||||
3. **Composants** : reprendre de `bundle.css` les boutons ronds
|
||||
(`radius-pill`), le filet intérieur des pions, l'anneau de focus et la zone
|
||||
de consigne.
|
||||
4. **Icônes et logo** : remplacer `web/icons/` par les fichiers de
|
||||
`../logo/` (icônes any et maskable, favicon), mettre le logo horizontal
|
||||
dans la barre haute, et la couleur `theme-color` du manifeste à `#4A2E1F`.
|
||||
|
||||
Les contrastes de tous les textes ont été vérifiés par calcul (4,5:1 au moins
|
||||
dans les deux thèmes) ; les marques du plateau, à 3:1 contre au moins un de
|
||||
leurs voisins.
|
||||
@@ -0,0 +1,74 @@
|
||||
/* Dessin de référence du plateau Ustagammon, en SVG, avec les classes de bundle.css.
|
||||
* Repère : 640 × 520, comme web/app.css (.board, aspect-ratio 640 / 520).
|
||||
* Numérotation du point de vue du joueur : 1 à 12 en bas (de droite à gauche),
|
||||
* 13 à 24 en haut (de gauche à droite). Le joueur a les pions ivoire. */
|
||||
window.UstaBoard = (function () {
|
||||
var W = 640, H = 520, SIDE = 16, TB = 28, PW = 43, BAR = 40, PH = 190, R = 20;
|
||||
var TRAY_X = 580, TRAY_W = 44;
|
||||
|
||||
function colX(col) { return SIDE + col * PW + (col >= 6 ? BAR : 0); }
|
||||
function place(point) { // point 1..24 → {col, top}
|
||||
return point <= 12 ? { col: 12 - point, top: false } : { col: point - 13, top: true };
|
||||
}
|
||||
function checker(cx, cy, side, extra) {
|
||||
var c = side === "player" ? "player" : "computer";
|
||||
return '<circle class="checker checker-' + c + (extra ? " " + extra : "") + '" cx="' + cx + '" cy="' + cy + '" r="' + R + '"/>' +
|
||||
'<circle class="checker-ring ring-' + c + '" cx="' + cx + '" cy="' + cy + '" r="12"/>';
|
||||
}
|
||||
function die(x, y, n, side) {
|
||||
var s = 36, p = { 1: [[.5, .5]], 2: [[.27, .27], [.73, .73]], 3: [[.27, .27], [.5, .5], [.73, .73]],
|
||||
4: [[.27, .27], [.73, .27], [.27, .73], [.73, .73]], 5: [[.27, .27], [.73, .27], [.5, .5], [.27, .73], [.73, .73]],
|
||||
6: [[.27, .25], [.73, .25], [.27, .5], [.73, .5], [.27, .75], [.73, .75]] }[n];
|
||||
var out = '<rect class="die-' + side + '" x="' + x + '" y="' + y + '" width="' + s + '" height="' + s + '" rx="6"/>';
|
||||
p.forEach(function (q) { out += '<circle class="pip-' + side + '" cx="' + (x + q[0] * s) + '" cy="' + (y + q[1] * s) + '" r="3.6"/>'; });
|
||||
return out;
|
||||
}
|
||||
|
||||
/* state = { checkers: {point: [side, n]}, selected: point, movable: [points],
|
||||
* targets: [points], lastMove: [points], dice: [a, b], diceSide, cube } */
|
||||
function svg(state) {
|
||||
var o = '<svg class="board" viewBox="0 0 ' + W + ' ' + H + '" role="img" aria-label="Plateau de backgammon" xmlns="http://www.w3.org/2000/svg">';
|
||||
o += '<rect class="board-frame" x="0" y="0" width="' + W + '" height="' + H + '" rx="10"/>';
|
||||
o += '<rect class="board-bed" x="' + SIDE + '" y="' + TB + '" width="' + (TRAY_X - 8 - SIDE) + '" height="' + (H - 2 * TB) + '"/>';
|
||||
o += '<rect class="board-bar" x="' + (SIDE + 6 * PW) + '" y="' + TB + '" width="' + BAR + '" height="' + (H - 2 * TB) + '"/>';
|
||||
o += '<rect class="board-tray" x="' + TRAY_X + '" y="' + TB + '" width="' + TRAY_W + '" height="' + (H / 2 - TB - 4) + '" rx="4"/>';
|
||||
o += '<rect class="board-tray" x="' + TRAY_X + '" y="' + (H / 2 + 4) + '" width="' + TRAY_W + '" height="' + (H / 2 - TB - 4) + '" rx="4"/>';
|
||||
for (var point = 1; point <= 24; point++) {
|
||||
var pl = place(point), x = colX(pl.col), cls = (pl.col % 2 === 0) === pl.top ? "point-a" : "point-b";
|
||||
var base = pl.top ? TB : H - TB, apex = pl.top ? TB + PH : H - TB - PH;
|
||||
o += '<polygon class="' + cls + '" points="' + x + ',' + base + ' ' + (x + PW) + ',' + base + ' ' + (x + PW / 2) + ',' + apex + '"/>';
|
||||
if ((state.targets || []).indexOf(point) >= 0)
|
||||
o += '<polygon class="target-zone" points="' + x + ',' + base + ' ' + (x + PW) + ',' + base + ' ' + (x + PW / 2) + ',' + apex + '"/>';
|
||||
if ((state.lastMove || []).indexOf(point) >= 0)
|
||||
o += '<rect class="last-move" x="' + (x + 6) + '" y="' + (pl.top ? TB : H - TB - 5) + '" width="' + (PW - 12) + '" height="5" rx="2.5"/>';
|
||||
o += '<text class="point-number" x="' + (x + PW / 2) + '" y="' + (pl.top ? 19 : H - 9) + '">' + point + '</text>';
|
||||
var c = (state.checkers || {})[point];
|
||||
if (c) {
|
||||
var shown = Math.min(c[1], 5);
|
||||
for (var i = 0; i < shown; i++) {
|
||||
var cy = pl.top ? TB + R + 1 + i * (2 * R + 1) : H - TB - R - 1 - i * (2 * R + 1);
|
||||
var extra = "";
|
||||
if (i === shown - 1 && state.selected === point) extra = "selected";
|
||||
else if (i === shown - 1 && (state.movable || []).indexOf(point) >= 0) extra = "movable";
|
||||
o += checker(x + PW / 2, cy, c[0], extra);
|
||||
if (i === shown - 1 && c[1] > 5)
|
||||
o += '<text class="checker-count count-' + c[0] + '" x="' + (x + PW / 2) + '" y="' + (cy + 6) + '">' + c[1] + '</text>';
|
||||
}
|
||||
}
|
||||
}
|
||||
if (state.dice) {
|
||||
var dx = colX(8) + 6, dy = H / 2 - 18, side = state.diceSide || "player";
|
||||
o += die(dx, dy, state.dice[0], side) + die(dx + 46, dy, state.dice[1], side);
|
||||
}
|
||||
if (state.cube) {
|
||||
var bx = SIDE + 6 * PW + 2;
|
||||
o += '<rect class="cube-face" x="' + bx + '" y="' + (H / 2 - 18) + '" width="36" height="36" rx="6"/>';
|
||||
o += '<text class="cube-value" x="' + (bx + 18) + '" y="' + (H / 2 + 6) + '">' + state.cube + '</text>';
|
||||
}
|
||||
return o + '</svg>';
|
||||
}
|
||||
|
||||
var OPENING = { 24: ["player", 2], 13: ["player", 5], 8: ["player", 3], 6: ["player", 5],
|
||||
1: ["computer", 2], 12: ["computer", 5], 17: ["computer", 3], 19: ["computer", 5] };
|
||||
return { svg: svg, OPENING: OPENING };
|
||||
})();
|
||||
@@ -0,0 +1,165 @@
|
||||
/* Ustagammon — styles des composants.
|
||||
* Toutes les valeurs viennent de tokens.json (variables CSS du même nom).
|
||||
* Les noms de classes reprennent ceux de web/app.css : ce fichier peut être
|
||||
* recopié dans l'application presque tel quel. */
|
||||
|
||||
body {
|
||||
margin: 0;
|
||||
font-family: var(--font-sans);
|
||||
font-size: 17px;
|
||||
line-height: 25px;
|
||||
color: var(--text);
|
||||
background: var(--background);
|
||||
}
|
||||
|
||||
a { color: var(--accent); text-underline-offset: 3px; }
|
||||
|
||||
:focus-visible {
|
||||
outline: 3px solid var(--focus);
|
||||
outline-offset: 2px;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ Barre haute */
|
||||
|
||||
.topbar {
|
||||
display: flex;
|
||||
gap: var(--space-2);
|
||||
align-items: center;
|
||||
padding-block: var(--space-2);
|
||||
}
|
||||
.topbar .brand { flex: 1; display: flex; align-items: center; min-width: 0; }
|
||||
.topbar .brand img { height: 32px; width: auto; display: block; }
|
||||
.topbar h1 { flex: 1; margin: 0; font-size: 20px; line-height: 26px; font-weight: 700; }
|
||||
|
||||
/* ---------------------------------------------------------------- Boutons */
|
||||
|
||||
button, .button {
|
||||
min-height: var(--button-height);
|
||||
padding: 0 20px;
|
||||
font: inherit;
|
||||
font-weight: 700;
|
||||
color: var(--on-accent);
|
||||
background: var(--accent);
|
||||
border: 2px solid var(--accent);
|
||||
border-radius: var(--radius-pill);
|
||||
cursor: pointer;
|
||||
}
|
||||
button.secondary, .button.secondary {
|
||||
color: var(--text);
|
||||
background: transparent;
|
||||
border-color: var(--border-strong);
|
||||
}
|
||||
button.quiet, .button.quiet {
|
||||
min-height: 44px;
|
||||
padding: 0 12px;
|
||||
color: var(--text);
|
||||
background: transparent;
|
||||
border-color: transparent;
|
||||
font-weight: 500;
|
||||
}
|
||||
.topbar button { min-height: 44px; padding: 0 14px; font-size: 15px; }
|
||||
button:disabled { opacity: 0.45; cursor: default; }
|
||||
|
||||
.actions { display: flex; flex-wrap: wrap; gap: var(--space-2); }
|
||||
.actions button { flex: 1; }
|
||||
|
||||
/* ------------------------------------------------------- Zone de consigne */
|
||||
|
||||
.pips { margin: var(--space-1) 0 0; font-size: 15px; line-height: 20px; color: var(--muted); text-align: center; font-variant-numeric: tabular-nums; }
|
||||
.info, .prompt { min-height: 25px; margin: 6px 0; }
|
||||
.info { color: var(--muted); }
|
||||
.prompt { font-weight: 700; }
|
||||
.prompt.thinking::after { content: ""; animation: thinking 1.2s steps(4, end) infinite; }
|
||||
@keyframes thinking { 0% { content: ""; } 25% { content: "."; } 50% { content: ".."; } 75% { content: "..."; } }
|
||||
@media (prefers-reduced-motion: reduce) { .prompt.thinking::after { animation: none; content: "…"; } }
|
||||
|
||||
/* ---------------------------------------------------------------- Plateau */
|
||||
|
||||
.board { display: block; width: 100%; height: auto; user-select: none; -webkit-tap-highlight-color: transparent; }
|
||||
.board-frame { fill: var(--frame); }
|
||||
.board-bed { fill: var(--bed); }
|
||||
.board-bar { fill: var(--bar); }
|
||||
.board-tray { fill: var(--tray); }
|
||||
.point-a { fill: var(--point-a); }
|
||||
.point-b { fill: var(--point-b); }
|
||||
.point-number { fill: var(--point-number); font-size: 13px; font-weight: 500; text-anchor: middle; font-family: var(--font-sans); }
|
||||
.checker { stroke-width: 2; }
|
||||
.checker-player { fill: var(--checker-player); stroke: var(--checker-player-edge); }
|
||||
.checker-computer { fill: var(--checker-computer); stroke: var(--checker-computer-edge); }
|
||||
.checker-ring { fill: none; stroke-width: 1.5; }
|
||||
.checker-player + .checker-ring, .ring-player { stroke: var(--checker-player-edge); }
|
||||
.ring-computer { stroke: var(--checker-computer-edge); }
|
||||
.checker.movable { stroke: var(--highlight); stroke-width: 3; }
|
||||
.checker.selected { stroke: var(--highlight); stroke-width: 6; }
|
||||
.checker-count { font-size: 18px; font-weight: 700; text-anchor: middle; font-family: var(--font-sans); }
|
||||
.count-player { fill: var(--count-player); }
|
||||
.count-computer { fill: var(--count-computer); }
|
||||
.target-zone { fill: var(--target); }
|
||||
.last-move { fill: var(--last-move); }
|
||||
.die-player { fill: var(--die-player); stroke: var(--checker-player-edge); stroke-width: 1.5; }
|
||||
.die-computer { fill: var(--die-computer); stroke: var(--checker-computer-edge); stroke-width: 1.5; }
|
||||
.pip-player { fill: var(--pip-player); }
|
||||
.pip-computer { fill: var(--pip-computer); }
|
||||
.cube-face { fill: var(--cube); stroke: var(--checker-player-edge); stroke-width: 2; }
|
||||
.cube-value { fill: var(--cube-text); font-size: 17px; font-weight: 800; text-anchor: middle; font-family: var(--font-sans); }
|
||||
|
||||
/* ------------------------------------------------------------------ Cartes */
|
||||
|
||||
.card {
|
||||
background: var(--surface);
|
||||
border: 1px solid var(--border);
|
||||
border-radius: var(--radius-md);
|
||||
box-shadow: var(--shadow-raised);
|
||||
padding: var(--space-4);
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: var(--space-2);
|
||||
}
|
||||
.overline { font-size: 13px; line-height: 16px; font-weight: 700; letter-spacing: 0.08em; text-transform: uppercase; color: var(--muted); }
|
||||
|
||||
/* --------------------------------------------------- Appréciation d'un coup */
|
||||
|
||||
.verdict {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: var(--space-1);
|
||||
font-weight: 700;
|
||||
font-size: 15px;
|
||||
line-height: 20px;
|
||||
}
|
||||
.verdict svg { width: 18px; height: 18px; flex: none; }
|
||||
.verdict-good { color: var(--verdict-good); }
|
||||
.verdict-doubtful { color: var(--verdict-doubtful); }
|
||||
.verdict-bad { color: var(--verdict-bad); }
|
||||
|
||||
/* -------------------------------------------------------- Fiche de glossaire */
|
||||
|
||||
.glossary-card h3 { margin: 0; font-size: 20px; line-height: 26px; font-weight: 700; }
|
||||
.glossary-card .en { color: var(--muted); font-size: 15px; line-height: 20px; font-style: italic; }
|
||||
.glossary-card p { margin: 0; }
|
||||
.glossary-card .see { font-size: 15px; line-height: 20px; color: var(--muted); }
|
||||
|
||||
/* ------------------------------------------------ Demander à une IA (prompt) */
|
||||
|
||||
.ask-ai { display: flex; flex-direction: column; gap: var(--space-2); }
|
||||
.ask-ai pre {
|
||||
margin: 0;
|
||||
max-height: 7.5em;
|
||||
overflow: auto;
|
||||
padding: var(--space-3);
|
||||
background: var(--surface-sunken);
|
||||
border-radius: var(--radius-md);
|
||||
font: 15px/20px var(--font-sans);
|
||||
white-space: pre-wrap;
|
||||
color: var(--text);
|
||||
}
|
||||
.ask-ai .done { color: var(--verdict-good); font-weight: 700; font-size: 15px; }
|
||||
|
||||
/* ---------------------------------------------------------- Carte de leçon */
|
||||
|
||||
.lesson-card { flex-direction: row; align-items: center; gap: var(--space-3); }
|
||||
.lesson-card .body { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 2px; }
|
||||
.lesson-card h3 { margin: 0; font-size: 17px; line-height: 25px; font-weight: 700; }
|
||||
.lesson-card .state { font-size: 15px; line-height: 20px; color: var(--muted); }
|
||||
.progress { height: 6px; border-radius: var(--radius-pill); background: var(--surface-sunken); overflow: hidden; }
|
||||
.progress > span { display: block; height: 100%; background: var(--accent); border-radius: inherit; }
|
||||
@@ -0,0 +1,61 @@
|
||||
Ustagammon apprend le backgammon comme on l'apprend à une table de café : quelqu'un qui sait montre à quelqu'un qui découvre. L'interface est **chaleureuse, artisanale, claire et intemporelle**, discrètement turque par la matière (le bois, l'ivoire, la brique), jamais par le folklore. Elle doit donner envie à un débutant sans paraître naïve à un joueur confirmé : un maître bienveillant, pas un logiciel d'analyse, pas un casino.
|
||||
|
||||
Ce système s'applique à la PWA (`web/`). Les noms des couleurs du plateau sont exactement ceux des variables de `web/app.css` ; `components/bundle.css` reprend ses noms de classes et peut y être recopié.
|
||||
|
||||
## Contenus et ton
|
||||
|
||||
- **Vouvoiement**, phrases courtes, verbes d'action. Le joueur est « vous », l'adversaire est « l'ordinateur » (ou le nom d'un joueur réel).
|
||||
- **Les mots du jeu**, toujours les mêmes, ceux du glossaire (`docs/glossaire/`) : flèche, pion, barre, videau, compte de points, sortir. Un terme technique s'explique la première fois qu'il apparaît, avec un lien vers sa fiche.
|
||||
- **Les boutons disent ce qu'ils font** : « Lancer les dés », « Annuler », « Doubler », « Prendre », « Passer », « Nouvelle partie ». Pas de « OK », pas de « Valider ». Les textes de l'app vivent dans `app/src/ui/texts.ts`.
|
||||
- **Le maître encourage, il ne juge pas.** « Bien joué : ce coup protège votre point 8. » plutôt que « Coup correct (−0,012) ». Les chiffres d'équité ne viennent que sur demande.
|
||||
- **Les erreurs disent quoi faire** : « Ce pion ne peut pas aller là : la flèche est tenue par deux pions adverses. »
|
||||
- **Ni émoji, ni point d'exclamation en série, ni majuscules de réclame.** Les capitales sont réservées au style `overline`.
|
||||
- Le nom s'écrit **Ustagammon**, en un mot, majuscule initiale.
|
||||
|
||||
## Couleurs
|
||||
|
||||
La palette, c'est le bois, les pions et le café, avec **un seul accent : le rouge brique** (`accent`).
|
||||
|
||||
- Fond de page `background`, cartes et panneaux `surface`, zones en retrait `surface-sunken`.
|
||||
- Texte `text` ; texte secondaire `muted`, jamais pour une consigne.
|
||||
- `accent` est rare et a toujours un sens : le bouton principal de l'écran (un seul), un lien, le pion sélectionné (`highlight`), la case où il peut aller (`target`), le focus clavier (`focus`). Ce n'est jamais une couleur de décoration ni une couleur d'erreur.
|
||||
- `accent-soft` : fond léger pour signaler « c'est à vous », avec du texte `text` dessus.
|
||||
- Les appréciations de coups ont leurs propres couleurs, distinctes de la brique : `verdict-good` (vert), `verdict-doubtful` (ocre), `verdict-bad` (lie-de-vin). **Toujours avec le mot et l'icône**, jamais la couleur seule.
|
||||
- `brand-laiton` (via `last-move`) marque le dernier coup joué, comme les charnières en laiton d'un plateau de tavla. Rien d'autre.
|
||||
- Le plateau : cadre `frame` en noyer, fond `bed`, flèches alternées `point-a` (noyer clair) et `point-b` (chêne), barre `bar`, sorties `tray`. Le joueur a les pions ivoire (`checker-player`, l'apprenti), l'ordinateur les pions noyer (`checker-computer`, le maître), comme dans le logo.
|
||||
- **À éviter** : le vert feutre de casino, le noir et or, les dégradés, les néons.
|
||||
|
||||
Les deux thèmes, clair et sombre, sont complets. Tous les textes atteignent 4,5:1 sur leurs fonds dans les deux thèmes ; les contours et marques porteuses de sens, 3:1.
|
||||
|
||||
## Typographie
|
||||
|
||||
Une seule famille, **Alegreya Sans** (licence SIL OFL, fichiers dans `fonts/`), sans empattement humaniste, chaleureuse et lisible en petit. À embarquer dans l'app : elle doit fonctionner hors ligne.
|
||||
|
||||
- `display` (32px, 800) : un seul par écran, accueil et fin de partie.
|
||||
- `title` (24px) : titre d'écran ; `heading` (20px) : titre de section ou de carte.
|
||||
- `body` (17px) : tout le texte à lire, jamais plus petit. `body-strong` pour la consigne du moment et les boutons. `body-italic` pour la parole du maître ou un exemple.
|
||||
- `caption` (15px) : compte de points, légendes. `overline` (13px, capitales espacées) : étiquette au-dessus d'un titre, avec parcimonie.
|
||||
- Chiffres alignés (`font-variant-numeric: tabular-nums`) dès que des nombres se comparent (compte de points, scores).
|
||||
|
||||
## Formes, espace et profondeur
|
||||
|
||||
- **Boutons ronds comme des pions** : `radius-pill`, hauteur `button-height` (48px). Aucune cible tactile sous 44px.
|
||||
- Cartes et fiches : `radius-md`, contour `border`, ombre `shadow-raised` et rien de plus profond. Dés et videau : `radius-sm`.
|
||||
- Espacements : `space-1` à `space-8`. Gouttière de page `space-4` sur téléphone ; écart entre blocs `space-6`. Contenu limité à `page-width` sur grand écran.
|
||||
- Le plateau occupe toute la largeur sur téléphone ; c'est lui le héros de l'écran de jeu, pas les panneaux autour.
|
||||
- Focus clavier : anneau `focus` plein de 3px, décalé de 2px, sur tous les éléments interactifs.
|
||||
|
||||
## Mouvement
|
||||
|
||||
Sobre et utile : un pion glisse vers sa flèche (150 à 250 ms, sans rebond), les dés roulent brièvement. Les trois points de « l'ordinateur réfléchit » sont la seule animation en boucle. Tout s'arrête avec `prefers-reduced-motion`.
|
||||
|
||||
## Iconographie
|
||||
|
||||
- Le **symbole** (deux pions sur une flèche, le 8 caché) et le **logotype** (les « mm » en flèches) sont dans le groupe Logos ; versions couleur, sombre, noire et blanche. Ne jamais les redessiner, déformer ou recolorer.
|
||||
- Barre haute : `logo-horizontal-couleur.svg` en thème clair, `logo-horizontal-sombre.svg` en thème sombre, 32px de haut.
|
||||
- Icônes d'interface : traits simples de 2px à bouts ronds, dessinés en SVG dans le code (pas de police d'icônes, pas d'émoji). Les seules icônes du système pour l'instant : les trois appréciations de coups (coche, point d'interrogation, croix) et la copie (deux feuillets).
|
||||
- Dés, pions et videau sont dessinés en SVG avec les couleurs du plateau, jamais en images.
|
||||
|
||||
## Composants
|
||||
|
||||
Plateau (`Board`) et ses pièces (`Checker`, `Die`, `DoublingCube`), boutons (`Button`), barre haute (`TopBar`), zone de consigne (`GamePrompt`), appréciation d'un coup (`MoveVerdict`), fiche de glossaire (`GlossaryCard`), carte de leçon (`LessonCard`) et « Demander à une IA » (`AskAI`). Chacun a sa fiche avec ses règles d'usage et un aperçu dans les deux thèmes.
|
||||
@@ -0,0 +1,530 @@
|
||||
{
|
||||
"name": "Ustagammon",
|
||||
"version": 1,
|
||||
"color": {
|
||||
"themes": [
|
||||
{
|
||||
"id": "light",
|
||||
"name": "Clair"
|
||||
},
|
||||
{
|
||||
"id": "dark",
|
||||
"name": "Sombre"
|
||||
}
|
||||
],
|
||||
"tokens": [
|
||||
{
|
||||
"name": "background",
|
||||
"value": {
|
||||
"light": "#F5EFE5",
|
||||
"dark": "#17110D"
|
||||
},
|
||||
"usage": "Fond de page (papier ivoire / café torréfié)."
|
||||
},
|
||||
{
|
||||
"name": "surface",
|
||||
"value": {
|
||||
"light": "#FFFCF6",
|
||||
"dark": "#221913"
|
||||
},
|
||||
"usage": "Fond des cartes, fiches de glossaire, panneaux posés sur `background`."
|
||||
},
|
||||
{
|
||||
"name": "surface-sunken",
|
||||
"value": {
|
||||
"light": "#ECE3D4",
|
||||
"dark": "#2C211A"
|
||||
},
|
||||
"usage": "Zones en retrait : bloc de prompt à copier, piste de progression."
|
||||
},
|
||||
{
|
||||
"name": "text",
|
||||
"value": {
|
||||
"light": "#2B1D15",
|
||||
"dark": "#EFE5D5"
|
||||
},
|
||||
"usage": "Texte courant et titres, sur `background`, `surface` et `surface-sunken`."
|
||||
},
|
||||
{
|
||||
"name": "muted",
|
||||
"value": {
|
||||
"light": "#6B5C50",
|
||||
"dark": "#A99886"
|
||||
},
|
||||
"usage": "Texte secondaire (compte de points, légendes, aide), sur `background` et `surface`."
|
||||
},
|
||||
{
|
||||
"name": "border",
|
||||
"value": {
|
||||
"light": "#DED2C0",
|
||||
"dark": "#3A2D24"
|
||||
},
|
||||
"usage": "Séparateurs et contours décoratifs de cartes (ne porte aucun sens)."
|
||||
},
|
||||
{
|
||||
"name": "border-strong",
|
||||
"value": {
|
||||
"light": "#8E7D6A",
|
||||
"dark": "#7D6B5B"
|
||||
},
|
||||
"usage": "Contour des boutons secondaires et des champs : 3:1 sur `background` et `surface`."
|
||||
},
|
||||
{
|
||||
"name": "accent",
|
||||
"value": {
|
||||
"light": "#A8432B",
|
||||
"dark": "#D0694B"
|
||||
},
|
||||
"usage": "Rouge brique, l'accent unique : bouton principal, liens, case où le pion peut aller, focus. Texte en brique sur `background` et `surface`."
|
||||
},
|
||||
{
|
||||
"name": "on-accent",
|
||||
"value": {
|
||||
"light": "#FFFFFF",
|
||||
"dark": "#1A110C"
|
||||
},
|
||||
"usage": "Texte et icônes posés sur un aplat `accent`."
|
||||
},
|
||||
{
|
||||
"name": "accent-soft",
|
||||
"value": {
|
||||
"light": "#F1D9CF",
|
||||
"dark": "#4A2519"
|
||||
},
|
||||
"usage": "Fond léger d'accent : puce « à toi de jouer », sélection dans une liste. Texte `text` dessus."
|
||||
},
|
||||
{
|
||||
"name": "focus",
|
||||
"value": {
|
||||
"light": "#A8432B",
|
||||
"dark": "#E58A6E"
|
||||
},
|
||||
"usage": "Anneau de focus clavier, 3 px plein, décalé de 2 px : 3:1 sur tous les fonds."
|
||||
},
|
||||
{
|
||||
"name": "error",
|
||||
"value": {
|
||||
"light": "#8C1C3A",
|
||||
"dark": "#F08FA6"
|
||||
},
|
||||
"usage": "Message d'erreur technique (texte), toujours accompagné d'un mot. Lie-de-vin, distinct de la brique."
|
||||
},
|
||||
{
|
||||
"name": "verdict-good",
|
||||
"value": {
|
||||
"light": "#2F6B4F",
|
||||
"dark": "#7CCBA4"
|
||||
},
|
||||
"usage": "« Bon coup » : texte et icône, toujours avec le mot. Sur `background` et `surface`."
|
||||
},
|
||||
{
|
||||
"name": "verdict-doubtful",
|
||||
"value": {
|
||||
"light": "#7E5A0F",
|
||||
"dark": "#E0B04F"
|
||||
},
|
||||
"usage": "« Imprécision » (doubtful) : texte et icône, toujours avec le mot."
|
||||
},
|
||||
{
|
||||
"name": "verdict-bad",
|
||||
"value": {
|
||||
"light": "#8C1C3A",
|
||||
"dark": "#F08FA6"
|
||||
},
|
||||
"usage": "« Erreur » et « grosse erreur » (bad, very bad) : texte et icône, toujours avec le mot."
|
||||
},
|
||||
{
|
||||
"name": "brand-noyer",
|
||||
"value": {
|
||||
"light": "#4A2E1F",
|
||||
"dark": "#4A2E1F"
|
||||
},
|
||||
"usage": "Noyer du logo : pion maître. Ne sert pas au texte de l'interface."
|
||||
},
|
||||
{
|
||||
"name": "brand-ivoire",
|
||||
"value": {
|
||||
"light": "#F3EAD8",
|
||||
"dark": "#F3EAD8"
|
||||
},
|
||||
"usage": "Ivoire du logo : pion apprenti, fond de l'icône d'application."
|
||||
},
|
||||
{
|
||||
"name": "brand-laiton",
|
||||
"value": {
|
||||
"light": "#8F6A1C",
|
||||
"dark": "#D6A64A"
|
||||
},
|
||||
"usage": "Laiton, comme les charnières d'un plateau de tavla : marque du dernier coup joué, rien d'autre."
|
||||
},
|
||||
{
|
||||
"name": "frame",
|
||||
"value": {
|
||||
"light": "#4A2E1F",
|
||||
"dark": "#2A1A10"
|
||||
},
|
||||
"usage": "Cadre du plateau (noyer)."
|
||||
},
|
||||
{
|
||||
"name": "bed",
|
||||
"value": {
|
||||
"light": "#E9DCC4",
|
||||
"dark": "#4A3626"
|
||||
},
|
||||
"usage": "Fond du plateau, entre les flèches."
|
||||
},
|
||||
{
|
||||
"name": "bar",
|
||||
"value": {
|
||||
"light": "#3F2619",
|
||||
"dark": "#24170E"
|
||||
},
|
||||
"usage": "Barre centrale."
|
||||
},
|
||||
{
|
||||
"name": "tray",
|
||||
"value": {
|
||||
"light": "#3A2418",
|
||||
"dark": "#22150D"
|
||||
},
|
||||
"usage": "Plateaux de sortie, à droite."
|
||||
},
|
||||
{
|
||||
"name": "point-a",
|
||||
"value": {
|
||||
"light": "#6B4430",
|
||||
"dark": "#3A2519"
|
||||
},
|
||||
"usage": "Flèches sombres (noyer clair), une sur deux."
|
||||
},
|
||||
{
|
||||
"name": "point-b",
|
||||
"value": {
|
||||
"light": "#C9AE88",
|
||||
"dark": "#7E6142"
|
||||
},
|
||||
"usage": "Flèches claires (chêne), une sur deux."
|
||||
},
|
||||
{
|
||||
"name": "point-number",
|
||||
"value": {
|
||||
"light": "#F3EAD8",
|
||||
"dark": "#CDBFA8"
|
||||
},
|
||||
"usage": "Numéros des flèches, posés sur `frame`."
|
||||
},
|
||||
{
|
||||
"name": "checker-player",
|
||||
"value": {
|
||||
"light": "#F7F0E2",
|
||||
"dark": "#EDE3CF"
|
||||
},
|
||||
"usage": "Pions du joueur : ivoire, l'apprenti."
|
||||
},
|
||||
{
|
||||
"name": "checker-player-edge",
|
||||
"value": {
|
||||
"light": "#8C7A62",
|
||||
"dark": "#8E7C64"
|
||||
},
|
||||
"usage": "Contour et filet des pions du joueur."
|
||||
},
|
||||
{
|
||||
"name": "checker-computer",
|
||||
"value": {
|
||||
"light": "#2E1C12",
|
||||
"dark": "#140D09"
|
||||
},
|
||||
"usage": "Pions de l'ordinateur : noyer sombre, le maître."
|
||||
},
|
||||
{
|
||||
"name": "checker-computer-edge",
|
||||
"value": {
|
||||
"light": "#120A05",
|
||||
"dark": "#A8957D"
|
||||
},
|
||||
"usage": "Contour et filet des pions de l'ordinateur ; clair en thème sombre pour rester visible."
|
||||
},
|
||||
{
|
||||
"name": "count-player",
|
||||
"value": {
|
||||
"light": "#2B1D15",
|
||||
"dark": "#2B1D15"
|
||||
},
|
||||
"usage": "Nombre écrit sur une pile de pions du joueur."
|
||||
},
|
||||
{
|
||||
"name": "count-computer",
|
||||
"value": {
|
||||
"light": "#F3EAD8",
|
||||
"dark": "#F3EAD8"
|
||||
},
|
||||
"usage": "Nombre écrit sur une pile de pions de l'ordinateur."
|
||||
},
|
||||
{
|
||||
"name": "die-player",
|
||||
"value": {
|
||||
"light": "#F7F0E2",
|
||||
"dark": "#EDE3CF"
|
||||
},
|
||||
"usage": "Dés du joueur."
|
||||
},
|
||||
{
|
||||
"name": "pip-player",
|
||||
"value": {
|
||||
"light": "#2B1D15",
|
||||
"dark": "#2B1D15"
|
||||
},
|
||||
"usage": "Points des dés du joueur."
|
||||
},
|
||||
{
|
||||
"name": "die-computer",
|
||||
"value": {
|
||||
"light": "#2E1C12",
|
||||
"dark": "#140D09"
|
||||
},
|
||||
"usage": "Dés de l'ordinateur."
|
||||
},
|
||||
{
|
||||
"name": "pip-computer",
|
||||
"value": {
|
||||
"light": "#F3EAD8",
|
||||
"dark": "#EDE3CF"
|
||||
},
|
||||
"usage": "Points des dés de l'ordinateur."
|
||||
},
|
||||
{
|
||||
"name": "cube",
|
||||
"value": {
|
||||
"light": "#F7F0E2",
|
||||
"dark": "#EDE3CF"
|
||||
},
|
||||
"usage": "Face du videau."
|
||||
},
|
||||
{
|
||||
"name": "cube-text",
|
||||
"value": {
|
||||
"light": "#2B1D15",
|
||||
"dark": "#2B1D15"
|
||||
},
|
||||
"usage": "Valeur du videau (2, 4, 8…)."
|
||||
},
|
||||
{
|
||||
"name": "highlight",
|
||||
"value": {
|
||||
"light": "#A8432B",
|
||||
"dark": "#E07A5A"
|
||||
},
|
||||
"usage": "Contour d'un pion jouable ou sélectionné du joueur : la brique. Il contraste à 3:1 au moins avec le pion ivoire (clair) ou avec le fond du plateau (sombre)."
|
||||
},
|
||||
{
|
||||
"name": "target",
|
||||
"value": {
|
||||
"light": "rgba(168,67,43,0.32)",
|
||||
"dark": "rgba(224,122,90,0.38)"
|
||||
},
|
||||
"usage": "Voile sur la flèche où le pion sélectionné peut aller."
|
||||
},
|
||||
{
|
||||
"name": "last-move",
|
||||
"value": {
|
||||
"light": "{brand-laiton}",
|
||||
"dark": "{brand-laiton}"
|
||||
},
|
||||
"usage": "Marque du dernier coup joué (laiton)."
|
||||
}
|
||||
]
|
||||
},
|
||||
"type": {
|
||||
"fonts": [
|
||||
{
|
||||
"family": "Alegreya Sans",
|
||||
"file": "fonts/AlegreyaSans-Regular.ttf",
|
||||
"weight": "400"
|
||||
},
|
||||
{
|
||||
"family": "Alegreya Sans",
|
||||
"file": "fonts/AlegreyaSans-Italic.ttf",
|
||||
"weight": "400",
|
||||
"style": "italic"
|
||||
},
|
||||
{
|
||||
"family": "Alegreya Sans",
|
||||
"file": "fonts/AlegreyaSans-Medium.ttf",
|
||||
"weight": "500"
|
||||
},
|
||||
{
|
||||
"family": "Alegreya Sans",
|
||||
"file": "fonts/AlegreyaSans-Bold.ttf",
|
||||
"weight": "700"
|
||||
},
|
||||
{
|
||||
"family": "Alegreya Sans",
|
||||
"file": "fonts/AlegreyaSans-ExtraBold.ttf",
|
||||
"weight": "800"
|
||||
}
|
||||
],
|
||||
"families": {
|
||||
"sans": "\"Alegreya Sans\", \"Gill Sans\", \"Segoe UI\", system-ui, sans-serif"
|
||||
},
|
||||
"groups": [
|
||||
{
|
||||
"name": "Titres",
|
||||
"family": "sans",
|
||||
"styles": [
|
||||
{
|
||||
"name": "display",
|
||||
"fontSize": "32px",
|
||||
"lineHeight": "36px",
|
||||
"fontWeight": 800,
|
||||
"letterSpacing": "-0.01em",
|
||||
"sample": "Une partie contre le maître",
|
||||
"usage": "Titre d'accueil et de fin de partie, une fois par écran."
|
||||
},
|
||||
{
|
||||
"name": "title",
|
||||
"fontSize": "24px",
|
||||
"lineHeight": "30px",
|
||||
"fontWeight": 700,
|
||||
"sample": "Le point 8",
|
||||
"usage": "Titre d'écran (leçon, aide)."
|
||||
},
|
||||
{
|
||||
"name": "heading",
|
||||
"fontSize": "20px",
|
||||
"lineHeight": "26px",
|
||||
"fontWeight": 700,
|
||||
"sample": "Les ouvertures",
|
||||
"usage": "Sous-titre de section, titre de carte."
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "Texte",
|
||||
"family": "sans",
|
||||
"styles": [
|
||||
{
|
||||
"name": "body",
|
||||
"fontSize": "17px",
|
||||
"lineHeight": "25px",
|
||||
"fontWeight": 400,
|
||||
"sample": "Ce pion peut rejoindre votre point 8.",
|
||||
"usage": "Texte courant ; jamais en dessous de 17px pour le contenu à lire."
|
||||
},
|
||||
{
|
||||
"name": "body-strong",
|
||||
"fontSize": "17px",
|
||||
"lineHeight": "25px",
|
||||
"fontWeight": 700,
|
||||
"sample": "À vous de jouer : 6 et 1.",
|
||||
"usage": "Consigne du moment (zone prompt), boutons."
|
||||
},
|
||||
{
|
||||
"name": "body-italic",
|
||||
"fontSize": "17px",
|
||||
"lineHeight": "25px",
|
||||
"fontWeight": 400,
|
||||
"fontStyle": "italic",
|
||||
"sample": "Philippe aurait joué 13/7 8/7.",
|
||||
"usage": "Parole du maître, citation, exemple."
|
||||
},
|
||||
{
|
||||
"name": "caption",
|
||||
"fontSize": "15px",
|
||||
"lineHeight": "20px",
|
||||
"fontWeight": 400,
|
||||
"sample": "Vous : 167 · Ordinateur : 152",
|
||||
"usage": "Compte de points, légendes, mentions."
|
||||
},
|
||||
{
|
||||
"name": "overline",
|
||||
"fontSize": "13px",
|
||||
"lineHeight": "16px",
|
||||
"fontWeight": 700,
|
||||
"letterSpacing": "0.08em",
|
||||
"sample": "LEÇON 3 SUR 12",
|
||||
"usage": "Étiquette en capitales au-dessus d'un titre ; avec parcimonie."
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"spacing": {
|
||||
"tokens": [
|
||||
{
|
||||
"name": "space-1",
|
||||
"value": "4px",
|
||||
"usage": "Écart entre une icône et son texte."
|
||||
},
|
||||
{
|
||||
"name": "space-2",
|
||||
"value": "8px",
|
||||
"usage": "Écart entre boutons voisins, marges internes serrées."
|
||||
},
|
||||
{
|
||||
"name": "space-3",
|
||||
"value": "12px",
|
||||
"usage": "Marge interne des puces et du bloc prompt."
|
||||
},
|
||||
{
|
||||
"name": "space-4",
|
||||
"value": "16px",
|
||||
"usage": "Gouttière latérale de page sur téléphone, marge interne des cartes."
|
||||
},
|
||||
{
|
||||
"name": "space-6",
|
||||
"value": "24px",
|
||||
"usage": "Écart entre blocs d'un écran."
|
||||
},
|
||||
{
|
||||
"name": "space-8",
|
||||
"value": "32px",
|
||||
"usage": "Écart entre sections."
|
||||
},
|
||||
{
|
||||
"name": "button-height",
|
||||
"value": "48px",
|
||||
"usage": "Hauteur des boutons ; aucune cible tactile sous 44px."
|
||||
},
|
||||
{
|
||||
"name": "page-width",
|
||||
"value": "40rem",
|
||||
"usage": "Largeur maximale du contenu sur grand écran."
|
||||
}
|
||||
]
|
||||
},
|
||||
"radius": {
|
||||
"tokens": [
|
||||
{
|
||||
"name": "radius-sm",
|
||||
"value": "6px",
|
||||
"usage": "Dés, videau, puces de verdict."
|
||||
},
|
||||
{
|
||||
"name": "radius-md",
|
||||
"value": "12px",
|
||||
"usage": "Cartes, fiches, bloc prompt."
|
||||
},
|
||||
{
|
||||
"name": "radius-pill",
|
||||
"value": "999px",
|
||||
"usage": "Boutons : ronds comme des pions."
|
||||
}
|
||||
]
|
||||
},
|
||||
"shadow": {
|
||||
"tokens": [
|
||||
{
|
||||
"name": "shadow-raised",
|
||||
"value": {
|
||||
"light": "0 1px 2px rgba(43,29,21,0.10)",
|
||||
"dark": "0 1px 2px rgba(0,0,0,0.40)"
|
||||
},
|
||||
"usage": "Seule ombre permise : cartes posées sur le fond. Rien de plus profond."
|
||||
}
|
||||
]
|
||||
},
|
||||
"meta": {
|
||||
"source": "Brief créatif + ADR 0010 + web/app.css (noms des variables du plateau)"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,192 @@
|
||||
"""Génère les fichiers SVG de l'identité Ustagammon : symbole P3d, logotype L3.
|
||||
|
||||
Le symbole : deux pions vus de trois quarts (le maître en noyer devant,
|
||||
l'apprenti en ivoire derrière) posés sur une flèche brique ; leurs deux
|
||||
silhouettes dessinent un 8, clin d'œil à l'Atelier du Huit.
|
||||
Le logotype : « Ustagammon » en Alegreya Sans Bold (SIL OFL), dont les deux
|
||||
« m » sont redessinés en quatre flèches au trait, alternant noyer et brique.
|
||||
|
||||
Usage : python3 -I generer-logo.py <AlegreyaSans-Bold.ttf> <dossier_sortie>
|
||||
Licence des dessins produits : CC BY-SA 4.0.
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
|
||||
from fontTools.pens.svgPathPen import SVGPathPen
|
||||
from fontTools.ttLib import TTFont
|
||||
|
||||
FONT, OUT = sys.argv[1], sys.argv[2]
|
||||
os.makedirs(OUT, exist_ok=True)
|
||||
|
||||
# ---------- Palettes ----------
|
||||
# d/ds/de : face, tranche et filet du pion noyer ; l/ls : face et tranche du pion ivoire ;
|
||||
# o : contour du pion ivoire ; a : flèche et filet brique ; sep : liseré du pion noyer ;
|
||||
# txt / acc : texte du logotype et flèches brique des « mm ».
|
||||
COULEUR = dict(d="#4A2E1F", ds="#2B1A10", de="#7A5038", l="#F3EAD8", ls="#CDB898",
|
||||
o="#2B1A10", a="#A8432B", sep="#F3EAD8", txt="#2B1D15", acc="#A8432B")
|
||||
SOMBRE = dict(COULEUR, a="#C9583C", txt="#F3EAD8", acc="#D0694B")
|
||||
# Monochromes : I = encre, H = trou (transparent)
|
||||
MONO = dict(d="I", ds="I", de="H", l="H", ls="I", o="I", a="I", sep="H", txt="I", acc="I")
|
||||
|
||||
|
||||
def symbol(p, simple=False):
|
||||
"""Symbole P3d dans une boîte de 64 × 64. `simple` : sans filets, pour le favicon."""
|
||||
s = [f'<polygon points="6,62 58,62 32,1" fill="{p["a"]}"/>']
|
||||
ow = 3 if simple else 2.2
|
||||
s.append(f'<path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="{p["ls"]}" stroke="{p["o"]}" stroke-width="{ow}" stroke-linejoin="round"/>')
|
||||
s.append(f'<ellipse cx="32" cy="21" rx="10.5" ry="7" fill="{p["l"]}" stroke="{p["o"]}" stroke-width="{ow}"/>')
|
||||
if not simple:
|
||||
s.append(f'<ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="{p["a"]}" stroke-width="2"/>')
|
||||
sw = 2.6 if simple else 2
|
||||
s.append(f'<path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="{p["ds"]}" stroke="{p["sep"]}" stroke-width="{sw}" stroke-linejoin="round"/>')
|
||||
s.append(f'<ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="{p["d"]}" stroke="{p["sep"]}" stroke-width="{sw}"/>')
|
||||
if not simple:
|
||||
s.append(f'<ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="{p["de"]}" stroke-width="1.6"/>')
|
||||
return "".join(s)
|
||||
|
||||
|
||||
# ---------- Logotype ----------
|
||||
font = TTFont(FONT)
|
||||
gs = font.getGlyphSet()
|
||||
cmap = font.getBestCmap()
|
||||
hmtx = font["hmtx"]
|
||||
XH = font["OS/2"].sxHeight # hauteur d'x (465 pour Alegreya Sans Bold)
|
||||
STROKE = 0.21 * XH # épaisseur du trait des flèches, proche du fût des lettres
|
||||
MM_W = 3.0 * XH # largeur du bloc « mm »
|
||||
GAP = 20
|
||||
|
||||
|
||||
def glyph(ch, x, fill):
|
||||
g = cmap[ord(ch)]
|
||||
pen = SVGPathPen(gs)
|
||||
gs[g].draw(pen)
|
||||
return f'<path transform="translate({x:.1f},0) scale(1,-1)" d="{pen.getCommands()}" fill="{fill}"/>', hmtx[g][0]
|
||||
|
||||
|
||||
def inter(p1, d1, p2, d2):
|
||||
"""Intersection de deux droites données par un point et une direction."""
|
||||
(x1, y1), (dx1, dy1), (x2, y2), (dx2, dy2) = p1, d1, p2, d2
|
||||
det = dx1 * -dy2 - dy1 * -dx2
|
||||
t = ((x2 - x1) * -dy2 - (y2 - y1) * -dx2) / det
|
||||
return (x1 + t * dx1, y1 + t * dy1)
|
||||
|
||||
|
||||
def chevron(x0, x1, top):
|
||||
"""Flèche « ^ » au trait : pieds coupés sur la ligne de base (y = 0), sommet en onglet."""
|
||||
peak = ((x0 + x1) / 2, -top)
|
||||
h = STROKE / 2
|
||||
lines = []
|
||||
for a, b in (((x0, 0), peak), (peak, (x1, 0))):
|
||||
dx, dy = b[0] - a[0], b[1] - a[1]
|
||||
n = (dx * dx + dy * dy) ** 0.5
|
||||
nx, ny = -dy / n, dx / n
|
||||
lines.append(((a[0] + nx * h, a[1] + ny * h), (dx, dy), (a[0] - nx * h, a[1] - ny * h)))
|
||||
(lo, ld, li), (ro, rd, ri) = lines
|
||||
base = ((0, 0), (1, 0))
|
||||
l_ext, l_int = (li, lo) if li[1] < lo[1] else (lo, li)
|
||||
r_ext, r_int = (ri, ro) if ri[1] < ro[1] else (ro, ri)
|
||||
pts = [inter(l_ext, ld, *base), inter(l_ext, ld, r_ext, rd), inter(r_ext, rd, *base),
|
||||
inter(r_int, rd, *base), inter(l_int, ld, r_int, rd), inter(l_int, ld, *base)]
|
||||
return " ".join(f"{x:.1f},{y:.1f}" for x, y in pts)
|
||||
|
||||
|
||||
def logotype(p, x=0.0):
|
||||
parts = []
|
||||
for ch in "Ustaga":
|
||||
s, adv = glyph(ch, x, p["txt"])
|
||||
parts.append(s)
|
||||
x += adv
|
||||
x += GAP
|
||||
unit = MM_W / 300 # coordonnées de la maquette : boîte de 300 × 100
|
||||
top = XH * 1.06 # léger dépassement de la hauteur d'x, comme une lettre pointue
|
||||
for i, (a, b) in enumerate(((8, 74), (74, 140), (160, 226), (226, 292))):
|
||||
fill = p["txt"] if i % 2 == 0 else p["acc"]
|
||||
parts.append(f'<polygon points="{chevron(x + a * unit, x + b * unit, top)}" fill="{fill}"/>')
|
||||
x += MM_W + GAP
|
||||
for ch in "on":
|
||||
s, adv = glyph(ch, x, p["txt"])
|
||||
parts.append(s)
|
||||
x += adv
|
||||
return "".join(parts), x
|
||||
|
||||
|
||||
ASC, DESC = 680, 240 # marges verticales autour de la ligne de base
|
||||
|
||||
|
||||
def mono_wrap(body, vb, ink, mid):
|
||||
"""Transforme un dessin encre/trou en dessin d'une seule couleur, trous transparents."""
|
||||
body = body.replace('"I"', '"#fff"').replace('"H"', '"#000"')
|
||||
x, y, w, h = vb
|
||||
return (f'<mask id="{mid}" maskUnits="userSpaceOnUse" x="{x}" y="{y}" width="{w}" height="{h}">'
|
||||
f'<rect x="{x}" y="{y}" width="{w}" height="{h}" fill="#000"/>{body}</mask>'
|
||||
f'<rect x="{x}" y="{y}" width="{w}" height="{h}" fill="{ink}" mask="url(#{mid})"/>')
|
||||
|
||||
|
||||
def svg(vb, body, title):
|
||||
return (f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="{" ".join(f"{v:g}" for v in vb)}" '
|
||||
f'width="{vb[2]:g}" height="{vb[3]:g}" role="img" aria-label="{title}"><title>{title}</title>{body}</svg>\n')
|
||||
|
||||
|
||||
def write(name, content):
|
||||
with open(os.path.join(OUT, name), "w", encoding="utf-8") as f:
|
||||
f.write(content)
|
||||
|
||||
|
||||
VARIANTS = {"couleur": COULEUR, "sombre": SOMBRE, "noir": "#000000", "blanc": "#FFFFFF"}
|
||||
|
||||
|
||||
def palette(v):
|
||||
return VARIANTS[v] if isinstance(VARIANTS[v], dict) else MONO
|
||||
|
||||
|
||||
def ink(body, v):
|
||||
return body if isinstance(VARIANTS[v], dict) else body.replace('"I"', f'"{VARIANTS[v]}"')
|
||||
|
||||
|
||||
# ---------- Symbole ----------
|
||||
for v in VARIANTS:
|
||||
vb = (0, 0, 64, 64)
|
||||
body = symbol(palette(v))
|
||||
if not isinstance(VARIANTS[v], dict):
|
||||
body = mono_wrap(body, vb, VARIANTS[v], "m")
|
||||
write(f"symbole-{v}.svg", svg(vb, body, "Ustagammon"))
|
||||
|
||||
# ---------- Logotype seul ----------
|
||||
for v in VARIANTS:
|
||||
body, w = logotype(palette(v))
|
||||
write(f"logotype-{v}.svg", svg((-10, -ASC, round(w + 20), ASC + DESC), ink(body, v), "Ustagammon"))
|
||||
|
||||
# ---------- Logo horizontal ----------
|
||||
SYM = 1450 # hauteur du symbole, pour un corps de 1000
|
||||
CENTER = -322 # centre optique : mi-hauteur des capitales
|
||||
for v in VARIANTS:
|
||||
p = palette(v)
|
||||
sym = f'<g transform="translate(0,{CENTER - SYM / 2}) scale({SYM / 64:.4f})">{symbol(p)}</g>'
|
||||
text, w = logotype(p, x=SYM + 280)
|
||||
vb = (-20, CENTER - SYM / 2 - 20, round(w + 40), SYM + 40)
|
||||
if not isinstance(VARIANTS[v], dict):
|
||||
sym = mono_wrap(sym, vb, VARIANTS[v], "m")
|
||||
write(f"logo-horizontal-{v}.svg", svg(vb, sym + ink(text, v), "Ustagammon"))
|
||||
|
||||
# ---------- Icônes ----------
|
||||
IVOIRE = "#F3EAD8"
|
||||
|
||||
|
||||
def placed(frac, size, pal=COULEUR, simple=False):
|
||||
"""Symbole centré dans un carré de `size`, occupant la fraction `frac` du côté."""
|
||||
s = size * frac / 64
|
||||
off = (size - 64 * s) / 2
|
||||
return f'<g transform="translate({off:.2f},{off:.2f}) scale({s:.4f})">{symbol(pal, simple)}</g>'
|
||||
|
||||
|
||||
# Icône « any » : tuile ivoire aux coins arrondis, transparente autour
|
||||
write("icone.svg", svg((0, 0, 512, 512), f'<rect width="512" height="512" rx="112" fill="{IVOIRE}"/>' + placed(0.70, 512), "Ustagammon"))
|
||||
# Icône « maskable » : fond plein, symbole dans la zone de sécurité (cercle de 80 %)
|
||||
write("icone-maskable.svg", svg((0, 0, 512, 512), f'<rect width="512" height="512" fill="{IVOIRE}"/>' + placed(0.56, 512), "Ustagammon"))
|
||||
# Favicon : dessin simplifié (sans filets), traits épaissis, fond transparent
|
||||
write("favicon.svg", svg((0, 0, 64, 64), symbol(COULEUR, simple=True), "Ustagammon"))
|
||||
# Android, icône adaptative : canevas de 108 × 108 dp, zone sûre de 66 dp au centre
|
||||
write("android-premier-plan.svg", svg((0, 0, 108, 108), placed(0.58, 108), "Ustagammon, premier plan"))
|
||||
write("android-arriere-plan.svg", svg((0, 0, 108, 108), f'<rect width="108" height="108" fill="{IVOIRE}"/>', "Ustagammon, arrière-plan"))
|
||||
write("android-monochrome.svg", svg((0, 0, 108, 108), mono_wrap(placed(0.58, 108, MONO), (0, 0, 108, 108), "#000000", "m"), "Ustagammon, monochrome"))
|
||||
print("\n".join(sorted(os.listdir(OUT))))
|
||||
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 108 108" width="108" height="108" role="img" aria-label="Ustagammon, arrière-plan"><title>Ustagammon, arrière-plan</title><rect width="108" height="108" fill="#F3EAD8"/></svg>
|
||||
|
After Width: | Height: | Size: 231 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 108 108" width="108" height="108" role="img" aria-label="Ustagammon, monochrome"><title>Ustagammon, monochrome</title><mask id="m" maskUnits="userSpaceOnUse" x="0" y="0" width="108" height="108"><rect x="0" y="0" width="108" height="108" fill="#000"/><g transform="translate(22.68,22.68) scale(0.9787)"><polygon points="6,62 58,62 32,1" fill="#fff"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#fff" stroke="#fff" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#000" stroke="#fff" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#fff" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#fff" stroke="#000" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#fff" stroke="#000" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#000" stroke-width="1.6"/></g></mask><rect x="0" y="0" width="108" height="108" fill="#000000" mask="url(#m)"/></svg>
|
||||
|
After Width: | Height: | Size: 1.1 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 108 108" width="108" height="108" role="img" aria-label="Ustagammon, premier plan"><title>Ustagammon, premier plan</title><g transform="translate(22.68,22.68) scale(0.9787)"><polygon points="6,62 58,62 32,1" fill="#A8432B"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#A8432B" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#7A5038" stroke-width="1.6"/></g></svg>
|
||||
|
After Width: | Height: | Size: 912 B |
Binary file not shown.
|
After Width: | Height: | Size: 6.0 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 618 B |
Binary file not shown.
|
After Width: | Height: | Size: 1.4 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.2 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Ustagammon"><title>Ustagammon</title><polygon points="6,62 58,62 32,1" fill="#A8432B"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="3" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="3"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2.6" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2.6"/></svg>
|
||||
|
After Width: | Height: | Size: 642 B |
Binary file not shown.
|
After Width: | Height: | Size: 9.8 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 28 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 6.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 18 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512" role="img" aria-label="Ustagammon"><title>Ustagammon</title><rect width="512" height="512" fill="#F3EAD8"/><g transform="translate(112.64,112.64) scale(4.4800)"><polygon points="6,62 58,62 32,1" fill="#A8432B"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#A8432B" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#7A5038" stroke-width="1.6"/></g></svg>
|
||||
|
After Width: | Height: | Size: 933 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512" role="img" aria-label="Ustagammon"><title>Ustagammon</title><rect width="512" height="512" rx="112" fill="#F3EAD8"/><g transform="translate(76.80,76.80) scale(5.6000)"><polygon points="6,62 58,62 32,1" fill="#A8432B"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#A8432B" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#7A5038" stroke-width="1.6"/></g></svg>
|
||||
|
After Width: | Height: | Size: 940 B |
File diff suppressed because one or more lines are too long
|
After Width: | Height: | Size: 5.0 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="-20 -1067 7050 1490" width="7050" height="1490" role="img" aria-label="Ustagammon"><title>Ustagammon</title><g transform="translate(0,-1047.0) scale(22.6562)"><polygon points="6,62 58,62 32,1" fill="#A8432B"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#A8432B" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#7A5038" stroke-width="1.6"/></g><path transform="translate(1730.0,0) scale(1,-1)" d="M573 317 572 232Q573 117 505.0 54.0Q437 -9 310 -9Q188 -9 124.0 52.0Q60 113 63 227L64 320L61 644H197L190 245Q189 172 221.0 137.0Q253 102 318 102Q448 102 447 238L440 644H578Z" fill="#2B1D15"/><path transform="translate(2368.0,0) scale(1,-1)" d="M345 450 327 352 311 347Q282 366 253.0 376.0Q224 386 202 386Q178 386 164.0 373.5Q150 361 150 343Q150 322 168.5 309.0Q187 296 227 280Q267 264 293.0 249.0Q319 234 337.5 207.5Q356 181 356 142Q356 102 335.5 67.5Q315 33 273.0 11.5Q231 -10 170 -10Q98 -10 21 20L36 124L49 132Q80 106 118.0 90.5Q156 75 185 75Q212 75 227.0 88.5Q242 102 242 121Q242 142 223.5 155.0Q205 168 165 184Q124 202 98.0 216.5Q72 231 53.5 258.0Q35 285 35 325Q35 390 84.0 431.5Q133 473 217 473Q285 473 345 450Z" fill="#2B1D15"/><path transform="translate(2752.0,0) scale(1,-1)" d="M316 115 327 105 314 26Q263 0 210 -6Q75 8 75 126L80 209L79 381H17L12 388L19 461H78V538L199 577L208 569L205 461H324L328 454L322 381H203L197 157Q197 125 209.0 111.5Q221 98 249 98Q281 98 316 115Z" fill="#2B1D15"/><path transform="translate(3090.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#2B1D15"/><path transform="translate(3571.0,0) scale(1,-1)" d="M431 387 429 383Q444 353 444 316Q444 241 389.5 196.5Q335 152 242 152Q214 152 184 157Q175 148 172.0 143.0Q169 138 169 131Q169 113 193.0 106.0Q217 99 269 92Q328 85 367.5 75.0Q407 65 435.5 40.0Q464 15 464 -31Q464 -78 434.5 -115.5Q405 -153 353.0 -174.0Q301 -195 235 -195Q144 -195 95.0 -158.0Q46 -121 46 -60Q77 -17 129 15V20Q95 32 76.0 53.5Q57 75 57 111Q84 144 125 172V177Q89 197 70.5 229.5Q52 262 52 306Q52 384 106.0 428.0Q160 472 253 472Q307 472 351 454Q423 467 498 494L508 485V402Q481 395 431 387ZM329 314Q329 390 251 390Q167 390 167 313Q167 273 187.0 252.5Q207 232 246 232Q287 232 308.0 253.0Q329 274 329 314ZM236 -1 202 4Q178 -12 166.0 -27.0Q154 -42 154 -59Q154 -85 178.0 -101.0Q202 -117 248 -117Q295 -117 323.5 -100.5Q352 -84 352 -55Q352 -28 323.5 -18.0Q295 -8 236 -1Z" fill="#2B1D15"/><path transform="translate(4071.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#2B1D15"/><polygon points="4558.1,0.0 4762.6,-657.2 4967.2,0.0 4865.0,0.0 4762.6,-328.6 4660.3,0.0" fill="#2B1D15"/><polygon points="4865.0,0.0 5069.6,-657.2 5274.1,0.0 5171.9,0.0 5069.6,-328.6 4967.2,0.0" fill="#A8432B"/><polygon points="5264.9,0.0 5469.4,-657.2 5674.0,0.0 5571.8,0.0 5469.4,-328.6 5367.1,0.0" fill="#2B1D15"/><polygon points="5571.8,0.0 5776.4,-657.2 5980.9,0.0 5878.7,0.0 5776.4,-328.6 5674.0,0.0" fill="#A8432B"/><path transform="translate(5987.0,0) scale(1,-1)" d="M464 241Q464 119 406.0 54.5Q348 -10 239 -10Q137 -10 83.0 50.0Q29 110 29 223Q29 345 87.0 409.5Q145 474 254 474Q356 474 410.0 414.0Q464 354 464 241ZM154 249Q154 157 176.0 118.0Q198 79 248 79Q296 79 317.5 110.5Q339 142 339 214Q339 305 316.5 344.5Q294 384 245 384Q197 384 175.5 352.0Q154 320 154 249Z" fill="#2B1D15"/><path transform="translate(6481.0,0) scale(1,-1)" d="M347 290Q348 325 331.5 344.5Q315 364 284 364Q239 364 188 321V205L194 0H61L68 192L63 456L189 467V399H196Q251 449 316 471Q392 471 432.0 436.5Q472 402 470 337L467 204L473 0H339Z" fill="#2B1D15"/></svg>
|
||||
|
After Width: | Height: | Size: 4.8 KiB |
File diff suppressed because one or more lines are too long
|
After Width: | Height: | Size: 5.0 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="-20 -1067 7050 1490" width="7050" height="1490" role="img" aria-label="Ustagammon"><title>Ustagammon</title><g transform="translate(0,-1047.0) scale(22.6562)"><polygon points="6,62 58,62 32,1" fill="#C9583C"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#C9583C" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#7A5038" stroke-width="1.6"/></g><path transform="translate(1730.0,0) scale(1,-1)" d="M573 317 572 232Q573 117 505.0 54.0Q437 -9 310 -9Q188 -9 124.0 52.0Q60 113 63 227L64 320L61 644H197L190 245Q189 172 221.0 137.0Q253 102 318 102Q448 102 447 238L440 644H578Z" fill="#F3EAD8"/><path transform="translate(2368.0,0) scale(1,-1)" d="M345 450 327 352 311 347Q282 366 253.0 376.0Q224 386 202 386Q178 386 164.0 373.5Q150 361 150 343Q150 322 168.5 309.0Q187 296 227 280Q267 264 293.0 249.0Q319 234 337.5 207.5Q356 181 356 142Q356 102 335.5 67.5Q315 33 273.0 11.5Q231 -10 170 -10Q98 -10 21 20L36 124L49 132Q80 106 118.0 90.5Q156 75 185 75Q212 75 227.0 88.5Q242 102 242 121Q242 142 223.5 155.0Q205 168 165 184Q124 202 98.0 216.5Q72 231 53.5 258.0Q35 285 35 325Q35 390 84.0 431.5Q133 473 217 473Q285 473 345 450Z" fill="#F3EAD8"/><path transform="translate(2752.0,0) scale(1,-1)" d="M316 115 327 105 314 26Q263 0 210 -6Q75 8 75 126L80 209L79 381H17L12 388L19 461H78V538L199 577L208 569L205 461H324L328 454L322 381H203L197 157Q197 125 209.0 111.5Q221 98 249 98Q281 98 316 115Z" fill="#F3EAD8"/><path transform="translate(3090.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#F3EAD8"/><path transform="translate(3571.0,0) scale(1,-1)" d="M431 387 429 383Q444 353 444 316Q444 241 389.5 196.5Q335 152 242 152Q214 152 184 157Q175 148 172.0 143.0Q169 138 169 131Q169 113 193.0 106.0Q217 99 269 92Q328 85 367.5 75.0Q407 65 435.5 40.0Q464 15 464 -31Q464 -78 434.5 -115.5Q405 -153 353.0 -174.0Q301 -195 235 -195Q144 -195 95.0 -158.0Q46 -121 46 -60Q77 -17 129 15V20Q95 32 76.0 53.5Q57 75 57 111Q84 144 125 172V177Q89 197 70.5 229.5Q52 262 52 306Q52 384 106.0 428.0Q160 472 253 472Q307 472 351 454Q423 467 498 494L508 485V402Q481 395 431 387ZM329 314Q329 390 251 390Q167 390 167 313Q167 273 187.0 252.5Q207 232 246 232Q287 232 308.0 253.0Q329 274 329 314ZM236 -1 202 4Q178 -12 166.0 -27.0Q154 -42 154 -59Q154 -85 178.0 -101.0Q202 -117 248 -117Q295 -117 323.5 -100.5Q352 -84 352 -55Q352 -28 323.5 -18.0Q295 -8 236 -1Z" fill="#F3EAD8"/><path transform="translate(4071.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#F3EAD8"/><polygon points="4558.1,0.0 4762.6,-657.2 4967.2,0.0 4865.0,0.0 4762.6,-328.6 4660.3,0.0" fill="#F3EAD8"/><polygon points="4865.0,0.0 5069.6,-657.2 5274.1,0.0 5171.9,0.0 5069.6,-328.6 4967.2,0.0" fill="#D0694B"/><polygon points="5264.9,0.0 5469.4,-657.2 5674.0,0.0 5571.8,0.0 5469.4,-328.6 5367.1,0.0" fill="#F3EAD8"/><polygon points="5571.8,0.0 5776.4,-657.2 5980.9,0.0 5878.7,0.0 5776.4,-328.6 5674.0,0.0" fill="#D0694B"/><path transform="translate(5987.0,0) scale(1,-1)" d="M464 241Q464 119 406.0 54.5Q348 -10 239 -10Q137 -10 83.0 50.0Q29 110 29 223Q29 345 87.0 409.5Q145 474 254 474Q356 474 410.0 414.0Q464 354 464 241ZM154 249Q154 157 176.0 118.0Q198 79 248 79Q296 79 317.5 110.5Q339 142 339 214Q339 305 316.5 344.5Q294 384 245 384Q197 384 175.5 352.0Q154 320 154 249Z" fill="#F3EAD8"/><path transform="translate(6481.0,0) scale(1,-1)" d="M347 290Q348 325 331.5 344.5Q315 364 284 364Q239 364 188 321V205L194 0H61L68 192L63 456L189 467V399H196Q251 449 316 471Q392 471 432.0 436.5Q472 402 470 337L467 204L473 0H339Z" fill="#F3EAD8"/></svg>
|
||||
|
After Width: | Height: | Size: 4.8 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="-10 -680 5300 920" width="5300" height="920" role="img" aria-label="Ustagammon"><title>Ustagammon</title><path transform="translate(0.0,0) scale(1,-1)" d="M573 317 572 232Q573 117 505.0 54.0Q437 -9 310 -9Q188 -9 124.0 52.0Q60 113 63 227L64 320L61 644H197L190 245Q189 172 221.0 137.0Q253 102 318 102Q448 102 447 238L440 644H578Z" fill="#FFFFFF"/><path transform="translate(638.0,0) scale(1,-1)" d="M345 450 327 352 311 347Q282 366 253.0 376.0Q224 386 202 386Q178 386 164.0 373.5Q150 361 150 343Q150 322 168.5 309.0Q187 296 227 280Q267 264 293.0 249.0Q319 234 337.5 207.5Q356 181 356 142Q356 102 335.5 67.5Q315 33 273.0 11.5Q231 -10 170 -10Q98 -10 21 20L36 124L49 132Q80 106 118.0 90.5Q156 75 185 75Q212 75 227.0 88.5Q242 102 242 121Q242 142 223.5 155.0Q205 168 165 184Q124 202 98.0 216.5Q72 231 53.5 258.0Q35 285 35 325Q35 390 84.0 431.5Q133 473 217 473Q285 473 345 450Z" fill="#FFFFFF"/><path transform="translate(1022.0,0) scale(1,-1)" d="M316 115 327 105 314 26Q263 0 210 -6Q75 8 75 126L80 209L79 381H17L12 388L19 461H78V538L199 577L208 569L205 461H324L328 454L322 381H203L197 157Q197 125 209.0 111.5Q221 98 249 98Q281 98 316 115Z" fill="#FFFFFF"/><path transform="translate(1360.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#FFFFFF"/><path transform="translate(1841.0,0) scale(1,-1)" d="M431 387 429 383Q444 353 444 316Q444 241 389.5 196.5Q335 152 242 152Q214 152 184 157Q175 148 172.0 143.0Q169 138 169 131Q169 113 193.0 106.0Q217 99 269 92Q328 85 367.5 75.0Q407 65 435.5 40.0Q464 15 464 -31Q464 -78 434.5 -115.5Q405 -153 353.0 -174.0Q301 -195 235 -195Q144 -195 95.0 -158.0Q46 -121 46 -60Q77 -17 129 15V20Q95 32 76.0 53.5Q57 75 57 111Q84 144 125 172V177Q89 197 70.5 229.5Q52 262 52 306Q52 384 106.0 428.0Q160 472 253 472Q307 472 351 454Q423 467 498 494L508 485V402Q481 395 431 387ZM329 314Q329 390 251 390Q167 390 167 313Q167 273 187.0 252.5Q207 232 246 232Q287 232 308.0 253.0Q329 274 329 314ZM236 -1 202 4Q178 -12 166.0 -27.0Q154 -42 154 -59Q154 -85 178.0 -101.0Q202 -117 248 -117Q295 -117 323.5 -100.5Q352 -84 352 -55Q352 -28 323.5 -18.0Q295 -8 236 -1Z" fill="#FFFFFF"/><path transform="translate(2341.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#FFFFFF"/><polygon points="2828.1,0.0 3032.6,-657.2 3237.2,0.0 3135.0,0.0 3032.6,-328.6 2930.3,0.0" fill="#FFFFFF"/><polygon points="3135.0,0.0 3339.6,-657.2 3544.1,0.0 3441.9,0.0 3339.6,-328.6 3237.2,0.0" fill="#FFFFFF"/><polygon points="3534.9,0.0 3739.4,-657.2 3944.0,0.0 3841.8,0.0 3739.4,-328.6 3637.1,0.0" fill="#FFFFFF"/><polygon points="3841.8,0.0 4046.4,-657.2 4250.9,0.0 4148.7,0.0 4046.4,-328.6 3944.0,0.0" fill="#FFFFFF"/><path transform="translate(4257.0,0) scale(1,-1)" d="M464 241Q464 119 406.0 54.5Q348 -10 239 -10Q137 -10 83.0 50.0Q29 110 29 223Q29 345 87.0 409.5Q145 474 254 474Q356 474 410.0 414.0Q464 354 464 241ZM154 249Q154 157 176.0 118.0Q198 79 248 79Q296 79 317.5 110.5Q339 142 339 214Q339 305 316.5 344.5Q294 384 245 384Q197 384 175.5 352.0Q154 320 154 249Z" fill="#FFFFFF"/><path transform="translate(4751.0,0) scale(1,-1)" d="M347 290Q348 325 331.5 344.5Q315 364 284 364Q239 364 188 321V205L194 0H61L68 192L63 456L189 467V399H196Q251 449 316 471Q392 471 432.0 436.5Q472 402 470 337L467 204L473 0H339Z" fill="#FFFFFF"/></svg>
|
||||
|
After Width: | Height: | Size: 4.1 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="-10 -680 5300 920" width="5300" height="920" role="img" aria-label="Ustagammon"><title>Ustagammon</title><path transform="translate(0.0,0) scale(1,-1)" d="M573 317 572 232Q573 117 505.0 54.0Q437 -9 310 -9Q188 -9 124.0 52.0Q60 113 63 227L64 320L61 644H197L190 245Q189 172 221.0 137.0Q253 102 318 102Q448 102 447 238L440 644H578Z" fill="#2B1D15"/><path transform="translate(638.0,0) scale(1,-1)" d="M345 450 327 352 311 347Q282 366 253.0 376.0Q224 386 202 386Q178 386 164.0 373.5Q150 361 150 343Q150 322 168.5 309.0Q187 296 227 280Q267 264 293.0 249.0Q319 234 337.5 207.5Q356 181 356 142Q356 102 335.5 67.5Q315 33 273.0 11.5Q231 -10 170 -10Q98 -10 21 20L36 124L49 132Q80 106 118.0 90.5Q156 75 185 75Q212 75 227.0 88.5Q242 102 242 121Q242 142 223.5 155.0Q205 168 165 184Q124 202 98.0 216.5Q72 231 53.5 258.0Q35 285 35 325Q35 390 84.0 431.5Q133 473 217 473Q285 473 345 450Z" fill="#2B1D15"/><path transform="translate(1022.0,0) scale(1,-1)" d="M316 115 327 105 314 26Q263 0 210 -6Q75 8 75 126L80 209L79 381H17L12 388L19 461H78V538L199 577L208 569L205 461H324L328 454L322 381H203L197 157Q197 125 209.0 111.5Q221 98 249 98Q281 98 316 115Z" fill="#2B1D15"/><path transform="translate(1360.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#2B1D15"/><path transform="translate(1841.0,0) scale(1,-1)" d="M431 387 429 383Q444 353 444 316Q444 241 389.5 196.5Q335 152 242 152Q214 152 184 157Q175 148 172.0 143.0Q169 138 169 131Q169 113 193.0 106.0Q217 99 269 92Q328 85 367.5 75.0Q407 65 435.5 40.0Q464 15 464 -31Q464 -78 434.5 -115.5Q405 -153 353.0 -174.0Q301 -195 235 -195Q144 -195 95.0 -158.0Q46 -121 46 -60Q77 -17 129 15V20Q95 32 76.0 53.5Q57 75 57 111Q84 144 125 172V177Q89 197 70.5 229.5Q52 262 52 306Q52 384 106.0 428.0Q160 472 253 472Q307 472 351 454Q423 467 498 494L508 485V402Q481 395 431 387ZM329 314Q329 390 251 390Q167 390 167 313Q167 273 187.0 252.5Q207 232 246 232Q287 232 308.0 253.0Q329 274 329 314ZM236 -1 202 4Q178 -12 166.0 -27.0Q154 -42 154 -59Q154 -85 178.0 -101.0Q202 -117 248 -117Q295 -117 323.5 -100.5Q352 -84 352 -55Q352 -28 323.5 -18.0Q295 -8 236 -1Z" fill="#2B1D15"/><path transform="translate(2341.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#2B1D15"/><polygon points="2828.1,0.0 3032.6,-657.2 3237.2,0.0 3135.0,0.0 3032.6,-328.6 2930.3,0.0" fill="#2B1D15"/><polygon points="3135.0,0.0 3339.6,-657.2 3544.1,0.0 3441.9,0.0 3339.6,-328.6 3237.2,0.0" fill="#A8432B"/><polygon points="3534.9,0.0 3739.4,-657.2 3944.0,0.0 3841.8,0.0 3739.4,-328.6 3637.1,0.0" fill="#2B1D15"/><polygon points="3841.8,0.0 4046.4,-657.2 4250.9,0.0 4148.7,0.0 4046.4,-328.6 3944.0,0.0" fill="#A8432B"/><path transform="translate(4257.0,0) scale(1,-1)" d="M464 241Q464 119 406.0 54.5Q348 -10 239 -10Q137 -10 83.0 50.0Q29 110 29 223Q29 345 87.0 409.5Q145 474 254 474Q356 474 410.0 414.0Q464 354 464 241ZM154 249Q154 157 176.0 118.0Q198 79 248 79Q296 79 317.5 110.5Q339 142 339 214Q339 305 316.5 344.5Q294 384 245 384Q197 384 175.5 352.0Q154 320 154 249Z" fill="#2B1D15"/><path transform="translate(4751.0,0) scale(1,-1)" d="M347 290Q348 325 331.5 344.5Q315 364 284 364Q239 364 188 321V205L194 0H61L68 192L63 456L189 467V399H196Q251 449 316 471Q392 471 432.0 436.5Q472 402 470 337L467 204L473 0H339Z" fill="#2B1D15"/></svg>
|
||||
|
After Width: | Height: | Size: 4.1 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="-10 -680 5300 920" width="5300" height="920" role="img" aria-label="Ustagammon"><title>Ustagammon</title><path transform="translate(0.0,0) scale(1,-1)" d="M573 317 572 232Q573 117 505.0 54.0Q437 -9 310 -9Q188 -9 124.0 52.0Q60 113 63 227L64 320L61 644H197L190 245Q189 172 221.0 137.0Q253 102 318 102Q448 102 447 238L440 644H578Z" fill="#000000"/><path transform="translate(638.0,0) scale(1,-1)" d="M345 450 327 352 311 347Q282 366 253.0 376.0Q224 386 202 386Q178 386 164.0 373.5Q150 361 150 343Q150 322 168.5 309.0Q187 296 227 280Q267 264 293.0 249.0Q319 234 337.5 207.5Q356 181 356 142Q356 102 335.5 67.5Q315 33 273.0 11.5Q231 -10 170 -10Q98 -10 21 20L36 124L49 132Q80 106 118.0 90.5Q156 75 185 75Q212 75 227.0 88.5Q242 102 242 121Q242 142 223.5 155.0Q205 168 165 184Q124 202 98.0 216.5Q72 231 53.5 258.0Q35 285 35 325Q35 390 84.0 431.5Q133 473 217 473Q285 473 345 450Z" fill="#000000"/><path transform="translate(1022.0,0) scale(1,-1)" d="M316 115 327 105 314 26Q263 0 210 -6Q75 8 75 126L80 209L79 381H17L12 388L19 461H78V538L199 577L208 569L205 461H324L328 454L322 381H203L197 157Q197 125 209.0 111.5Q221 98 249 98Q281 98 316 115Z" fill="#000000"/><path transform="translate(1360.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#000000"/><path transform="translate(1841.0,0) scale(1,-1)" d="M431 387 429 383Q444 353 444 316Q444 241 389.5 196.5Q335 152 242 152Q214 152 184 157Q175 148 172.0 143.0Q169 138 169 131Q169 113 193.0 106.0Q217 99 269 92Q328 85 367.5 75.0Q407 65 435.5 40.0Q464 15 464 -31Q464 -78 434.5 -115.5Q405 -153 353.0 -174.0Q301 -195 235 -195Q144 -195 95.0 -158.0Q46 -121 46 -60Q77 -17 129 15V20Q95 32 76.0 53.5Q57 75 57 111Q84 144 125 172V177Q89 197 70.5 229.5Q52 262 52 306Q52 384 106.0 428.0Q160 472 253 472Q307 472 351 454Q423 467 498 494L508 485V402Q481 395 431 387ZM329 314Q329 390 251 390Q167 390 167 313Q167 273 187.0 252.5Q207 232 246 232Q287 232 308.0 253.0Q329 274 329 314ZM236 -1 202 4Q178 -12 166.0 -27.0Q154 -42 154 -59Q154 -85 178.0 -101.0Q202 -117 248 -117Q295 -117 323.5 -100.5Q352 -84 352 -55Q352 -28 323.5 -18.0Q295 -8 236 -1Z" fill="#000000"/><path transform="translate(2341.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#000000"/><polygon points="2828.1,0.0 3032.6,-657.2 3237.2,0.0 3135.0,0.0 3032.6,-328.6 2930.3,0.0" fill="#000000"/><polygon points="3135.0,0.0 3339.6,-657.2 3544.1,0.0 3441.9,0.0 3339.6,-328.6 3237.2,0.0" fill="#000000"/><polygon points="3534.9,0.0 3739.4,-657.2 3944.0,0.0 3841.8,0.0 3739.4,-328.6 3637.1,0.0" fill="#000000"/><polygon points="3841.8,0.0 4046.4,-657.2 4250.9,0.0 4148.7,0.0 4046.4,-328.6 3944.0,0.0" fill="#000000"/><path transform="translate(4257.0,0) scale(1,-1)" d="M464 241Q464 119 406.0 54.5Q348 -10 239 -10Q137 -10 83.0 50.0Q29 110 29 223Q29 345 87.0 409.5Q145 474 254 474Q356 474 410.0 414.0Q464 354 464 241ZM154 249Q154 157 176.0 118.0Q198 79 248 79Q296 79 317.5 110.5Q339 142 339 214Q339 305 316.5 344.5Q294 384 245 384Q197 384 175.5 352.0Q154 320 154 249Z" fill="#000000"/><path transform="translate(4751.0,0) scale(1,-1)" d="M347 290Q348 325 331.5 344.5Q315 364 284 364Q239 364 188 321V205L194 0H61L68 192L63 456L189 467V399H196Q251 449 316 471Q392 471 432.0 436.5Q472 402 470 337L467 204L473 0H339Z" fill="#000000"/></svg>
|
||||
|
After Width: | Height: | Size: 4.1 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="-10 -680 5300 920" width="5300" height="920" role="img" aria-label="Ustagammon"><title>Ustagammon</title><path transform="translate(0.0,0) scale(1,-1)" d="M573 317 572 232Q573 117 505.0 54.0Q437 -9 310 -9Q188 -9 124.0 52.0Q60 113 63 227L64 320L61 644H197L190 245Q189 172 221.0 137.0Q253 102 318 102Q448 102 447 238L440 644H578Z" fill="#F3EAD8"/><path transform="translate(638.0,0) scale(1,-1)" d="M345 450 327 352 311 347Q282 366 253.0 376.0Q224 386 202 386Q178 386 164.0 373.5Q150 361 150 343Q150 322 168.5 309.0Q187 296 227 280Q267 264 293.0 249.0Q319 234 337.5 207.5Q356 181 356 142Q356 102 335.5 67.5Q315 33 273.0 11.5Q231 -10 170 -10Q98 -10 21 20L36 124L49 132Q80 106 118.0 90.5Q156 75 185 75Q212 75 227.0 88.5Q242 102 242 121Q242 142 223.5 155.0Q205 168 165 184Q124 202 98.0 216.5Q72 231 53.5 258.0Q35 285 35 325Q35 390 84.0 431.5Q133 473 217 473Q285 473 345 450Z" fill="#F3EAD8"/><path transform="translate(1022.0,0) scale(1,-1)" d="M316 115 327 105 314 26Q263 0 210 -6Q75 8 75 126L80 209L79 381H17L12 388L19 461H78V538L199 577L208 569L205 461H324L328 454L322 381H203L197 157Q197 125 209.0 111.5Q221 98 249 98Q281 98 316 115Z" fill="#F3EAD8"/><path transform="translate(1360.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#F3EAD8"/><path transform="translate(1841.0,0) scale(1,-1)" d="M431 387 429 383Q444 353 444 316Q444 241 389.5 196.5Q335 152 242 152Q214 152 184 157Q175 148 172.0 143.0Q169 138 169 131Q169 113 193.0 106.0Q217 99 269 92Q328 85 367.5 75.0Q407 65 435.5 40.0Q464 15 464 -31Q464 -78 434.5 -115.5Q405 -153 353.0 -174.0Q301 -195 235 -195Q144 -195 95.0 -158.0Q46 -121 46 -60Q77 -17 129 15V20Q95 32 76.0 53.5Q57 75 57 111Q84 144 125 172V177Q89 197 70.5 229.5Q52 262 52 306Q52 384 106.0 428.0Q160 472 253 472Q307 472 351 454Q423 467 498 494L508 485V402Q481 395 431 387ZM329 314Q329 390 251 390Q167 390 167 313Q167 273 187.0 252.5Q207 232 246 232Q287 232 308.0 253.0Q329 274 329 314ZM236 -1 202 4Q178 -12 166.0 -27.0Q154 -42 154 -59Q154 -85 178.0 -101.0Q202 -117 248 -117Q295 -117 323.5 -100.5Q352 -84 352 -55Q352 -28 323.5 -18.0Q295 -8 236 -1Z" fill="#F3EAD8"/><path transform="translate(2341.0,0) scale(1,-1)" d="M408 343Q408 325 402 229Q401 201 399.0 171.5Q397 142 397 121Q397 104 402.0 97.5Q407 91 420 91Q430 91 446 95L456 87L444 17Q412 -4 371 -8Q341 -5 321.0 13.5Q301 32 294 65H287Q237 12 184 -9Q112 -8 71.0 29.0Q30 66 30 130Q30 180 55.5 208.5Q81 237 133 247L286 276V317Q286 382 222 382Q191 382 156.5 368.0Q122 354 79 324L69 330L54 418Q97 445 146.0 459.5Q195 474 244 474Q321 474 364.5 439.5Q408 405 408 343ZM179 186Q163 182 155.5 172.5Q148 163 148 144Q148 118 162.0 103.5Q176 89 201 89Q240 89 283 135L285 209Z" fill="#F3EAD8"/><polygon points="2828.1,0.0 3032.6,-657.2 3237.2,0.0 3135.0,0.0 3032.6,-328.6 2930.3,0.0" fill="#F3EAD8"/><polygon points="3135.0,0.0 3339.6,-657.2 3544.1,0.0 3441.9,0.0 3339.6,-328.6 3237.2,0.0" fill="#D0694B"/><polygon points="3534.9,0.0 3739.4,-657.2 3944.0,0.0 3841.8,0.0 3739.4,-328.6 3637.1,0.0" fill="#F3EAD8"/><polygon points="3841.8,0.0 4046.4,-657.2 4250.9,0.0 4148.7,0.0 4046.4,-328.6 3944.0,0.0" fill="#D0694B"/><path transform="translate(4257.0,0) scale(1,-1)" d="M464 241Q464 119 406.0 54.5Q348 -10 239 -10Q137 -10 83.0 50.0Q29 110 29 223Q29 345 87.0 409.5Q145 474 254 474Q356 474 410.0 414.0Q464 354 464 241ZM154 249Q154 157 176.0 118.0Q198 79 248 79Q296 79 317.5 110.5Q339 142 339 214Q339 305 316.5 344.5Q294 384 245 384Q197 384 175.5 352.0Q154 320 154 249Z" fill="#F3EAD8"/><path transform="translate(4751.0,0) scale(1,-1)" d="M347 290Q348 325 331.5 344.5Q315 364 284 364Q239 364 188 321V205L194 0H61L68 192L63 456L189 467V399H196Q251 449 316 471Q392 471 432.0 436.5Q472 402 470 337L467 204L473 0H339Z" fill="#F3EAD8"/></svg>
|
||||
|
After Width: | Height: | Size: 4.1 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Ustagammon"><title>Ustagammon</title><mask id="m" maskUnits="userSpaceOnUse" x="0" y="0" width="64" height="64"><rect x="0" y="0" width="64" height="64" fill="#000"/><polygon points="6,62 58,62 32,1" fill="#fff"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#fff" stroke="#fff" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#000" stroke="#fff" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#fff" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#fff" stroke="#000" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#fff" stroke="#000" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#000" stroke-width="1.6"/></mask><rect x="0" y="0" width="64" height="64" fill="#FFFFFF" mask="url(#m)"/></svg>
|
||||
|
After Width: | Height: | Size: 999 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Ustagammon"><title>Ustagammon</title><polygon points="6,62 58,62 32,1" fill="#A8432B"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#A8432B" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#7A5038" stroke-width="1.6"/></svg>
|
||||
|
After Width: | Height: | Size: 824 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Ustagammon"><title>Ustagammon</title><mask id="m" maskUnits="userSpaceOnUse" x="0" y="0" width="64" height="64"><rect x="0" y="0" width="64" height="64" fill="#000"/><polygon points="6,62 58,62 32,1" fill="#fff"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#fff" stroke="#fff" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#000" stroke="#fff" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#fff" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#fff" stroke="#000" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#fff" stroke="#000" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#000" stroke-width="1.6"/></mask><rect x="0" y="0" width="64" height="64" fill="#000000" mask="url(#m)"/></svg>
|
||||
|
After Width: | Height: | Size: 999 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Ustagammon"><title>Ustagammon</title><polygon points="6,62 58,62 32,1" fill="#C9583C"/><path d="M21.5,21 v4.5 a10.5,7 0 0 0 21,0 v-4.5 z" fill="#CDB898" stroke="#2B1A10" stroke-width="2.2" stroke-linejoin="round"/><ellipse cx="32" cy="21" rx="10.5" ry="7" fill="#F3EAD8" stroke="#2B1A10" stroke-width="2.2"/><ellipse cx="32" cy="21" rx="5.5" ry="3.6" fill="none" stroke="#C9583C" stroke-width="2"/><path d="M17.5,43 v6.5 a14.5,9.5 0 0 0 29,0 v-6.5 z" fill="#2B1A10" stroke="#F3EAD8" stroke-width="2" stroke-linejoin="round"/><ellipse cx="32" cy="43" rx="14.5" ry="9.5" fill="#4A2E1F" stroke="#F3EAD8" stroke-width="2"/><ellipse cx="32" cy="43" rx="8.3" ry="5.4" fill="none" stroke="#7A5038" stroke-width="1.6"/></svg>
|
||||
|
After Width: | Height: | Size: 824 B |
@@ -64,3 +64,49 @@ Une entrée datée par session : ce qui a été fait, décidé, et la suite.
|
||||
- Étape 0d : plateau minimal jouable sur le socle retenu.
|
||||
- `adb` n'est pas installé sur le PC : `sudo apt install adb` avant les tests sur
|
||||
le téléphone.
|
||||
|
||||
## 2026-11-02 (soir) et 2026-11-03
|
||||
|
||||
**Fait**
|
||||
- Mesures sur le Fairphone 4 (Chrome 156) : 2 plis en 348 ms au pire, seuil
|
||||
3 s ; ADR 0009 accepté (socle PWA en TypeScript), 0c abandonnée.
|
||||
- Déploiement CapRover (MR !10) : app `ustagammon` créée, site publié sur
|
||||
https://ustagammon.sans.pub (HTTPS forcé).
|
||||
- Étape 0d.1 (MR !11) : domaine « partie » en journal d'événements, scénario
|
||||
exécuté par Cucumber sur le vrai moteur, garde-fous d'architecture.
|
||||
- Étape 0d.2 : plateau jouable au toucher en PWA hors ligne, aide intégrée
|
||||
(glossaire et scénarios lus depuis leurs sources), CSP, `make test-browser`
|
||||
(parties complètes dans Chromium et Firefox). Deux bugs trouvés et corrigés :
|
||||
la pile du moteur WebAssembly débordait après quelques centaines de commandes
|
||||
(plantage en cours de partie), et le service worker échouait dans Chromium en
|
||||
téléchargeant les données en même temps que le moteur.
|
||||
- Interruptions de quota : reprise programmée à 23h50 ; l'agent de 0d.2 arrêté a
|
||||
été remplacé par un agent de reprise sur le même espace de travail.
|
||||
|
||||
**Reste à faire**
|
||||
- Vérification finale de l'étape 0 avec Pierre : une partie complète sur le
|
||||
Fairphone 4, en suivant le guide de test (section « Étape 0d »).
|
||||
- Sous Firefox sur PC, un tour de l'ordinateur a pris jusqu'à 5,1 s
|
||||
(Chromium : 0,4 s) ; Firefox sur le téléphone reste à mesurer.
|
||||
- Validation par Pierre de Playwright (Apache-2.0), outil de `make test-browser`.
|
||||
|
||||
## 2026-11-03 (nuit) : identité visuelle
|
||||
|
||||
**Fait**
|
||||
- Identité choisie par Pierre en trois tours sur une planche de travail :
|
||||
accent brique, symbole « P3d » (deux pions sur une flèche, le 8 caché),
|
||||
logotype « L3 » (les « mm » en flèches), icône sur fond ivoire. ADR 0010,
|
||||
fichiers du logo et des icônes dans `docs/identite/logo/` (MR !12).
|
||||
- Design system publié (https://claude.ai/artifact/K2Z7MPE58XXJzv19n5r11M) :
|
||||
couleurs des deux thèmes reprenant les noms de variables de `web/app.css`,
|
||||
Alegreya Sans, onze composants, contrastes vérifiés par calcul. Copie dans
|
||||
`docs/identite/charte/`.
|
||||
- Maquettes des quatre écrans et du thème sombre
|
||||
(https://claude.ai/artifact/CQw6vbDpi6XQqVWQa4sANe).
|
||||
|
||||
**Reste à faire**
|
||||
- Appliquer la charte à la PWA (couleurs, police embarquée, icônes, logo) :
|
||||
à planifier pour l'agent développeur, voir `docs/identite/charte/README.md`.
|
||||
- Les maquettes proposent des éléments de produit qui ne sont pas encore
|
||||
décidés (leçons, « Conseil du maître », bilan de fin de partie) : à valider
|
||||
par Pierre avant toute mise en œuvre.
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
# Revue UX : compte de points, fluidité, paysage
|
||||
|
||||
- **Date** : 2026-11-03
|
||||
- **Étape** : 0e (retours du premier test de Pierre sur le téléphone)
|
||||
- **Statut** : en cours
|
||||
- **Exécutant** : sous-agent general-purpose, rôle de designer UI, en lecture
|
||||
seule sur le code
|
||||
|
||||
## Objectif
|
||||
|
||||
Proposer à Pierre, avec maquettes, une meilleure présentation du compte de
|
||||
points et une revue de toute l'expérience de jeu (point 10 de son message du
|
||||
2026-11-03), en couvrant la fluidité (ligne 0d.2+ de la feuille de route) et le
|
||||
paysage sur téléphone (point 5).
|
||||
|
||||
## Consignes
|
||||
|
||||
- Partir de la charte (`docs/identite/`, ADR 0010), des ADR 0011 et 0012, et de
|
||||
l'application publiée (https://ustagammon.sans.pub, ou `make site` puis les
|
||||
captures de `make test-browser`).
|
||||
- Ne pas modifier le dépôt. Livrer un rapport en Markdown (chemin indiqué par
|
||||
la session principale) et, si utile, une page de maquettes.
|
||||
- Pour chaque proposition : le problème observé, la solution, sa maquette, son
|
||||
coût technique estimé, et ce qui relève d'un choix de Pierre.
|
||||
- Sujets imposés : compte de points ; bouton « Nouvelle partie » et tout ce qui
|
||||
interrompt la partie ; paysage sur téléphone, plateau sur presque tout
|
||||
l'écran, contrôles en pictogrammes.
|
||||
- Les changements de saisie du coup en cours (plan
|
||||
`2026-11-03-saisie-du-coup.md`) sont acquis : ne pas les reproposer.
|
||||
|
||||
## Critères de réussite
|
||||
|
||||
Un rapport priorisé que Pierre peut valider point par point.
|
||||
|
||||
## Résultat
|
||||
|
||||
À remplir à la clôture.
|
||||
@@ -0,0 +1,65 @@
|
||||
# Saisie du coup, videau confirmé, pages de test du moteur retirées
|
||||
|
||||
- **Date** : 2026-11-03
|
||||
- **Étape** : 0e (retours du premier test de Pierre sur le téléphone)
|
||||
- **Statut** : en cours
|
||||
- **Exécutant** : sous-agent general-purpose, dans un worktree
|
||||
|
||||
## Objectif
|
||||
|
||||
Rendre la saisie du coup aussi confortable que dans CBG, d'après les retours de
|
||||
Pierre du 2026-11-03 (points 1, 6, 7, 8, 9 et 11 de son message), et retirer du
|
||||
site les pages de test du moteur.
|
||||
|
||||
## Consignes
|
||||
|
||||
Règles de code : ADR 0007 (domaine pur, aucune règle de backgammon
|
||||
réimplémentée : tout vient du moteur via le domaine). Glossaire et scénarios :
|
||||
ADR 0008 (chaque comportement visible a son scénario Gherkin dans
|
||||
`docs/scenarios/`, chaque nouveau terme sa fiche). Aucune nouvelle dépendance.
|
||||
|
||||
1. **Pages de test du moteur retirées** (« supprimer la partie test du moteur
|
||||
totalement ») : plus de `/moteur/` sur le site ni dans `make deploy`.
|
||||
`make bench` (mesure sous Node) reste : déplacer ce dont il a besoin hors de
|
||||
`web/`. Mettre à jour `tests/test_site.sh`, le Makefile, `deploy/`, le
|
||||
service worker, `docs/guide-test-etape-0.md` et ajouter un amendement daté à
|
||||
l'ADR 0009.
|
||||
2. **Un seul coup possible, le pion avance** : quand le joueur touche un pion
|
||||
(ou une case) et qu'une seule case d'arrivée est possible pour ce pion, le
|
||||
demi-coup est joué aussitôt, sans second toucher. S'il y en a plusieurs, la
|
||||
sélection actuelle reste.
|
||||
3. **Coup à valider, annulable** : quand tous les demi-coups sont joués (ou
|
||||
qu'aucun autre n'est possible), le coup n'est pas envoyé tout de suite. Le
|
||||
joueur le valide en touchant ses dés (ou un bouton « Valider »). Tant qu'il
|
||||
ne l'a pas validé, « Annuler » défait le dernier demi-coup, un par un. Le
|
||||
journal d'événements ne reçoit `MovePlayed` qu'à la validation.
|
||||
4. **Dés joués marqués** : chaque dé déjà utilisé par un demi-coup est
|
||||
visiblement estompé. Pour un double, quatre dés, marqués un par un.
|
||||
5. **Dés de l'adversaire touchables** : toucher la zone des dés de l'un ou
|
||||
l'autre côté du plateau lance les dés quand le joueur peut lancer (et valide
|
||||
le coup en attente de validation).
|
||||
6. **Confirmation du videau** : toucher le videau ou « Doubler » ouvre une
|
||||
confirmation courte (« Doubler à 2 ? L'ordinateur pourra prendre ou
|
||||
passer. » : Doubler / Annuler) avant d'envoyer le double.
|
||||
|
||||
Tests : scénarios Gherkin mis à jour ou ajoutés (validation du coup, annulation
|
||||
demi-coup par demi-coup, confirmation du videau), tests unitaires, et
|
||||
`tests/browser/play.mjs` adapté (Playwright est validé par Pierre). Lancer
|
||||
`make lint`, `make test` et `make test-browser`.
|
||||
|
||||
Rapporter : ce qui a été fait, les écarts, les résultats des trois commandes,
|
||||
et un brouillon de description de MR (7 sections, voir `docs/organisation.md`).
|
||||
Commits fréquents sur la branche du worktree ; ne pas pousser, ne pas ouvrir de
|
||||
MR : la session principale s'en charge.
|
||||
|
||||
## Critères de réussite
|
||||
|
||||
- `make lint`, `make test` et `make test-browser` passent.
|
||||
- Dans le navigateur : un pion à destination unique avance en un toucher ; un
|
||||
coup complet attend la validation ; « Annuler » défait un demi-coup à la
|
||||
fois ; les dés joués sont estompés ; le videau demande confirmation.
|
||||
- `https://…/moteur/` n'existe plus dans le site construit (`make site`).
|
||||
|
||||
## Résultat
|
||||
|
||||
À remplir à la clôture.
|
||||
@@ -5,8 +5,15 @@ joueur, écrit pour lui. Ces fichiers sont la seule source (ADR 0008) :
|
||||
l'application les met en forme comme pages d'aide, et ils sont exécutés comme
|
||||
tests d'intégration sur le domaine et le moteur réel.
|
||||
|
||||
Tant que le domaine n'existe pas, les scénarios se déroulent à la main : ils
|
||||
servent alors de guide de test.
|
||||
`make site` copie ce dossier dans le site publié (`docs/scenarios/`) ; l'aide
|
||||
de l'application (bouton « Aide ») lit ces copies à l'exécution
|
||||
(`app/src/ui/help.ts`). Les fichiers affichés dans l'aide sont ceux de la
|
||||
liste `FEATURES` de `help.ts`.
|
||||
|
||||
`make test` les exécute avec Cucumber : les étapes, définies dans
|
||||
`app/tests/steps/`, pilotent le domaine branché sur le vrai moteur
|
||||
WebAssembly, avec des dés imposés pour que chaque exécution soit identique. Une
|
||||
étape sans définition fait échouer les tests.
|
||||
|
||||
## Format
|
||||
|
||||
|
||||
@@ -14,11 +14,14 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
|
||||
Étant donné que c'est à vous de jouer avec le jet 3-1
|
||||
Quand vous jouez 8/5 6/5
|
||||
Alors votre coup est accepté
|
||||
Et c'est au tour de l'ordinateur
|
||||
Et c'est ensuite au tour de l'ordinateur
|
||||
|
||||
Scénario: Un coup interdit est refusé
|
||||
La case 12 est tenue par l'ordinateur, qui y a cinq pions : vous ne
|
||||
pouvez pas vous y poser.
|
||||
|
||||
Étant donné que c'est à vous de jouer avec le jet 3-1
|
||||
Quand vous essayez de jouer 8/4
|
||||
Quand vous essayez de jouer 13/12
|
||||
Alors votre coup est refusé
|
||||
Et la position n'a pas changé
|
||||
|
||||
@@ -27,6 +30,30 @@ Fonctionnalité: Jouer une partie contre l'ordinateur
|
||||
Quand ses dés sont tirés
|
||||
Alors il joue le coup recommandé par le moteur en moins de 2 secondes
|
||||
|
||||
Scénario: Aucun coup possible avec votre jet
|
||||
Il arrive que les dés ne permettent de bouger aucun pion. Votre jet reste
|
||||
affiché avec un message, et le tour ne passe à l'ordinateur qu'une fois
|
||||
que vous avez touché « Continuer ».
|
||||
|
||||
Étant donné que votre pion sur la barre ne peut pas rentrer
|
||||
Quand vous lancez les dés
|
||||
Alors aucun coup n'est possible avec votre jet
|
||||
Et c'est toujours à vous
|
||||
Quand vous continuez
|
||||
Alors c'est ensuite au tour de l'ordinateur
|
||||
|
||||
Scénario: Voir le coup de l'ordinateur
|
||||
Après chaque coup de l'ordinateur, ses pions glissent un par un sur le
|
||||
plateau. Restent ensuite, jusqu'à votre prochaine action, une flèche par
|
||||
pion déplacé, ses pions arrivés entourés et un pion fantôme là où ils
|
||||
étaient. Le bouton « Revoir » rejoue son coup.
|
||||
|
||||
Étant donné qu'un de vos pions est seul à portée de l'ordinateur
|
||||
Quand l'ordinateur a joué
|
||||
Alors son coup vous est montré case par case
|
||||
Et votre pion frappé part sur la barre
|
||||
Et vous pouvez revoir son coup
|
||||
|
||||
Scénario: Prendre le double de l'ordinateur
|
||||
Étant donné que l'ordinateur vous propose de doubler
|
||||
Quand vous prenez
|
||||
|
||||
+202
-4
@@ -13,6 +13,15 @@
|
||||
* legal POSITION_ID MATCH_ID DÉS coups légaux, sans évaluation
|
||||
* cube POSITION_ID MATCH_ID décision de videau
|
||||
* eval POSITION_ID MATCH_ID évaluation de la position
|
||||
* position POSITION_ID MATCH_ID plateau décodé, même position vue de
|
||||
* l'adversaire, fin de partie éventuelle
|
||||
* halfmoves POSITION_ID DÉS [DEMI-COUPS]
|
||||
* vérifie des demi-coups saisis un par
|
||||
* un (ex. « 8/5 6/5 », « bar/22 »,
|
||||
* « 6/off »)
|
||||
* matchid VIDEAU PROPRIÉTAIRE Match ID d'une partie libre avec la
|
||||
* règle Jacoby, joueur 0 au trait ;
|
||||
* PROPRIÉTAIRE : -1 (centre), 0 ou 1
|
||||
* reference POSITION_ID MATCH_ID [DÉS]
|
||||
* un niveau au format des positions de
|
||||
* référence (tests/reference/README.md) :
|
||||
@@ -45,6 +54,9 @@
|
||||
* float32 calculé par gnubg. */
|
||||
#define NUMBER "%.9g"
|
||||
|
||||
/* Liste des commandes, pour les messages d'erreur. */
|
||||
#define COMMANDS "bestmove, moves, legal, cube, eval, position, halfmoves, matchid ou reference"
|
||||
|
||||
/* Coups gardés dans le classement de la commande reference (comme hint). */
|
||||
#define REFERENCE_MAX_MOVES 10
|
||||
|
||||
@@ -113,10 +125,24 @@ print_probabilities(const float p[ENGINE_NUM_PROBABILITIES])
|
||||
p[ENGINE_LOSE_GAMMON], p[ENGINE_LOSE_BACKGAMMON]);
|
||||
}
|
||||
|
||||
/* Demi-coups sous la forme [[8, 5], [6, 5]]. */
|
||||
static void
|
||||
print_half_moves(const engine_half_move *half_moves, int count)
|
||||
{
|
||||
int i;
|
||||
|
||||
printf("[");
|
||||
for (i = 0; i < count; i++)
|
||||
printf("%s[%d, %d]", i ? ", " : "", half_moves[i].from, half_moves[i].to);
|
||||
printf("]");
|
||||
}
|
||||
|
||||
static void
|
||||
print_move(const engine_move *m, int with_evaluation)
|
||||
{
|
||||
printf("{\"move\": \"%s\", \"position_id\": \"%s\"", m->notation, m->position_id);
|
||||
printf("{\"move\": \"%s\", \"position_id\": \"%s\", \"half_moves\": ",
|
||||
m->notation, m->position_id);
|
||||
print_half_moves(m->half_moves, m->half_move_count);
|
||||
if (with_evaluation) {
|
||||
printf(", \"ply\": %d, \"equity\": " NUMBER ", \"probabilities\": ", m->ply, m->equity);
|
||||
print_probabilities(m->probabilities);
|
||||
@@ -254,11 +280,177 @@ run_position_command(const options *opt)
|
||||
print_probabilities(c.probabilities);
|
||||
printf(", ");
|
||||
print_cube_fields(&c);
|
||||
printf("}\n");
|
||||
printf(", \"available\": %s, \"double\": %s, \"take\": %s}\n",
|
||||
c.available ? "true" : "false", c.should_double ? "true" : "false",
|
||||
c.should_take ? "true" : "false");
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
static void
|
||||
print_side(const engine_side *side)
|
||||
{
|
||||
int i;
|
||||
|
||||
printf("{\"points\": [");
|
||||
for (i = 0; i < 24; i++)
|
||||
printf("%s%d", i ? ", " : "", side->points[i]);
|
||||
printf("], \"bar\": %d, \"off\": %d, \"pip_count\": %d}", side->bar, side->off,
|
||||
side->pip_count);
|
||||
}
|
||||
|
||||
/* position : plateau, même position vue de l'adversaire, fin de partie. */
|
||||
static int
|
||||
run_board_command(const options *opt)
|
||||
{
|
||||
static const char *const kinds[] = { "", "single", "gammon", "backgammon" };
|
||||
const char *position_id = opt->args[0], *match_id = opt->args[1];
|
||||
engine_board board;
|
||||
engine_result result;
|
||||
engine_status status;
|
||||
|
||||
if (opt->arg_count != 2)
|
||||
return usage_error("arguments attendus : POSITION_ID MATCH_ID");
|
||||
status = engine_decode_position(position_id, &board);
|
||||
if (status == ENGINE_OK)
|
||||
status = engine_game_result(position_id, match_id, &result);
|
||||
if (status != ENGINE_OK)
|
||||
return print_engine_error(status);
|
||||
|
||||
printf("{\"position_id\": \"%s\", \"match_id\": \"%s\", \"on_roll\": ", position_id,
|
||||
match_id);
|
||||
print_side(&board.on_roll);
|
||||
printf(", \"opponent\": ");
|
||||
print_side(&board.opponent);
|
||||
printf(", \"swapped_position_id\": \"%s\", \"result\": ", board.swapped_position_id);
|
||||
if (result.over)
|
||||
printf("{\"winner\": \"%s\", \"kind\": \"%s\", \"points\": %d}",
|
||||
result.winner == 0 ? "on_roll" : "opponent", kinds[result.kind], result.points);
|
||||
else
|
||||
printf("null");
|
||||
printf("}\n");
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
/* Lit une case d'un demi-coup : 1 à 25, « bar » (25) ou « off » (0). */
|
||||
static int
|
||||
parse_point(const char *text, size_t length, int *point)
|
||||
{
|
||||
char buffer[4];
|
||||
char *end;
|
||||
long value;
|
||||
|
||||
if (length == 0 || length >= sizeof buffer)
|
||||
return 0;
|
||||
memcpy(buffer, text, length);
|
||||
buffer[length] = '\0';
|
||||
if (strcmp(buffer, "bar") == 0) {
|
||||
*point = ENGINE_BAR;
|
||||
return 1;
|
||||
}
|
||||
if (strcmp(buffer, "off") == 0) {
|
||||
*point = ENGINE_OFF;
|
||||
return 1;
|
||||
}
|
||||
value = strtol(buffer, &end, 10);
|
||||
if (*end || value < 1 || value > ENGINE_BAR)
|
||||
return 0;
|
||||
*point = (int) value;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Lit des demi-coups séparés par des espaces, chacun « DÉPART/ARRIVÉE ».
|
||||
* Renvoie leur nombre, ou -1 si le texte est mal formé. */
|
||||
static int
|
||||
parse_half_moves(const char *text, engine_half_move half_moves[ENGINE_MAX_HALF_MOVES])
|
||||
{
|
||||
int count = 0;
|
||||
|
||||
while (*text) {
|
||||
const char *start, *slash;
|
||||
size_t length;
|
||||
|
||||
while (*text == ' ')
|
||||
text++;
|
||||
if (!*text)
|
||||
break;
|
||||
start = text;
|
||||
while (*text && *text != ' ')
|
||||
text++;
|
||||
length = (size_t) (text - start);
|
||||
slash = memchr(start, '/', length);
|
||||
if (!slash || count == ENGINE_MAX_HALF_MOVES
|
||||
|| !parse_point(start, (size_t) (slash - start), &half_moves[count].from)
|
||||
|| !parse_point(slash + 1, length - (size_t) (slash - start) - 1, &half_moves[count].to))
|
||||
return -1;
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* halfmoves : vérifie des demi-coups saisis un par un. */
|
||||
static int
|
||||
run_half_moves_command(const options *opt)
|
||||
{
|
||||
const char *position_id = opt->args[0];
|
||||
engine_half_move half_moves[ENGINE_MAX_HALF_MOVES];
|
||||
engine_half_moves_check check;
|
||||
engine_status status;
|
||||
int die1, die2, count = 0;
|
||||
|
||||
if (opt->arg_count != 2 && opt->arg_count != 3)
|
||||
return usage_error("arguments attendus : POSITION_ID DÉS [DEMI-COUPS]");
|
||||
if (!parse_dice(opt->args[1], &die1, &die2))
|
||||
return usage_error("dés attendus sous la forme 31");
|
||||
if (opt->arg_count == 3)
|
||||
count = parse_half_moves(opt->args[2], half_moves);
|
||||
if (count < 0)
|
||||
return usage_error("demi-coups attendus sous la forme 8/5 6/5, bar/22 ou 6/off");
|
||||
|
||||
status = engine_check_half_moves(position_id, die1, die2, half_moves, count, &check);
|
||||
if (status != ENGINE_OK)
|
||||
return print_engine_error(status);
|
||||
|
||||
printf("{\"position_id\": \"%s\", \"dice\": [%d, %d], \"half_moves\": ", position_id,
|
||||
die1, die2);
|
||||
print_half_moves(half_moves, count);
|
||||
printf(", \"valid\": %s, \"complete\": %s, \"result_position_id\": ",
|
||||
check.valid ? "true" : "false", check.complete ? "true" : "false");
|
||||
if (check.valid)
|
||||
printf("\"%s\"}\n", check.position_id);
|
||||
else
|
||||
printf("null}\n");
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
/* matchid : Match ID d'une partie libre avec la règle Jacoby, joueur 0 au
|
||||
* trait. */
|
||||
static int
|
||||
run_match_id_command(const options *opt)
|
||||
{
|
||||
engine_match match = { .cube_value = 1, .cube_owner = -1, .jacoby = 1 };
|
||||
char match_id[13];
|
||||
char *end;
|
||||
engine_status status;
|
||||
|
||||
if (opt->arg_count != 2)
|
||||
return usage_error("arguments attendus : VIDEAU PROPRIÉTAIRE");
|
||||
match.cube_value = (int) strtol(opt->args[0], &end, 10);
|
||||
if (*end || end == opt->args[0])
|
||||
return usage_error("VIDEAU attend un nombre");
|
||||
match.cube_owner = (int) strtol(opt->args[1], &end, 10);
|
||||
if (*end || end == opt->args[1])
|
||||
return usage_error("PROPRIÉTAIRE attend -1, 0 ou 1");
|
||||
|
||||
status = engine_encode_match(&match, match_id);
|
||||
if (status != ENGINE_OK)
|
||||
return print_engine_error(status);
|
||||
printf("{\"match_id\": \"%s\", \"match\": ", match_id);
|
||||
print_match(&match);
|
||||
printf("}\n");
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
* reference : un niveau d'un fichier de résultat de tests/reference/, de
|
||||
* même structure que plies["<n>"] (voir tests/reference/README.md).
|
||||
@@ -359,7 +551,7 @@ parse_options(int argc, char **argv, options *opt)
|
||||
}
|
||||
}
|
||||
if (!opt->command)
|
||||
return "commande attendue : bestmove, moves, legal, cube, eval ou reference";
|
||||
return "commande attendue : " COMMANDS;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -393,8 +585,14 @@ main(int argc, char **argv)
|
||||
result = run_position_command(&opt);
|
||||
else if (strcmp(opt.command, "reference") == 0)
|
||||
result = run_reference_command(&opt);
|
||||
else if (strcmp(opt.command, "position") == 0)
|
||||
result = run_board_command(&opt);
|
||||
else if (strcmp(opt.command, "halfmoves") == 0)
|
||||
result = run_half_moves_command(&opt);
|
||||
else if (strcmp(opt.command, "matchid") == 0)
|
||||
result = run_match_id_command(&opt);
|
||||
else
|
||||
result = usage_error("commande inconnue : bestmove, moves, legal, cube, eval ou reference");
|
||||
result = usage_error("commande inconnue : " COMMANDS);
|
||||
|
||||
#ifndef __EMSCRIPTEN__
|
||||
engine_shutdown();
|
||||
|
||||
@@ -10,7 +10,7 @@ import os from "node:os";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { gzipSync } from "node:zlib";
|
||||
import createEngineModule from "../build/wasm/engine.mjs";
|
||||
import { DOWNLOADED_FILES, formatReport, measureTimes } from "../web/benchmark.mjs";
|
||||
import { DOWNLOADED_FILES, formatReport, measureTimes } from "../web/moteur/benchmark.mjs";
|
||||
import { commands, loadEngine } from "../web/engine-wasm.mjs";
|
||||
|
||||
const root = new URL("../", import.meta.url);
|
||||
|
||||
+6
-2
@@ -33,14 +33,18 @@ ENGINE_INCLUDES := -I$(COMPAT) -I$(COMPAT)/glib-shim -I$(GNUBG) -I$(GNUBG)/lib -
|
||||
# - main n'est pas lancé au chargement, et le programme ne s'arrête pas à sa
|
||||
# sortie : le moteur reste chargé entre deux commandes ;
|
||||
# - mémoire extensible : les bases de fin de partie occupent plusieurs
|
||||
# mégaoctets.
|
||||
# mégaoctets ;
|
||||
# - stackSave et stackRestore : callMain laisse ses arguments sur la pile
|
||||
# (64 Ko) ; sans restauration après chaque commande, elle déborde au bout
|
||||
# de quelques centaines de commandes et corrompt la mémoire du moteur
|
||||
# (voir web/engine-wasm.mjs).
|
||||
LINK_FLAGS := -O3 \
|
||||
-sMODULARIZE -sEXPORT_ES6 -sEXPORT_NAME=createEngineModule \
|
||||
-sENVIRONMENT=web,worker,node \
|
||||
-sINVOKE_RUN=0 -sEXIT_RUNTIME=0 \
|
||||
-sALLOW_MEMORY_GROWTH \
|
||||
-sEXPORTED_FUNCTIONS=_main,_engine_init \
|
||||
-sEXPORTED_RUNTIME_METHODS=callMain,ccall,HEAPU8 \
|
||||
-sEXPORTED_RUNTIME_METHODS=callMain,ccall,HEAPU8,stackSave,stackRestore \
|
||||
--preload-file $(BUILD)/data@/data
|
||||
|
||||
DATA := $(BUILD)/data/gnubg.wd $(BUILD)/data/gnubg_os0.bd $(BUILD)/data/gnubg_ts0.bd \
|
||||
|
||||
+277
-4
@@ -182,6 +182,38 @@ engine_decode_match(const char *match_id, engine_match *match)
|
||||
return ENGINE_OK;
|
||||
}
|
||||
|
||||
/* Code un Match ID : voir engine.h. */
|
||||
engine_status
|
||||
engine_encode_match(const engine_match *match, char match_id[13])
|
||||
{
|
||||
const unsigned int no_dice[2] = { 0, 0 };
|
||||
int value = match->cube_value, log2 = 0;
|
||||
|
||||
while (value > 1 && value % 2 == 0) {
|
||||
value /= 2;
|
||||
log2++;
|
||||
}
|
||||
if (value != 1 || log2 > 12 || match->cube_owner < -1 || match->cube_owner > 1
|
||||
|| match->player_on_roll < 0 || match->player_on_roll > 1 || match->match_length < 0)
|
||||
return ENGINE_ERROR_MATCH_ID;
|
||||
snprintf(match_id, 13, "%s",
|
||||
MatchID(no_dice, match->player_on_roll, 0, 0, match->player_on_roll,
|
||||
match->cube_owner, match->crawford, match->match_length, match->score,
|
||||
match->cube_value, match->jacoby, GAME_PLAYING));
|
||||
return ENGINE_OK;
|
||||
}
|
||||
|
||||
/* Décode un Position ID en plateau de gnubg. */
|
||||
static engine_status
|
||||
decode_board(const char *position_id, TanBoard board)
|
||||
{
|
||||
if (engine_state != READY)
|
||||
return ENGINE_ERROR_NOT_INITIALISED;
|
||||
if (!is_base64_id(position_id, L_POSITIONID) || !PositionFromID(board, position_id))
|
||||
return ENGINE_ERROR_POSITION_ID;
|
||||
return ENGINE_OK;
|
||||
}
|
||||
|
||||
/* Décode Position ID et Match ID, et prépare le cubeinfo de gnubg. */
|
||||
static engine_status
|
||||
decode_position(const char *position_id, const char *match_id, position *pos)
|
||||
@@ -189,10 +221,9 @@ decode_position(const char *position_id, const char *match_id, position *pos)
|
||||
engine_match *m = &pos->match;
|
||||
engine_status status;
|
||||
|
||||
if (engine_state != READY)
|
||||
return ENGINE_ERROR_NOT_INITIALISED;
|
||||
if (!is_base64_id(position_id, L_POSITIONID) || !PositionFromID(pos->board, position_id))
|
||||
return ENGINE_ERROR_POSITION_ID;
|
||||
status = decode_board(position_id, pos->board);
|
||||
if (status != ENGINE_OK)
|
||||
return status;
|
||||
status = engine_decode_match(match_id, m);
|
||||
if (status != ENGINE_OK)
|
||||
return status;
|
||||
@@ -237,6 +268,13 @@ fill_move(engine_move *out, const move *m, const position *pos, int evaluated)
|
||||
|
||||
FormatMove(out->notation, (ConstTanBoard) pos->board, m->anMove);
|
||||
snprintf(out->position_id, sizeof out->position_id, "%s", PositionIDFromKey(&m->key));
|
||||
/* gnubg numérote les cases de 0 à 23, la barre 24 et la sortie -1. */
|
||||
out->half_move_count = 0;
|
||||
for (i = 0; i < 2 * ENGINE_MAX_HALF_MOVES && m->anMove[i] >= 0; i += 2) {
|
||||
out->half_moves[i / 2].from = m->anMove[i] + 1;
|
||||
out->half_moves[i / 2].to = m->anMove[i + 1] + 1;
|
||||
out->half_move_count++;
|
||||
}
|
||||
out->ply = evaluated ? (int) m->esMove.ec.nPlies : -1;
|
||||
for (i = 0; i < ENGINE_NUM_PROBABILITIES; i++)
|
||||
out->probabilities[i] = evaluated ? m->arEvalMove[i] : 0.0f;
|
||||
@@ -381,5 +419,240 @@ engine_cube_decision(const char *position_id, const char *match_id, int ply, eng
|
||||
cube->optimal = equities[OUTPUT_OPTIMAL];
|
||||
cube->decision = cube_decision_names[decision];
|
||||
cube->decision_text = GetCubeRecommendation(decision);
|
||||
GetDPEq(&cube->available, NULL, &pos.cube);
|
||||
cube->should_double = decision == DOUBLE_TAKE || decision == DOUBLE_PASS
|
||||
|| decision == DOUBLE_BEAVER || decision == REDOUBLE_TAKE || decision == REDOUBLE_PASS;
|
||||
cube->should_take = cube->double_take <= cube->double_pass;
|
||||
return ENGINE_OK;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------- Plateau et fin de partie */
|
||||
|
||||
static void
|
||||
fill_side(engine_side *side, const unsigned int checkers[25])
|
||||
{
|
||||
int i, on_board = 0;
|
||||
|
||||
side->pip_count = 0;
|
||||
for (i = 0; i < 25; i++) {
|
||||
on_board += (int) checkers[i];
|
||||
side->pip_count += (int) checkers[i] * (i + 1);
|
||||
}
|
||||
for (i = 0; i < 24; i++)
|
||||
side->points[i] = (int) checkers[i];
|
||||
side->bar = (int) checkers[24];
|
||||
side->off = anChequers[VARIATION_STANDARD] - on_board;
|
||||
}
|
||||
|
||||
engine_status
|
||||
engine_decode_position(const char *position_id, engine_board *board)
|
||||
{
|
||||
TanBoard b;
|
||||
engine_status status = decode_board(position_id, b);
|
||||
|
||||
if (status != ENGINE_OK)
|
||||
return status;
|
||||
/* Dans gnubg, b[1] est le joueur au trait et b[0] son adversaire. */
|
||||
fill_side(&board->on_roll, b[1]);
|
||||
fill_side(&board->opponent, b[0]);
|
||||
SwapSides(b);
|
||||
snprintf(board->swapped_position_id, sizeof board->swapped_position_id, "%s", PositionID((ConstTanBoard) b));
|
||||
return ENGINE_OK;
|
||||
}
|
||||
|
||||
engine_status
|
||||
engine_game_result(const char *position_id, const char *match_id, engine_result *result)
|
||||
{
|
||||
TanBoard b;
|
||||
engine_match match;
|
||||
engine_status status = decode_board(position_id, b);
|
||||
int i;
|
||||
|
||||
if (status == ENGINE_OK)
|
||||
status = engine_decode_match(match_id, &match);
|
||||
if (status != ENGINE_OK)
|
||||
return status;
|
||||
|
||||
memset(result, 0, sizeof *result);
|
||||
result->kind = GameStatus((ConstTanBoard) b, VARIATION_STANDARD);
|
||||
if (result->kind == 0)
|
||||
return ENGINE_OK;
|
||||
result->over = 1;
|
||||
/* Le gagnant est celui qui n'a plus aucun pion sur le plateau. */
|
||||
for (i = 0; i < 25 && b[1][i] == 0; i++)
|
||||
;
|
||||
result->winner = i == 25 ? 0 : 1;
|
||||
/* Règle Jacoby : gammons et backgammons ne comptent qu'une fois le
|
||||
* videau tourné, c'est-à-dire quand il n'est plus au centre. */
|
||||
if (match.match_length == 0 && match.jacoby && match.cube_owner == -1)
|
||||
result->points = match.cube_value;
|
||||
else
|
||||
result->points = result->kind * match.cube_value;
|
||||
return ENGINE_OK;
|
||||
}
|
||||
|
||||
/* ------------------------------------------ Saisie demi-coup par demi-coup */
|
||||
|
||||
/*
|
||||
* La légalité de chaque demi-coup vient de gnubg : GenerateMoves avec un seul
|
||||
* dé (le second à 0) donne exactement les demi-coups permis avec ce dé (barre
|
||||
* d'abord, case libre, règles de sortie). Celle du coup entier aussi : les
|
||||
* demi-coups doivent pouvoir se compléter en une position de la liste des
|
||||
* coups légaux, qui impose de jouer le plus de dés possible.
|
||||
*/
|
||||
|
||||
/* Un demi-coup permis et la position où il mène. */
|
||||
typedef struct {
|
||||
int from, to; /* numérotation de gnubg : 0 à 24, -1 sortie */
|
||||
positionkey key;
|
||||
} step;
|
||||
|
||||
/* Positions d'arrivée des coups légaux. */
|
||||
typedef struct {
|
||||
positionkey *keys;
|
||||
int count;
|
||||
} legal_results;
|
||||
|
||||
/* Les demi-coups permis avec un dé. Ils sont copiés : GenerateMoves réutilise
|
||||
* un tableau interne, que l'appel suivant écraserait. Il y en a au plus un
|
||||
* par case de départ. */
|
||||
static int
|
||||
single_steps(ConstTanBoard board, int die, step steps[25])
|
||||
{
|
||||
movelist list;
|
||||
unsigned int i;
|
||||
|
||||
GenerateMoves(&list, board, die, 0, FALSE);
|
||||
for (i = 0; i < list.cMoves && i < 25; i++) {
|
||||
steps[i].from = list.amMoves[i].anMove[0];
|
||||
steps[i].to = list.amMoves[i].anMove[1];
|
||||
steps[i].key = list.amMoves[i].key;
|
||||
}
|
||||
return (int) i;
|
||||
}
|
||||
|
||||
static int
|
||||
is_legal_result(ConstTanBoard board, const legal_results *legal)
|
||||
{
|
||||
positionkey key;
|
||||
int i;
|
||||
|
||||
PositionKey(board, &key);
|
||||
for (i = 0; i < legal->count; i++)
|
||||
if (EqualKeys(key, legal->keys[i]))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Les dés sans celui d'indice skip. */
|
||||
static void
|
||||
remove_die(const int dice[], int count, int skip, int rest[])
|
||||
{
|
||||
int i, j = 0;
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
if (i != skip)
|
||||
rest[j++] = dice[i];
|
||||
}
|
||||
|
||||
/* Vrai si board peut encore mener à un coup légal avec les dés restants. */
|
||||
static int
|
||||
can_complete(ConstTanBoard board, const int dice[], int count, const legal_results *legal)
|
||||
{
|
||||
step steps[25];
|
||||
int rest[ENGINE_MAX_HALF_MOVES];
|
||||
TanBoard next;
|
||||
int i, j, n;
|
||||
|
||||
if (is_legal_result(board, legal))
|
||||
return 1;
|
||||
for (i = 0; i < count; i++) {
|
||||
if (i > 0 && dice[i] == dice[0])
|
||||
continue; /* même valeur déjà essayée (double) */
|
||||
remove_die(dice, count, i, rest);
|
||||
n = single_steps(board, dice[i], steps);
|
||||
for (j = 0; j < n; j++) {
|
||||
PositionFromKey(next, &steps[j].key);
|
||||
if (can_complete((ConstTanBoard) next, rest, count - 1, legal))
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Joue les demi-coups ; en cas de succès, result reçoit la position atteinte.
|
||||
* Un même demi-coup peut correspondre à plusieurs dés (une sortie avec un dé
|
||||
* plus fort que nécessaire) : chacun est essayé. */
|
||||
static int
|
||||
play_half_moves(ConstTanBoard board, const int dice[], int count,
|
||||
const engine_half_move *half_moves, int remaining,
|
||||
const legal_results *legal, TanBoard result)
|
||||
{
|
||||
step steps[25];
|
||||
int rest[ENGINE_MAX_HALF_MOVES];
|
||||
TanBoard next;
|
||||
int i, j, n;
|
||||
|
||||
if (remaining == 0) {
|
||||
if (!can_complete(board, dice, count, legal))
|
||||
return 0;
|
||||
memcpy(result, board, sizeof(TanBoard));
|
||||
return 1;
|
||||
}
|
||||
for (i = 0; i < count; i++) {
|
||||
if (i > 0 && dice[i] == dice[0])
|
||||
continue; /* même valeur déjà essayée (double) */
|
||||
remove_die(dice, count, i, rest);
|
||||
n = single_steps(board, dice[i], steps);
|
||||
for (j = 0; j < n; j++) {
|
||||
if (steps[j].from != half_moves->from - 1 || steps[j].to != half_moves->to - 1)
|
||||
continue;
|
||||
PositionFromKey(next, &steps[j].key);
|
||||
if (play_half_moves((ConstTanBoard) next, rest, count - 1, half_moves + 1,
|
||||
remaining - 1, legal, result))
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
engine_status
|
||||
engine_check_half_moves(const char *position_id, int die1, int die2,
|
||||
const engine_half_move *half_moves, int count,
|
||||
engine_half_moves_check *check)
|
||||
{
|
||||
TanBoard board, result;
|
||||
movelist list;
|
||||
legal_results legal;
|
||||
int dice[ENGINE_MAX_HALF_MOVES] = { die1, die2, die1, die2 };
|
||||
int dice_count = die1 == die2 ? 4 : 2;
|
||||
engine_status status;
|
||||
unsigned int i;
|
||||
|
||||
status = decode_board(position_id, board);
|
||||
if (status == ENGINE_OK)
|
||||
status = check_dice(die1, die2);
|
||||
if (status != ENGINE_OK)
|
||||
return status;
|
||||
|
||||
memset(check, 0, sizeof *check);
|
||||
if (count < 0 || count > dice_count)
|
||||
return ENGINE_OK;
|
||||
|
||||
GenerateMoves(&list, (ConstTanBoard) board, die1, die2, FALSE);
|
||||
if (list.cMoves == 0)
|
||||
return ENGINE_OK; /* aucun coup possible : rien à saisir */
|
||||
legal.count = (int) list.cMoves;
|
||||
legal.keys = g_malloc(sizeof *legal.keys * list.cMoves);
|
||||
for (i = 0; i < list.cMoves; i++)
|
||||
legal.keys[i] = list.amMoves[i].key;
|
||||
|
||||
if (play_half_moves((ConstTanBoard) board, dice, dice_count, half_moves, count, &legal, result)) {
|
||||
check->valid = 1;
|
||||
check->complete = is_legal_result((ConstTanBoard) result, &legal);
|
||||
snprintf(check->position_id, sizeof check->position_id, "%s",
|
||||
PositionID((ConstTanBoard) result));
|
||||
}
|
||||
g_free(legal.keys);
|
||||
return ENGINE_OK;
|
||||
}
|
||||
|
||||
@@ -66,11 +66,29 @@ enum {
|
||||
ENGINE_NUM_PROBABILITIES
|
||||
};
|
||||
|
||||
/*
|
||||
* Demi-coup : un pion déplacé d'une case avec un seul dé. Les cases sont
|
||||
* numérotées du point de vue du joueur qui joue, comme dans la notation de
|
||||
* gnubg : 1 à 24, 25 pour la barre, 0 pour la sortie.
|
||||
*/
|
||||
#define ENGINE_BAR 25
|
||||
#define ENGINE_OFF 0
|
||||
|
||||
typedef struct {
|
||||
int from;
|
||||
int to;
|
||||
} engine_half_move;
|
||||
|
||||
/* Un coup complet utilise au plus quatre dés (un double). */
|
||||
#define ENGINE_MAX_HALF_MOVES 4
|
||||
|
||||
/* Un coup, avec son évaluation quand il a été classé. */
|
||||
typedef struct {
|
||||
char notation[32]; /* notation de gnubg, ex. « 8/5 6/5 » */
|
||||
char position_id[16]; /* Position ID après le coup, plateau vu du
|
||||
* joueur qui vient de jouer */
|
||||
engine_half_move half_moves[ENGINE_MAX_HALF_MOVES];
|
||||
int half_move_count; /* demi-coups du coup, dans un ordre jouable */
|
||||
int ply; /* niveau de l'évaluation (-1 : non évalué) */
|
||||
float probabilities[ENGINE_NUM_PROBABILITIES];
|
||||
float equity; /* équité de classement (avec videau) */
|
||||
@@ -96,8 +114,50 @@ typedef struct {
|
||||
* « DOUBLE_TAKE », « DOUBLE_PASS »,
|
||||
* « TOOGOOD_PASS », « NOT_AVAILABLE »… */
|
||||
const char *decision_text; /* libellé anglais de gnubg, ex. « Double, take » */
|
||||
int available; /* le joueur au trait a le droit de doubler */
|
||||
int should_double; /* gnubg recommande de doubler : décision
|
||||
* DOUBLE_TAKE, DOUBLE_PASS, DOUBLE_BEAVER,
|
||||
* REDOUBLE_TAKE ou REDOUBLE_PASS (un double
|
||||
* « facultatif » n'est pas recommandé) */
|
||||
int should_take; /* s'il double, l'adversaire doit prendre :
|
||||
* prendre lui coûte moins que passer
|
||||
* (double_take <= double_pass) */
|
||||
} engine_cube;
|
||||
|
||||
/* Un camp sur le plateau, vu de lui-même (sa case 1 est la plus proche de
|
||||
* la sortie). */
|
||||
typedef struct {
|
||||
int points[24]; /* pions sur les cases 1 à 24 (indices 0 à 23) */
|
||||
int bar; /* pions sur la barre */
|
||||
int off; /* pions sortis */
|
||||
int pip_count; /* compte de points */
|
||||
} engine_side;
|
||||
|
||||
/* Plateau décodé d'un Position ID. */
|
||||
typedef struct {
|
||||
engine_side on_roll; /* le joueur au trait */
|
||||
engine_side opponent; /* son adversaire */
|
||||
char swapped_position_id[16]; /* la même position vue de l'adversaire */
|
||||
} engine_board;
|
||||
|
||||
/* Fin de partie. */
|
||||
typedef struct {
|
||||
int over; /* la partie est finie */
|
||||
int winner; /* 0 : le joueur au trait, 1 : son adversaire */
|
||||
int kind; /* 1 : simple, 2 : gammon, 3 : backgammon */
|
||||
int points; /* points gagnés : kind fois la valeur du videau,
|
||||
* mais 1 fois en partie libre avec la règle
|
||||
* Jacoby quand le videau n'a pas bougé */
|
||||
} engine_result;
|
||||
|
||||
/* Où en est un coup saisi demi-coup par demi-coup. */
|
||||
typedef struct {
|
||||
int valid; /* les demi-coups commencent un coup légal */
|
||||
int complete; /* ils forment à eux seuls un coup légal */
|
||||
char position_id[16]; /* si valid : position après ces demi-coups, vue
|
||||
* du joueur qui joue ; sinon chaîne vide */
|
||||
} engine_half_moves_check;
|
||||
|
||||
/* Description lisible d'un Match ID décodé. */
|
||||
typedef struct {
|
||||
int match_length; /* 0 : partie libre (money game) */
|
||||
@@ -125,6 +185,30 @@ const char *engine_status_message(engine_status status);
|
||||
/* Décode un Match ID. */
|
||||
engine_status engine_decode_match(const char *match_id, engine_match *match);
|
||||
|
||||
/*
|
||||
* Code un Match ID (12 caractères et le zéro final), sans dés ni double en
|
||||
* cours. cube_value : puissance de 2 de 1 à 4096 ; cube_owner : -1, 0 ou 1.
|
||||
*/
|
||||
engine_status engine_encode_match(const engine_match *match, char match_id[13]);
|
||||
|
||||
/* Décode un Position ID en plateau. */
|
||||
engine_status engine_decode_position(const char *position_id, engine_board *board);
|
||||
|
||||
/* La partie est-elle finie dans cette position, et combien rapporte-t-elle ? */
|
||||
engine_status engine_game_result(const char *position_id, const char *match_id,
|
||||
engine_result *result);
|
||||
|
||||
/*
|
||||
* Vérifie des demi-coups saisis un par un (count de 0 à
|
||||
* ENGINE_MAX_HALF_MOVES), avec le jet die1, die2 : chacun doit être permis
|
||||
* par les règles, et l'ensemble doit pouvoir se compléter en un des coups
|
||||
* légaux d'engine_legal_moves. Des demi-coups refusés ne sont pas une erreur :
|
||||
* check->valid vaut alors 0.
|
||||
*/
|
||||
engine_status engine_check_half_moves(const char *position_id, int die1, int die2,
|
||||
const engine_half_move *half_moves, int count,
|
||||
engine_half_moves_check *check);
|
||||
|
||||
/*
|
||||
* Coups légaux pour une position et un jet (die1, die2 dans 1..6), sans
|
||||
* évaluation (ply vaut -1). moves doit pouvoir contenir max_moves coups ;
|
||||
|
||||
Executable
+40
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env bash
|
||||
# Complète le service worker d'un site assemblé (make site) : en tête de
|
||||
# <site>/sw.js (copie de web/sw.js), écrit la liste de tous les fichiers du
|
||||
# site, à mettre en cache pour le hors ligne, et la version du site, une
|
||||
# empreinte de leur contenu.
|
||||
#
|
||||
# Le navigateur compare sw.js octet par octet à chaque visite : le moindre
|
||||
# fichier modifié change l'empreinte, donc sw.js, ce qui déclenche la mise à
|
||||
# jour du cache. Un site identique garde le même sw.js : rien à
|
||||
# retélécharger.
|
||||
#
|
||||
# Usage : scripts/service-worker.sh build/site
|
||||
|
||||
set -euo pipefail
|
||||
|
||||
site="${1:?usage : scripts/service-worker.sh <dossier du site>}"
|
||||
cd "$site"
|
||||
[ -f sw.js ] || { echo "$site/sw.js absent" >&2; exit 1; }
|
||||
|
||||
# Tous les fichiers sauf sw.js, triés pour que l'empreinte soit stable.
|
||||
mapfile -t files < <(find . -type f ! -path ./sw.js | sed 's|^\./||' | LC_ALL=C sort)
|
||||
version="$(sha256sum "${files[@]}" | sha256sum | cut -c1-16)"
|
||||
|
||||
{
|
||||
echo "// Généré par scripts/service-worker.sh (make site) : ne pas modifier."
|
||||
echo "const VERSION = \"$version\";"
|
||||
echo "const FILES = ["
|
||||
for f in "${files[@]}"; do
|
||||
# Une page index.html est aussi demandée sous le nom de son dossier.
|
||||
case "$f" in
|
||||
index.html) echo ' "./",' ;;
|
||||
*/index.html) echo " \"${f%index.html}\"," ;;
|
||||
esac
|
||||
echo " \"$f\","
|
||||
done
|
||||
echo "];"
|
||||
echo
|
||||
cat sw.js
|
||||
} >sw.js.tmp
|
||||
mv sw.js.tmp sw.js
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user