From f75e0f8e492a266e89ab1b502affb0beeeed6c2e Mon Sep 17 00:00:00 2001 From: Codex Date: Wed, 28 Oct 2026 09:57:12 +0100 Subject: [PATCH] Bind tactics and training drafts to confirmed engine commits (by Codex) --- docs/new_ui/NATIVE_STATUS.md | 2 +- docs/new_ui/desktop/tactics/README.md | 13 +++ docs/new_ui/desktop/training/README.md | 13 +++ docs/new_ui/integration/ENGINE_ENTRY.md | 39 ++++++- docs/new_ui/integration/NATIVE_BINDING_MAP.md | 2 +- src/modern/ui/demo_sports.cpp | 6 +- src/modern/ui/demo_sports.hpp | 2 +- src/modern/ui/engine_bridge.cpp | 2 +- src/modern/ui/engine_bridge.hpp | 6 + src/modern/ui/engine_controls.inc | 16 ++- src/modern/ui/engine_dto.cpp | 109 ++++++++++++++++++ src/modern/ui/engine_screens.inc | 8 +- src/modern/ui/engine_sports.inc | 107 +++++++++++++++++ src/modern/ui/engine_state.inc | 8 +- src/modern/ui/sports_screens.inc | 50 ++++---- src/modern/ui/view.cpp | 1 + tests/modern_engine_bridge_probe.cpp | 25 +++- tests/modern_engine_dto_tests.cpp | 32 +++++ 18 files changed, 398 insertions(+), 43 deletions(-) create mode 100644 src/modern/ui/engine_sports.inc diff --git a/docs/new_ui/NATIVE_STATUS.md b/docs/new_ui/NATIVE_STATUS.md index 6b93696..29268bc 100644 --- a/docs/new_ui/NATIVE_STATUS.md +++ b/docs/new_ui/NATIVE_STATUS.md @@ -6,7 +6,7 @@ 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 und Aufstellung an die +echte Modern-OBS-Karriere und bindet Schreibtisch, Trainingslager, Aufstellung, Taktik und Training an die Session. Kader und Profile zeigen die tatsächlichen Sessionwerte; Spielertausch verwendet die bestätigte Engineaktion. Preisbestätigung, Buchung und Speichern als neue OBS-Datei sind echte Engineoperationen. Dieser Einstieg ist auf diesen Umfang begrenzt; die übrigen diff --git a/docs/new_ui/desktop/tactics/README.md b/docs/new_ui/desktop/tactics/README.md index bede05c..f2f074e 100644 --- a/docs/new_ui/desktop/tactics/README.md +++ b/docs/new_ui/desktop/tactics/README.md @@ -50,3 +50,16 @@ Linux/OpenGL wurde tatsächlich gerendert. Windows/macOS haben CI-Builds und synthetische Tests; ihre visuelle Laufzeitabnahme ist damit nicht erledigt. Kleine Schrift-/Kantenrasterungsunterschiede bleiben protokolliert. Siehe [wiederholbare Menü-QA](../../menu-qa.md). + + +## Echter Engine-Einstieg + +Über `--ui-career` verwendet derselbe Presenter jetzt die passenden Engine-Reads. +Änderungen bleiben im lokalen Entwurf bis „Anwenden“ und dessen Bestätigung. +Zurücksetzen, Abbruch und Schließen verändern den Spielstand nicht. Die Bridge +verwendet die echten Commit-Befehle mit stabilen IDs und Revisionsschutz; Werte, +Bereiche und Budgets werden nicht aus Demoformeln ergänzt. Bestätigte Änderungen +werden als neue OBS-Datei gespeichert und nach Neustart wieder eingelesen. +Nicht im Commit-Vertrag verfügbare Automatiken und Spielerschwerpunkte bleiben +im echten Trainingsmenü schreibgeschützt. Der bisherige Demomodus bleibt separat. +Private Nachweise: `bmh_4k_ui/docs/qa/engine-sports-2026-10-28/`. diff --git a/docs/new_ui/desktop/training/README.md b/docs/new_ui/desktop/training/README.md index 008945c..e95c30f 100644 --- a/docs/new_ui/desktop/training/README.md +++ b/docs/new_ui/desktop/training/README.md @@ -73,3 +73,16 @@ Synthetische Tests ergänzen atomare Ablehnung, Revisionen und Migration. Die gemeinsame Dropdown-Markierungsspalte und geringe Unterschiede der Kantenglättung bleiben dokumentierte Abweichungen. Screenshots, Eingaben und passende Demostände: [wiederholbare Menü-QA](../../menu-qa.md). + + +## Echter Engine-Einstieg + +Über `--ui-career` verwendet derselbe Presenter jetzt die passenden Engine-Reads. +Änderungen bleiben im lokalen Entwurf bis „Anwenden“ und dessen Bestätigung. +Zurücksetzen, Abbruch und Schließen verändern den Spielstand nicht. Die Bridge +verwendet die echten Commit-Befehle mit stabilen IDs und Revisionsschutz; Werte, +Bereiche und Budgets werden nicht aus Demoformeln ergänzt. Bestätigte Änderungen +werden als neue OBS-Datei gespeichert und nach Neustart wieder eingelesen. +Nicht im Commit-Vertrag verfügbare Automatiken und Spielerschwerpunkte bleiben +im echten Trainingsmenü schreibgeschützt. Der bisherige Demomodus bleibt separat. +Private Nachweise: `bmh_4k_ui/docs/qa/engine-sports-2026-10-28/`. diff --git a/docs/new_ui/integration/ENGINE_ENTRY.md b/docs/new_ui/integration/ENGINE_ENTRY.md index 6301fef..ae7f9e1 100644 --- a/docs/new_ui/integration/ENGINE_ENTRY.md +++ b/docs/new_ui/integration/ENGINE_ENTRY.md @@ -1,5 +1,5 @@ -# Nativer Engine-Einstieg: Schreibtisch, Trainingslager und Aufstellung +# Nativer Engine-Einstieg: Schreibtisch, Trainingslager, Aufstellung und Vorbereitung Der opt-in Einstieg lädt eine bestehende Modern-Karriere aus einer OBS-Datei. Er ist ein erster vertikaler Integrationsschritt, kein vollständiger spielbarer @@ -17,7 +17,7 @@ werden. Die Quelle wird nicht in DemoSource überführt. ## Gebundener Umfang -- `ModernSession::ui_read`: `session`, `desktop`, `camps`, `squad`, `lineup`. Karriere, Manager, +- `ModernSession::ui_read`: `session`, `desktop`, `camps`, `squad`, `lineup`, `tactics`, `training`. 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 @@ -59,6 +59,36 @@ bleiben in diesem echten Einstieg bis zu ihren eigenen Engineanschlüssen unverfügbar; die vollständige Demo behält ihre getrennte Bedienung. Die erweiterten Nachweise liegen unter `bmh_4k_ui/docs/qa/engine-lineup-2026-10-28/`. +## Taktik und Training + +Beide bestehenden Presenter sind im echten Einstieg angebunden. Ihre Werte, +Bereiche und Ballbudgets stammen aus den jeweiligen Engine-Reads. Die Taktiktafel +verwendet die tatsächlich gelieferten Aufstellungskoordinaten einschließlich +`depthMax`/`laneMax`; eine unbekannte Formation wird nicht ersetzt. Die neutralen +Taktikbezeichnungen des Vertrags bleiben erhalten. + +Änderungen sind zunächst lokale Entwürfe. „Zurücksetzen“ verwirft sie, Schließen +übernimmt nichts. „Anwenden“ fragt nach Bestätigung und sendet dann +`tactics.commit` beziehungsweise `training.commit` mit Karriere, Manager, +erwarteter Revision und neuer requestId. Der Client prüft die vom Read genannten +Bereiche/Budgets; die maßgebliche Anwendung und weitere Prüfung bleiben bei der +Engine. Bei noch nicht eingerichtetem Training weist die UI auf die erstmalige +Einrichtung mit Anwenden hin. Öffnen des Menüs initialisiert es nicht heimlich. + +Training zeigt den aktuellen Engine-Kader und dessen Stärke statt der statischen +Katalogwerte. Typen, Bereiche und Spielerintensität sind bearbeitbar. Die vier +Automatikschalter spiegeln die gespeicherten Bildschirmflags, sind hier aber +schreibgeschützt; ihr Byte wird vom Client nicht geschrieben. Auch die vorhandenen +Spielerschwerpunkte bleiben bis zu einem entsprechenden Commit-Vertrag +schreibgeschützt. Unbelegte Überlastungsschwellen aus der Demo werden im echten +Einstieg nicht als neue Engine-Regeln eingeführt. + +Die Hintergrundaufträge liefern nach dem Commit einen neuen zusammenhängenden +Snapshot. Rückmeldung und Änderungsstatus folgen der Engineantwort; ein bestätigter +No-op wird nicht als neue ungespeicherte Änderung ausgegeben. Taktik und Training +bleiben in einer neuen OBS-Datei und nach Prozessneustart erhalten. Private Belege: +`bmh_4k_ui/docs/qa/engine-sports-2026-10-28/`. + ## Ausführung und Dateien Laden, Reads nach einer Aktion, Buchen und Speichern laufen seriell über einen @@ -81,10 +111,11 @@ Die Demoabläufe sind davon ausdrücklich getrennt. `modern_engine_dto_tests` ist synthetisch und prüft Kontextschutz, exakte große Geld-/Revisionswerte, fremde/veraltete Angebote, National-Sperre und ungültige -Schwerpunkte. Der opt-in `modern_engine_bridge_probe prepare|verify|verify-lineup +Schwerpunkte. Der opt-in `modern_engine_bridge_probe prepare|verify|verify-lineup|verify-sports ` prüft mit privat bereitgestellten Weltdaten tatsächliche Buchung, Preisabzug, Anfragewiederholung und OBS-Speicherrundreise. `verify-lineup` prüft zusätzlich tatsächlichen Tausch, -Wiederholung, abgewiesene alte Revision und gespeicherte Aufstellung. Er ist kein +Wiederholung, abgewiesene alte Revision und gespeicherte Aufstellung. `verify-sports` prüft Taktik/Training, Anfragewiederholung, +alte Revision und gespeicherte Pläne. Er ist kein bedingungsloser CTest und verteilt keine Originaldaten. `--ui-script` unterstützt `engine-wait` zum Abwarten realer Hintergrundaufträge. diff --git a/docs/new_ui/integration/NATIVE_BINDING_MAP.md b/docs/new_ui/integration/NATIVE_BINDING_MAP.md index 9f66310..7d8fb7f 100644 --- a/docs/new_ui/integration/NATIVE_BINDING_MAP.md +++ b/docs/new_ui/integration/NATIVE_BINDING_MAP.md @@ -3,7 +3,7 @@ Stand: 28. Oktober 2026. Neben der UI-Demo gibt es jetzt einen getrennten [opt-in Engine-Einstieg](ENGINE_ENTRY.md) für echte OBS-Karrieren mit Schreibtisch, -Trainingslager und Aufstellung. Die übrigen hier genannten Presenter laufen weiterhin als +Trainingslager, Aufstellung, Taktik und Training. Die übrigen hier genannten Presenter laufen weiterhin als UI-Demo. Diese Übersicht ergänzt den [gestuften Einstieg](MVP_FOR_CLAUDE.md) um die tatsächlich vorhandenen C++-Anschlussstellen; sie definiert kein weiteres Protokoll und verlangt keine neue Enginearchitektur. diff --git a/src/modern/ui/demo_sports.cpp b/src/modern/ui/demo_sports.cpp index f333c17..f713099 100644 --- a/src/modern/ui/demo_sports.cpp +++ b/src/modern/ui/demo_sports.cpp @@ -181,7 +181,7 @@ std::string edit_demo_tactics(Json &state, const Json &action) { return {}; } std::string tactics_diagram(const Json &state, const std::string &theme, - const Json &lineup_points) { + const Json &lineup_points, int depth_max, int lane_max) { const auto values = state.at("values").get>(); const std::string line = theme == "silver" ? "#536f66" : "#dfe8bf"; const auto field_line = theme == "silver" ? "#536f66" : "#d7edbf", @@ -236,7 +236,7 @@ std::string tactics_diagram(const Json &state, const std::string &theme, for (size_t i = 0; i < lineup_points.size(); ++i) { const auto &p = lineup_points[i]; if (!p.is_array() || p.size() != 2 || !p[0].is_number_integer() || - !p[1].is_number_integer() || p[0] < 0 || p[0] > 18 || p[1] < 0 || p[1] > 8) + !p[1].is_number_integer() || p[0] < 0 || p[0] > depth_max || p[1] < 0 || p[1] > lane_max) throw editor::Error("invalid_lineup_points"); const std::pair point{p[0].get(), p[1].get()}; if (!occupied.insert(point).second) throw editor::Error("invalid_lineup_points"); @@ -244,7 +244,7 @@ std::string tactics_diagram(const Json &state, const std::string &theme, } } for (const auto &[x, y] : formation) { - const double px = 25 + x / 18.0 * 82, py = 16 + y / 8.0 * 49; + const double px = 25 + x / double(depth_max) * 82, py = 16 + y / double(lane_max) * 49; arrow(px, py, std::array{-16, -7, 7, 16}[size_t(values[0])], 0); dot(px, py); } diff --git a/src/modern/ui/demo_sports.hpp b/src/modern/ui/demo_sports.hpp index 70a916f..95e0492 100644 --- a/src/modern/ui/demo_sports.hpp +++ b/src/modern/ui/demo_sports.hpp @@ -12,5 +12,5 @@ Json demo_tactics(); bool valid_demo_tactics(const Json &); std::string edit_demo_tactics(Json &, const Json &action); std::string tactics_diagram(const Json &, const std::string &theme, - const Json &lineup_points = Json()); + const Json &lineup_points = Json(), int depth_max = 18, int lane_max = 8); } // namespace bmh::modern_ui diff --git a/src/modern/ui/engine_bridge.cpp b/src/modern/ui/engine_bridge.cpp index 2016ce6..3b7d547 100644 --- a/src/modern/ui/engine_bridge.cpp +++ b/src/modern/ui/engine_bridge.cpp @@ -30,7 +30,7 @@ std::shared_ptr EngineBridge::open(const fs::path &world, const fs } Json EngineBridge::snapshot() const { Json bundle = Json::object(); - for (const auto *kind : {"session", "desktop", "camps", "squad", "lineup"}) + for (const auto *kind : {"session", "desktop", "camps", "squad", "lineup", "tactics", "training"}) bundle[kind] = from_engine(impl_->session->ui_read(cli::Json::Object{{"kind", kind}}, impl_->revision)); validate_engine_desk(bundle); return bundle; diff --git a/src/modern/ui/engine_bridge.hpp b/src/modern/ui/engine_bridge.hpp index b783cfa..f634a13 100644 --- a/src/modern/ui/engine_bridge.hpp +++ b/src/modern/ui/engine_bridge.hpp @@ -13,6 +13,12 @@ Json engine_camp_command(const Json &bundle, const std::string &camp, Json engine_lineup_projection(const Json &bundle); Json engine_lineup_command(const Json &bundle, const Json &order, const std::string &request_id); +Json engine_tactics_projection(const Json &bundle); +Json engine_training_projection(const Json &bundle); +Json engine_tactics_command(const Json &bundle, const Json &values, + const std::string &request_id); +Json engine_training_command(const Json &bundle, const Json &draft, + const std::string &request_id); // Single-session facade. Its owner serializes all calls on a background worker. // No RmlUI objects or callbacks cross this boundary. diff --git a/src/modern/ui/engine_controls.inc b/src/modern/ui/engine_controls.inc index cd309cd..caab7d0 100644 --- a/src/modern/ui/engine_controls.inc +++ b/src/modern/ui/engine_controls.inc @@ -17,16 +17,15 @@ void App::engine_poll() { 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_ = true; - const auto changed = engine_response_.value("changedReadKinds", Json::array()); - const bool lineup_changed = std::find(changed.begin(), changed.end(), Json("lineup")) != changed.end(); - engine_notice_ = lineup_changed ? "Aufstellung übernommen · Änderungen noch nicht gespeichert." : "Trainingslager gebucht · Änderungen noch nicht gespeichert."; + 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_; engine_notice_ = "Änderung abgewiesen: " + engine_response_.value("code", "unknown_error"); } 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."; + 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()) @@ -37,7 +36,9 @@ void App::engine_poll() { void App::engine_frame() { engine_poll(); if (needs_render_) engine_render(); + engine_sports_update(); render_popup(); 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_); lineup_roster_scroll_.reset(); @@ -71,6 +72,7 @@ void App::engine_event(Rml::Event &event) { const auto type = event.GetType(); auto *target = event.GetTargetElement(); if (type == "keydown") keyboard_navigation_ = true; if (type == "mousedown") keyboard_navigation_ = false; + if (engine_sports_event(event)) return; Rml::ElementFormControl *range = nullptr; for (auto *node = target; node && node != doc_; node = node->GetParentNode()) if (node->GetId().starts_with("camp-focus-") && !node->HasAttribute("disabled")) { @@ -96,7 +98,7 @@ void App::engine_event(Rml::Event &event) { if (type == "keydown" && event.GetParameter("key_identifier", 0) == Rml::Input::KI_ESCAPE) { if (!popup_.empty()) { popup_.clear(); confirm_ = {}; 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_.empty()) { menu_.clear(); refresh(); } + else if (!engine_busy_ && !menu_.empty()) { if (menu_ == "training" || menu_ == "tactics") engine_sports_reset(); menu_.clear(); refresh(); } else engine_quit(); event.StopImmediatePropagation(); return; } @@ -132,9 +134,11 @@ void App::engine_event(Rml::Event &event) { if (action == "popup-confirm") { auto callback = std::move(confirm_); popup_.clear(); dirty_ = true; if (callback) callback(); } return; } + if (engine_sports_action(action, id, node)) return; if (engine_lineup_action(action, id, node)) return; if (action == "close") { menu_.clear(); refresh(); } else if (action == "engine-open" && id == "save") engine_save(); + else if (action == "engine-open" && (id == "training" || id == "tactics")) { engine_sports_reset(); menu_ = id; refresh(); } else if (action == "engine-open" && id == "lineup") { menu_ = "lineup"; lineup_selected_.clear(); lineup_reset_scroll_ = true; refresh(); } else if (action == "engine-open" && id == "camp") { menu_ = "camp"; refresh(); } else if (action == "camp-region") { selections_["camp-region"] = id; refresh(); } @@ -153,5 +157,5 @@ 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_}, {"player_profile", engine_player_}, {"lineup_selected", lineup_selected_}, {"focus", engine_focus_}, {"selected_camp", engine_camp_}, {"notice", engine_notice_}}; + {"response", engine_response_}, {"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_dto.cpp b/src/modern/ui/engine_dto.cpp index 6c60c26..c2d2496 100644 --- a/src/modern/ui/engine_dto.cpp +++ b/src/modern/ui/engine_dto.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only #include "modern/ui/engine_bridge.hpp" #include +#include #include #include @@ -168,4 +169,112 @@ Json engine_lineup_command(const Json &bundle, const Json &order, const std::str {"expectedRevision", meta.at("stateRevision")}, {"owner", {{"managerId", meta.at("scope").at("managerId")}}}, {"kind", "lineup.commit"}, {"payload", {{"order", order}}}}; } + +namespace { +Json sports_command(const Json &bundle, const char *kind, const Json &payload, const std::string &id) { + validate_engine_desk(bundle); + const auto &meta = bundle.at("desktop").at("meta"); + const auto commands = meta.at("scope").value("allowedCommands", Json::array()); + require(!id.empty() && commands.is_array() && std::find(commands.begin(), commands.end(), Json(kind)) != commands.end(), + "Diese Änderung ist im aktuellen Kontext nicht verfügbar."); + return {{"messageType", "command"}, {"requestId", id}, {"careerId", meta.at("careerId")}, + {"expectedRevision", meta.at("stateRevision")}, {"owner", {{"managerId", meta.at("scope").at("managerId")}}}, + {"kind", kind}, {"payload", payload}}; +} +int whole_in_range(const Json &v, int lo, int hi) { + require(v.is_number_integer() && v.get() >= lo && v.get() <= hi, + "Wert außerhalb des verfügbaren Bereichs."); + return v.get(); +} +} +Json engine_tactics_projection(const Json &bundle) { + validate_engine_desk(bundle); + const auto &data = lineup_read(bundle, "tactics"); + require(data.at("teamId") == bundle.at("desktop").at("meta").at("scope").at("teamId"), "Taktik gehört einer anderen Mannschaft."); + require(data.at("controls").is_array() && data.at("controls").size() == 8, "Unvollständige Taktikeinstellungen."); + Json out = {{"values", Json::array()}, {"limits", Json::array()}, {"minima", Json::array()}, {"labels", Json::array()}}; + // These bounds describe the existing board's visual capacity, not engine rules. + const std::array visual_limits{3,3,3,3,1,1,1,11}; + for (int i = 0; i < 8; ++i) { + const Json *control = nullptr; + for (const auto &item : data.at("controls")) if (item.at("id") == "tactic:" + std::to_string(i)) { + require(!control, "Doppelte Taktik-ID."); control = &item; + } + require(control, "Taktikeinstellung fehlt."); + const auto &range = control->at("range"); + const int lo = whole_in_range(range.at("min"), 0, visual_limits[size_t(i)]); + const int hi = whole_in_range(range.at("max"), lo, visual_limits[size_t(i)]); + require(range.at("step") == 1, "Diese Taktikschrittweite wird noch nicht dargestellt."); + out["values"].push_back(whole_in_range(control->at("value"), lo, hi)); + out["limits"].push_back(hi); out["minima"].push_back(lo); + out["labels"].push_back(control->at("label").at("text")); + } + const auto board = engine_lineup_projection(bundle).at("board"); + require(board.at("points").size() == 11, "Die Taktiktafel benötigt gelieferte Spielfeldpositionen."); + std::set occupied; + for (const auto &point : board.at("points")) require(point.is_array() && occupied.insert(point.dump()).second, "Spielfeldpositionen sind nicht vollständig bekannt."); + out["board"] = board; + return out; +} +Json engine_tactics_command(const Json &bundle, const Json &values, const std::string &id) { + const auto base = engine_tactics_projection(bundle); + require(values.is_array() && values.size() == 8, "Acht Taktikwerte werden benötigt."); + for (size_t i = 0; i < 8; ++i) (void)whole_in_range(values[i], base.at("minima")[i], base.at("limits")[i]); + return sports_command(bundle, "tactics.commit", {{"values", values}}, id); +} +Json engine_training_projection(const Json &bundle) { + validate_engine_desk(bundle); + const auto &data = lineup_read(bundle, "training"), &squad = lineup_read(bundle, "squad"); + const auto &team = bundle.at("desktop").at("meta").at("scope").at("teamId"); + require(data.at("teamId") == team && squad.at("team").at("id") == team, "Training gehört einer anderen Mannschaft."); + Json out = {{"club", team}, {"types", Json::array()}, {"areas", Json::array()}, {"players", Json::object()}, + {"roster", Json::array()}, {"initialized", data.at("initialized")}, {"limits", data.at("limits")}}; + const auto group = [&](const char *name, const std::vector &ids) { + require(data.at(name).is_array() && data.at(name).size() == ids.size(), "Unvollständiger Trainingsplan."); + for (const auto &id : ids) { + const Json *chosen = nullptr; + for (const auto &item : data.at(name)) if (item.at("id") == id) { require(!chosen, "Doppelte Trainings-ID."); chosen = &item; } + require(chosen && chosen->at("min") == 1 && chosen->at("max") == 3, "Trainingsgruppe wird nicht unterstützt."); + out[name].push_back(whole_in_range(chosen->at("allocation"), 1, 3)); + } + }; + group("types", {"training:type/goalkeepers", "training:type/defence", "training:type/midfield", "training:type/attack"}); + group("areas", {"training:area/fitness", "training:area/skill", "training:area/corner", "training:area/free_kick", "training:area/tackling", "training:area/pass", "training:area/shot", "training:area/speed", "training:area/game"}); + std::map people; + for (const auto &row : squad.at("players")) require(people.emplace(row.at("player").at("id").get(), row).second, "Doppelter Kaderspieler."); + for (const auto &row : data.at("players")) { + const auto id = row.at("playerId").get(); + require(people.contains(id) && !out.at("players").contains(id), "Fremder oder doppelter Trainingsspieler."); + const auto &person = people.at(id); + out["players"][id] = {{"intensity", whole_in_range(row.at("intensity"), 0, 3)}, {"focus", whole_in_range(row.at("focus"), 0, 7)}}; + out["roster"].push_back({{"id", id}, {"name", person.at("player").at("name")}, {"positions", person.at("player").at("positions")}, + {"attributes", {{"strength", metric_value(person, "strength")}}}}); + } + require(out.at("players").size() == people.size(), "Trainingskader ist unvollständig."); + const int automation = whole_in_range(data.at("automation"), 0, 255); + // Reflect the original screen's four stored subordinate flags. This client + // never writes the automation byte; only the engine changes it on commit. + out["autos"] = Json::array({bool(automation & 2), bool(automation & 4), bool(automation & 8), bool(automation & 16)}); + out["master_auto"] = bool(automation & 1); + return out; +} +Json engine_training_command(const Json &bundle, const Json &draft, const std::string &id) { + const auto base = engine_training_projection(bundle); + for (const auto *group : {"types", "areas"}) { + require(draft.at(group).is_array() && draft.at(group).size() == base.at(group).size(), "Trainingsplan ist unvollständig."); + for (const auto &n : draft.at(group)) (void)whole_in_range(n, 1, 3); + } + int types = 0, fitness = 0, areas = 0; + for (const auto &v : draft.at("types")) types += v.get(); + for (size_t i = 0; i < 9; ++i) (i < 2 ? fitness : areas) += draft.at("areas")[i].get(); + require(types <= base.at("limits").at("types").get() && fitness <= base.at("limits").at("fitnessAndSkill").get() && areas <= base.at("limits").at("otherAreas").get(), "Ballbudget überschritten."); + require(draft.at("players").is_object() && draft.at("players").size() == base.at("players").size(), "Trainingskader ist unvollständig."); + Json changed = Json::array(); + for (const auto &[pid, row] : draft.at("players").items()) { + require(base.at("players").contains(pid) && row.at("focus") == base.at("players").at(pid).at("focus"), "Spielerschwerpunkte sind noch schreibgeschützt."); + if (row.at("intensity") != base.at("players").at(pid).at("intensity")) + changed.push_back({{"playerId", pid}, {"intensity", whole_in_range(row.at("intensity"), 1, 3)}}); + } + return sports_command(bundle, "training.commit", {{"types", draft.at("types")}, {"areas", draft.at("areas")}, {"players", changed}}, id); +} } // namespace bmh::modern_ui diff --git a/src/modern/ui/engine_screens.inc b/src/modern/ui/engine_screens.inc index 4607101..d1571cb 100644 --- a/src/modern/ui/engine_screens.inc +++ b/src/modern/ui/engine_screens.inc @@ -56,6 +56,9 @@ void App::engine_render() { esc(engine_price(desk.at("accounts").at("cash"))) + ""; bool lineup_available = false; try { (void)engine_lineup_projection(engine_data_); lineup_available = true; } catch (const std::exception &) {} + bool training_available = false, tactics_available = false; + try { (void)engine_training_projection(engine_data_); training_available = true; } catch (const std::exception &) {} + try { (void)engine_tactics_projection(engine_data_); tactics_available = true; } catch (const std::exception &) {} init_desktop(); for (const auto &[id, o] : desktop_.at("objects").items()) { if (!o.value("visible", false)) continue; @@ -88,16 +91,19 @@ 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 == "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 == "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()); out += desktop_button(id, o, "engine-open", supported && !engine_busy_); } } out += ""; + if (menu_ == "training") out += "
" + window("Training", render_training()) + "
"; + if (menu_ == "tactics") out += "
" + window("Taktik", render_tactics()) + "
"; if (menu_ == "lineup") out += "
" + window("Aufstellung", render_lineup()) + "
"; if (menu_ == "camp") out += "
" + window("Trainingslager", render_camp()) + "
"; } if (menu_.empty() || engine_data_.empty()) out += "
" + esc(engine_busy_ ? engine_operation_ : engine_notice_) + "
"; element("canvas")->SetInnerRML(out); ++document_generation_; + scale_chalk_shadow(); if (!engine_player_.empty()) { Rml::ElementList underlay; doc_->QuerySelectorAll(underlay, "#lineup-underlay button,#window-close"); for (auto *node : underlay) { node->SetAttribute("disabled", true); node->SetProperty("pointer-events", "none"); } diff --git a/src/modern/ui/engine_sports.inc b/src/modern/ui/engine_sports.inc new file mode 100644 index 0000000..2919914 --- /dev/null +++ b/src/modern/ui/engine_sports.inc @@ -0,0 +1,107 @@ +// SPDX-License-Identifier: GPL-3.0-only +void App::engine_sports_reset() { + try { engine_training_draft_ = engine_training_projection(engine_data_); } catch (const std::exception &) { engine_training_draft_ = Json(); } + try { engine_tactics_draft_ = engine_tactics_projection(engine_data_); } catch (const std::exception &) { engine_tactics_draft_ = Json(); } +} +bool App::engine_sports_dirty() const { + if (menu_ == "training") return !engine_training_draft_.is_null() && + (!engine_training_draft_.at("initialized").get() || engine_training_draft_ != engine_training_projection(engine_data_)); + if (menu_ == "tactics") return !engine_tactics_draft_.is_null() && + engine_tactics_draft_.at("values") != engine_tactics_projection(engine_data_).at("values"); + return false; +} +std::string App::engine_sports_footer() { + const bool training = menu_ == "training"; + return "

