From 54079accb5b22ae78c7f5d627ec4b2f7aeb5da53 Mon Sep 17 00:00:00 2001 From: SinuS Von SifriduS Date: Sun, 20 Sep 2026 06:15:50 +0200 Subject: [PATCH] 0.3.0-0-pre.1 --- Cargo.toml | 4 +- README.md | 6 +- ROADMAP.md | 30 +- deltas/0.3.0/0-pre.1.md | 157 ++++++++ docs/rules/RULES_COMMANDS.md | 8 +- docs/studies/000-README.md | 6 +- docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md | 354 ++++++++++++++++++ scripts/audit_project_workspace_rules.py | 14 +- scripts/audit_rust_workspace_rules.py | 8 +- 9 files changed, 567 insertions(+), 20 deletions(-) create mode 100644 deltas/0.3.0/0-pre.1.md create mode 100644 docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md diff --git a/Cargo.toml b/Cargo.toml index e69e305..2ebbb41 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ # file: Cargo.toml -# version: 57 +# version: 58 [workspace] resolver = "3" @@ -19,7 +19,7 @@ members = [ ] [workspace.package] -version = "0.2.0" +version = "0.3.0-0-pre.1" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/games" diff --git a/README.md b/README.md index 895b5d7..010c1ee 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ - + # games.sasedev @@ -23,9 +23,9 @@ Workspace expérimental puis productif pour des jeux multiplateformes principale ## Baseline -Version stable de référence : `0.1.0`. +Version stable de référence : `0.2.0`. -Version candidate en cours de conception : `0.2.0`. +Version de développement : `0.3.0-0-pre.1`. Les deux premiers jeux sont des POC structurels : `game-reflex-poc` et `game-snake-poc`. Ils existent d'abord pour valider les frontières du workspace, le moteur, les assets et le packaging multiplateforme. diff --git a/ROADMAP.md b/ROADMAP.md index 709293f..51d320a 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1,5 +1,5 @@ - + # Roadmap @@ -26,11 +26,31 @@ Le détail historique des prereleases `0.1.0-*` reste dans `deltas/0.1.0/` et `h - (x) `0.2.0` — fixer la gouvernance documentaire, la nomenclature et le cycle de maturation des idées et décisions. - (x) `0.2.0` — inventorier et réserver les capabilities déjà justifiées sans les implémenter prématurément. -- ( ) `0.2.0` — définir les couches, les dépendances autorisées et la frontière entre kernel, capability, plateforme, provider, système de jeu et service. -- ( ) `0.2.0` — établir la matrice plateformes et les archétypes de jeux utilisés pour challenger l'architecture. -- ( ) `0.2.0` — définir le modèle de composition statique, le manifest produit/jeu et l'architecture cible des crates. -- ( ) `0.2.0` — définir la trajectoire d'implémentation progressive des versions suivantes seulement après revue de la conception. +- (x) `0.2.0` — définir les couches, les dépendances autorisées et la frontière entre kernel, capability, plateforme, provider, système de jeu et service. +- (x) `0.2.0` — établir la matrice plateformes et les archétypes de jeux utilisés pour challenger l'architecture. +- (x) `0.2.0` — retenir la composition Rust statique comme direction de référence. +- (d) `0.2.0` — figer un manifest produit/jeu et l'architecture physique définitive des crates → target TBD après observation des POC `0.3.x`. +- (x) `0.2.0` — définir la trajectoire d'implémentation progressive `0.3.x` POC puis `0.4.x` Uroburas. - (x) `0.2.0` — consolider les études acceptées en architecture/règles durables, notamment ownership, réseau, Uroburas et POC, puis fermer les points encore candidats. - (x) `0.2.0` — formaliser la stratégie réseau : Actix Web pour le Web/API, asset delivery auto-hébergé H2/H3, WebSocket baseline et WebTransport/QUIC candidat. - (x) `0.2.0` — préparer une trajectoire `0.3.x` dédiée aux POC plateforme/réseau avec Snake comme jeu-sonde. - (x) `0.2.0` — préparer la trajectoire `0.4.x` Uroburas Mode 1 et le prompt de session associé après gel de la conception. + +## 0.3.0 — Baseline Snake + premier POC Web direct + +- ( ) `0.3.0` — nettoyer la baseline Snake sans introduire de logique Uroburas et maintenir le runner Desktop SDL3 fonctionnel. +- ( ) `0.3.0` — produire une adaptation WASM dédiée à Snake sans déplacer le gameplay hors de `game-snake-poc`. +- ( ) `0.3.0` — réaliser un POC navigateur direct Snake couvrant clavier, boutons directionnels tactiles, resize, lifecycle, logging, assets et provenance runtime. +- ( ) `0.3.0` — utiliser uniquement Cargo, `wasm-bindgen` et Vite/npm pour le chemin de build Web ; aucun script Python ne pilote ce build. +- ( ) `0.3.0` — documenter les duplications observées, les extractions réellement justifiées et les reports avant promotion RC. + +## Série 0.3.x — trajectoire actuelle après 0.3.0 + +- ( ) `0.3.1` — second host Snake : Tauri Android, en réutilisant la baseline Web/WASM validée et en remplaçant toute orchestration Python du chemin touché. +- ( ) `0.3.2` — Tauri Desktop + Snake et factorisation WebView uniquement lorsque deux consommateurs réels justifient l'extraction. +- ( ) `0.3.3` — Android SDL natif multi-ABI avec Cargo/Gradle natifs, sans script Python de build. +- ( ) `0.3.4` — API de transport realtime + WebSocket/tokio-tungstenite baseline, sans serveur Uroburas Mode 3. +- ( ) `0.3.5` — POC WebTransport/QUIC sur le même protocole, avec comparaison mesurée et fallback WebSocket. +- ( ) `0.3.6` — consolidation des POC plateforme/réseau et préparation de la baseline `0.4.x`. + +La numérotation `0.3.1+` reste révisable à partir des résultats réels ; les lignes ci-dessus décrivent le planning actuel, pas une obligation de créer des versions artificielles. diff --git a/deltas/0.3.0/0-pre.1.md b/deltas/0.3.0/0-pre.1.md new file mode 100644 index 0000000..e3f639f --- /dev/null +++ b/deltas/0.3.0/0-pre.1.md @@ -0,0 +1,157 @@ + + + +# Delta 0.3.0-0-pre.1 + +## Base + +Base déclarée : `0.2.0`. + +L'archive de base a été inspectée avant modification. Sa version workspace est `0.2.0`. L'archive ne contient pas `.git`, donc le tag réel et la propreté Git ne peuvent pas être vérifiés dans l'environnement de génération. + +## Objet + +Ouvrir `0.3.0` par le cadrage obligatoire : audit réel de la baseline, revue des règles, requirements Snake, graphe de dépendances, choix du premier POC, sizing corrigé et préparation des validations. + +Aucun gameplay, runtime SDL, Java/JNI, Tauri ou frontend existant n'est modifié dans cette tranche. + +## Version + +La version workspace passe de : + +```text +0.2.0 +``` + +à : + +```text +0.3.0-0-pre.1 +``` + +Les métadonnées Android restent à `0.2.0` dans cette tranche, car le chemin Android natif n'est ni modifié ni construit par le premier POC Web. Elles seront réévaluées dans la version qui réouvre effectivement ce produit Android. + +## Audit de baseline + +Les audits statiques officiels ont été exécutés avant modification et étaient propres : + +```text +General Rust rule audit: clean +Rust export completeness audit: 0 candidate(s) +games.sasedev workspace audit: clean +Markdown table audit: clean (4 table(s), 158 file(s)) +Distribution layout audit: clean (19 required path(s), 1 forbidden path(s) absent) +``` + +La revue manuelle a néanmoins détecté : + +- README encore positionné sur `0.1.0` stable / `0.2.0` candidate ; +- quatre lignes `( )` sous la stable `0.2.0` dans ROADMAP, en violation de `DOC-RMAP-010` ; +- la gate `audit_rust_workspace_rules.py` qui créait un cache Python `.pyc` pendant son exécution, alors qu’un audit doit rester en lecture seule ; +- `CMD-RC-001` encore spécifique à `0.1.0` ; +- contradiction entre `CMD-BUILD-002` (interdiction globale) et `CMD-BUILD-004` (remplacement progressif en `0.3.x`), alors que deux orchestrateurs Python historiques existent encore ; +- `CMD-WEB-003` décrivant sans contexte le build Python Tauri/WASM historique ; +- dépendances `engine-v1-platform-api` déclarées mais non utilisées par les crates de jeu ; +- `RuntimeProvenance` défini mais non branché aux launchers ; +- `game-assets-lib` encore sans consommateur runtime ; +- deux orchestrateurs Python de build historiques à ne pas réutiliser dans les nouveaux POC. + +Les détails et le graphe complet sont documentés dans `docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md`. + +## Corrections de règles et hygiène + +Cette tranche : + +- corrige le README de version ; +- ferme correctement le scope `0.2.0` dans ROADMAP ; +- distingue ce qui a été livré de ce qui est reporté ; +- rend `CMD-RC-001` générique à la version courante ; +- rend `CMD-BUILD-002` cohérente avec la migration `0.3.x` : les deux orchestrateurs Python historiques sont gelés jusqu’à réactivation de leur chemin, mais aucun nouveau chemin ne peut les reprendre ; +- qualifie explicitement `scripts/build_reflex_tauri_wasm.py` de mécanisme historique non réutilisable comme orchestration `0.3.x` ; +- renforce `audit_project_workspace_rules.py` pour détecter le scope `( )` restant sous une version stable présente dans CHANGELOG ; +- fait exécuter les sous-audits de `audit_rust_workspace_rules.py` avec l’interpréteur courant et `-B`, afin que la gate standard reste effectivement en lecture seule malgré l’import effectué dans l’audit de complétude des exports. + +## Premier POC retenu + +Le premier host de `0.3.0` devient : + +```text +Web navigateur direct + Snake +``` + +Tauri Android est reporté au second host, actuellement prévu en `0.3.1`. + +Le but est de valider d'abord la frontière Web/WASM et les capabilities directement observables sans cumuler simultanément la généralisation Snake/WASM et la complexité d'un host mobile Tauri. + +## Forecast corrigé + +```text +0-pre.1 audit / règles / requirements / sizing +0-pre.2 Snake portability baseline +0-pre.3 adapter Snake WASM + build natif Web +0-pre.4 navigateur direct end-to-end +0-pre.5 seulement si un défaut réel est observé +2-beta.1 validation large +3-rc.1 candidate gelée +0.3.0 release mécanique +``` + +Aucune alpha n'est créée par cérémonial. Elle reste possible si le volume réel de stabilisation le justifie. + +## Scope exclu de 0.3.0 + +- Tauri Android ; +- Tauri Desktop Snake ; +- Android multi-ABI natif ; +- réseau realtime ; +- WebTransport/QUIC ; +- Uroburas ; +- ads, billing, auth et leaderboard ; +- ECS ou nouveau moteur. + +## Suppressions + +Aucune suppression de fichier appartenant à la baseline `0.2.0` n'est nécessaire. + +## Validations exécutées dans l'environnement de génération + +Après constitution de l'état livré, les audits statiques suivants doivent être réexécutés et leur résultat est enregistré avant packaging : + +```bash +python3 scripts/audit_rust_workspace_rules.py +python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history +python3 scripts/audit_distribution_layout.py +``` + +Aucun build/test/smoke n'est exécuté par le générateur, conformément à `CMD-GEN-007` et `CMD-BUILD-005`. + +## Validation utilisateur demandée + +Cette tranche ne modifie aucun source Rust/Java/TypeScript ni aucune configuration runtime. Elle ouvre toutefois une nouvelle version `0.3.0` et modifie le manifest workspace ; la gate utilisateur retient donc les audits statiques puis une gate Cargo workspace complète, conformément à la discipline des frontières de version : + +```bash +python3 scripts/audit_rust_workspace_rules.py +python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history +python3 scripts/audit_distribution_layout.py + +cargo fmt --all -- --check +cargo check --workspace +cargo clippy --workspace --all-targets --all-features -- -D warnings +cargo test --workspace --all-targets --all-features +``` + +Aucun build de distribution, smoke Desktop, Tauri ou Android n'est requis par `pre.1`, car aucun runtime ni packaging de ces hosts n'est modifié. + +La revue humaine doit confirmer : + +- le choix Web direct comme premier POC ; +- le scope corrigé de `0.3.0` ; +- le report de Tauri Android vers le second host ; +- le sizing `pre.2` à `pre.4` ; +- la fermeture correcte des lignes historiques `0.2.0`. + +## Suite après validation + +Si cette gate est propre et le cadrage accepté, passer automatiquement à `0.3.0-0-pre.2`. + +`pre.2` doit rester une tranche bornée de portabilité Snake et de nettoyage de dépendances ; elle ne doit pas commencer le frontend Web complet. diff --git a/docs/rules/RULES_COMMANDS.md b/docs/rules/RULES_COMMANDS.md index 2c8f7d3..e22a4e4 100644 --- a/docs/rules/RULES_COMMANDS.md +++ b/docs/rules/RULES_COMMANDS.md @@ -1,5 +1,5 @@ - + # Règles d'exécution des commandes @@ -56,7 +56,7 @@ - **CMD-WEB-001** — Aucun gestionnaire de paquets JavaScript ni build Web n'est exécuté tant qu'un frontend Web réel n'a pas été introduit dans le dépôt. - **CMD-WEB-002** — Lorsqu'une cible Web existe, ses commandes de build et test sont documentées avant d'être ajoutées aux gates. -- **CMD-WEB-003** — Le POC Tauri/WASM utilise `scripts/build_reflex_tauri_wasm.py` pour WASM et Vite/TypeScript pour le frontend local ; aucun site distant n'est requis. +- **CMD-WEB-003** — Le POC Tauri/WASM historique `0.1.0` utilise `scripts/build_reflex_tauri_wasm.py` ; ce script reste une référence de baseline mais ne doit pas être réutilisé comme orchestrateur par un POC `0.3.x`, conformément à `CMD-BUILD-004`. - **CMD-WEB-004** — Les fichiers produits par `wasm-bindgen` sont générés localement et ne sont pas commités. ## Git et fichiers générés @@ -75,7 +75,7 @@ ## RC et release -- **CMD-RC-001** — L'entrée en RC gèle le périmètre fonctionnel de `0.1.0` ; seuls les correctifs, la reproductibilité des builds, le packaging, la documentation de livraison et les défauts de release sont admis. +- **CMD-RC-001** — L'entrée en RC gèle le périmètre fonctionnel de la version courante ; seuls les correctifs, la reproductibilité des builds, le packaging, la documentation de livraison et les défauts de release sont admis. - **CMD-RC-002** — La validation d'une RC exécute `cargo test --workspace --all-targets --all-features` en plus des audits, du check et de Clippy strict. - **CMD-RC-003** — Les deux runners Desktop natifs sont construits en `--release` et font l'objet d'un smoke sur les binaires de release. - **CMD-RC-004** — Le POC Tauri est construit uniquement via `cargo tauri build`; ses hooks possèdent toujours le build WASM et Vite/TypeScript. @@ -92,7 +92,7 @@ ## Outils de build et scripts d'audit - **CMD-BUILD-001** — Les scripts Python du dépôt sont autorisés pour les audits, audits complémentaires, validations et validations complémentaires. -- **CMD-BUILD-002** — Un script Python ne pilote pas le build d'un produit, d'une plateforme ou d'un package distribué. +- **CMD-BUILD-002** — À partir de `0.3.x`, aucun chemin de build nouveau ou modifié n’est piloté par Python. Les orchestrateurs historiques `scripts/build_reflex_tauri_wasm.py` et `scripts/build_android_rust.py` restent tolérés uniquement comme mécanismes gelés de la baseline `0.1.0` jusqu’à la tranche qui réactive leur chemin ; ils ne sont ni copiés, ni généralisés, ni utilisés pour un nouveau POC. - **CMD-BUILD-003** — Les builds utilisent l'outil natif approprié au périmètre : Cargo pour Rust, Gradle pour Android, Tauri CLI pour Tauri, ou l'outil officiellement retenu par la plateforme concernée. - **CMD-BUILD-004** — Les POC `0.3.x` doivent remplacer toute orchestration de build Python restante par des procédures explicites, reproductibles et testées avec les outils natifs. - **CMD-BUILD-005** — Les builds, tests unitaires, tests d'intégration et smoke tests de validation sont exécutés côté utilisateur ; les scripts d'audit peuvent vérifier statiquement leur préparation mais ne les simulent pas. diff --git a/docs/studies/000-README.md b/docs/studies/000-README.md index 5df7df2..3f51af3 100644 --- a/docs/studies/000-README.md +++ b/docs/studies/000-README.md @@ -1,5 +1,5 @@ - + # Études @@ -53,3 +53,7 @@ Ces documents étudient les POC à réaliser ; ils ne lancent encore aucune impl - [`020-UROBURAS_CRATE_DECOMPOSITION_STUDY.md`](020-UROBURAS_CRATE_DECOMPOSITION_STUDY.md) — proposition de familles de crates et dépendances sans monolithe jeu. - [`021-UROBURAS_SERVER_REFERENCE_STACK.md`](021-UROBURAS_SERVER_REFERENCE_STACK.md) — stack serveur de référence Actix/Tokio/tokio-tungstenite/Maud/Fluent/Lettre et gRPC/Tonic conditionnel. - [`022-UROBURAS_IMPLEMENTATION_DEPENDENCY_ORDER.md`](022-UROBURAS_IMPLEMENTATION_DEPENDENCY_ORDER.md) — ordre d'implémentation recommandé pour le Mode 1 avant les modes multijoueurs. + +## Étude de cadrage 0.3.0 + +- [`023-V0_3_0_PLATFORM_POC_AUDIT.md`](023-V0_3_0_PLATFORM_POC_AUDIT.md) — audit réel de la baseline `0.2.0`, requirements Snake, graphe de dépendances, choix du premier POC et sizing corrigé de `0.3.0`. diff --git a/docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md b/docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md new file mode 100644 index 0000000..b4d5a1f --- /dev/null +++ b/docs/studies/023-V0_3_0_PLATFORM_POC_AUDIT.md @@ -0,0 +1,354 @@ + + + +# 0.3.0 — audit de baseline et cadrage du premier POC plateforme + +## Statut + +Étude de cadrage pour `0.3.0-0-pre.1`. + +Elle décrit l'état observé de la stable `0.2.0`, les requirements réellement nécessaires à Snake, le premier POC retenu et le sizing corrigé. Elle ne transforme pas encore les extractions candidates en architecture durable. + +## Base inspectée + +Base déclarée : tag stable `v0.2.0`, fourni sous forme d'archive `games-v0.2.0.zip`. + +L'intégrité ZIP est propre. L'archive ne contient pas `.git` : l'état du commit, le tag effectif et la propreté du working tree ne peuvent donc pas être vérifiés dans cet environnement. + +La version workspace observée avant modification est `0.2.0`. + +## Audits officiels exécutés sur la baseline + +Les audits en lecture seule suivants passent sur la baseline telle que livrée : + +```text +General Rust rule audit: clean +Rust export completeness audit: 0 candidate(s) +games.sasedev workspace audit: clean +Markdown table audit: clean (4 table(s), 158 file(s)) +Distribution layout audit: clean (19 required path(s), 1 forbidden path(s) absent) +``` + +Ces résultats valident uniquement les contrôles mécaniques réellement couverts par les scripts. La revue manuelle des règles a détecté des écarts supplémentaires. + +## Écarts de baseline détectés + +### README de version obsolète + +`README.md` annonce encore `0.1.0` comme stable et `0.2.0` comme candidate alors que l'archive est la stable `0.2.0`. + +Correction dans `0-pre.1` : afficher `0.2.0` comme stable de référence et `0.3.0-0-pre.1` comme version de développement. + +### ROADMAP stable non fermé + +`ROADMAP.md` conserve quatre lignes `( )` sous `0.2.0`. Cela contredit `DOC-RMAP-010`, qui interdit du scope encore planifié sous une version stable clôturée. + +La revue du contenu `0.2.0` montre que : + +- layering et dépendances ont été couverts par les études puis l'architecture consolidée ; +- matrice plateforme et pressure tests ont été produits ; +- la composition Rust statique a été retenue ; +- le manifest produit/jeu et l'architecture physique définitive des crates ne sont volontairement pas figés ; +- la trajectoire `0.3.x` puis `0.4.x` a été définie. + +Correction dans `0-pre.1` : fermer les lignes réellement livrées et marquer explicitement le manifest/shape physique définitif comme reporté. + +### Effet de bord de la gate d'audit Python + +Le ZIP `v0.2.0` ne contient aucun `__pycache__` ni fichier `.pyc`. En revanche, l'exécution de `scripts/audit_rust_workspace_rules.py` sur la baseline crée `scripts/__pycache__/audit_rust_general_rules.cpython-313.pyc` : `audit_rust_export_completeness.py` importe `audit_rust_general_rules.py` dans un sous-processus Python standard. + +Cela contredit l'intention de `CMD-GEN-006`, selon laquelle les audits sont des contrôles en lecture seule. Correction dans `0-pre.1` : le wrapper exécute désormais ses trois sous-audits avec l'interpréteur courant et `-B`, ce qui supprime cet effet de bord sans modifier les audits eux-mêmes. Une réexécution complète confirme qu'aucun cache Python n'est créé. + +### Règle RC encore spécifique à 0.1.0 + +`CMD-RC-001` parle encore du gel fonctionnel de `0.1.0`. La règle est générale et doit viser la version courante. + +Correction dans `0-pre.1` : formulation générique. + +### Build Python historique et cohérence normative + +La revue des règles révèle une contradiction dans `0.2.0` : `CMD-BUILD-002` interdisait globalement qu’un script Python pilote un build, tandis que `CMD-BUILD-004` demandait précisément aux POC `0.3.x` de remplacer les orchestrateurs Python encore présents. La baseline conserve effectivement deux chemins historiques qui les utilisent. + +Deux scripts historiques pilotent encore des builds : + +- `scripts/build_reflex_tauri_wasm.py` ; +- `scripts/build_android_rust.py`. + +Le premier est encore appelé par les hooks Tauri Reflex. Le second orchestre `cargo ndk`, l'extraction SDL3 depuis l'AAR et le staging `jniLibs`. + +Ils appartiennent à la baseline validée `0.1.0`, mais un POC `0.3.x` ne doit pas les reprendre comme mécanisme de build. `CMD-BUILD-002` est rendue cohérente avec cette migration : les deux orchestrateurs sont explicitement tolérés uniquement comme baseline gelée jusqu’à la réactivation du chemin concerné. `CMD-WEB-003` qualifie également le script Tauri/WASM comme historique. Les remplacements sont réalisés lorsque le chemin concerné devient actif : Web direct en `0.3.0`, Tauri Android/Desktop dans les versions correspondantes et Android natif multi-ABI dans sa tranche dédiée. + +## Contraintes de l'environnement courant + +L'environnement d'inspection dispose de : + +```text +Python 3.13.5 +Node.js v22.16.0 +npm 10.9.2 +OpenJDK 21 +``` + +Il ne dispose pas de : + +```text +cargo +rustc +rustup +gradle +wasm-bindgen +cargo-ndk +Tauri CLI +``` + +L'archive ne contient pas de Gradle Wrapper et ne vend pas l'AAR SDL3, conformément à la baseline Android actuelle. + +Conséquence : seuls les audits statiques et inspections de fichiers sont exécutables ici. Les builds, tests et smokes restent à exécuter par l'utilisateur conformément à `CMD-BUILD-005`. + +## Inventaire Snake et hosts existants + +### Gameplay Snake + +`game-snake-poc` possède déjà : + +- un état déterministe indépendant de SDL, Android, Tauri et Web ; +- des directions sémantiques `Left/Right/Up/Down` via `InputState` ; +- une cadence de déplacement interne ; +- collision mur/corps ; +- score et nourriture ; +- rendu sous forme de `EngineScene` normalisée. + +Le jeu ne consomme aucun symbole de `engine-v1-platform-api`, bien que cette dépendance soit encore déclarée dans son manifest. La même déclaration inutilisée existe dans `game-reflex-poc`. Cette dette est à nettoyer avant le premier adapter Web. + +### Desktop SDL3 + +`engine-v1-sdl` fournit déjà : + +- fenêtre redimensionnable ; +- clavier directionnel ; +- pointeur normalisé ; +- swipe tactile/souris ; +- quit par fermeture, Escape et Back plateforme ; +- rendu de rectangles normalisés ; +- boucle fixed-step de 16 ms utilisée par les runners. + +Le runner Snake Desktop compose correctement gameplay, SDL, logging et capacité plateforme désactivée. Il reste la baseline de non-régression pour `0.3.0`. + +### Android SDL3 / Java / JNI + +La baseline possède : + +- `SaseGameActivity` commune dérivée de `SDLActivity` ; +- un bridge JNI versionné ; +- un `cdylib` Rust commun sélectionnant Reflex ou Snake par feature ; +- tactile transporté par SDL3 ; +- observation Back Android 16 non consommatrice ; +- staging Gradle des assets ; +- configuration NDK centralisée. + +Le chemin build Rust Android reste toutefois orchestré par Python et n'est pas réutilisé par le premier POC `0.3.0`. + +### Référence Tauri/WASM Reflex + +La référence Reflex valide déjà plusieurs conventions utiles : + +- crate WASM distincte de la crate Tauri ; +- `lib.rs` Tauri limité à la façade/réexport ; +- `tauri.rs` propriétaire de l'assemblage et des commandes ; +- frontend Vite/TypeScript dans la crate Tauri ; +- tracing frontend relayé vers Rust ; +- canvas redimensionné selon le viewport et le device pixel ratio. + +Les APIs WASM et le frontend restent cependant Reflex-specific. Elles sont des références à adapter, pas du code générique à copier aveuglément. + +## Graphe de dépendances local observé + +```text +engine-v1-common + +engine-v1-platform-api + +engine-v1-sdl + -> engine-v1-common + +game-snake-poc + -> engine-v1-common + -> engine-v1-platform-api [déclarée, non utilisée] + +game-reflex-poc + -> engine-v1-common + -> engine-v1-platform-api [déclarée, non utilisée] + +game-snake-poc-desktop + -> game-snake-poc + -> engine-v1-common + -> engine-v1-platform-api + -> engine-v1-sdl + -> game-logging-lib + +game-android-entrypoint + -> engine-v1-common + -> engine-v1-sdl + -> game-logging-lib + -> game-snake-poc / game-reflex-poc via features + +game-reflex-poc-wasm + -> engine-v1-common + -> game-reflex-poc + +game-reflex-poc-tauri Rust + -> engine-v1-platform-api + -> game-logging-lib + +frontend Reflex Tauri + -> bindings générés game-reflex-poc-wasm + +game-assets-lib + -> aucun consommateur runtime actuel +``` + +Le graphe confirme que gameplay Snake et host peuvent être séparés sans créer un nouveau moteur. + +## Requirements du premier POC Snake + +| Besoin | Baseline réelle | Décision 0.3.0 | +|--------------------------------|-------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------| +| Input clavier | SDL oui ; Web Snake absent | adapter clavier Web vers `GameAction` | +| Boutons directionnels tactiles | absent | quatre contrôles virtuels Web vers `GameAction` | +| Viewport / resize | SDL oui ; Reflex Web oui | réutiliser le principe canvas responsive sans coupler Snake à Tauri | +| Lifecycle | quit minimal ; pas de lifecycle Web générique | pause des ticks sur `visibilitychange`, reprise contrôlée, sortie/navigation host-specific | +| Runtime provenance | type présent mais non consommé | instancier une provenance Browser/WASM et refléter le profil d'input réellement utilisé | +| Assets | sources + resolver/staging présents ; aucun runtime ne charge actuellement les JSON | valider le packaging/chargement de `common` et `game` dans le POC Web | +| Logging | tracing natif ; bridge Tauri Reflex | logging Web local distinct de Tauri, sans dupliquer la logique gameplay | +| WASM bridge | Reflex-specific | créer un adapter Snake dédié ; n'extraire un bridge générique qu'après duplication réellement observée | +| Tauri bridge | Reflex Desktop uniquement | hors scope `0.3.0` | +| Android packaging | SDL/Java/JNI existant | hors scope `0.3.0` | +| Multi-ABI | script historique supportant plusieurs ABI | hors scope `0.3.0`, remplacement natif prévu plus tard | + +## Duplications et extractions candidates + +Duplications déjà visibles : + +- runners Desktop Reflex/Snake très proches ; +- activities Android spécifiques volontairement minimales ; +- future exposition de `EngineScene` en WASM susceptible de répéter l'adapter Reflex ; +- shell frontend Canvas/input susceptible d'être commun au Web direct et à Tauri. + +Décision : ne pas extraire un runner générique, un bridge WASM générique ou un shell Web commun dans `pre.1`. Le premier second consommateur réel décide de l'extraction. + +## Choix du premier POC + +Le premier POC de `0.3.0` est : + +```text +Web navigateur direct + Snake +``` + +Le choix initial Tauri Android est reporté au second host, actuellement `0.3.1`. + +Raisons : + +- le Web direct exerce déjà WASM, keyboard/touch, resize, lifecycle, assets et provenance ; +- la référence Reflex fournit un précédent WASM/Canvas sans imposer Tauri ; +- Tauri Android ajouterait simultanément un nouveau gameplay WASM, un nouveau host mobile Tauri, le lifecycle mobile, le packaging Android Tauri et les plugins ; +- la baseline Web obtenue devient ensuite un point de comparaison et de réutilisation pour Tauri Android ; +- ce découpage réduit le risque de créer trop tôt une abstraction Tauri/Web commune sur la seule base de Reflex. + +## Scope corrigé de 0.3.0 + +Inclus : + +- correction des écarts de baseline détectés en `pre.1` ; +- nettoyage host-neutral de Snake ; +- maintien du runner Desktop SDL3 ; +- adapter WASM Snake dédié ; +- frontend Web direct Vite/TypeScript minimal ; +- clavier + boutons directionnels tactiles ; +- canvas responsive ; +- lifecycle navigateur minimal ; +- logging Web ; +- chargement d'assets de preuve ; +- provenance Browser/WASM ; +- build Web avec outils natifs ; +- audit de duplication et décisions d'extraction après POC. + +Exclus : + +- Tauri Android ; +- Tauri Desktop Snake ; +- remplacement du build Android natif multi-ABI ; +- publicité, billing, auth ou leaderboard ; +- réseau realtime ; +- WebTransport/QUIC ; +- logique Uroburas ; +- ECS, physique ou nouveau moteur. + +## Sizing corrigé + +Le forecast initial est réduit et réordonné afin que `0.3.0` reste une version de session unique. + +### `0-pre.1` — audit, règles, requirements et sizing + +- audit complet de la baseline ; +- correction des incohérences documentaires/règles détectées ; +- choix Web direct ; +- forecast corrigé ; +- aucune implémentation gameplay/host lourde. + +### `0-pre.2` — Snake portability baseline + +- supprimer les dépendances de plateforme inutiles des crates jeu concernées ; +- confirmer les actions sémantiques nécessaires à Snake ; +- conserver Desktop SDL3 comme non-régression ; +- préciser le contrat minimal attendu par l'adapter WASM. + +### `0-pre.3` — adapter Snake WASM + build natif Web + +- crate WASM Snake dédiée ; +- exposition input/update/scene strictement nécessaire ; +- procédure Cargo + `wasm-bindgen` reproductible sans Python ; +- tests ciblés de l'adapter lorsqu'ils sont possibles hors navigateur. + +### `0-pre.4` — POC navigateur direct de bout en bout + +- frontend Vite/TypeScript ; +- rendu Canvas ; +- clavier ; +- boutons tactiles ; +- resize ; +- visibility lifecycle ; +- logging ; +- assets ; +- provenance ; +- build et smoke navigateur réels côté utilisateur. + +### `0-pre.5` — uniquement si le POC révèle un défaut réel + +Cette tranche n'est pas créée artificiellement. Elle corrige une frontière, une duplication ou un bug observé. + +### `2-beta.1` — validation large du scope retenu + +Alpha n'est pas planifiée par défaut. Si `pre.4` est fonctionnellement complet, la beta valide le workspace affecté, le build Web de production et le smoke du POC. + +### `3-rc.1` — candidate gelée + +Documentation durable, commandes reproductibles, décisions d'extraction/report, ROADMAP et préparation de la version suivante. Aucun nouveau scope. + +### `0.3.0` — promotion mécanique + +Aucune nouvelle fonctionnalité. + +## Critères de sortie de 0.3.0 + +`0.3.0` peut être clôturée lorsque : + +- Snake Desktop SDL3 reste fonctionnel ; +- Snake fonctionne réellement dans un navigateur direct ; +- clavier et boutons tactiles produisent les mêmes actions sémantiques ; +- resize et visibility lifecycle ont été exercés ; +- assets et provenance sont observables ; +- le chemin Web ne dépend d'aucun script Python de build ; +- les duplications avec Reflex/Tauri sont documentées ; +- seules les abstractions prouvées nécessaires ont été extraites ; +- les validations applicables ont été exécutées par l'utilisateur ; +- aucune logique Uroburas ni réseau realtime n'a été introduite. diff --git a/scripts/audit_project_workspace_rules.py b/scripts/audit_project_workspace_rules.py index 853af1a..6a7e050 100755 --- a/scripts/audit_project_workspace_rules.py +++ b/scripts/audit_project_workspace_rules.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 # file: scripts/audit_project_workspace_rules.py -# version: 5 +# version: 6 """Audit mechanically verifiable games.sasedev workspace boundaries.""" @@ -92,6 +92,18 @@ def main() -> int: for java_path in sorted(root.rglob("*.java")): if not java_path.is_relative_to(root / "Android"): errors.append(f"GAME-ANDROID-001: Java source outside Android/: {java_path.relative_to(root).as_posix()}") + + changelog_text = (root / "CHANGELOG.md").read_text(encoding="utf-8") + stable_versions = set(re.findall(r"^## ([0-9]+\.[0-9]+\.[0-9]+)(?: \u2014.*)?$", changelog_text, re.MULTILINE)) + roadmap_text = (root / "ROADMAP.md").read_text(encoding="utf-8") + roadmap_sections = re.split(r"(?=^## )", roadmap_text, flags=re.MULTILINE) + for section in roadmap_sections: + heading = re.match(r"^## ([0-9]+\.[0-9]+\.[0-9]+)(?: \u2014.*)?$", section.splitlines()[0] if section.splitlines() else "") + if heading is None or heading.group(1) not in stable_versions: + continue + for line in section.splitlines()[1:]: + if line.startswith("- ( )"): + errors.append(f"DOC-RMAP-010: stable version {heading.group(1)} retains planned scope: {line}") if errors: for error in errors: print(error, file=sys.stderr) diff --git a/scripts/audit_rust_workspace_rules.py b/scripts/audit_rust_workspace_rules.py index 91fa7fb..bcb6d8b 100755 --- a/scripts/audit_rust_workspace_rules.py +++ b/scripts/audit_rust_workspace_rules.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 # file: scripts/audit_rust_workspace_rules.py -# version: 1 +# version: 2 """Run all Rust normalization and games.sasedev workspace audits.""" @@ -20,9 +20,9 @@ def main() -> int: arguments = parser.parse_args() script_dir = pathlib.Path(__file__).resolve().parent commands = [ - ["python3", str(script_dir / "audit_rust_general_rules.py"), "--root", arguments.root], - ["python3", str(script_dir / "audit_rust_export_completeness.py"), "--root", arguments.root], - ["python3", str(script_dir / "audit_project_workspace_rules.py"), "--root", arguments.root], + [sys.executable, "-B", str(script_dir / "audit_rust_general_rules.py"), "--root", arguments.root], + [sys.executable, "-B", str(script_dir / "audit_rust_export_completeness.py"), "--root", arguments.root], + [sys.executable, "-B", str(script_dir / "audit_project_workspace_rules.py"), "--root", arguments.root], ] for command in commands: completed = subprocess.run(command, check=False)