Create real careers from the native wizard and preserve manager presentation (by Codex)

This commit is contained in:
Codex committed 2026-10-29 01:11:41 +01:00
1 parent 738ecc7a09
commit ce1535fe2d
38 files changed
+466 -75

No files matched your search

+1 -1
View File
@@ -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
+4
View File
@@ -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)
+1 -1
View File
@@ -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 |
+19
View File
@@ -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.
+16
View File
@@ -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/.
+11
View File
@@ -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.
+2 -2
View File
@@ -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
+2 -2
View File
@@ -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) |
+18 -1
View File
@@ -1,7 +1,8 @@
<!-- SPDX-License-Identifier: GPL-3.0-only -->
# 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.
+42 -1
View File
@@ -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 <uint32>`
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.
+32
View File
@@ -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/`.
+6
View File
@@ -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) {
+31 -1
View File
@@ -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<int> seen;const int count=g_.memory.u8(counts[competition]);
for(int i=0;i<count;++i){const int runtime=g_.memory.u16(pools[competition]+uint32_t(i)*2);if(runtime<modern::german_clubs()&&seen.insert(runtime).second)std::get<A>(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
+1
View File
@@ -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)
+1 -1
View File
@@ -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)}};
+4 -1
View File
@@ -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))}};
}
+20 -2
View File
@@ -5,6 +5,7 @@
#include <bit>
#include <utility>
#include <variant>
#include <set>
#include "content/digest.hpp"
#include "content/package.hpp"
@@ -43,6 +44,20 @@ std::vector<std::string> strings(const J& value) {
for (const J& v : arr(value)) out.push_back(str(v));
return out;
}
J manager_presentations_json(const std::vector<ModernState::ManagerPresentation>& 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<ModernState::ManagerPresentation> manager_presentations_json(const J& value) {
std::vector<ModernState::ManagerPresentation> out; std::set<std::string> 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"));
+1
View File
@@ -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]));
+12
View File
@@ -82,6 +82,18 @@ struct ModernState : GameState {
std::string career_id;
std::vector<std::string> 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<ManagerPresentation> 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.
+2 -2
View File
@@ -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);
+19 -11
View File
@@ -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<std::string>(),
phase = flow.at("phase").get<std::string>();
auto flow=source;
if(!flow.at("order").is_array()||!flow.at("revealed").is_number_integer()||flow.at("revealed").get<int64_t>()<0||flow.at("revealed").get<uint64_t>()>flow.at("order").size()||!flow.at("playing").is_boolean())return "Ungültiger Darstellungszustand der Saisonvorbereitung.";
const auto phase = flow.at("phase").get<std::string>();
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<std::string>() == "done";
next["opening"] = done ? "complete" : "pending";
next["opening_created"] = done && flow.at("created").get<bool>();
+2
View File
@@ -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 &);
+35
View File
@@ -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 <set>
namespace bmh::modern_ui {
namespace {
@@ -21,6 +24,34 @@ struct EngineBridge::Impl {
session = std::make_unique<modern::app::ModernSession>(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<int64_t>()<low||v.get<int64_t>()>high)throw editor::Error("Ungültige Grundeinstellung: "+std::string(key));return v.get<int>();};
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<ui::ManagerChoice> choices;std::vector<std::string> names,styles;std::set<std::string> clubs;std::set<int> 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<std::string>());if(!name)throw editor::Error("Bitte einen gültigen Managernamen angeben.");
const auto id=m.at("club").get<std::string>();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<int64_t>()<0||portrait.get<int64_t>()>11||!portraits.insert(portrait.get<int>()).second||!strength.is_number_integer()||strength.get<int64_t>()<0||strength.get<int64_t>()>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<content::Mount>(world,package.classic);session=std::make_unique<modern::app::ModernSession>(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;i<choices.size();++i)state.manager_presentations.push_back({state.manager_ids.at(i),names[i],styles[i]});
ui::CareerInitializationResult result;if(!session->finish(result,error))throw editor::Error("Die Partie konnte nicht gestartet werden: "+error);
for(size_t i=0;i<managers.size();++i){const auto status=from_engine(session->ui_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<Impl> p) : impl_(std::move(p)) {}
@@ -28,6 +59,10 @@ EngineBridge::~EngineBridge() = default;
std::shared_ptr<EngineBridge> EngineBridge::open(const fs::path &world, const fs::path &save) {
return std::shared_ptr<EngineBridge>(new EngineBridge(std::make_unique<Impl>(world, save)));
}
std::shared_ptr<EngineBridge> 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<EngineBridge>(new EngineBridge(std::make_unique<Impl>(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"})
+3
View File
@@ -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<EngineBridge> open(const fs::path &world, const fs::path &save);
static std::shared_ptr<EngineBridge> create(const fs::path &world,const Json &setup,const Json &managers,uint32_t seed);
~EngineBridge();
Json snapshot() const;
Json read(const Json &request) const;
+50 -33
View File
@@ -6,6 +6,38 @@ void App::engine_start(std::string label, std::function<EngineReply()> 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<int>("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<int>("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<Rml::String>("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<Rml::String>("data-action", ""), id = node->GetAttribute<Rml::String>("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_}};
}
+26
View File
@@ -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<const Catalog> &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();
}
+10
View File
@@ -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<std::string> ids;int previous=-1,rank=0;for(auto &r:data["rows"]){const auto id=r.at("team").at("id").get<std::string>();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<std::string> seen;entrants[kind]=Json::array();for(const auto &t:data.at("entrants").at(kind)){const auto id=t.at("id").get<std::string>();require(!id.empty()&&seen.insert(id).second&&t.at("name").is_string(),"Doppelter oder unbenannter Europapokalteilnehmer.");entrants[kind].push_back(id);}}
std::set<std::string> teams,fixtures;for(const auto &t:data.at("order")){const auto id=t.at("id").get<std::string>();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<std::string>().empty()&&fixtures.insert(id.get<std::string>()).second,"Doppelte Pokalpaarung.");}
require(data.at("enabled").get<bool>()||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
+3
View File
@@ -51,6 +51,8 @@ void App::engine_render() {
if (engine_data_.empty()) {
out = "<div class=\"fill center\"><div class=\"panel\" style=\"padding:70dp;\"><h1>OpenBMH</h1><p>" +
esc(engine_busy_ ? "Spielstand wird geladen …" : engine_notice_) + "</p></div></div>";
} else if(engine_opening_active()) {
out=main_menu()+"<div class=\"fill\" style=\"z-index:100;\">"+render_opening()+"</div>";
} 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 += "<div class=\"desk-portrait-caption\"><small>Manager</small><strong>" + esc(person.at("name").get<std::string>()) + "</strong></div>";
} else if (id == "calendar") {
const auto date = meta.at("date").get<std::string>();
+9
View File
@@ -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<EngineReply> engine_creation_job_;
Json engine_opening_state_,engine_opening_read_;
void engine_create(const std::shared_ptr<const Catalog> &,const Json &);
void engine_create_poll();
void engine_accept(EngineReply);
bool engine_opening_active() const;
+8 -1
View File
@@ -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<DemoSource>(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();
+15 -9
View File
@@ -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<bool>()
(engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("playing").get<bool>()
? "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<std::string>();
(engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("phase").get<std::string>();
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<std::string>();
(engine_mode_?engine_opening_state_:snap().state).at("opening_flow").at("phase").get<std::string>();
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<bool>()) {
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<bool>())
(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<bool>())
opening_change("pause");
}
resize();
+4 -4
View File
@@ -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<std::string>();
const bool playing = flow.value("playing", false) && !opening_io_blocked_;
@@ -46,7 +46,8 @@ std::string App::render_opening() {
"<span class=\"opening-heading-detail\">" +
esc(detail) + "</span></header>";
};
const auto note = [](const std::string &text) {
const auto note = [&](const std::string &text) {
if(engine_mode_)return std::string();
return "<span class=\"opening-demo-note\">" + esc(text) + "</span>";
};
const auto pair = [&](int index, int known, int logo_size,
@@ -116,8 +117,7 @@ std::string App::render_opening() {
if (entrants.empty()) {
body += "<div class=\"opening-empty-entrants\"><h3><span>Keine "
"Teilnehmer eingetragen</span></h3>"
"<p><span>Für diesen Wettbewerb sind in dieser Demo-Welt keine "
"Vereine vorgesehen.</span></p></div>";
"<p><span>"+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.")+"</span></p></div>";
} else {
const bool single = entrants.size() == 1;
const auto card = [&](const Json *c) {
+1
View File
@@ -130,6 +130,7 @@ std::string App::render_manager() {
return window("Neuer Spieler",
"<p>Bitte zuerst eine Modern-Mod aktivieren.</p>");
const bool national = career_national_entry();
if(engine_creation_busy_)return window("Neues Spiel","<div class=\"fill center\"><h2>Die Partie wird vorbereitet …</h2></div>",false);
const bool full = entry_full(), modal = manager_confirm_ || manager_success_;
const int limit =
adding_manager_ ? (national ? 1 : 4) : start_options_.value("players", 1);
+4 -1
View File
@@ -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 {
+4
View File
@@ -1,11 +1,15 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "launch/mods.hpp"
#include <optional>
#include <cstdint>
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<uint32_t> creation_seed;
std::string scene = "main", theme;
int width = 1280, height = 720;
};
+27 -1
View File
@@ -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 <iostream>
#include <algorithm>
#include <set>
@@ -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<std::string> 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<std::string> 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 <prepare[-two|-national|-almanac]|inspect[-friendlies|-almanac]|verify[-lineup|-sports|-bank|-commerce|-contracts|-calendar|-friendlies|-national|-almanac|-shootouts]> <world.obw> <new-output-directory>");
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<std::string,4> 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;i<count;++i)managers.push_back({{"name",names[size_t(i)]},{"club",clubs.at(size_t(i))},{"portrait",i},{"portrait_style",i%2?"photo":"painted"},{"strength_choice",1}});
auto created=EngineBridge::create(world,setup,managers,17);const auto before=created->snapshot(),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;i<count;++i){const auto &m=before.at("session").at("data").at("managers").at(size_t(i));if(m.at("name")!=names[size_t(i)]||m.at("teamId")!=clubs.at(size_t(i))||m.at("portraitStyle")!=(i%2?"photo":"painted"))throw std::runtime_error("new career manager mapping differs");}
write(("saved-initial-"+std::to_string(count)+".json").c_str(),created->save_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");
+7
View File
@@ -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; }
@@ -0,0 +1,13 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/content/ui_contract.hpp"
#include "modern/game/modern_state.hpp"
#include <iostream>
#include <stdexcept>
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;i<original.size();++i)g.manager_records[0xa8+i]=original[i];
const std::string unicode="J\xc3\xb6rg M\xc3\xbcller";g.manager_presentations.push_back({"manager:1",unicode,"painted"});modern::UiContext c;c.manager=0;
const auto read=modern::ui_read(g,c,O{{"kind","session"}});const auto &m=at(at(read,"data"),"managers").array()->at(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<<e.what()<<'\n';return 1;}