" + "
" + + btn("sports-reset", "Zurücksetzen", "", "id=\"sports-reset\" style=\"width:440dp;height:94dp;\"") + + btn("sports-apply", "Anwenden", "primary", "id=\"sports-apply\" style=\"width:440dp;height:94dp;\"") + "
"; +} +void App::engine_sports_update() { + if (menu_ != "training" && menu_ != "tactics") return; + bool changed = false, valid = false; std::string note; + try { + changed = engine_sports_dirty(); + if (menu_ == "training") (void)engine_training_command(engine_data_, engine_training_draft_, "request:validate-only"); + else (void)engine_tactics_command(engine_data_, engine_tactics_draft_.at("values"), "request:validate-only"); + valid = true; + note = changed ? "Entwurf · Änderungen werden erst mit Anwenden übernommen." : engine_notice_; + if (menu_ == "training" && !engine_training_draft_.at("initialized").get()) note = "Mit Anwenden wird das Training erstmals eingerichtet."; + } catch (const std::exception &e) { note = e.what(); } + if (auto *button = element("sports-apply")) { + if (valid && changed && engine_fresh_ && !engine_busy_) button->RemoveAttribute("disabled"); + else button->SetAttribute("disabled", true); + } + if (auto *button = element("sports-reset")) { + if (changed && !engine_busy_) button->RemoveAttribute("disabled"); + else button->SetAttribute("disabled", true); + } + if (auto *text = element("sports-note")) { + const auto value = esc(engine_busy_ ? engine_operation_ : note); + if (text->GetInnerRML() != value) text->SetInnerRML(value); + text->SetProperty("color", valid ? "var(--muted)" : "var(--danger)"); + } +} +bool App::engine_sports_action(const std::string &action, const std::string &id, Rml::Element *target) { + if (menu_ != "training" && menu_ != "tactics") return false; + if (action == "close") { engine_sports_reset(); menu_.clear(); refresh(); return true; } + if (action == "sports-reset") { engine_sports_reset(); focus_after_render_ = "sports-reset"; refresh(); return true; } + if (action == "sports-apply" && engine_fresh_ && engine_sports_dirty()) { + const auto command = menu_ == "training" + ? engine_training_command(engine_data_, engine_training_draft_, editor::new_id("request:ui-")) + : engine_tactics_command(engine_data_, engine_tactics_draft_.at("values"), editor::new_id("request:ui-")); + confirmation(menu_ == "training" ? "Diesen Trainingsplan übernehmen?" : "Diese Taktikeinstellungen übernehmen?", [this, command] { + auto link = engine_link_; + engine_start("Änderungen werden übernommen …", [link, command] { + auto response = link->command(command); return EngineReply{link, link->snapshot(), response, nullptr}; + }, true); + }); + return true; + } + if (action == "tactic-cycle" && menu_ == "tactics" && engine_fresh_) { + const int i = std::stoi(id); if (i < 0 || i > 6) return true; + const int lo = engine_tactics_draft_.at("minima")[size_t(i)], hi = engine_tactics_draft_.at("limits")[size_t(i)]; + auto &v = engine_tactics_draft_["values"][size_t(i)]; v = v.get() == hi ? lo : v.get() + 1; + last_tactic_ = i; focus_after_render_ = target->GetId(); refresh(); return true; + } + if (action == "training-ball" && menu_ == "training" && engine_fresh_) { + const auto group = target->GetAttribute("data-group", ""); + const int i = std::stoi(id), value = target->GetAttribute("data-value", 0); + if (value < 1 || value > 3) return true; + if ((group == "type" && i >= 0 && i < 4) || (group == "area" && i >= 0 && i < 9)) + engine_training_draft_[group == "type" ? "types" : "areas"][size_t(i)] = value; + else if (group == "player") { + const auto player = target->GetAttribute("data-player", ""); + if (engine_training_draft_.at("players").contains(player)) engine_training_draft_["players"][player]["intensity"] = value; + } + focus_after_render_ = target->GetId(); refresh(); return true; + } + return action.starts_with("training-") || action.starts_with("sports-"); +} +bool App::engine_sports_event(Rml::Event &event) { + if (menu_ != "tactics" || !popup_.empty() || engine_busy_) return false; + Rml::ElementFormControl *range = nullptr; + for (auto *node = event.GetTargetElement(); node && node != doc_; node = node->GetParentNode()) + if (node->GetId() == "tactic-effort") { range = dynamic_cast(node); break; } + if (!range) return false; + const auto type = event.GetType(); + int value = std::stoi(range->GetValue()); bool change = type == "input" || type == "change"; + if (type == "mouseup") { focus_after_render_ = "tactic-effort"; dirty_ = true; } + if (type == "keydown") { + const auto key = Rml::Input::KeyIdentifier(event.GetParameter("key_identifier", 0)); + const int lo = engine_tactics_draft_.at("minima")[7], hi = engine_tactics_draft_.at("limits")[7]; + if (key == Rml::Input::KI_HOME) value = lo; + else if (key == Rml::Input::KI_END) value = hi; + else if (key == Rml::Input::KI_LEFT || key == Rml::Input::KI_DOWN) value = std::max(lo, value - 1); + else if (key == Rml::Input::KI_RIGHT || key == Rml::Input::KI_UP) value = std::min(hi, value + 1); + else return false; + event.StopImmediatePropagation(); range->SetValue(std::to_string(value)); change = true; + } + if (!change) return false; + engine_tactics_draft_["values"][7] = value; last_tactic_ = 7; + element("tactic-effort-value")->SetInnerRML(std::string(size_t(value), '!')); + element("tactic-hint")->SetInnerRML(esc(engine_tactics_draft_.at("labels")[7].get() + ": " + std::to_string(value) + " / " + std::to_string(engine_tactics_draft_.at("limits")[7].get()))); + engine_sports_update(); dirty_ = true; return true; +} diff --git a/src/modern/ui/engine_state.inc b/src/modern/ui/engine_state.inc index a32b547..4da5dd5 100644 --- a/src/modern/ui/engine_state.inc +++ b/src/modern/ui/engine_state.inc @@ -2,7 +2,7 @@ bool engine_mode_ = false, engine_busy_ = false, engine_dirty_ = false, engine_fresh_ = false, engine_base_dirty_ = false; std::shared_ptr engine_link_; std::future engine_job_; - Json engine_data_, engine_response_, engine_focus_; + Json engine_data_, engine_response_, engine_focus_, engine_training_draft_, engine_tactics_draft_; std::string engine_camp_, engine_operation_, engine_notice_, engine_player_; void engine_start(std::string, std::function, bool mutating = false); void engine_poll(); @@ -15,4 +15,10 @@ std::string engine_lineup_controls(); std::string engine_player_profile(const Json &); bool engine_lineup_action(const std::string &, const std::string &, Rml::Element *); + void engine_sports_reset(); + bool engine_sports_dirty() const; + void engine_sports_update(); + std::string engine_sports_footer(); + bool engine_sports_action(const std::string &, const std::string &, Rml::Element *); + bool engine_sports_event(Rml::Event &); Json engine_snapshot() const; diff --git a/src/modern/ui/sports_screens.inc b/src/modern/ui/sports_screens.inc index 70ee5b4..76047f8 100644 --- a/src/modern/ui/sports_screens.inc +++ b/src/modern/ui/sports_screens.inc @@ -1,4 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only +namespace { +std::string sports_number(const Json &v) { return v.is_number_integer() ? number(v.get()) : "—"; } +} std::string App::training_balls(const std::string &group, int index, int value, bool automatic, const std::string &player, int size, int gap, bool overtraining) { @@ -20,8 +23,8 @@ std::string App::training_balls(const std::string &group, int index, int value, return body + ""; } std::string App::render_training() { - const auto s = snap(); - const auto &t = s.state.at("training"), &automatic = t.at("autos"); + const auto t = engine_mode_ ? engine_training_draft_ : snap().state.at("training"); + const auto &automatic = t.at("autos"); const std::array skills = { "Kondition", "Technik", "Eckball", "Freistoß", "Zweikampf", "Pass", "Schuss", "Schnelligkeit", "Teamplay"}; @@ -43,8 +46,8 @@ std::string App::render_training() { ":
" + training_balls("area", int(i), t["areas"][i].get(), - automatic[i < 2 ? 1 : 2].get(), {}, 56, 10, - i >= 2 && skill_total > 14) + + !engine_mode_ && automatic[i < 2 ? 1 : 2].get(), {}, 56, 10, + !engine_mode_ && i >= 2 && skill_total > 14) + "
"; body += "
"; for (int i = 0; i < 10; ++i) @@ -59,7 +62,7 @@ std::string App::render_training() { std::to_string(30 + (i % 2) * 277) + "dp;top:" + std::to_string(26 + (i / 2) * 176) + "dp;\">" + training_balls("type", i, t["types"][size_t(i)].get(), - automatic[0].get(), {}, 48, 5) + + !engine_mode_ && automatic[0].get(), {}, 48, 5) + "
"; body += ""; const std::array auto_names = { @@ -78,19 +81,19 @@ std::string App::render_training() { (automatic[i].get() ? "primary" : ""), "id=\"training-auto-" + std::to_string(i) + "\" data-id=\"" + std::to_string(i) + "\" style=\"position:absolute;" + - rect(a[0], a[1], a[2], a[3]) + "\""); + rect(a[0], a[1], a[2], a[3]) + "\" " + (engine_mode_ ? "disabled" : "")); } - const bool all_auto = std::all_of(automatic.begin(), automatic.end(), + const bool all_auto = engine_mode_ ? t.at("master_auto").get() : std::all_of(automatic.begin(), automatic.end(), [](const auto &v) { return v == true; }); body += btn("training-auto-all", "Automatisch", std::string("training-auto ") + (all_auto ? "primary" : ""), "id=\"training-auto-all\" style=\"position:absolute;" + - rect(604, 1232, 440, 76) + "\""); + rect(604, 1232, 440, 76) + "\" " + (engine_mode_ ? "disabled" : "")); body += "

