From e3ea03a05ddd2c482551bd7c61e475e33a0ae9e2 Mon Sep 17 00:00:00 2001 From: Codex Date: Thu, 29 Oct 2026 02:57:32 +0100 Subject: [PATCH] Manage real OBS careers in native save and load dialogs (by Codex) --- .github/workflows/modern-ui.yml | 2 +- docs/new_engine/ui-schnittstelle.md | 12 +++ docs/new_ui/NATIVE_STATUS.md | 6 +- docs/new_ui/desktop/save-load/README.md | 57 +++++++++++ docs/new_ui/integration/ENGINE_ENTRY.md | 11 +- src/modern/content/ui_contract.cpp | 7 ++ src/modern/content/world_save.cpp | 32 ++++++ src/modern/content/world_save.hpp | 4 + src/modern/ui/CMakeLists.txt | 4 +- src/modern/ui/career_files.cpp | 122 +++++++++++++++++++++++ src/modern/ui/career_files.hpp | 30 ++++++ src/modern/ui/controls.inc | 6 +- src/modern/ui/engine_bridge.cpp | 46 +++++++-- src/modern/ui/engine_bridge.hpp | 2 + src/modern/ui/engine_controls.inc | 24 +++-- src/modern/ui/engine_files.inc | 80 +++++++++++++++ src/modern/ui/engine_files_state.inc | 19 ++++ src/modern/ui/engine_screens.inc | 6 +- src/modern/ui/entry_opening_controls.inc | 2 +- src/modern/ui/files_controls.inc | 9 +- src/modern/ui/files_screens.inc | 15 +-- src/modern/ui/front_screens.inc | 2 +- src/modern/ui/view.cpp | 5 + tests/modern_career_files_tests.cpp | 54 ++++++++++ tests/modern_engine_bridge_probe.cpp | 21 +++- 25 files changed, 539 insertions(+), 39 deletions(-) create mode 100644 src/modern/ui/career_files.cpp create mode 100644 src/modern/ui/career_files.hpp create mode 100644 src/modern/ui/engine_files.inc create mode 100644 src/modern/ui/engine_files_state.inc create mode 100644 tests/modern_career_files_tests.cpp diff --git a/.github/workflows/modern-ui.yml b/.github/workflows/modern-ui.yml index fae0ab5..2c51643 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 modern_manager_presentation_tests modern_coach_identity_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_career_files_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 modern_coach_identity_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/docs/new_engine/ui-schnittstelle.md b/docs/new_engine/ui-schnittstelle.md index 4e3beef..dc2ea62 100644 --- a/docs/new_engine/ui-schnittstelle.md +++ b/docs/new_engine/ui-schnittstelle.md @@ -90,3 +90,15 @@ löst eine Buchung aus. Regeln und 6-Sterne-Wirkung: [Trainingslager](trainingsl - Die UI arbeitet mit dem POC-Zustand oder mit Beispieldaten in genau den oben genannten Formen. Beispieldaten sind fiktiv und liegen bei den UI-Tests, nicht im Datensatz. - Weicht eine Projektion von dieser Beschreibung ab, wird zuerst dieses Dokument angepasst, dann der Code. - Fragen zur Schnittstelle als GitHub-Issue mit dem Label `modern-engine`. + + +### Spielstandmetadaten + +`ui_read({kind: "file-metadata"})` liefert die reine Projektion +`modern-career-metadata@1`: Welt-/Karriere-ID, Datenrevision, Datum, Saison, +nächster Ligaspieltag (National: unbekannt), Menschenzahl, aktive Person und +Menschenliste mit stabiler ID, kanonischem Namen, Verein, Teamtext, Porträt und +Nationalkennzeichen. Dieselbe Contentprojektion liest die geprüften OBS-Dateien +für die Dateiliste ohne zweite aktive Session. Kein RNG, keine Änderungen an +Weltmaßen und kein neues Save-/OBW-Format. Der Live-Frontendadapter liest auch +hier ausschließlich über `ModernSession::ui_read`. diff --git a/docs/new_ui/NATIVE_STATUS.md b/docs/new_ui/NATIVE_STATUS.md index 55843b1..de2b7d0 100644 --- a/docs/new_ui/NATIVE_STATUS.md +++ b/docs/new_ui/NATIVE_STATUS.md @@ -1,6 +1,6 @@ # Native Modern UI · erster Umsetzungsstand -Stand: 28. Oktober 2026. **Experimenteller RmlUI-Unterbau und erster +Stand: 29. Oktober 2026. **Experimenteller RmlUI-Unterbau und erster 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. @@ -9,7 +9,9 @@ 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 +Engineoperationen. Die vorhandenen Speichern-/Laden-Fenster verwalten echte OBS-Dateien +mit Metadaten, Import/Export und bestätigtem Ersetzen, Umbenennen und Löschen. +Dieser Einstieg ist auf diesen Umfang begrenzt; die übrigen nachfolgend beschriebenen Menüpakete sind weiterhin Präsentationsdemos. ## Vorhanden diff --git a/docs/new_ui/desktop/save-load/README.md b/docs/new_ui/desktop/save-load/README.md index d0c9116..70de725 100644 --- a/docs/new_ui/desktop/save-load/README.md +++ b/docs/new_ui/desktop/save-load/README.md @@ -151,3 +151,60 @@ und betrachtet sie anschließend mit einer anderen laufenden Vereinsrolle/Person Der rechte Kopf und Robins Zeile zeigen weiter Deutschland; der laufende Viewer-Source bleibt unverändert. Es werden ausschließlich Metadaten gelesen, kein Karrierepayload oder Enginezustand umgebaut. + + +## Echte OBS-Karrieren (Engine-Einstieg, 29.10.2026) + +Der normale Modern-Einstieg verwendet dieselbe RmlUI-Liste mit Detailbereich, +liest und schreibt aber echte OBS-Dateien. Der getrennte `--modern-ui-demo`-Weg +behält seine lokalen JSON-Präsentationsstände; sie sind keine Engine-Spielstände. +Die HTML-Goldreferenz und das gemeinsame Layout bleiben unverändert. + +Die Ablage liegt unter `userdata/careers//`. Eine Mod darf +nur Karrieren derselben Welt-ID und Datenrevision öffnen. Die Metadaten stammen +vom geprüften OBS-Inhalt: Datum, Saison, nächster Ligaspieltag, logische Menschen, +aktuelle Rolle und kanonische Namen. In der Nationalrolle steht Deutschland; +wartende Manager behalten ihre Vereinsnamen. Es wird kein fiktives Desktopdatum +oder Porträtvergleich als Rollenbestimmung benutzt. + +- Neue Bezeichnung oder gewählter Eintrag; Ersetzen immer mit Rückfrage. +- Umbenennen ändert auch den `.obs`-Dateinamen. Namen sind auf allen drei + Zielsystemen gültig; Groß-/Kleinschreibungs- und Unicode-Konflikte werden erkannt. +- Löschen mit Rückfrage; beschädigte, noch lesbare Dateien bleiben löschbar. +- Import/Export mit nativer Dateiauswahl. Ein Import ändert keine laufende Partie. +- Vor dem Laden ungespeicherter Änderungen: Abbrechen, ohne Speichern laden + oder erst speichern. Abgebrochene/fehlgeschlagene Vorgänge beenden die Partie nicht. +- Strg+S/Strg+O öffnen die Bibliothek. Der ausdrückliche QA-Override + `--ui-file-export` erhält den bisherigen direkten Save-Export über die App-Taste. + +Schreibvorgänge werden pro Ablage durch eine vom Betriebssystem freigegebene +Sperre serialisiert. Der Writer erzeugt zunächst eine temporäre OBS-Datei, +liest sie erneut ein und veröffentlicht sie atomar. Ein SHA-256-Auswahltoken +blockiert veraltetes Ersetzen, Umbenennen, Löschen, Laden oder Exportieren, +wenn eine Datei inzwischen extern verändert wurde. Es gibt kein neues OBS-Format. + +Laden innerhalb einer Welt baut eine neue Session auf dem vorhandenen Mount auf +und prüft ihren vollständigen Desktop-/Menüsnapshot. Erst dann wird die bisherige +Session ersetzt. Bei einem Fehler bleiben die bisherige Karriere und ihre +Zufallszustände erhalten; die Prozessdimensionen werden wieder auf die aktive +Welt gesetzt. Ansichts- und Archivcaches werden auch beim Laden derselben +Karriere, desselben Datums und derselben Revision verworfen. + +Nach erfolgreichem Engine-Speichern/Laden geht es zum Desktop zurück. Die +abweichend oben beschriebene offenbleibende Liste betrifft weiterhin den Demo-Pfad. +Bei Speichern und beenden schließt die Anwendung erst nach erfolgreicher +Veröffentlichung. Spielregeln, Matchablauf und Anstoßfreigabe werden nicht geändert. + +### Prüfung dieses Integrationspakets + +56 synthetische Regressionstests, 54 native Hauptprüfungen, 20 zusätzliche +Randfallprüfungen und 516 Geometrieprüfungen bestanden. Native Dialoge unter +Linux x64/SDL2/OpenGL in Silver, Midnight und Matchday bei 1080p/720p. Geprüft +wurden auch echter Prozessneustart, vier Menschen, dritter Mensch als +Nationalcoach, Speichern vor Laden und Speichern vor Beenden. Defekte Archive +und ein korrekt gehashtes Archiv mit ungültigem Driver ersetzen die aktive +Session nicht; danach funktioniert ein echter Eintrittspreisbefehl weiterhin. +RNG und Almanachbytes bleiben bei bloßem Speichern/Laden unverändert. +Windows/macOS wurden in diesem Paket nicht nativ ausgeführt. Die private +Galerie enthält Screenshots und zugehörige OBS-Dateien unter +`bmh_4k_ui/docs/qa/engine-files-2026-10-29/`. diff --git a/docs/new_ui/integration/ENGINE_ENTRY.md b/docs/new_ui/integration/ENGINE_ENTRY.md index 67fae9a..7205c41 100644 --- a/docs/new_ui/integration/ENGINE_ENTRY.md +++ b/docs/new_ui/integration/ENGINE_ENTRY.md @@ -18,7 +18,7 @@ werden. Die Quelle wird nicht in DemoSource überführt. ## Gebundener Umfang -- `ModernSession::ui_read`: `session`, `desktop`, `camps`, `squad`, `lineup`, `tactics`, `training`, `bank`, `stadium`, `credit`, `environment`, `advertising`, `contracts`, `calendar`, `scheduling`, `friendly-plan`, `report-index`, `league-report`, `league-fixtures`, `other-index`, `other-fixtures`, `player-rankings`, `fairplay`; parameterisierte Angebote über `friendly` und Archivabfragen über `almanac`. Karriere, Manager, +- `ModernSession::ui_read`: `session`, `desktop`, `file-metadata`, `camps`, `squad`, `lineup`, `tactics`, `training`, `bank`, `stadium`, `credit`, `environment`, `advertising`, `contracts`, `calendar`, `scheduling`, `friendly-plan`, `report-index`, `league-report`, `league-fixtures`, `other-index`, `other-fixtures`, `player-rankings`, `fairplay`; parameterisierte Angebote über `friendly` und Archivabfragen über `almanac`. Karriere, Manager, Mannschaft, Datum, Saison, Geld, Lagerqualitäten und Angebote kommen aus der Engine. Katalog und Engine müssen dieselbe Welt-ID und Datenrevision haben. - Der bestehende RmlUI-Schreibtisch verwendet die gemeinsamen App-Buttons und @@ -355,3 +355,12 @@ die passende Manager-ID, Name und Porträtart; wartende Menschen verlieren ihre Vereinszuordnungen nicht. UI-Commands verwenden wie bisher IDs und Revisionen, keine aus der Anzeige geratenen Recordnummern. Alte OBS ohne Darstellungsfelder bleiben unterstützt. Details: [Nationalteams](../../new_engine/nationalteams.md). + + +## Echte Dateibibliothek + +Siehe [Speichern/Laden](../desktop/save-load/README.md). Der Engine-Einstieg +öffnet nun den vorhandenen RmlUI-Dateidialog für echte OBS-Dateien, einschließlich +Metadaten, bestätigtem Ersetzen, Umbenennen/Löschen und Import/Export. Der normale +Hauptmenü-Ladeweg führt in dieselbe Bibliothek. Ein fehlerhafter Ladevorgang ersetzt +die aktive Session nicht. Die Demo-Dateiverwaltung bleibt separat. diff --git a/src/modern/content/ui_contract.cpp b/src/modern/content/ui_contract.cpp index 4b2c1f4..8551e57 100644 --- a/src/modern/content/ui_contract.cpp +++ b/src/modern/content/ui_contract.cpp @@ -15,6 +15,7 @@ #include "modern/content/press_journal.hpp" #include "modern/content/statistics.hpp" #include "modern/content/world_package.hpp" +#include "modern/content/world_save.hpp" #include "modern/game/almanac.hpp" #include "modern/game/desk_actions.hpp" #include "modern/game/environment.hpp" @@ -494,6 +495,12 @@ cli::Json ui_read(const ModernState& g, const UiContext& c, const cli::Json& req const std::string today = *std::get(m.value).at("date").string(); if (kind == "session") return snapshot(request_id, std::move(m), session_data(g, c)); if (kind == "desktop") return snapshot(request_id, std::move(m), desktop_data(g, c, today)); + if (kind == "file-metadata") { + const auto* world=current_world(); + if(!world)return failure(request_id,"world_unavailable","Keine aktive Modern-Welt.",c.state_revision); + try{return snapshot(request_id,std::move(m),world_career_metadata(*world,g));} + catch(const std::exception&){return failure(request_id,"metadata_unavailable","Spielstandangaben nicht verfügbar.",c.state_revision);} + } if (kind == "camps") return snapshot(request_id, std::move(m), camps_data(g, c, std::to_string(c.state_revision))); if (kind == "player-rankings" || kind == "fairplay") { J data = query_rankings(g, c.manager, request); diff --git a/src/modern/content/world_save.cpp b/src/modern/content/world_save.cpp index d7abb27..789d214 100644 --- a/src/modern/content/world_save.cpp +++ b/src/modern/content/world_save.cpp @@ -3,6 +3,7 @@ #include #include +#include #include #include #include @@ -13,6 +14,7 @@ #include "formats/native_state.hpp" #include "import/detail.hpp" #include "modern/game/save.hpp" +#include "formats/executable_layout.hpp" namespace bmh::modern { @@ -266,4 +268,34 @@ SavedWorldCareer load_world_career(const std::filesystem::path& path, const Worl return out; } +cli::Json world_career_metadata(const World& world,const ModernState& state) { + const bool coach=state.memory.has(::bmh::layout::CoachActive)&&state.memory.u8(::bmh::layout::CoachActive)!=0; + const int count=coach?state.memory.u8(::bmh::layout::OriginalManagerCount):int(state.manager_teams.size()); + if(count<1||count>4)fail("unsupported saved manager count"); + const int runtime=coach?0:state.memory.has(::bmh::layout::ActiveManager)?state.memory.u8(::bmh::layout::ActiveManager):0; + const int active=state.human_manager_slot(runtime);if(active<0||active>=count)fail("invalid saved active manager"); + A managers;int active_team=-1; + for(int human=0;humanstate.manager_records.size())fail("saved manager record missing"); + const int team=record>=0&&size_t(record)=state.world_club_id.size())fail("saved manager team missing"); + const auto* presentation=state.manager_presentation_for_human(human);std::string name; + if(presentation)name=presentation->name;else {for(size_t n=0;n<25&&state.manager_records[at+0xa8+n];++n)name.push_back(char(state.manager_records[at+0xa8+n]));name=almanac_utf8(name);} + const auto id=size_t(human)portrait_style:"photo"},{"national",coach&&record==0}}); + if(human==active)active_team=team; + } + const auto date=almanac_date(state.date,state.display_start_year);char iso[16];std::snprintf(iso,sizeof iso,"%04d-%02d-%02d",date.year,date.month,date.day); + const int year=state.display_start_year+state.season,next=(year+1)%100;const auto season=std::to_string(year)+"/"+(next<10?"0":"")+std::to_string(next);std::string round="—"; + if(!coach) { + std::vector leagues;for(const auto& l:world.leagues)if(l.index>=0)leagues.push_back(&l);std::sort(leagues.begin(),leagues.end(),[](auto* a,auto* b){return a->indexindex;}); + int first=0;for(const auto* l:leagues){const int size=int(l->members.size());if(active_team>=first&&active_team1&&size_t(l->index)index)])+1,(size-1)*2))+". Spieltag";first+=size;} + } + return O{{"schema","modern-career-metadata@1"},{"career_id",state.career_id},{"world_id",world.id},{"world_revision",world.data_revision},{"date",iso},{"season",season},{"matchday",round},{"role",coach?"national":"club"},{"human_count",count},{"current_manager",managers.at(size_t(active))},{"managers",std::move(managers)}}; +} +cli::Json read_world_career_metadata(const std::filesystem::path& path,const World& world) { + const auto saved=load_world_career(path,world);return world_career_metadata(world,saved.state); +} + } // namespace bmh::modern diff --git a/src/modern/content/world_save.hpp b/src/modern/content/world_save.hpp index a88f54f..6948f23 100644 --- a/src/modern/content/world_save.hpp +++ b/src/modern/content/world_save.hpp @@ -29,6 +29,10 @@ void save_world_career(const std::filesystem::path& path, const World& world, co const WatcomRandom& random, const GameRandom& game, const TurnDriver& driver, bool overwrite, const cli::Json& session = {}); +// Read-only metadata, independent of the active session and global world layout. +cli::Json world_career_metadata(const World&,const ModernState&); +cli::Json read_world_career_metadata(const std::filesystem::path&,const World&); + // Throws FormatError when the save is damaged, not a Modern save or belongs to another world. SavedWorldCareer load_world_career(const std::filesystem::path& path, const World& world); diff --git a/src/modern/ui/CMakeLists.txt b/src/modern/ui/CMakeLists.txt index 7d3ffaf..b46be1e 100644 --- a/src/modern/ui/CMakeLists.txt +++ b/src/modern/ui/CMakeLists.txt @@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-3.0-only -add_library(bmh_modern_ui_core STATIC catalog.cpp crest_contrast.cpp engine_dto.cpp model.cpp demo_career.cpp demo_national_ui.cpp gui_assets.cpp desktop.cpp demo_sports.cpp demo_calendar.cpp demo_reports.cpp demo_almanac.cpp demo_finance.cpp demo_environment.cpp demo_advertising.cpp demo_toto.cpp demo_lineup.cpp demo_live.cpp demo_post_match.cpp demo_transfer.cpp demo_career_reports.cpp demo_rankings.cpp demo_stadium.cpp demo_statistics.cpp demo_news.cpp news_catalog.cpp news_journal.cpp demo_settings.cpp ui_preferences.cpp demo_widgets.cpp demo_files.cpp demo_opening.cpp) +add_library(bmh_modern_ui_core STATIC catalog.cpp crest_contrast.cpp engine_dto.cpp model.cpp demo_career.cpp demo_national_ui.cpp gui_assets.cpp desktop.cpp demo_sports.cpp demo_calendar.cpp demo_reports.cpp demo_almanac.cpp demo_finance.cpp demo_environment.cpp demo_advertising.cpp demo_toto.cpp demo_lineup.cpp demo_live.cpp demo_post_match.cpp demo_transfer.cpp demo_career_reports.cpp demo_rankings.cpp demo_stadium.cpp demo_statistics.cpp demo_news.cpp news_catalog.cpp news_journal.cpp demo_settings.cpp ui_preferences.cpp demo_widgets.cpp demo_files.cpp career_files.cpp demo_opening.cpp) target_include_directories(bmh_modern_ui_core PUBLIC ../..) target_link_libraries(bmh_modern_ui_core PUBLIC bmh_asset_io) add_library(bmh_modern_ui_mods STATIC mod_library.cpp) @@ -49,7 +49,7 @@ foreach(asset modern.rml theme.rcss ticket.rcss sports.rcss calendar.rcss report configure_file("${CMAKE_SOURCE_DIR}/assets/modern/${asset}" "${modern_assets}/${asset}" COPYONLY) endforeach() -foreach(component career_reports rankings) +foreach(component career_reports rankings career_files) add_executable(modern_${component}_tests ../../../tests/modern_${component}_tests.cpp) target_link_libraries(modern_${component}_tests PRIVATE bmh_modern_ui_core) if(MSVC) diff --git a/src/modern/ui/career_files.cpp b/src/modern/ui/career_files.cpp new file mode 100644 index 0000000..0d654de --- /dev/null +++ b/src/modern/ui/career_files.cpp @@ -0,0 +1,122 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "modern/ui/career_files.hpp" +#include "content/digest.hpp" +#include +#include +#include +#include +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +#else +#include +#include +#include +#endif +namespace bmh::modern_ui { +namespace { +constexpr uint64_t file_limit=256*1024*1024; +void safe_directory(const fs::path &path,bool create=false) { + fs::path current; + for(const auto &part:fs::absolute(path).lexically_normal()) { + current/=part;const auto status=fs::symlink_status(current); + if(fs::is_symlink(status)||(fs::exists(status)&&!fs::is_directory(status)))throw editor::Error("Die Spielstandablage ist nicht verfügbar."); + } + if(create)fs::create_directories(path); +} +std::string bytes(const fs::path &path) { + if(fs::is_symlink(fs::symlink_status(path))||!fs::is_regular_file(path))throw editor::Error("Der Spielstand ist keine reguläre Datei."); + return editor::read_file(path,file_limit); +} +std::string timestamp(const fs::path &file) { + const auto elapsed=fs::last_write_time(file)-fs::file_time_type::clock::now();const auto time=std::chrono::system_clock::now()+std::chrono::duration_cast(elapsed);const auto days=std::chrono::floor(time);const std::chrono::year_month_day date{days};const std::chrono::hh_mm_ss clock{std::chrono::floor(time-days)}; + std::ostringstream out;out<=0){flock(handle,LOCK_UN);::close(handle);} +#endif + } +}; +struct Staging {fs::path path;~Staging(){std::error_code e;fs::remove(path,e);}}; +} +std::string CareerFiles::clean_name(const std::string &raw) { + const auto name=DemoFiles::clean_name(raw); + if(name.front()=='.'||name.back()=='.'||name.find_first_of("<>:\"/\\|?*")!=std::string::npos) + throw editor::Error("Bitte eine Bezeichnung ohne Dateipfad oder Sonderzeichen eingeben."); + const auto base=DemoFiles::name_key(name.substr(0,name.find('.'))); + if(base=="con"||base=="prn"||base=="aux"||base=="nul"|| + (base.size()==4&&(base.starts_with("com")||base.starts_with("lpt"))&&base[3]>='1'&&base[3]<='9')) + throw editor::Error("Diese Bezeichnung ist als Dateiname reserviert."); + return name; +} +CareerFiles::CareerFiles(fs::path directory,Reader reader):directory_(fs::absolute(std::move(directory)).lexically_normal()),reader_(std::move(reader)){if(!reader_)throw editor::Error("Die Spielstandprüfung fehlt.");} +fs::path CareerFiles::file(const std::string &id) const { + const auto p=editor::path(id);if(id.empty()||id.front()=='.'||id.find_first_of("/\\")!=std::string::npos||p.filename()!=p||p.extension()!=".obs")throw editor::Error("Ungültiger Spielstandeintrag.");safe_directory(directory_);return directory_/p; +} +DemoFileEntry CareerFiles::decode(const fs::path &path) const { + DemoFileEntry e;e.id=editor::utf8(path.filename());e.name=editor::utf8(path.stem());const auto raw=bytes(path);e.token=content::sha256(raw);e.bytes=raw.size();e.modified=e.created=timestamp(path);e.data=reader_(path);return e; +} +std::vector CareerFiles::list() const { + safe_directory(directory_);std::vector result;if(!fs::exists(directory_))return result; + for(const auto &p:fs::directory_iterator(directory_)){const auto name=editor::utf8(p.path().filename());if(name.starts_with('.')||p.path().extension()!=".obs")continue;DemoFileEntry e;try{e=decode(p.path());}catch(const std::exception &error){e.id=name;e.name=editor::utf8(p.path().stem());e.error=error.what();try{const auto raw=bytes(p.path());e.token=content::sha256(raw);e.bytes=raw.size();e.modified=e.created=timestamp(p.path());}catch(...) {}}result.push_back(std::move(e));} + std::sort(result.begin(),result.end(),[](const auto &a,const auto &b){return a.name0&&(uint8_t(prefix[at])&0xc0)==0x80)--at;prefix.erase(at);}} + if(candidate.empty())throw editor::Error("Keine freie Bezeichnung gefunden.");bool found=false;for(const auto &e:rows)try{found|=DemoFiles::name_key(e.name)==DemoFiles::name_key(candidate);}catch(...){}if(!found)return candidate; + } + throw editor::Error("Keine freie Bezeichnung gefunden."); +} +DemoFileEntry CareerFiles::put(const std::string &raw_name,const Writer &writer,const std::string &id,const std::string &expected) { + const auto name=clean_name(raw_name);Lock lock(directory_);available_name(name,id);const auto selected=id.empty()?name+".obs":id;const auto target=file(selected); + if(!id.empty()){if(expected.empty()||content::sha256(bytes(target))!=expected)throw editor::Error("Dieser Spielstand wurde inzwischen geändert. Bitte erneut auswählen.");} + Staging staging{directory_/(".pending-"+content::sha256(editor::new_id("save")).substr(0,32)+".obs")};writer(staging.path);(void)reader_(staging.path);const auto raw=bytes(staging.path); + if(!id.empty()&&content::sha256(bytes(target))!=expected)throw editor::Error("Dieser Spielstand wurde inzwischen geändert. Bitte erneut auswählen.");editor::write_atomic(target,raw,!id.empty());return decode(target); +} +DemoFileEntry CareerFiles::rename(const std::string &id,const std::string &expected,const std::string &raw_name) { + const auto name=clean_name(raw_name);Lock lock(directory_);const auto previous=read(id,expected);available_name(name,id);const auto target=file(name+".obs"),source=file(id);if(target==source)return previous; + if(fs::exists(target)&&fs::equivalent(source,target)){fs::rename(source,target);return decode(target);} + const auto raw=bytes(source);if(content::sha256(raw)!=expected)throw editor::Error("Dieser Spielstand wurde inzwischen geändert. Bitte erneut auswählen.");editor::write_atomic(target,raw,false);try{if(content::sha256(bytes(source))!=expected)throw editor::Error("Dieser Spielstand wurde inzwischen geändert.");fs::remove(source);}catch(...){if(fs::exists(target)&&content::sha256(bytes(target))==content::sha256(raw)){std::error_code e;fs::remove(target,e);}throw;}return decode(target); +} +void CareerFiles::remove(const std::string &id,const std::string &expected) { + Lock lock(directory_);const auto source=file(id);const auto raw=bytes(source);if(expected.empty()||content::sha256(raw)!=expected)throw editor::Error("Dieser Spielstand wurde inzwischen geändert. Bitte erneut auswählen.");const auto trash=directory_/(".deleted-"+content::sha256(editor::new_id("delete")));fs::rename(source,trash);std::error_code e;fs::remove(trash,e); +} +DemoFileEntry CareerFiles::import_file(const fs::path &source) { + const auto raw=bytes(source);(void)reader_(source);const auto name=free_name(clean_name(editor::utf8(source.stem())));return put(name,[&](const auto &path){editor::write_atomic(path,raw,false);}); +} +void CareerFiles::export_file(const std::string &id,const std::string &expected,const fs::path &destination,bool overwrite) const { + const auto e=read(id,expected);(void)e;const auto target=fs::weakly_canonical(destination);const auto relative=target.lexically_relative(fs::weakly_canonical(directory_));if(!relative.empty()&&*relative.begin()!="..")throw editor::Error("Für den Export bitte ein anderes Verzeichnis wählen.");safe_directory(target.parent_path());const auto raw=bytes(file(id));if(content::sha256(raw)!=expected)throw editor::Error("Dieser Spielstand wurde inzwischen geändert. Bitte erneut auswählen.");editor::write_atomic(target,raw,overwrite); +} +} // namespace bmh::modern_ui diff --git a/src/modern/ui/career_files.hpp b/src/modern/ui/career_files.hpp new file mode 100644 index 0000000..9b18454 --- /dev/null +++ b/src/modern/ui/career_files.hpp @@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-3.0-only +#pragma once +#include "modern/ui/demo_files.hpp" +#include +namespace bmh::modern_ui { +// Real OBS files only. Entry.data is validated display metadata, never a DemoSource checkpoint. +class CareerFiles { +public: + using Reader=std::function; + using Writer=std::function; + CareerFiles(fs::path directory,Reader reader); + static std::string clean_name(const std::string&); + std::vector list() const; + DemoFileEntry read(const std::string&,const std::string& expected={}) const; + std::string free_name(const std::string&) const; + DemoFileEntry put(const std::string& name,const Writer&,const std::string& id={},const std::string& expected={}); + DemoFileEntry rename(const std::string&,const std::string&,const std::string&); + void remove(const std::string&,const std::string&); + DemoFileEntry import_file(const fs::path&); + void export_file(const std::string&,const std::string&,const fs::path&,bool overwrite=false) const; + fs::path file(const std::string&) const; + fs::path directory() const {return directory_;} +private: + fs::path directory_;Reader reader_; + DemoFileEntry decode(const fs::path&) const; + void available_name(const std::string&,const std::string& except={}) const; +}; +// Production metadata reader, implemented with the Modern content adapter. +CareerFiles make_career_files(const fs::path &directory,const fs::path &world); +} // namespace bmh::modern_ui diff --git a/src/modern/ui/controls.inc b/src/modern/ui/controls.inc index 6004d8e..68d0630 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_ || 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."); + while ((engine_busy_ || engine_creation_busy_ || engine_files_busy_) && SDL_GetTicks64() < until) { pump_events(); frame(); SDL_Delay(10); } + if (engine_busy_ || engine_creation_busy_ || engine_files_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); @@ -950,7 +950,7 @@ void App::script() { {"HOME", Rml::Input::KI_HOME}, {"END", Rml::Input::KI_END}, {"LEFT", Rml::Input::KI_LEFT}, {"RIGHT", Rml::Input::KI_RIGHT}, {"UP", Rml::Input::KI_UP}, {"DOWN", Rml::Input::KI_DOWN}, - {"A", Rml::Input::KI_A}, {"Z", Rml::Input::KI_Z}, {"V", Rml::Input::KI_V}, + {"S", Rml::Input::KI_S}, {"O", Rml::Input::KI_O}, {"A", Rml::Input::KI_A}, {"Z", Rml::Input::KI_Z}, {"V", Rml::Input::KI_V}, {"P", Rml::Input::KI_P}, {"BACKSPACE", Rml::Input::KI_BACK}, {"DELETE", Rml::Input::KI_DELETE}, {"F4", Rml::Input::KI_F4}, {"F10", Rml::Input::KI_F10}, {"CONTEXT", Rml::Input::KI_APPS}, {"0", Rml::Input::KI_0}, {"1", Rml::Input::KI_1}, {"2", Rml::Input::KI_2}, {"3", Rml::Input::KI_3}, diff --git a/src/modern/ui/engine_bridge.cpp b/src/modern/ui/engine_bridge.cpp index 8a1500e..dc6ca35 100644 --- a/src/modern/ui/engine_bridge.cpp +++ b/src/modern/ui/engine_bridge.cpp @@ -3,13 +3,26 @@ #include "modern/app/modern_session.hpp" #include "modern/content/world_package.hpp" #include "modern/content/ui_contract.hpp" +#include "modern/content/world_save.hpp" +#include "modern/content/world_expand.hpp" #include "modern/ui/model.hpp" +#include "modern/ui/career_files.hpp" +#include "content/digest.hpp" #include namespace bmh::modern_ui { namespace { Json from_engine(const cli::Json &v) { return Json::parse(cli::dump_json(v)); } } +namespace { +Json session_snapshot(modern::app::ModernSession &session,uint64_t revision) { + Json bundle=Json::object(); + for(const auto *kind:{"session","desktop","camps","squad","lineup","tactics","training","bank","stadium","credit","environment","advertising","contracts","friendly-plan"})bundle[kind]=from_engine(session.ui_read(cli::Json::Object{{"kind",kind}},revision)); + validate_engine_desk(bundle);const auto &season=bundle.at("desktop").at("meta").at("season"); + bundle["calendar"]=from_engine(session.ui_read(cli::Json::Object{{"kind","calendar"},{"from",season.at("startDate").get()},{"until",season.at("endDate").get()}},revision)); + bundle["scheduling"]=from_engine(session.ui_read(cli::Json::Object{{"kind","scheduling"}},revision));return bundle; +} +} struct EngineBridge::Impl { modern::WorldPackage package; std::unique_ptr mount; @@ -63,22 +76,35 @@ std::shared_ptr EngineBridge::create(const fs::path &world,const J 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"}) - bundle[kind] = from_engine(impl_->session->ui_read(cli::Json::Object{{"kind", kind}}, impl_->revision)); - validate_engine_desk(bundle); - const auto &season = bundle.at("desktop").at("meta").at("season"); - bundle["calendar"] = read({{"kind", "calendar"}, {"from", season.at("startDate")}, {"until", season.at("endDate")}}); - bundle["scheduling"] = read({{"kind", "scheduling"}}); - return bundle; -} +Json EngineBridge::snapshot() const {return session_snapshot(*impl_->session,impl_->revision);} Json EngineBridge::command(const Json &request) { return from_engine(impl_->session->ui_command(cli::parse_json(request.dump()), impl_->revision)); } Json EngineBridge::read(const Json &request) const { return from_engine(impl_->session->ui_read(cli::parse_json(request.dump()), impl_->revision)); } +CareerFiles make_career_files(const fs::path &directory,const fs::path &world) { + const auto model=modern::open_world_package(world).world; + return CareerFiles(directory,[model](const fs::path &file){ + try{return from_engine(modern::read_world_career_metadata(file,*model));} + catch(const std::exception &e){const std::string reason=e.what();if(reason.starts_with("the save belongs to another world"))throw editor::Error("Dieser Spielstand gehört zu einer anderen Mod oder Datensatzversion.");throw editor::Error("Dieser Spielstand ist beschädigt oder wird nicht unterstützt.");} + }); +} +Json EngineBridge::file_metadata() const { + const auto reply=read({{"kind","file-metadata"}}); + if(reply.value("messageType","")!="snapshot")throw editor::Error("Spielstandangaben nicht verfügbar."); + return reply.at("data"); +} +Json EngineBridge::load_same_world(const fs::path &path,const std::string &expected_token) { + const auto check=[&]{if(!expected_token.empty()&&content::sha256(editor::read_file(path,256*1024*1024))!=expected_token)throw editor::Error("Dieser Spielstand wurde inzwischen geändert. Bitte erneut auswählen.");}; + check();(void)modern::load_world_career(path,*impl_->package.world); + try { + auto staged=std::make_unique(impl_->mount->root(),1u,path,false); + (void)session_snapshot(*staged,0);check(); + impl_->session=std::move(staged);impl_->input=fs::weakly_canonical(path);impl_->revision=0; + }catch(...){modern::install_world_dimensions(*impl_->package.world);throw;} + return {{"messageType","loaded"}}; +} Json EngineBridge::save_copy(const fs::path &path) { if (fs::weakly_canonical(path) == impl_->input || fs::exists(path)) throw editor::Error("Bitte eine neue Datei wählen. Der geladene Spielstand wird nicht überschrieben."); diff --git a/src/modern/ui/engine_bridge.hpp b/src/modern/ui/engine_bridge.hpp index c307ab1..c8c4469 100644 --- a/src/modern/ui/engine_bridge.hpp +++ b/src/modern/ui/engine_bridge.hpp @@ -75,6 +75,8 @@ public: Json read(const Json &request) const; Json command(const Json &request); Json save_copy(const fs::path &path); + Json file_metadata() const; + Json load_same_world(const fs::path &path,const std::string &expected_token={}); private: struct Impl; explicit EngineBridge(std::unique_ptr); diff --git a/src/modern/ui/engine_controls.inc b/src/modern/ui/engine_controls.inc index 93ae845..6cf01b1 100644 --- a/src/modern/ui/engine_controls.inc +++ b/src/modern/ui/engine_controls.inc @@ -87,6 +87,7 @@ void App::engine_frame() { engine_contract_scroll_.reset(); } if(rendered&&(menu_=="scorers"||menu_=="fairplay")){rankings_restore_scroll();context_->Update();} + if(rendered&&files_native_){files_after_render();context_->Update();} if (center_selects(*doc_)) context_->Update(); if (menu_ == "lineup" && lineup_roster_scroll_) { if (auto *roster = element("lineup-roster-scroll")) roster->SetScrollTop(*lineup_roster_scroll_); @@ -114,7 +115,8 @@ void App::engine_frame() { renderer_.Clear(); renderer_.BeginFrame(); context_->Render(); renderer_.EndFrame(); video_.present(); dirty_ = false; } void App::engine_save() { - if (engine_busy_ || !engine_link_) return; + if (engine_busy_ || engine_files_busy_ || !engine_link_) return; + if(config_.file_export.empty()){engine_files_begin("save");return;} auto output = config_.file_export; if (output.empty()) { NFD::Guard guard; NFD::UniquePath chosen; @@ -128,7 +130,7 @@ void App::engine_save() { engine_start("Spielstand wird gespeichert …", [link, output] { auto response = link->save_copy(output); return EngineReply{link, link->snapshot(), response, nullptr}; }); } void App::engine_quit() { - if (engine_busy_) { engine_notice_ = "Bitte den laufenden Vorgang abwarten."; dirty_ = true; return; } + if (engine_busy_ || engine_files_busy_) { engine_notice_ = "Bitte den laufenden Vorgang abwarten."; dirty_ = true; return; } if (engine_dirty_) { confirmation("Die Partie enthält ungespeicherte Änderungen. Vor dem Beenden speichern?",[this]{closed_=true;}); popup_accept_="Ohne Speichern beenden"; @@ -147,13 +149,14 @@ 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(engine_opening_active()&&menu_.empty()&&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(files_native_&&files_event(event))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; @@ -183,7 +186,7 @@ void App::engine_event(Rml::Event &event) { } if (type == "keydown" && event.GetParameter("key_identifier", 0) == Rml::Input::KI_ESCAPE) { if (menu_ == "almanac" && engine_busy_) { event.StopImmediatePropagation(); return; } - if (!popup_.empty()) { popup_.clear(); confirm_ = {}; dirty_ = true; } + if (!popup_.empty()) { popup_.clear(); reset_popup(); engine_files_pending_load_.reset(); engine_exit_after_save_=false; dirty_ = true; } else if (!engine_busy_ && !engine_player_.empty()) { focus_after_render_ = "lineup-detail-" + engine_player_ + "-0"; engine_player_.clear(); refresh(); } else if (!engine_busy_ && menu_ == "almanac") engine_almanac_action("alm-back",nullptr); else if (!engine_busy_ && !menu_.empty()) { if (menu_ == "training" || menu_ == "tactics") engine_sports_reset(); if(menu_=="scorers"||menu_=="fairplay")rankings_remember_scroll(); menu_.clear(); refresh(); } @@ -208,6 +211,10 @@ void App::engine_event(Rml::Event &event) { } event.StopImmediatePropagation(); return; } + if(type=="keydown"&&popup_.empty()&&menu_.empty()&&!engine_busy_&&!engine_files_busy_) { + const auto key=Rml::Input::KeyIdentifier(event.GetParameter("key_identifier",0)); + if(event.GetParameter("ctrl_key",0)&&(key==Rml::Input::KI_S||key==Rml::Input::KI_O)){engine_files_begin(key==Rml::Input::KI_S?"save":"load");event.StopImmediatePropagation();return;} + } if (engine_busy_) return; if ((type == "input" || type == "change") && menu_ == "camp" && popup_.empty() && target->GetId().starts_with("camp-focus-")) { const int index = target->GetAttribute("data-id", -1); @@ -233,11 +240,13 @@ void App::engine_event(Rml::Event &event) { if (!node->HasAttribute("data-action") || node->HasAttribute("disabled")) continue; 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 == "popup-close") { popup_.clear(); reset_popup(); engine_files_pending_load_.reset(); engine_exit_after_save_=false; dirty_ = true; } + if(action=="files-save-before-load"){const auto pending=engine_files_pending_load_;reset_popup();popup_.clear();engine_files_begin("save");engine_files_pending_load_=pending;return;} 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(); } + if (action == "popup-confirm") { auto callback=std::move(confirm_);auto text_callback=std::move(text_accept_);const auto text=field("popup-text");popup_.clear();reset_popup();dirty_=true;if(text_callback)text_callback(text);else if(callback)callback(); } return; } + if(files_native_&&files_action(action,node))return; if(action.starts_with("rankings-")&&menu_=="scorers"){rankings_action(action,node);return;} if (engine_reports_action(action,node)) return; if (almanac_action(action,node)) return; @@ -256,6 +265,7 @@ void App::engine_event(Rml::Event &event) { ticket_->open(node, device_ratio_, price.at("min"), price.at("max")); dirty_ = true; } else if (action == "engine-open" && (id == "environment" || id == "advertising")) { menu_ = id; advertising_selected_ = -1; advertising_offer_ = 0; refresh(); } + else if(action=="engine-open"&&id=="load"){engine_files_begin("load");} else if(action=="engine-open"&&id=="scorers"){menu_=id;engine_reports_sync();engine_rankings_load(engine_rankings_state_.at("league"),engine_rankings_state_.at("scope"));} else if(action=="engine-open"&&id=="fairplay"){menu_=id;engine_reports_sync();engine_fairplay_load();} else if(action=="engine-open"&&id=="other"){menu_=id;engine_reports_sync();engine_other_load(engine_other_value_.is_object()?engine_other_value_.at("viewId").get():"",engine_other_value_.is_object()?engine_other_value_.at("round").get():0);} @@ -286,5 +296,5 @@ void App::engine_event(Rml::Event &event) { } Json App::engine_snapshot() const { 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_}}; + {"response", engine_response_}, {"files_native",files_native_},{"files_busy",engine_files_busy_},{"files_current",engine_files_metadata_},{"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_files.inc b/src/modern/ui/engine_files.inc new file mode 100644 index 0000000..731ada8 --- /dev/null +++ b/src/modern/ui/engine_files.inc @@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-3.0-only +fs::path App::engine_files_directory() const { + return (config_.userdata.empty()?root_/"userdata":config_.userdata)/"careers"/content::sha256(world_->manifest().at("id").get()); +} +void App::engine_files_start(std::string label,std::function work) { + if(engine_files_busy_||engine_busy_)return;engine_files_busy_=true;files_feedback_=std::move(label);engine_files_job_=std::async(std::launch::async,std::move(work));refresh(); +} +void App::engine_files_begin(const std::string &mode) { + if(engine_files_busy_||engine_busy_)return; + if(!world_){const auto *active=mod(active_mod_);if(!active||active->type!="Modern"||!active->error.empty()){message("Bitte zuerst eine spielbare Modern-Mod aktivieren.");return;}load_world(active->file);} + reset_files();files_native_=true;files_mode_=mode;menu_=mode;files_world_=world_;files_name_="Spielstand 1";engine_files_metadata_=Json(); + const auto directory=engine_files_directory(),file=world_->source();auto link=engine_link_; + engine_files_start("Spielstände werden geladen …",[directory,file,link,mode]{auto store=make_career_files(directory,file);EngineFilesReply result;result.rows=store.list();result.feedback="";result.operation="list";if(mode=="load"&&!result.rows.empty())result.selected=result.rows.front().id;if(link)result.metadata=link->file_metadata();return result;}); +} +void App::engine_files_select(const std::string &id) { + files_selected_=id;files_entry_.reset();for(const auto &row:files_rows_)if(row.id==id){files_entry_=row;break;}files_feedback_.clear();files_reveal_selected_=true;focus_after_render_=id.empty()?"files-name":"files-confirm";refresh(); +} +void App::engine_files_poll() { + if(!engine_files_busy_||engine_files_job_.wait_for(std::chrono::milliseconds(0))!=std::future_status::ready)return; + engine_files_busy_=false; + try { + auto result=engine_files_job_.get(); + if(result.operation=="loaded") { + engine_reports_context_=Json();engine_almanac_context_=Json();engine_friendly_read_=Json();engine_friendly_stage_=0;engine_calendar_season_.clear();engine_calendar_day_=-1;engine_move_id_.clear();report_detail_kind_.clear();engine_player_.clear();lineup_selected_.clear();engine_opening_state_=Json();engine_opening_read_=Json(); + engine_mode_=true;engine_dirty_=engine_base_dirty_=false;engine_accept(std::move(*result.engine));source_.reset();entry_catalog_.reset();engine_files_current_id_=result.selected;engine_files_pending_load_.reset();scene_="engine";menu_.clear();reset_files();refresh();return; + } + files_rows_=std::move(result.rows);if(result.metadata.is_object())engine_files_metadata_=std::move(result.metadata); + if(result.operation=="saved") { + engine_accept(std::move(*result.engine));engine_files_current_id_=result.selected; + const auto pending=engine_files_pending_load_;engine_files_pending_load_.reset();menu_.clear();reset_files(); + if(pending&&!closed_)engine_files_load(*pending,true);refresh();return; + } + if(result.operation=="deleted"&&engine_files_current_id_==result.selected){engine_files_current_id_.clear();if(engine_mode_)engine_dirty_=true;result.selected.clear();} + else if(result.operation=="renamed"&&engine_files_current_id_==files_selected_)engine_files_current_id_=result.selected; + if(!result.selected.empty())engine_files_select(result.selected);else {files_selected_.clear();files_entry_.reset();} + files_feedback_=std::move(result.feedback);refresh(); + }catch(const std::exception &e){files_feedback_=e.what();engine_exit_after_save_=false;engine_files_pending_load_.reset();refresh();} +} +void App::engine_files_load(DemoFileEntry row,bool confirmed) { + if(engine_files_busy_||engine_busy_)return; + if(engine_mode_&&engine_dirty_&&!confirmed) { + confirmation("Die aktuelle Partie enthält ungespeicherte Änderungen. Vor dem Laden speichern?",[this,row]{engine_files_load(row,true);});popup_accept_="Ohne Speichern laden";popup_extra_=btn("files-save-before-load","Zuerst speichern","primary");engine_files_pending_load_=row;return; + } + const auto directory=engine_files_directory(),file=world_->source();auto link=engine_link_; + engine_files_start("Spielstand wird geprüft und geladen …",[directory,file,link,row]{auto store=make_career_files(directory,file);const auto current=store.read(row.id,row.token);(void)current;auto loaded=link;if(loaded)loaded->load_same_world(store.file(row.id),row.token);else {loaded=EngineBridge::open(file,store.file(row.id));if(store.read(row.id,row.token).token!=row.token)throw editor::Error("Der Spielstand wurde inzwischen geändert.");}auto bundle=loaded->snapshot();EngineFilesReply result;result.operation="loaded";result.selected=row.id;result.engine=EngineReply{loaded,bundle,{{"messageType","loaded"}},link?nullptr:Catalog::open(file)};return result;}); +} +bool App::engine_files_action(const std::string &action,Rml::Element *target) { + if(!action.starts_with("files-"))return false; + if(engine_files_busy_||engine_busy_)return true; + const auto id=target?target->GetAttribute("data-id",""):std::string(); + try { + if(action=="files-close"){engine_exit_after_save_=false;engine_files_pending_load_.reset();menu_.clear();reset_files();refresh();return true;} + if(action=="files-new"){engine_files_select("");return true;} + if(action=="files-select"){engine_files_select(id);return true;} + const auto directory=engine_files_directory(),file=world_->source(); + if(action=="files-load"){if(files_entry_&&files_entry_->valid())engine_files_load(*files_entry_);return true;} + if(action=="files-save") { + if(!engine_mode_||!engine_fresh_||!engine_files_metadata_.is_object())return true; + const auto name=files_entry_?files_entry_->name:CareerFiles::clean_name(files_name_);auto chosen=files_entry_; + if(!chosen)for(const auto &row:files_rows_)try{if(DemoFiles::name_key(row.name)==DemoFiles::name_key(name)){chosen=row;break;}}catch(...){} + auto link=engine_link_;const auto save=[this,directory,file,name,chosen,link]{engine_files_start("Spielstand wird gespeichert …",[directory,file,name,chosen,link]{auto store=make_career_files(directory,file);const auto row=store.put(name,[link](const auto &path){(void)link->save_copy(path);},chosen?chosen->id:std::string(),chosen?chosen->token:std::string());EngineFilesReply result;result.operation="saved";result.selected=row.id;result.engine=EngineReply{link,link->snapshot(),{{"messageType","saved"}},nullptr};return result;});}; + if(chosen)confirmation("Spielstand „"+chosen->name+"“ überschreiben?",save);else save();return true; + } + if(action=="files-rename"&&files_entry_&&files_entry_->valid()) { + const auto row=*files_entry_;text_dialog("Neue Bezeichnung",row.name,[this,directory,file,row](const auto &name){engine_files_start("Spielstand wird umbenannt …",[directory,file,row,name]{auto store=make_career_files(directory,file);const auto renamed=store.rename(row.id,row.token,name);EngineFilesReply r;r.operation="renamed";r.selected=renamed.id;r.rows=store.list();r.feedback="Spielstand umbenannt.";return r;});});return true; + } + if(action=="files-delete"&&files_entry_&&!files_entry_->token.empty()) { + const auto row=*files_entry_;confirmation("Spielstand „"+row.name+"“ wirklich löschen?",[this,directory,file,row]{engine_files_start("Spielstand wird gelöscht …",[directory,file,row]{auto store=make_career_files(directory,file);store.remove(row.id,row.token);EngineFilesReply r;r.operation="deleted";r.selected=row.id;r.rows=store.list();r.feedback="Spielstand gelöscht.";return r;});});return true; + } + if(action=="files-import") { + auto input=config_.file_import;if(input.empty()){NFD::Guard guard;NFD::UniquePath selected;const nfdfilteritem_t filter[]={{"OpenBMH-Spielstand","obs"}};const auto result=NFD::OpenDialog(selected,filter,1);if(result==NFD_CANCEL)return true;if(result!=NFD_OKAY)throw editor::Error("Die Dateiauswahl konnte nicht geöffnet werden.");input=editor::path(selected.get());} + engine_files_start("Spielstand wird importiert …",[directory,file,input]{auto store=make_career_files(directory,file);const auto imported=store.import_file(input);EngineFilesReply r;r.operation="imported";r.selected=imported.id;r.rows=store.list();r.feedback="Spielstand importiert. Die aktive Partie bleibt unverändert.";return r;});return true; + } + if(action=="files-export"&&files_entry_&&files_entry_->valid()) { + const auto row=*files_entry_;auto output=config_.file_export;if(output.empty()){NFD::Guard guard;NFD::UniquePath selected;const nfdfilteritem_t filter[]={{"OpenBMH-Spielstand","obs"}};const auto name=row.name+".obs";const auto result=NFD::SaveDialog(selected,filter,1,nullptr,name.c_str());if(result==NFD_CANCEL)return true;if(result!=NFD_OKAY)throw editor::Error("Die Dateiauswahl konnte nicht geöffnet werden.");output=editor::path(selected.get());} + const auto copy=[this,directory,file,row,output]{engine_files_start("Spielstand wird exportiert …",[directory,file,row,output]{auto store=make_career_files(directory,file);store.export_file(row.id,row.token,output,fs::exists(output));EngineFilesReply r;r.operation="exported";r.selected=row.id;r.rows=store.list();r.feedback="Spielstand exportiert.";return r;});};if(fs::exists(output))confirmation("Vorhandene Exportdatei ersetzen?",copy);else copy();return true; + } + }catch(const std::exception &e){files_feedback_=e.what();refresh();} + return true; +} diff --git a/src/modern/ui/engine_files_state.inc b/src/modern/ui/engine_files_state.inc new file mode 100644 index 0000000..7966bd2 --- /dev/null +++ b/src/modern/ui/engine_files_state.inc @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: GPL-3.0-only +struct EngineFilesReply { + std::vector rows; + std::string selected,feedback,operation; + Json metadata; + std::optional engine; +}; +bool files_native_=false,engine_files_busy_=false; +std::future engine_files_job_; +Json engine_files_metadata_; +std::string engine_files_current_id_; +std::optional engine_files_pending_load_; +fs::path engine_files_directory() const; +void engine_files_begin(const std::string &); +void engine_files_start(std::string,std::function); +void engine_files_poll(); +void engine_files_select(const std::string &); +void engine_files_load(DemoFileEntry,bool confirmed=false); +bool engine_files_action(const std::string &,Rml::Element *); diff --git a/src/modern/ui/engine_screens.inc b/src/modern/ui/engine_screens.inc index 4395507..bccc6e5 100644 --- a/src/modern/ui/engine_screens.inc +++ b/src/modern/ui/engine_screens.inc @@ -36,6 +36,7 @@ Json App::engine_camp_view() const { return {{"maps", maps}, {"training_camps", camps}}; } void App::engine_render() { + if(menu_=="save"||menu_=="load"||!files_mode_.empty())files_before_render(); if (ticket_) ticket_->close(false); if(menu_=="scorers"||menu_=="fairplay")rankings_remember_scroll(); fixture_half_width_=-1.f; @@ -51,7 +52,7 @@ void App::engine_render() { if (engine_data_.empty()) { out = "

OpenBMH

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

"; - } else if(engine_opening_active()) { + } else if(engine_opening_active()&&menu_.empty()) { out=main_menu()+"
"+render_opening()+"
"; } else { const auto &desk = engine_data_.at("desktop").at("data"), &meta = engine_data_.at("desktop").at("meta"); @@ -118,11 +119,12 @@ void App::engine_render() { const auto route = id.substr(4); const bool camp_allowed = desk.at("menuAvailability").at("camps").value("status", "") == "available"; const auto commands = meta.at("scope").value("allowedCommands", Json::array()); - const bool supported = ((route=="tables"||route=="strengths"||route=="league"||route=="other"||route=="scorers"||route=="fairplay")&&engine_fresh_&&meta.at("scope").at("role")=="club") || (route == "almanac" && engine_fresh_) || (route == "friendlies" && friendlies_available && engine_fresh_) || (route == "calendar" && calendar_available && engine_fresh_) || (route == "postpone" && scheduling_available && engine_fresh_) || (route == "contracts" && contracts_available && engine_fresh_) || (route == "environment" && environment_available && engine_fresh_) || (route == "advertising" && advertising_available && engine_fresh_) || (route == "bank" && bank_available && engine_fresh_) || (route == "training" && training_available && engine_fresh_) || (route == "tactics" && tactics_available && engine_fresh_) || (route == "lineup" && lineup_available && engine_fresh_) || route == "save" || (route == "camp" && engine_fresh_ && camp_allowed && std::find(commands.begin(), commands.end(), Json("camp.book")) != commands.end()); + const bool supported = ((route=="tables"||route=="strengths"||route=="league"||route=="other"||route=="scorers"||route=="fairplay")&&engine_fresh_&&meta.at("scope").at("role")=="club") || (route == "almanac" && engine_fresh_) || (route == "friendlies" && friendlies_available && engine_fresh_) || (route == "calendar" && calendar_available && engine_fresh_) || (route == "postpone" && scheduling_available && engine_fresh_) || (route == "contracts" && contracts_available && engine_fresh_) || (route == "environment" && environment_available && engine_fresh_) || (route == "advertising" && advertising_available && engine_fresh_) || (route == "bank" && bank_available && engine_fresh_) || (route == "training" && training_available && engine_fresh_) || (route == "tactics" && tactics_available && engine_fresh_) || (route == "lineup" && lineup_available && engine_fresh_) || route == "save" || route == "load" || (route == "camp" && engine_fresh_ && camp_allowed && std::find(commands.begin(), commands.end(), Json("camp.book")) != commands.end()); out += desktop_button(id, o, "engine-open", supported && !engine_busy_); } } out += ""; + if(menu_=="save"||menu_=="load")out+="
"+window(menu_=="save"?"Spiel speichern":"Spiel laden",render_files(false,menu_=="save"))+"
"; if(menu_=="scorers")out+="
"+window("Spielerstatistiken",engine_rankings_value_.is_object()?render_scorers():"
"+esc(engine_busy_?"Spielerstatistiken werden geladen …":engine_notice_)+"
")+"
"; if(menu_=="fairplay")out+="
"+window("Fairplay",engine_fairplay_value_.is_object()?render_fairplay():"
"+esc(engine_busy_?"Fairplay wird geladen …":engine_notice_)+"
")+"
"; if(menu_=="other")out+="
"+window("Übrige Spiele",engine_other_value_.is_object()?render_reports("other"):"
"+esc(engine_busy_?"Wettbewerbe werden geladen …":engine_other_index_.is_object()?"Keine aktiven Wettbewerbe.":engine_notice_)+"
")+"
"; diff --git a/src/modern/ui/entry_opening_controls.inc b/src/modern/ui/entry_opening_controls.inc index 6fcd6f2..1c82cf6 100644 --- a/src/modern/ui/entry_opening_controls.inc +++ b/src/modern/ui/entry_opening_controls.inc @@ -199,7 +199,7 @@ void App::opening_tick() { } 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_creation_busy_||engine_files_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."; diff --git a/src/modern/ui/files_controls.inc b/src/modern/ui/files_controls.inc index 716f8b2..f932b64 100644 --- a/src/modern/ui/files_controls.inc +++ b/src/modern/ui/files_controls.inc @@ -11,6 +11,7 @@ bool App::files_bound() const { files_desktop_base_ == desktop_ && files_theme_base_ == theme_; } void App::reset_files() { + files_native_=false;engine_files_metadata_=Json(); files_mode_.clear(); files_selected_.clear(); files_name_.clear(); @@ -27,6 +28,7 @@ void App::reset_files() { files_reveal_selected_ = false; } void App::files_begin(const std::string &mode) { + if(!config_.preview_only&&(mode=="save"||mode=="load")){engine_files_begin(mode);return;} reset_files(); files_mode_ = mode; files_world_ = world_; @@ -48,6 +50,7 @@ void App::files_begin(const std::string &mode) { } } void App::files_reload(const std::string &selected) { + if(files_native_){engine_files_select(selected.empty()?files_selected_:selected);return;} files_rows_ = files_store().list(); if (!selected.empty()) files_selected_ = selected; @@ -71,6 +74,7 @@ void App::files_reload(const std::string &selected) { } } void App::files_select(const std::string &selected) { + if(files_native_){engine_files_select(selected);return;} files_selected_ = selected; files_feedback_.clear(); files_reload(); @@ -103,6 +107,7 @@ void App::files_before_render() { } } void App::files_after_render() { + if(files_native_&&engine_files_busy_){Rml::ElementList nodes;doc_->QuerySelectorAll(nodes,".window button,.window input");for(auto *n:nodes)n->SetAttribute("disabled",true);} if (files_capturing_ || files_mode_ != menu_) return; context_->Update(); @@ -266,6 +271,7 @@ void App::files_load() { refresh(); } bool App::files_action(const std::string &action, Rml::Element *target) { + if(files_native_){if(action=="close")return engine_files_action("files-close",target);return engine_files_action(action,target);} if (!action.starts_with("files-")) return false; const auto id = @@ -431,7 +437,7 @@ bool App::files_change(Rml::Element *target) { if (auto *button = element("files-confirm")) { bool valid = true; try { - DemoFiles::clean_name(files_name_); + if(files_native_)CareerFiles::clean_name(files_name_);else DemoFiles::clean_name(files_name_); } catch (...) { valid = false; } @@ -446,6 +452,7 @@ bool App::files_change(Rml::Element *target) { return true; } bool App::files_event(Rml::Event &event) { + if(files_native_&&engine_files_busy_){event.StopImmediatePropagation();return true;} if (files_mode_.empty() || !popup_.empty()) return false; if (event.GetType() == "input" || event.GetType() == "change") diff --git a/src/modern/ui/files_screens.inc b/src/modern/ui/files_screens.inc index 145dfc7..386cf54 100644 --- a/src/modern/ui/files_screens.inc +++ b/src/modern/ui/files_screens.inc @@ -5,6 +5,7 @@ std::string App::files_standard_preview() { } std::string App::files_details(bool layouts, bool save) { + if(files_native_&&engine_files_busy_&&save&&!engine_files_metadata_.is_object())return "

Spielstände werden geladen …

"; const bool standard = layouts && files_selected_ == "standard"; const bool fresh = save && files_selected_.empty(); if (files_entry_ && !files_entry_->valid()) @@ -35,8 +36,8 @@ std::string App::files_details(bool layouts, bool save) { for (const auto &[label, value] : meta) out += ""; return out + ""; } - const auto data = fresh ? snap().state : files_entry_->data; - const auto meta = DemoFiles::career_metadata(data); + const auto data = fresh ? (files_native_?engine_files_metadata_:snap().state) : files_entry_->data; + const auto meta = files_native_?data:DemoFiles::career_metadata(data); const auto &managers = meta.at("managers"); const Json *own = managers.empty() ? nullptr : world_->find("clubs", meta.at("current_manager").value("club", "")); out = "
" + (meta.at("role")=="national"?img("career.national-de",108,108,false,false,256):crest(own,108)) + "

" + std::string(fresh ? "Aktuelles Spiel" : "Gespeicherter Spielstand") + "

" + esc(fresh ? "Neuer Speicherstand" : files_entry_->name) + "

" + esc(meta.at("role")=="national"?"Deutschland":own ? world_->name(*own) : "") + "
"; @@ -49,9 +50,9 @@ std::string App::files_details(bool layouts, bool save) { out += "

Mitspieler

"; for (const auto &manager : managers) { const auto *managed = world_->find("clubs", manager.value("club", "")); - out += "
" + esc(manager.value("name", "")) + "" + esc(meta.at("role")=="national"&&manager.value("portrait",0)==meta.at("current_manager").value("portrait",0)?"Deutschland":managed ? world_->name(*managed) : "") + "
"; + out += "
" + esc(manager.value("name", "")) + "" + esc(files_native_?manager.value("team_name",std::string()):meta.at("role")=="national"&&manager.value("portrait",0)==meta.at("current_manager").value("portrait",0)?"Deutschland":managed ? world_->name(*managed) : "") + "
"; } - return out + "

" + (fresh ? "Diese Angaben werden mit dem Spielstand gespeichert." : "Gespeichert am " + esc(files_entry_->created) + "
Geändert am " + esc(files_entry_->modified) + " · " + std::to_string(files_entry_->bytes) + " Bytes") + "

"; + return out + "

" + (fresh ? "Diese Angaben werden mit dem Spielstand gespeichert." : (files_native_?"Datei geändert am ":"Gespeichert am ") + esc(files_entry_->created) + (files_native_?std::string():"
Geändert am "+esc(files_entry_->modified)) + " · " + std::to_string(files_entry_->bytes) + " Bytes") + "

"; } std::string App::render_files(bool layouts, bool save) { if (files_mode_ != menu_) files_begin(menu_); @@ -66,13 +67,13 @@ std::string App::render_files(bool layouts, bool save) { const auto &entry = files_rows_[i]; entries += row("files-select", entry.id, entry.name, entry.valid() ? "Gespeichert am " + entry.created : "Datei kann nicht geöffnet werden", files_selected_ == entry.id, "files-entry-" + std::to_string(i)); } - if (entries.empty()) entries = "

Noch keine Spielstände vorhanden.

"; + if (entries.empty()) entries = "

"+std::string(files_native_&&engine_files_busy_?"Spielstände werden geladen …":"Noch keine Spielstände vorhanden.")+"

"; std::string details; try { details = files_details(layouts, save); } catch (const std::exception &e) { details = "

Datei nicht verfügbar

" + esc(e.what()) + "

"; } const bool selected = files_entry_ && files_entry_->valid(); - bool can_save = save && (!files_entry_ || selected); - if (save && !selected) try { DemoFiles::clean_name(files_name_); } catch (...) { can_save = false; } + bool can_save = save && (!files_entry_ || selected) && (!files_native_||engine_files_metadata_.is_object()); + if (save && !selected) try { if(files_native_)CareerFiles::clean_name(files_name_);else DemoFiles::clean_name(files_name_); } catch (...) { can_save = false; } const auto disabled = selected ? "" : "disabled"; std::string footer = "
"; if (!layouts) footer += btn("files-import", "Importieren") + btn("files-export", "Exportieren", {}, disabled); diff --git a/src/modern/ui/front_screens.inc b/src/modern/ui/front_screens.inc index 5888102..19d6edf 100644 --- a/src/modern/ui/front_screens.inc +++ b/src/modern/ui/front_screens.inc @@ -54,7 +54,7 @@ std::string App::main_menu() { "class=\"front-active-dot\">
Aktive Mod" + esc(label) + "
v" + - std::string(kOpenBmhVersion) + " · UI-Demo"; + std::string(kOpenBmhVersion) + (config_.preview_only ? " · UI-Demo" : " · Entwicklung") + ""; return out; } std::string App::front_mod_details() { diff --git a/src/modern/ui/view.cpp b/src/modern/ui/view.cpp index b544189..f97fe4c 100644 --- a/src/modern/ui/view.cpp +++ b/src/modern/ui/view.cpp @@ -7,6 +7,7 @@ #include "modern/ui/controls.hpp" #include "modern/ui/crest_contrast.hpp" #include "modern/ui/engine_bridge.hpp" +#include "modern/ui/career_files.hpp" #include "modern/ui/live_match_info.hpp" #include "modern/ui/script_locator.hpp" #include "modern/ui/select_menu.hpp" @@ -480,6 +481,7 @@ class App final : public Rml::EventListener { #include "modern/ui/settings_state.inc" #include "modern/ui/widgets_state.inc" #include "modern/ui/files_state.inc" +#include "modern/ui/engine_files_state.inc" #include "modern/ui/front_state.inc" #include "modern/ui/live_state.inc" #include "modern/ui/postmatch_state.inc" @@ -1110,6 +1112,7 @@ class App final : public Rml::EventListener { } void frame() { engine_create_poll(); + engine_files_poll(); if (engine_mode_) { engine_frame(); return; } front_poll(); flush_selects(); @@ -1444,6 +1447,7 @@ public: while (!closed_) { front_poll(); engine_create_poll(); + engine_files_poll(); if (engine_mode_) engine_poll(); opening_tick(); live_tick(); @@ -1536,6 +1540,7 @@ public: #include "modern/ui/engine_reports.inc" #include "modern/ui/engine_rankings.inc" #include "modern/ui/engine_creation.inc" +#include "modern/ui/engine_files.inc" } // namespace bool is_modern_world(const fs::path &file) { try { diff --git a/tests/modern_career_files_tests.cpp b/tests/modern_career_files_tests.cpp new file mode 100644 index 0000000..f78994e --- /dev/null +++ b/tests/modern_career_files_tests.cpp @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "modern/ui/career_files.hpp" +#include +#include +#include +using namespace bmh::modern_ui; +namespace { +void require(bool ok,const char *why){if(!ok)throw std::runtime_error(why);} +template void rejected(F f,const char *why){bool caught=false;try{f();}catch(const std::exception&){caught=true;}require(caught,why);} +struct Fixture { + fs::path root=fs::temp_directory_path()/("modern-career-files-"+std::to_string(std::chrono::steady_clock::now().time_since_epoch().count())); + Fixture(){fs::create_directories(root);} + ~Fixture(){std::error_code e;fs::remove_all(root,e);} +}; +Json metadata(const fs::path &file){const auto j=Json::parse(bmh::editor::read_file(file));if(j.at("world")!="synthetic")throw std::runtime_error("wrong world");return j;} +CareerFiles::Writer writer(int value){return [value](const fs::path &file){bmh::editor::write_atomic(file,Json{{"world","synthetic"},{"value",value}}.dump(),false);};} +void transactions(){ + Fixture f;CareerFiles store(f.root/"careers",metadata);require(store.list().empty()&&!fs::exists(store.directory()),"browsing created storage"); + auto first=store.put("Öffnung",writer(1));const auto original=bmh::editor::read_file(store.file(first.id));require(first.data.at("value")==1&&store.read(first.id,first.token).bytes==original.size(),"published save differs"); + rejected([&]{store.put("o\xcc\x88" "FFNUNG",writer(2));},"casefold duplicate replaced save"); + rejected([&]{store.put(first.name,writer(2),first.id,"stale");},"stale overwrite accepted"); + rejected([&]{store.put(first.name,[](const auto &file){bmh::editor::write_atomic(file,"partial",false);throw std::runtime_error("disk error");},first.id,first.token);},"writer failure published"); + rejected([&]{store.put(first.name,[](const auto &file){bmh::editor::write_atomic(file,"not a career",false);},first.id,first.token);},"invalid replacement published"); + require(bmh::editor::read_file(store.file(first.id))==original,"failed replacement damaged original"); + auto second=store.put(first.name,writer(2),first.id,first.token);require(second.data.at("value")==2&&second.token!=first.token,"confirmed overwrite lost new state"); + rejected([&]{store.remove(first.id,first.token);},"old deletion token accepted"); + const auto renamed=store.rename(second.id,second.token,"Neue Saison");require(!fs::exists(store.file(second.id))&&renamed.data==second.data,"rename altered data"); + const auto exported=f.root/"export.obs";store.export_file(renamed.id,renamed.token,exported);require(bmh::editor::read_file(exported)==bmh::editor::read_file(store.file(renamed.id)),"export altered bytes"); + rejected([&]{store.export_file(renamed.id,renamed.token,exported);},"export overwrote without consent"); + rejected([&]{store.export_file(renamed.id,renamed.token,store.file("Other.obs"));},"export mutated internal library"); + const auto imported=store.import_file(exported);require(imported.id!=renamed.id&&imported.data==renamed.data,"import replaced an existing entry"); + bmh::editor::write_atomic(store.file(renamed.id),Json{{"world","synthetic"},{"value",3}}.dump()); + rejected([&]{store.read(renamed.id,renamed.token);},"external mutation missed on read"); + rejected([&]{store.rename(renamed.id,renamed.token,"Stale");},"external mutation missed on rename"); + rejected([&]{store.remove(renamed.id,renamed.token);},"external mutation missed on delete"); + rejected([&]{store.export_file(renamed.id,renamed.token,f.root/"stale.obs");},"external mutation missed on export"); + store.remove(imported.id,imported.token);require(!fs::exists(store.file(imported.id)),"delete retained selected save"); + bmh::editor::write_atomic(store.file("Corrupt.obs"),"damaged");const auto entries=store.list();bool corrupt=false;for(const auto &e:entries)if(e.id=="Corrupt.obs")corrupt=!e.valid()&&!e.token.empty();require(corrupt,"corrupt entry disappeared or became loadable"); + for(const auto &p:fs::directory_iterator(store.directory()))require(!bmh::editor::utf8(p.path().filename()).starts_with(".pending-"),"staging leak"); +} +void boundaries(){ + Fixture f;CareerFiles store(f.root/"library",metadata); + for(const auto *name:{"../escape.obs","a/b.obs","a\\b.obs",".hidden.obs","wrong.json",""})rejected([&]{store.read(name);},"unsafe identifier accepted"); + for(const auto *name:{"CON","../escape","", "line\nbreak"})rejected([&]{store.put(name,writer(1));},"unsafe filename accepted"); + auto max=store.put(std::string(64,'x'),writer(1));const auto free=store.free_name(max.name);require(free!=max.name&&DemoFiles::clean_name(free)==free,"long-name import suffix invalid"); + const auto before=store.list().size();rejected([&]{store.put("Wrong world",[](const auto &p){bmh::editor::write_atomic(p,"{\"world\":\"other\"}",false);});},"foreign world accepted");require(store.list().size()==before,"foreign import changed library"); + std::error_code e;fs::create_symlink(store.file(max.id),store.file("Link.obs"),e);if(!e){rejected([&]{store.read("Link.obs");},"linked source accepted");rejected([&]{store.remove("Link.obs",max.token);},"linked source deleted");} + fs::create_directory_symlink(store.directory(),f.root/"linked",e);if(!e){CareerFiles linked(f.root/"linked",metadata);rejected([&]{linked.list();},"linked library accepted");} + // Recursive callback simulates concurrent writers. OS locks release after the failure. + rejected([&]{store.put("Outer",[&](const auto &){store.put("Inner",writer(7));});},"simultaneous writers accepted"); + require(store.put("After failed lock",writer(8)).valid(),"failed writer retained lock"); +} +} +int main(){try{transactions();boundaries();std::cout<<"career files: transactions, stale files, failed producers, imports, names and boundaries passed\n";return 0;}catch(const std::exception &e){std::cerr<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","verify-create","inspect-coach-identity","prepare-coach-identity","verify-coach-almanac"}; + 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","inspect-coach-identity","prepare-coach-identity","verify-coach-almanac","verify-files"}; 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)); }; @@ -128,6 +130,23 @@ int main(int argc, char **argv) { 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"); + if(mode=="verify-files") { + auto store=make_career_files(out/"library",world);const auto meta=link->file_metadata();write("metadata.json",meta); + const auto first=store.put("Erste Saison",[&](const auto &path){link->save_copy(path);}); + if(first.data!=meta||link->snapshot()!=before)throw std::runtime_error("save/list changed state or metadata"); + // A real command changes revision; loading the saved copy must restore the earlier career. + const auto current=engine_money_minor(before.at("stadium").at("data").at("ticketPrice"))/100; + const auto request=engine_ticket_command(before,int(current==20?21:20),"request:file-change"); + const auto response=link->command(request);write("changed-response.json",response);if(response.value("messageType","")!="command_result")throw std::runtime_error(response.dump()); + link->load_same_world(store.file(first.id),first.token);if(link->snapshot()!=before)throw std::runtime_error("staged load failed to restore snapshot"); + store.export_file(first.id,first.token,out/"export.obs");const auto imported=store.import_file(out/"export.obs");if(imported.data!=first.data)throw std::runtime_error("real OBS import metadata differs"); + editor::write_atomic(out/"damaged.obs","damaged"); + auto documents=content::read_archive(store.file(first.id));auto driver=Json::parse(documents.at("state/driver.json"));driver["schema"]="invalid-driver";documents["state/driver.json"]=driver.dump();auto integrity=Json::parse(documents.at("state/integrity.json"));integrity["entries"]["state/driver.json"]=content::sha256(documents.at("state/driver.json"));documents["state/integrity.json"]=integrity.dump();content::write_archive(documents,out/"bad-driver.obs",false); + Json rejected=Json::array();for(const auto *file:{"damaged.obs","bad-driver.obs"}){bool caught=false;try{link->load_same_world(out/file);}catch(const std::exception &e){caught=true;rejected.push_back({{"file",file},{"error",e.what()}});}if(!caught||link->snapshot()!=before)throw std::runtime_error("rejected load damaged old session");} + // A command after the failed staged constructor catches leaked process-global layout state. + const auto after=link->command(request);if(after.value("messageType","")!="command_result")throw std::runtime_error("old session no longer usable after failed load"); + write("rejected.json",rejected);write("after-failures.json",link->snapshot());write("receipt.json",{{"status","passed"},{"realObsRoundTrip",true},{"failedLoadPreservesSession",true},{"metadataReadOnly",true}});std::cout<<"real OBS file library and staged load failure preservation passed\n";return 0; + } if (std::string(argv[1]) == "inspect-friendlies") { const auto &opponents=before.at("friendly-plan").at("data").at("opponents"); if(opponents.empty())throw std::runtime_error("no friendly opponents");