From 72e06aabdb97708be63c1c632dc53e0c31df4fcd Mon Sep 17 00:00:00 2001 From: Weyoune Date: Tue, 17 Nov 2026 16:58:34 +0100 Subject: [PATCH] Players wear shirt numbers the manager can change Every player keeps a number from 1 to 99, unique within his squad. The line-up shows it and changes it by a click; the tactics sketch and the match sheet wear it too. Engine: shirt_numbers.hpp, squad read player.shirtNumber, command lineup.setNumber; saved in state/modern.json. Co-Authored-By: Claude Fable 5.2 --- CMakeLists.txt | 3 ++ docs/DIFFERENCES.md | 1 + docs/new_engine/README.md | 1 + docs/new_engine/rueckennummern.md | 40 ++++++++++++++++ docs/new_engine/ui-anbindung.md | 1 + src/modern/app/modern_session.cpp | 19 ++++++++ src/modern/content/ui_contract.cpp | 6 ++- src/modern/content/world_save.cpp | 17 +++++++ src/modern/game/modern_state.hpp | 2 + src/modern/game/shirt_numbers.cpp | 62 ++++++++++++++++++++++++ src/modern/game/shirt_numbers.hpp | 28 +++++++++++ src/modern/ui/engine_assembly.inc | 15 ++++++ src/modern/ui/engine_bridge.hpp | 2 + src/modern/ui/engine_controls.inc | 19 +++++++- src/modern/ui/engine_dto.cpp | 3 ++ src/modern/ui/lineup_page.inc | 9 +++- src/modern/ui/live_screens.inc | 4 +- src/modern/ui/live_state.inc | 4 ++ src/modern/ui/tactics_page.inc | 2 +- tests/modern_shirt_number_tests.cpp | 74 +++++++++++++++++++++++++++++ 20 files changed, 304 insertions(+), 8 deletions(-) create mode 100644 docs/new_engine/rueckennummern.md create mode 100644 src/modern/game/shirt_numbers.cpp create mode 100644 src/modern/game/shirt_numbers.hpp create mode 100644 tests/modern_shirt_number_tests.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 7e8d798..6cbc574 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1239,6 +1239,9 @@ add_test(NAME modern_naming_tests COMMAND modern_naming_tests) add_executable(modern_marketing_tests tests/modern_marketing_tests.cpp) target_link_libraries(modern_marketing_tests PRIVATE bmh_season_modern) add_test(NAME modern_marketing_tests COMMAND modern_marketing_tests) +add_executable(modern_shirt_number_tests tests/modern_shirt_number_tests.cpp) +target_link_libraries(modern_shirt_number_tests PRIVATE bmh_season_modern) +add_test(NAME modern_shirt_number_tests COMMAND modern_shirt_number_tests) add_executable(modern_almanac_tests tests/modern_almanac_tests.cpp) target_link_libraries(modern_almanac_tests PRIVATE bmh_modern_content) add_test(NAME modern_almanac_tests COMMAND modern_almanac_tests) diff --git a/docs/DIFFERENCES.md b/docs/DIFFERENCES.md index 574c48b..769d98a 100644 --- a/docs/DIFFERENCES.md +++ b/docs/DIFFERENCES.md @@ -65,6 +65,7 @@ describe deliberate changes; they are not a list of every known compatibility li - [src/modern/ui/demo_calendar.cpp](../src/modern/ui/demo_calendar.cpp): the native season follows its saved start year (including leap days), rather than the HTML's fixed 2027/28. - [src/modern/ui/engine_achievements.cpp](../src/modern/ui/engine_achievements.cpp): shows recorded manager history between seasons without inventing future results. - [src/modern/ui/engine_balance.cpp](../src/modern/ui/engine_balance.cpp): viewing a balance is read-only and publishing a changed plan requires explicit confirmation. +- [src/modern/game/shirt_numbers.cpp](../src/modern/game/shirt_numbers.cpp): in Modern every player keeps a shirt number from 1 to 99, unique within his squad, which the manager of a club can change. - [src/ui/league_table.hpp](../src/ui/league_table.hpp): uses three points for a win in the supported rule profile. - [src/ui/pitch.cpp](../src/ui/pitch.cpp): supports owner-bound designated set-piece selection in the extended manager record. - [src/ui/save_load.cpp](../src/ui/save_load.cpp): focuses the host save filename on entry and selects an existing name for replacement. diff --git a/docs/new_engine/README.md b/docs/new_engine/README.md index 1c464f8..4a839ec 100644 --- a/docs/new_engine/README.md +++ b/docs/new_engine/README.md @@ -14,6 +14,7 @@ Grundlage ist der [Engine-Split](../ENGINE_SPLIT.md); die Oberfläche ist in | [Jahreshauptversammlung](hauptversammlung.md) | Abstimmung am Saisonende, interessierte Vereine, Vereinswechsel | | [Namensrecht](namensrecht.md) | Stadionname, Angebote der Sponsoren, monatliche Zahlung | | [Internationale Vermarktung](vermarktung.md) | Monatsbudget, Reichweite im Ausland, Einnahmen | +| [Rückennummern](rueckennummern.md) | Nummern 1–99 je Spieler, eindeutig im Kader, änderbar | | [Datenformat](datenformat.md) | **Formatänderungen für Engine und Editor** (F1–F8) | | [Agentenregeln](AGENTS.md) | Arbeitsregeln für diesen Bereich | diff --git a/docs/new_engine/rueckennummern.md b/docs/new_engine/rueckennummern.md new file mode 100644 index 0000000..19bdb55 --- /dev/null +++ b/docs/new_engine/rueckennummern.md @@ -0,0 +1,40 @@ +# Rückennummern · Modern-Engine + +Stand: 17. November 2026. Eine Modern-Regel; Classic zählt eine Mannschaft nach dem Platz auf +dem Brett von 1 bis 11. + +## Regel + +- Jeder Spieler behält eine Nummer von 1 bis 99 (`ModernState::shirt_numbers`, 0 = noch keine). +- In einem Kader wird jede Nummer einmal getragen (`modern::squad_shirt_numbers`): Wer eine + Nummer hat, behält sie, bei zwei Spielern mit derselben der in der Kaderreihe vordere. Alle + anderen erhalten die niedrigste freie Nummer. +- Nach jedem Anstoß werden die getragenen Nummern der Menschenvereine festgeschrieben + (`modern::fix_shirt_numbers`). Davor folgen Nummern ohne Festlegung der Kaderreihe. +- Der Manager kann einem Spieler seines Vereins eine Nummer geben + (`modern::set_shirt_number`). Trägt sie schon ein anderer, tauschen die beiden. +- Ein Neuzugang, dessen Nummer vergeben ist, erhält die niedrigste freie; wird seine Nummer + frei, trägt er sie wieder. +- Keine Zufallszahl. Auf das Spielgeschehen haben die Nummern keinen Einfluss. + +## Speichern + +`state/modern.json` erhält das optionale Feld `shirt_numbers`: Paare `[Spieler, Nummer]` nur +für Spieler mit Nummer. + +## Anbindung + +Read `squad`: `player.shirtNumber` (bisher immer `null`). Befehl +`lineup.setNumber {playerId, number}` (Fehler `no_club`, `unknown_player`, `invalid_number`). + +## Prüfung + +`modern_shirt_number_tests` (ohne Spieldaten): 1 bis 20 in Kaderreihe, freie und getragene +Nummer, Tausch, Eindeutigkeit, Grenzen, Nummern bleiben beim Umstellen, Neuzugang mit +vergebener Nummer. + +## Offen + +- Computervereine zählen weiter nach der Kaderreihe; ihre Nummern werden nicht festgeschrieben. +- Der Almanach zeichnet keine Rückennummern auf. +- Die Nationalmannschaft hat keine eigenen Nummern. diff --git a/docs/new_engine/ui-anbindung.md b/docs/new_engine/ui-anbindung.md index 6fa0c81..e4734f0 100644 --- a/docs/new_engine/ui-anbindung.md +++ b/docs/new_engine/ui-anbindung.md @@ -95,6 +95,7 @@ Die UI ruft diese über `DataSource::read_almanac` und `read_statistics` direkt | `environment.commit` | `itemId`, `level` 0–6 | setzt ein Monatsbudget des Umfelds (keine Sofortbuchung, kein Zufall); unverändert: `outcome: no_change`; Fehler `environment_refused` | | `manager.resign.commit` | `confirmed: true` | Aufgeben (neu in Modern, das Original kennt kein Aussteigen). Spielt nur ein Mensch (oder ist er der letzte), endet das Spiel wie mit dem Ablauf der festgelegten Dauer: die Highscore-Tabelle wird fortgeschrieben und angezeigt (der Hook der Saisonwende, erst Aktualisierung, dann Anzeige), `outcome: career_ended`, `ownershipChange` mit `archivedIdentity` (Manager `control: archived`, `status: resigned`, Amtszeiten mit `until` und `endReason: resigned`), `terminationReason: last_human_resigned`; danach antwortet jeder Befehl `career_ended`. Beim Ablauf der Dauer sind die Manager `retired`, die Amtszeiten enden mit `career_end`. Mit weiteren Menschen soll der Computer den Verein übernehmen; das braucht das Nachrücken aller Managertabellen und folgt (`resign_not_supported_yet`). Fehler `confirmation_required` | | `manager.clubChange` | `teamId`, `confirmed: true` | der Manager wechselt zu einem der interessierten Vereine des Reads `assembly` und beginnt dort mit dessen Kasse ([Regeln](hauptversammlung.md)). Fehler: `confirmation_required`, `not_at_desk`, `no_club` (Bundestrainer), `club_change_refused` (Verein nicht auf der Liste) | +| `lineup.setNumber` | `playerId`, `number` 1–99 | die [Rückennummer](rueckennummern.md) eines Spielers des eigenen Vereins; wer die Nummer trug, übernimmt die bisherige des Spielers. Fehler: `no_club`, `unknown_player`, `invalid_number` | | `marketing.commit` | `budget` (`Money`, 0–500 000 € in ganzen Tausendern) | das Monatsbudget der [internationalen Vermarktung](vermarktung.md). Fehler: `no_club`, `invalid_budget` | | `stadium.rename` | `name` | benennt das eigene Stadion ([Regeln](namensrecht.md)): 1–40 Zeichen. Fehler: `no_club`, `invalid_name`, `name_sold` (der Name ist verkauft) | | `stadium.namingRights` | `offerId` (`naming:` aus dem Read `stadium`), `confirmed: true` | verkauft den Stadionnamen an den Sponsor des Angebots; er zahlt mit jedem Monatswechsel. Fehler: `confirmation_required`, `name_sold`, `unknown_offer` | diff --git a/src/modern/app/modern_session.cpp b/src/modern/app/modern_session.cpp index 0d3fad6..12bd914 100644 --- a/src/modern/app/modern_session.cpp +++ b/src/modern/app/modern_session.cpp @@ -14,6 +14,7 @@ #include "modern/game/assembly.hpp" #include "modern/game/naming_rights.hpp" #include "modern/game/marketing.hpp" +#include "modern/game/shirt_numbers.hpp" #include "modern/game/balance_plan.hpp" #include "modern/game/bank_credit.hpp" #include "modern/game/career.hpp" @@ -9788,6 +9789,7 @@ cli::Json ModernSession::finish_live(const std::string& request_id, uint64_t pre g_.transfer_offer_selector = run.previous_offer_selector; contract_expiry_presenter_installed_ = run.previous_contract_installed; modern::journal_advance(g_, run.saved_state); + for (const int t : g_.manager_teams) if (t >= 0 && t < league_clubs()) modern::fix_shirt_numbers(g_, t); // the numbers stay with the players modern::ensure_ui_identities(g_); ui_last_advance_ = std::make_pair(run.from_date, g_.date); ui_last_awards_ = std::move(run.awards); @@ -10442,6 +10444,7 @@ cli::Json ModernSession::ui_command(const cli::Json& request, uint64_t& revision return rehearsal; } modern::journal_advance(g_, saved_state); + for (const int t : g_.manager_teams) if (t >= 0 && t < league_clubs()) modern::fix_shirt_numbers(g_, t); // the numbers stay with the players modern::ensure_ui_identities(g_); revision = previous + 1; ui_last_advance_ = std::make_pair(saved_state.date, g_.date); // what read_live replays @@ -11097,6 +11100,22 @@ cli::Json ModernSession::ui_command(const cli::Json& request, uint64_t& revision } else if (kind == "manager.join.commit") { answer = ui_join_managers(*payload,request_id,revision); if (ui_text(answer,"messageType")=="error") return answer; + } else if (kind == "lineup.setNumber") { + // payload {playerId, number 1-99}: the shirt number of a player of the manager's club; the + // player who wore the number takes the other's (rueckennummern.md) + const cli::Json* number = ui_field(*payload, "number"); + const std::string id = ui_text(*payload, "playerId"); + const int team = g_.manager_teams[size_t(manager)]; + if (team < 0 || team >= league_clubs()) return refuse("no_club", "Am Schreibtisch des Bundestrainers gibt es keine Rückennummern."); + int player = -1; + const SquadRange range = squad_range(team); + for (size_t i = 0; i < range.count; ++i) + if (const int p = g_.squad_slots[range.first + i] & 0x0fff; p != 0x0fff && modern::ui_player_id(g_, p) == id) player = p; + if (player < 0) return refuse("unknown_player", "Spieler nicht im Kader: " + id); + if (!number || !number->integer() || !modern::set_shirt_number(g_, manager, player, int(*number->integer()))) + return refuse("invalid_number", "Die Rückennummer liegt zwischen 1 und 99."); + revision = previous + 1; + answer = modern::ui_command_result(request_id, previous, revision, {"squad", "lineup", "tactics"}, "Rückennummer vergeben."); } else if (kind == "marketing.commit") { // payload {budget: Money}: the monthly budget for international marketing, in whole thousands const cli::Json* amount = ui_field(*payload, "budget"); diff --git a/src/modern/content/ui_contract.cpp b/src/modern/content/ui_contract.cpp index 1863b2a..5a5e1dd 100644 --- a/src/modern/content/ui_contract.cpp +++ b/src/modern/content/ui_contract.cpp @@ -21,6 +21,7 @@ #include "modern/game/desk_actions.hpp" #include "modern/game/environment.hpp" #include "modern/game/reschedule.hpp" +#include "modern/game/shirt_numbers.hpp" namespace bmh::modern { @@ -151,7 +152,7 @@ A allowed_commands(const ModernState& g, const UiContext& c) { const int team = team_of(g, c.manager); const bool national = team == no_team(); static constexpr const char* kAll[] = { - "session.advance", "lineup.commit", "lineup.setPiece", "lineup.setOrder", "lineup.setFormation", "tactics.commit", "friendly.book", "manager.resign.commit", "manager.clubChange", "stadium.rename", "stadium.namingRights", "marketing.commit", + "session.advance", "lineup.commit", "lineup.setPiece", "lineup.setOrder", "lineup.setFormation", "tactics.commit", "friendly.book", "manager.resign.commit", "manager.clubChange", "stadium.rename", "stadium.namingRights", "marketing.commit", "lineup.setNumber", "training.commit", "camp.book", "bank.commit", "toto.submit", "quote.request", "contract.offer", "stadium.commit", "advertising.accept", "budget.commit", "ticket.commit", "transfer.submit", "sponsor.answer", "environment.commit", "fixture.reschedule", "contract.cancel", "news.update", "balance.commit", "settings.commit", "manager.join.commit"}; @@ -298,6 +299,7 @@ J squad_data(const ModernState& g, const UiContext& c, int team, const std::stri } } A players; + const std::vector shirts = squad_shirt_numbers(g, team); for (size_t s = r.first; s < r.first + r.count && s < g.squad_slots.size(); ++s) { const uint16_t e = g.squad_slots[s]; const int id = e & 0x0fff; @@ -320,7 +322,7 @@ J squad_data(const ModernState& g, const UiContext& c, int team, const std::stri for (int k = 0; k < 7; ++k) skills[kSkills[k]] = int(p.w368 >> (2 * k) & 3); O row{{"player", O{{"id", pid}, {"name", first.empty() ? last : first + " " + last}, {"photoAssetId", photo_of(pid)}, {"nationIds", nation.empty() ? A{} : A{J(nation)}}, {"positions", A{J(kPositions[p.position()])}}, - {"shirtNumber", nullptr}}}, + {"shirtNumber", s - r.first < shirts.size() && shirts[s - r.first] ? J(shirts[s - r.first]) : J(nullptr)}}}, {"clubId", team < league_clubs() ? J(team_id(g, team)) : J(nullptr)}, {"squadTeamId", team_id(g, team)}, {"role", (e & 0x8000) ? "starter" : (e & 0x4000) ? "bench" : "reserve"}, diff --git a/src/modern/content/world_save.cpp b/src/modern/content/world_save.cpp index 5aca94c..bbd912b 100644 --- a/src/modern/content/world_save.cpp +++ b/src/modern/content/world_save.cpp @@ -194,6 +194,13 @@ void save_world_career(const std::filesystem::path& path, const World& world, co return J(std::move(rows)); }()}, {"dismissals", state.dismissals}, + {"shirt_numbers", [&] { + // only the players who have a number: [player, number] pairs + A rows; + for (size_t p = 0; p < state.shirt_numbers.size(); ++p) + if (state.shirt_numbers[p]) rows.push_back(A{J(int64_t(p)), J(int64_t(state.shirt_numbers[p]))}); + return J(std::move(rows)); + }()}, {"marketing", [&] { A rows; for (const auto& m : state.marketing) rows.push_back(O{{"budget", int64_t(m.budget)}, {"reach", int64_t(m.reach)}}); @@ -281,6 +288,16 @@ SavedWorldCareer load_world_career(const std::filesystem::path& path, const Worl if (const auto it = o->find("dismissals"); it != o->end() && std::holds_alternative(it->second.value)) out.state.dismissals = std::get(it->second.value); } + // shirt numbers (since 17 November 2026) + if (o->count("shirt_numbers")) + for (const J& row : arr(get(modern, "shirt_numbers"))) { + const A& pair = arr(row); + if (pair.size() != 2) fail("invalid shirt number"); + const int64_t player = num(pair[0]), number = num(pair[1]); + if (player < 0 || size_t(player) >= out.state.players.size() || number < 1 || number > 99) fail("invalid shirt number"); + if (out.state.shirt_numbers.size() <= size_t(player)) out.state.shirt_numbers.resize(out.state.players.size(), 0); + out.state.shirt_numbers[size_t(player)] = uint8_t(number); + } // international marketing (since 17 November 2026) if (o->count("marketing")) for (const J& row : arr(get(modern, "marketing"))) { diff --git a/src/modern/game/modern_state.hpp b/src/modern/game/modern_state.hpp index d316a54..0dec88b 100644 --- a/src/modern/game/modern_state.hpp +++ b/src/modern/game/modern_state.hpp @@ -157,6 +157,8 @@ struct ModernState : GameState { bool operator==(const Marketing&) const = default; }; std::vector marketing; + // Shirt numbers (docs/new_engine/rueckennummern.md) by player: 1-99, 0 = none yet. + std::vector shirt_numbers; // Whether a manager the meeting votes out has to leave his club. On until the options offer it. bool dismissals = true; // Players whose age the data set gives (birth date); the others carry a placeholder the diff --git a/src/modern/game/shirt_numbers.cpp b/src/modern/game/shirt_numbers.cpp new file mode 100644 index 0000000..07563ee --- /dev/null +++ b/src/modern/game/shirt_numbers.cpp @@ -0,0 +1,62 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "modern/game/shirt_numbers.hpp" + +#include + +namespace bmh::modern { + +// OpenBMH deviates from the original: in Modern every player keeps a shirt number from 1 to 99, unique within his squad, which the manager of a club can change. +std::vector squad_shirt_numbers(const ModernState& g, int team) { + const SquadRange range = squad_range(team); + std::vector numbers(range.count, 0); + std::array taken{}; + const auto player_at = [&](size_t row) { + const size_t slot = range.first + row; + const int player = slot < g.squad_slots.size() ? g.squad_slots[slot] & 0x0fff : 0x0fff; + return player == 0x0fff || size_t(player) >= g.players.size() ? -1 : player; + }; + for (size_t row = 0; row < range.count; ++row) { + const int player = player_at(row); + const int kept = player >= 0 && size_t(player) < g.shirt_numbers.size() ? g.shirt_numbers[size_t(player)] : 0; + if (kept >= 1 && kept <= 99 && !taken[size_t(kept)]) numbers[row] = kept, taken[size_t(kept)] = true; + } + int next = 1; + for (size_t row = 0; row < range.count; ++row) { + if (player_at(row) < 0 || numbers[row] != 0) continue; + while (next < 99 && taken[size_t(next)]) ++next; + numbers[row] = next, taken[size_t(next)] = true; + } + return numbers; +} + +void fix_shirt_numbers(ModernState& g, int team) { + const SquadRange range = squad_range(team); + const std::vector numbers = squad_shirt_numbers(g, team); + for (size_t row = 0; row < numbers.size(); ++row) { + if (numbers[row] == 0) continue; + const size_t player = g.squad_slots[range.first + row] & 0x0fff; + if (g.shirt_numbers.size() <= player) g.shirt_numbers.resize(g.players.size(), 0); + if (player < g.shirt_numbers.size()) g.shirt_numbers[player] = uint8_t(numbers[row]); + } +} + +bool set_shirt_number(ModernState& g, int manager, int player, int number) { + if (manager < 0 || size_t(manager) >= g.manager_teams.size() || number < 1 || number > 99 || player < 0) return false; + const int team = g.manager_teams[size_t(manager)]; + if (team < 0 || team >= league_clubs()) return false; + const SquadRange range = squad_range(team); + const std::vector numbers = squad_shirt_numbers(g, team); + int own_row = -1, other_row = -1; + for (size_t row = 0; row < numbers.size(); ++row) { + if (numbers[row] == 0) continue; + if (int(g.squad_slots[range.first + row] & 0x0fff) == player) own_row = int(row); + else if (numbers[row] == number) other_row = int(row); + } + if (own_row < 0) return false; + fix_shirt_numbers(g, team); + if (other_row >= 0) g.shirt_numbers[g.squad_slots[range.first + size_t(other_row)] & 0x0fff] = uint8_t(numbers[size_t(own_row)]); + g.shirt_numbers[size_t(player)] = uint8_t(number); + return true; +} + +} // namespace bmh::modern diff --git a/src/modern/game/shirt_numbers.hpp b/src/modern/game/shirt_numbers.hpp new file mode 100644 index 0000000..ed78e66 --- /dev/null +++ b/src/modern/game/shirt_numbers.hpp @@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-3.0-only +#pragma once +// Shirt numbers (docs/new_engine/rueckennummern.md). A Modern rule; Classic numbers a team +// 1 to 11 by its place on the board. +// +// Every player keeps a number from 1 to 99 (ModernState::shirt_numbers, 0 = none yet). Within +// a squad a number is worn once. A player without a number, or whose number another player of +// the squad already wears, gets the lowest free one. Draws no random number. + +#include + +#include "modern/game/modern_state.hpp" + +namespace bmh::modern { + +// The numbers the squad of a club wears, by squad row (0 for an empty row): the kept numbers +// first come first served in row order, the lowest free numbers for everybody else. +std::vector squad_shirt_numbers(const ModernState& g, int team); + +// Writes the numbers of squad_shirt_numbers into the players, so they stay when rows change. +void fix_shirt_numbers(ModernState& g, int team); + +// Gives a player of the manager's club the number (1-99). The player who wore it takes the +// other's number. False, with nothing changed, for a player who is not in the squad or a +// number out of range. +bool set_shirt_number(ModernState& g, int manager, int player, int number); + +} // namespace bmh::modern diff --git a/src/modern/ui/engine_assembly.inc b/src/modern/ui/engine_assembly.inc index 3c1916d..802ac54 100644 --- a/src/modern/ui/engine_assembly.inc +++ b/src/modern/ui/engine_assembly.inc @@ -255,3 +255,18 @@ void App::engine_assembly_choose(const std::string &team) { popup_title_ = "Vereinswechsel"; popup_accept_ = "Wechseln"; } +// Shirt numbers: what the squad read says a player wears. +std::string App::engine_shirt(const std::string &player, size_t fallback) const { + if (engine_mode_) try { + for (const auto &row : engine_data_.at("squad").at("data").at("players")) + if (row.at("player").at("id") == player && row.at("player").at("shirtNumber").is_number_integer()) return std::to_string(row.at("player").at("shirtNumber").get()); + } catch (const std::exception &) {} + return std::to_string(fallback); +} +std::string App::engine_shirt_at(size_t place) const { + if (engine_mode_) try { + const auto &rows = engine_data_.at("squad").at("data").at("players"); + if (place < rows.size() && rows[place].at("player").at("shirtNumber").is_number_integer()) return std::to_string(rows[place].at("player").at("shirtNumber").get()); + } catch (const std::exception &) {} + return std::to_string(place + 1); +} diff --git a/src/modern/ui/engine_bridge.hpp b/src/modern/ui/engine_bridge.hpp index 17733e6..bb31daf 100644 --- a/src/modern/ui/engine_bridge.hpp +++ b/src/modern/ui/engine_bridge.hpp @@ -32,6 +32,8 @@ Json engine_ticket_command(const Json &bundle, int euros, const std::string &req Json engine_environment_projection(const Json &bundle); Json engine_environment_command(const Json &bundle, const std::string &item, int level, const std::string &request_id); +// A player of the squad gets the shirt number 1-99. +Json engine_shirt_number_command(const Json &bundle, const std::string &player, int number, const std::string &request_id); // The monthly budget for international marketing (read "advertising", internationalMarketing). Json engine_marketing_command(const Json &bundle, int64_t euros, const std::string &request_id); // The manager names his stadium, or sells its name to the sponsor of an offer (read "stadium"). diff --git a/src/modern/ui/engine_controls.inc b/src/modern/ui/engine_controls.inc index 3da4ae6..2d094f4 100644 --- a/src/modern/ui/engine_controls.inc +++ b/src/modern/ui/engine_controls.inc @@ -521,7 +521,24 @@ void App::engine_event(Rml::Event &event) { 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 (engine_assembly_open_) { engine_assembly_action(action, id); return; } // the sheet of the interested clubs lies over everything + if (engine_assembly_open_) { engine_assembly_action(action, id); return; } + if (action == "lineup-number" && engine_fresh_ && !engine_busy_ && menu_ == "lineup") { + // a new shirt number for the player; whoever wears it takes his + const std::string player = id; + const auto meta = engine_data_.at("desktop").at("meta"); + AmountRequest request; + request.title = "Rückennummer"; + request.review_text = [](int64_t) { return "Trägt schon ein anderer Spieler die Nummer, tauschen die beiden."; }; + request.unit = ""; + try { request.value = std::stoll(engine_shirt(player, 1)); } catch (const std::exception &) { request.value = 1; } + request.min = 1; request.max = 99; request.step = 1; request.suggestion_step = 1; request.review = false; + request.accept = [this, meta, player](int64_t value) { + if (engine_busy_ || !engine_fresh_ || meta != engine_data_.at("desktop").at("meta")) return false; + try { engine_finance_submit(engine_shirt_number_command(engine_data_, player, int(value), editor::new_id("request:ui-"))); } catch (const std::exception &) { return false; } + return true; + }; + open_amount(std::move(request)); return; + } // the sheet of the interested clubs lies over everything if (action == "engine-widget-warning" && menu_.empty() && !engine_busy_) { const auto rows = engine_widgets_projection(engine_data_).at("warnings"); std::string text; diff --git a/src/modern/ui/engine_dto.cpp b/src/modern/ui/engine_dto.cpp index 5078c4f..9c71a9c 100644 --- a/src/modern/ui/engine_dto.cpp +++ b/src/modern/ui/engine_dto.cpp @@ -513,6 +513,9 @@ Json engine_environment_projection(const Json &bundle) { } return {{"ok", true}, {"rows", rows}}; } +Json engine_shirt_number_command(const Json &bundle, const std::string &player, int number, const std::string &request_id) { + return sports_command(bundle, "lineup.setNumber", {{"playerId", player}, {"number", number}}, request_id); +} Json engine_marketing_command(const Json &bundle, int64_t euros, const std::string &request_id) { return sports_command(bundle, "marketing.commit", {{"budget", {{"currency", "EUR"}, {"minorUnits", 2}, {"minor", std::to_string(euros * 100)}}}}, request_id); } diff --git a/src/modern/ui/lineup_page.inc b/src/modern/ui/lineup_page.inc index 7ab3050..de112e8 100644 --- a/src/modern/ui/lineup_page.inc +++ b/src/modern/ui/lineup_page.inc @@ -53,7 +53,12 @@ std::string App::render_lineup_page() { size_t field = 0; for (const auto &column : columns) { const std::string key = column.key; - if (std::string(column.label) == "Nr.") { out += pg_td(slot < field_count ? std::to_string(slot + 1) : std::string("–"), column.width, "r"); continue; } + if (std::string(column.label) == "Nr.") { + // the shirt number; with the engine it can be changed by a click + if (engine_mode_) out += pg_td(btn("lineup-number", "" + engine_shirt(id, size_t(slot + 1)) + "", "pg-link", "id=\"lineup-number-" + esc(id) + "\" data-id=\"" + esc(id) + "\" title=\"Rückennummer ändern\""), column.width, "r", true); + else out += pg_td(slot < field_count ? std::to_string(slot + 1) : std::string("–"), column.width, "r"); + continue; + } if (std::string(column.label) == "Name") { auto name = esc(row.at("name").get()); if (row.at("pair_number").is_number_integer()) name += "P" + std::to_string(row.at("pair_number").get()); @@ -91,7 +96,7 @@ std::string App::render_lineup_page() { const bool selected = lineup_selected_ == row.at("id").get(); const std::string level = condition.is_number_integer() ? (condition.get() >= 85 ? "a" : condition.get() >= 70 ? "b" : "c") : "n"; return btn("lineup-player", "" + picture(renderer_.diagram("lineup-shirt-" + shirt_colour + (selected ? "-s-" : "-n-") + level, lineup_shirt(shirt_colour, selected, condition), 160), shirt_size, shirt_size) + - "" + (index < size_t(field_count) ? std::to_string(index + 1) : std::string()) + "" + esc(last_name(row.at("name").get())) + "", + "" + (engine_mode_ ? engine_shirt(row.at("id").get(), index + 1) : index < size_t(field_count) ? std::to_string(index + 1) : std::string()) + "" + esc(last_name(row.at("name").get())) + "", std::string("lp-shirt") + (selected ? " sel" : ""), player_attrs(row, "lineup-player-") + (style.empty() ? std::string() : " style=\"" + style + "\"")); }; const double side_width = 900, pitch_height = 1512 - 27 - (indoor ? 420 : 250); diff --git a/src/modern/ui/live_screens.inc b/src/modern/ui/live_screens.inc index 66d2e21..c04d442 100644 --- a/src/modern/ui/live_screens.inc +++ b/src/modern/ui/live_screens.inc @@ -204,7 +204,7 @@ std::string App::live_roster(const Json &owner) { last = "
70 ? "#56874a" : value > 50 ? "#d9a441" : "#c8372d") + ";\">
" + std::to_string(value) + "
"; } - out += "
" + cell(std::to_string(i + 1), "w1") + + out += "
" + cell(engine_shirt(id, i + 1), "w1") + cell(live_position_text(row.value("position", Json())), "w2 l pos") + "" + esc(row.at("name").get()) + "" + badges + "" + cell(lineup_value(row.at(national ? "caps" : "strength")), "w3") + last + "
"; @@ -328,7 +328,7 @@ std::string App::live_dialog_markup(const Json &owner) { if (chosen) names[bench] = rows[i].at("name").get(); const std::string strength = lineup_value(rows[i].value("strength", Json())), condition = lineup_value(rows[i].value("condition", Json())); lists[bench] += btn(bench ? "live-pick-in" : "live-pick-out", - "" + std::to_string(i + 1) + "" + esc(live_position_text(rows[i].value("position", Json()))) + "" + + "" + engine_shirt(id, i + 1) + "" + esc(live_position_text(rows[i].value("position", Json()))) + "" + esc(rows[i].at("name").get()) + "" + esc(strength + " · " + condition) + "", std::string("mv-pick") + (chosen ? " selected" : ""), "id=\"live-pick-" + std::to_string(i) + "\" data-id=\"" + esc(id) + "\" aria-pressed=\"" + (chosen ? "true" : "false") + "\""); diff --git a/src/modern/ui/live_state.inc b/src/modern/ui/live_state.inc index 70d3b10..44dfb1f 100644 --- a/src/modern/ui/live_state.inc +++ b/src/modern/ui/live_state.inc @@ -53,6 +53,10 @@ void engine_assembly_ask(const Json &args); void engine_assembly_clubs(bool forced); void engine_assembly_choose(const std::string &team); + // The shirt number of a player of the squad at the desk, or of its n-th player; the fallback + // (the place on the board) where the engine gives none. + std::string engine_shirt(const std::string &player, size_t fallback) const; + std::string engine_shirt_at(size_t place) const; // The big sheet of the interested clubs: open or not, the club whose details are shown, and // where its list was scrolled to before the sheet was drawn again. bool engine_assembly_open_ = false; diff --git a/src/modern/ui/tactics_page.inc b/src/modern/ui/tactics_page.inc index 41b8488..67d79e1 100644 --- a/src/modern/ui/tactics_page.inc +++ b/src/modern/ui/tactics_page.inc @@ -119,7 +119,7 @@ std::string App::render_tactics() { for (size_t i = 0; i < 11; ++i) { const auto &[x, y, side] = players[i]; lines += ""; - over += "" + std::to_string(i + 1) + ""; + over += "" + engine_shirt_at(i) + ""; if (side != 0) over += "
"; } // the three knobs: head of the pass, its arc, head of the goal kick diff --git a/tests/modern_shirt_number_tests.cpp b/tests/modern_shirt_number_tests.cpp new file mode 100644 index 0000000..716da9d --- /dev/null +++ b/tests/modern_shirt_number_tests.cpp @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: GPL-3.0-only +// Shirt numbers (docs/new_engine/rueckennummern.md) on a synthetic squad: the lowest free +// numbers, kept numbers, the swap, and that numbers stay with players when rows change. +#include +#include + +#include "modern/game/shirt_numbers.hpp" + +using namespace bmh; +using namespace bmh::modern; + +namespace { +int failures = 0; +void check(bool ok, const char* what) { + if (!ok) { + std::fprintf(stderr, "FAIL: %s\n", what); + ++failures; + } +} +// Manager 0 runs club 0 with players 0-19 in its first twenty rows. +ModernState squad() { + ModernState g; + g.manager_teams = {0}; + g.manager_records.assign(5 * 0xb0c, 0); + g.squad_slots.assign(3150, kEmptySlot); + for (int i = 0; i < 20; ++i) { + g.players.push_back(Player{}); + g.squad_slots[size_t(i)] = uint16_t(i); + } + return g; +} +} // namespace + +int main() { + { + ModernState g = squad(); + const auto numbers = squad_shirt_numbers(g, 0); + bool in_order = numbers.size() >= 20; + for (int i = 0; in_order && i < 20; ++i) in_order = numbers[size_t(i)] == i + 1; + check(in_order && numbers[20] == 0, "without kept numbers the squad wears 1 to 20 in row order, empty rows none"); + + check(set_shirt_number(g, 0, 5, 33) && squad_shirt_numbers(g, 0)[5] == 33, "a free number is given"); + check(set_shirt_number(g, 0, 0, 10), "a worn number is given"); + const auto swapped = squad_shirt_numbers(g, 0); + check(swapped[0] == 10 && swapped[9] == 1, "the two players swap their numbers"); + std::set worn; + bool unique = true; + for (int i = 0; i < 20; ++i) unique = unique && worn.insert(swapped[size_t(i)]).second; + check(unique, "every number is worn once"); + check(!set_shirt_number(g, 0, 5, 0) && !set_shirt_number(g, 0, 5, 100) && !set_shirt_number(g, 0, 30, 7) && !set_shirt_number(g, 1, 5, 7) && + squad_shirt_numbers(g, 0)[5] == 33, + "a number out of range, a player outside the squad and a missing manager are refused"); + + // rows change (a new line-up): the numbers go with the players + std::swap(g.squad_slots[0], g.squad_slots[15]); + const auto moved = squad_shirt_numbers(g, 0); + check(moved[15] == 10 && moved[0] == 16, "numbers stay with the players when rows change"); + } + // a newcomer whose number is taken gets the lowest free one + { + ModernState g = squad(); + fix_shirt_numbers(g, 0); + g.players.push_back(Player{}); + g.shirt_numbers.resize(g.players.size(), 0); + g.shirt_numbers[20] = 7; + g.squad_slots[20] = 20; + check(squad_shirt_numbers(g, 0)[20] == 21 && squad_shirt_numbers(g, 0)[6] == 7, "a taken number: the newcomer gets the lowest free one"); + g.squad_slots[6] = kEmptySlot; + check(squad_shirt_numbers(g, 0)[20] == 7, "once the number is free he wears his own"); + } + if (failures) return 1; + std::puts("modern_shirt_number_tests: ok"); + return 0; +}