From d42c8558437463c23289714753b8398bbb579fe6 Mon Sep 17 00:00:00 2001 From: Codex Date: Sat, 24 Oct 2026 04:04:33 +0200 Subject: [PATCH] Add read-only Almanac desktop and match history views (by Codex) --- .github/workflows/modern-ui.yml | 4 +- assets/modern/almanac.rcss | 123 ++++++ assets/modern/icons/almanac.svg | 29 ++ assets/modern/modern.rml | 2 +- docs/new_engine/almanach.md | 9 + docs/new_ui/NATIVE_STATUS.md | 6 + docs/new_ui/README.md | 1 + docs/new_ui/assets.md | 10 + docs/new_ui/desktop/almanac/DATA_CONTRACT.md | 299 +++++++++++++ docs/new_ui/desktop/almanac/README.md | 147 +++++++ docs/new_ui/menu-qa.md | 5 + docs/new_ui/qa-findings.md | 2 +- src/modern/ui/CMakeLists.txt | 10 +- src/modern/ui/almanac_controls.inc | 41 ++ src/modern/ui/almanac_screens.inc | 392 +++++++++++++++++ src/modern/ui/controls.inc | 41 +- src/modern/ui/demo_almanac.cpp | 435 +++++++++++++++++++ src/modern/ui/demo_almanac.hpp | 27 ++ src/modern/ui/desktop.cpp | 17 +- src/modern/ui/desktop.hpp | 2 + src/modern/ui/model.cpp | 10 +- src/modern/ui/model.hpp | 7 + src/modern/ui/report_pickers.inc | 40 +- src/modern/ui/screens.inc | 6 +- src/modern/ui/view.cpp | 47 +- tests/modern_almanac_ui_tests.cpp | 297 +++++++++++++ tests/modern_control_layout_tests.cpp | 2 +- tests/modern_ui_core_tests.cpp | 32 ++ tools/modern_ui/prepare_gui_assets.py | 1 + 29 files changed, 2009 insertions(+), 35 deletions(-) create mode 100644 assets/modern/almanac.rcss create mode 100644 assets/modern/icons/almanac.svg create mode 100644 docs/new_ui/desktop/almanac/DATA_CONTRACT.md create mode 100644 docs/new_ui/desktop/almanac/README.md create mode 100644 src/modern/ui/almanac_controls.inc create mode 100644 src/modern/ui/almanac_screens.inc create mode 100644 src/modern/ui/demo_almanac.cpp create mode 100644 src/modern/ui/demo_almanac.hpp create mode 100644 tests/modern_almanac_ui_tests.cpp diff --git a/.github/workflows/modern-ui.yml b/.github/workflows/modern-ui.yml index 05e5022..8030d81 100644 --- a/.github/workflows/modern-ui.yml +++ b/.github/workflows/modern-ui.yml @@ -52,9 +52,9 @@ jobs: - name: Configure opt-in UI without external assets run: cmake -S . -B build-ui -G Ninja -DCMAKE_BUILD_TYPE=Release -DOPENBMH_BUILD_MODERN_UI=ON -DOPENBMH_BUILD_EDITOR=OFF -DBMH_DATA= - name: Compile native frontend and synthetic checks - run: cmake --build build-ui --target openbmh_play modern_ui_core_tests modern_ticket_document_tests modern_control_layout_tests modern_reports_tests modern_planning_tests --parallel 2 + run: cmake --build build-ui --target openbmh_play modern_ui_core_tests modern_ticket_document_tests modern_control_layout_tests modern_reports_tests modern_planning_tests modern_almanac_ui_tests --parallel 2 - name: Check controls, fonts, density and draft cancellation - run: ctest --test-dir build-ui -R "^modern_(ui_|ticket_|control_|reports_|planning_)" --output-on-failure --output-junit modern-ui-results.xml + run: ctest --test-dir build-ui -R "^modern_(ui_|ticket_|control_|reports_|planning_|almanac_ui_)" --output-on-failure --output-junit modern-ui-results.xml - name: Upload test report if: always() uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 diff --git a/assets/modern/almanac.rcss b/assets/modern/almanac.rcss new file mode 100644 index 0000000..93b4857 --- /dev/null +++ b/assets/modern/almanac.rcss @@ -0,0 +1,123 @@ +/* SPDX-License-Identifier: GPL-3.0-only */ +/* Historical DTO values only; logical coordinates match the HTML glass window. */ +.almanac {position:absolute;left:0;top:0;width:2612dp;height:1864dp;font-size:32dp;line-height:1.3;color:var(--text);} +.almanac h2,.almanac h3,.almanac p {margin:0;} +.alm-toolbar {position:absolute;left:0;top:0;width:2612dp;height:94dp;z-index:22;} +.alm-control {display:flex;align-items:center;justify-content:center;height:94dp;padding:12dp 20dp;border:2dp var(--border);border-radius:12dp;background-color:transparent;decorator:linear-gradient(180deg,#c1d1e31c,#869eb312);font-size:32dp;font-weight:normal;color:var(--text);} +.alm-control:hover {decorator:none;background-color:var(--hover);} +.alm-control:focus-visible {border-color:var(--accent);} +.alm-control span {display:block;line-height:41.6dp;} +.alm-back {position:absolute;left:0;top:0;width:420dp;} +.alm-heading {position:absolute;left:444dp;top:21dp;width:1724dp;height:52dp;font-size:40dp;line-height:52dp;font-weight:normal;text-align:center;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} +.alm-year-context {position:absolute;left:2192dp;top:0;width:420dp;height:94dp;display:flex;align-items:center;justify-content:flex-end;font-size:34dp;color:var(--muted);} +.alm-year-context span {display:block;line-height:44.2dp;} +.alm-underlay {position:absolute;left:0;top:0;width:2612dp;height:1864dp;} +.alm-calendar {position:absolute;left:0;top:132dp;width:2612dp;height:1598dp;} +.alm-month {position:absolute;padding:14dp 16dp;border:2dp var(--border);border-radius:16dp;background-color:var(--soft);} +.alm-month h3 {position:absolute;left:16dp;right:16dp;top:14dp;height:38dp;font-size:30dp;line-height:38dp;font-weight:normal;text-align:center;} +.alm-month-grid {position:absolute;left:16dp;top:68dp;} +.alm-weekday {position:absolute;display:flex;align-items:center;font-size:24dp;color:var(--muted);} +.alm-weekday span {display:block;line-height:31.2dp;} +.alm-weekday.sunday {color:var(--danger);} +.alm-day {position:absolute;display:flex;align-items:center;justify-content:center;min-width:0;margin:0;padding:0;border:0dp;border-radius:8dp;background-color:transparent;color:var(--muted);font-size:30dp;} +.alm-day-text {display:block;line-height:39dp;} +.alm-day.future {opacity:0.4;} +.alm-day.played {background-color:var(--selected);color:var(--accent);} +.alm-day.played:hover {background-color:var(--hover);} +.alm-day.played:focus-visible {border:2dp var(--accent);} +.alm-footer {position:absolute;left:0;top:1770dp;width:2612dp;height:94dp;display:flex;align-items:center;justify-content:space-between;gap:24dp;font-size:28dp;color:var(--muted);} +.alm-key {display:flex;align-items:center;gap:16dp;flex-shrink:0;} +.alm-key span {display:block;line-height:36.4dp;} +.alm-key .alm-key-marker {width:20dp;height:20dp;flex-shrink:0;border-radius:5dp;background-color:var(--accent);} +.alm-footer-info {display:block;min-width:0;line-height:36.4dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;text-align:right;} +.alm-picker-shield {position:absolute;left:0;top:0;width:2612dp;height:1864dp;margin:0;padding:0;border:0dp;border-radius:0dp;background-color:transparent;z-index:20;} +/* The shared picker opens down from this toolbar and mirrors its check to the right. */ +.alm-toolbar .report-picker-wrapper {top:0;bottom:auto;height:94dp;} +.alm-toolbar .report-picker-wrapper .report-picker-trigger {justify-content:center;gap:18dp;padding:12dp 20dp;text-align:center;} +.alm-toolbar .report-picker-label {flex:none;max-width:310dp;text-align:center;} +.alm-toolbar .report-picker-popup {top:108dp;bottom:auto;max-height:650dp;padding:12dp;border-radius:14dp;} +.alm-toolbar .report-picker-popup .report-picker-option {flex-direction:row;justify-content:space-between;gap:0dp;height:66dp;min-height:66dp;padding:8dp 20dp;border-radius:8dp;} +.alm-toolbar .report-picker-option-label {display:block;text-align:left;} +.almanac .alm-toolbar .report-picker-popup .report-picker-option[aria-checked=true] {background-color:var(--selected);color:var(--accent);} +.alm-day-list {position:absolute;left:0;top:132dp;width:2612dp;height:1598dp;overflow-y:auto;overflow-x:hidden;} +.alm-list-head {position:relative;display:flex;align-items:center;gap:18dp;width:100%;height:70dp;padding:0dp 28dp;border-bottom:2dp var(--border);font-size:28dp;color:var(--muted);} +.alm-row-home,.alm-row-away {display:flex;align-items:center;min-width:0;flex:1;} +.alm-row-score {display:flex;align-items:center;justify-content:center;flex-shrink:0;width:160dp;} +.alm-list-head .alm-row-home,.alm-list-head .alm-row-away {justify-content:center;} +.alm-list-head span {display:block;line-height:36.4dp;} +.alm-match-row {position:relative;display:block;width:100%;height:160dp;min-height:160dp;margin:0;padding:0;border:0dp;border-bottom:2dp var(--border);border-radius:12dp;background-color:transparent;color:var(--text);text-align:left;} +.alm-match-row.striped {background-color:var(--soft);} +.alm-match-row:hover {background-color:var(--hover);} +.alm-match-row:focus-visible {border-color:var(--accent);background-color:var(--hover);} +.alm-match-main {position:absolute;left:28dp;right:28dp;top:16dp;height:82dp;display:flex;align-items:center;gap:18dp;} +.alm-match-main .alm-row-home,.alm-match-main .alm-row-away {height:82dp;} +.alm-team {display:flex;align-items:center;gap:14dp;min-width:0;max-width:100%;font-size:34dp;line-height:44.2dp;} +.alm-row-home .alm-team,.alm-row-away .alm-team {width:100%;} +.alm-team-home {justify-content:flex-end;} +.alm-team-away {justify-content:flex-start;} +.alm-team-name {display:block;min-width:0;line-height:44.2dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} +.alm-crest {display:flex;align-items:center;justify-content:center;flex-shrink:0;overflow:hidden;} +.alm-crest .image-frame {flex-shrink:0;} +.alm-no-crest {display:block;font-size:24dp;line-height:31.2dp;text-align:center;} +.alm-list-score {height:82dp;flex-direction:column;gap:3dp;} +.alm-list-score-value {display:block;height:52dp;line-height:52dp;font-size:40dp;white-space:nowrap;} +.alm-list-score-phase {display:block;height:27dp;line-height:27dp;font-size:22dp;white-space:nowrap;color:var(--muted);} +.alm-match-meta {position:absolute;left:28dp;right:28dp;top:111dp;height:31.2dp;display:flex;align-items:center;justify-content:center;font-size:24dp;color:var(--muted);} +.alm-match-meta span {display:block;width:100%;max-width:100%;text-align:center;line-height:31.2dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} +.alm-summary {position:absolute;left:0;top:132dp;width:2612dp;height:360dp;padding:20dp 28dp;border:2dp var(--border);border-radius:18dp;background-color:var(--soft);} +.alm-summary-teams {position:absolute;left:28dp;right:28dp;top:20dp;height:250dp;} +.alm-summary-team {position:absolute;top:0;width:854dp;height:250dp;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:10dp;min-width:0;text-align:center;} +.alm-summary-team.home {left:0;} +.alm-summary-team.away {right:0;} +.alm-summary-team-name {display:block;width:100%;max-width:100%;height:50dp;line-height:50dp;font-size:42dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} +.alm-summary-manager {display:block;width:100%;max-width:100%;height:39dp;line-height:39dp;font-size:30dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;color:var(--muted);} +.alm-summary-result {position:absolute;left:886dp;top:0;width:780dp;height:250dp;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:10dp;text-align:center;} +.alm-summary-score {display:block;height:80dp;line-height:80dp;font-size:68dp;} +.alm-summary-phase {display:block;max-width:780dp;line-height:33.8dp;font-size:26dp;color:var(--muted);} +.alm-summary-phases {display:block;max-width:780dp;line-height:31.2dp;font-size:24dp;color:var(--muted);} +.alm-match-facts {position:absolute;left:28dp;right:28dp;bottom:0;height:86dp;border-top:2dp var(--border);display:flex;align-items:center;gap:24dp;} +.alm-match-fact {display:flex;align-items:center;justify-content:center;gap:16dp;flex:1;min-width:0;height:84dp;font-size:28dp;} +.alm-fact-label {display:block;flex-shrink:0;line-height:36.4dp;white-space:nowrap;color:var(--muted);} +.alm-fact-value {display:block;min-width:0;line-height:36.4dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} +.alm-tabs {position:absolute;left:0;top:520dp;width:2612dp;height:82dp;padding:6dp;border:2dp var(--border);border-radius:16dp;background-color:var(--soft);display:flex;gap:12dp;} +.alm-tab {display:flex;align-items:center;justify-content:center;flex:1;min-width:0;height:66dp;padding:0;border:0dp;border-radius:10dp;background-color:transparent;font-size:32dp;color:var(--muted);} +.alm-tab span {display:block;line-height:41.6dp;} +.alm-tab.selected {background-color:var(--selected);color:var(--text);} +.alm-tab:hover {background-color:var(--hover);} +.alm-detail-content {position:absolute;left:0;top:626dp;width:2612dp;height:1104dp;overflow-y:auto;overflow-x:hidden;} +.alm-lineups {display:flex;align-items:stretch;gap:32dp;} +.alm-lineup {flex:1;min-width:0;padding:20dp 26dp;border:2dp var(--border);border-radius:16dp;background-color:var(--soft);} +.alm-lineup header {height:64dp;display:flex;align-items:center;justify-content:center;} +.alm-lineup h3 {height:46dp;line-height:46dp;margin-top:20dp;font-size:28dp;font-weight:normal;color:var(--muted);} +.alm-player {display:flex;align-items:center;height:66dp;gap:20dp;border-bottom:1dp var(--border);font-size:32dp;} +.alm-player-number {display:block;flex-shrink:0;width:70dp;line-height:41.6dp;text-align:right;color:var(--muted);} +.alm-position {display:block;flex-shrink:0;width:110dp;line-height:33.8dp;font-size:26dp;color:var(--muted);} +.alm-player-name {display:block;min-width:0;flex:1;line-height:41.6dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} +.alm-empty {padding:40dp 0;font-size:30dp;line-height:39dp;text-align:center;color:var(--muted);} +.alm-event {position:relative;display:flex;align-items:center;min-height:104dp;padding:12dp 18dp;gap:24dp;border-bottom:2dp var(--border);font-size:30dp;} +.alm-event.striped {background-color:var(--soft);} +.alm-event-minute {display:block;flex-shrink:0;width:160dp;line-height:36.4dp;font-size:28dp;white-space:nowrap;color:var(--accent);} +.alm-event-team {display:block;flex-shrink:0;min-width:0;width:500dp;line-height:39dp;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;} +.alm-event-description {display:block;flex:1;min-width:0;} +.alm-event-kind {display:block;line-height:36.4dp;font-size:28dp;} +.alm-event-text {display:block;margin-top:5dp;line-height:36.4dp;font-size:28dp;white-space:normal;color:var(--muted);} +body.midnight .almanac {color:#dce3e9;} +body.midnight .alm-control {border-color:#d4e0ec29;color:#e0e6ec;} +body.midnight .alm-month,body.midnight .alm-summary,body.midnight .alm-tabs,body.midnight .alm-lineup {background-color:#101d2826;border-color:#c5d9e71a;} +body.midnight .alm-weekday,body.midnight .alm-day {color:#9aaab9;} +body.midnight .alm-weekday.sunday {color:#eb9f98;} +body.midnight .alm-day.played {background-color:#7d9eb83b;color:#a9dccb;} +body.midnight .alm-day.played:hover {background-color:#d0e2f226;} +body.midnight .alm-year-context,body.midnight .alm-footer,body.midnight .alm-list-head,body.midnight .alm-list-score-phase,body.midnight .alm-match-meta,body.midnight .alm-summary-manager,body.midnight .alm-summary-phase,body.midnight .alm-summary-phases,body.midnight .alm-fact-label,body.midnight .alm-lineup h3,body.midnight .alm-player-number,body.midnight .alm-position,body.midnight .alm-empty,body.midnight .alm-event-text {color:#9eb4c7;} +body.midnight .alm-key-marker {background-color:#a9dccb;} +body.midnight .alm-match-row {color:#dce3e9;border-color:#d5e3ed15;} +body.midnight .alm-match-row.striped,body.midnight .alm-event.striped {background-color:#e3edf605;} +body.midnight .alm-match-row:hover {background-color:#d0e2f226;} +body.midnight .alm-tab.selected {background-color:#7d9eb83b;color:#eff4f7;} +body.midnight .alm-event-minute {color:#a9dccb;} +body.midnight .alm-list-head {border-color:#d5e3ed26;} +body.midnight .alm-player,body.midnight .alm-event {border-color:#d5e3ed15;} +body.silver .alm-control {decorator:linear-gradient(180deg,#ffffffb0,#bfd0e259);} +body.matchday .alm-control {decorator:linear-gradient(180deg,#e8d6dc12,#a1a0aa0d);} + +body.midnight .almanac .alm-toolbar .report-picker-popup .report-picker-option[aria-checked=true] {background-color:#7d9eb83b;color:#a9dccb;} diff --git a/assets/modern/icons/almanac.svg b/assets/modern/icons/almanac.svg new file mode 100644 index 0000000..3dd1ba2 --- /dev/null +++ b/assets/modern/icons/almanac.svg @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/modern/modern.rml b/assets/modern/modern.rml index 7470fa2..1851246 100644 --- a/assets/modern/modern.rml +++ b/assets/modern/modern.rml @@ -1,5 +1,5 @@ -OpenBMH +OpenBMH
diff --git a/docs/new_engine/almanach.md b/docs/new_engine/almanach.md index 3142b7a..156b970 100644 --- a/docs/new_engine/almanach.md +++ b/docs/new_engine/almanach.md @@ -45,6 +45,15 @@ Pro Spiel (`AlmanacMatch`): ## Für die UI (Codex) +Der [native und HTML-Almanachprototyp](../new_ui/desktop/almanac/README.md) +liegt mit Pseudodaten vor. Der [Lesevertrag](../new_ui/desktop/almanac/DATA_CONTRACT.md) +beschreibt die Abfragen `index`, `calendar`, `day` und `match` für eine spätere +konstante Modern-Sessionprojektion. Dort sind auch die F10-Grenzen festgehalten: +Teilstände nur bei vollständigem Nachweis ableiten, die ET-Teilnahme beim +Elfmeterschießen nicht raten, historische Tabellen verwenden und fehlende +Kader beziehungsweise Einzelangaben neutral ausgeben. Die UI liest derzeit +keine F10-/OBS-Dateien und ändert keine Engine- oder Spielstanddaten. + - `ModernState::almanac`: `finished` (Dateiname + Bytes je Saison, mit `decode_almanac_season` lesen) und `current` (laufende Saison). - Auswertungen (Torjäger aller Zeiten, Bilanzen, Rekorde) baut die Engine als Projektionen, sobald die Almanach-Oberfläche feststeht. Bis dahin kann die UI direkt auf den Saisons rechnen. `modern_season_sim` zeigt am Laufende ein Beispiel (`print_almanac`: Prüfung Tore gegen Ergebnis, Top-Torschützen über alle Saisons). - Namen sind UTF-8; Wettbewerbsnamen für Pokale kommen wie im Ergebnisbildschirm aus den Texten (`type - 1` = Pokal-ID). diff --git a/docs/new_ui/NATIVE_STATUS.md b/docs/new_ui/NATIVE_STATUS.md index 66de9b8..7730582 100644 --- a/docs/new_ui/NATIVE_STATUS.md +++ b/docs/new_ui/NATIVE_STATUS.md @@ -54,6 +54,12 @@ wird ausdrücklich mit `OPENBMH_BUILD_MODERN_UI=ON` gebaut. - [Hallentabellen](desktop/indoor/README.md): bis zu 16 Vereine aus der ersten deutschen Liga, unabhängige Platz-/Punktesortierung, Vereinsprofile und Info. +- [Almanach](desktop/almanac/README.md): eigenes Desktopicon, Jahreskalender, + Tagespaarungen und Spielberichte mit Phasenergebnissen, menschlichen Managern, + Schiedsrichter, Zuschauern, Wetter, beiden Aufstellungen/Bank und Ereignissen. + Die Vorschau verwendet unveränderliche Pseudodatensätze über zwei Saisons; + die vorbereitete Leseprojektion ist noch nicht an F10/OBS angeschlossen. + **Anstoß führt keine Aktion aus**, weder per Maus noch per Tastatur. Das gilt auch für die direkte Aktionsschnittstelle des Demoanbieters. diff --git a/docs/new_ui/README.md b/docs/new_ui/README.md index d923e6c..9029bf3 100644 --- a/docs/new_ui/README.md +++ b/docs/new_ui/README.md @@ -19,6 +19,7 @@ Implementierung in der Spiel-Engine. | Training | [Übungen, Kader, Intensität und Demo-Automatik](desktop/training/README.md) | | Taktik | [Interaktive Diagramme und Einsatzregler](desktop/tactics/README.md) | | Kalender | [Zwölf Monate, transponierte Wochen und Ligavorschau](desktop/calendar/README.md) | +| Almanach | [Jahreskalender, Tagespartien und historische Spielberichte](desktop/almanac/README.md) | | Paarungsanordnung | [Mittige Ergebnisse und innenliegende Wappen](desktop/fixtures/README.md) | | Berichte | [Tabellen, Stärken, Ligaspiele, übrige Spiele und Profile](desktop/reports/README.md) | | Freundschaftsspiele | [Gegner, Austragungsort, Kostenbestätigung und Vormerkungen](desktop/friendlies/README.md) | diff --git a/docs/new_ui/assets.md b/docs/new_ui/assets.md index 2effda6..6b7d9e7 100644 --- a/docs/new_ui/assets.md +++ b/docs/new_ui/assets.md @@ -79,3 +79,13 @@ private QA-Inhalte bleiben im privaten Bestand. `cacf8fdd5376110529afbf97c7b977aaee1d7957`: Karten, Campmotive und Menügrafiken. - Diamond 2026/27 Modern, Datenrevision 1.3: der geprüfte Asset-Index enthält HQ-Wappen und Spielerbilder, aber keine `asset:camp/...`-Bildschlüssel. + +## Almanachsymbol + +Das neue `almanac.svg` ist ein eigenständig gezeichnetes Vektorsymbol aus +Kalenderbuch und Fußball. Die GUI-Vorbereitung übernimmt +`assets/vector/desktop-almanac.svg` als `button.almanac`. Die native UI liefert +dieselbe Grafik unter `assets/modern/icons/almanac.svg` mit und kann sie auch +bei einem älteren externen GUI-Paket anzeigen. Ein OBW muss dieses Motiv +nicht enthalten. Bestehende Desktopansichten erhalten nur das zusätzliche +Icon an einer freien Stelle; vorhandene Objekte werden dabei nicht verschoben. diff --git a/docs/new_ui/desktop/almanac/DATA_CONTRACT.md b/docs/new_ui/desktop/almanac/DATA_CONTRACT.md new file mode 100644 index 0000000..3f44650 --- /dev/null +++ b/docs/new_ui/desktop/almanac/DATA_CONTRACT.md @@ -0,0 +1,299 @@ +# Almanach · Datenvertrag der UI-Projektion + +Stand: 24. Oktober 2026. Dieser Vertrag beschreibt die native +Präsentationsschnittstelle des [Almanachs](README.md). Er ist kein neues +Engine-Speicherformat. Die gegenwärtige Quelle ist ein unveränderliches +Pseudoarchiv; eine spätere Modern-Sessionprojektion kann denselben +Lesevertrag bedienen. + +## Besitz und Lesezugriff + +`DataSource::read_almanac(const Json &request) const` liefert eine +JSON-Antwort. Nicht unterstützte Quellen antworten mit +`{"ok":false,"error":"almanac_unavailable"}`. `DemoSource` leitet an +`query_demo_almanac(archive, request, state.date)` weiter. + +Das separat gehaltene Demoarchiv hat die Form +`{schema: "openbmh-ui-demo-almanac@1", matches: [...]}`. Es liegt nicht in +`Snapshot.state` oder UI-Demoständen. Abfragen geben eigenständige +Ergebniskopien zurück und verändern weder Archiv noch Revision, +Änderungsmarkierung, Geld oder RNG. Die App hält ihre Navigation nur in +flüchtigen Feldern. Das Laden eines UI-Demostands ändert den +Abfragestichtag, importiert aber kein Enginearchiv. Bestehende `.obs`- +Dateien und F10-Daten werden von diesem Paket weder gelesen noch geändert. + +## Requests und Antworten + +Requests sind Objekte mit genau den angegebenen Schlüsseln. Datumswerte +sind gültige Gregorianische ISO-Daten `YYYY-MM-DD`; Jahre sind ganze +Zahlen von 1 bis 9999. Boolesche Werte und Fließkommazahlen ersetzen keine +Ganzzahlen. Der Stichtag `as_of` ist kein frei überschreibbarer +Requestparameter: Die Datenquelle bindet ihn an das gespeicherte Datum. + +| Request | Erfolgsantwort zusätzlich zu `ok: true` | +|---|---| +| `{kind: "index"}` | `years: [Jahre]`, `match_count`, `first_date`, `last_date` | +| `{kind: "calendar", year: 2025}` | `year`, `days: [{date, count, highlights: [Match-IDs]}]` | +| `{kind: "day", date: "2025-08-03"}` | `date`, `matches: [vollständige Records]` | +| `{kind: "match", id: "demo:almanac:2025:0"}` | `match: vollständiger Record` | + +`years` ist aufsteigend und enthält nur Kalenderjahre sichtbarer Records. +`first_date` und `last_date` sind bei leerem Archiv `null`, +`match_count` ist dann `0`. Ein Jahreskalender enthält nur Tage mit +sichtbaren Partien, chronologisch geordnet. `count` zählt alle Partien +des Tages. `highlights` enthält in der Demo die IDs von Partien mit +Verlängerung, Elfmeterschießen oder mindestens vier Spieltoren insgesamt; +es enthält keine zusätzlichen Ergebnisse. Die Tagesabfrage erhält bei +Partien desselben Datums ihre ursprüngliche Archivreihenfolge. + +Alle vier Abfragen filtern zuerst auf `record.date <= as_of`. Damit +verraten weder die Jahresauswahl noch Anzahlen, Datumsgrenzen oder direkte +Matchabfragen zukünftige Partien. Ein gültiger leerer Tag oder ein Jahr +ohne sichtbare Daten liefert ein leeres Array. Unbekannte und noch nicht +sichtbare Match-IDs liefern denselben Fehler. + +Fehler haben die Form `{ok: false, error: "..."}`: + +| Fehler | Bedeutung | +|---|---| +| `almanac_unavailable` | Datenquelle unterstützt diese Projektion nicht. | +| `invalid_almanac_request` | Ungültige Requestform, unbekannte Art, zusätzliche Felder oder ungültiger Wert. | +| `invalid_almanac_cutoff` | Ungültiges Stichtagsdatum. | +| `invalid_demo_almanac` | Das separat gehaltene Demoarchiv verletzt seinen Vertrag. | +| `almanac_match_not_found` | Match-ID unbekannt oder jenseits des Stichtags. | + +Diese Fehlercodes beschreiben den nativen Provider. Der private +HTML-Arbeitsstand besitzt eigene Fehlerbezeichnungen; sein normalisierter +Recordaufbau und seine erfolgreichen Leseprojektionen folgen demselben +fachlichen Vertrag. + +## Normalisierter Matchrecord + +Alle folgenden Hauptfelder sind vorhanden. „Nullable“ bedeutet einen +expliziten JSON-Wert `null`, keinen ersatzweise erfundenen Inhalt. + +| Feld | Typ und Bedeutung | +|---|---| +| `id` | Stabile, nicht leere Match-ID. | +| `date` | ISO-Kalendertag des gespielten Matches. | +| `season` | Historische Saisonbeschriftung, etwa `2025/26`; kein Kalenderjahrfilter. | +| `competition` | `{id, name, type}` mit historischen Werten; `type` beispielsweise `league`, `cup` oder `friendly`. | +| `round` | Positive ganze Spieltags- oder Rundennummer. | +| `home`, `away` | Je `{id, name, crest, manager}`; unterschiedliche stabile Vereins-IDs. | +| `result` | Getrennte Ergebnisphasen gemäß folgendem Abschnitt. | +| `referee` | Historischer Name oder `null`. | +| `attendance` | Bekannte ganze Zuschauerzahl einschließlich `0`, sonst `null`. | +| `weather` | `{temperature, rain}`; beide ganzzahlig oder `null`, Regen im Bereich `0..7`. | +| `lineups` | `{home, away}`; jede Seite entweder `null` oder `{starters: [...], bench: [...]}`. | +| `events` | Geordnetes Array der unten definierten Ereignisse. | + +`crest` ist ein GUI-/Katalog-Assetverweis oder `null`. Namen und Verweise +werden als historische Snapshotwerte gehalten. Das DTO enthält keine +historischen Bildbytes und belegt deshalb nicht, dass eine später unter +demselben Assetverweis geladene Grafik dem früheren Wappenstand entspricht. +Der aktuelle Bildresolver darf eine Referenz darstellen; daraus folgt +keine zugesicherte historische Bildarchivierung. + +`manager` ist entweder `{id, name}` für einen archivierten menschlichen +Manager oder `null` für die in der Demo gesichert computergesteuerte +Seite. Der Renderer zeigt dafür „Computer“. Ein künftiger Adapter darf +einen ungültigen oder unbekannten menschlichen Managerverweis nicht +stillschweigend auf diesen Computerfall abbilden. + +Ein Aufstellungsspieler hat `{id, name, position?}`. `position` ist das +einzige optionale Feld dieses Teilobjekts. In der Demo wird sie beim +Archivaufbau aus dem Katalog kopiert, etwa `gk`, `def`, `mid` oder `fwd`. +Die sichtbaren Kürzel TW, ABW, MIT und STU sind reine Darstellung. +Der Renderer ersetzt fehlende historische Angaben nicht durch heutige +Kaderdaten. Die Demo bildet bei ausreichendem Kader genau einen Torwart +und zehn Feldspieler ab; alle übrigen Kaderspieler bleiben auf der Bank. +Ist das nicht möglich, bleibt die betreffende Aufstellung `null`. + +Die Laufnummer eines Aufstellungsplatzes ist kein Spieler-ID-Ersatz und +keine historische Rückennummer. Historische Spieleridentitäten bleiben +auch bei gleichnamigen Personen getrennt. Katalogumbenennungen nach dem +Archivaufbau verändern weder Vereins- noch Spieler- oder Managernamen +bereits erzeugter Records. + +### Ergebnisphasen + +`result` enthält immer folgende Schlüssel: + +| Feld | Bedeutung | +|---|---| +| `regulation` | `[Heimtore, Gasttore]` nach regulärer Spielzeit oder `null`, falls unbekannt. | +| `extra` | Ausschließlich zusätzlich in der Verlängerung gefallene Tore; bei nicht gespielter oder unbekannter Phase `null`. | +| `penalties` | Separates Ergebnis des Elfmeterschießens; ohne Elfmeterschießen `null`. | +| `final` | Spielendstand nach 90 beziehungsweise 120 Minuten, ohne Tore des Elfmeterschießens. | +| `extra_played` | Explizit bekanntes boolesches Kennzeichen für gespielte Verlängerung. | +| `penalties_played` | Boolesches Kennzeichen für gespieltes Elfmeterschießen. | + +Alle bekannten Ergebnisse sind Paare nicht negativer ganzer Zahlen. +Sind reguläre Zeit und Verlängerung bekannt, gilt pro Seite +`regulation + extra == final`. Beispiel: + +```json +{ + "regulation": [1, 1], + "extra": [1, 1], + "penalties": [4, 3], + "final": [2, 2], + "extra_played": true, + "penalties_played": true +} +``` + +`extra: [0, 0]` bezeichnet eine bekannte torlose Verlängerung und ist +etwas anderes als `extra: null`. Die aktuelle Demo erlaubt bei gespielter +Verlängerung unbekannte Teilstände. Bei gesetztem `penalties_played` +verlangt ihr Validator dagegen ein bekanntes, entscheidendes +Elfmeterschießenergebnis. Das Elfmeterschießen wird niemals zum +Spielendstand addiert. Ohne gespielte Verlängerung bleibt `extra` stets +`null`. + +Die booleschen Phasenkennzeichen sind in der Demo ausdrücklich bekannt. +Für einen Liveadapter mit unbekannter ET-Teilnahme muss vor der Anbindung +ein ausdrücklicher Unbekanntzustand vereinbart werden. `false` wäre dafür +kein zulässiger Ersatz; aus `decided == 2` einfach `true` abzuleiten wäre +ebenfalls unbelegt. + +### Ereignisse + +Jedes Ereignis enthält genau +`{kind, minute, side, player, other, detail}`. `side` ist `home` oder +`away`. `player` und `other` sind jeweils `{id, name}` oder `null`; +sie tragen keine nachträglich aus dem Kader ergänzten Werte. + +| `kind` | Bedeutung von Spieler und Zusatzangaben | +|---|---| +| `goal` | Torschütze, ggf. Vorlagengeber unter `other`; `detail` bezeichnet die Torart. | +| `miss` | Schütze, ggf. Zuspieler unter `other`; gleiche Detailarten wie beim Tor. | +| `yellow` | Verwarnter Spieler. | +| `second_yellow` | Spieler mit Gelb-Rot. | +| `red` | Spieler mit direkter Roter Karte. | +| `injury` | Verletzter Spieler. | +| `substitution` | `player` kommt ein, `other` geht aus; unbekannte Beteiligte bleiben `null`. | +| `shootout` | Schütze eines einzelnen Versuchs; `detail: 1` getroffen, `detail: 0` verfehlt. | + +Bei Tor und Fehlschuss bedeutet `detail: 0` Spiel, `1` +Elfmeter/Freistoß, `2` Nachschuss und `3` Ecke. Die gemeinsame Kategorie +Elfmeter/Freistoß wird nicht willkürlich in zwei Ursprünge aufgeteilt. +Die übrigen Ereignisarten verwenden in der Demo `detail: 0`. + +Spielereignisse tragen Minuten ab 1, in der Verlängerung bis 120. +Shootout-Ereignisse verwenden symbolisch Minute 121. Die ursprüngliche +Arrayfolge ist bei gleicher Minute maßgeblich; insbesondere dürfen +Shootoutversuche nicht nach Spieler, Seite oder Trefferstatus umsortiert +werden. Die Anzeige sortiert Minuten stabil und nummeriert alle Versuche +einschließlich Fehlversuchen fortlaufend. + +### Null, Nullwert und Validierung + +`0` ist ein bekannter Wert, etwa keine Zuschauer, null Grad oder kein +Regen. `null` bedeutet fehlende Information. Leere Aufstellung, fehlender +Spieler und Computersteuerung dürfen nicht über numerische Null oder +den ersten Eintrag einer Tabelle erraten werden. Fehlende Namen und +Metadaten erscheinen neutral; ein fehlender Kader erhält keine erfundene +Startelf. + +`valid_demo_almanac()` prüft den vollständigen Demoaufbau, eindeutige +Match-IDs, Ergebnis- und Ereigniskonsistenz, gültige Referenzen innerhalb +bekannter Aufstellungen, genau eine bekannte Torwartposition bei +vollständig bekannten Startpositionen, Wechsel, Platzverweise und die +Vollständigkeit eines entscheidenden Shootouts. Die Demoereignisse sind +vollständig und stimmen mit den Spieltoren überein. Dieser Validator ist +kein Ersatz für einen künftigen Adapter mit ausdrücklich unvollständigen +Engineaufzeichnungen; dort dürfen fehlende Phasen nicht durch erfundene +Ereignisse passend gemacht werden. + +## Spätere Modern-Sessionprojektion und F10 + +Grundlage bleiben +[almanach.md](../../../new_engine/almanach.md) und +[almanac.hpp](../../../../src/modern/game/almanac.hpp). F10 enthält bereits +historische Saison-, Vereins-, Spieler-, Manager- und +Schiedsrichtertabellen, Aufstellungen, Zuschauer, Wetter und acht +Ereignisarten. Die Phasenlücke beim Ergebnis bedeutet nicht, dass F10 +insgesamt nur einen Endstand und ein Ereignisprotokoll speichern würde. + +Der spätere Adapter gehört an die konstante Leseseite der Modern-Session. +Er soll nur benötigte Saisons bei Bedarf dekodieren und historische +Tabellen in UI-Records auflösen. Renderer und Navigation bleiben +unabhängig von OBS, Binärdekodierung und laufenden Engineobjekten. +Abgeschlossene Archive müssen dafür nicht in jeden GUI-Snapshot kopiert +werden. Dieses Paket implementiert oder verändert diesen Adapter nicht. + +Die fachliche Zuordnung für den späteren Adapter ist: + +| Engine-/F10-Quelle | Normalisiertes UI-Feld | +|---|---| +| Saisonkopf und ursprünglicher Matchordinal | Stabile `id` und Saisonbeschriftung `season`. | +| `date`, `display_start_year`, `almanac_date()` | ISO-Kalendertag `date`; daraus Kalenderjahr und Cutoff. | +| `type`, `league`, `stage`, `round` sowie verfügbare Wettbewerbsmetadaten | `competition` und `round`; Ligakennung und Pokalstufe sind keine austauschbaren Indizes. | +| Saison-Clubtabelle und `home`/`away` | Historische Vereins-IDs und Namen unter `home`/`away`; Bildreferenzen sind keine historischen F10-Bildbytes. | +| `home_manager`/`away_manager` und Managertabelle | Historische menschliche Manager; gesichert `-1` bezeichnet Computer. | +| `home_goals`/`away_goals` | `result.final`, ohne Shootouttore. | +| `home_shootout`/`away_shootout`, `decided` | Separates `result.penalties` und bekannte Entscheidungsart; keine pauschale ET-Ableitung. | +| Vollständige Torereignisse und gesicherte Phaseninformation | Soweit belegt `result.regulation` und zusätzliche Tore unter `result.extra`. | +| Schiedsrichterreferenz, Zuschauer, Temperatur und Regen | `referee`, `attendance`, `weather`, nach Referenz- und Bekanntheitsprüfung. | +| Aufstellungsvektor und saisonale Spielertabelle | Historische Spieleridentitäten und Namen; `starters`/`bench` nur bei belegbarer Trennung. | +| `AlmanacEvent` und seine historischen Spielerreferenzen | Die acht `events.kind`-Werte, Minute, Seite, Spieler, zweiter Spieler und Detail. | + +Die konkrete Gap-Liste für diese spätere Integration lautet: + +1. **Ergebnisphasen:** `AlmanacMatch.home_goals/away_goals` enthalten den + Spielendstand ohne Shootout; separate Shootouttore sind vorhanden. + Ein eigener 90-Minuten-Stand und ein ausdrückliches ET-Kennzeichen + fehlen im Fall `decided == 2`. Reguläre Tore und zusätzliche + Verlängerungstore dürfen nur bei gesichert vollständigen Daten aus + Torereignissen und Endstand abgeleitet werden. Fehlen solche Daten, + bleiben Teilstände unbekannt. Aus Shootout oder `decided == 2` allein + darf niemals pauschal auf eine gespielte Verlängerung geschlossen werden. +2. **Matchidentität:** Ein eigenes stabiles Match-ID-Feld fehlt. + Saisonkennung plus ursprünglicher Matchordinal kann den stabilen + Projektionsschlüssel bilden. Eine aktuelle Sortier- oder Zeilennummer + reicht nicht. Die Demo verwendet entsprechend + `demo:almanac::`. +3. **Historische Namensstände:** Die Tabellen werden pro Saison geführt. + Vereine und Spieler werden beim ersten Eintrag ihrer stabilen ID + aufgenommen; Namen werden nicht für jeden einzelnen Matchtag erneut + eingefroren. Diese historischen Tabellen sind maßgeblich und dürfen + nicht durch heutige Kadernamen ersetzt werden. +4. **Spielerattribute:** F10-Spieler enthalten ID, Vorname, Nachname und + Nation, keine archivierte Rückennummer, Position oder Stärke. + Optionale Demo-Positionen stammen aus dem POC-Aufbau und sind keine + vorgeblich aus F10 gelesenen Daten. +5. **Startelf und Bank:** Der Enginevektor bedeutet nominell elf Starter, + anschließend Bank. Der Recorder überspringt jedoch leere Plätze. + Bei unvollständiger Startelf mit Bank kann die Grenze im Vektor allein + mehrdeutig sein. Kader von Länder- und Amateurteams fehlen ausdrücklich. + Die UI darf aus dieser Unsicherheit keine erfundene Elf konstruieren; + das normalisierte DTO trennt beide Bereiche ausdrücklich. +6. **Ereignisbedeutung:** `Goal.detail == 1` kombiniert Elfmeter/Freistoß; + `0`, `2`, `3` stehen für Spiel, Nachschuss und Ecke. + `Substitution.player` bezeichnet Ein, `other` Aus. + `kAlmanacNone == 0xffff` ist ein fehlender Verweis, kein Spieler an + Tabellenposition 0. +7. **Shootoutfolge:** Mehrere Versuche teilen typischerweise Minute 121. + Ihre ursprüngliche Arrayreihenfolge muss erhalten bleiben; jeder + Treffer und Fehlversuch zählt. Ein gesondertes Zeit- oder Sequenzfeld + für diese Kicks existiert nicht. +8. **Fehlende Rohwerte:** Manche Raw-Standardwerte unterscheiden eine + fehlende Angabe nicht von einer gültigen Null, etwa bei Zuschauern, + Temperatur und Regen. Der Adapter braucht gesichert bekannte Werte + oder `null`, keine Heuristik „0 bedeutet unbekannt“. Schiedsrichterindex + 0 bezeichnet keinen ausgewählten Schiedsrichter. +9. **Referenzgrenzen:** Die Binärdekodierung prüft nicht jeden Spieler-, + Manager- oder Schiedsrichterindex. Der Adapter muss Grenzen prüfen und + unbekannte Referenzen neutral behandeln. Ein ungültiger menschlicher + Managerindex darf nicht unbemerkt als Computersteuerung erscheinen. +10. **Datumdomäne:** Datum ist aus Tageszähler und `display_start_year` + über `almanac_date()` zu übertragen. Ein Saisonstartjahr ist kein + Kalenderjahrfilter. Engine- und Schreibtischdatum müssen deshalb + ausdrücklich in die Kalenderdatumdomäne der UI übersetzt werden. + +Die Wappenfrage bleibt daneben eine gesonderte Darstellungsgrenze: +Assetreferenzen sind vorhanden, historische Bildbytes sind durch den +vorliegenden Vertrag nicht belegt. Weder Namen noch Positions- oder +Bildlücken rechtfertigen einen stillen Zugriff des Renderers auf heutige +Spielwerte oder einen behaupteten vollständigen historischen Bildstand. diff --git a/docs/new_ui/desktop/almanac/README.md b/docs/new_ui/desktop/almanac/README.md new file mode 100644 index 0000000..8182716 --- /dev/null +++ b/docs/new_ui/desktop/almanac/README.md @@ -0,0 +1,147 @@ +# Fußball-Almanach · native Modern UI + +Stand: 24. Oktober 2026. Das Paket ergänzt einen eigenständigen Almanach +mit fiktiven historischen Spielen. Die private HTML-Referenz sind die mit diesem Paket eingeführten Dateien +`desktop/almanac-menu.js` und `desktop/almanac-window.css` auf Basis von +`13e44980540d9dbecaf9e667aec03cbe3fbfb3f0`. Diese Basisrevision allein +enthält das neue Menü noch nicht. Die HTML-Studie und die native +RmlUI-Umsetzung verwenden denselben normalisierten +[Datenvertrag](DATA_CONTRACT.md), bleiben aber getrennte Frontends. +Private Referenzbilder und Weltdaten gehören nicht in dieses Repository. + +Native Quellen sind +[almanac_screens.inc](../../../../src/modern/ui/almanac_screens.inc), +[almanac_controls.inc](../../../../src/modern/ui/almanac_controls.inc), +[almanac.rcss](../../../../assets/modern/almanac.rcss), +[demo_almanac.hpp](../../../../src/modern/ui/demo_almanac.hpp) und +[demo_almanac.cpp](../../../../src/modern/ui/demo_almanac.cpp). + +## Drei Ansichtsebenen + +Das Desktop-Icon „Almanach“ öffnet zunächst den **Jahreskalender**. +Anders als der Saisonkalender zeigt er Januar bis Dezember desselben +Kalenderjahres. Zwölf Monatskarten stehen in vier Spalten und drei Reihen; +innerhalb der Karte stehen Wochentage in sieben Zeilen und Wochen in +sechs Datumsspalten. Monate mit 28, 29, 30 oder 31 Tagen behalten ihre +wirkliche Wochentagslage. Der Jahresschalter bietet nur Kalenderjahre mit +bereits sichtbaren Archivspielen an. Beim ersten Öffnen wird das jüngste +solche Jahr gewählt. + +Nur Tage mit gespielten Partien sind Schaltflächen. Ihr zugänglicher Name +nennt das Datum und die Anzahl der Partien. Andere Tage bleiben reine +Datumsbeschriftungen; zukünftige Tage erscheinen zusätzlich gedämpft. +Die Jahre werden aus vorhandenen Datensätzen ermittelt, nicht aus einer +festgeschriebenen Liste. Ein leeres Archiv zeigt einen verständlichen +Leerzustand; eine nicht unterstützte Datenquelle meldet die fehlende +Verfügbarkeit. + +Ein Datum öffnet die **Tagespaarungen** mit allen Partien dieses Tages. +Die gesamte Paarungszeile ist anklickbar. Heimname und Wappen stehen links, +Gastwappen und Name rechts vom mittigen Ergebnis. Darunter stehen +Wettbewerb, Spieltag beziehungsweise Runde und Saison. Eine Entscheidung +nach Verlängerung trägt „n. V.“, ein Elfmeterschießen „i. E.“. Bei letzterem +zeigt die Paarungszeile das separate Ergebnis des Elfmeterschießens. + +Die Paarungszeile führt unmittelbar in den **Spielbericht**, ohne +zusätzlichen Informationsdialog oder aktuelles Vereinsprofil. Der Kopf +zeigt die archivierten Vereinsnamen, Wappenreferenzen, menschlichen +Manager beziehungsweise „Computer“ und den Spielendstand ohne +Elfmeterschießen. Reguläre Spielzeit, zusätzliche Verlängerungstore und +Elfmeterschießen stehen getrennt darunter. Beispiel: regulär `1 : 1`, +Verlängerung `1 : 1`, Spielendstand `2 : 2`, Elfmeterschießen `4 : 3`. +`result.extra` enthält ausschließlich die in der Verlängerung zusätzlich +gefallenen Tore. + +Schiedsrichter, Zuschauer, Temperatur und Regen gehören ebenfalls zum +Spielbericht. Die beiden Reiter **Aufstellungen** und **Ereignisse** +wechseln den darunterliegenden Inhalt. Aufstellungen zeigen beide Seiten +mit Startelf und der gesamten überlieferten Bank. Die angezeigten +Laufnummern sind Zeilenpositionen, keine behaupteten historischen +Rückennummern. Fehlende Aufstellungen heißen „Keine Aufstellung +überliefert.“; fehlende Einzelangaben erscheinen als „—“. Eine bekannte +Null bleibt dagegen sichtbar, etwa `0` Zuschauer, `0 °C` oder `0 / 7` Regen. + +Die Ereignisliste enthält Tor, Fehlschuss, Gelb, Gelb-Rot, Rot, +Verletzung, Wechsel und jeden Versuch des Elfmeterschießens. Tore und +Fehlschüsse nennen Spieler, Vorlage beziehungsweise Zuspiel und die Art +Spiel, Elfmeter/Freistoß, Nachschuss oder Ecke. Beim Wechsel stehen Ein- +und Auswechslung ausdrücklich getrennt. Im Elfmeterschießen bleiben +Treffer und Fehlversuche einzeln sichtbar. Ereignisse derselben Minute +behalten ihre ursprüngliche Reihenfolge; die symbolische Minute 121 wird +als fortlaufender Versuch „i. E.“ angezeigt. + +„Zurück“ und Escape führen vom Spielbericht zu den Tagespaarungen, von +dort zum Jahreskalender und schließlich zum Desktop. Der Fokus kehrt +jeweils zur aufrufenden Zeile, zum Datum oder zum Desktop-Icon zurück. +Escape schließt zuerst eine offene Jahresauswahl. Jahreswechsel setzen +Tag und Spielbericht zurück. Die aktive Registerkarte wird beim Öffnen +eines anderen Spielberichts wieder auf „Aufstellungen“ gesetzt. + +## Präsentationsquelle und Speicherung + +[DataSource::read_almanac()](../../../../src/modern/ui/model.hpp) ist eine +konstante Leseoperation. Die Standardimplementierung meldet +`almanac_unavailable`. `DemoSource` besitzt ein unveränderliches +Pseudoarchiv außerhalb von `Snapshot.state` und den UI-Demoständen. +Alle Abfragen verwenden das gespeicherte Demodatum als `as_of`: Sichtbar +sind ausschließlich Spiele bis einschließlich dieses Tages. Auch eine +direkte Abfrage einer bekannten zukünftigen Match-ID liefert keinen +Datensatz. + +Jahr, Tag, Match-ID, Registerkarte und Jahresauswahl sind nur flüchtige +Felder der App. Navigation ruft weder `Source.apply()` auf noch erhöht +sie die Revision oder setzt den Spielstand auf geändert. Sie verändert +keine Finanzen, Manager, Kader oder Zufallsströme. Das Archiv wird beim +Speichern nicht in jeden Snapshot oder UI-Checkpoint kopiert. + +Die Demo erzeugt zwölf Spiele aus zwei abgeschlossenen Saisons vor der +Saison von `manifest.start_date`; ohne dieses Feld gilt `2026-07-01` als +Demoausgangspunkt. Das ergibt drei Kalenderjahre mit mehreren Partien an +einem Tag, regulären Ergebnissen, Verlängerung und einem vollständigen +Elfmeterschießen. Vereins- und Spielernamen werden beim Aufbau aus dem +Katalog kopiert. Namen werden danach nicht aus dem aktuellen Kader neu +ermittelt. Fehlende Kader werden nicht durch erfundene Spieler ersetzt. +Die HTML-Studie verwendet eigene Pseudokader; deren Namen und Werte sind +keine zusätzlichen OBW-Daten. + +Das neue Desktop-Objekt heißt `app-almanac`. Ein mitgeliefertes SVG-Icon +und die GUI-Ressourcenaufbereitung machen es unabhängig von zusätzlichen +Weltbildern verfügbar. `migrate_desktop()` ergänzt bei älteren gültigen +Layouts das fehlende Icon an einem freien Platz. Vorhandene Objekte +bleiben unverändert. Beschädigte bestehende Layoutdaten werden atomar +abgewiesen und nicht teilweise repariert. Gespeichert wird weiterhin nur +das Desktop-Layout, nicht die Almanachnavigation oder das Pseudoarchiv. + +## Enginegrenze und Prüfstand + +Der Renderer liest ausschließlich die Projektion über die Datenquelle. +Er öffnet keine `.obs`-Datei, dekodiert kein F10 und greift nicht auf +`ModernState` oder die laufende Session zu. Der vorhandene +[Engine-Almanach](../../../new_engine/almanach.md) und sein Speicherformat +bleiben durch dieses UI-Paket unverändert. Eine spätere konstante +Modern-Sessionprojektion soll benötigte Saisons bei Bedarf dekodieren und +dieselben Ansichten liefern. Die konkreten F10-Grenzen und die Regeln für +unbekannte Werte stehen im [Datenvertrag](DATA_CONTRACT.md). + +Für das integrierte Paket sind 19 automatische Tests grün. Dazu gehören +die neuen synthetischen Providerprüfungen sowie Source-, Core- und +Desktopmigrationstests. Geprüft sind unter anderem Cutoff und leeres +Archiv, historische Namen, getrennte Ergebnisphasen, Aufstellung und Bank, +Ereignisse und Shootout, ungültige Eingaben sowie unveränderte Snapshots, +Revisionen und Änderungsmarkierungen bei Leseabfragen. + +Die unabhängige native Laufzeitprüfung besteht: sechs Matrixläufe in drei +Themes bei 720p/1080p mit 96 dokumentierten Zuständen, gezielte Text-/Icon- +Nachaufnahmen, 25 Navigations-/Cutoff-/Dirty-Zustände und fünf Fokusproben. +Beide 20er-Kader sind bis zum Bankende erreichbar, ebenso alle zehn +Shootoutversuche. Die Archivnavigation verändert weder Revision noch Daten +oder vorhandene Dirty-Markierungen. Altansichten werden additiv migriert; +reines Blättern löst beim Beenden keine Speichernachfrage aus. + +Die HTML-Prüfung ergänzt leeres Archiv, heute/zukünftig, unbekannte Menschen, +Nullwerte sowie direktes Elfmeterschießen ohne Verlängerung. Diese Sonderfälle +sind im nativen Renderer zusätzlich quellgeprüft; native Standard-, ET-, PK- +und Fehlwertfälle wurden tatsächlich bedient. Bilder, Skripte, Inputs und +Checkpoints liegen privat unter `bmh_4k_ui/docs/qa/almanac-2026-10-24/`. +Die Belege betreffen Linux/OpenGL und Browser, keine vollständige native +Windows-/macOS-Abnahme. Eine F10-/OBS-Anbindung ist weiterhin nicht enthalten. diff --git a/docs/new_ui/menu-qa.md b/docs/new_ui/menu-qa.md index 01d5e7e..b7e2e9d 100644 --- a/docs/new_ui/menu-qa.md +++ b/docs/new_ui/menu-qa.md @@ -72,3 +72,8 @@ deshalb nicht ins öffentliche Quellcode-Repository. Öffentliche Zusammenfassun [Hallentabellen](desktop/indoor/README.md): ein gemeinsames Paket mit 18 Rendererläufen, 43 Bedienzuständen und gesondertem OS-Beenden-/ Speichern-Nachtest. Aktueller Gesamtkatalog: 18 native und 18 offene Routen. + +- [Almanach](desktop/almanac/README.md): Jahreskalender, Tagespartien und + Spielbericht als neues readonly Menü; alle Ergebnisphasen, Kader/Bank, + Ereignisse, alte Ansichten und unveränderte Revision/Dirty-Zustände geprüft. + Der Katalog umfasst jetzt 19 native und 18 offene Routen. diff --git a/docs/new_ui/qa-findings.md b/docs/new_ui/qa-findings.md index 056a6c5..181f473 100644 --- a/docs/new_ui/qa-findings.md +++ b/docs/new_ui/qa-findings.md @@ -32,7 +32,7 @@ gemeinsamen Controländerungen zusätzlich in mehreren Menüs nachgeprüft. Die erste Gesamterfassung enthält 36 Routen, davon zwölf native Aufnahmen und 24 ausstehende Ports. Diese historische Matrix bleibt unverändert. Der anschließend übertragene Kalender bekommt einen eigenen Vergleich; -der aktuelle Runner erfasst 18 native Routen und 18 offene Ports. +der aktuelle Runner erfasst 19 native Routen und 18 offene Ports. Spätere Meilensteine erfassen denselben Gesamtkatalog erneut. Siehe [QA-Ablauf](menu-qa.md), [Typografie](typography-qa.md) und diff --git a/src/modern/ui/CMakeLists.txt b/src/modern/ui/CMakeLists.txt index 9b978e4..11db434 100644 --- a/src/modern/ui/CMakeLists.txt +++ b/src/modern/ui/CMakeLists.txt @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-3.0-only -add_library(bmh_modern_ui_core STATIC catalog.cpp model.cpp gui_assets.cpp desktop.cpp demo_sports.cpp demo_calendar.cpp demo_reports.cpp) +add_library(bmh_modern_ui_core STATIC catalog.cpp model.cpp gui_assets.cpp desktop.cpp demo_sports.cpp demo_calendar.cpp demo_reports.cpp demo_almanac.cpp) target_include_directories(bmh_modern_ui_core PUBLIC ../..) target_link_libraries(bmh_modern_ui_core PUBLIC bmh_asset_io) add_library(bmh_modern_ui STATIC view.cpp ticket_popover.cpp) @@ -14,7 +14,7 @@ endif() set(modern_assets "${CMAKE_BINARY_DIR}/assets/modern") FetchContent_GetProperties(rmlui) file(MAKE_DIRECTORY "${modern_assets}") -foreach(asset modern.rml theme.rcss ticket.rcss sports.rcss calendar.rcss reports.rcss report_details.rcss report_pickers.rcss indoor.rcss planning.rcss) +foreach(asset modern.rml theme.rcss ticket.rcss sports.rcss calendar.rcss reports.rcss report_details.rcss report_pickers.rcss indoor.rcss planning.rcss almanac.rcss) configure_file("${CMAKE_SOURCE_DIR}/assets/modern/${asset}" "${modern_assets}/${asset}" COPYONLY) endforeach() file(GLOB modern_icons CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/assets/modern/icons/*.svg") @@ -47,6 +47,12 @@ if(MSVC) target_compile_options(modern_planning_tests PRIVATE /utf-8) endif() add_test(NAME modern_planning_tests COMMAND modern_planning_tests) +add_executable(modern_almanac_ui_tests ../../../tests/modern_almanac_ui_tests.cpp) +target_link_libraries(modern_almanac_ui_tests PRIVATE bmh_modern_ui_core) +if(MSVC) + target_compile_options(modern_almanac_ui_tests PRIVATE /utf-8) +endif() +add_test(NAME modern_almanac_ui_tests COMMAND modern_almanac_ui_tests) add_executable(modern_reports_tests ../../../tests/modern_reports_tests.cpp) target_link_libraries(modern_reports_tests PRIVATE bmh_modern_ui_core) if(MSVC) diff --git a/src/modern/ui/almanac_controls.inc b/src/modern/ui/almanac_controls.inc new file mode 100644 index 0000000..13d2aae --- /dev/null +++ b/src/modern/ui/almanac_controls.inc @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: GPL-3.0-only +bool App::almanac_action(const std::string &action, Rml::Element *target) { + if (!action.starts_with("alm-")) return false; + if (menu_ != "almanac" || !source_) return true; + const auto id = target ? target->GetAttribute("data-id", "") : ""; + if (action == "alm-year-cancel" || (action == "alm-back" && report_picker_ == "year")) { + close_report_picker(true); + return true; + } + if (action == "alm-back") { + if (!almanac_match_.empty()) { + focus_after_render_ = "alm-match-" + almanac_match_; + almanac_match_.clear(); + } else if (!almanac_day_.empty()) { + focus_after_render_ = "alm-day-" + almanac_day_; + almanac_day_.clear(); + } else { + menu_.clear(); + focus_after_render_ = "object-app-almanac"; + } + } else if (action == "alm-day") { + const auto result = source_->read_almanac({{"kind", "day"}, {"date", id}}); + if (!result.value("ok", false) || result.at("matches").empty()) return true; + almanac_day_ = id; + almanac_match_.clear(); + focus_after_render_ = "alm-heading"; + } else if (action == "alm-match") { + const auto result = source_->read_almanac({{"kind", "match"}, {"id", id}}); + if (!result.value("ok", false) || result.at("match").at("date") != almanac_day_) return true; + almanac_match_ = id; + almanac_tab_ = "lineups"; + focus_after_render_ = "alm-heading"; + } else if (action == "alm-tab") { + if (almanac_match_.empty() || (id != "lineups" && id != "events")) return true; + almanac_tab_ = id; + focus_after_render_ = "alm-tab-" + id; + } else return false; + close_report_picker(false); + refresh(); + return true; +} diff --git a/src/modern/ui/almanac_screens.inc b/src/modern/ui/almanac_screens.inc new file mode 100644 index 0000000..554c5a7 --- /dev/null +++ b/src/modern/ui/almanac_screens.inc @@ -0,0 +1,392 @@ +// SPDX-License-Identifier: GPL-3.0-only +namespace { +const Json &almanac_field(const Json &object, const char *key) { + static const Json absent; + if (object.is_object()) { + const auto found = object.find(key); + if (found != object.end()) + return *found; + } + return absent; +} +std::string almanac_text(const Json &value, const std::string &fallback = "—") { + return value.is_string() && !value.get_ref().empty() + ? value.get() : fallback; +} +std::string almanac_name(const Json &person) { + return almanac_text(almanac_field(person, "name")); +} +bool almanac_flag(const Json &object, const char *key) { + const auto &value = almanac_field(object, key); + return value.is_boolean() && value.get(); +} +std::string almanac_number(const Json &value) { + return value.is_number_integer() ? number(value.get()) : "—"; +} +std::string almanac_score(const Json &value) { + return value.is_array() && value.size() == 2 && + value[0].is_number_integer() && value[1].is_number_integer() + ? std::to_string(value[0].get()) + " : " + + std::to_string(value[1].get()) : "—"; +} +std::optional> almanac_date_parts(const Json &value) { + if (!value.is_string()) + return {}; + const auto text = value.get(); + if (text.size() != 10 || text[4] != '-' || text[7] != '-') + return {}; + for (size_t i = 0; i < text.size(); ++i) + if (i != 4 && i != 7 && (text[i] < '0' || text[i] > '9')) + return {}; + const std::array date = {std::stoi(text.substr(0, 4)), + std::stoi(text.substr(5, 2)), + std::stoi(text.substr(8, 2))}; + if (!std::chrono::year_month_day{std::chrono::year{date[0]}, + std::chrono::month{unsigned(date[1])}, + std::chrono::day{unsigned(date[2])}}.ok()) + return {}; + return date; +} +const std::array almanac_months = { + "Januar", "Februar", "März", "April", "Mai", "Juni", + "Juli", "August", "September", "Oktober", "November", "Dezember"}; +std::string almanac_date_label(const Json &value) { + const auto date = almanac_date_parts(value); + return date ? std::to_string((*date)[2]) + ". " + + almanac_months[size_t((*date)[1] - 1)] + " " + + std::to_string((*date)[0]) : "—"; +} +std::string almanac_iso(int year, int month, int day) { + std::ostringstream out; + out << std::setfill('0') << std::setw(4) << year << '-' << std::setw(2) + << month << '-' << std::setw(2) << day; + return out.str(); +} +std::string almanac_position(const Json &player) { + const auto value = almanac_text(almanac_field(player, "position")); + return value == "gk" ? "TW" : value == "def" ? "ABW" + : value == "mid" ? "MIT" : value == "fwd" ? "STU" : value; +} +std::string almanac_competition_label(const Json &record) { + const auto &competition = almanac_field(record, "competition"); + return almanac_name(competition) + " · " + + almanac_number(almanac_field(record, "round")) + ". " + + (almanac_text(almanac_field(competition, "type"), "") == "league" + ? "Spieltag" : "Runde"); +} +std::string almanac_event_kind(const std::string &kind) { + if (kind == "goal") return "Tor"; + if (kind == "miss") return "Fehlschuss"; + if (kind == "yellow") return "Gelbe Karte"; + if (kind == "second_yellow") return "Gelb-Rote Karte"; + if (kind == "red") return "Rote Karte"; + if (kind == "injury") return "Verletzung"; + if (kind == "substitution") return "Wechsel"; + if (kind == "shootout") return "Elfmeterschießen"; + return "Ereignis"; +} +} // namespace + +std::string App::render_almanac() { + const auto query = [&](const Json &request) -> Json { + try { + return source_ ? source_->read_almanac(request) + : Json{{"ok", false}, {"error", "almanac_unavailable"}}; + } catch (const std::exception &) { + return {{"ok", false}, {"error", "almanac_unavailable"}}; + } + }; + const auto index = query({{"kind", "index"}}); + const bool available = almanac_flag(index, "ok"); + std::vector years; + const auto &year_values = almanac_field(index, "years"); + if (available && year_values.is_array()) + for (const auto &value : year_values) + if (value.is_number_integer() && value >= 1 && value <= 9999) + years.push_back(value.get()); + std::sort(years.begin(), years.end()); + years.erase(std::unique(years.begin(), years.end()), years.end()); + const auto snapshot = snap(); + const auto &reference = almanac_field(snapshot.state, "date"); + const auto date = almanac_date_parts(reference); + if (almanac_year_ == 0 || + std::find(years.begin(), years.end(), almanac_year_) == years.end()) { + almanac_year_ = years.empty() ? (date ? (*date)[0] : 0) : years.back(); + almanac_day_.clear(); + almanac_match_.clear(); + almanac_tab_ = "lineups"; + } + if (almanac_tab_ != "lineups" && almanac_tab_ != "events") + almanac_tab_ = "lineups"; + if (!almanac_day_.empty()) { + const auto selected = almanac_date_parts(almanac_day_); + if (!selected || (*selected)[0] != almanac_year_) { + almanac_day_.clear(); + almanac_match_.clear(); + } + } + Json record; + if (!almanac_match_.empty()) { + const auto response = query({{"kind", "match"}, {"id", almanac_match_}}); + if (almanac_flag(response, "ok") && almanac_field(response, "match").is_object()) + record = response.at("match"); + else { + almanac_match_.clear(); + almanac_tab_ = "lineups"; + } + } + const bool detail = record.is_object(), day_view = !almanac_day_.empty(); + const auto title = detail ? almanac_competition_label(record) + : day_view ? almanac_date_label(almanac_day_) + : "Spielarchiv" + (almanac_year_ ? " · " + std::to_string(almanac_year_) : ""); + const auto crest_image = [&](const Json &team, double size) { + const auto &key = almanac_field(team, "crest"); + return "
" + + (key.is_string() && !key.get_ref().empty() + ? img(key.get(), size, size, true) + : "—") + "
"; + }; + const auto team_label = [&](const Json &team, bool home) { + const auto label = "" + esc(almanac_name(team)) + ""; + return "
" + (home ? label + crest_image(team, 42) + : crest_image(team, 42) + label) + "
"; + }; + std::string output = "
"; + + Json day_response; + if (!detail && day_view) { + day_response = query({{"kind", "day"}, {"date", almanac_day_}}); + output += "
" + "
Heim
" + "
Ergebnis
Auswärts
"; + const auto &matches = almanac_field(day_response, "matches"); + if (matches.is_array()) + for (size_t i = 0; i < matches.size(); ++i) { + const auto &match = matches[i], &result = almanac_field(match, "result"); + const auto id = almanac_text(almanac_field(match, "id"), ""); + const bool penalties = almanac_flag(result, "penalties_played"), extra = almanac_flag(result, "extra_played"); + const auto description = almanac_name(almanac_field(match, "home")) + " " + + almanac_score(almanac_field(result, "final")) + " " + + almanac_name(almanac_field(match, "away")) + " · Spielbericht öffnen"; + output += btn("alm-match", + "
" + + team_label(almanac_field(match, "home"), true) + "
" + "
" + + esc(almanac_score(almanac_field(result, penalties ? "penalties" : "final"))) + + "" + + (penalties ? "i. E." : extra ? "n. V." : "") + "
" + "
" + team_label(almanac_field(match, "away"), false) + + "
" + + esc(almanac_competition_label(match) + " · Saison " + + almanac_text(almanac_field(match, "season"))) + "
", + "alm-match-row " + std::string(i % 2 == 0 ? "striped" : ""), + "id=\"alm-match-" + esc(id) + "\" data-id=\"" + esc(id) + + "\" aria-label=\"" + esc(description) + "\""); + } + if (!matches.is_array() || matches.empty()) + output += "