Arten: " + std::to_string(type_total) + - " / 8 Bälle ·
Kondition/Technik: " + + " / " + std::to_string(engine_mode_ ? t.at("limits").at("types").get() : 8) + " Bälle ·
Kondition/Technik: " + std::to_string(t["areas"][0].get() + t["areas"][1].get()) + - " / 4 ·
Fertigkeiten: " + std::to_string(skill_total) + " / 18" + - (skill_total > 14 ? " · hohe
Belastung" : "") + + " / " + std::to_string(engine_mode_ ? t.at("limits").at("fitnessAndSkill").get() : 4) + " ·
Fertigkeiten: " + std::to_string(skill_total) + " / " + std::to_string(engine_mode_ ? t.at("limits").at("otherAreas").get() : 18) + + (!engine_mode_ && skill_total > 14 ? " · hohe
Belastung" : "") + "

"; @@ -102,7 +105,9 @@ std::string App::render_training() { "\" style=\"width:" + std::to_string(widths[i]) + "dp;\">" + headings[i] + "
"; body += "
"; - const auto players = world_->squad(t.value("club", "")); + std::vector players; + if (engine_mode_) { for (const auto &p : t.at("roster")) players.push_back(&p); } + else players = world_->squad(t.value("club", "")); for (size_t i = 0; i < players.size(); ++i) { const auto *p = players[i]; const auto id = p->value("id", ""); @@ -121,30 +126,29 @@ std::string App::render_training() { "class=\"training-name-text\" title=\"" + esc(world_->name(*p)) + "\">" + esc(world_->name(*p)) + "
" + - std::to_string( - p->value("attributes", Json::object()).value("strength", 0)) + + sports_number(p->value("attributes", Json::object()).value("strength", Json())) + "
"; auto selector = select("training-focus-" + std::to_string(i), focuses, std::to_string(row.value("focus", 0)), "training-focus"); const auto end = selector.find('>'); selector.insert(end, " data-player=\"" + esc(id) + "\" " + - (automatic[3] == true ? "disabled" : "")); + (engine_mode_ || automatic[3] == true ? "disabled" : "")); body += selector + "
" + training_balls("player", int(i), row.value("intensity", 0), - automatic[3].get(), id, 50, 9) + + !engine_mode_ && automatic[3].get(), id, 50, 9) + "
"; } - return body + ""; + return body + "" + (engine_mode_ ? engine_sports_footer() : ""); } std::string App::render_tactics() { - const auto t = snap().state.at("tactics"); - const std::array names = { + const auto t = engine_mode_ ? engine_tactics_draft_ : snap().state.at("tactics"); + const std::array names = engine_mode_ ? t.at("labels").get>() : std::array{ "Defensiv / offensiv", "Pass-/Schussbild unten", "Pass-/Schussbild Mitte", "Pass-/Schussbild links", "Flache / hohe Bälle", "Flügelbild links", "Flügelbild rechts", "Einsatz"}; - const std::array limits = {3, 3, 3, 3, 1, 1, 1, 11}; + const std::array limits = engine_mode_ ? t.at("limits").get>() : std::array{3, 3, 3, 3, 1, 1, 1, 11}; const std::array, 7> areas = {{{19, 9, 104, 62}, {61, 108, 50, 34}, {63, 84, 54, 30}, @@ -154,7 +158,7 @@ std::string App::render_tactics() { {205, 10, 58, 37}}}; std::string body = "
" + - picture(renderer_.diagram("tactics", tactics_diagram(t, theme_, snap().state.value("lineup", Json::object()).value("points", Json()))), 2300, + picture(renderer_.diagram("tactics", tactics_diagram(t, theme_, engine_mode_ ? t.at("board").at("points") : snap().state.value("lineup", Json::object()).value("points", Json()), engine_mode_ ? t.at("board").at("depth_max").get() : 18, engine_mode_ ? t.at("board").at("lane_max").get() : 8)), 2300, 1864); for (size_t i = 0; i < 7; ++i) { const auto a = areas[i]; @@ -173,11 +177,11 @@ std::string App::render_tactics() { "id=\"tactic-effort-value\" class=\"tactic-effort-marks\">" + std::string(size_t(effort), '!') + "
() : 0) + "\" max=\"" + std::to_string(limits[7]) + "\" step=\"1\" value=\"" + std::to_string(effort) + "\"/>

