From 2639f37def2ca84b1de33a7111fb9dde123009f3 Mon Sep 17 00:00:00 2001 From: Weyoune Date: Tue, 17 Nov 2026 15:09:01 +0100 Subject: [PATCH] The stadium has a name of its own, and the name can be sold A manager renames his stadium on the stadium page. On the advertising page three sponsors offer to buy the name for one to five years; the sponsor pays with every month change, the stadium is called after him, and until the contract ends it can be neither renamed nor sold again. The match sheet shows the name. Engine: naming_rights.hpp; read stadium (name, nameEditable, namingRights, namingOffers), commands stadium.rename and stadium.namingRights, live read stadiumName; 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/namensrecht.md | 67 +++++++++++++++++++ docs/new_engine/ui-anbindung.md | 4 +- src/modern/app/modern_session.cpp | 62 +++++++++++++++++- src/modern/content/ui_contract.cpp | 2 +- src/modern/content/world_save.cpp | 16 ++++- src/modern/game/career.cpp | 1 + src/modern/game/modern_state.hpp | 11 ++++ src/modern/game/month.cpp | 2 + src/modern/game/naming_rights.cpp | 93 +++++++++++++++++++++++++++ src/modern/game/naming_rights.hpp | 45 +++++++++++++ src/modern/ui/advertising_screens.inc | 11 +++- src/modern/ui/engine_bridge.hpp | 3 + src/modern/ui/engine_commerce.inc | 24 +++++++ src/modern/ui/engine_controls.inc | 21 ++++++ src/modern/ui/engine_dto.cpp | 6 ++ src/modern/ui/engine_live.cpp | 2 +- src/modern/ui/engine_stadium.cpp | 2 + src/modern/ui/engine_stadium.inc | 13 ++++ src/modern/ui/live_controls.inc | 2 +- src/modern/ui/live_screens.inc | 2 +- src/modern/ui/stadium_screens.inc | 6 +- tests/modern_naming_tests.cpp | 93 +++++++++++++++++++++++++++ tests/modern_ui_contract_tests.cpp | 23 +++++++ 26 files changed, 507 insertions(+), 9 deletions(-) create mode 100644 docs/new_engine/namensrecht.md create mode 100644 src/modern/game/naming_rights.cpp create mode 100644 src/modern/game/naming_rights.hpp create mode 100644 tests/modern_naming_tests.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 95a7c40..13218ff 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1233,6 +1233,9 @@ add_test(NAME modern_camp_tests COMMAND modern_camp_tests) add_executable(modern_assembly_tests tests/modern_assembly_tests.cpp) target_link_libraries(modern_assembly_tests PRIVATE bmh_season_modern) add_test(NAME modern_assembly_tests COMMAND modern_assembly_tests) +add_executable(modern_naming_tests tests/modern_naming_tests.cpp) +target_link_libraries(modern_naming_tests PRIVATE bmh_season_modern) +add_test(NAME modern_naming_tests COMMAND modern_naming_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 5efc3a8..0b75747 100644 --- a/docs/DIFFERENCES.md +++ b/docs/DIFFERENCES.md @@ -52,6 +52,7 @@ describe deliberate changes; they are not a list of every known compatibility li - [src/modern/content/statistics.cpp](../src/modern/content/statistics.cpp): Modern chooses its own eleven of the day per league from the recorded facts of the matchday (goals, assists, cards, result, clean sheets) instead of the original's Sportschau rating, and words the ticker from several variants per event. - [src/modern/game/matchday_setup.cpp](../src/modern/game/matchday_setup.cpp): in Modern worlds a referee may take a second match on a day with more matches than referees. - [src/modern/game/month.cpp](../src/modern/game/month.cpp): in Modern every manager receives the monthly dividend of his own shares; the price product is kept in 64 bits until the division. +- [src/modern/game/naming_rights.cpp](../src/modern/game/naming_rights.cpp): in Modern a manager names his stadium and can sell the name to a sponsor for one to five years; the sponsor pays monthly and the name is fixed until the contract ends. - [src/modern/game/season.cpp](../src/modern/game/season.cpp): retains the enhanced academy player-generation strength bands with monthly youth budgets. - [src/modern/game/season.cpp](../src/modern/game/season.cpp): in Modern the age stops at 47, the most its five bits hold; real ages of a data set (a goalkeeper of 40) would otherwise run into the bits above. - [src/modern/game/season.hpp](../src/modern/game/season.hpp): retains the enhanced academy player-generation strength bands with monthly youth budgets. diff --git a/docs/new_engine/README.md b/docs/new_engine/README.md index 0e11d1f..a51d0c1 100644 --- a/docs/new_engine/README.md +++ b/docs/new_engine/README.md @@ -12,6 +12,7 @@ Grundlage ist der [Engine-Split](../ENGINE_SPLIT.md); die Oberfläche ist in | [Befund](befund.md) | Feste Classic-Größen im Code, die Modern auflösen muss | | [Trainingslager](trainingslager.md) | Katalog, Preis, Wirkung und die neue 6-Sterne-Stufe | | [Jahreshauptversammlung](hauptversammlung.md) | Abstimmung am Saisonende, interessierte Vereine, Vereinswechsel | +| [Namensrecht](namensrecht.md) | Stadionname, Angebote der Sponsoren, monatliche Zahlung | | [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/namensrecht.md b/docs/new_engine/namensrecht.md new file mode 100644 index 0000000..5ff2c92 --- /dev/null +++ b/docs/new_engine/namensrecht.md @@ -0,0 +1,67 @@ +# Stadionname und Namensrecht · Modern-Engine + +Stand: 17. November 2026. Eine Modern-Regel; Classic kennt weder einen änderbaren Stadionnamen +noch ein Namensrecht. + +## Stadionname + +- Das Stadion eines menschlichen Managers heißt zunächst so, wie der Datensatz es nennt. +- Der Manager kann es jederzeit umbenennen: 1 bis 40 Zeichen, Leerzeichen am Rand werden + entfernt, Steuerzeichen sind nicht erlaubt. +- Ist der Name verkauft, heißt das Stadion „-Arena“ und lässt sich bis zum + Vertragsende nicht umbenennen. Der eigene Name bleibt gespeichert und gilt danach wieder. +- Bei einem [Vereinswechsel](hauptversammlung.md) bleiben Name und Vertrag beim alten Stadion. + +## Namensrecht + +Solange der Name frei ist, liegen drei Angebote verschiedener Sponsoren vor +(`modern::naming_offers`). Die Sponsoren sind die zehn Namen der Werbeliste des Datensatzes. + +``` +Plätze = Summe der acht Tribünenblöcke +Satz = 36 / 22 / 12 / 7 / 7 Euro je Platz und Jahr (1. bis 5. Liga) +Basis = Plätze × Satz / 12 × (80 + Ansehen × 2 / 5) % +je Angebot: + Sponsor = Zufall(0–9), jeder nur einmal + Jahre = Zufall(1–5) + Prozent = Zufall(80–125) − 3 je weiterem Jahr + monatlich = Basis × Prozent %, auf 1000 abgerundet, mindestens 1000 +``` + +- Ein Stadion mit 24 000 Plätzen in der ersten Liga bringt bei mittlerem Ansehen rund + 45 000 bis 90 000 Euro im Monat, in der dritten Liga etwa ein Drittel davon. +- Die Angebote haben einen eigenen Zufallsgenerator (Startwert aus Karriere, Manager und dem + Vier-Wochen-Abschnitt des Datums). Sie wechseln alle vier Wochen; das Ansehen der Liste + zieht keine Zahl aus den Generatoren des Spiels. +- Mit dem Verkauf (`modern::sell_naming_rights`) beginnt der Vertrag. Der Sponsor zahlt mit + jedem Monatswechsel (`modern::naming_rights_month`, erster Schritt von `month_change`); mit + der letzten Zahlung endet der Vertrag, und das Stadion trägt wieder den eigenen Namen. +- Während der Laufzeit gibt es keine weiteren Angebote und keinen zweiten Verkauf. Ein + vorzeitiges Ende ist nicht vorgesehen. + +## Speichern + +`state/modern.json` erhält das optionale Feld `stadiums`: je Managerplatz +`{name, sponsor, monthly, months}`. Ältere Stände laden ohne es. Das OBW-Format ändert sich nicht. + +## Anbindung + +Siehe [UI-Anbindung](ui-anbindung.md): Felder des Reads `stadium`, Befehle `stadium.rename` +und `stadium.namingRights`, Feld `stadiumName` des Live-Reads. + +## Prüfung + +- `modern_naming_tests` (ohne Spieldaten): Umbenennen und seine Grenzen, drei Angebote + verschiedener Sponsoren, Höhe nach Plätzen und Liga, unverändert beim erneuten Lesen, Verkauf, + gesperrtes Umbenennen, monatliche Zahlung über die ganze Laufzeit, Ende des Vertrags. +- `modern_ui_contract_tests` (mit Spieldaten): Read, Umbenennen, Verkauf mit Bestätigung, + Ablehnung von Umbenennen und zweitem Verkauf. + +## Offen + +- Die Zahlung wird wie eine einfache Buchung geführt und erscheint in der Bilanz unter keinem + eigenen Posten. +- Auf der leichtesten Stufe bucht das Spiel grundsätzlich kein Geld; dort ändert der Verkauf + nur den Namen. +- Keine Nachricht im Posteingang bei Verkauf und Vertragsende. +- Die Saisonwirkung auf die Wirtschaft ist nicht in einem Langlauf gemessen. diff --git a/docs/new_engine/ui-anbindung.md b/docs/new_engine/ui-anbindung.md index 814e6f9..82a74ed 100644 --- a/docs/new_engine/ui-anbindung.md +++ b/docs/new_engine/ui-anbindung.md @@ -33,7 +33,7 @@ Revision kommt vom Aufrufer (Konsole bzw. AppController), der Read ändert nicht | `training` | Bälle je Spielertyp und Trainingsbereich (1–3) mit den Grenzen, je Spieler Intensität und Schwerpunkt, ob das Training eingerichtet ist, Automatik-Bits | | `contracts` | je Spieler Restlaufzeit, Monatsgehalt, Versicherung, Prämien; das offene Angebot (`quote`: ID, Spieler, Monatsforderung für 1–4 Jahre, Höchstgehalt 200.000 €) | | `advertising` | 14 Banden (`ad:board/`), Trikot (`ad:shirt`), TV-Rechte (`ad:tv`) je mit Vertrag (Sponsor, Monatsbetrag, Restmonate, Verlängerung, Option) und den offenen Angeboten (`offer:ad--`, Sponsor, Betrag, Banden, Monate, `allowed`); die drei Budgets (Merchandising, Presse, Fanarbeit) mit Stand, Höchstbetrag, Lieferwochen; die Finanzvorschau des Originals | -| `stadium` | Umfeld (14 Objekte mit Namen und Bautagen; Verkehrsanbindung mit `stage` und `maxStage`: Classic 3, Modern-Welt 4; sonst `built`), die acht Anlagen (Stufe, Höchststufe, Bauwochen, ob ausbaubar), die acht Tribünenblöcke (Plätze, Höchstplätze, Sitzplätze, Dach, Bauwochen, Plätze nach dem Bau), Eintrittspreis (8–25 €); das offene Angebot des Stadion-Dialogs (`quote`: Umfeld mit Preis, oder Anlage mit Zielstufe, Preis, Bauwochen und dem Trinkgeld-Bereich 6–14 %) | +| `stadium` | Umfeld (14 Objekte mit Namen und Bautagen; Verkehrsanbindung mit `stage` und `maxStage`: Classic 3, Modern-Welt 4; sonst `built`), die acht Anlagen (Stufe, Höchststufe, Bauwochen, ob ausbaubar), die acht Tribünenblöcke (Plätze, Höchstplätze, Sitzplätze, Dach, Bauwochen, Plätze nach dem Bau), Eintrittspreis (8–25 €); das offene Angebot des Stadion-Dialogs (`quote`: Umfeld mit Preis, oder Anlage mit Zielstufe, Preis, Bauwochen und dem Trinkgeld-Bereich 6–14 %). Dazu der Name: `name` (wie das Stadion heißt), `worldName` (Name des Datensatzes), `nameEditable`, `namingRights` (`null` oder `{sponsor, monthly, monthsLeft}`) und `namingOffers[]` (`id`, `sponsor`, `name`, `monthly`, `months`, `total`) | | `balance` | `view` current/real/future, optional `edits [{id: balance:<0–17>, amount: Money}]`; liefert ursprüngliche Posten/Labels/Grenzen, sechs Zusatzwerte, Abschreibung, Nettoergebnis und Bilanzwarnung. Prognose auf eigener Kopie, kein RNG/Live-Publish. | | `achievements` | Reine Manager-Saisonhistorie am Vereinsschreibtisch: `managerId`, aktuelles `teamId`, `currentSeasonYear`, `records` mit Jahr/Abschlussstatus, Liga-ID/Platz/Teilnehmerzahl und ursprünglichen Pokal-/Europapokalständen samt Text. Keine historische Vereinszuordnung erfinden. `available` bedeutet vorhandene Aufzeichnungen; `originalMenuAvailable` nennt zusätzlich die bisherige Ligaspiel-Sperre. Abgeschlossene Daten bleiben in der Modern UI auch zwischen Saisons lesbar; ungespielte neue Saisons werden nicht ergänzt. Kein RNG oder Schreibvorgang. | | `transfer` | die Transferliste (`listing:`: Spieler, Alter, Position, Stärke, Verkäufer, Ablöseforderung, Gehaltsreferenz pro Monat, Gehaltsforderung in %, Zahl der Angebote, eigene Listung, eigenes Gebot), der eigene Kader (gelistet oder nicht), Kontostand, Kreditrahmen; `details` je Spieler mit vollständigem Namen, Nationalität, Foto, Kondition/Technik/Form und sieben Fähigkeiten; `activeStrengths`/`teamStrengths` enthalten vier Positionen und Gesamtschnitt. `ownBid.monthlySalary` ist das gespeicherte Monatsgehalt; `annualSalary` bleibt als früher irreführend benannter Alias erhalten. `salaryReferencePeriod: month`. `loanAvailable` sperrt vereinslose Anbieter; `offerTerms` liefert Kauf-/Leihgebühr, jeweilige maximale Gebühr und maximales Monatsgehalt aus den Original-Editorgrenzen. `ownBid.loan` bezeichnet die gespeicherte Leihart. `ownBid.bonuses` sind sieben gespeicherte Prämienstufen. Die Projektion und Gebotsprüfung verwenden den weltabhängigen Modern-Pool, nicht Classic `0xb70` (#24). | @@ -95,6 +95,8 @@ 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) | +| `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` | | `toto.submit` | `stake` (`Money` je Spalte), `columns` (bis 6 Spalten mit 11 Tipps: 1 Heim, 0 Unentschieden, 2 Auswärts) | gibt den Tippschein ab; Fehler `toto_refused` (z. B. kein offener Schein, Einsatzgrenzen, doppelte Spalte) | | `sponsor.answer` | `accept` | Antwort auf das Exklusiv-Sponsor-Angebot: beginnt sofort, wird vorgemerkt oder abgelehnt | | `quote.request` (Stadion) | `kind: periphery`, `objectId`; oder `kind: facility`, `facilityId`, `increment` 1–3; oder `kind: block`, `blockId` (`block:a`–`block:h`), `places` (Ziel insgesamt), optional `seats`, `roof` | öffnet den Stadion-Dialog und holt das Angebot der Baufirma bzw. wählt Anlage und Stufen bzw. stellt den Tribünenausbau zusammen (Plätze, Sitzplätze, Dach; vorhandene Ausstattung bleibt; Angebot mit Aufschlüsselung Plätze/Sitze/Dach); `offer_pending`. Der Dialog bleibt offen (andere Schreibtisch-Einstellungen sind bis dahin gesperrt, `quote_open` für ein zweites Angebot) | diff --git a/src/modern/app/modern_session.cpp b/src/modern/app/modern_session.cpp index e27a098..28e783b 100644 --- a/src/modern/app/modern_session.cpp +++ b/src/modern/app/modern_session.cpp @@ -12,6 +12,7 @@ #include "ui/indoor_standings.hpp" #include "modern/content/world_save.hpp" #include "modern/game/assembly.hpp" +#include "modern/game/naming_rights.hpp" #include "modern/game/balance_plan.hpp" #include "modern/game/bank_credit.hpp" #include "modern/game/career.hpp" @@ -8722,6 +8723,7 @@ int ui_team_index(const ModernState& g, const std::string& id) { } // namespace +namespace { std::string managed_stadium_name(const modern::ModernState& g, int manager); } cli::Json ModernSession::read_live(const cli::Json& request) const { using O = cli::Json::Object; const auto fail = [](const char* e) { return cli::Json(O{{"ok", false}, {"error", e}}); }; @@ -8810,6 +8812,7 @@ cli::Json ModernSession::read_live(const cli::Json& request) const { {"attendance", size_t(m) < grp.spectators.size() ? cli::Json(int64_t(grp.spectators[size_t(m)])) : cli::Json(nullptr)}, // the places of a managed home ground: its eight stand blocks (record +0x4c.., thousands) {"capacity", home_capacity}, + {"stadiumName", hm >= 0 ? cli::Json(managed_stadium_name(g_, hm)) : cli::Json(nullptr)}, {"weather", grp.desc.size() > 0x50 + size_t(m) ? cli::Json(cli::Json::Object{{"temperature", int(int8_t(grp.desc[0x30 + size_t(m)]))}, {"rain", int(grp.desc[0x50 + size_t(m)])}}) : cli::Json(nullptr)}, @@ -8923,6 +8926,30 @@ cli::Json ModernSession::read_statistics_screen(const cli::Json& request) const #include "modern/app/ui_managers.inc" namespace { +// The name of a sponsor of the advertising list (naming rights). +std::string naming_sponsor(const modern::ModernState& g, int sponsor) { + return ui::original_to_utf8(message_text(g, ::bmh::layout::Advertising_FormatError_ExecutableField3 + uint32_t(sponsor) * 4)); +} +// The name of the data set for the stadium of a club ("Stadion" without one). +std::string world_stadium_name(const modern::ModernState& g, int team) { + std::string name; + const size_t at = size_t(team) * 2; + if (team >= 0 && at + 1 < g.club_heap_bc.size()) { + const size_t offset = size_t(g.club_heap_bc[at]) | (size_t(g.club_heap_bc[at + 1]) << 8); + for (size_t i = offset; i < g.stadium_names.size() && g.stadium_names[i]; ++i) name.push_back(char(g.stadium_names[i])); + } + name = ui::original_to_utf8(name); + return name.empty() ? std::string("Stadion") : name; +} +// What a human manager's stadium is called: the sponsor's arena while the name is sold, else +// the name he gave it, else the data set's. +std::string managed_stadium_name(const modern::ModernState& g, int manager) { + const int team = manager >= 0 && size_t(manager) < g.manager_teams.size() ? g.manager_teams[size_t(manager)] : -1; + const auto* entry = modern::stadium_entry(g, manager); + if (entry && entry->months > 0) return naming_sponsor(g, entry->sponsor) + "-Arena"; + if (entry && !entry->name.empty()) return entry->name; + return world_stadium_name(g, team); +} // The annual general meeting and the interested clubs for the interface (read "assembly", and the // args of the advance's question): the vote of the three groups, whether it is due at this desk, // and the clubs with the cash they offer and the strength of their eleven. @@ -9467,6 +9494,18 @@ cli::Json ModernSession::ui_read(const cli::Json& request, uint64_t revision) co A history,table; for(size_t curve=0;curve<6;++curve){A values,absolute,relative;for(const auto value:data.series[curve])values.push_back(int64_t(value));auto graph=data;bool absolute_ok=true,relative_ok=true;try{graph.flags=0x7f;for(const auto& [x,y]:ui::stadium_data_points(graph,exe_,int(curve)))absolute.push_back(A{cli::Json(x),cli::Json(y)});}catch(const std::exception&){absolute_ok=false;}try{graph.flags=0xbf;for(const auto& [x,y]:ui::stadium_data_points(graph,exe_,int(curve)))relative.push_back(A{cli::Json(x),cli::Json(y)});}catch(const std::exception&){relative_ok=false;}history.push_back(O{{"name",ui::original_to_utf8(exe_.cstring(exe_.u32(::bmh::layout::Analytics_FormatError_ExecutableField+(6+uint32_t(curve))*4)))},{"values",std::move(values)},{"absolute",std::move(absolute)},{"relative",std::move(relative)},{"absoluteAvailable",absolute_ok},{"relativeAvailable",relative_ok}});} for(size_t row=0;rowmonths > 0) + naming_contract = O{{"sponsor", naming_sponsor(g_, entry->sponsor)}, {"monthly", modern::ui_money(int64_t(entry->monthly))}, {"monthsLeft", int(entry->months)}}; + { + const auto offers = modern::naming_offers(g_, manager); + for (size_t i = 0; i < offers.size(); ++i) + naming_offers.push_back(O{{"id", "naming:" + std::to_string(i)}, {"sponsor", naming_sponsor(g_, offers[i].sponsor)}, + {"name", naming_sponsor(g_, offers[i].sponsor) + "-Arena"}, {"monthly", modern::ui_money(int64_t(offers[i].monthly))}, + {"months", int(offers[i].months)}, {"total", modern::ui_money(int64_t(offers[i].monthly) * offers[i].months)}}); + } std::string stadium_name;const size_t name_at=size_t(team)*2;if(name_at+1= league_clubs()) + return refuse("no_club", "Am Schreibtisch des Bundestrainers gibt es kein Stadion."); + if (modern::naming_rights_sold(g_, manager)) return refuse("name_sold", "Der Stadionname ist verkauft und lässt sich bis zum Vertragsende nicht ändern."); + if (!modern::rename_stadium(g_, manager, ui_text(*payload, "name"))) return refuse("invalid_name", "Der Name braucht 1 bis 40 Zeichen."); + revision = previous + 1; + answer = modern::ui_command_result(request_id, previous, revision, {"stadium", "desktop"}, "Das Stadion heißt jetzt " + managed_stadium_name(g_, manager) + "."); + } else if (kind == "stadium.namingRights") { + // payload {offerId: "naming:", confirmed: true}: sells the stadium's name to the sponsor of the offer + const cli::Json* confirmed = ui_field(*payload, "confirmed"); + if (!confirmed || !std::holds_alternative(confirmed->value) || !std::get(confirmed->value)) + return refuse("confirmation_required", "Der Verkauf des Namens muss bestätigt werden (confirmed: true)."); + if (modern::naming_rights_sold(g_, manager)) return refuse("name_sold", "Der Stadionname ist schon verkauft."); + int offer = -1; + if (std::sscanf(ui_text(*payload, "offerId").c_str(), "naming:%d", &offer) != 1 || !modern::sell_naming_rights(g_, manager, offer)) + return refuse("unknown_offer", "Dieses Angebot gibt es nicht (mehr)."); + revision = previous + 1; + answer = modern::ui_command_result(request_id, previous, revision, {"stadium", "advertising", "desktop"}, + "Das Stadion heißt jetzt " + managed_stadium_name(g_, manager) + "."); } else if (kind == "manager.clubChange") { // payload {teamId, confirmed: true}. A Modern rule (hauptversammlung.md): the manager leaves // for one of the clubs of the read "assembly" and starts there with the cash it offers. diff --git a/src/modern/content/ui_contract.cpp b/src/modern/content/ui_contract.cpp index a73e4ab..2a928ef 100644 --- a/src/modern/content/ui_contract.cpp +++ b/src/modern/content/ui_contract.cpp @@ -151,7 +151,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", + "session.advance", "lineup.commit", "lineup.setPiece", "lineup.setOrder", "lineup.setFormation", "tactics.commit", "friendly.book", "manager.resign.commit", "manager.clubChange", "stadium.rename", "stadium.namingRights", "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"}; diff --git a/src/modern/content/world_save.cpp b/src/modern/content/world_save.cpp index dd85525..d8873bf 100644 --- a/src/modern/content/world_save.cpp +++ b/src/modern/content/world_save.cpp @@ -193,7 +193,13 @@ void save_world_career(const std::filesystem::path& path, const World& world, co rows.push_back(O{{"assets", m.assets}, {"place", int64_t(m.place)}, {"voted_season", int64_t(m.voted_season)}}); return J(std::move(rows)); }()}, - {"dismissals", state.dismissals}}); + {"dismissals", state.dismissals}, + {"stadiums", [&] { + A rows; + for (const auto& s : state.stadiums) + rows.push_back(O{{"name", s.name}, {"sponsor", int64_t(s.sponsor)}, {"monthly", int64_t(s.monthly)}, {"months", int64_t(s.months)}}); + return J(std::move(rows)); + }()}}); // The almanac: finished seasons unchanged, the running one encoded now. for (const auto& [name, bytes] : state.almanac.finished) docs[name] = bytes; if (state.almanac.current.season >= 0) docs["history/current.bin"] = encode_almanac_season(state.almanac.current); @@ -270,6 +276,14 @@ 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); } + // stadium names and naming rights (since 17 November 2026) + if (o->count("stadiums")) + for (const J& row : arr(get(modern, "stadiums"))) { + ModernState::StadiumName s; + s.name = str(get(row, "name")), s.sponsor = uint8_t(num(get(row, "sponsor"))), s.monthly = uint32_t(num(get(row, "monthly"))), s.months = uint16_t(num(get(row, "months"))); + if (s.name.size() > 40 || s.months > 60 || (s.months && s.sponsor > 9)) fail("invalid stadium name"); + out.state.stadiums.push_back(std::move(s)); + } if (o->count("career_end_reason")) { out.state.career_end_reason = str(get(modern, "career_end_reason")); out.state.career_end_date = uint32_t(num(get(modern, "career_end_date"))); diff --git a/src/modern/game/career.cpp b/src/modern/game/career.cpp index 97c9806..f450c1d 100644 --- a/src/modern/game/career.cpp +++ b/src/modern/game/career.cpp @@ -698,6 +698,7 @@ bool change_club(ModernState& g, const LeImage& exe, int m, int team, int32_t ca } if (size_t(m) < g.pools.size()) g.pools[size_t(m)] = {}; if (size_t(m) < g.exclusive_sponsors.size()) g.exclusive_sponsors[size_t(m)] = {}; + if (size_t(m) < g.stadiums.size()) g.stadiums[size_t(m)] = {}; // the name and its sponsor belong to the old ground // The club he leaves is a computer club again: its sales, bids and loans as a human club end. remove_join_transfers(g, old_team); diff --git a/src/modern/game/modern_state.hpp b/src/modern/game/modern_state.hpp index 9ee7420..15cf332 100644 --- a/src/modern/game/modern_state.hpp +++ b/src/modern/game/modern_state.hpp @@ -138,6 +138,17 @@ struct ModernState : GameState { bool operator==(const AssemblyMemory&) const = default; }; std::vector assembly; + // The stadium's name and its naming rights (docs/new_engine/namensrecht.md), per manager slot: + // the name the manager gave it (empty: the default), and while the name is sold the sponsor + // (name index of the advertising list), what he pays a month and the months left. + struct StadiumName { + std::string name; + uint8_t sponsor = 0xff; + uint32_t monthly = 0; + uint16_t months = 0; + bool operator==(const StadiumName&) const = default; + }; + std::vector stadiums; // 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/month.cpp b/src/modern/game/month.cpp index 3e64ccf..117145a 100644 --- a/src/modern/game/month.cpp +++ b/src/modern/game/month.cpp @@ -4,6 +4,7 @@ #include "modern/game/modern_state.hpp" #include "modern/game/environment.hpp" #include "modern/game/month.hpp" +#include "modern/game/naming_rights.hpp" #include "modern/game/desk_actions.hpp" #include "game/trace.hpp" @@ -947,6 +948,7 @@ void search_profile_news(ModernState& g, int manager, uint32_t list, int player) } void month_change(ModernState& g, WatcomRandom& rand, MinuteReport& report, GameRandom* game) { + modern::naming_rights_month(g); // Modern: the stadium sponsors pay (naming_rights.hpp) StaticMemory& mem = g.memory; std::vector& r = g.manager_records; const int managers = int(g.manager_teams.size()); diff --git a/src/modern/game/naming_rights.cpp b/src/modern/game/naming_rights.cpp new file mode 100644 index 0000000..2494375 --- /dev/null +++ b/src/modern/game/naming_rights.cpp @@ -0,0 +1,93 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include "modern/game/naming_rights.hpp" + +#include + +#include "game/random.hpp" +#include "game/schedule.hpp" +#include "modern/game/matchday.hpp" + +namespace bmh::modern { +namespace { + +constexpr size_t kRecord = 0xb0c; + +int league_club(const ModernState& g, int manager) { + if (manager < 0 || size_t(manager) >= g.manager_teams.size() || g.manager_records.size() < size_t(manager + 1) * kRecord) return -1; + const int team = g.manager_teams[size_t(manager)]; + return team >= 0 && team < league_clubs() ? team : -1; +} + +} // namespace + +const ModernState::StadiumName* stadium_entry(const ModernState& g, int manager) { + return manager >= 0 && size_t(manager) < g.stadiums.size() ? &g.stadiums[size_t(manager)] : nullptr; +} + +bool naming_rights_sold(const ModernState& g, int manager) { + const auto* entry = stadium_entry(g, manager); + return entry && entry->months > 0; +} + +bool rename_stadium(ModernState& g, int manager, const std::string& name) { + if (league_club(g, manager) < 0 || naming_rights_sold(g, manager)) return false; + const size_t first = name.find_first_not_of(' '), last = name.find_last_not_of(' '); + if (first == std::string::npos) return false; + const std::string trimmed = name.substr(first, last - first + 1); + if (trimmed.size() > 40 || std::any_of(trimmed.begin(), trimmed.end(), [](unsigned char c) { return c < 0x20 || c == 0x7f; })) return false; + if (g.stadiums.size() <= size_t(manager)) g.stadiums.resize(size_t(manager) + 1); + g.stadiums[size_t(manager)].name = trimmed; + return true; +} + +// OpenBMH deviates from the original: in Modern a manager names his stadium and can sell the name to a sponsor for one to five years; the sponsor pays monthly and the name is fixed until the contract ends. +std::vector naming_offers(const ModernState& g, int manager) { + const int team = league_club(g, manager); + if (team < 0 || naming_rights_sold(g, manager)) return {}; + const size_t rec = size_t(manager) * kRecord; + int seats = 0; + for (size_t block = 0; block < 8; ++block) seats += int(g.manager_records[rec + 0x4c + block]) * 1000; + if (seats <= 0) return {}; + // euros a seat and year, by league + static constexpr int kRate[5] = {36, 22, 12, 7, 7}; + const int league = std::clamp(team_league(team), 0, 4); + const int prestige = g.manager_records[rec + 0x211]; + const int64_t base = int64_t(seats) * kRate[league] / 12 * (80 + prestige * 2 / 5) / 100; + + uint32_t salt = 2166136261u; + for (const unsigned char c : g.career_id) salt = (salt ^ c) * 16777619u; + GameRandom draw(int32_t((uint64_t(salt) + uint64_t(g.date / 28) * 6151u + uint64_t(manager) * 98317u + 17u) % 4000000u)); + std::vector offers; + while (offers.size() < 3) { + NamingOffer offer; + offer.sponsor = uint8_t(draw.range(0, 9)); + const int years = draw.range(1, 5); + // a longer contract pays a little less each month + const int percent = draw.range(80, 125) - (years - 1) * 3; + if (std::any_of(offers.begin(), offers.end(), [&](const NamingOffer& o) { return o.sponsor == offer.sponsor; })) continue; + offer.months = uint16_t(years * 12); + offer.monthly = uint32_t(std::max(base * percent / 100 / 1000 * 1000, 1000)); + offers.push_back(offer); + } + return offers; +} + +bool sell_naming_rights(ModernState& g, int manager, int index) { + const auto offers = naming_offers(g, manager); + if (index < 0 || size_t(index) >= offers.size()) return false; + if (g.stadiums.size() <= size_t(manager)) g.stadiums.resize(size_t(manager) + 1); + auto& entry = g.stadiums[size_t(manager)]; + entry.sponsor = offers[size_t(index)].sponsor, entry.monthly = offers[size_t(index)].monthly, entry.months = offers[size_t(index)].months; + return true; +} + +void naming_rights_month(ModernState& g) { + for (size_t m = 0; m < g.stadiums.size() && m < g.manager_teams.size(); ++m) { + auto& entry = g.stadiums[m]; + if (entry.months == 0) continue; + if (league_club(g, int(m)) >= 0) modern::book_money(g, int(m), -int32_t(entry.monthly), true); + if (--entry.months == 0) entry.sponsor = 0xff, entry.monthly = 0; + } +} + +} // namespace bmh::modern diff --git a/src/modern/game/naming_rights.hpp b/src/modern/game/naming_rights.hpp new file mode 100644 index 0000000..04ef2bc --- /dev/null +++ b/src/modern/game/naming_rights.hpp @@ -0,0 +1,45 @@ +// SPDX-License-Identifier: GPL-3.0-only +#pragma once +// The name of a human manager's stadium and its naming rights +// (docs/new_engine/namensrecht.md). A Modern rule; Classic has no stadium names. +// +// A manager names his stadium as he likes. He can sell the name to one of three sponsors for +// one to five years; the sponsor pays every month, the stadium bears the sponsor's name, and +// until the contract has run out the manager can neither rename the stadium nor sell the name +// again. Nothing here draws from the game's generators: the offers come from a generator of +// their own, seeded from the career, the manager and the four weeks of the date. + +#include +#include +#include + +#include "modern/game/modern_state.hpp" + +namespace bmh::modern { + +// The manager's stadium entry, or nullptr when he has none yet (default name, nothing sold). +const ModernState::StadiumName* stadium_entry(const ModernState& g, int manager); +// Whether the name is sold at the moment. +bool naming_rights_sold(const ModernState& g, int manager); + +// Gives the stadium the name (UTF-8, 1-40 bytes after trimming, no control characters). +// False, with nothing changed, for a manager without a league club, a bad name, or a sold name. +bool rename_stadium(ModernState& g, int manager, const std::string& name); + +struct NamingOffer { + uint8_t sponsor = 0; // sponsor name index of the advertising list (0-9) + uint32_t monthly = 0; // paid with every month change + uint16_t months = 0; // 12-60 +}; +// Three offers of different sponsors; none while the name is sold or without a stadium. The +// payment follows the seats of the stadium, the league and the manager's prestige. +std::vector naming_offers(const ModernState& g, int manager); + +// Accepts offer `index` of naming_offers. False, with nothing changed, when there is no such offer. +bool sell_naming_rights(ModernState& g, int manager, int index); + +// The month change: every running contract pays and loses a month; with the last one the +// stadium has its own name again. +void naming_rights_month(ModernState& g); + +} // namespace bmh::modern diff --git a/src/modern/ui/advertising_screens.inc b/src/modern/ui/advertising_screens.inc index 893fa94..ba741e3 100644 --- a/src/modern/ui/advertising_screens.inc +++ b/src/modern/ui/advertising_screens.inc @@ -206,7 +206,16 @@ std::string App::render_advertising() { out += tile("ad-contract", "ad-contract-" + std::to_string(slot), "data-ad-contract=\"" + std::to_string(slot) + "\" data-id=\"" + std::to_string(slot) + "\" aria-pressed=\"" + (advertising_selected_ == slot ? "true" : "false") + "\"", art, title, on ? (slot == 14 ? "Aktueller Sponsor" : "Aktueller Sender") : "Platz frei", on ? c.at("name").get() : std::string("Kein Vertrag"), on ? terms(c) : std::string("Anklicken für Angebote"), advertising_selected_ == slot, "four"); } - out += tile("ad-soon", "ad-contract-naming", soon, "advertising.scene.arena", "Namensrecht Stadion", "Neu", "Noch nicht im Spiel", "Dieser Vertrag folgt", false, "four") + ""; + // the stadium's name: free, or sold to a sponsor until the contract ends + Json ground; + if (engine_mode_) try { ground = engine_data_.at("stadium").at("data"); } catch (const std::exception &) {} + if (ground.is_object() && ground.contains("namingOffers")) { + const Json sold = ground.value("namingRights", Json()); + out += tile("ad-naming", "ad-contract-naming", "", "advertising.scene.arena", "Namensrecht Stadion", sold.is_object() ? "Namensgeber" : "Name frei", + ground.value("name", std::string("Stadion")), + sold.is_object() ? ad_cash(std::stoll(sold.at("monthly").value("minor", std::string("0"))) / 100) + " monatlich · noch " + std::to_string(sold.value("monthsLeft", 0)) + " Monate" : std::string("Anklicken für Angebote"), false, "four") + ""; + } else + out += tile("ad-soon", "ad-contract-naming", soon, "advertising.scene.arena", "Namensrecht Stadion", "Neu", "Noch nicht im Spiel", "Dieser Vertrag folgt", false, "four") + ""; } out += ""; if (advertising_selected_ < 0 || advertising_selected_ > 15) return out; diff --git a/src/modern/ui/engine_bridge.hpp b/src/modern/ui/engine_bridge.hpp index fd4b713..f8fa2d5 100644 --- a/src/modern/ui/engine_bridge.hpp +++ b/src/modern/ui/engine_bridge.hpp @@ -32,6 +32,9 @@ 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); +// The manager names his stadium, or sells its name to the sponsor of an offer (read "stadium"). +Json engine_stadium_rename_command(const Json &bundle, const std::string &name, const std::string &request_id); +Json engine_naming_rights_command(const Json &bundle, const std::string &offer, const std::string &request_id); // The manager leaves for one of the clubs interested in him (read "assembly"). Json engine_club_change_command(const Json &bundle, const std::string &team, const std::string &request_id); Json engine_advertising_projection(const Json &bundle); diff --git a/src/modern/ui/engine_commerce.inc b/src/modern/ui/engine_commerce.inc index e8973e5..e0543f8 100644 --- a/src/modern/ui/engine_commerce.inc +++ b/src/modern/ui/engine_commerce.inc @@ -15,6 +15,30 @@ bool App::engine_commerce_action(const std::string &action, Rml::Element *target } if (!action.starts_with("ad-") || menu_ != "advertising") return false; const auto view = engine_advertising_projection(engine_data_); + if (action == "ad-naming" && engine_fresh_ && !engine_busy_) { + Json ground; + try { ground = engine_data_.at("stadium").at("data"); } catch (const std::exception &) { return true; } + const Json sold = ground.value("namingRights", Json()); + if (sold.is_object()) { + message("Das Stadion trägt den Namen " + ground.value("name", std::string()) + ". " + sold.value("sponsor", std::string()) + " zahlt " + engine_price(sold.at("monthly")) + " im Monat, noch " + + std::to_string(sold.value("monthsLeft", 0)) + " Monate. Bis dahin lässt sich der Name nicht ändern."); + popup_title_ = "Namensrecht Stadion"; + return true; + } + std::string body = "
"; + for (const auto &offer : ground.value("namingOffers", Json::array())) { + const std::string id = offer.value("id", std::string()); + body += "
" + esc(offer.value("name", std::string())) + "" + esc(engine_price(offer.at("monthly"))) + " monatlich · " + + std::to_string(offer.value("months", 0) / 12) + (offer.value("months", 0) == 12 ? " Jahr" : " Jahre") + "zusammen " + esc(engine_price(offer.at("total"))) + "
" + + pg_button("naming-accept", "Verkaufen", "primary", "id=\"naming-accept-" + esc(id) + "\" data-id=\"" + esc(id) + "\"") + "
"; + } + body += "
"; + message("Drei Sponsoren wollen dem Stadion ihren Namen geben. Solange der Vertrag läuft, heißt es wie der Sponsor, und du kannst es nicht umbenennen. Heute heißt es " + ground.value("name", std::string("Stadion")) + "."); + popup_title_ = "Namensrecht Stadion"; + popup_close_ = "Abbrechen"; + popup_body_ = body; + return true; + } if (action == "ad-contract" && target) { const int slot = target->GetAttribute("data-id", -1); if (slot < 0 || slot > 15) return true; diff --git a/src/modern/ui/engine_controls.inc b/src/modern/ui/engine_controls.inc index ff2a11d..3da4ae6 100644 --- a/src/modern/ui/engine_controls.inc +++ b/src/modern/ui/engine_controls.inc @@ -481,6 +481,27 @@ void App::engine_event(Rml::Event &event) { const auto action = node->GetAttribute("data-action", ""), id = node->GetAttribute("data-id", ""); if (!popup_.empty()) { if(action=="balance-discard"){engine_balance_action(action,node);return;} + if (action == "naming-accept") { + const std::string offer = id; + std::string name, terms; + try { + for (const auto &row : engine_data_.at("stadium").at("data").at("namingOffers")) + if (row.value("id", std::string()) == offer) { + name = row.value("name", std::string()); + terms = engine_price(row.at("monthly")) + " im Monat für " + std::to_string(row.value("months", 0) / 12) + (row.value("months", 0) == 12 ? " Jahr" : " Jahre"); + } + } catch (const std::exception &) {} + popup_.clear(); reset_popup(); confirm_ = {}; dirty_ = true; + if (name.empty()) return; + confirmation("Den Stadionnamen wirklich verkaufen? Das Stadion heißt dann " + name + " (" + terms + "). Bis zum Vertragsende lässt sich der Name nicht mehr ändern.", [this, offer] { + try { + engine_finance_submit(engine_naming_rights_command(engine_data_, offer, editor::new_id("request:ui-"))); + } catch (const std::exception &e) { message(e.what()); } + }); + popup_title_ = "Namensrecht verkaufen"; + popup_accept_ = "Verkaufen"; + return; + } if (action == "engine-offer-accept") { const auto player = engine_offer_player_; const int index = node->GetAttribute("data-id", -1); diff --git a/src/modern/ui/engine_dto.cpp b/src/modern/ui/engine_dto.cpp index 9854ad1..6436d3b 100644 --- a/src/modern/ui/engine_dto.cpp +++ b/src/modern/ui/engine_dto.cpp @@ -513,6 +513,12 @@ Json engine_environment_projection(const Json &bundle) { } return {{"ok", true}, {"rows", rows}}; } +Json engine_stadium_rename_command(const Json &bundle, const std::string &name, const std::string &request_id) { + return sports_command(bundle, "stadium.rename", {{"name", name}}, request_id); +} +Json engine_naming_rights_command(const Json &bundle, const std::string &offer, const std::string &request_id) { + return sports_command(bundle, "stadium.namingRights", {{"offerId", offer}, {"confirmed", true}}, request_id); +} Json engine_club_change_command(const Json &bundle, const std::string &team, const std::string &request_id) { return sports_command(bundle, "manager.clubChange", {{"teamId", team}, {"confirmed", true}}, request_id); } diff --git a/src/modern/ui/engine_live.cpp b/src/modern/ui/engine_live.cpp index e501d0b..d600c93 100644 --- a/src/modern/ui/engine_live.cpp +++ b/src/modern/ui/engine_live.cpp @@ -329,7 +329,7 @@ Json engine_live_progress(const Json &previous, const Json &state, const Json &b } catch (const std::exception &) {} out["matches"].push_back({{"id", id}, {"home", home}, {"away", away}, {"owners", owners}, {"competition", competition}, - {"attendance", m.value("attendance", Json())}, {"weather", m.value("weather", Json())}, {"capacity", m.value("capacity", Json())}, + {"attendance", m.value("attendance", Json())}, {"weather", m.value("weather", Json())}, {"capacity", m.value("capacity", Json())}, {"stadiumName", m.value("stadiumName", Json())}, {"lineups", m.value("lineups", Json())}}); } if (out.at("owners").empty() || out.at("matches").empty()) return failure("live_no_human_match"); diff --git a/src/modern/ui/engine_stadium.cpp b/src/modern/ui/engine_stadium.cpp index 5d6e996..2a1801e 100644 --- a/src/modern/ui/engine_stadium.cpp +++ b/src/modern/ui/engine_stadium.cpp @@ -118,6 +118,8 @@ Json engine_stadium_projection(const Json &bundle, bool future) { return {{"ok", true}, {"club", d.at("teamId")}, {"name", d.value("name", std::string("Stadion"))}, + {"name_editable", d.value("nameEditable", false)}, + {"naming", d.value("namingRights", Json())}, {"budget", engine_money_minor(bundle.at("desktop").at("data").at("accounts").at("cash"))}, {"blocks", blocks}, {"facilities", facilities}, diff --git a/src/modern/ui/engine_stadium.inc b/src/modern/ui/engine_stadium.inc index 15118c6..e4ec8a2 100644 --- a/src/modern/ui/engine_stadium.inc +++ b/src/modern/ui/engine_stadium.inc @@ -217,6 +217,19 @@ bool App::engine_stadium_action(const std::string &action, Rml::Element *target) refresh(); return true; } + if (action == "stadium-rename" && engine_fresh_ && !engine_busy_) { + Json data; + try { data = engine_data_.at("stadium").at("data"); } catch (const std::exception &) { return true; } + if (!data.value("nameEditable", false)) { message("Der Stadionname ist verkauft und lässt sich bis zum Vertragsende nicht ändern."); return true; } + text_dialog("Wie soll das Stadion heißen? (höchstens 40 Zeichen)", data.value("name", std::string()), [this](const std::string &name) { + try { + engine_finance_submit(engine_stadium_rename_command(engine_data_, name, editor::new_id("request:ui-"))); + } catch (const std::exception &e) { message(e.what()); } + }); + popup_title_ = "Stadion umbenennen"; + popup_accept_ = "Umbenennen"; + return true; + } if (action == "stadium-data") { stadium_view_["view"] = "data"; refresh(); diff --git a/src/modern/ui/live_controls.inc b/src/modern/ui/live_controls.inc index 6144dd0..1421f9f 100644 --- a/src/modern/ui/live_controls.inc +++ b/src/modern/ui/live_controls.inc @@ -48,7 +48,7 @@ bool App::engine_live_open(const Json &recording) { if (at_end && fixture.value("ok", false) && live_.available()) for (auto &match : fixture.at("matches")) for (const auto &known : live_.fixture().at("matches")) - if (known.at("home").at("id") == match.at("home").at("id") && known.contains("capacity") && !match.contains("capacity")) match["capacity"] = known.at("capacity"); + if (known.at("home").at("id") == match.at("home").at("id") && known.contains("capacity") && !match.contains("capacity")) { match["capacity"] = known.at("capacity"); if (known.contains("stadiumName")) match["stadiumName"] = known.at("stadiumName"); } engine_live_at_end_ = false; if (!fixture.value("ok", false) || !(at_end ? live_.follow(fixture) : live_.open(fixture, ""))) { engine_notice_ = "Spieltag gespielt · Der Ticker kann diese Aufzeichnung nicht zeigen (" + diff --git a/src/modern/ui/live_screens.inc b/src/modern/ui/live_screens.inc index ac9349a..66d2e21 100644 --- a/src/modern/ui/live_screens.inc +++ b/src/modern/ui/live_screens.inc @@ -603,7 +603,7 @@ std::string App::live_sheet(const std::string &over) { filling = "von " + number(places) + " Plätzen · " + std::to_string(percent) + " % ausgelastet · "; bar = "
"; } - out += "
" + esc(pg_upper(indoor ? "Halle" : "Stadion")) + "" + esc(crowd) + + out += "
" + esc(pg_upper(indoor ? std::string("Halle") : match->contains("stadiumName") && match->at("stadiumName").is_string() ? match->at("stadiumName").get() : std::string("Stadion"))) + "" + esc(crowd) + "" + bar + "" + esc(filling + "Heimspiel von " + match->at("home").at("name").get()) + "
"; const auto weather = match->value("weather", Json()); if (!indoor && weather.is_object()) { diff --git a/src/modern/ui/stadium_screens.inc b/src/modern/ui/stadium_screens.inc index 6fd299a..767a48a 100644 --- a/src/modern/ui/stadium_screens.inc +++ b/src/modern/ui/stadium_screens.inc @@ -87,7 +87,9 @@ std::string App::render_stadium() { const bool outer=view=="panorama"; const auto ground=overview.at("name").get(); page_title_=outer?"Peripherie – "+ground:ground+" – "+number(overview.at("capacity").get())+" Plätze"; - page_hint_=view=="data"?"Stadiondaten":std::string(outer?"ein Gebäude anklicken":"ein Bauteil anklicken")+(future?(outer?" · Stand nach Fertigstellung":" · geplante Kapazität"):""); + const std::string naming_hint=engine_mode_&&overview.value("naming",Json()).is_object()?" · Namensrecht: "+overview.at("naming").value("sponsor",std::string())+", noch "+std::to_string(overview.at("naming").value("monthsLeft",0))+" Monate":std::string(); + page_hint_=naming_hint.empty()?std::string():naming_hint.substr(4); + if(naming_hint.empty())page_hint_=view=="data"?"Stadiondaten":std::string(outer?"ein Gebäude anklicken":"ein Bauteil anklicken")+(future?(outer?" · Stand nach Fertigstellung":" · geplante Kapazität"):""); if(view=="data"){stadium_seen_="data";stadium_flying_=false;return render_stadium_data()+render_stadium_dialog();} // over the gate stands the first word of the ground's name auto sign=pg_upper(ground.substr(0,ground.find_first_of(" -"))); @@ -203,6 +205,8 @@ std::string App::render_stadium() { out+=btn("stadium-future",""+std::string(i?"Zukunft":"Aktuell")+"",std::string(i?"":"first ")+(on?"on":""),on?std::string("style=\"pointer-events:none;\" aria-pressed=\"true\""):std::string("id=\"stadium-future\" aria-pressed=\"false\"")); } out+="
"+pg_button("stadium-data","Stadion-Daten","","id=\"stadium-data\""); + // the name is the manager's to choose until he sells it to a sponsor + if(engine_mode_)out+=pg_button("stadium-rename","Stadion umbenennen","","id=\"stadium-rename\" "+std::string(overview.value("name_editable",false)?"":"disabled=\"disabled\" title=\"Der Name ist an einen Sponsor verkauft\"")); } out+=pg_button("stadium-reset","Ansicht zurücksetzen","","id=\"stadium-reset\"")+""+pg_status("Mausrad zoomt · Ziehen verschiebt die Ansicht"); return out+""+render_stadium_dialog(); diff --git a/tests/modern_naming_tests.cpp b/tests/modern_naming_tests.cpp new file mode 100644 index 0000000..cedc7ae --- /dev/null +++ b/tests/modern_naming_tests.cpp @@ -0,0 +1,93 @@ +// SPDX-License-Identifier: GPL-3.0-only +// The stadium's name and its naming rights (docs/new_engine/namensrecht.md) on a synthetic +// manager: renaming, the three offers, the sale, the monthly payment and the end of the contract. +#include +#include + +#include "modern/game/naming_rights.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; + } +} +int32_t cash(const ModernState& g) { + return int32_t(uint32_t(g.manager_records[0x314]) | uint32_t(g.manager_records[0x315]) << 8 | uint32_t(g.manager_records[0x316]) << 16 | + uint32_t(g.manager_records[0x317]) << 24); +} +// Manager 0 runs club 0 of the first league with a stadium of 24 000 places. +ModernState world() { + ModernState g; + g.career_id = "career:test"; + g.level = 2; + g.manager_teams = {0}; + g.manager_records.assign(5 * 0xb0c, 0); + for (size_t block = 0; block < 8; ++block) g.manager_records[0x4c + block] = 3; + g.manager_records[0x211] = 50; + g.manager_records[0x314] = 0x40, g.manager_records[0x315] = 0x42, g.manager_records[0x316] = 0x0f; // 1 000 000 + return g; +} +} // namespace + +int main() { + { + ModernState g = world(); + check(stadium_entry(g, 0) == nullptr && !naming_rights_sold(g, 0), "no entry before the manager names anything"); + check(rename_stadium(g, 0, " Waldstadion ") && stadium_entry(g, 0)->name == "Waldstadion", "the name is trimmed and kept"); + check(!rename_stadium(g, 0, " ") && !rename_stadium(g, 0, std::string(41, 'x')) && !rename_stadium(g, 0, "a\nb") && + stadium_entry(g, 0)->name == "Waldstadion", + "an empty, too long or broken name is refused and changes nothing"); + check(!rename_stadium(g, 1, "Nordpark"), "no stadium without a manager"); + } + { + ModernState g = world(); + const auto offers = naming_offers(g, 0); + std::set sponsors; + bool sound = offers.size() == 3; + for (const NamingOffer& o : offers) + sound = sound && o.sponsor <= 9 && sponsors.insert(o.sponsor).second && o.months >= 12 && o.months <= 60 && o.months % 12 == 0 && + o.monthly >= 1000 && o.monthly % 1000 == 0; + check(sound, "three offers of different sponsors for one to five years"); + // 24 000 places at 36 euros a year: 72 000 a month before the factors (0.8-1.25 times prestige 1.0) + bool in_range = true; + for (const NamingOffer& o : offers) in_range = in_range && o.monthly >= 45000 && o.monthly <= 90000; + check(in_range, "the payment follows the places and the league"); + const auto again = naming_offers(g, 0); + bool same = again.size() == offers.size(); + for (size_t i = 0; same && i < offers.size(); ++i) + same = again[i].sponsor == offers[i].sponsor && again[i].monthly == offers[i].monthly && again[i].months == offers[i].months; + check(same, "reading the offers does not change them"); + + ModernState lower = world(); + lower.manager_teams = {60}; + check(naming_offers(lower, 0).front().monthly < offers.front().monthly / 2, "a lower league pays much less"); + + check(!sell_naming_rights(g, 0, 3) && !naming_rights_sold(g, 0), "an offer that does not exist is refused"); + rename_stadium(g, 0, "Waldstadion"); + const NamingOffer taken = offers[1]; + check(sell_naming_rights(g, 0, 1) && naming_rights_sold(g, 0) && stadium_entry(g, 0)->sponsor == taken.sponsor && + stadium_entry(g, 0)->monthly == taken.monthly && stadium_entry(g, 0)->months == taken.months, + "the sale notes sponsor, payment and term"); + check(!rename_stadium(g, 0, "Nordpark") && stadium_entry(g, 0)->name == "Waldstadion", "a sold name cannot be changed"); + check(naming_offers(g, 0).empty() && !sell_naming_rights(g, 0, 0), "no second sale while the contract runs"); + + const int32_t before = cash(g); + naming_rights_month(g); + check(cash(g) == before + int32_t(taken.monthly) && stadium_entry(g, 0)->months == taken.months - 1, "the sponsor pays with the month change"); + for (int month = 1; month < taken.months; ++month) naming_rights_month(g); + check(cash(g) == before + int32_t(taken.monthly) * taken.months, "he pays every month of the term"); + check(!naming_rights_sold(g, 0) && stadium_entry(g, 0)->name == "Waldstadion" && rename_stadium(g, 0, "Nordpark") && naming_offers(g, 0).size() == 3, + "after the last month the stadium has its own name again and can be renamed or sold"); + naming_rights_month(g); + check(cash(g) == before + int32_t(taken.monthly) * taken.months, "nothing is paid without a contract"); + } + if (failures) return 1; + std::puts("modern_naming_tests: ok"); + return 0; +} diff --git a/tests/modern_ui_contract_tests.cpp b/tests/modern_ui_contract_tests.cpp index 3d799ee..3ebd30b 100644 --- a/tests/modern_ui_contract_tests.cpp +++ b/tests/modern_ui_contract_tests.cpp @@ -980,6 +980,29 @@ int main(int argc, char** argv) { const J curves = session.read_statistics_screen(O{{"section", 2}}); check(!club_desk || (at(curves, "series").array() && at(curves, "series").array()->size() == 6), "the six curves of the original"); } + // the stadium's name and its naming rights + { + const auto ground = [&] { return at(session.ui_read(O{{"kind", "stadium"}}, rev), "data"); }; + const J first = ground(); + if (first.object() && at(first, "namingOffers").array()) { + check(truth(at(first, "nameEditable")) && at(first, "namingOffers").array()->size() == 3 && std::holds_alternative(at(first, "namingRights").value), + "stadium: the name is free, three sponsors offer"); + const uint64_t n0 = rev; + check(s(at(session.ui_command(cmd("request:n1", "stadium.rename", O{{"name", " "}}), rev), "code")) == "invalid_name" && rev == n0, "an empty stadium name is refused"); + const J renamed = session.ui_command(cmd("request:n2", "stadium.rename", O{{"name", "Waldstadion"}}), rev); + check(s(at(renamed, "messageType")) == "command_result" && rev == n0 + 1 && s(at(ground(), "name")) == "Waldstadion", "the stadium is renamed"); + const std::string offer = s(at(at(ground(), "namingOffers").array()->front(), "id")); + check(s(at(session.ui_command(cmd("request:n3", "stadium.namingRights", O{{"offerId", offer}}), rev), "code")) == "confirmation_required", "selling the name needs the confirmation"); + const J sold = session.ui_command(cmd("request:n4", "stadium.namingRights", O{{"offerId", offer}, {"confirmed", true}}), rev); + const J after = ground(); + check(s(at(sold, "messageType")) == "command_result" && rev == n0 + 2 && !truth(at(after, "nameEditable")) && at(after, "namingRights").object() && + at(after, "namingOffers").array()->empty() && s(at(after, "name")) != "Waldstadion", + "the name is sold: the sponsor's arena, no further offers"); + check(s(at(session.ui_command(cmd("request:n5", "stadium.rename", O{{"name", "Nordpark"}}), rev), "code")) == "name_sold" && + s(at(session.ui_command(cmd("request:n6", "stadium.namingRights", O{{"offerId", offer}, {"confirmed", true}}), rev), "code")) == "name_sold", + "a sold name can be neither changed nor sold again"); + } + } // the annual general meeting and the interested clubs: the read, then a change of club { const J meeting = at(session.ui_read(O{{"kind", "assembly"}}, rev), "data");