Keine gespielten Partien an diesem Tag.

"; + output += "
"; + } else if (!detail) { + output += "
"; + Json days = Json::array(); + if (available && almanac_year_) { + const auto calendar = query({{"kind", "calendar"}, {"year", almanac_year_}}); + if (almanac_flag(calendar, "ok") && almanac_field(calendar, "days").is_array()) + days = calendar.at("days"); + } + constexpr double month_width = 635, month_height = 1550.0 / 3; + if (almanac_year_ >= 1 && almanac_year_ <= 9999) + for (int month = 1; month <= 12; ++month) { + const int column = (month - 1) % 4, row = (month - 1) / 4; + const auto first = std::chrono::year{almanac_year_} / std::chrono::month{unsigned(month)} / 1; + const int offset = int(std::chrono::weekday{std::chrono::sys_days{first}}.iso_encoding()) - 1; + const int count = int(unsigned(std::chrono::year_month_day{ + std::chrono::sys_days{std::chrono::year{almanac_year_} / + std::chrono::month{unsigned(month)} / std::chrono::last}}.day())); + constexpr double grid_width = 599; + const double grid_height = month_height - 86, cell_height = grid_height / 7; + constexpr double cell_width = (grid_width - 65) / 6; + output += "

" + almanac_months[size_t(month - 1)] + "

