From ce1535fe2d9fedbec7a4ee18dfcfd4e41799b273 Mon Sep 17 00:00:00 2001 From: Codex Date: Thu, 29 Oct 2026 01:11:41 +0100 Subject: [PATCH] Create real careers from the native wizard and preserve manager presentation (by Codex) --- .github/workflows/modern-ui.yml | 2 +- CMakeLists.txt | 4 + docs/new_engine/README.md | 2 +- docs/new_engine/datenformat.md | 19 +++++ docs/new_engine/phasen.md | 16 ++++ docs/new_engine/ui-abfragen.md | 11 +++ docs/new_ui/NATIVE_STATUS.md | 4 +- docs/new_ui/README.md | 4 +- docs/new_ui/integration/ENGINE_ENTRY.md | 19 ++++- docs/new_ui/main-menu/entry/README.md | 43 ++++++++++- docs/new_ui/main-menu/opening/README.md | 32 ++++++++ src/app/main.cpp | 6 ++ src/modern/app/modern_session.cpp | 32 +++++++- src/modern/content/projections.cpp | 1 + src/modern/content/statistics.cpp | 2 +- src/modern/content/ui_contract.cpp | 5 +- src/modern/content/world_save.cpp | 22 +++++- src/modern/game/almanac.cpp | 1 + src/modern/game/modern_state.hpp | 12 +++ src/modern/ui/controls.inc | 4 +- src/modern/ui/demo_opening.cpp | 30 +++++--- src/modern/ui/demo_opening.hpp | 2 + src/modern/ui/engine_bridge.cpp | 35 +++++++++ src/modern/ui/engine_bridge.hpp | 3 + src/modern/ui/engine_controls.inc | 83 +++++++++++++-------- src/modern/ui/engine_creation.inc | 26 +++++++ src/modern/ui/engine_dto.cpp | 10 +++ src/modern/ui/engine_screens.inc | 3 + src/modern/ui/engine_state.inc | 9 +++ src/modern/ui/entry_controls.inc | 9 ++- src/modern/ui/entry_opening_controls.inc | 24 +++--- src/modern/ui/entry_opening_screens.inc | 8 +- src/modern/ui/entry_screens.inc | 1 + src/modern/ui/view.cpp | 5 +- src/modern/ui/view.hpp | 4 + tests/modern_engine_bridge_probe.cpp | 28 ++++++- tests/modern_engine_dto_tests.cpp | 7 ++ tests/modern_manager_presentation_tests.cpp | 13 ++++ 38 files changed, 466 insertions(+), 75 deletions(-) create mode 100644 src/modern/ui/engine_creation.inc create mode 100644 tests/modern_manager_presentation_tests.cpp diff --git a/.github/workflows/modern-ui.yml b/.github/workflows/modern-ui.yml index abfd7ee..a9a1bc2 100644 --- a/.github/workflows/modern-ui.yml +++ b/.github/workflows/modern-ui.yml @@ -52,7 +52,7 @@ 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 modern_almanac_ui_tests modern_finance_ui_tests modern_environment_ui_tests modern_advertising_ui_tests modern_toto_ui_tests modern_lineup_ui_tests modern_transfer_ui_tests modern_career_reports_tests modern_rankings_tests modern_stadium_ui_tests modern_statistics_ui_tests modern_news_ui_tests modern_settings_ui_tests modern_desktop_ui_tests modern_files_ui_tests modern_mods_ui_tests modern_entry_ui_tests modern_opening_ui_tests modern_select_menu_tests modern_career_ui_tests modern_live_ui_tests modern_national_ui_tests modern_news_catalog_tests modern_post_match_ui_tests modern_engine_dto_tests modern_report_read_tests modern_other_read_tests modern_rankings_read_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 modern_finance_ui_tests modern_environment_ui_tests modern_advertising_ui_tests modern_toto_ui_tests modern_lineup_ui_tests modern_transfer_ui_tests modern_career_reports_tests modern_rankings_tests modern_stadium_ui_tests modern_statistics_ui_tests modern_news_ui_tests modern_settings_ui_tests modern_desktop_ui_tests modern_files_ui_tests modern_mods_ui_tests modern_entry_ui_tests modern_opening_ui_tests modern_select_menu_tests modern_career_ui_tests modern_live_ui_tests modern_national_ui_tests modern_news_catalog_tests modern_post_match_ui_tests modern_engine_dto_tests modern_report_read_tests modern_other_read_tests modern_rankings_read_tests modern_manager_presentation_tests --parallel 2 - name: Check controls, fonts, density and draft cancellation run: ctest --test-dir build-ui -R "^modern_(ui_|ticket_|control_|reports_|planning_|almanac_ui_|finance_ui_|environment_ui_|advertising_ui_|toto_ui_|lineup_ui_|transfer_ui_|career_reports_|rankings_|stadium_ui_|statistics_ui_|news_ui_|settings_ui_|desktop_ui_|files_ui_|mods_ui_|entry_ui_|opening_ui_|select_menu_|career_ui_|live_ui_|national_ui_|news_catalog_|post_match_ui_|engine_dto_|report_read_)" -LE external-data --output-on-failure --output-junit modern-ui-results.xml - name: Upload test report diff --git a/CMakeLists.txt b/CMakeLists.txt index 42154cd..d6a5b42 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1217,6 +1217,10 @@ add_test(NAME modern_camp_tests COMMAND modern_camp_tests) add_executable(modern_almanac_tests tests/modern_almanac_tests.cpp) target_link_libraries(modern_almanac_tests PRIVATE bmh_modern_content) add_test(NAME modern_almanac_tests COMMAND modern_almanac_tests) +add_executable(modern_manager_presentation_tests tests/modern_manager_presentation_tests.cpp) +target_link_libraries(modern_manager_presentation_tests PRIVATE bmh_modern_content) +add_test(NAME modern_manager_presentation_tests COMMAND modern_manager_presentation_tests) + add_executable(modern_rankings_read_tests tests/modern_rankings_read_tests.cpp) target_link_libraries(modern_rankings_read_tests PRIVATE bmh_modern_content) add_test(NAME modern_rankings_read_tests COMMAND modern_rankings_read_tests) diff --git a/docs/new_engine/README.md b/docs/new_engine/README.md index 9b5615b..34c942e 100644 --- a/docs/new_engine/README.md +++ b/docs/new_engine/README.md @@ -57,7 +57,7 @@ Für 0.3 gilt außerdem: | M3 | Modern-Weltlader, Namen (Vor-/Nachname, UTF-8), Asset-Schlüssel | Weltlader erledigt: Modern-Datensatz spielt zwei Saisons; Namen/Assets für die UI liegen in `ModernState`, Spielstände folgen mit M6 | | M4 | Trainingslager: 18 Lager, drei Karten, 6-Sterne-Wirkung | Engine erledigt (Katalog, Preis, 6-Sterne-Wirkung, Test); Saisonwirkung wird in M7 gemessen | | M5 | Datenrevision 1.4 des Modern-Datensatzes (privat), Wirtschaftsprüfung | erledigt: Revision 1.4 abgenommen (Lager, 100 Schiedsrichter, Geburtsdaten; siehe Phasen) | -| M6 | Modern-Spielstände (`modern-career-v1`), Projektionen für die UI | Spielstände erledigt (Rundreise identisch); UI-Projektionen schrittweise angebunden (u. a. Tabellen, Stärken, Liga-/Pokalspiele, Spielerstatistiken/Fairplay, Almanach) | +| M6 | Modern-Spielstände (`modern-career-v1`), Projektionen für die UI | Spielstände und native Neuanlage vorhanden (Rundreisen geprüft); UI-Projektionen schrittweise angebunden (u. a. Tabellen, Stärken, Liga-/Pokalspiele, Spielerstatistiken/Fairplay, Almanach) | | M7 | Balance-Läufe und Anpassungen | erledigt: Spielerwerte nach Rangfolge, Langläufe über 12 Saisons ohne Drift gegenüber Classic ([Balance](balance.md)); offen nur Läufe mit aktivem Manager | | M8 | Fußball-Almanach: alle Spiele mit Ereignissen und Aufstellungen ([Almanach](almanach.md)) | Engine und Leseprojektionen vorhanden; nativer Almanach angeschlossen; Elfmeterschuss-Aufzeichnung und belegte Altarchive korrigiert (#18) | | M9 | Nationalteams mit echten Kadern ([Nationalteams](nationalteams.md)) | Engine erledigt: 24 von 61 Nationen des Diamond-Datensatzes spielen mit Spielern | diff --git a/docs/new_engine/datenformat.md b/docs/new_engine/datenformat.md index faf3686..efdd6fb 100644 --- a/docs/new_engine/datenformat.md +++ b/docs/new_engine/datenformat.md @@ -139,6 +139,25 @@ Die bestehende Regel `rule:training-camps` (Typ `training_camps`) bleibt und wir - Die Integritätsprüfung deckt `history/` mit ab. - **Editor:** keine Änderung (öffnet keine Spielstände). Eine Welt muss nichts liefern; sinnvoll sind stabile Vereins- und Spieler-IDs, die sich zwischen Datenrevisionen nicht ändern. +### F8 · Optionale Managerdarstellung (29.10.2026) + +`state/modern.json` darf zusätzlich `manager_presentations` enthalten: eine Liste +mit `{id, name, portrait_style}`. `id` ist die stabile Manager-ID, `name` der +kanonische UTF-8-Anzeigename, `portrait_style` ist `photo` oder `painted`. +Fehlt die Liste, bleiben die bisherigen Originalnamen/Fotoansichten maßgeblich. +Die Einträge ändern keine Spielregeln oder Manageridentitäten. Die bestehenden +Originalrecords bleiben vollständig erhalten; das Feld mit 24 Originalbytes +ist keine UTF-8-Speichergrenze für die Modern-Anzeige. Native UI und neu erzeugte +Almanach-Managernamen bevorzugen die optionale Darstellung. Bereits archivierte +Namen werden nicht rückwirkend geändert. + +Spielstände mit Managerdarstellungen verwenden `modern-state@1.2`, damit ältere +Programme diese Angaben nicht unbemerkt beim erneuten Speichern verlieren. Ohne +Managerdarstellungen bleibt der Writer bei `modern-state@1.1`; der neue Reader +akzeptiert beide Versionen. Weltformat und Original-Spielstände bleiben unverändert. Doppelte/ungültige IDs, leere/überlange Namen +oder unbekannte Darstellungsarten werden abgewiesen. **Editor:** keine Änderung, +da der Welteditor keine Karriere-Spielstände bearbeitet. + ## F11 · Nationen - Die Nationalität eines Spielers hat in der Engine sechs Bit (Original: `w368` Bits 27–31 plus Bit 7 von `PlayerBonuses`, also 0–63); die Original-Nationen haben die Indizes 0–61 (`x-legacy.nationality_index`). Die Engine vergleicht Nationalitäten nur (deutsch oder ausländisch, gleiche Nation, Regionen bei Transfers), sie nutzt sie nicht als Tabellenindex. diff --git a/docs/new_engine/phasen.md b/docs/new_engine/phasen.md index 5af4d35..8b27ae1 100644 --- a/docs/new_engine/phasen.md +++ b/docs/new_engine/phasen.md @@ -158,3 +158,19 @@ Gelb-Rot und liefert die bekannten Darstellungsgewichte. Keine Regel-, OBW-, Spielstand- oder Editoränderung. Synthetische Tests prüfen Saison-/Vereinsgrenzen, Transfers, Tore/Assists, Einsätze, Karten und Gleichstände. Private QA: `bmh_4k_ui/docs/qa/engine-rankings-2026-10-28/`. + +### M6 · Native Neuanlage und Managerdarstellung, 29. Oktober 2026 + +Der bestehende Wizard erstellt eine ModernSession über confirm_manager/finish. +Stabile Vereinszuordnungen werden nach der Initialisierung geprüft. Ein reiner +opening-Read projiziert aktive Europapokal-Listen und tatsächliche DFB-Paarungen; +Präsentationsschritte lösen keine zweite Auslosung aus. Die UI übernimmt erst +fertige Session, konsistenten Snapshot und Bildkatalog vom Hintergrund-Worker. + +Optionale UTF-8-/Porträt-Metadaten sind in F8 dokumentiert. Neue Karrieren mit +Angaben verwenden modern-state@1.2, ältere ohne Angaben weiter 1.1. Classic- +Records und Weltformat bleiben unverändert; der Editor öffnet keine Karrieren. +Ein/zwei/vier Menschen, drei Themes, 720p/1080p, reine Nationalwahl und +OBS-Neustarts sind geprüft. 54 synthetische CTests und private Bytevergleiche +bestehen. Anstoß bleibt gesperrt. Private QA: +bmh_4k_ui/docs/qa/engine-new-career-2026-10-29/. diff --git a/docs/new_engine/ui-abfragen.md b/docs/new_engine/ui-abfragen.md index 7f8f35b..c2fd993 100644 --- a/docs/new_engine/ui-abfragen.md +++ b/docs/new_engine/ui-abfragen.md @@ -80,3 +80,14 @@ sind enthalten. Die Gewichtung ist eine Anzeigeauswertung, keine Disziplinarrege Beide Reads sind rein und revisionsgebunden. Es gibt keinen Demoersatz bei leeren Kategorien und keine erfundenen Fotos/Profilwerte. OBW und Editor bleiben unverändert. + +## Saisonvorbereitung nach Neuanlage + +`ui_read {kind: "opening"}` liefert `enabled`, `showEntrants`, `entrants` +mit `uefa`/`champions`/`winners` (je Teamreferenzen), `order` (abwechselnd Heim/ +Auswärts der tatsächlichen DFB-Erstrundenpaarungen) und passende `fixtureIds`. +Die übliche Snapshot-Hülle bindet an Karriere, Welt, Manager und Revision. +Quelle sind die aktiven Europapokal-Listen der Engine und die vorhandene +Pokalprojektion; Original-Pixel-Platzierungstabellen werden nicht benötigt. Die Abfrage +initialisiert oder würfelt nichts. Die native UI verwendet sie direkt nach +Neuanlage; ein späteres Laden erzeugt keine weitere Karriere. diff --git a/docs/new_ui/NATIVE_STATUS.md b/docs/new_ui/NATIVE_STATUS.md index 16a687a..55843b1 100644 --- a/docs/new_ui/NATIVE_STATUS.md +++ b/docs/new_ui/NATIVE_STATUS.md @@ -5,8 +5,8 @@ bedienbarer Durchlauf. Noch keine vollständige Umsetzung des HTML-Mockups.** Die normale Classic-Konfiguration bleibt unverändert; die neue Oberfläche wird ausdrücklich mit `OPENBMH_BUILD_MODERN_UI=ON` gebaut. -Der [opt-in Engine-Einstieg](integration/ENGINE_ENTRY.md) lädt inzwischen eine -echte Modern-OBS-Karriere und bindet Schreibtisch, Trainingslager, Aufstellung, Taktik, Training, Bank, Eintrittspreis, Umfeld, Werbung, Spielerverträge, Vereinskalender, Spielverlegung, Vereins-/Nationalfreundschaftsspiele, den Almanach sowie Tabellen, Stärken, Ligaspiele, übrige Spiele, Spielerstatistiken und Fairplay an die +Der [Engine-Einstieg](integration/ENGINE_ENTRY.md) erzeugt über den +vorhandenen Wizard eine echte Karriere oder lädt eine Modern-OBS-Karriere und bindet Schreibtisch, Trainingslager, Aufstellung, Taktik, Training, Bank, Eintrittspreis, Umfeld, Werbung, Spielerverträge, Vereinskalender, Spielverlegung, Vereins-/Nationalfreundschaftsspiele, den Almanach sowie Tabellen, Stärken, Ligaspiele, übrige Spiele, Spielerstatistiken und Fairplay an die Session. Kader und Profile zeigen die tatsächlichen Sessionwerte; Spielertausch verwendet die bestätigte Engineaktion. Preisbestätigung, Buchung und Speichern als neue OBS-Datei sind echte Engineoperationen. Dieser Einstieg ist auf diesen Umfang begrenzt; die übrigen diff --git a/docs/new_ui/README.md b/docs/new_ui/README.md index 6034920..1666ab8 100644 --- a/docs/new_ui/README.md +++ b/docs/new_ui/README.md @@ -17,8 +17,8 @@ Implementierung in der Spiel-Engine. | QA-Befunde | [Offene Abweichungen zur HTML-Referenz](qa-findings.md) | | Ressourcen | [GUI-Assets, Weltbilder und spätere Paketbereinigung](assets.md) | | Hauptmenü & Mods | [Bibliothek, Import und explizite Aktivierung](main-menu/README.md) | -| Spieleinstieg | [Grundeinstellungen, Managerwahl und Bestätigung](main-menu/entry/README.md) | -| Saisonvorbereitung | [Teilnehmer, Ziehung und Fortsetzung](main-menu/opening/README.md) | +| Spieleinstieg | [Reale Karriereanlage, Grundeinstellungen, Managerwahl und Bestätigung](main-menu/entry/README.md) | +| Saisonvorbereitung | [Echte Teilnehmer/Paarungen, gemeinsame Präsentation und getrennte Demo](main-menu/opening/README.md) | | Desktop | [Statusleiste, Gestaltung und Fenster](desktop/README.md) | | Live-Ticker-Demo | [Vorgegebene Aufzeichnung, unabhängige Managerdetails und Read-Provider](desktop/live/README.md) | | Nach dem Spiel | [Native 5/3-Seitenauswertung der gehaltenen Aufnahme](desktop/post-match/README.md) | diff --git a/docs/new_ui/integration/ENGINE_ENTRY.md b/docs/new_ui/integration/ENGINE_ENTRY.md index e1a9c9d..39a11d9 100644 --- a/docs/new_ui/integration/ENGINE_ENTRY.md +++ b/docs/new_ui/integration/ENGINE_ENTRY.md @@ -1,7 +1,8 @@ # Nativer Engine-Einstieg: Schreibtisch, Vereins-/Nationalplanung und Archiv -Der opt-in Einstieg lädt eine bestehende Modern-Karriere aus einer OBS-Datei. +Der Einstieg kann eine neue Runtime-Modern-Karriere aus dem vorhandenen Wizard +erzeugen oder eine bestehende Modern-Karriere aus einer OBS-Datei laden. Er ist ein erster vertikaler Integrationsschritt, kein vollständiger spielbarer Modern-Frontend-Ersatz. Der bisherige UI-Demomodus bleibt separat erhalten. @@ -328,3 +329,19 @@ Revisionskontext. Tabs bleiben lokal, Sessionmutationen verwerfen den Cache. Profile zeigen aktuelle Kaderwerte oder ausdrücklich unbekannte Angaben bei nur noch archivierten Personen. [Spielerstatistiken](../desktop/scorers/README.md) und [Fairplay](../desktop/fairplay/README.md) beschreiben Umfang und Grenzen. + +## Neuanlage aus dem Hauptmenü · 29. Oktober 2026 + +Ohne `--modern-ui-demo` erzeugt der Abschluss des Wizards eine echte Session +über `confirm_manager`/`finish`. `--ui-career` bleibt der direkte OBS-Einstieg. +Ein reiner `opening`-Read liefert tatsächliche Teilnehmer und Pokalpaarungen; +die vorhandene Introgestaltung zeigt diese Daten ohne zweite Auslosung. +Erst nach Abschluss erscheint der gebundene Schreibtisch. Anstoß bleibt gesperrt. +[Karriereanlage](../main-menu/entry/README.md) und +[Saisonvorbereitung](../main-menu/opening/README.md) beschreiben den Ablauf. + +Beim Beenden einer ungespeicherten echten Partie stehen Abbrechen, Speichern +und beenden sowie Ohne Speichern beenden zur Auswahl. Ein abgebrochener oder +fehlgeschlagener Save schließt die Partie nicht; vorhandene Zieldateien werden +weiterhin nicht überschrieben. Der vollständige moderne Dateibibliotheksdialog +ist ein getrenntes Folgepaket. diff --git a/docs/new_ui/main-menu/entry/README.md b/docs/new_ui/main-menu/entry/README.md index 6b7a121..66503fe 100644 --- a/docs/new_ui/main-menu/entry/README.md +++ b/docs/new_ui/main-menu/entry/README.md @@ -9,7 +9,7 @@ werden als separates Paket geführt. ## Ablauf und Datenvertrag „Neues Spiel“ öffnet zuerst vier gleich große Grundeinstellungen: Dauer, -Schwierigkeit, Mitspieler und Modus. Die Grenzen und Wettbewerbsabhängigkeiten +Schwierigkeit, Mitspieler und Wettbewerbswahl. Modus III bleibt fest. Die Grenzen und Wettbewerbsabhängigkeiten entsprechen dem HTML-Mockup. Ein eigener Katalogverweis versorgt die Managerauswahl; die laufende DemoSource, Revision und Arbeitsansicht werden beim Öffnen oder Abbrechen nicht ersetzt. @@ -75,3 +75,44 @@ Rml-Attribut `[disabled]` ihre volle aktive Farbe. Sie bleibt gesperrt und gedr der vorhandene Legendentext erklärt, weshalb Vereinsfußball aktiv bleibt. Der CSS-only Nachweis auf dem bestehenden Binary zeigt volle Illustration bei unverändertem Sperrstatus. Keine Auswahl-/Spielregel wurde geändert. + +## Reale Karriereanlage · 29. Oktober 2026 + +Der normale Einstieg mit einer Runtime-Modern-Welt führt nach der letzten +Bestätigung über `EngineBridge::create` zur ModernSession. Modus III bleibt fest; +Dauer, Schwierigkeit, Zahl der Menschen und die beiden Wettbewerbsbereiche +werden aus dem vorhandenen Entwurf übernommen. Ausländische Vereine bleiben +sichtbar und gesperrt. Erst die endgültige Bestätigung erzeugt eine Partie; +alle vorherigen Dialogschritte und Abbrüche bleiben reine UI-Entwürfe. + +Die Bridge prüft stabile Vereins-IDs gegen die Welt und übergibt Original- +Master-ID, Startliga, Startstärke und Porträt an `confirm_manager`. `finish` +bleibt allein für die Karriereinitialisierung zuständig. Nach der Anlage werden +die tatsächlichen Vereinszuordnungen für alle Menschen geprüft. Es gibt keine +zweite Initialisierungs-, Geld- oder Auslosungslogik im Frontend. + +Eine neue Session wird zunächst auf dem Hintergrund-Worker vollständig aufgebaut. +Die UI übernimmt sie erst zusammen mit Bildkatalog und konsistentem Snapshot. +Bei einem Fehler bleibt der Managerentwurf erhalten. Eine laufende echte Partie +wird dabei nicht parallel durch eine zweite Session ersetzt. Die neue Karriere +ist bis zum Speichern ausdrücklich ungespeichert; Anstoß bleibt gesperrt. + +Kanonische UTF-8-Namen und `photo`/`painted` werden als optionale Modern- +Darstellung an stabile Manager-IDs gebunden und im OBS erhalten. Neue Spielstände mit diesen Angaben verwenden `modern-state@1.2`; alte +Karrieren ohne Angaben bleiben unter 1.1 lesbar. Das Format ist +unter [F8](../../../new_engine/datenformat.md) beschrieben. Originalrecords und +Spielregeln bleiben unverändert; ältere OBS ohne diese Angaben behalten ihren +bisherigen Fallback. Die gewählte Porträtart ist auch auf dem echten Desktop sichtbar. + +`--modern-ui-demo` bleibt die explizite getrennte Präsentationsdemo. Sie verwendet +weiterhin ihre JSON-Stände und erzeugt keine Enginekarriere. `--ui-seed ` +ist eine optionale QA-Vorgabe für reproduzierbare Spielinitialisierung; Karriere- +und Manageridentitäten bleiben eigene Metadaten. + +Private Nachweise werden unter `bmh_4k_ui/docs/qa/engine-new-career-2026-10-29/` +geführt. 54 synthetische CTests, 123 Haupt-GUI-Prüfungen, 12 Randfallprüfungen +und 704 Geometrieprüfungen sind bestanden. Die Matrix erfasst drei Themes, +720p/1080p und einen/zwei/vier Menschen. Die vollständige automatische Auslosung, +Speichern/Neustart, abgelehnte Bestätigungen, reiner Nationalstart und ein +fehlgeschlagenes Speichern beim Beenden sind geprüft. Native Ausführung Linux x64; +Windows/macOS wurden nicht ausgeführt. diff --git a/docs/new_ui/main-menu/opening/README.md b/docs/new_ui/main-menu/opening/README.md index 5b3bc95..2dae2e3 100644 --- a/docs/new_ui/main-menu/opening/README.md +++ b/docs/new_ui/main-menu/opening/README.md @@ -63,3 +63,35 @@ Wiederaufnahme sowie den Vorrang ausdrücklich geladener Checkpoints. Bilder, Eingaben und UI-Zustände liegen privat unter `docs/qa/opening-batch-2026-10-26`. Browser-Themes werden über die tatsächlichen Optionen eingestellt und im DOM geprüft; ein URL-Parameter allein genügt nicht. + +## Engine-Saisonvorbereitung · 29. Oktober 2026 + +Ein reiner `opening`-Read der ModernSession liefert die tatsächlichen deutschen +Europapokalteilnehmer aus den vorhandenen aktiven Europapokal-Listen der Engine und die +bereits von der Engine erzeugten Erstrundenpaarungen des DFB-Pokals. Die alten Pixel-Platzierungstabellen werden nicht benötigt. IDs, +Mannschaftsnamen, Reihenfolge und Fixture-IDs werden an denselben Snapshot- +Kontext wie der Schreibtisch gebunden. Ein reiner Nationalstart erhält keine +Vereinsauslosung. + +Der bestehende RmlUI-Presenter bleibt erhalten. Er bekommt einen separaten +Engine-Ansichtszustand; weder Demo-Qualifikationen noch Demo-Auslosungen werden +in die Karriere übernommen. Beide Quellen teilen nur die Präsentationsschritte +Weiter, Pause/Fortsetzen, schrittweises Aufdecken, Überspringen und Abschluss. +Die Anzeige zieht keine Zufallszahlen und löst keine zweite Auslosung aus. + +Zwischen letzter Bestätigung und Desktop gibt es weiterhin keinen X-Knopf. +Rechtsklick/Escape beenden die Folge nicht. Die Buttons sind per Tab und +Enter/Leertaste erreichbar. Neue Partien bleiben bis zum tatsächlichen OBS- +Speichern ungespeichert; die Intro-Schritte verändern keine Spielrevision. +Eine geladene OBS startet am Schreibtisch und wiederholt keine Initialisierung. + +Die schrittweise UI-Aufdeckung selbst ist noch kein Bestandteil der OBS. +Ein Speichern/Neustart setzt die bereits erzeugte Karriere mit denselben +Paarungen fort; es werden keine neuen Teilnehmer oder Lose erzeugt. + +Die native Prüfung umfasst die vollständig automatische Aufdeckung aller 64 +Mannschaften und Abbruchversuche per Escape/Rechtsklick, Pause/Fortsetzen, +Überspringen, 32 echte Paarungen sowie OBS-Neustart ohne erneute Initialisierung. +Initialer und abschließender nativer Spielzustand sowie RNG-/Archivbytes bleiben +bei reinen Präsentationsschritten identisch. Private Nachweise: +`bmh_4k_ui/docs/qa/engine-new-career-2026-10-29/`. diff --git a/src/app/main.cpp b/src/app/main.cpp index b1b4373..698548c 100644 --- a/src/app/main.cpp +++ b/src/app/main.cpp @@ -118,6 +118,11 @@ int main(int argc, char** argv) { #ifdef OPENBMH_MODERN_UI if (is("--modern-ui-demo")) { modern_demo = true; + modern_config.preview_only = true; + } else if (is("--ui-seed") && value) { + const auto text = args[++i]; size_t used=0; const auto n=std::stoull(text,&used); + if(used!=text.size()||n>UINT32_MAX||text.empty()||text.front()=='-')throw std::runtime_error("Ungültiger Modern-Startseed."); + modern_config.creation_seed=uint32_t(n);modern_demo=true; } else if (is("--gui-assets") && value) { modern_config.gui_assets = launch::path_from_utf8(args[++i]); } else if (is("--ui-scene") && value) { @@ -135,6 +140,7 @@ int main(int argc, char** argv) { modern_demo = true; } else if (is("--ui-state") && value) { modern_config.state = launch::path_from_utf8(args[++i]); + modern_config.preview_only = true; } else if (is("--ui-preferences") && value) { modern_config.preferences = launch::path_from_utf8(args[++i]); } else if (is("--ui-userdata") && value) { diff --git a/src/modern/app/modern_session.cpp b/src/modern/app/modern_session.cpp index 282fdd7..0e7fe12 100644 --- a/src/modern/app/modern_session.cpp +++ b/src/modern/app/modern_session.cpp @@ -54,6 +54,7 @@ #include "formats/fbm.hpp" #include "formats/savestate.hpp" #include "modern/game/career.hpp" +#include "ui/season_entrants.hpp" #include "modern/game/cup.hpp" #include "modern/game/driver.hpp" #include "modern/game/desk.hpp" @@ -8947,12 +8948,41 @@ cli::Json ModernSession::ui_read(const cli::Json& request, uint64_t revision) co const std::string kind = ui_text(request, "kind"), request_id = ui_text(request, "requestId"); const int manager = context.manager; if (manager < 0 || size_t(manager) >= g_.manager_teams.size() || - (kind != "lineup" && kind != "tactics" && kind != "training" && kind != "bank" && kind != "contracts" && + (kind != "opening" && kind != "lineup" && kind != "tactics" && kind != "training" && kind != "bank" && kind != "contracts" && kind != "advertising" && kind != "stadium" && kind != "transfer" && kind != "postmatch" && kind != "credit" && !(kind == "friendly" && g_.manager_teams[size_t(manager)] == no_team()))) return modern::ui_read(g_, context, request); if (const std::string wanted = ui_text(request, "managerId"); !wanted.empty() && wanted != modern::ui_manager_id(g_, manager)) return modern::ui_error(request_id, "manager_not_active", "Dieser Manager sitzt nicht am Schreibtisch.", revision, false); + if (kind == "opening") { + try { + O entrants{{"uefa", A{}}, {"champions", A{}}, {"winners", A{}}}; A order, fixtures; + const bool enabled = g_.memory.has(::bmh::layout::CompetitionSelection) && (g_.memory.u32(::bmh::layout::CompetitionSelection) & 1) != 0; + const auto team = [&](int runtime) { + if (runtime < 0 || size_t(runtime) >= g_.world_club_id.size()) throw FormatError("opening participant outside world"); + const auto name = size_t(runtime) < g_.world_club_name.size() && !g_.world_club_name[size_t(runtime)].empty() ? g_.world_club_name[size_t(runtime)] : ui::original_to_utf8(g_.club_name(runtime)); + return cli::Json(O{{"id", modern::ui_team_id(g_, runtime)}, {"name", name}}); + }; + // Read the same active prefixes as EuropeanClub/SeasonEntrants, without + // depending on Classic's executable pixel-placement and badge tables. + constexpr uint32_t pools[]{::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField25,::bmh::layout::Career_CompetitionPointersEnglish_RuntimeField14,::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField19}; + constexpr uint32_t counts[]{::bmh::layout::Career_EuropeanClub_ExecutableField,::bmh::layout::Career_EuropeanClub_ExecutableField2,::bmh::layout::Career_EuropeanClub_ExecutableField3}; + constexpr const char* keys[]{"uefa", "champions", "winners"}; + if(enabled)for(size_t competition=0;competition<3;++competition) { + std::set seen;const int count=g_.memory.u8(counts[competition]); + for(int i=0;i(entrants.at(keys[competition]).value).push_back(team(runtime));} + } + if (enabled) { + const auto pairs = modern::query_projection(g_, manager, O{{"kind", "other-fixtures"}, {"viewId", "cup-view:0:0"}, {"round", 1}}); + const auto* p = pairs.object(); + if (!p || !p->count("matches")) throw FormatError("opening cup pairings unavailable"); + for (const auto& match : *p->at("matches").array()) { + const auto& m = *match.object(); order.push_back(m.at("home")); order.push_back(m.at("away")); fixtures.push_back(m.at("id")); + } + } + return modern::ui_snapshot(g_, context, request_id, O{{"kind", "opening"}, {"enabled", enabled}, {"showEntrants", enabled}, {"entrants", std::move(entrants)}, {"order", std::move(order)}, {"fixtureIds", std::move(fixtures)}}); + } catch (const std::exception&) { return modern::ui_error(request_id, "opening_unavailable", "Die Saisonvorbereitung ist derzeit nicht verfügbar.", revision, false); } + } if (kind == "friendly") { // the national coach's friendly (menu 6): the quote rates both teams with a draw of the // Watcom generator; the read quotes on a copy of it (the session's generator stays as it diff --git a/src/modern/content/projections.cpp b/src/modern/content/projections.cpp index ce19409..b60b5c2 100644 --- a/src/modern/content/projections.cpp +++ b/src/modern/content/projections.cpp @@ -105,6 +105,7 @@ int32_t money_of(const ModernState& g, int manager) { } std::string manager_name(const ModernState& g, int manager) { + if (const auto* p = g.manager_presentation(manager)) return p->name; std::string name; const size_t at = size_t(manager) * kRecord + 0xa8; for (size_t i = 0; i < 30 && at + i < g.manager_records.size() && g.manager_records[at + i]; ++i) diff --git a/src/modern/content/statistics.cpp b/src/modern/content/statistics.cpp index d1cacb2..184131b 100644 --- a/src/modern/content/statistics.cpp +++ b/src/modern/content/statistics.cpp @@ -738,7 +738,7 @@ cli::Json query_statistics_screen(const ModernState& g, int manager, const cli:: O out{{"ok", true}, {"fictional", false}, {"available", true}, {"section", section}, {"category", category}, {"country", country}, {"winner_country", winner_country}, {"absolute", absolute}, {"curves", curves}, {"title", kSections[section]}, {"season", season_label(year)}, {"previous_season", season_label(year - 1)}, - {"year", year}, {"manager", manager_name.empty() ? "—" : almanac_utf8(manager_name)}, + {"year", year}, {"manager", g.manager_presentation(manager) ? g.manager_presentation(manager)->name : manager_name.empty() ? "—" : almanac_utf8(manager_name)}, {"club", club ? J(own_id) : J(nullptr)}, {"columns", A{}}, {"rows", A{}}, {"countries", std::move(countries)}, {"sections", std::move(sections)}, {"world_views", std::move(views)}, {"series", A{}}, {"eternal_countries", std::move(eternal)}}; diff --git a/src/modern/content/ui_contract.cpp b/src/modern/content/ui_contract.cpp index 0984a05..34435e7 100644 --- a/src/modern/content/ui_contract.cpp +++ b/src/modern/content/ui_contract.cpp @@ -69,6 +69,7 @@ int human_managers(const ModernState& g) { } std::string manager_name(const ModernState& g, int manager) { + if (const auto* p = g.manager_presentation(manager)) return p->name; std::string name; const size_t at = size_t(manager) * kRecord + 0xa8; for (size_t i = 0; i < 30 && at + i < g.manager_records.size() && g.manager_records[at + i]; ++i) @@ -120,12 +121,14 @@ J manager_json(const ModernState& g, int manager, bool at_desk) { const int team = team_of(g, manager); const size_t at = size_t(manager) * kRecord; const int portrait = at + 0x221 < g.manager_records.size() ? g.manager_records[at + 0x221] : 0; + const auto* presentation = g.manager_presentation(manager); + const std::string style = presentation ? presentation->portrait_style : "photo"; const bool ended = !g.career_end_reason.empty(); const char* status = !ended ? "active" : g.career_end_reason == "last_human_resigned" ? "resigned" : "retired"; return O{{"id", manager_id(g, manager)}, {"slot", manager}, {"name", manager_name(g, manager)}, {"control", ended ? "archived" : "human"}, {"status", status}, {"teamId", team >= 0 ? J(team_id(g, team)) : J(nullptr)}, - {"portraitGuiKey", "gui:manager/photo/" + std::to_string(portrait)}, {"portraitStyle", "photo"}, + {"portraitGuiKey", "gui:manager/" + style + "/" + std::to_string(portrait)}, {"portraitStyle", style}, {"strengthChoice", nullptr}, {"employments", manager_employments(g, manager, manager_id(g, manager))}}; } diff --git a/src/modern/content/world_save.cpp b/src/modern/content/world_save.cpp index 1c7357b..d7abb27 100644 --- a/src/modern/content/world_save.cpp +++ b/src/modern/content/world_save.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include "content/digest.hpp" #include "content/package.hpp" @@ -43,6 +44,20 @@ std::vector strings(const J& value) { for (const J& v : arr(value)) out.push_back(str(v)); return out; } +J manager_presentations_json(const std::vector& values) { + A out; + for (const auto& p : values) out.push_back(O{{"id", p.id}, {"name", p.name}, {"portrait_style", p.portrait_style}}); + return out; +} +std::vector manager_presentations_json(const J& value) { + std::vector out; std::set ids; + for (const auto& row : arr(value)) { + ModernState::ManagerPresentation p{str(get(row, "id")), str(get(row, "name")), str(get(row, "portrait_style"))}; + if (!p.id.starts_with("manager:") || p.id.size() > 64 || !ids.insert(p.id).second || p.name.empty() || p.name.size() > 96 || p.name.find('\0') != std::string::npos || (p.portrait_style != "photo" && p.portrait_style != "painted")) fail("invalid manager presentation"); + out.push_back(std::move(p)); + } + return out; +} std::string world_identity(const World& world) { return world.id + "@" + world.data_revision; } // Exclusive sponsor offers and queued contracts per manager (docs/new_engine/trainingslager.md). @@ -137,7 +152,7 @@ void save_world_career(const std::filesystem::path& path, const World& world, co {"world", O{{"id", world.id}, {"data_revision", world.data_revision}, {"title", world.title}}}}); put(docs, "state/career.json", encode_native_state(state)); put(docs, "state/modern.json", - O{{"schema", "modern-state@1.1"}, + O{{"schema", state.manager_presentations.empty() ? "modern-state@1.1" : "modern-state@1.2"}, {"club_ids", strings(state.world_club_id)}, {"club_names", strings(state.world_club_name)}, {"club_short_names", strings(state.world_club_short)}, @@ -153,6 +168,7 @@ void save_world_career(const std::filesystem::path& path, const World& world, co {"career_id", state.career_id}, {"manager_ids", strings(state.manager_ids)}, {"manager_serial", int64_t(state.manager_serial)}, + {"manager_presentations", manager_presentations_json(state.manager_presentations)}, {"traffic_scale", int64_t(state.traffic_scale)}, {"press", press_json(state.press)}, {"press_serial", int64_t(state.press_serial)}, @@ -196,7 +212,8 @@ SavedWorldCareer load_world_career(const std::filesystem::path& path, const Worl SavedWorldCareer out; out.state = ModernState(decode_native_state(parse(docs, "state/career.json"))); const auto modern = parse(docs, "state/modern.json"); - if (str(get(modern, "schema")) != "modern-state@1.1") fail("unsupported Modern state"); + const auto modern_schema = str(get(modern, "schema")); + if (modern_schema != "modern-state@1.1" && modern_schema != "modern-state@1.2") fail("unsupported Modern state"); out.state.world_club_id = strings(get(modern, "club_ids")); out.state.world_club_name = strings(get(modern, "club_names")); out.state.world_club_short = strings(get(modern, "club_short_names")); @@ -214,6 +231,7 @@ SavedWorldCareer load_world_career(const std::filesystem::path& path, const Worl out.state.career_id = str(get(modern, "career_id")); out.state.manager_ids = strings(get(modern, "manager_ids")); out.state.manager_serial = uint32_t(num(get(modern, "manager_serial"))); + if (o->count("manager_presentations")) out.state.manager_presentations = manager_presentations_json(get(modern, "manager_presentations")); if (o->count("traffic_scale")) out.state.traffic_scale = uint8_t(num(get(modern, "traffic_scale"))); if (o->count("press")) { out.state.press = press_json(get(modern, "press")); diff --git a/src/modern/game/almanac.cpp b/src/modern/game/almanac.cpp index 5d91fb1..399d735 100644 --- a/src/modern/game/almanac.cpp +++ b/src/modern/game/almanac.cpp @@ -64,6 +64,7 @@ AlmanacClub club_of(const ModernState& g, int team) { AlmanacManager manager_of(const ModernState& g, int manager) { AlmanacManager m; m.index = manager; + if (const auto* p = g.manager_presentation(manager)) { m.name = p->name; return m; } const size_t at = size_t(manager) * kManagerRecord + 0xa8; // the manager's name (30 bytes) for (size_t i = 0; i < 30 && at + i < g.manager_records.size() && g.manager_records[at + i]; ++i) m.name.push_back(char(g.manager_records[at + i])); diff --git a/src/modern/game/modern_state.hpp b/src/modern/game/modern_state.hpp index f226115..f159d91 100644 --- a/src/modern/game/modern_state.hpp +++ b/src/modern/game/modern_state.hpp @@ -82,6 +82,18 @@ struct ModernState : GameState { std::string career_id; std::vector manager_ids; uint32_t manager_serial = 0; + // Optional Modern-only display metadata, keyed by stable manager identity. + // Original records remain byte-compatible and are the fallback for older saves. + struct ManagerPresentation { + std::string id, name, portrait_style = "photo"; + bool operator==(const ManagerPresentation&) const = default; + }; + std::vector manager_presentations; + const ManagerPresentation* manager_presentation(int slot) const { + if (slot < 0 || size_t(slot) >= manager_ids.size()) return nullptr; + for (const auto& p : manager_presentations) if (p.id == manager_ids[size_t(slot)]) return &p; + return nullptr; + } // The press journal (content/press_journal.hpp): business events the almanac cannot give // (transfers, contracts, toto, seasons, managers), noted once when they happen and saved, so // the interface's news keep their ids. `data` is the event's facts as JSON text. diff --git a/src/modern/ui/controls.inc b/src/modern/ui/controls.inc index 4e1acc5..6004d8e 100644 --- a/src/modern/ui/controls.inc +++ b/src/modern/ui/controls.inc @@ -901,8 +901,8 @@ void App::script() { const auto type = command.value("type", std::string()); if (type == "engine-wait") { const auto until = SDL_GetTicks64() + command.value("timeout_ms", uint64_t(300000)); - while (engine_busy_ && SDL_GetTicks64() < until) { pump_events(); frame(); SDL_Delay(10); } - if (engine_busy_) throw editor::Error("Engine-Vorgang hat das QA-Zeitlimit überschritten."); + while ((engine_busy_ || engine_creation_busy_) && SDL_GetTicks64() < until) { pump_events(); frame(); SDL_Delay(10); } + if (engine_busy_ || engine_creation_busy_) throw editor::Error("Engine-Vorgang hat das QA-Zeitlimit überschritten."); } else if(type=="window-resize-probe"){ // QA-only synthetic event: no OS window or mouse coordinate is changed. int w,h,pw,ph;SDL_GetWindowSize(video_.window,&w,&h);video_.drawable_size(pw,ph); diff --git a/src/modern/ui/demo_opening.cpp b/src/modern/ui/demo_opening.cpp index 5cb2d41..d667d89 100644 --- a/src/modern/ui/demo_opening.cpp +++ b/src/modern/ui/demo_opening.cpp @@ -157,18 +157,11 @@ bool migrate_demo_opening(Json &state, const Catalog &world) { return false; } } -std::string edit_demo_opening(Json &state, const Json &action, - const Catalog &world) { +std::string advance_opening_presentation(Json &source,const std::string &kind) { try { - if (!action.is_object() || action.size() != 1 || !action.contains("kind") || - !action.at("kind").is_string()) - return "Ungültige Aktion der Saisonvorbereitung."; - auto next = state; - if (!migrate_demo_opening(next, world)) - return "Die gespeicherte Saisonvorbereitung ist ungültig."; - auto &flow = next.at("opening_flow"); - const auto kind = action.at("kind").get(), - phase = flow.at("phase").get(); + auto flow=source; + if(!flow.at("order").is_array()||!flow.at("revealed").is_number_integer()||flow.at("revealed").get()<0||flow.at("revealed").get()>flow.at("order").size()||!flow.at("playing").is_boolean())return "Ungültiger Darstellungszustand der Saisonvorbereitung."; + const auto phase = flow.at("phase").get(); const auto total = flow.at("order").size(); if (kind == "next") { if (phase == "uefa") @@ -212,6 +205,21 @@ std::string edit_demo_opening(Json &state, const Json &action, flow["playing"] = false; } else return "Unbekannte Aktion der Saisonvorbereitung."; + source=std::move(flow);return {}; + }catch(const std::exception&){return "Ungültiger Darstellungszustand der Saisonvorbereitung.";} +} +std::string edit_demo_opening(Json &state, const Json &action, + const Catalog &world) { + try { + if (!action.is_object() || action.size() != 1 || !action.contains("kind") || + !action.at("kind").is_string()) + return "Ungültige Aktion der Saisonvorbereitung."; + auto next = state; + if (!migrate_demo_opening(next, world)) + return "Die gespeicherte Saisonvorbereitung ist ungültig."; + auto &flow = next.at("opening_flow"); + const auto error=advance_opening_presentation(flow,action.at("kind")); + if(!error.empty())return error; const bool done = flow.at("phase").get() == "done"; next["opening"] = done ? "complete" : "pending"; next["opening_created"] = done && flow.at("created").get(); diff --git a/src/modern/ui/demo_opening.hpp b/src/modern/ui/demo_opening.hpp index 136c67b..6553c17 100644 --- a/src/modern/ui/demo_opening.hpp +++ b/src/modern/ui/demo_opening.hpp @@ -6,6 +6,8 @@ namespace bmh::modern_ui { // Fictional UI participants, derived solely from the immutable catalogue. // No engine draw, actual qualification or gameplay random stream is involved. Json make_demo_opening(const Catalog &, const Json &state, bool created); +// Presentation steps never create participants or pairings; used by both sources. +std::string advance_opening_presentation(Json &flow,const std::string &kind); // Missing legacy flows are migrated; existing inconsistent flows are rejected. // Both migration and edits leave the input untouched on rejection. bool migrate_demo_opening(Json &state, const Catalog &); diff --git a/src/modern/ui/engine_bridge.cpp b/src/modern/ui/engine_bridge.cpp index ec76ee1..e4649e8 100644 --- a/src/modern/ui/engine_bridge.cpp +++ b/src/modern/ui/engine_bridge.cpp @@ -2,6 +2,9 @@ #include "modern/ui/engine_bridge.hpp" #include "modern/app/modern_session.hpp" #include "modern/content/world_package.hpp" +#include "modern/content/ui_contract.hpp" +#include "modern/ui/model.hpp" +#include namespace bmh::modern_ui { namespace { @@ -21,6 +24,34 @@ struct EngineBridge::Impl { session = std::make_unique(mount->root(), 1u, save, false); } catch (...) { modern::set_current_world(nullptr); throw; } } + Impl(const fs::path &world,const Json &setup,const Json &managers,uint32_t seed) : package(modern::open_world_package(world)) { + const auto integer=[&](const char* key,int low,int high){const auto &v=setup.at(key);if(!v.is_number_integer()||v.get()()>high)throw editor::Error("Ungültige Grundeinstellung: "+std::string(key));return v.get();}; + ui::SetupOptions options;options.mode=integer("mode",3,3);options.duration=integer("duration",0,5);options.difficulty=integer("difficulty",0,9);options.managers=integer("players",1,4); + if(!setup.at("league").is_boolean()||!setup.at("world").is_boolean())throw editor::Error("Ungültige Wettbewerbswahl.");options.league=setup.at("league");options.world=setup.at("world"); + if((!options.league&&!options.world)||!managers.is_array()||managers.size()!=size_t(options.managers))throw editor::Error("Die Manager- oder Wettbewerbswahl ist unvollständig."); + std::vector choices;std::vector names,styles;std::set clubs;std::set portraits; + for(const auto &m:managers) { + if(!m.at("name").is_string()||!m.at("club").is_string())throw editor::Error("Managername oder Verein fehlt.");const auto name=normalized_manager_name(m.at("name").get());if(!name)throw editor::Error("Bitte einen gültigen Managernamen angeben."); + const auto id=m.at("club").get();const auto *club=package.world->club(id);const modern::WorldLeague *league=nullptr; + if(club)for(const auto &l:package.world->leagues)if(l.id==club->competition)league=&l; + if(!club||!league||league->index<0||league->index>4||club->legacy_index<0||!clubs.insert(id).second)throw editor::Error("Dieser Verein ist für die Managerwahl nicht verfügbar."); + const auto &portrait=m.at("portrait"),&strength=m.at("strength_choice");if(!portrait.is_number_integer()||portrait.get()<0||portrait.get()>11||!portraits.insert(portrait.get()).second||!strength.is_number_integer()||strength.get()<0||strength.get()>2)throw editor::Error("Ungültige Managerdarstellung oder Startstärke."); + const auto style=m.value("portrait_style",std::string("photo"));if(style!="photo"&&style!="painted")throw editor::Error("Ungültige Porträtart."); + ui::ManagerChoice choice;choice.slot=int(choices.size());choice.master_club=club->legacy_index;choice.start_league=league->index;choice.strength=strength;choice.portrait=portrait; + try {choice.name=ui::utf8_to_original(*name);}catch(const std::exception&){choice.name="Manager "+std::to_string(choice.slot+1);} + if(choice.name.empty()||choice.name.size()>24)choice.name="Manager "+std::to_string(choice.slot+1); + choices.push_back(choice);names.push_back(*name);styles.push_back(style); + } + modern::set_current_world(package.world); + try { + mount=std::make_unique(world,package.classic);session=std::make_unique(mount->root(),seed);std::string error; + for(const auto &choice:choices)if(!session->confirm_manager(options,choice,error))throw editor::Error("Die Managerwahl wurde abgewiesen: "+error); + auto &state=session->state();modern::ensure_ui_identities(state); + for(size_t i=0;ifinish(result,error))throw editor::Error("Die Partie konnte nicht gestartet werden: "+error); + for(size_t i=0;iui_read(cli::Json::Object{{"kind","session"}},revision));const auto &all=status.at("data").at("managers");if(all.at(i).at("teamId")!=managers.at(i).at("club"))throw editor::Error("Die Engine hat einen anderen Verein zugeordnet.");} + }catch(...){session.reset();mount.reset();modern::set_current_world(nullptr);throw;} + } ~Impl() { session.reset(); mount.reset(); modern::set_current_world(nullptr); } }; EngineBridge::EngineBridge(std::unique_ptr p) : impl_(std::move(p)) {} @@ -28,6 +59,10 @@ EngineBridge::~EngineBridge() = default; std::shared_ptr EngineBridge::open(const fs::path &world, const fs::path &save) { return std::shared_ptr(new EngineBridge(std::make_unique(world, save))); } +std::shared_ptr EngineBridge::create(const fs::path &world,const Json &setup,const Json &managers,uint32_t seed) { + if(modern::current_world())throw editor::Error("Bitte die laufende Partie beenden, bevor eine neue begonnen wird."); + return std::shared_ptr(new EngineBridge(std::make_unique(world,setup,managers,seed))); +} Json EngineBridge::snapshot() const { Json bundle = Json::object(); for (const auto *kind : {"session", "desktop", "camps", "squad", "lineup", "tactics", "training", "bank", "stadium", "credit", "environment", "advertising", "contracts", "friendly-plan"}) diff --git a/src/modern/ui/engine_bridge.hpp b/src/modern/ui/engine_bridge.hpp index 302be9f..c307ab1 100644 --- a/src/modern/ui/engine_bridge.hpp +++ b/src/modern/ui/engine_bridge.hpp @@ -62,11 +62,14 @@ Json engine_other_projection(const Json &bundle,const Json &index,const Json &re Json engine_rankings_projection(const Json &bundle,const Json &index,const Json &read,const std::string &league,int scope); Json engine_fairplay_projection(const Json &bundle,const Json &index,const Json &read); +Json engine_opening_projection(const Json &bundle,const Json &read); + // Single-session facade. Its owner serializes all calls on a background worker. // No RmlUI objects or callbacks cross this boundary. class EngineBridge { public: static std::shared_ptr open(const fs::path &world, const fs::path &save); + static std::shared_ptr create(const fs::path &world,const Json &setup,const Json &managers,uint32_t seed); ~EngineBridge(); Json snapshot() const; Json read(const Json &request) const; diff --git a/src/modern/ui/engine_controls.inc b/src/modern/ui/engine_controls.inc index 3c0113d..93ae845 100644 --- a/src/modern/ui/engine_controls.inc +++ b/src/modern/ui/engine_controls.inc @@ -6,6 +6,38 @@ void App::engine_start(std::string label, std::function job, bool engine_operation_ = std::move(label); engine_busy_ = true; engine_job_ = std::async(std::launch::async, std::move(job)); refresh(); } +void App::engine_accept(EngineReply result) { + engine_fresh_ = true; + if (result.catalog) { world_ = std::move(result.catalog); bind_world(world_); } + engine_link_ = std::move(result.connection); engine_data_ = std::move(result.bundle); + engine_response_ = std::move(result.response); + if (engine_response_.value("messageType", "") == "command_result") { + engine_dirty_ = engine_base_dirty_ || engine_response_.at("newRevision") != engine_response_.at("previousRevision"); + engine_notice_ = engine_text(engine_response_.at("feedback")) + (engine_dirty_ ? " · Änderungen noch nicht gespeichert." : ""); + } else if (engine_response_.value("messageType", "") == "error") { + engine_dirty_ = engine_base_dirty_; + auto reason = engine_text(engine_response_.value("message", Json())); + if (reason.empty() || reason == "—") reason = engine_response_.value("code", "unknown_error"); + engine_notice_ = "Änderung abgewiesen: " + reason; + } else if (engine_response_.value("messageType", "") == "saved") { + engine_dirty_ = false; engine_notice_ = "Spielstand als neue OBS-Datei gespeichert."; + if(engine_exit_after_save_){engine_exit_after_save_=false;closed_=true;} + } else if(engine_response_.value("messageType","")=="created"){engine_dirty_=true;engine_notice_="Neue Partie · Noch nicht gespeichert.";} + else engine_notice_ = "Spielstand geladen · Weitere Menüs werden schrittweise angebunden."; + if (engine_response_.value("messageType", "") == "command_result") { advertising_selected_ = -1; advertising_offer_ = 0; } + engine_credit_ = engine_data_.value("credit", Json()); engine_credit_edits_ = Json::array(); + engine_reports_sync(); + engine_almanac_sync(); + engine_ticket_bind(); + engine_contracts_poll(); + engine_calendar_sync(); + engine_friendly_sync(); + engine_sports_reset(); + const auto &f = engine_data_.at("camps").at("data").at("focus"); + engine_focus_ = {{"condition", f.at("condition")}, {"technique", f.at("technique")}, {"play", f.at("play")}}; + if (engine_camp_.empty() && !engine_data_.at("camps").at("data").at("camps").empty()) + engine_camp_ = engine_data_.at("camps").at("data").at("camps").front().at("id"); +} void App::engine_poll() { if (!engine_busy_ || engine_job_.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) return; engine_busy_ = false; @@ -37,35 +69,8 @@ void App::engine_poll() { } refresh(); return; } - engine_fresh_ = true; - if (result.catalog) { world_ = std::move(result.catalog); bind_world(world_); } - engine_link_ = std::move(result.connection); engine_data_ = std::move(result.bundle); - engine_response_ = std::move(result.response); - if (engine_response_.value("messageType", "") == "command_result") { - engine_dirty_ = engine_base_dirty_ || engine_response_.at("newRevision") != engine_response_.at("previousRevision"); - engine_notice_ = engine_text(engine_response_.at("feedback")) + (engine_dirty_ ? " · Änderungen noch nicht gespeichert." : ""); - } else if (engine_response_.value("messageType", "") == "error") { - engine_dirty_ = engine_base_dirty_; - auto reason = engine_text(engine_response_.value("message", Json())); - if (reason.empty() || reason == "—") reason = engine_response_.value("code", "unknown_error"); - engine_notice_ = "Änderung abgewiesen: " + reason; - } else if (engine_response_.value("messageType", "") == "saved") { - engine_dirty_ = false; engine_notice_ = "Spielstand als neue OBS-Datei gespeichert."; - } else engine_notice_ = "Spielstand geladen · Weitere Menüs werden schrittweise angebunden."; - if (engine_response_.value("messageType", "") == "command_result") { advertising_selected_ = -1; advertising_offer_ = 0; } - engine_credit_ = engine_data_.value("credit", Json()); engine_credit_edits_ = Json::array(); - engine_reports_sync(); - engine_almanac_sync(); - engine_ticket_bind(); - engine_contracts_poll(); - engine_calendar_sync(); - engine_friendly_sync(); - engine_sports_reset(); - const auto &f = engine_data_.at("camps").at("data").at("focus"); - engine_focus_ = {{"condition", f.at("condition")}, {"technique", f.at("technique")}, {"play", f.at("play")}}; - if (engine_camp_.empty() && !engine_data_.at("camps").at("data").at("camps").empty()) - engine_camp_ = engine_data_.at("camps").at("data").at("camps").front().at("id"); - } catch (const std::exception &e) { engine_notice_ = e.what(); } + engine_accept(std::move(result)); + } catch (const std::exception &e) { engine_notice_ = e.what(); if(engine_exit_after_save_){engine_exit_after_save_=false;message("Der Spielstand konnte nicht gespeichert werden: "+std::string(e.what()));} } refresh(); } void App::engine_frame() { @@ -115,7 +120,7 @@ void App::engine_save() { NFD::Guard guard; NFD::UniquePath chosen; const nfdfilteritem_t filters[] = {{"OpenBMH-Spielstand", "obs"}}; const auto result = NFD::SaveDialog(chosen, filters, 1, nullptr, "openbmh-career.obs"); - if (result == NFD_CANCEL) return; + if (result == NFD_CANCEL) {engine_exit_after_save_=false;return;} if (result != NFD_OKAY) throw editor::Error("Die Dateiauswahl konnte nicht geöffnet werden."); output = editor::path(chosen.get()); } @@ -124,7 +129,11 @@ void App::engine_save() { } void App::engine_quit() { if (engine_busy_) { engine_notice_ = "Bitte den laufenden Vorgang abwarten."; dirty_ = true; return; } - if (engine_dirty_) confirmation("Ungespeicherte Änderungen verwerfen und beenden? Über die Diskette kannst du zuvor eine neue OBS-Datei speichern.", [this] { closed_ = true; }); + if (engine_dirty_) { + confirmation("Die Partie enthält ungespeicherte Änderungen. Vor dem Beenden speichern?",[this]{closed_=true;}); + popup_accept_="Ohne Speichern beenden"; + popup_extra_=btn("engine-save-exit","Speichern und beenden","primary","id=\"engine-save-exit\""); + } else closed_ = true; } void App::engine_event(Rml::Event &event) { @@ -138,6 +147,13 @@ void App::engine_event(Rml::Event &event) { if (!engine_busy_ && bank_event(event)) return; if (!engine_busy_ && advertising_event(event)) return; if (!engine_busy_ && popup_.empty() && contracts_event(event)) return; + if(engine_opening_active()&&popup_.empty()) { + if(type=="keydown") {const auto key=Rml::Input::KeyIdentifier(event.GetParameter("key_identifier",0)); + if(key==Rml::Input::KI_TAB){Rml::ElementList nodes;doc_->QuerySelectorAll(nodes,".opening-actions button");std::erase_if(nodes,[](auto *n){return n->HasAttribute("disabled");});if(!nodes.empty()){const auto it=std::find(nodes.begin(),nodes.end(),context_->GetFocusElement());const int i=it==nodes.end()?-1:int(it-nodes.begin()),n=int(nodes.size());nodes[size_t((i+n+(event.GetParameter("shift_key",0)?-1:1))%n)]->Focus(true);}event.StopImmediatePropagation();return;} + if(key==Rml::Input::KI_RETURN||key==Rml::Input::KI_SPACE){for(auto *n=target;n&&n!=doc_;n=n->GetParentNode())if(n->GetTagName()=="button"&&!n->HasAttribute("disabled")){n->DispatchEvent("click",{});break;}}} + if(type=="click")for(auto *n=target;n&&n!=doc_;n=n->GetParentNode())if(n->HasAttribute("data-action")){opening_action(n->GetAttribute("data-action",""),n);break;} + event.StopImmediatePropagation();return; + } if (engine_reports_event(event)) return; if(!engine_busy_&&popup_.empty()&&rankings_event(event))return; if (!engine_busy_ && popup_.empty() && engine_friendly_event(event)) return; @@ -218,6 +234,7 @@ void App::engine_event(Rml::Event &event) { const auto action = node->GetAttribute("data-action", ""), id = node->GetAttribute("data-id", ""); if (!popup_.empty()) { if (action == "popup-close") { popup_.clear(); confirm_ = {}; dirty_ = true; } + if(action=="engine-save-exit"){reset_popup();popup_.clear();engine_exit_after_save_=true;try{engine_save();}catch(const std::exception &e){engine_exit_after_save_=false;message(e.what());}return;} if (action == "popup-confirm") { auto callback = std::move(confirm_); popup_.clear(); dirty_ = true; if (callback) callback(); } return; } @@ -268,6 +285,6 @@ void App::engine_event(Rml::Event &event) { } } Json App::engine_snapshot() const { - return {{"mode", engine_mode_}, {"busy", engine_busy_}, {"dirty", engine_dirty_}, {"fresh", engine_fresh_}, {"bundle", engine_data_}, - {"response", engine_response_}, {"rankings_read",engine_rankings_read_},{"rankings_state",engine_rankings_state_},{"fairplay_read",engine_fairplay_read_},{"other_index",engine_other_index_},{"other_read",engine_other_read_},{"fixtures_read",engine_fixtures_read_},{"reports_state",engine_reports_state_},{"reports_index",engine_reports_index_},{"reports_read",engine_reports_read_},{"reports_roster",engine_reports_roster_},{"almanac_cache",engine_almanac_cache_}, {"almanac_context",engine_almanac_context_}, {"friendly_quote", engine_friendly_read_}, {"friendly_league", engine_friendly_league_}, {"friendly_opponent", engine_friendly_opponent_}, {"friendly_date", engine_friendly_date_}, {"friendly_home", engine_friendly_home_}, {"friendly_stage", engine_friendly_stage_}, {"friendly_month", engine_friendly_month_}, {"calendar_day", engine_calendar_day_}, {"move_id", engine_move_id_}, {"credit_preview", engine_credit_}, {"credit_edits", engine_credit_edits_}, {"training_draft", engine_training_draft_}, {"tactics_draft", engine_tactics_draft_}, {"player_profile", engine_player_}, {"lineup_selected", lineup_selected_}, {"focus", engine_focus_}, {"selected_camp", engine_camp_}, {"notice", engine_notice_}}; + return {{"mode", engine_mode_}, {"creation_busy",engine_creation_busy_}, {"busy", engine_busy_}, {"dirty", engine_dirty_}, {"fresh", engine_fresh_}, {"bundle", engine_data_}, + {"response", engine_response_}, {"opening_read",engine_opening_read_},{"opening_state",engine_opening_state_},{"rankings_read",engine_rankings_read_},{"rankings_state",engine_rankings_state_},{"fairplay_read",engine_fairplay_read_},{"other_index",engine_other_index_},{"other_read",engine_other_read_},{"fixtures_read",engine_fixtures_read_},{"reports_state",engine_reports_state_},{"reports_index",engine_reports_index_},{"reports_read",engine_reports_read_},{"reports_roster",engine_reports_roster_},{"almanac_cache",engine_almanac_cache_}, {"almanac_context",engine_almanac_context_}, {"friendly_quote", engine_friendly_read_}, {"friendly_league", engine_friendly_league_}, {"friendly_opponent", engine_friendly_opponent_}, {"friendly_date", engine_friendly_date_}, {"friendly_home", engine_friendly_home_}, {"friendly_stage", engine_friendly_stage_}, {"friendly_month", engine_friendly_month_}, {"calendar_day", engine_calendar_day_}, {"move_id", engine_move_id_}, {"credit_preview", engine_credit_}, {"credit_edits", engine_credit_edits_}, {"training_draft", engine_training_draft_}, {"tactics_draft", engine_tactics_draft_}, {"player_profile", engine_player_}, {"lineup_selected", lineup_selected_}, {"focus", engine_focus_}, {"selected_camp", engine_camp_}, {"notice", engine_notice_}}; } diff --git a/src/modern/ui/engine_creation.inc b/src/modern/ui/engine_creation.inc new file mode 100644 index 0000000..404c948 --- /dev/null +++ b/src/modern/ui/engine_creation.inc @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-3.0-only +bool App::engine_opening_active() const { + return engine_mode_&&engine_opening_state_.is_object()&&engine_opening_state_.at("opening_flow").at("phase")!="done"; +} +void App::engine_create(const std::shared_ptr &catalog,const Json &managers) { + if(engine_creation_busy_||engine_mode_)return; + const auto file=catalog->source();const auto setup=start_options_; + const uint32_t seed=config_.creation_seed.value_or(uint32_t(SDL_GetPerformanceCounter())); + engine_creation_busy_=true;manager_confirm_=false;focus_after_render_.clear(); + engine_creation_job_=std::async(std::launch::async,[file,setup,managers,seed] { + auto link=EngineBridge::create(file,setup,managers,seed);auto loaded=Catalog::open(file);auto bundle=link->snapshot();auto opening=link->read({{"kind","opening"}});const auto state=engine_opening_projection(bundle,opening); + if(loaded->manifest().at("id")!=bundle.at("desktop").at("meta").at("worldId"))throw editor::Error("Bildkatalog und Partie gehören nicht zur selben Welt."); + for(const auto &id:state.at("opening_flow").at("order"))if(!loaded->find("clubs",id))throw editor::Error("Ein ausgeloster Verein fehlt im Bildkatalog."); + for(const auto &ids:state.at("opening_flow").at("entrants"))for(const auto &id:ids)if(!loaded->find("clubs",id))throw editor::Error("Ein Europapokalteilnehmer fehlt im Bildkatalog."); + return EngineReply{link,bundle,{{"messageType","created"},{"opening",opening}},loaded}; + });refresh(); +} +void App::engine_create_poll() { + if(!engine_creation_busy_||engine_creation_job_.wait_for(std::chrono::milliseconds(0))!=std::future_status::ready)return; + engine_creation_busy_=false;const auto previous=world_; + try { + auto result=engine_creation_job_.get();validate_engine_desk(result.bundle);auto opening=engine_opening_projection(result.bundle,result.response.at("opening")); + engine_mode_=true;engine_accept(std::move(result));engine_opening_read_=engine_response_.at("opening");engine_opening_state_=std::move(opening);source_.reset();entry_catalog_.reset();managers_draft_=Json::array();scene_="engine";menu_.clear();manager_confirm_=manager_success_=false;opening_due_=0;opening_io_blocked_=false;focus_after_render_=engine_opening_active()?(engine_opening_state_.at("opening_flow").at("phase")=="draw"?"opening-play":"opening-next"):"";engine_creation_busy_=false; + }catch(const std::exception &e){engine_mode_=false;engine_link_.reset();engine_data_=Json();engine_fresh_=false;world_=previous;if(entry_catalog_)bind_world(entry_catalog_);else bind_world(world_);manager_confirm_=true;message("Die Partie konnte nicht gestartet werden: "+std::string(e.what()));} + refresh(); +} diff --git a/src/modern/ui/engine_dto.cpp b/src/modern/ui/engine_dto.cpp index 40d094c..7ea6ed7 100644 --- a/src/modern/ui/engine_dto.cpp +++ b/src/modern/ui/engine_dto.cpp @@ -896,4 +896,14 @@ Json engine_fairplay_projection(const Json &bundle,const Json &index,const Json const auto &league=catalogue.at("leagues")[0];require(data.at("rows").is_array()&&data.at("rows").size()==league.at("members").size(),"Unvollständige Fairplayliste.");std::set ids;int previous=-1,rank=0;for(auto &r:data["rows"]){const auto id=r.at("team").at("id").get();require(ids.insert(id).second&&std::find(league.at("members").begin(),league.at("members").end(),Json(id))!=league.at("members").end()&&r.at("team").at("name").is_string(),"Doppelter/fremder Fairplayverein.");const int y=whole_in_range(r.at("yellow"),0,10000000),red=whole_in_range(r.at("red"),0,10000000),points=whole_in_range(r.at("points"),0,50000000);require(points==y+4*red&&points>=previous&&r.at("rank")==++rank,"Ungültige Fairplaywertung.");previous=points;r["club"]=id;} (void)whole_in_range(data.at("recordedMatches"),0,10000000);data["league"]=league;return data; } +Json engine_opening_projection(const Json &bundle,const Json &read) { + validate_engine_desk(bundle);auto context=bundle;context["opening"]=read;const auto &data=lineup_read(context,"opening"); + require(data.at("enabled").is_boolean()&&data.at("showEntrants").is_boolean()&&data.at("entrants").is_object()&&data.at("order").is_array()&&data.at("order").size()%2==0&&data.at("fixtureIds").is_array()&&data.at("fixtureIds").size()*2==data.at("order").size(),"Unvollständige Saisonvorbereitung."); + Json entrants=Json::object(),order=Json::array(),managers=Json::array(); + for(const auto *kind:{"uefa","champions","winners"}){require(data.at("entrants").at(kind).is_array(),"Teilnehmerliste fehlt.");std::set seen;entrants[kind]=Json::array();for(const auto &t:data.at("entrants").at(kind)){const auto id=t.at("id").get();require(!id.empty()&&seen.insert(id).second&&t.at("name").is_string(),"Doppelter oder unbenannter Europapokalteilnehmer.");entrants[kind].push_back(id);}} + std::set teams,fixtures;for(const auto &t:data.at("order")){const auto id=t.at("id").get();require(!id.empty()&&teams.insert(id).second&&t.at("name").is_string(),"Doppelter Pokalteilnehmer.");order.push_back(id);}for(const auto &id:data.at("fixtureIds")){require(id.is_string()&&!id.get().empty()&&fixtures.insert(id.get()).second,"Doppelte Pokalpaarung.");} + require(data.at("enabled").get()||order.empty(),"Deaktivierter Vereinswettbewerb hat Auftaktpaarungen.");for(const auto &m:bundle.at("session").at("data").at("managers"))managers.push_back({{"club",m.at("teamId")}}); + const bool enabled=data.at("enabled"),show=data.at("showEntrants");const auto phase=!enabled?"done":show?"uefa":order.empty()?"done":"draw"; + return {{"date",bundle.at("desktop").at("meta").at("date")},{"managers",managers},{"opening_flow",{{"created",true},{"phase",phase},{"playing",std::string_view(phase)=="draw"},{"revealed",0},{"order",order},{"entrants",entrants}}}}; +} } // namespace bmh::modern_ui diff --git a/src/modern/ui/engine_screens.inc b/src/modern/ui/engine_screens.inc index 883f9b4..4395507 100644 --- a/src/modern/ui/engine_screens.inc +++ b/src/modern/ui/engine_screens.inc @@ -51,6 +51,8 @@ void App::engine_render() { if (engine_data_.empty()) { out = "

OpenBMH

" + esc(engine_busy_ ? "Spielstand wird geladen …" : engine_notice_) + "

"; + } else if(engine_opening_active()) { + out=main_menu()+"
"+render_opening()+"
"; } else { const auto &desk = engine_data_.at("desktop").at("data"), &meta = engine_data_.at("desktop").at("meta"); const auto &team = desk.at("team"), &person = desk.at("manager"); @@ -93,6 +95,7 @@ void App::engine_render() { auto portrait = person.value("portraitGuiKey", ""); if (portrait.starts_with("gui:manager/photo/")) body = img("manager." + portrait.substr(18), o.at("w"), o.at("h"), false, false, 768); + else if(portrait.starts_with("gui:manager/painted/"))body=img("manager-painted."+portrait.substr(20),o.at("w"),o.at("h"),false,false,768); body += "
Manager" + esc(person.at("name").get()) + "
"; } else if (id == "calendar") { const auto date = meta.at("date").get(); diff --git a/src/modern/ui/engine_state.inc b/src/modern/ui/engine_state.inc index 78117a8..65d4cda 100644 --- a/src/modern/ui/engine_state.inc +++ b/src/modern/ui/engine_state.inc @@ -86,3 +86,12 @@ bool engine_sports_action(const std::string &, const std::string &, Rml::Element *); bool engine_sports_event(Rml::Event &); Json engine_snapshot() const; + + bool engine_exit_after_save_=false; + bool engine_creation_busy_=false; + std::future engine_creation_job_; + Json engine_opening_state_,engine_opening_read_; + void engine_create(const std::shared_ptr &,const Json &); + void engine_create_poll(); + void engine_accept(EngineReply); + bool engine_opening_active() const; diff --git a/src/modern/ui/entry_controls.inc b/src/modern/ui/entry_controls.inc index 10af622..257606d 100644 --- a/src/modern/ui/entry_controls.inc +++ b/src/modern/ui/entry_controls.inc @@ -69,6 +69,10 @@ void App::entry_begin() { message("Bitte eine Modern-Mod aktivieren."); return; } + if(!config_.preview_only) { + const auto requirements=next->manifest().value("requires",Json::array()); + if(!requirements.is_array()||std::find(requirements.begin(),requirements.end(),Json("runtime:modern-v1"))==requirements.end()){message("Diese Mod ist nicht als spielbare Modern-Welt freigegeben.");return;} + } const auto clubs = next->clubs(); if (std::none_of(clubs.begin(), clubs.end(), [&](auto *c) { return next->manageable(c->value("id", "")); @@ -146,7 +150,7 @@ void App::entry_cancel() { refresh(); } void App::entry_confirm() { - if (!manager_confirm_ || entry_full()) + if (engine_creation_busy_ || !manager_confirm_ || entry_full()) return; const auto name = normalized_manager_name(selections_["manager-name"]); const auto catalog = entry_world(); @@ -191,6 +195,7 @@ void App::entry_confirm() { manager_success_ = true; focus_after_render_ = "manager-success-close"; } else { + if(!config_.preview_only) {engine_create(catalog,candidate);return;} // Construct and validate before releasing any part of the current session. auto demo = std::make_unique(catalog); Json start={{"setup",start_options_},{"managers",candidate}}; @@ -217,6 +222,7 @@ void App::entry_confirm() { refresh(); } bool App::entry_action(const std::string &action, Rml::Element *target) { + if (engine_creation_busy_) return scene_=="newgame"||scene_=="manager"; if ((scene_ != "newgame" && scene_ != "manager") || !popup_.empty() || menu_ == "quit") return false; const auto id = @@ -410,6 +416,7 @@ bool App::entry_input(Rml::Element *target) { return true; } bool App::entry_event(Rml::Event &event) { + if(engine_creation_busy_){event.StopImmediatePropagation();return true;} if ((scene_ != "newgame" && scene_ != "manager") || !popup_.empty() || menu_ == "quit") return false; const auto type = event.GetType(); diff --git a/src/modern/ui/entry_opening_controls.inc b/src/modern/ui/entry_opening_controls.inc index 996f599..6fcd6f2 100644 --- a/src/modern/ui/entry_opening_controls.inc +++ b/src/modern/ui/entry_opening_controls.inc @@ -86,6 +86,11 @@ void App::opening_restore_startup() { } } bool App::opening_change(const std::string &kind) { + if(engine_mode_) { + if(!engine_opening_active())return false; + auto next=engine_opening_state_.at("opening_flow");const auto error=advance_opening_presentation(next,kind);if(!error.empty())return false; + engine_opening_state_["opening_flow"]=std::move(next);opening_due_=0;refresh();return true; + } if (!source_) return false; const auto before = snap(); @@ -116,7 +121,7 @@ bool App::opening_change(const std::string &kind) { return true; } bool App::opening_action(const std::string &action, Rml::Element *) { - if (scene_ != "opening" || !menu_.empty() || !popup_.empty()) + if ((!engine_mode_&&scene_ != "opening") || (engine_mode_&&!engine_opening_active()) || !menu_.empty() || !popup_.empty()) return false; if (action == "close") return true; @@ -125,14 +130,14 @@ bool App::opening_action(const std::string &action, Rml::Element *) { kind = "next"; else if (action == "opening-play") kind = opening_io_blocked_ && - snap().state.at("opening_flow").at("playing").get() + (engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("playing").get() ? "reveal" : "toggle"; else if (action == "opening-all") kind = "skip"; else if (action == "opening-finish") { const auto phase = - snap().state.at("opening_flow").at("phase").get(); + (engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("phase").get(); if (phase == "done") { scene_ = "desktop"; opening_due_ = 0; @@ -145,7 +150,7 @@ bool App::opening_action(const std::string &action, Rml::Element *) { if (!opening_change(kind)) return true; const auto phase = - snap().state.at("opening_flow").at("phase").get(); + (engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("phase").get(); if (phase == "done") { scene_ = "desktop"; focus_after_render_.clear(); @@ -169,10 +174,10 @@ bool App::opening_event(Rml::Event &event) { return false; } void App::opening_tick() { - if (scene_ != "opening" || !source_ || !menu_.empty() || !popup_.empty() || + if ((!engine_mode_&&(scene_ != "opening" || !source_)) || (engine_mode_&&!engine_opening_active()) || !menu_.empty() || !popup_.empty() || opening_io_blocked_) return; - const auto flow = snap().state.at("opening_flow"); + const auto flow = (engine_mode_?engine_opening_state_:snap().state).at("opening_flow"); if (flow.at("phase") != "draw" || !flow.at("playing").get()) { opening_due_ = 0; return; @@ -187,13 +192,14 @@ void App::opening_tick() { if (now < opening_due_) return; if (opening_change("reveal")) { - if (snap().state.at("opening_flow").at("phase") == "overview") + if ((engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("phase") == "overview") focus_after_render_ = "opening-finish"; opening_due_ = SDL_GetTicks64() + 900; } } void App::handle_event(SDL_Event &event) { if (event.type == SDL_QUIT) { + if(engine_creation_busy_){message("Die Partie wird noch vorbereitet. Bitte kurz warten.");return;} if (engine_mode_) { engine_quit(); return; } if (front_busy_) { front_feedback_ = "Bitte den laufenden Import abwarten."; @@ -209,8 +215,8 @@ void App::handle_event(SDL_Event &event) { if (event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) { desktop_cancel_drag(); if (scene_ == "opening" && source_ && !opening_io_blocked_ && - snap().state.at("opening_flow").at("phase") == "draw" && - snap().state.at("opening_flow").at("playing").get()) + (engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("phase") == "draw" && + (engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("playing").get()) opening_change("pause"); } resize(); diff --git a/src/modern/ui/entry_opening_screens.inc b/src/modern/ui/entry_opening_screens.inc index 71d7626..39a94c9 100644 --- a/src/modern/ui/entry_opening_screens.inc +++ b/src/modern/ui/entry_opening_screens.inc @@ -4,7 +4,7 @@ // belong to the controller. No participants or pairings are invented by the // renderer. std::string App::render_opening() { - const auto state = snap().state; + const auto state = engine_mode_?engine_opening_state_:snap().state; const auto &flow = state.at("opening_flow"); const auto phase = flow.at("phase").get(); const bool playing = flow.value("playing", false) && !opening_io_blocked_; @@ -46,7 +46,8 @@ std::string App::render_opening() { "" + esc(detail) + ""; }; - const auto note = [](const std::string &text) { + const auto note = [&](const std::string &text) { + if(engine_mode_)return std::string(); return "" + esc(text) + ""; }; const auto pair = [&](int index, int known, int logo_size, @@ -116,8 +117,7 @@ std::string App::render_opening() { if (entrants.empty()) { body += "

Keine " "Teilnehmer eingetragen

" - "

Für diesen Wettbewerb sind in dieser Demo-Welt keine " - "Vereine vorgesehen.

"; + "

"+std::string(engine_mode_?"Für diesen Wettbewerb sind derzeit keine deutschen Vereine gemeldet.":"Für diesen Wettbewerb sind in dieser Demo-Welt keine Vereine vorgesehen.")+"

"; } else { const bool single = entrants.size() == 1; const auto card = [&](const Json *c) { diff --git a/src/modern/ui/entry_screens.inc b/src/modern/ui/entry_screens.inc index 970a6ab..222990c 100644 --- a/src/modern/ui/entry_screens.inc +++ b/src/modern/ui/entry_screens.inc @@ -130,6 +130,7 @@ std::string App::render_manager() { return window("Neuer Spieler", "

Bitte zuerst eine Modern-Mod aktivieren.

"); const bool national = career_national_entry(); + if(engine_creation_busy_)return window("Neues Spiel","

Die Partie wird vorbereitet …

",false); const bool full = entry_full(), modal = manager_confirm_ || manager_success_; const int limit = adding_manager_ ? (national ? 1 : 4) : start_options_.value("players", 1); diff --git a/src/modern/ui/view.cpp b/src/modern/ui/view.cpp index 5141ce9..b544189 100644 --- a/src/modern/ui/view.cpp +++ b/src/modern/ui/view.cpp @@ -1109,6 +1109,7 @@ class App final : public Rml::EventListener { return true; } void frame() { + engine_create_poll(); if (engine_mode_) { engine_frame(); return; } front_poll(); flush_selects(); @@ -1393,7 +1394,7 @@ public: throw editor::Error("Bildkatalog und Engine verwenden unterschiedliche Weltdaten."); return EngineReply{link, std::move(bundle), Json::object(), std::move(catalog)}; }); - } else opening_restore_startup(); + } else if(config_.preview_only) opening_restore_startup(); if (scene_ == "manager" && selections_["manager-name"].empty()) selections_["manager-name"] = "Alex Berger"; doc_->Show(); @@ -1442,6 +1443,7 @@ public: } while (!closed_) { front_poll(); + engine_create_poll(); if (engine_mode_) engine_poll(); opening_tick(); live_tick(); @@ -1533,6 +1535,7 @@ public: #include "modern/ui/engine_almanac.inc" #include "modern/ui/engine_reports.inc" #include "modern/ui/engine_rankings.inc" +#include "modern/ui/engine_creation.inc" } // namespace bool is_modern_world(const fs::path &file) { try { diff --git a/src/modern/ui/view.hpp b/src/modern/ui/view.hpp index 8807c8d..fa62a96 100644 --- a/src/modern/ui/view.hpp +++ b/src/modern/ui/view.hpp @@ -1,11 +1,15 @@ // SPDX-License-Identifier: GPL-3.0-only #pragma once #include "launch/mods.hpp" +#include +#include namespace bmh::modern_ui { struct Config { std::filesystem::path world, gui_assets, screenshot, commands, state, preferences, userdata, file_import, file_export, mods, mod_import; std::filesystem::path engine_save; + bool preview_only = false; + std::optional creation_seed; std::string scene = "main", theme; int width = 1280, height = 720; }; diff --git a/tests/modern_engine_bridge_probe.cpp b/tests/modern_engine_bridge_probe.cpp index 26d99a9..daea238 100644 --- a/tests/modern_engine_bridge_probe.cpp +++ b/tests/modern_engine_bridge_probe.cpp @@ -3,6 +3,7 @@ #include "modern/ui/engine_bridge.hpp" #include "modern/app/modern_session.hpp" #include "modern/content/world_package.hpp" +#include "modern/ui/demo_opening.hpp" #include #include #include @@ -11,7 +12,7 @@ using namespace bmh::modern_ui; int main(int argc, char **argv) { try { const std::string mode=argc>1?argv[1]:""; - const std::set modes{"prepare","prepare-two","prepare-national","prepare-almanac","inspect","inspect-friendlies","inspect-almanac","verify","verify-lineup","verify-sports","verify-bank","verify-commerce","verify-contracts","verify-calendar","verify-friendlies","verify-national","verify-almanac","verify-shootouts","verify-reports","verify-fixtures","verify-other","verify-rankings","prepare-rankings-archived"}; + const std::set modes{"prepare","prepare-two","prepare-national","prepare-almanac","inspect","inspect-friendlies","inspect-almanac","verify","verify-lineup","verify-sports","verify-bank","verify-commerce","verify-contracts","verify-calendar","verify-friendlies","verify-national","verify-almanac","verify-shootouts","verify-reports","verify-fixtures","verify-other","verify-rankings","prepare-rankings-archived","verify-create"}; if(argc!=4||!modes.contains(mode))throw std::runtime_error("usage: modern_engine_bridge_probe "); const fs::path world = argv[2], out = argv[3]; fs::create_directories(out); const auto write = [&](const char *file, const Json &j) { editor::write_atomic(out / file, j.dump(2)); }; @@ -59,6 +60,31 @@ int main(int argc, char **argv) { modern::set_current_world(nullptr);auto fixture=EngineBridge::open(world,out/"archived.obs");const auto bundle=fixture->snapshot(),index=fixture->read({{"kind","report-index"}}),read=fixture->read({{"kind","player-rankings"},{"leagueId",league},{"scope",0}});const auto value=engine_rankings_projection(bundle,index,read,league,0); if(value.at("categories")[0][0].at("player")!=person||!value.at("categories")[0][0].at("currentTeam").is_null())throw std::runtime_error("archived-only counterexample not retained");write("rankings.json",read);std::cout<<"synthetic archived-only rankings fixture passed\n";return 0; } + if(mode=="verify-create") { + const auto package=modern::open_world_package(world);Json clubs=Json::array();for(int league=0;league<5;++league)for(const auto &l:package.world->leagues)if(l.index==league&&!l.members.empty())clubs.push_back(l.members.front()); + const std::array names{"Jörg Müller","Zoë García","Alex Berger","Mina Öztürk"};Json cases=Json::array(); + for(int count:{1,2,4}) { + Json setup={{"duration",5},{"difficulty",3},{"players",count},{"mode",3},{"league",true},{"world",true}},managers=Json::array(); + for(int i=0;isnapshot(),opening=created->read({{"kind","opening"}});write(("created-"+std::to_string(count)+".json").c_str(),before);write(("opening-"+std::to_string(count)+".json").c_str(),opening);auto state=engine_opening_projection(before,opening); + if(before.at("session").at("data").at("managers").size()!=size_t(count))throw std::runtime_error("wrong human manager count"); + for(int i=0;isave_copy(out/("initial-"+std::to_string(count)+".obs"))); + for(int page=0;page<3;++page){const auto error=advance_opening_presentation(state["opening_flow"],"next");if(!error.empty())throw std::runtime_error(error);} + if(!advance_opening_presentation(state["opening_flow"],"skip").empty()||!advance_opening_presentation(state["opening_flow"],"finish").empty())throw std::runtime_error("opening presentation failed"); + if(created->snapshot()!=before)throw std::runtime_error("intro presentation modified career"); + const auto saved=out/("created-"+std::to_string(count)+".obs");write(("saved-"+std::to_string(count)+".json").c_str(),created->save_copy(saved));created.reset();created=EngineBridge::open(world,saved); + if(created->snapshot().at("session").at("data")!=before.at("session").at("data")||created->read({{"kind","opening"}}).at("data")!=opening.at("data"))throw std::runtime_error("created career lost managers or draw after restart"); + cases.push_back({{"managers",count},{"sameManagersAfterReload",true},{"sameDrawAfterReload",true},{"presentationIsReadOnly",true}});created.reset(); + } + Json setup={{"duration",5},{"difficulty",3},{"players",1},{"mode",3},{"league",false},{"world",true}},managers={{{"name","National QA"},{"club",clubs[0]},{"portrait",0},{"portrait_style","photo"},{"strength_choice",1}}}; + {auto c=EngineBridge::create(world,setup,managers,17);const auto o=c->read({{"kind","opening"}});if(o.at("data").at("enabled")!=false)throw std::runtime_error("national-only created club intro");write("national-only.json",c->snapshot());write("saved-national.json",c->save_copy(out/"national-only.obs"));} + setup["league"]=true; + for(int fault=0;fault<7;++fault){auto bad_setup=setup,bad_managers=managers;if(fault==0){bad_setup["league"]=false;bad_setup["world"]=false;}if(fault==1)bad_setup["mode"]=2;if(fault==2)bad_managers[0]["club"]="club:missing";if(fault==3)bad_managers[0]["name"]="";if(fault==4)bad_managers[0]["portrait"]=12;if(fault==5)bad_managers[0]["strength_choice"]=3;if(fault==6){bad_setup["players"]=2;bad_managers.push_back(bad_managers[0]);bad_managers[1]["portrait"]=1;} + bool rejected=false;try{auto invalid=EngineBridge::create(world,bad_setup,bad_managers,17);}catch(const std::exception&){rejected=true;}if(!rejected||modern::current_world())throw std::runtime_error("invalid creation retained an active session"); + } + write("receipt.json",{{"status","passed"},{"cases",cases},{"invalidRequests",7},{"nationalOnly",true}});std::cout<<"real career creation, multiple managers, UTF-8, portrait styles and reload passed\n";return 0; + } auto link = EngineBridge::open(world, out / "input.obs"); const auto before = link->snapshot(); write("before.json", before); if (before != link->snapshot()) throw std::runtime_error("reads changed the engine projection"); diff --git a/tests/modern_engine_dto_tests.cpp b/tests/modern_engine_dto_tests.cpp index ced5929..b841dc4 100644 --- a/tests/modern_engine_dto_tests.cpp +++ b/tests/modern_engine_dto_tests.cpp @@ -399,6 +399,13 @@ int main() { bad_rank=rr;bad_rank["meta"]["stateRevision"]="42";rejects([&]{engine_rankings_projection(rankings_bundle,ri,bad_rank,"league:live",0);}); const auto fr=rw({{"kind","fairplay"},{"leagueId","league:live"},{"season","2026/27"},{"weights",{{"yellow",1},{"red",4}}},{"recordedMatches",1},{"rows",{{{"rank",1},{"team",{{"id","club:6"},{"name","Live A"}}},{"yellow",1},{"red",0},{"points",1}},{{"rank",2},{"team",{{"id","club:7"},{"name","Live B"}}},{"yellow",0},{"red",1},{"points",4}}}}}); require(engine_fairplay_projection(rankings_bundle,ri,fr).at("rows").size()==2,"fairplay rows lost");auto bad_fair=fr;bad_fair["data"]["rows"][1]["points"]=1;rejects([&]{engine_fairplay_projection(rankings_bundle,ri,bad_fair);}); + auto opening_bundle=fixture();opening_bundle["desktop"]["meta"]["date"]="2026-07-01";opening_bundle["session"]["data"]["managers"]={{{"teamId","club:6"}}}; + const auto ow=[&](const Json &d){return Json{{"messageType","snapshot"},{"meta",opening_bundle.at("desktop").at("meta")},{"data",d}};}; + Json opening_data={{"kind","opening"},{"enabled",true},{"showEntrants",true}}; + opening_data["entrants"]={{"uefa",Json::array({Json{{"id","club:7"},{"name","Live B"}}})},{"champions",Json::array()},{"winners",Json::array()}}; + opening_data["order"]=Json::array({Json{{"id","club:6"},{"name","Live A"}},Json{{"id","club:7"},{"name","Live B"}}}); + opening_data["fixtureIds"]={"fixture:cup-0-1-0"};const auto oi=ow(opening_data); + require(engine_opening_projection(opening_bundle,oi).at("opening_flow").at("order")[0]=="club:6","opening ignored authoritative pair order");auto bad_opening=oi;bad_opening["data"]["order"][1]["id"]="club:6";rejects([&]{engine_opening_projection(opening_bundle,bad_opening);});bad_opening=oi;bad_opening["meta"]["stateRevision"]="42";rejects([&]{engine_opening_projection(opening_bundle,bad_opening);}); std::cout << "engine DTO, exact money, scope and booking tests passed\n"; return 0; } catch (const std::exception &e) { std::cerr << e.what() << '\n'; return 1; } diff --git a/tests/modern_manager_presentation_tests.cpp b/tests/modern_manager_presentation_tests.cpp new file mode 100644 index 0000000..9a9ab30 --- /dev/null +++ b/tests/modern_manager_presentation_tests.cpp @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "modern/content/ui_contract.hpp" +#include "modern/game/modern_state.hpp" +#include +#include +using namespace bmh; +namespace {using J=cli::Json;using O=J::Object;const J& at(const J& j,const char* k){return j.object()->at(k);}void check(bool ok,const char* why){if(!ok)throw std::runtime_error(why);}} +int main() try { + modern::ModernState g;g.manager_teams={0};g.manager_ids={"manager:1"};g.manager_serial=1;g.manager_records.resize(0xb0c);g.world_club_id={"club:one"};g.world_club_name={"Synthetic"};const std::string original="M}ller";for(size_t i=0;iat(0);check(*at(m,"name").string()==unicode,"UTF-8 manager name lost");check(*at(m,"portraitStyle").string()=="painted"&&*at(m,"portraitGuiKey").string()=="gui:manager/painted/0","portrait style lost");check(!g.manager_presentation(1)&&!g.manager_presentation(-1),"presentation crossed slot bounds");check(g.manager_records[0xa8+1]=='}',"display metadata modified original bytes"); + g.manager_presentations.clear();const auto fallback=modern::ui_read(g,c,O{{"kind","session"}});const auto &old=at(at(fallback,"data"),"managers").array()->at(0);check(*at(old,"name").string()=="M\xc3\xbcller"&&*at(old,"portraitStyle").string()=="photo","old saves lost original-name/photo fallback");std::cout<<"Modern UTF-8 presentation, original bytes and older-save fallback passed\n";return 0; +} catch(const std::exception& e){std::cerr<