" + esc(names[size_t(last_tactic_)]) + ": " + std::to_string(t["values"][size_t(last_tactic_)].get()) + " / " + std::to_string(limits[size_t(last_tactic_)]) + "

"; - return body; + return body + (engine_mode_ ? engine_sports_footer() : ""); } diff --git a/src/modern/ui/view.cpp b/src/modern/ui/view.cpp index 2f6e6c9..b6e8a6c 100644 --- a/src/modern/ui/view.cpp +++ b/src/modern/ui/view.cpp @@ -1514,6 +1514,7 @@ public: #include "modern/ui/engine_screens.inc" #include "modern/ui/engine_controls.inc" #include "modern/ui/engine_lineup.inc" +#include "modern/ui/engine_sports.inc" } // namespace bool is_modern_world(const fs::path &file) { try { diff --git a/tests/modern_engine_bridge_probe.cpp b/tests/modern_engine_bridge_probe.cpp index 6eccf4e..bf82796 100644 --- a/tests/modern_engine_bridge_probe.cpp +++ b/tests/modern_engine_bridge_probe.cpp @@ -8,7 +8,7 @@ using namespace bmh; using namespace bmh::modern_ui; int main(int argc, char **argv) { try { - if (argc != 4 || (std::string(argv[1]) != "prepare" && std::string(argv[1]) != "verify" && std::string(argv[1]) != "verify-lineup")) throw std::runtime_error("usage: modern_engine_bridge_probe prepare|verify|verify-lineup "); + if (argc != 4 || (std::string(argv[1]) != "prepare" && std::string(argv[1]) != "verify" && std::string(argv[1]) != "verify-lineup" && std::string(argv[1]) != "verify-sports")) throw std::runtime_error("usage: modern_engine_bridge_probe prepare|verify|verify-lineup|verify-sports "); 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)); }; if (std::string(argv[1]) == "prepare") { @@ -57,6 +57,29 @@ int main(int argc, char **argv) { link = EngineBridge::open(world, out / "lineup.obs"); const auto loaded = link->snapshot(); write("lineup-loaded.json", loaded); if (loaded.at("lineup").at("data").at("order") != order) throw std::runtime_error("lineup lost during OBS round trip"); } + if (std::string(argv[1]) == "verify-sports") { + auto tactics = engine_tactics_projection(before); tactics["values"][0] = 1; tactics["values"][7] = 7; + const auto tc = engine_tactics_command(before, tactics.at("values"), "request:sports-tactics"); + const auto tr = link->command(tc); write("tactics-command.json", tc); write("tactics-response.json", tr); + if (tr.value("messageType", "") != "command_result" || link->command(tc) != tr) throw std::runtime_error(tr.dump()); + const auto tactic_after = link->snapshot(); write("tactics-after.json", tactic_after); + if (engine_tactics_projection(tactic_after).at("values") != tactics.at("values")) throw std::runtime_error("tactics not applied"); + auto training = engine_training_projection(tactic_after); + training["types"] = Json::array({1,3,2,2}); training["areas"] = Json::array({1,3,3,1,2,2,2,2,2}); + const auto player = training.at("roster")[0].at("id").get(); training["players"][player]["intensity"] = 3; + const auto pc = engine_training_command(tactic_after, training, "request:sports-training"); + const auto pr = link->command(pc); write("training-command.json", pc); write("training-response.json", pr); + if (pr.value("messageType", "") != "command_result" || link->command(pc) != pr) throw std::runtime_error(pr.dump()); + const auto after = link->snapshot(); write("sports-after.json", after); const auto actual = engine_training_projection(after); + if (actual.at("types") != training.at("types") || actual.at("areas") != training.at("areas") || actual.at("players").at(player).at("intensity") != 3 || !actual.at("initialized").get()) throw std::runtime_error("training not applied"); + if (after.at("desktop").at("data").at("accounts") != before.at("desktop").at("data").at("accounts")) throw std::runtime_error("sports changed account"); + auto stale = pc; stale["requestId"] = "request:stale-sports"; + const auto rejected = link->command(stale); write("sports-rejected.json", rejected); + if (rejected.value("code", "") != "stale_revision" || link->snapshot() != after) throw std::runtime_error("stale sports request changed state"); + write("sports-saved.json", link->save_copy(out / "sports.obs")); link.reset(); + link = EngineBridge::open(world, out / "sports.obs"); const auto loaded = link->snapshot(); write("sports-loaded.json", loaded); + if (engine_tactics_projection(loaded).at("values") != tactics.at("values") || engine_training_projection(loaded).at("types") != training.at("types") || engine_training_projection(loaded).at("areas") != training.at("areas")) throw std::runtime_error("sports lost in OBS round trip"); + } std::cout << "engine bridge " << argv[1] << " passed\n"; return 0; } catch (const std::exception &e) { std::cerr << e.what() << '\n'; return 1; } } diff --git a/tests/modern_engine_dto_tests.cpp b/tests/modern_engine_dto_tests.cpp index d936d43..8824a54 100644 --- a/tests/modern_engine_dto_tests.cpp +++ b/tests/modern_engine_dto_tests.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only #include "modern/ui/engine_bridge.hpp" #include +#include #include #include using namespace bmh::modern_ui; @@ -98,6 +99,37 @@ int main() { require(engine_lineup_projection(hidden_metric).at("rows")[0].at("strength").is_null(), "unavailable metric exposed its stale numeric value"); auto unknown_point = squad_bundle; unknown_point["lineup"]["data"]["positions"][0]["depth"] = -1; require(engine_lineup_projection(unknown_point).at("board").at("points")[0].is_null(), "unknown pitch position was fabricated"); + auto sports = squad_bundle; + for (auto &item : sports) { item["meta"]["scope"]["allowedCommands"].push_back("training.commit"); item["meta"]["scope"]["allowedCommands"].push_back("tactics.commit"); } + const auto sports_meta = sports.at("desktop").at("meta"); + // Eleven real identifiers/positions are required by the existing tactical board. + auto &sl = sports["lineup"]["data"]; auto &sp = sports["squad"]["data"]["players"]; + for (int i = 4; i < 11; ++i) { auto p = sp[0]; p["player"]["id"] = "player:" + std::to_string(i); sp.push_back(p); sl["order"].push_back(p["player"]["id"]); sl["rows"].push_back({{"playerId",p["player"]["id"]},{"role","starter"}}); } + sl["positions"] = Json::array(); + for (int i = 0; i < 11; ++i) sl["positions"].push_back({{"playerId","player:"+std::to_string(i)},{"depth",i},{"lane",i%9}}); + Json controls = Json::array(); const std::array ranges{3,3,3,3,1,1,1,11}; + for (int i = 0; i < 8; ++i) controls.push_back({{"id","tactic:"+std::to_string(i)},{"label",{{"text","Backend label "+std::to_string(i)}}},{"value",0},{"range",{{"min",0},{"max",ranges[size_t(i)]},{"step",1}}}}); + sports["tactics"] = {{"messageType","snapshot"},{"meta",sports_meta},{"data",{{"kind","tactics"},{"teamId","club:6"},{"controls",controls}}}}; + Json types = Json::array(), areas = Json::array(), training_players = Json::array(); + for (const auto &name : {"goalkeepers","defence","midfield","attack"}) types.push_back({{"id",std::string("training:type/")+name},{"allocation",2},{"min",1},{"max",3}}); + for (const auto &name : {"fitness","skill","corner","free_kick","tackling","pass","shot","speed","game"}) areas.push_back({{"id",std::string("training:area/")+name},{"allocation",2},{"min",1},{"max",3}}); + for (const auto &p : sports.at("squad").at("data").at("players")) training_players.push_back({{"playerId",p["player"]["id"]},{"focus",0},{"intensity",2}}); + sports["training"] = {{"messageType","snapshot"},{"meta",sports_meta},{"data",{{"kind","training"},{"teamId","club:6"},{"types",types},{"areas",areas},{"players",training_players},{"limits",{{"types",8},{"fitnessAndSkill",4},{"otherAreas",18}}},{"initialized",false},{"automation",0}}}}; + const auto sports_original = sports; + auto tactics = engine_tactics_projection(sports); + require(tactics.at("labels")[3] == "Backend label 3" && tactics.at("values")[0] == 0, "tactics invented labels or discarded known zero"); + tactics["values"][7] = 11; + require(engine_tactics_command(sports,tactics.at("values"),"request:t").at("payload").at("values")[7] == 11,"tactics payload wrong"); + tactics["values"][7] = 12; rejects([&] { engine_tactics_command(sports,tactics.at("values"),"request:t"); }); + auto training = engine_training_projection(sports); + require(training.at("roster").size() == 11 && training.at("roster")[0].at("attributes").at("strength") == 91,"training used catalogue values or a guessed roster"); + training["types"][0] = 1; training["players"]["player:0"]["intensity"] = 3; + auto training_cmd = engine_training_command(sports,training,"request:p"); + require(training_cmd.at("payload").at("players").size() == 1 && training_cmd.at("owner").at("managerId") == "manager:99" && sports == sports_original,"training query mutated source or payload lost identities"); + training["types"] = Json::array({3,3,3,3}); rejects([&] { engine_training_command(sports,training,"request:p"); }); + training = engine_training_projection(sports); training["players"]["player:0"]["focus"] = 1; rejects([&] { engine_training_command(sports,training,"request:p"); }); + training = engine_training_projection(sports); training["players"]["foreign"] = {{"focus",0},{"intensity",2}}; rejects([&] { engine_training_command(sports,training,"request:p"); }); + auto different = sports; different["training"]["meta"]["scope"]["managerId"] = "manager:1"; rejects([&] { engine_training_projection(different); }); 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; }