" + "
"; + const std::array weekdays = {"MO", "DI", "MI", "DO", "FR", "SA", "SO"}; + for (int weekday = 0; weekday < 7; ++weekday) { + output += "
" + weekdays[size_t(weekday)] + "
"; + for (int week = 0; week < 6; ++week) { + const int day = week * 7 + weekday - offset + 1; + if (day < 1 || day > count) + continue; + const auto iso = almanac_iso(almanac_year_, month, day); + const auto found = std::find_if(days.begin(), days.end(), [&](const auto &entry) { + return almanac_field(entry, "date") == iso; + }); + const bool played = found != days.end() && + almanac_field(*found, "count").is_number_integer() && + found->at("count").get() > 0; + const auto style = rect(65 + week * cell_width, weekday * cell_height, cell_width, cell_height); + const auto text = "" + std::to_string(day) + ""; + if (played) + output += btn("alm-day", text, "alm-day played", + "id=\"alm-day-" + iso + "\" data-id=\"" + iso + "\" style=\"" + style + + "\" aria-label=\"" + esc(almanac_date_label(iso) + ", " + + almanac_number(found->at("count")) + " gespielte Partien") + "\""); + else { + const bool future = reference.is_string() && iso > reference.get(); + output += "
" + text + "
"; + } + } + } + output += "
"; + } + else + output += "

Keine gespielten Partien im Archiv.

"; + output += "
"; + } else { + const auto &result = almanac_field(record, "result"), &weather = almanac_field(record, "weather"); + const bool extra = almanac_flag(result, "extra_played"), penalties = almanac_flag(result, "penalties_played"); + const auto phase = std::string(extra ? "Nach Verlängerung" : "Nach regulärer Spielzeit") + + (penalties ? " · Entscheidung i. E." : ""); + std::string phases = "Reguläre Zeit: " + almanac_score(almanac_field(result, "regulation")); + if (extra) phases += " · Verlängerung: " + almanac_score(almanac_field(result, "extra")); + if (penalties) phases += " · i. E.: " + almanac_score(almanac_field(result, "penalties")); + output += "
"; + const auto summary_team = [&](const char *side, const std::string &css) { + const auto &team = almanac_field(record, side), &manager = almanac_field(team, "manager"); + const auto manager_name = manager.is_null() ? std::string("Computer") : almanac_name(manager); + return "
" + crest_image(team, 80) + + "" + + esc(almanac_name(team)) + "Manager: " + + esc(manager_name) + "
"; + }; + output += summary_team("home", "home") + + "
" + + esc(almanac_score(almanac_field(result, "final"))) + + "" + esc(phase) + + "" + esc(phases) + "
" + + summary_team("away", "away") + "
"; + const std::vector> facts = { + {"Schiedsrichter", almanac_text(almanac_field(record, "referee"))}, + {"Zuschauer", almanac_number(almanac_field(record, "attendance"))}, + {"Temperatur", almanac_number(almanac_field(weather, "temperature")) + + (almanac_field(weather, "temperature").is_number_integer() ? " °C" : "")}, + {"Regen", almanac_number(almanac_field(weather, "rain")) + + (almanac_field(weather, "rain").is_number_integer() ? " / 7" : "")}}; + for (const auto &[label, value] : facts) + output += "
" + esc(label) + + "" + esc(value) + "
"; + output += "
"; + if (almanac_tab_ == "lineups") { + output += "
"; + for (const auto *side : {"home", "away"}) { + const auto &team = almanac_field(record, side), &lineup = almanac_field(almanac_field(record, "lineups"), side); + // Both roster headings read left-to-right. Pairing rows alone mirror the home label. + output += "
" + team_label(team, false) + "
"; + if (!lineup.is_object()) + output += "

Keine Aufstellung überliefert.

"; + else + for (const auto *part : {"starters", "bench"}) { + output += "

" + std::string(std::string_view(part) == "starters" ? "Startelf" : "Bank") + "

"; + const auto &players = almanac_field(lineup, part); + if (players.is_array()) + for (size_t i = 0; i < players.size(); ++i) { + const auto &player = players[i]; + output += "
" + + std::to_string(i + (std::string_view(part) == "starters" ? 1 : 12)) + + "" + esc(almanac_position(player)) + + "" + esc(almanac_name(player)) + "
"; + } + } + output += "
"; + } + output += "
"; + } else { + std::vector events; + const auto &source_events = almanac_field(record, "events"); + if (source_events.is_array()) + for (const auto &event : source_events) events.push_back(event); + std::stable_sort(events.begin(), events.end(), [](const Json &a, const Json &b) { + const auto &am = almanac_field(a, "minute"), &bm = almanac_field(b, "minute"); + return (am.is_number_integer() ? am.get() : 0) < + (bm.is_number_integer() ? bm.get() : 0); + }); + output += "
"; + int kick = 0; + const std::array goal_types = {"Spiel", "Elfmeter/Freistoß", "Nachschuss", "Ecke"}; + for (size_t i = 0; i < events.size(); ++i) { + const auto &event = events[i]; + const auto kind = almanac_text(almanac_field(event, "kind"), ""); + const auto side = almanac_text(almanac_field(event, "side"), ""); + const auto player = almanac_name(almanac_field(event, "player")); + const auto other = almanac_name(almanac_field(event, "other")); + const auto &value = almanac_field(event, "detail"); + const int detail_value = value.is_number_integer() ? value.get() : -1; + std::string description = player; + if (kind == "shootout") + description = std::string(detail_value == 1 ? "Treffer" : detail_value == 0 ? "Fehlversuch" : "—") + " · " + player; + else if (kind == "substitution") + description = "Ein: " + player + " · Aus: " + other; + else if (kind == "goal" || kind == "miss") + description = player + " · " + (kind == "miss" ? "Zuspiel" : "Vorlage") + ": " + other + + " · " + (detail_value >= 0 && detail_value < 4 ? goal_types[size_t(detail_value)] : "—"); + const auto minute = kind == "shootout" ? "i. E. · " + std::to_string(++kick) + : almanac_number(almanac_field(event, "minute")) + "′"; + const auto team = side == "home" || side == "away" + ? almanac_name(almanac_field(record, side.c_str())) : "—"; + output += "
" + esc(minute) + + "" + esc(team) + + "
" + + almanac_event_kind(kind) + "" + esc(description) + "
"; + } + if (events.empty()) + output += "

Keine Ereignisse überliefert.

"; + output += "
"; + } + output += "
"; + } + std::string footer; + if (detail) + footer = almanac_date_label(almanac_field(record, "date")) + " · Saison " + + almanac_text(almanac_field(record, "season")); + else if (day_view) { + const auto &matches = almanac_field(day_response, "matches"); + footer = std::to_string(matches.is_array() ? matches.size() : 0) + " gespielte Partien"; + } else if (!available) + footer = "Almanach derzeit nicht verfügbar."; + else if (years.empty()) + footer = "Keine gespielten Partien im Archiv"; + else + footer = almanac_number(almanac_field(index, "match_count")) + " Partien · " + + std::to_string(years.front()) + "–" + std::to_string(years.back()); + output += "
" + "Gespielte Partien
" + esc(footer) + "
"; + if (report_picker_ == "year") + output += btn("alm-year-cancel", "", "alm-picker-shield", "id=\"alm-year-shield\" aria-label=\"Jahresauswahl schließen\""); + return output + "
"; +} diff --git a/src/modern/ui/controls.inc b/src/modern/ui/controls.inc index 02b868a..099ba23 100644 --- a/src/modern/ui/controls.inc +++ b/src/modern/ui/controls.inc @@ -187,6 +187,32 @@ void App::ProcessEvent(Rml::Event &event) try { } } else if (report_detail_kind_.empty() && planning_dialog_.empty() && popup_.empty() && report_picker_event(event)) return; + if (menu_ == "almanac" && popup_.empty() && report_picker_.empty()) { + const auto key = type == "keydown" ? Rml::Input::KeyIdentifier(event.GetParameter("key_identifier", 0)) : Rml::Input::KI_UNKNOWN; + if (key == Rml::Input::KI_ESCAPE || (type == "mouseup" && event.GetParameter("button", 0) == 1)) { + almanac_action("alm-back", nullptr); + event.StopImmediatePropagation(); + return; + } + if (key == Rml::Input::KI_TAB && context_->GetFocusElement() && + context_->GetFocusElement()->GetId() == "alm-heading") { + auto *next = event.GetParameter("shift_key", 0) ? element("alm-back") + : !almanac_match_.empty() ? element("alm-tab-lineups") + : doc_->QuerySelector("#alm-day-list .alm-match-row"); + if (!next) next = element("alm-back"); + if (next) next->Focus(true); + event.StopImmediatePropagation(); + return; + } + if (type == "keydown" && !almanac_match_.empty() && event.GetTargetElement()->GetId().starts_with("alm-tab-") && + (key == Rml::Input::KI_LEFT || key == Rml::Input::KI_RIGHT || key == Rml::Input::KI_HOME || key == Rml::Input::KI_END)) { + almanac_tab_ = key == Rml::Input::KI_HOME ? "lineups" : key == Rml::Input::KI_END ? "events" : almanac_tab_ == "lineups" ? "events" : "lineups"; + focus_after_render_ = "alm-tab-" + almanac_tab_; + refresh(); + event.StopImmediatePropagation(); + return; + } + } if (menu_ == "friendlies" && planning_dialog_.empty() && popup_.empty() && snap().state.at("calendar").at("friendly_stage") == 1 && ((type == "keydown" && event.GetParameter("key_identifier", 0) == Rml::Input::KI_ESCAPE) || @@ -362,7 +388,8 @@ void App::ProcessEvent(Rml::Event &event) try { controls[size_t(next)]->Focus(true); if (controls[size_t(next)]->GetId().starts_with("report-detail-player-") || controls[size_t(next)]->GetId().starts_with("report-club-") || - controls[size_t(next)]->GetId().starts_with("friendly-opponent-")) + controls[size_t(next)]->GetId().starts_with("friendly-opponent-") || + controls[size_t(next)]->GetId().starts_with("alm-match-")) controls[size_t(next)]->ScrollIntoView( Rml::ScrollIntoViewOptions(Rml::ScrollAlignment::Nearest)); event.StopImmediatePropagation(); @@ -402,7 +429,7 @@ void App::ProcessEvent(Rml::Event &event) try { void App::dispatch(const std::string &action, Rml::Element *target) { const auto id = target ? target->GetAttribute("data-id", "") : std::string(); - if (planning_action(action, target) || indoor_action(action, target)) return; + if (almanac_action(action, target) || planning_action(action, target) || indoor_action(action, target)) return; if (report_detail_action(action, target)) { close_report_picker(false); return; @@ -589,8 +616,8 @@ void App::dispatch(const std::string &action, Rml::Element *target) { const auto file = user_dir() / "layouts" / editor::path(selections_["view"] + ".json"); auto next = Json::parse(editor::read_file(file)); - if (!valid_desktop(next)) - throw editor::Error("Ungültige Desktopansicht."); + if (!migrate_desktop(next)) + throw editor::Error("Ungültige Desktopansicht oder kein freier Platz für den Almanach."); undo_.push_back(desktop_); desktop_ = std::move(next); menu_.clear(); @@ -1013,7 +1040,7 @@ void App::dispatch(const std::string &action, Rml::Element *target) { } static const std::set available = { "tables", "strengths", "camp", "settings", - "save", "load", "training", "tactics", "calendar", "league", "other", "postpone", "friendlies", "indoor"}; + "save", "load", "training", "tactics", "calendar", "league", "other", "postpone", "friendlies", "indoor", "almanac"}; if (!available.contains(route)) { message("Diese native Ansicht wird im nächsten Menüpaket übertragen."); return; @@ -1393,6 +1420,10 @@ void App::script() { {"menu", menu_}, {"report_picker", report_picker_}, {"planning_dialog", planning_dialog_}, + {"source_revision", source_ ? Json(snap().revision) : Json()}, + {"game_dirty", source_ && source_->dirty()}, + {"desktop_dirty", desktop_ != saved_desktop_}, + {"almanac_view", {{"year", almanac_year_}, {"date", almanac_day_}, {"id", almanac_match_}, {"tab", almanac_tab_}}}, {"report_detail", {{"kind", report_detail_kind_}, {"club", report_detail_club_}, {"player", report_detail_player_}}}, diff --git a/src/modern/ui/demo_almanac.cpp b/src/modern/ui/demo_almanac.cpp new file mode 100644 index 0000000..41c6f4b --- /dev/null +++ b/src/modern/ui/demo_almanac.cpp @@ -0,0 +1,435 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "modern/ui/demo_almanac.hpp" +#include +#include +#include +#include +#include +#include +#include + +namespace bmh::modern_ui { +namespace { +bool keys(const Json &v, std::initializer_list required, + std::initializer_list optional = {}) { + if (!v.is_object()) return false; + std::set allowed; + for (auto *key : required) { + if (!v.contains(key)) return false; + allowed.emplace(key); + } + for (auto *key : optional) allowed.emplace(key); + for (const auto &entry : v.items()) + if (!allowed.contains(entry.key())) return false; + return true; +} +bool integer(const Json &v, int lo, int hi) { + if (v.is_number_unsigned()) + return hi >= 0 && v.get() <= uint64_t(hi) && + (lo <= 0 || v.get() >= uint64_t(lo)); + return v.is_number_integer() && v.get() >= lo && v.get() <= hi; +} +bool text(const Json &v, bool nonempty = true) { + return v.is_string() && (!nonempty || !v.get_ref().empty()); +} +bool date(const std::string &iso) { + if (iso.size() != 10 || iso[4] != '-' || iso[7] != '-') return false; + for (size_t i = 0; i < iso.size(); ++i) + if (i != 4 && i != 7 && (iso[i] < '0' || iso[i] > '9')) return false; + const auto y = std::stoi(iso.substr(0, 4)), m = std::stoi(iso.substr(5, 2)), + d = std::stoi(iso.substr(8, 2)); + return y >= 1 && std::chrono::year_month_day{std::chrono::year{y}, + std::chrono::month{unsigned(m)}, std::chrono::day{unsigned(d)}}.ok(); +} +std::string iso(int year, int month, int day) { + std::ostringstream out; + out.imbue(std::locale::classic()); + out << std::setfill('0') << std::setw(4) << year << '-' << std::setw(2) + << month << '-' << std::setw(2) << day; + return out.str(); +} +std::string season(int year) { + std::ostringstream out; + out.imbue(std::locale::classic()); + out << std::setfill('0') << std::setw(4) << year << '/' << std::setw(2) + << (year + 1) % 100; + return out.str(); +} +bool person(const Json &p, bool position = false) { + return keys(p, {"id", "name"}, position + ? std::initializer_list{"position"} + : std::initializer_list{}) && text(p.at("id")) && + text(p.at("name"), false) && (!p.contains("position") || text(p.at("position"))); +} +bool score(const Json &v) { + return v.is_array() && v.size() == 2 && integer(v[0], 0, 99) && integer(v[1], 0, 99); +} +std::string position(const Json &p) { + const auto found = p.find("positions"); + if (found == p.end() || !found->is_array()) return ""; + if (std::find(found->begin(), found->end(), "gk") != found->end()) return "gk"; + for (const auto &v : *found) + if (text(v)) return v.get(); + return ""; +} +Json snapshot_player(const Catalog &world, const Json &p) { + Json result = {{"id", p.at("id")}, {"name", world.name(p)}}; + const auto role = position(p); + if (!role.empty()) result["position"] = role; + return result; +} +Json lineup(const Catalog &world, const std::string &club) { + const auto players = world.squad(club); + const Json *keeper = nullptr; + std::vector outfield; + for (auto *p : players) { + if (position(*p) == "gk") { + if (!keeper) keeper = p; + } else outfield.push_back(p); + } + // A partial squad is missing information, never an invented starting XI. + if (!keeper || outfield.size() < 10) return nullptr; + Json starters = Json::array({snapshot_player(world, *keeper)}), bench = Json::array(); + std::set selected{keeper->at("id").get()}; + for (size_t i = 0; i < 10; ++i) { + starters.push_back(snapshot_player(world, *outfield[i])); + selected.emplace(outfield[i]->at("id").get()); + } + for (auto *p : players) + if (!selected.contains(p->at("id").get())) + bench.push_back(snapshot_player(world, *p)); + return {{"starters", starters}, {"bench", bench}}; +} +Json actor(const Json &team, int index, bool bench = false) { + if (team.is_null()) return nullptr; + const auto &players = team.at(bench ? "bench" : "starters"); + if (index < 0 || size_t(index) >= players.size()) return nullptr; + const auto &p = players.at(size_t(index)); + return {{"id", p.at("id")}, {"name", p.at("name")}}; +} +Json club_snapshot(const Catalog &world, const Json &club, int manager_index = -1) { + Json manager = nullptr; + if (manager_index >= 0) + manager = {{"id", "demo:almanac:manager:" + std::to_string(manager_index)}, + {"name", "Demo-Manager " + std::to_string(manager_index + 1)}}; + Json crest = nullptr; + if (club.contains("crest") && text(club.at("crest"))) crest = club.at("crest"); + return {{"id", club.at("id")}, {"name", world.name(club)}, + {"crest", crest}, {"manager", manager}}; +} +Json competition(const Catalog &world, const Json &home, const Json &away, bool cup) { + if (!cup && home.value("competition", "") == away.value("competition", "")) { + const auto *league = world.find("competitions", home.value("competition", "")); + if (league && league->value("type", "") == "league") + return {{"id", league->at("id")}, {"name", world.name(*league)}, {"type", "league"}}; + } + if (cup) + for (const auto &c : world.rows("competitions")) + if (c.value("type", "") == "cup") + return {{"id", c.at("id")}, {"name", world.name(c)}, {"type", "cup"}}; + return {{"id", cup ? "demo:competition:cup" : "demo:competition:friendly"}, + {"name", cup ? "Demo-Pokal" : "Demo-Freundschaftsspiel"}, + {"type", cup ? "cup" : "friendly"}}; +} +Json make_match(const Catalog &world, const Json &home, const Json &away, + int year, int ordinal) { + const std::array, 6> scores{{{3, 1}, {0, 0}, {2, 0}, + {2, 1}, {2, 2}, {1, 2}}}; + const auto [hg, ag] = scores[size_t(ordinal)]; + const bool extra = ordinal == 3 || ordinal == 4, shootout = ordinal == 4; + const auto day = ordinal < 3 ? iso(year, 8, 3) : ordinal == 3 ? iso(year, 12, 14) + : ordinal == 4 ? iso(year + 1, 2, 20) : iso(year + 1, 5, 18); + Json rosters = {{"home", lineup(world, home.at("id"))}, + {"away", lineup(world, away.at("id"))}}; + // Historical recording can be incomplete even when the current world has a squad. + if (ordinal == 5) rosters["away"] = nullptr; + Json events = Json::array(); + const auto event = [&](const char *kind, int minute, const char *side, int index, + int detail = 0, Json other = nullptr, bool bench = false) { + events.push_back({{"kind", kind}, {"minute", minute}, {"side", side}, + {"player", actor(rosters.at(side), index, bench)}, {"other", std::move(other)}, + {"detail", detail}}); + }; + if (ordinal == 0) { + event("miss", 6, "home", 1, 0); + event("goal", 9, "home", 1, 0, actor(rosters.at("home"), 3)); + event("goal", 18, "away", 1, 1); + event("yellow", 23, "home", 2); + event("miss", 25, "away", 3, 1); + event("miss", 41, "home", 4, 2); + event("injury", 49, "home", 5); + if (!rosters.at("home").is_null() && !rosters["home"]["bench"].empty()) + event("substitution", 50, "home", 0, 0, actor(rosters.at("home"), 5), true); + else if (rosters.at("home").is_null()) + event("substitution", 50, "home", -1); + event("goal", 61, "home", 2, 2); + event("red", 67, "away", 4); + event("second_yellow", 72, "home", 2); + event("miss", 79, "away", 6, 3); + event("goal", 82, "home", 3, 3); + } else if (ordinal == 1) { + event("miss", 27, "home", 1, 1); + event("yellow", 54, "away", 3); + } else if (ordinal == 2) { + event("goal", 29, "home", 2, 1); + event("goal", 76, "home", 3, 0); + } else if (extra) { + event("goal", 19, "home", 1, 0); + event("goal", 58, "away", 1, 3); + event("goal", 103, "home", 2, 2); + if (shootout) { + event("goal", 117, "away", 2, 1); + const std::array h{1, 1, 0, 1, 1}, a{1, 1, 0, 1, 0}; + for (int i = 0; i < 5; ++i) { + event("shootout", 121, "home", i + 1, h[size_t(i)]); + event("shootout", 121, "away", i + 1, a[size_t(i)]); + } + } + } else { + event("goal", 12, "away", 1, 0); + event("goal", 43, "home", 1, 3); + event("goal", 88, "away", 2, 2); + } + return {{"id", "demo:almanac:" + std::to_string(year) + ":" + std::to_string(ordinal)}, + {"date", day}, {"season", season(year)}, + {"competition", competition(world, home, away, extra)}, + {"round", ordinal + 1}, {"home", club_snapshot(world, home, ordinal == 0 ? 0 : -1)}, + {"away", club_snapshot(world, away, ordinal == 0 ? 1 : -1)}, + {"result", {{"regulation", extra ? Json::array({1, 1}) : Json::array({hg, ag})}, + {"extra", extra ? Json::array({hg - 1, ag - 1}) : Json(nullptr)}, + {"penalties", shootout ? Json::array({4, 3}) : Json(nullptr)}, + {"final", {hg, ag}}, {"extra_played", extra}, {"penalties_played", shootout}}}, + {"referee", ordinal == 5 ? Json(nullptr) : Json("Demo-Schiedsrichter " + std::to_string(ordinal % 3 + 1))}, + {"attendance", ordinal == 5 ? Json(nullptr) : Json(ordinal == 1 ? 0 : 14500 + ordinal * 3275)}, + {"weather", {{"temperature", ordinal == 5 ? Json(nullptr) : Json(ordinal == 1 ? 0 : ordinal == 4 ? 3 : 16 + ordinal)}, + {"rain", ordinal == 5 ? Json(nullptr) : Json(ordinal == 1 ? 0 : ordinal % 8)}}}, + {"lineups", rosters}, {"events", events}}; +} +bool valid_club(const Json &club) { + return keys(club, {"id", "name", "crest", "manager"}) && text(club.at("id")) && + text(club.at("name"), false) && (club.at("crest").is_null() || text(club.at("crest"))) && + (club.at("manager").is_null() || person(club.at("manager"))); +} +struct Roster { + bool known = false; + std::map names; + std::set active, bench, yellow, dismissed; +}; +bool valid_roster(const Json &value, Roster &out) { + if (value.is_null()) return true; + if (!keys(value, {"starters", "bench"}) || !value.at("starters").is_array() || + value.at("starters").size() != 11 || !value.at("bench").is_array()) return false; + out.known = true; + int keepers = 0, unknown_positions = 0; + for (const auto *key : {"starters", "bench"}) + for (const auto &p : value.at(key)) { + if (!person(p, true)) return false; + const auto id = p.at("id").get(); + if (!out.names.emplace(id, p.at("name").get()).second) return false; + if (std::string(key) == "starters") { + out.active.insert(id); + if (!p.contains("position")) ++unknown_positions; + if (p.value("position", "") == "gk") ++keepers; + } else out.bench.insert(id); + } + return keepers == 1 || (keepers == 0 && unknown_positions > 0); +} +bool valid_match(const Json &m) { + if (!keys(m, {"id", "date", "season", "competition", "round", "home", "away", + "result", "referee", "attendance", "weather", "lineups", "events"}) || + !text(m.at("id")) || !text(m.at("date")) || !date(m.at("date").get()) || + !text(m.at("season")) || !integer(m.at("round"), 1, 999) || + !valid_club(m.at("home")) || !valid_club(m.at("away")) || + m.at("home").at("id") == m.at("away").at("id")) return false; + const auto when = m.at("date").get(); + const int year = std::stoi(when.substr(0, 4)) - (when.substr(5, 2) < "07" ? 1 : 0); + if (year < 1 || m.at("season") != season(year)) return false; + const auto &c = m.at("competition"), &r = m.at("result"), &w = m.at("weather"); + if (!keys(c, {"id", "name", "type"}) || !text(c.at("id")) || !text(c.at("name"), false) || + !text(c.at("type")) || + !keys(r, {"regulation", "extra", "penalties", "final", "extra_played", "penalties_played"}) || + !score(r.at("final")) || !r.at("extra_played").is_boolean() || + !r.at("penalties_played").is_boolean() || + !(r.at("regulation").is_null() || score(r.at("regulation"))) || + !(r.at("extra").is_null() || score(r.at("extra"))) || + !(r.at("penalties").is_null() || score(r.at("penalties"))) || + !(m.at("referee").is_null() || text(m.at("referee"))) || + !(m.at("attendance").is_null() || integer(m.at("attendance"), 0, 1000000)) || + !keys(w, {"temperature", "rain"}) || + !(w.at("temperature").is_null() || integer(w.at("temperature"), -100, 100)) || + !(w.at("rain").is_null() || integer(w.at("rain"), 0, 7))) return false; + const bool extra = r.at("extra_played"), penalties = r.at("penalties_played"); + if ((!extra && !r.at("extra").is_null()) || + (!extra && !r.at("regulation").is_null() && r.at("regulation") != r.at("final")) || + (extra && !r.at("regulation").is_null() && r.at("regulation")[0] != r.at("regulation")[1]) || + (penalties != !r.at("penalties").is_null()) || + (penalties && (r.at("final")[0] != r.at("final")[1] || + r.at("penalties")[0] == r.at("penalties")[1]))) return false; + if (!keys(m.at("lineups"), {"home", "away"}) || !m.at("events").is_array()) return false; + std::array rosters; + if (!valid_roster(m.at("lineups").at("home"), rosters[0]) || + !valid_roster(m.at("lineups").at("away"), rosters[1])) return false; + for (const auto &[id, name] : rosters[0].names) { + (void)name; + if (rosters[1].names.contains(id)) return false; + } + std::array goals{}, regular{}, added{}, kicks{}, taken{}; + int last_minute = 0, kick_count = 0, first_kicker = -1; + bool decided = false; + for (const auto &e : m.at("events")) { + if (!keys(e, {"kind", "minute", "side", "player", "other", "detail"}) || + !text(e.at("kind")) || !integer(e.at("minute"), 1, 121) || + !(e.at("side") == "home" || e.at("side") == "away") || + !(e.at("player").is_null() || person(e.at("player"))) || + !(e.at("other").is_null() || person(e.at("other")))) return false; + const auto kind = e.at("kind").get(); + const bool kick = kind == "shootout", chance = kind == "goal" || kind == "miss"; + if (!(chance || kick || kind == "yellow" || kind == "second_yellow" || kind == "red" || + kind == "injury" || kind == "substitution") || + !integer(e.at("detail"), 0, kick ? 1 : chance ? 3 : 0)) return false; + const int minute = e.at("minute"), side = e.at("side") == "home" ? 0 : 1; + if (minute < last_minute || (kick ? (!penalties || minute != 121) : minute > (extra ? 120 : 90))) + return false; + last_minute = minute; + auto &roster = rosters[size_t(side)]; + for (const auto *key : {"player", "other"}) { + const auto &p = e.at(key); + if (!p.is_null() && roster.known) { + const auto found = roster.names.find(p.at("id").get()); + if (found == roster.names.end() || found->second != p.at("name").get()) + return false; + } + } + const auto player = e.at("player").is_null() ? "" : e.at("player").at("id").get(); + const auto other = e.at("other").is_null() ? "" : e.at("other").at("id").get(); + if (!other.empty() && !chance && kind != "substitution") return false; + if (roster.known) { + if (kind == "substitution") { + if (!player.empty() && other.empty() && + roster.active.size() >= 11 - roster.dismissed.size()) return false; + if (!player.empty() && !roster.bench.erase(player)) return false; + if (!other.empty() && !roster.active.erase(other)) return false; + if (!player.empty()) roster.active.insert(player); + } else if ((!player.empty() && !roster.active.contains(player)) || + (!other.empty() && (!roster.active.contains(other) || player == other))) return false; + if (kind == "yellow" && !player.empty()) { + if (!roster.yellow.insert(player).second) return false; + } else if ((kind == "red" || kind == "second_yellow") && !player.empty()) { + if (kind == "second_yellow" && !roster.yellow.contains(player)) return false; + roster.active.erase(player); + roster.dismissed.insert(player); + } + } + if (kind == "goal") { + ++goals[size_t(side)]; + if (minute <= 90) ++regular[size_t(side)]; + else ++added[size_t(side)]; + } else if (kick) { + if (first_kicker < 0) first_kicker = side; + if (decided || side != (first_kicker + kick_count) % 2) return false; + ++kick_count; + ++taken[size_t(side)]; + kicks[size_t(side)] += e.at("detail").get(); + if (taken[0] <= 5 && taken[1] <= 5) + decided = kicks[0] > kicks[1] + 5 - taken[1] || kicks[1] > kicks[0] + 5 - taken[0]; + else if (taken[0] == taken[1]) decided = kicks[0] != kicks[1]; + } + } + for (int side = 0; side < 2; ++side) { + if (r.at("final")[size_t(side)] != goals[size_t(side)] || + (!r.at("regulation").is_null() && r.at("regulation")[size_t(side)] != regular[size_t(side)]) || + (!r.at("extra").is_null() && r.at("extra")[size_t(side)] != added[size_t(side)]) || + (penalties && r.at("penalties")[size_t(side)] != kicks[size_t(side)])) return false; + } + return penalties ? decided : kick_count == 0; +} +Json error(const char *message) { return {{"ok", false}, {"error", message}}; } +} // namespace + +Json make_demo_almanac(const Catalog &world) { + Json archive = {{"schema", "openbmh-ui-demo-almanac@1"}, {"matches", Json::array()}}; + const auto clubs = world.clubs(); + if (clubs.size() < 2) return archive; + const auto start = world.manifest().value("start_date", Json("2026-07-01")); + if (!text(start) || !date(start.get())) return archive; + const auto when = start.get(); + const int current = std::stoi(when.substr(0, 4)) - (when.substr(5, 2) < "07" ? 1 : 0); + if (current < 3) return archive; + for (int year = current - 2; year < current; ++year) + for (int ordinal = 0; ordinal < 6; ++ordinal) { + const size_t pair = ordinal < 3 ? size_t(ordinal) * 2 : 0; + const auto *home = clubs[pair % clubs.size()], *away = clubs[(pair + 1) % clubs.size()]; + archive["matches"].push_back(make_match(world, *home, *away, year, ordinal)); + } + return archive; +} +bool valid_demo_almanac(const Json &archive) { + try { + if (!keys(archive, {"schema", "matches"}) || + archive.at("schema") != "openbmh-ui-demo-almanac@1" || !archive.at("matches").is_array()) + return false; + std::set ids; + for (const auto &m : archive.at("matches")) + if (!valid_match(m) || !ids.insert(m.at("id").get()).second) return false; + return true; + } catch (const Json::exception &) { return false; } +} +Json query_demo_almanac(const Json &archive, const Json &request, const std::string &as_of) { + if (!date(as_of)) return error("invalid_almanac_cutoff"); + if (!valid_demo_almanac(archive)) return error("invalid_demo_almanac"); + try { + if (!request.is_object() || !request.contains("kind") || !text(request.at("kind"))) + return error("invalid_almanac_request"); + const auto kind = request.at("kind").get(); + const bool index = kind == "index", calendar = kind == "calendar", day = kind == "day", match = kind == "match"; + if (!(index || calendar || day || match) || + !(index ? keys(request, {"kind"}) : calendar ? keys(request, {"kind", "year"}) + : day ? keys(request, {"kind", "date"}) : keys(request, {"kind", "id"})) || + (calendar && !integer(request.at("year"), 1, 9999)) || + (day && (!text(request.at("date")) || !date(request.at("date").get()))) || + (match && !text(request.at("id")))) return error("invalid_almanac_request"); + std::vector visible; + for (const auto &m : archive.at("matches")) + if (m.at("date").get() <= as_of) visible.push_back(&m); + std::stable_sort(visible.begin(), visible.end(), [](const auto *a, const auto *b) { + return a->at("date").template get() < b->at("date").template get(); + }); + if (index) { + std::set years; + for (const auto *m : visible) years.insert(std::stoi(m->at("date").template get().substr(0, 4))); + Json listed = Json::array(); + for (int year : years) listed.push_back(year); + return {{"ok", true}, {"years", listed}, {"match_count", visible.size()}, + {"first_date", visible.empty() ? Json(nullptr) : visible.front()->at("date")}, + {"last_date", visible.empty() ? Json(nullptr) : visible.back()->at("date")}}; + } + if (calendar) { + const int year = request.at("year"); + std::map days; + for (const auto *m : visible) { + const auto when = m->at("date").template get(); + if (std::stoi(when.substr(0, 4)) != year) continue; + auto [it, inserted] = days.try_emplace(when, Json{{"date", when}, {"count", 0}, {"highlights", Json::array()}}); + (void)inserted; + it->second["count"] = it->second.at("count").get() + 1; + const auto &r = m->at("result"); + if (r.at("extra_played") == true || r.at("penalties_played") == true || + r.at("final")[0].get() + r.at("final")[1].get() >= 4) + it->second["highlights"].push_back(m->at("id")); + } + Json listed = Json::array(); + for (const auto &[when, item] : days) { (void)when; listed.push_back(item); } + return {{"ok", true}, {"year", year}, {"days", listed}}; + } + if (day) { + Json matches = Json::array(); + for (const auto *m : visible) + if (m->at("date") == request.at("date")) matches.push_back(*m); + return {{"ok", true}, {"date", request.at("date")}, {"matches", matches}}; + } + for (const auto *m : visible) + if (m->at("id") == request.at("id")) return {{"ok", true}, {"match", *m}}; + return error("almanac_match_not_found"); + } catch (const Json::exception &) { return error("invalid_almanac_request"); } +} +} // namespace bmh::modern_ui diff --git a/src/modern/ui/demo_almanac.hpp b/src/modern/ui/demo_almanac.hpp new file mode 100644 index 0000000..2c27986 --- /dev/null +++ b/src/modern/ui/demo_almanac.hpp @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: GPL-3.0-only +#pragma once +#include "modern/ui/catalog.hpp" + +namespace bmh::modern_ui { +// Immutable presentation archive. It is deliberately separate from Snapshot and +// UI checkpoints; neither generation nor queries touch an engine, OBS or RNG. +// Two completed seasons precede the season of manifest.start_date (2026-07-01 +// when absent). Missing catalogues yield a valid empty archive. +Json make_demo_almanac(const Catalog &); +bool valid_demo_almanac(const Json &); +// Requests: {kind:"index"}, {kind:"calendar",year:2025}, +// {kind:"day",date:"2025-08-03"}, {kind:"match",id:"..."}. +// Responses always contain ok. Errors contain error; successful index responses +// have years (ascending), match_count, first_date/last_date (nullable). Calendar +// has year and days [{date,count,highlights:[match IDs]}], day has date/matches, +// and match has match. Only records dated <= as_of are ever returned. +// regulation contains 90-minute goals; extra contains only additional goals +// during extra time. Their sum is final; final excludes shootout goals. +// An engine adapter may derive regulation from complete goal events <= minute +// 90. AlmanacMatch itself only stores the end score and separate shootout; this +// demo does not claim that its explicit phase fields came from the backend. +// In particular, backend decided==2 alone does not establish extra-time +// participation, and F10 player identities do not carry archived positions. +Json query_demo_almanac(const Json &archive, const Json &request, + const std::string &as_of); +} // namespace bmh::modern_ui diff --git a/src/modern/ui/desktop.cpp b/src/modern/ui/desktop.cpp index be4b2d5..67b1ace 100644 --- a/src/modern/ui/desktop.cpp +++ b/src/modern/ui/desktop.cpp @@ -74,7 +74,7 @@ const std::vector &desktop_routes() { "camp", "training", "transfer", "tactics", "settings", "scorers", "advertising", "stadium", "statistics", "environment", "fairplay", "highscore", "contracts", "balance", "newplayer", - "news"}; + "news", "almanac"}; return value; } const std::vector &widget_definitions() { @@ -170,6 +170,21 @@ bool valid_desktop(const Json &layout) { return false; } } +bool migrate_desktop(Json &layout) { + try { + if (layout.at("objects").contains("app-almanac")) + return valid_desktop(layout); + auto next = layout; + next["objects"]["app-almanac"] = object(0, 0, 1, 1, false, true); + if (!valid_desktop(next) || + !find_space(next, "app-almanac", left, top, false)) + return false; + layout = std::move(next); + return true; + } catch (const Json::exception &) { + return false; + } +} bool place_desktop_object(Json &layout, const std::string &id, int x, int y, bool nearest) { if (!valid_desktop(layout) || !layout["objects"].contains(id)) diff --git a/src/modern/ui/desktop.hpp b/src/modern/ui/desktop.hpp index e9c591c..978adb3 100644 --- a/src/modern/ui/desktop.hpp +++ b/src/modern/ui/desktop.hpp @@ -13,6 +13,8 @@ const std::vector &desktop_routes(); // untouched. Json default_desktop(); bool valid_desktop(const Json &); +// Add new applications to a valid older view without moving existing objects. +bool migrate_desktop(Json &); bool place_desktop_object(Json &, const std::string &, int x, int y, bool nearest = true); bool resize_desktop_widget(Json &, const std::string &, int columns, int rows); diff --git a/src/modern/ui/model.cpp b/src/modern/ui/model.cpp index 1243e01..17018a8 100644 --- a/src/modern/ui/model.cpp +++ b/src/modern/ui/model.cpp @@ -1,5 +1,6 @@ // SPDX-License-Identifier: GPL-3.0-only #include "modern/ui/model.hpp" +#include "modern/ui/demo_almanac.hpp" #include "modern/ui/demo_calendar.hpp" #include "modern/ui/demo_reports.hpp" #include "modern/ui/demo_sports.hpp" @@ -48,7 +49,7 @@ bool preferences(const Json &value) { } } // namespace DemoSource::DemoSource(std::shared_ptr catalog) - : catalog_(std::move(catalog)) { + : catalog_(std::move(catalog)), almanac_(make_demo_almanac(*catalog_)) { std::string club; for (const auto *c : catalog_->clubs()) { if (!catalog_->manageable(c->value("id", ""))) @@ -86,6 +87,9 @@ DemoSource::DemoSource(std::shared_ptr catalog) saved_ = state_; } Snapshot DemoSource::snapshot() const { return {revision_, catalog_, state_}; } +Json DemoSource::read_almanac(const Json &request) const { + return query_demo_almanac(almanac_, request, state_.at("date")); +} ActionResult DemoSource::apply(const Action &action) { if (action.revision != revision_) return {false, revision_, "stale_revision"}; @@ -243,8 +247,8 @@ Json DemoSource::load(const fs::path &file) { if (!v.is_number_integer() || v < 0 || v > 15) throw editor::Error("invalid_focus"); auto next = data; - const auto desktop = next.value("desktop", Json::object()); - if (!valid_desktop(desktop)) + auto desktop = next.value("desktop", Json::object()); + if (!migrate_desktop(desktop)) throw editor::Error("invalid_demo_desktop"); next.erase("desktop"); state_ = std::move(next); diff --git a/src/modern/ui/model.hpp b/src/modern/ui/model.hpp index 6cb5bec..d596641 100644 --- a/src/modern/ui/model.hpp +++ b/src/modern/ui/model.hpp @@ -24,18 +24,25 @@ public: virtual ~DataSource() = default; virtual Snapshot snapshot() const = 0; virtual ActionResult apply(const Action &) = 0; + // Read-side history projections can be backed by lazy engine-season decoding. + // Browsing does not change the game revision or copy the archive into a save. + virtual Json read_almanac(const Json &) const { + return {{"ok", false}, {"error", "almanac_unavailable"}}; + } }; class DemoSource final : public DataSource { public: explicit DemoSource(std::shared_ptr); Snapshot snapshot() const override; ActionResult apply(const Action &) override; + Json read_almanac(const Json &) const override; void save(const fs::path &, const Json &desktop); Json load(const fs::path &); bool dirty() const { return state_ != saved_; } private: std::shared_ptr catalog_; + const Json almanac_; Json state_, saved_; uint64_t revision_ = 0; }; diff --git a/src/modern/ui/report_pickers.inc b/src/modern/ui/report_pickers.inc index 28e69e6..2a51035 100644 --- a/src/modern/ui/report_pickers.inc +++ b/src/modern/ui/report_pickers.inc @@ -2,11 +2,11 @@ namespace { bool report_picker_menu(const std::string &menu) { return menu == "tables" || menu == "strengths" || menu == "league" || - menu == "other" || menu == "calendar" || menu == "friendlies"; + menu == "other" || menu == "calendar" || menu == "friendlies" || menu == "almanac"; } bool report_picker_kind(const std::string &kind) { return kind == "country" || kind == "league" || kind == "filter" || - kind == "competition"; + kind == "competition" || kind == "year"; } } // namespace @@ -15,6 +15,15 @@ App::report_picker_items(const std::string &kind) const { std::vector> items; if (!world_ || !report_picker_kind(kind)) return items; + if (kind == "year") { + if (!source_) return items; + const auto index = source_->read_almanac({{"kind", "index"}}); + if (!index.value("ok", false)) return items; + for (const auto &year : index.at("years")) + items.emplace_back(std::to_string(year.get()), std::to_string(year.get())); + std::reverse(items.begin(), items.end()); + return items; + } if (kind == "filter" || kind == "competition") { const std::vector captions = kind == "filter" @@ -56,6 +65,7 @@ App::report_picker_items(const std::string &kind) const { std::string App::report_picker_value(const std::string &kind) const { if (!world_ || !report_picker_kind(kind)) return {}; + if (kind == "year") return std::to_string(almanac_year_); const auto reports = snap().state.at("reports"); if (kind == "filter" || kind == "competition") return std::to_string(reports.at(kind).get()); @@ -78,10 +88,11 @@ std::string App::report_picker(const std::string &kind, double left, for (const auto &[value, label] : items) if (value == selected) caption = label; + if (kind == "year") caption = "Jahr " + std::to_string(almanac_year_); const bool open = report_picker_ == kind; const std::string menu_label = kind == "country" ? "Land" : kind == "league" ? "Liga" - : kind == "filter" ? "Spiele" : "Wettbewerb"; + : kind == "filter" ? "Spiele" : kind == "year" ? "Kalenderjahr" : "Wettbewerb"; std::string out = "
" + @@ -103,8 +114,8 @@ std::string App::report_picker(const std::string &kind, double left, "" + std::string(checked ? "" : "") + ""; - out += btn("report-choice", marker + "" + - esc(items[i].second) + "", + const auto option_label = "" + esc(items[i].second) + ""; + out += btn("report-choice", kind == "year" ? option_label + marker : marker + option_label, "report-picker-option", "id=\"report-option-" + kind + "-" + std::to_string(i) + "\" data-kind=\"" + kind + "\" data-value=\"" + @@ -130,6 +141,10 @@ void App::close_report_picker(bool focus) { context_->Update(); if (focus && trigger) trigger->Focus(keyboard_navigation_); + if (kind == "year") { + if (focus) focus_after_render_ = "report-picker-year"; + refresh(); + } dirty_ = true; } @@ -171,7 +186,12 @@ bool App::report_picker_action(const std::string &action, Rml::Element *target) ? Json(std::stoi(value)) : Json(value); close_report_picker(false); // Commit even an unchanged country: the Gold resets its first league. - if (menu_ == "friendlies") + if (kind == "year" && menu_ == "almanac") { + almanac_year_ = std::stoi(value); + almanac_day_.clear(); + almanac_match_.clear(); + almanac_tab_ = "lineups"; + } else if (menu_ == "friendlies") apply("calendar", {{"kind", "friendly-" + kind}, {"value", selection}}); else if (menu_ == "calendar") { const auto leagues = kind == "country" ? world_->leagues(value) : std::vector{}; @@ -211,6 +231,7 @@ bool App::report_picker_event(Rml::Event &event) { return true; } if (type == "mousedown") { + if (report_picker_ == "year") return false; // Dedicated backdrop dismisses this toolbar popup. auto *wrapper = ancestor("data-report-picker"); if (!wrapper || wrapper->GetAttribute("data-report-picker", "") != report_picker_) @@ -229,13 +250,14 @@ bool App::report_picker_event(Rml::Event &event) { event.StopImmediatePropagation(); return true; } - if (key == Rml::Input::KI_TAB) { + if (key == Rml::Input::KI_TAB && report_picker_ != "year") { keyboard_navigation_ = true; close_report_picker(true); return false; } if (key == Rml::Input::KI_UP || key == Rml::Input::KI_DOWN || - key == Rml::Input::KI_HOME || key == Rml::Input::KI_END) { + key == Rml::Input::KI_HOME || key == Rml::Input::KI_END || + (key == Rml::Input::KI_TAB && report_picker_ == "year")) { const auto items = report_picker_items(report_picker_); if (items.empty()) return false; @@ -250,7 +272,7 @@ bool App::report_picker_event(Rml::Event &event) { const int count = int(items.size()); const int next = key == Rml::Input::KI_HOME ? 0 : key == Rml::Input::KI_END ? count - 1 - : (current + (key == Rml::Input::KI_UP ? -1 : 1) + count) % count; + : (current + ((key == Rml::Input::KI_UP || (key == Rml::Input::KI_TAB && event.GetParameter("shift_key", 0))) ? -1 : 1) + count) % count; if (auto *node = element("report-option-" + report_picker_ + "-" + std::to_string(next))) { keyboard_navigation_ = true; diff --git a/src/modern/ui/screens.inc b/src/modern/ui/screens.inc index a38a629..4c84aaf 100644 --- a/src/modern/ui/screens.inc +++ b/src/modern/ui/screens.inc @@ -208,13 +208,13 @@ std::string App::render_desktop() { "
"; else { const auto route = id.substr(4); - const std::array colors = { + const std::array colors = { "#3d789b", "#375a83", "#477c73", "#42846b", "#a58a49", "#586ba0", "#517d71", "#668a98", "#af6860", "#6b809c", "#657cb3", "#507b9c", "#559b76", "#a7474e", "#967d50", "#648f91", "#54856b", "#558f93", "#6379a3", "#788598", "#8d7856", "#a66d64", "#748474", "#6887a2", "#6b9270", "#7c8b9c", "#ac8b52", "#7783a4", "#648f83", "#927d9d", - "#ac5e63"}; + "#ac5e63", "#806c98"}; const auto i = std::find(routes.begin(), routes.end(), route); const auto color = colors[size_t(i - routes.begin())]; const auto top = theme_ == "matchday" ? mixed_color(color, "#27282e", .55) @@ -875,6 +875,8 @@ std::string App::render_menu(const std::string &key) { std::string body; if (key == "tables" || key == "strengths" || key == "league" || key == "other") body = render_reports(key); + else if (key == "almanac") + body = render_almanac(); else if (key == "postpone") body = render_postpone(); else if (key == "friendlies") diff --git a/src/modern/ui/view.cpp b/src/modern/ui/view.cpp index 2297cb4..5fe938c 100644 --- a/src/modern/ui/view.cpp +++ b/src/modern/ui/view.cpp @@ -59,15 +59,15 @@ std::string btn(const std::string &action, const std::string &label, const std::string &css = {}, const std::string &attrs = {}) { return button_markup(action, label, css, attrs); } -const std::array routes = { +const std::array routes = { "tables", "league", "strengths", "lineup", "achievements", "other", "friendlies", "postpone", "calendar", "indoor", "load", "save", "kickoff", "toto", "bank", "camp", "training", "transfer", "tactics", "settings", "scorers", "advertising", "stadium", "statistics", "environment", "fairplay", "highscore", "contracts", "balance", "newplayer", - "news"}; -const std::array titles = {"Tabellen", + "news", "almanac"}; +const std::array titles = {"Tabellen", "Ligaspiele", "Stärken", "Aufstellung", @@ -97,7 +97,7 @@ const std::array titles = {"Tabellen", "Verträge", "Bilanz", "Neuer Spieler", - "Nachrichten"}; + "Nachrichten", "Almanach"}; std::string title(const std::string &route) { const auto i = std::find(routes.begin(), routes.end(), route); if (i != routes.end()) @@ -212,6 +212,8 @@ public: } } raster = editor::images::decode(svg, ".svg", pixels); + } else if (key == "button.almanac" && !gui_.contains(key)) { + raster = editor::images::decode(editor::read_file(assets_ / "icons" / "almanac.svg"), ".svg", pixels); } else if (gui_.contains(key)) raster = gui_.decode(key, pixels); else if (key == "background") @@ -308,10 +310,13 @@ class App final : public Rml::EventListener { std::optional training_scroll_; std::optional report_scroll_; float fixture_half_width_ = -1.f; + float almanac_list_width_ = -1.f; std::string last_report_state_, report_picker_, report_detail_kind_, report_detail_club_, report_detail_player_, report_detail_return_focus_, report_option_to_scroll_; std::string planning_dialog_, planning_notice_, planning_return_focus_; + int almanac_year_ = 0; + std::string almanac_day_, almanac_match_, almanac_tab_ = "lineups"; float device_ratio_ = 1.f; Json desktop_ = Json::object(), saved_desktop_ = Json::object(), options_ = Json::object(); @@ -521,6 +526,10 @@ class App final : public Rml::EventListener { renderer_.world(next); world_ = std::move(next); source_ = std::move(demo); + almanac_year_ = 0; + almanac_day_.clear(); + almanac_match_.clear(); + almanac_tab_ = "lineups"; desktop_ = Json::object(); ticket_ = std::make_unique(*context_, *doc_, *source_, [this] { @@ -626,6 +635,8 @@ class App final : public Rml::EventListener { std::string render_planning_dialog(); std::string planning_progress(bool, bool); bool planning_action(const std::string &, Rml::Element *); + std::string render_almanac(); + bool almanac_action(const std::string &, Rml::Element *); std::string render_indoor(); bool indoor_action(const std::string &, Rml::Element *); std::string training_balls(const std::string &, int, int, bool, @@ -688,6 +699,7 @@ class App final : public Rml::EventListener { } void render() { fixture_half_width_ = -1.f; + almanac_list_width_ = -1.f; // A window-close save prompt can leave a menu while its local dialog is // open. Never keep that menu's modal/input gate in the destination view. if (menu_ != last_rendered_menu_) { @@ -757,7 +769,8 @@ class App final : public Rml::EventListener { if (auto *node = element(focus_after_render_)) node->Focus(keyboard_navigation_); if (focus_after_render_.starts_with("report-option-") || - focus_after_render_.starts_with("friendly-opponent-")) + focus_after_render_.starts_with("friendly-opponent-") || + focus_after_render_.starts_with("alm-match-")) report_option_to_scroll_ = focus_after_render_; focus_after_render_.clear(); } @@ -793,12 +806,28 @@ class App final : public Rml::EventListener { button->Focus(); } bool center_fixture_columns() { + bool changed = false; + // History can contain every competition on one date. Keep its whole-row + // buttons on the same centre even when the long list gains a scrollbar. + if (auto *history = element("alm-day-list")) { + if (auto *content = doc_->QuerySelector(".window .content")) { + const float width = content->GetBox().GetSize(Rml::BoxArea::Content).x; + if (std::abs(width - almanac_list_width_) >= .001f) { + almanac_list_width_ = width; + history->SetProperty("width", scalar(width) + "px"); + Rml::ElementList rows; + history->QuerySelectorAll(rows, ".alm-list-head,.alm-match-row"); + for (auto *row : rows) row->SetProperty("width", scalar(width) + "px"); + changed = true; + } + } + } auto *list = element("report-list"); if (!list || !list->IsClassSet("match-list")) - return false; + return changed; auto *score = list->QuerySelector(".report-cell.score"); if (!score) - return false; + return changed; const auto &box = list->GetBox(); // Rml rounds borders to physical pixels. Use the actual full inner width, // independently of the scrollport, so fractional density cannot move scores. @@ -807,7 +836,7 @@ class App final : public Rml::EventListener { box.GetEdge(Rml::BoxArea::Border, Rml::BoxEdge::Right); const float half = std::max(0.f, (inner - score->GetBox().GetSize(Rml::BoxArea::Border).x) / 2.f); if (std::abs(half - fixture_half_width_) < .001f) - return false; + return changed; fixture_half_width_ = half; Rml::ElementList sides; list->QuerySelectorAll(sides, ".report-cell.first,.report-cell:last-child"); @@ -1088,6 +1117,8 @@ public: #include "modern/ui/indoor_screen.inc" #include "modern/ui/planning_screens.inc" #include "modern/ui/planning_controls.inc" +#include "modern/ui/almanac_screens.inc" +#include "modern/ui/almanac_controls.inc" } // namespace bool is_modern_world(const fs::path &file) { try { diff --git a/tests/modern_almanac_ui_tests.cpp b/tests/modern_almanac_ui_tests.cpp new file mode 100644 index 0000000..fe7112e --- /dev/null +++ b/tests/modern_almanac_ui_tests.cpp @@ -0,0 +1,297 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "modern/ui/demo_almanac.hpp" +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace bmh::modern_ui; +namespace { +void require(bool value, const char *message) { + if (!value) throw std::runtime_error(message); +} +std::string club(int i) { return "club:almanac-test-" + std::to_string(i); } +std::string player(int team, int i) { + return "player:almanac-test-" + std::to_string(team) + "-" + std::to_string(i); +} +struct Fixture { + fs::path root; + std::shared_ptr world; + Json clubs = Json::array(), players = Json::array(); + void write(const std::string &file, const Json &value) const { + fs::create_directories((root / file).parent_path()); + std::ofstream out(root / file); out << value.dump(); + require(bool(out), "Cannot create synthetic world"); + } + explicit Fixture(int teams = 6, int squad = 18, Json start = "2027-07-07") { + root = fs::temp_directory_path() / ("openbmh-almanac-ui-" + + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count())); + write("manifest.json", {{"format", "openbmh-world"}, {"kind", "world"}, + {"format_version", "1.1"}, {"id", "world:synthetic-almanac-ui"}, + {"start_date", start}, {"requires", {"editor:world-v1"}}, + {"x-editor", {{"profile", "editor-world-v1"}}}}); + write("world/nations.json", {{"items", {{{"id", "nation:de"}, {"name", "Synthetic nation"}}}}}); + write("world/competitions.json", {{"items", { + {{"id", "competition:almanac-league"}, {"name", "Synthetic league"}, + {"type", "league"}, {"nation", "nation:de"}}, + {{"id", "competition:almanac-cup"}, {"name", "Synthetic cup"}, {"type", "cup"}}}}}); + for (int team = 0; team < teams; ++team) { + clubs.push_back({{"id", club(team)}, {"name", "Historical club " + std::to_string(team)}, + {"nation", "nation:de"}, {"competition", "competition:almanac-league"}, + {"crest", "asset:synthetic-crest-" + std::to_string(team)}}); + for (int i = 0; i < squad; ++i) { + // A keeper is deliberately not the first squad row. Another keeper and + // every remaining player must survive in the complete bench snapshot. + const auto role = i == 2 || i == 14 ? "gk" : i < 7 ? "def" : i < 12 ? "mid" : "fwd"; + players.push_back({{"id", player(team, i)}, {"team", club(team)}, + {"name", {{"first", "Synthetic " + std::to_string(team)}, + {"last", "Ältester " + std::to_string(i)}}}, + {"positions", {role}}, {"squad_order", i}}); + } + } + write("world/clubs.json", {{"items", clubs}}); + write("world/players.json", {{"items", players}}); + world = Catalog::open(root); + } + ~Fixture() { std::error_code ec; fs::remove_all(root, ec); } +}; +Json query(const Json &archive, Json request, const std::string &cutoff = "2027-07-07") { + auto result = query_demo_almanac(archive, request, cutoff); + if (result.at("ok") != true) + throw std::runtime_error("Unexpected query error " + result.dump() + " " + request.dump()); + return result; +} +void rejected(const Json &archive, const Json &request, const char *code, + const std::string &cutoff = "2027-07-07") { + const auto before = archive; + const auto result = query_demo_almanac(archive, request, cutoff); + require(result.at("ok") == false && result.at("error") == code && archive == before, + "Malformed query was accepted or changed archive"); +} +Json changed_match(const Json &archive, const Json &match, size_t index = 0) { + auto changed = archive; + changed["matches"][index] = match; + return changed; +} +} // namespace +int main() try { + Fixture fixture; + const auto &world = *fixture.world; + const auto original_clubs = world.rows("clubs"), original_players = world.rows("players"); + const auto archive = make_demo_almanac(world), original = archive; + require(valid_demo_almanac(archive) && archive.at("matches").size() == 12 && + archive == make_demo_almanac(world), "Archive is invalid or nondeterministic"); + require(world.rows("clubs") == original_clubs && world.rows("players") == original_players, + "Archive generation changed catalogue"); + const auto index = query(archive, {{"kind", "index"}}); + require(index.at("years") == Json::array({2025, 2026, 2027}) && index.at("match_count") == 12 && + index.at("first_date") == "2025-08-03" && index.at("last_date") == "2027-05-18", + "Wrong archive years or two-season range"); + std::set seasons, kinds, ids; + std::set goals, misses; + for (const auto &m : archive.at("matches")) { + seasons.insert(m.at("season").get()); ids.insert(m.at("id").get()); + require(world.find("clubs", m.at("home").at("id")) && + world.find("clubs", m.at("away").at("id")), "Archive invented a club identity"); + for (const auto &e : m.at("events")) { + kinds.insert(e.at("kind").get()); + if (e.at("kind") == "goal") goals.insert(e.at("detail").get()); + if (e.at("kind") == "miss") misses.insert(e.at("detail").get()); + } + for (const auto *side : {"home", "away"}) { + const auto &l = m.at("lineups").at(side); + if (l.is_null()) { + require(std::string(side) == "away" && m.at("date").get().substr(5) == "05-18", + "Complete catalogue unexpectedly lost its recorded lineup"); + continue; + } + require(l.at("starters").size() == 11 && l.at("bench").size() == 7 && + l.at("starters")[0].at("position") == "gk", "Starting XI or full bench is implausible"); + std::set roster; + int keepers = 0; + for (const auto *section : {"starters", "bench"}) + for (const auto &p : l.at(section)) { + const auto *source = world.find("players", p.at("id")); + require(source && world.name(*source) == p.at("name").get() && + source->at("team") == m.at(side).at("id") && roster.insert(p.at("id").get()).second, + "Roster changed a historical name, duplicated or invented a player"); + if (std::string(section) == "starters" && p.at("position") == "gk") ++keepers; + } + require(keepers == 1 && roster.size() == world.squad(m.at(side).at("id")).size(), + "Bench omits squad players or starters contain multiple keepers"); + } + } + require(ids.size() == 12 && seasons == std::set{"2025/26", "2026/27"} && + kinds == std::set{"goal", "miss", "yellow", "second_yellow", "red", "injury", "substitution", "shootout"} && + goals == std::set{0, 1, 2, 3} && misses == std::set{0, 1, 2, 3}, + "Archive lacks requested event types or chance kinds"); + const auto first = archive.at("matches")[0], extra = archive.at("matches")[3], penalties = archive.at("matches")[4]; + require(!first.at("home").at("manager").is_null() && !first.at("away").at("manager").is_null() && + first.at("home").at("manager").at("id") != first.at("away").at("manager").at("id"), + "No historical human-versus-human manager example"); + require(first.at("result").at("regulation") == Json::array({3, 1}) && + first.at("result").at("extra").is_null() && extra.at("result").at("regulation") == Json::array({1, 1}) && + extra.at("result").at("extra") == Json::array({1, 0}) && + penalties.at("result").at("extra") == Json::array({1, 1}) && + penalties.at("result").at("final") == Json::array({2, 2}) && + penalties.at("result").at("penalties") == Json::array({4, 3}), "Phase score semantics changed"); + Json kicks = Json::array(); + for (const auto &e : penalties.at("events")) if (e.at("kind") == "shootout") kicks.push_back(e); + require(kicks.size() == 10 && kicks[0].at("side") == "home" && kicks[9].at("side") == "away" && + kicks[9].at("minute") == 121 && kicks[9].at("detail") == 0, "Complete shootout order was lost"); + require(archive.at("matches")[1].at("attendance") == 0 && + archive.at("matches")[1].at("weather").at("temperature") == 0 && + archive.at("matches")[1].at("weather").at("rain") == 0 && + archive.at("matches")[5].at("attendance").is_null() && + archive.at("matches")[5].at("referee").is_null() && + archive.at("matches")[5].at("weather").at("temperature").is_null() && + archive.at("matches")[5].at("lineups").at("away").is_null(), + "Zero-valued and missing historical metadata were conflated"); + const auto calendar = query(archive, {{"kind", "calendar"}, {"year", 2025}}); + require(calendar.at("days").size() == 2 && calendar.at("days")[0].at("date") == "2025-08-03" && + calendar.at("days")[0].at("count") == 3 && calendar.at("days")[0].at("highlights").size() == 1 && + calendar.at("days")[1].at("highlights").size() == 1, "Calendar grouping or highlights incorrect"); + const auto day = query(archive, {{"kind", "day"}, {"date", "2025-08-03"}}); + require(day.at("matches").size() == 3 && day.at("matches")[0] == first && + query(archive, {{"kind", "match"}, {"id", first.at("id")}}).at("match") == first, + "Day or match projection lost normalized snapshots"); + auto copied = day; copied["matches"][0]["home"]["name"] = "Modified result copy"; + require(query(archive, {{"kind", "match"}, {"id", first.at("id")}}).at("match") == first, + "Mutable query result aliases immutable archive"); + auto shuffled = archive; + std::reverse(shuffled["matches"].begin(), shuffled["matches"].end()); + require(query(shuffled, {{"kind", "calendar"}, {"year", 2025}}).at("days")[0].at("date") == "2025-08-03", + "Calendar query relies on source ordering"); + const auto before_start = query(archive, {{"kind", "index"}}, "2025-08-02"); + require(before_start.at("years").empty() && before_start.at("match_count") == 0 && + before_start.at("first_date").is_null() && before_start.at("last_date").is_null(), + "Cutoff leaked future archive range"); + require(query(archive, {{"kind", "index"}}, "2025-08-03").at("match_count") == 3 && + query(archive, {{"kind", "index"}}, "2025-12-14").at("match_count") == 4 && + query(archive, {{"kind", "index"}}, "2025-12-14").at("years") == Json::array({2025}), + "Cutoff does not include exactly the played dates"); + require(query(archive, {{"kind", "day"}, {"date", "2027-02-20"}}, "2025-08-03").at("matches").empty() && + query(archive, {{"kind", "calendar"}, {"year", 2027}}, "2025-08-03").at("days").empty(), + "Future day or calendar query leaked records"); + rejected(archive, {{"kind", "match"}, {"id", penalties.at("id")}}, "almanac_match_not_found", "2025-08-03"); + rejected(archive, {{"kind", "match"}, {"id", "does-not-exist"}}, "almanac_match_not_found"); + for (const auto &request : std::vector{nullptr, Json::array(), true, Json::object(), + {{"kind", 1}}, {{"kind", "unknown"}}, {{"kind", "index"}, {"date", "2025-08-03"}}, + {{"kind", "calendar"}}, {{"kind", "calendar"}, {"year", 2025.0}}, + {{"kind", "calendar"}, {"year", true}}, {{"kind", "calendar"}, {"year", uint64_t(-1)}}, + {{"kind", "calendar"}, {"year", 0}}, {{"kind", "calendar"}, {"year", 10000}}, + {{"kind", "day"}}, {{"kind", "day"}, {"date", "2025-02-29"}}, + {{"kind", "day"}, {"date", "2025-13-01"}}, {{"kind", "day"}, {"date", "2025-8-03"}}, + {{"kind", "day"}, {"date", 20250803}}, {{"kind", "match"}}, + {{"kind", "match"}, {"id", ""}}, {{"kind", "match"}, {"id", true}}}) + rejected(archive, request, "invalid_almanac_request"); + for (const auto &cutoff : {"", "2025-02-29", "0000-01-01", "2025-13-01", "2027-7-07", "2027-07-07T00:00:00"}) + rejected(archive, {{"kind", "index"}}, "invalid_almanac_cutoff", cutoff); + require(query(archive, {{"kind", "day"}, {"date", "2024-02-29"}}).at("matches").empty(), + "Valid leap date was rejected"); + std::vector invalid; + auto bad = archive; bad["matches"].push_back(first); invalid.push_back(bad); + bad = archive; bad["schema"] = "unknown"; invalid.push_back(bad); + bad = archive; bad["unexpected"] = 1; invalid.push_back(bad); + bad = archive; bad["matches"] = Json::object(); invalid.push_back(bad); + std::vector bad_matches; + for (const auto *key : {"id", "date", "season", "competition", "round", "home", "away", "result", "referee", "attendance", "weather", "lineups", "events"}) { + auto m = first; m.erase(key); bad_matches.push_back(m); + } + auto m = first; m["date"] = "2025-02-29"; bad_matches.push_back(m); + m = first; m["season"] = "2024/25"; bad_matches.push_back(m); + m = first; m["away"]["id"] = m["home"]["id"]; bad_matches.push_back(m); + m = first; m["home"]["manager"]["id"] = nullptr; bad_matches.push_back(m); + m = first; m["round"] = uint64_t(-1); bad_matches.push_back(m); + m = first; m["attendance"] = -1; bad_matches.push_back(m); + m = first; m["weather"]["rain"] = 8; bad_matches.push_back(m); + m = first; m["weather"]["temperature"] = true; bad_matches.push_back(m); + m = first; m["result"]["final"] = {4, 1}; bad_matches.push_back(m); + m = first; m["result"]["regulation"] = {2, 1}; bad_matches.push_back(m); + m = first; m["result"]["extra_played"] = 1; bad_matches.push_back(m); + m = first; m["result"]["extra"] = {3, 1}; bad_matches.push_back(m); + m = first; m["lineups"]["home"]["starters"].erase(m["lineups"]["home"]["starters"].end() - 1); bad_matches.push_back(m); + m = first; m["lineups"]["home"]["bench"].push_back(m["lineups"]["home"]["starters"][0]); bad_matches.push_back(m); + m = first; m["lineups"]["home"]["starters"][1]["position"] = "gk"; bad_matches.push_back(m); + m = first; m["lineups"]["away"]["starters"][1]["id"] = m["lineups"]["home"]["starters"][1]["id"]; bad_matches.push_back(m); + m = first; m["events"][0]["kind"] = "unsupported"; bad_matches.push_back(m); + m = first; m["events"][0]["detail"] = 4; bad_matches.push_back(m); + m = first; m["events"][0]["minute"] = 0; bad_matches.push_back(m); + m = first; m["events"][0]["side"] = 0; bad_matches.push_back(m); + m = first; m["events"][1]["minute"] = 5; bad_matches.push_back(m); + m = first; m["events"][0]["player"]["name"] = "Wrong snapshot name"; bad_matches.push_back(m); + m = first; m["events"][0]["player"]["id"] = player(1, 0); bad_matches.push_back(m); + m = first; m["events"][3]["kind"] = "second_yellow"; bad_matches.push_back(m); + m = first; m["events"][7]["player"] = m["events"][7]["other"]; bad_matches.push_back(m); + m = first; m["events"][7]["other"] = nullptr; bad_matches.push_back(m); + m = first; m["events"].back()["player"] = m["events"][3]["player"]; bad_matches.push_back(m); + for (const auto &record : bad_matches) invalid.push_back(changed_match(archive, record)); + m = penalties; m["result"]["penalties"] = {4, 4}; invalid.push_back(changed_match(archive, m, 4)); + m = penalties; m["result"]["extra"] = {2, 2}; invalid.push_back(changed_match(archive, m, 4)); + m = extra; m["result"]["extra"] = {2, 1}; invalid.push_back(changed_match(archive, m, 3)); + m = penalties; m["events"].erase(m["events"].end() - 1); invalid.push_back(changed_match(archive, m, 4)); + m = penalties; m["events"].back()["detail"] = 1; invalid.push_back(changed_match(archive, m, 4)); + m = penalties; m["events"].back()["side"] = "home"; invalid.push_back(changed_match(archive, m, 4)); + m = penalties; m["events"].back()["minute"] = 120; invalid.push_back(changed_match(archive, m, 4)); + m = penalties; m["events"].push_back(m["events"].back()); invalid.push_back(changed_match(archive, m, 4)); + for (const auto &value : invalid) { + require(!valid_demo_almanac(value), "Corrupt score, roster, event or archive was accepted"); + rejected(value, {{"kind", "index"}}, "invalid_demo_almanac"); + } + auto nullable = archive; + for (auto &record : nullable["matches"]) { + record["referee"] = nullptr; record["attendance"] = nullptr; + record["weather"] = {{"temperature", nullptr}, {"rain", nullptr}}; + record["result"]["regulation"] = nullptr; + if (record["result"]["extra_played"] == true) record["result"]["extra"] = nullptr; + } + require(valid_demo_almanac(nullable), "Missing metadata or unknown phase score was invented or rejected"); + auto unknown_position = archive; + unknown_position["matches"][0]["lineups"]["home"]["starters"][0].erase("position"); + require(valid_demo_almanac(unknown_position), "Optional archived position was required"); + auto away_first = penalties; + auto &ordered_events = away_first["events"]; + for (size_t i = 4; i < ordered_events.size(); i += 2) + std::swap(ordered_events[i], ordered_events[i + 1]); + require(valid_demo_almanac(changed_match(archive, away_first, 4)), + "Alternating shootout with away side first was rejected"); + require(valid_demo_almanac(Json::parse(archive.dump())), "Archive JSON roundtrip lost validity"); + fixture.clubs[0]["name"] = "Current renamed club"; + fixture.clubs[0]["crest"] = "asset:replacement-crest"; + fixture.players[0]["name"] = "Current renamed player"; + fixture.write("world/clubs.json", {{"items", fixture.clubs}}); + fixture.write("world/players.json", {{"items", fixture.players}}); + const auto renamed = Catalog::open(fixture.root); + require(renamed->name(*renamed->find("clubs", club(0))) != first.at("home").at("name").get() && + query(archive, {{"kind", "match"}, {"id", first.at("id")}}).at("match") == first, + "Query re-looked up historical names or crests in current catalogue"); + Fixture partial(2, 8); const auto incomplete = make_demo_almanac(*partial.world); + require(valid_demo_almanac(incomplete) && incomplete["matches"].size() == 12 && + incomplete["matches"][0]["lineups"]["home"].is_null(), "Partial squad produced fabricated starters"); + for (const auto &e : incomplete["matches"][0]["events"]) + require(e["player"].is_null() && e["other"].is_null(), "Missing squad invented historical players"); + Fixture one(1); const auto empty = make_demo_almanac(*one.world); + require(valid_demo_almanac(empty) && empty["matches"].empty() && + query(empty, {{"kind", "index"}}).at("years").empty() && + query(empty, {{"kind", "calendar"}, {"year", 2025}}).at("days").empty() && + query(empty, {{"kind", "day"}, {"date", "2025-08-03"}}).at("matches").empty(), + "Empty archive query is unsafe"); + rejected(empty, {{"kind", "match"}, {"id", first.at("id")}}, "almanac_match_not_found"); + Fixture early(2, 0, "2027-02-12"); const auto winter = make_demo_almanac(*early.world); + require(query(winter, {{"kind", "index"}}, "2027-02-12").at("years") == Json::array({2024, 2025, 2026}), + "January-June manifest date selected wrong season"); + Fixture ancient(2, 0, "0002-07-01"); + require(make_demo_almanac(*ancient.world)["matches"].empty(), "Ancient date underflowed demo history"); + Fixture malformed(2, 0, false); + require(make_demo_almanac(*malformed.world)["matches"].empty(), "Invalid manifest date invented an archive year"); + require(archive == original && world.rows("clubs") == original_clubs && world.rows("players") == original_players, + "Read-only queries or rejection mutated archive or world"); + std::cout << "Modern UI almanac checks passed\n"; + return 0; +} catch (const std::exception &error) { + std::cerr << error.what() << '\n'; return 1; +} diff --git a/tests/modern_control_layout_tests.cpp b/tests/modern_control_layout_tests.cpp index 5c3e855..b050380 100644 --- a/tests/modern_control_layout_tests.cpp +++ b/tests/modern_control_layout_tests.cpp @@ -100,7 +100,7 @@ int main(int argc, char **argv) try { std::ostringstream css; for (const auto *name : {"theme.rcss", "ticket.rcss", "sports.rcss", "calendar.rcss", "reports.rcss", "report_details.rcss", - "report_pickers.rcss", "indoor.rcss", "planning.rcss"}) { + "report_pickers.rcss", "indoor.rcss", "planning.rcss", "almanac.rcss"}) { std::ifstream input(root / name); require(bool(input), "Production stylesheet missing"); css << input.rdbuf() << '\n'; diff --git a/tests/modern_ui_core_tests.cpp b/tests/modern_ui_core_tests.cpp index 4a29293..7babb87 100644 --- a/tests/modern_ui_core_tests.cpp +++ b/tests/modern_ui_core_tests.cpp @@ -111,6 +111,14 @@ int main(int argc, char **argv) try { "Minor currency units"); DemoSource source(world); const auto before = source.snapshot(); + const auto archive_index = source.read_almanac({{"kind", "index"}}); + require(archive_index.value("ok", false) && + source.snapshot().revision == before.revision && + source.snapshot().state == before.state && !source.dirty(), + "Almanac read mutated presentation state or revision"); + require(!source.read_almanac({{"kind", "invalid"}}).value("ok", true) && + source.snapshot().state == before.state && !source.dirty(), + "Rejected almanac query mutated state"); require(!source .apply({0, "managers", Json::array({{{"name", "Pat"}, {"club", "club:b"}}})}) @@ -130,6 +138,21 @@ int main(int argc, char **argv) try { const auto save = root / "demo.ui.json"; auto layout = default_desktop(); require(valid_desktop(layout), "Default desktop must validate"); + auto old_layout = layout; + old_layout["objects"].erase("app-almanac"); + const auto preserved_layout = old_layout; + require(migrate_desktop(old_layout) && valid_desktop(old_layout) && + old_layout["objects"]["app-almanac"]["visible"] == true, + "Older desktop did not gain its Almanac icon"); + auto without_added_icon = old_layout; + without_added_icon["objects"].erase("app-almanac"); + require(without_added_icon == preserved_layout, + "Almanac migration moved or reset existing desktop objects"); + auto bad_old_layout = preserved_layout; + bad_old_layout["objects"]["calendar"]["x"] = -1; + const auto before_bad_migration = bad_old_layout; + require(!migrate_desktop(bad_old_layout) && bad_old_layout == before_bad_migration, + "Desktop migration partially repaired invalid existing data"); auto moved = layout; require(!place_desktop_object(moved, "account", 3000, 1500) && moved == layout, @@ -146,6 +169,15 @@ int main(int argc, char **argv) try { require(!valid_desktop(corrupt), "Out of bounds desktop accepted"); source.save(save, layout); require(!source.dirty(), "Saved demo remains dirty"); + auto old_icon_save = Json::parse(bmh::editor::read_file(save)); + old_icon_save["desktop"]["objects"].erase("app-almanac"); + write(root, "old-icon.ui.json", old_icon_save); + DemoSource old_icon_source(world); + const auto migrated_icon_layout = old_icon_source.load(root / "old-icon.ui.json"); + require(valid_desktop(migrated_icon_layout) && + migrated_icon_layout["objects"].contains("app-almanac") && + !old_icon_source.dirty(), + "Older UI checkpoint rejected its missing Almanac desktop icon"); require(source.apply({1, "ticket", 21}).ok, "Second action"); const auto desktop = source.load(save); require(source.snapshot().state["ticket"] == 17 && desktop == layout, diff --git a/tools/modern_ui/prepare_gui_assets.py b/tools/modern_ui/prepare_gui_assets.py index 6aba605..c182e40 100644 --- a/tools/modern_ui/prepare_gui_assets.py +++ b/tools/modern_ui/prepare_gui_assets.py @@ -55,6 +55,7 @@ def main(): for route, button in zip(routes, buttons, strict=True): add('button.' + route, button['src'].removeprefix('../')) add('button.news', 'assets/vector/desktop-news.svg') + add('button.almanac', 'assets/vector/desktop-almanac.svg') for i in range(9): add('training.skill.' + str(i), 'assets/studies/submenus/training-icons-v2.png', [(i % 3) / 3, (i // 3) / 3, 1 / 3, 1 / 3])