From 0aa0ed68ca91c0582c68e2f34a65dbb9f11d1187 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 24 Oct 2026 11:06:57 +0200 Subject: [PATCH] Toto with up to six columns (Modern) Each column costs the stake (10,000-400,000) and is settled on its own with the original quotas; all columns stake 400,000 at most, every column beyond the first adds a 10 % fee, no two columns alike. Column 1 stays on the original coupon; columns 2-6 and the last settlement live in ModernState::pools and are saved. Session action dispatch_pools_columns, read query {kind: "toto"}, unit test modern_toto_tests, SIM_TOTO= in the season sim. Measured over two seasons: 1 column returns 30-71 %, 6 columns 12-49 % of the stakes; more columns win more often, never on average. Co-Authored-By: Claude Opus 5.5 --- CMakeLists.txt | 3 ++ docs/DIFFERENCES.md | 1 + docs/new_engine/toto.md | 37 +++++++++++++++ docs/new_engine/ui-abfragen.md | 1 + src/modern/app/modern_session.cpp | 22 ++++++++- src/modern/app/modern_session.hpp | 5 ++ src/modern/content/projections.cpp | 46 +++++++++++++++++++ src/modern/content/world_save.cpp | 41 ++++++++++++++++- src/modern/game/desk_actions.cpp | 23 ++++++++++ src/modern/game/desk_actions.hpp | 14 ++++++ src/modern/game/matchday_setup.cpp | 32 ++++++++++--- src/modern/game/modern_state.hpp | 11 +++++ tests/modern_season_sim.cpp | 57 ++++++++++++++++++++++- tests/modern_toto_tests.cpp | 74 ++++++++++++++++++++++++++++++ 14 files changed, 357 insertions(+), 10 deletions(-) create mode 100644 docs/new_engine/toto.md create mode 100644 tests/modern_toto_tests.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 82adaaf..cf75f7d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1172,6 +1172,9 @@ add_test(NAME modern_camp_tests COMMAND modern_camp_tests) add_executable(modern_almanac_tests tests/modern_almanac_tests.cpp) target_link_libraries(modern_almanac_tests PRIVATE bmh_season_modern) add_test(NAME modern_almanac_tests COMMAND modern_almanac_tests) +add_executable(modern_toto_tests tests/modern_toto_tests.cpp) +target_link_libraries(modern_toto_tests PRIVATE bmh_season_modern) +add_test(NAME modern_toto_tests COMMAND modern_toto_tests) add_executable(modern_calendar_tests tests/modern_calendar_tests.cpp) target_link_libraries(modern_calendar_tests PRIVATE bmh_season_modern) diff --git a/docs/DIFFERENCES.md b/docs/DIFFERENCES.md index 7e92d63..a6deb8c 100644 --- a/docs/DIFFERENCES.md +++ b/docs/DIFFERENCES.md @@ -36,6 +36,7 @@ describe deliberate changes; they are not a list of every known compatibility li - [src/modern/game/career.hpp](../src/modern/game/career.hpp): uses the supported player-generation ranges and excludes reserved calendar positions when assigning managers. - [src/modern/game/desk_actions.cpp](../src/modern/game/desk_actions.cpp): uses the supported transfer-fee arithmetic and designated set-piece fields. - [src/modern/game/desk_actions.cpp](../src/modern/game/desk_actions.cpp): Modern training camps have grades up to six stars with a capped step, a higher limit and recovery extras. +- [src/modern/game/desk_actions.cpp](../src/modern/game/desk_actions.cpp): the Modern Toto takes up to six columns (one in the original), each at the stake plus a 10 % fee per extra column, 400,000 at most in all. - [src/modern/game/desk_actions.hpp](../src/modern/game/desk_actions.hpp): supports designated set-piece records and the supported transfer-editor rules. - [src/modern/game/environment.hpp](../src/modern/game/environment.hpp): uses six monthly environment budgets across data editions while retaining the shared staff prices and academy player-generation strength bands. - [src/modern/game/highscore.cpp](../src/modern/game/highscore.cpp): reads the supported edition-specific high-score format from the loaded image. diff --git a/docs/new_engine/toto.md b/docs/new_engine/toto.md new file mode 100644 index 0000000..6515776 --- /dev/null +++ b/docs/new_engine/toto.md @@ -0,0 +1,37 @@ +# Toto mit mehreren Spalten (Modern) + +Michaels Wunsch: Man kann mehr als eine Spalte spielen (bis zu 6); die Regel soll das Gewinnen nicht zu einfach machen. Regel abgestimmt am 24.10.2026. + +## Original (Classic, unverändert) + +- Ein Tippschein mit 11 Spielen zwischen etwa gleich starken Vereinen, je Spiel 1 (Heimsieg), 0 (Unentschieden) oder 2 (Auswärtssieg). +- Einsatz 10.000–400.000 €, abgebucht am Ende des Spieltags. +- Feste Quoten auf den Einsatz: 9 Richtige ×10, 10 Richtige ×20, 11 Richtige ×50. + +## Modern + +1. Bis zu **6 Spalten**; jede Spalte kostet den Einsatz und wird einzeln mit den Original-Quoten ausgewertet. +2. Einsatz **je Spalte** 10.000–400.000 €, alle Spalten zusammen höchstens **400.000 €**. +3. Jede Spalte ab der zweiten kostet **10 % ihres Einsatzes** als Bearbeitungsgebühr. +4. **Keine zwei gleichen Spalten.** +5. Kosten: `Einsatz × Spalten + Einsatz / 10 × (Spalten − 1)` (`pools_cost`). Reicht das Geld nicht, gilt der ganze Tippschein als nicht abgegeben (Meldung wie im Original). + +Warum das nicht zu leicht ist: Die Quoten sind fest, also bringt jede Spalte für sich denselben Erwartungswert, egal wie die Spalten zusammenhängen. Mehr Spalten erhöhen nur die Chance auf irgendeinen Gewinn, nicht den Rückfluss; die Gebühr macht das Absichern über mehrere Spalten zusätzlich teurer. + +**Messung** (`SIM_TOTO= SIM_CONTRACTS=1 SIM_ADVERTISING=1 modern_season_sim 100 0 `, zwei Saisons, 400.000 € je Spieltag, Tipp: der stärkere Verein gewinnt, Zusatzspalten tippen je ein Unentschieden): + +| Spalten | Rückfluss (Seeds 1, 2) | Spalten mit 9+ Richtigen je Tippschein | +|---|---|---| +| 1 | 30 % / 71 % | etwa 3–5 % | +| 3 | 30 % / 64 % | etwa 3–4 % je Spalte, 7–10 % je Tippschein | +| 6 | 12 % / 49 % | etwa 8–18 % je Tippschein | + +Toto bleibt im Schnitt ein Verlustgeschäft; mit mehr Spalten gewinnt man öfter etwas, aber nicht mehr. + +## Umsetzung + +- Spalte 1 liegt im Original-Tippschein (`Coupon + Manager × 0x14`), damit alle bestehenden Abläufe unverändert bleiben; die Spalten 2–6 und die letzte Abrechnung (Treffer je Spalte, bezahlt, gewonnen) in `ModernState::pools`, gespeichert in `state/modern.json` (`pools`). +- Abgabe: `submit_pools_columns` (`desk_actions.hpp`), in der Session `dispatch_pools_columns(manager, stake, columns, revision, error)`; Fehler `too_many_columns`, `stake_out_of_range`, `total_stake_too_high`, `duplicate_column`, `toto_coupon_requires_eleven_matches`, `invalid_toto_coupon`. Die alte Einspalten-Aktion (`dispatch_toto`) verwirft frühere Zusatzspalten. +- Abrechnung: `settle_pools_coupon` (`matchday_setup.cpp`). +- Lesen: `{kind: "toto"}` über `ModernSession::read` ([UI-Abfragen](ui-abfragen.md)): `open`, `matches [{home, away}]`, `stake`, `cost`, `columns`, `rules`, `last {paid, won, hits}`. +- Tests: `modern_toto_tests` (Regeln, Kosten); Spielstand-Rundreise im Sim prüft die Spalten mit. diff --git a/docs/new_engine/ui-abfragen.md b/docs/new_engine/ui-abfragen.md index 90aba35..68509d6 100644 --- a/docs/new_engine/ui-abfragen.md +++ b/docs/new_engine/ui-abfragen.md @@ -23,6 +23,7 @@ Michaels Entscheidung: Die neue Oberfläche wird **je Menü** an die Modern-Engi | `{kind: "leagues"}` | `leagues: [{index, id, name, clubs, matchdays, played}]` | | `{kind: "table", league}` | `league`, `played`, `rows: [{rank, club, played, won, drawn, lost, goals_for, goals_against, points}]` (aktueller Stand, mit Punktabzug) | | `{kind: "fixtures", league, matchday?}` | `league`, `matchday`, `matches: [{home, away, result: [h, a] \| null, status: open \| played \| postponed}]`; ohne `matchday` der nächste | +| `{kind: "toto"}` | Tippschein des Spieltags und eigene Spalten, siehe [Toto](toto.md) | | `{kind: "squad", club?}` | `club`, `players: [{slot, player, nation, position (gk/def/mid/fwd), age, technique, condition, form, strength, skills {teamplay, speed, shooting, passing, tackling, free_kick, corner}, lineup (start/bench/none), injured_weeks, banned_weeks}]`; ohne `club` der eigene Verein, sonst Welt-ID oder Laufzeitindex | | `competitions`, `winners`, `player_stats` | siehe [Spielstatistik](statistik.md) | diff --git a/src/modern/app/modern_session.cpp b/src/modern/app/modern_session.cpp index 2ad2b76..bf6e758 100644 --- a/src/modern/app/modern_session.cpp +++ b/src/modern/app/modern_session.cpp @@ -8582,13 +8582,33 @@ bool ModernSession::dispatch_toto(const ui::TotoRequest& request, uint64_t& revi error = "stale_manager_or_revision"; return false; } if (g_.memory.u8(::bmh::layout::CareerSession_DispatchToto_RuntimeField) != 11) { error = "toto_coupon_requires_eleven_matches"; return false; } - if (!modern::submit_pools_coupon(g_, request.manager_slot, request.stake, request.tips)) { + // one column: the original coupon; earlier extra columns of this manager are dropped + if (modern::submit_pools_columns(g_, request.manager_slot, request.stake, {request.tips}) != PoolsColumnsResult::ok) { error = "invalid_toto_coupon"; return false; } ++revision; return true; } +bool ModernSession::dispatch_pools_columns(int manager, uint32_t stake, const std::vector>& columns, + uint64_t& revision, std::string& error) { + const int active = int(g_.memory.u8(::bmh::layout::ActiveManager)); + if (manager != active || manager < 0 || size_t(manager) >= g_.manager_teams.size()) { + error = "stale_manager_or_revision"; return false; + } + if (g_.memory.u8(::bmh::layout::CareerSession_DispatchToto_RuntimeField) != 11) { error = "toto_coupon_requires_eleven_matches"; return false; } + switch (modern::submit_pools_columns(g_, manager, stake, columns)) { + case PoolsColumnsResult::ok: ++revision; return true; + case PoolsColumnsResult::too_many_columns: error = "too_many_columns"; return false; + case PoolsColumnsResult::stake_out_of_range: error = "stake_out_of_range"; return false; + case PoolsColumnsResult::total_too_high: error = "total_stake_too_high"; return false; + case PoolsColumnsResult::duplicate_column: error = "duplicate_column"; return false; + case PoolsColumnsResult::invalid: break; + } + error = "invalid_toto_coupon"; + return false; +} + } // namespace bmh::modern::app namespace bmh::modern::app { diff --git a/src/modern/app/modern_session.hpp b/src/modern/app/modern_session.hpp index a76c80b..6c2e3f9 100644 --- a/src/modern/app/modern_session.hpp +++ b/src/modern/app/modern_session.hpp @@ -601,6 +601,11 @@ public: } bool stadium_tip_deadline_expired() const; bool dispatch_toto(const ui::TotoRequest&, uint64_t& revision, std::string& error); + // Modern Toto with up to six columns for the manager at the desk (docs/new_engine/toto.md). + // Errors: too_many_columns, stake_out_of_range, total_stake_too_high, duplicate_column, + // toto_coupon_requires_eleven_matches, invalid_toto_coupon, stale_manager_or_revision. + bool dispatch_pools_columns(int manager, uint32_t stake, const std::vector>& columns, + uint64_t& revision, std::string& error); bool dispatch_tactics(const ui::TacticsRequest&, uint64_t& revision, std::string& error); bool dispatch_lineup(const ui::LineupRequest&, uint64_t& revision, std::string& error); // Source PitchScreen live-match path: apply one user-picked field/bench diff --git a/src/modern/content/projections.cpp b/src/modern/content/projections.cpp index 3a57258..95b3964 100644 --- a/src/modern/content/projections.cpp +++ b/src/modern/content/projections.cpp @@ -10,7 +10,9 @@ #include "game/schedule.hpp" #include "game/table.hpp" #include "modern/content/statistics.hpp" +#include "formats/executable_layout.hpp" #include "modern/game/almanac.hpp" +#include "modern/game/desk_actions.hpp" #include "modern/game/matchday.hpp" namespace bmh::modern { @@ -201,6 +203,49 @@ J squad(const ModernState& g, int team) { return O{{"ok", true}, {"club", club_json(g, team)}, {"players", std::move(players)}}; } +// The Toto coupon of the matchday and the manager's columns (docs/new_engine/toto.md). +J toto(const ModernState& g, int manager) { + if (manager < 0 || size_t(manager) >= g.manager_teams.size()) return error("invalid_manager"); + const StaticMemory& mem = g.memory; + const uint32_t matches_at = ::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField; + const int count = mem.has(::bmh::layout::CareerSession_DispatchToto_RuntimeField) ? mem.u8(::bmh::layout::CareerSession_DispatchToto_RuntimeField) : 0; + A matches; + for (int k = 0; k < count && k < 11 && mem.has(matches_at + uint32_t(k) * 4 + 3); ++k) + matches.push_back(O{{"home", club_json(g, mem.u16(matches_at + uint32_t(k) * 4))}, + {"away", club_json(g, mem.u16(matches_at + uint32_t(k) * 4 + 2))}}); + const uint32_t at = ::bmh::layout::Coupon + uint32_t(manager) * 0x14; + uint32_t stake = 0; + A columns; + if (mem.has(at + 0x13)) { + stake = mem.u32(at) & 0x7fffffff; + if (stake != 0) { + A first; + for (uint32_t i = 0; i < 11; ++i) first.push_back(int(mem.u8(at + 8 + i))); + columns.push_back(std::move(first)); + if (size_t(manager) < g.pools.size()) + for (const auto& column : g.pools[size_t(manager)].extra) { + A tips; + for (uint8_t t : column) tips.push_back(int(t)); + columns.push_back(std::move(tips)); + } + } + } + const int64_t cost = int64_t(pools_cost(stake, columns.size())); + O last{{"paid", 0}, {"won", 0}, {"hits", A{}}}; + if (size_t(manager) < g.pools.size()) { + const auto& p = g.pools[size_t(manager)]; + A hits; + for (uint8_t h : p.hits) hits.push_back(int(h)); + last = O{{"paid", int64_t(p.paid)}, {"won", int64_t(p.won)}, {"hits", std::move(hits)}}; + } + return O{{"ok", true}, {"open", count == 11}, {"matches", std::move(matches)}, {"stake", int64_t(stake)}, + {"cost", cost}, {"columns", std::move(columns)}, + {"rules", O{{"max_columns", kPoolsMaxColumns}, {"stake_min", 10000}, {"stake_max", 400000}, + {"total_max", int64_t(kPoolsMaxTotalStake)}, {"extra_column_fee_percent", 10}, + {"quota", O{{"9", 10}, {"10", 20}, {"11", 50}}}}}, + {"last", std::move(last)}}; +} + } // namespace cli::Json query_projection(const ModernState& g, int manager, const cli::Json& request) { @@ -209,6 +254,7 @@ cli::Json query_projection(const ModernState& g, int manager, const cli::Json& r const std::string& k = *kind->string(); try { if (k == "status") return status(g, manager); + if (k == "toto") return toto(g, manager); if (k == "leagues") return leagues(g); if (k == "table" || k == "fixtures") { const int league = league_of_request(g, field(request, "league")); diff --git a/src/modern/content/world_save.cpp b/src/modern/content/world_save.cpp index 5cfcd4c..90cda8c 100644 --- a/src/modern/content/world_save.cpp +++ b/src/modern/content/world_save.cpp @@ -44,6 +44,43 @@ std::vector strings(const J& value) { } std::string world_identity(const World& world) { return world.id + "@" + world.data_revision; } +// The Toto columns 2-6 and the last settlement per manager (docs/new_engine/toto.md). +J pools_json(const std::vector& pools) { + A out; + for (const auto& p : pools) { + A extra, hits; + for (const auto& column : p.extra) { + A tips; + for (uint8_t t : column) tips.push_back(int(t)); + extra.push_back(std::move(tips)); + } + for (uint8_t h : p.hits) hits.push_back(int(h)); + out.push_back(O{{"extra", std::move(extra)}, {"hits", std::move(hits)}, {"paid", int64_t(p.paid)}, {"won", int64_t(p.won)}}); + } + return out; +} +std::vector pools_json(const J& value) { + std::vector out; + for (const J& row : arr(value)) { + ModernState::PoolsColumns p; + for (const J& column : arr(get(row, "extra"))) { + const A& tips = arr(column); + if (tips.size() != 11) fail("invalid Toto column"); + std::array c{}; + for (size_t i = 0; i < 11; ++i) { + const int64_t t = num(tips[i]); + if (t < 0 || t > 2) fail("invalid Toto tip"); + c[i] = uint8_t(t); + } + p.extra.push_back(c); + } + for (const J& h : arr(get(row, "hits"))) p.hits.push_back(uint8_t(num(h))); + p.paid = uint32_t(num(get(row, "paid"))), p.won = uint32_t(num(get(row, "won"))); + out.push_back(std::move(p)); + } + return out; +} + } // namespace void save_world_career(const std::filesystem::path& path, const World& world, const ModernState& state, @@ -69,7 +106,8 @@ void save_world_career(const std::filesystem::path& path, const World& world, co {"player_nations", strings(state.player_nation)}, {"league_ids", strings(state.world_league_id)}, {"league_names", strings(state.world_league_name)}, - {"generated_players", int64_t(state.almanac.generated_players)}}); + {"generated_players", int64_t(state.almanac.generated_players)}, + {"pools", pools_json(state.pools)}}); // 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); @@ -117,6 +155,7 @@ SavedWorldCareer load_world_career(const std::filesystem::path& path, const Worl out.state.world_league_id = strings(get(modern, "league_ids")); out.state.world_league_name = strings(get(modern, "league_names")); out.state.almanac.generated_players = uint32_t(num(get(modern, "generated_players"))); + out.state.pools = pools_json(get(modern, "pools")); for (const auto& [name, bytes] : docs) { if (!name.starts_with("history/season-")) continue; decode_almanac_season(bytes); // a damaged season fails here, not in the almanac screen diff --git a/src/modern/game/desk_actions.cpp b/src/modern/game/desk_actions.cpp index a5df645..f049e1a 100644 --- a/src/modern/game/desk_actions.cpp +++ b/src/modern/game/desk_actions.cpp @@ -1867,6 +1867,29 @@ bool submit_pools_coupon(ModernState& g, int manager, uint32_t stake, return true; } +// OpenBMH deviates from the original: the Modern Toto takes up to six columns (one in the original), each at the stake plus a 10 % fee per extra column, 400,000 at most in all. +PoolsColumnsResult submit_pools_columns(ModernState& g, int manager, uint32_t stake, + const std::vector>& columns) { + if (manager < 0 || size_t(manager) >= g.manager_teams.size()) return PoolsColumnsResult::invalid; + if (g.pools.size() < g.manager_teams.size()) g.pools.resize(g.manager_teams.size()); + if (stake == 0) { // clears the coupon + if (!modern::submit_pools_coupon(g, manager, 0, columns.empty() ? std::array{} : columns[0])) + return PoolsColumnsResult::invalid; + g.pools[size_t(manager)].extra.clear(); + return PoolsColumnsResult::ok; + } + if (columns.empty()) return PoolsColumnsResult::invalid; + if (columns.size() > size_t(kPoolsMaxColumns)) return PoolsColumnsResult::too_many_columns; + if (stake < 10'000 || stake > 400'000) return PoolsColumnsResult::stake_out_of_range; + if (uint64_t(stake) * columns.size() > kPoolsMaxTotalStake) return PoolsColumnsResult::total_too_high; + for (size_t a = 0; a < columns.size(); ++a) + for (size_t b = a + 1; b < columns.size(); ++b) + if (columns[a] == columns[b]) return PoolsColumnsResult::duplicate_column; + if (!modern::submit_pools_coupon(g, manager, stake, columns[0])) return PoolsColumnsResult::invalid; + g.pools[size_t(manager)].extra.assign(columns.begin() + 1, columns.end()); + return PoolsColumnsResult::ok; +} + } // namespace bmh::modern namespace bmh::modern { diff --git a/src/modern/game/desk_actions.hpp b/src/modern/game/desk_actions.hpp index 911fd0f..2407ec7 100644 --- a/src/modern/game/desk_actions.hpp +++ b/src/modern/game/desk_actions.hpp @@ -270,6 +270,20 @@ bool build_stadium_investment_source(ModernState&, int manager, StadiumInvestmen bool submit_pools_coupon(ModernState& g, int manager, uint32_t stake, const std::array& tips); +// Modern Toto with up to six columns (docs/new_engine/toto.md): each column costs the stake +// (10,000-400,000) and is settled on its own with the original quotas; all columns together +// stake at most 400,000; every column beyond the first adds a fee of 10 % of the stake; no two +// columns alike. Column 1 goes to the original coupon. A stake of 0 clears every column. +constexpr int kPoolsMaxColumns = 6; +constexpr uint32_t kPoolsMaxTotalStake = 400'000; +enum class PoolsColumnsResult { ok, invalid, too_many_columns, stake_out_of_range, total_too_high, duplicate_column }; +PoolsColumnsResult submit_pools_columns(ModernState& g, int manager, uint32_t stake, + const std::vector>& columns); +// What a coupon of `columns` columns costs at `stake` per column (stakes plus fee). +inline uint32_t pools_cost(uint32_t stake, size_t columns) { + return columns == 0 ? 0 : uint32_t(stake * columns + stake / 10 * (columns - 1)); +} + } // namespace bmh::modern namespace bmh::modern { diff --git a/src/modern/game/matchday_setup.cpp b/src/modern/game/matchday_setup.cpp index 398ca64..fdc0c32 100644 --- a/src/modern/game/matchday_setup.cpp +++ b/src/modern/game/matchday_setup.cpp @@ -19,6 +19,7 @@ #include "game/schedule.hpp" #include "game/messages.hpp" #include "game/table.hpp" +#include "modern/game/desk_actions.hpp" #include "modern/game/weekly.hpp" namespace bmh::modern { @@ -1216,24 +1217,41 @@ void settle_pools_coupon(ModernState& g, const std::vector& groups) if (mem.has(::bmh::layout::CareerSession_DispatchToto_RuntimeField)) mem.set8(::bmh::layout::CareerSession_DispatchToto_RuntimeField, uint8_t(k)); if (k <= 10) return; static constexpr uint8_t kQuota[12] = {11, 10, 0, 20, 11, 10, 0, 1, 0, 10, 20, 50}; // MatchdaySetupRuntimeField13 + if (g.pools.size() < g.manager_teams.size()) g.pools.resize(g.manager_teams.size()); for (size_t m = 0; m < g.manager_teams.size(); m++) { const uint32_t at = ::bmh::layout::Coupon + uint32_t(m) * 0x14; - if (mem.u8(at + 3) & 0x80) mem.set32(at, 0); + auto& extra = g.pools[m].extra; + if (mem.u8(at + 3) & 0x80) mem.set32(at, 0), extra.clear(); const uint32_t stake = mem.u32(at); if ((stake & 0x7fffffff) == 0) continue; - if (!modern::book_money(g, int(m), int32_t(stake), false, true)) { + // Modern: every column costs the stake, every one beyond the first 10 % more + // (docs/new_engine/toto.md); with one column this is the original booking. + const uint32_t cost = pools_cost(stake, 1 + extra.size()); + if (!modern::book_money(g, int(m), int32_t(cost), false, true)) { post_composed(g, int(m), message_text(g, ::bmh::layout::MatchdaySetup_SettlePoolsCoupon_TextPointer)); } else { - int hits = 0; - for (uint32_t i = 0; i < 0xb; i++) - if (mem.u8(at + 8 + i) == mem.u8(::bmh::layout::MatchdaySetup_EvaluatePoolsCoupon_RuntimeField + i)) hits++; - uint32_t win = 0; - if (hits > 8) win = stake * kQuota[hits]; + auto hits_of = [&](auto tip) { + int hits = 0; + for (uint32_t i = 0; i < 0xb; i++) + if (tip(i) == mem.u8(::bmh::layout::MatchdaySetup_EvaluatePoolsCoupon_RuntimeField + i)) hits++; + return hits; + }; + const int hits = hits_of([&](uint32_t i) { return mem.u8(at + 8 + i); }); + uint32_t win = hits > 8 ? stake * kQuota[hits] : 0; + std::vector column_hits{uint8_t(hits)}; + for (const auto& column : extra) { + const int h = hits_of([&](uint32_t i) { return column[i]; }); + column_hits.push_back(uint8_t(h)); + if (h > 8) win += stake * kQuota[h]; + } mem.set32(at + 4, win); mem.set8(at + 0x13, uint8_t(hits)); + g.pools[m].hits = std::move(column_hits); + g.pools[m].paid = cost, g.pools[m].won = win; modern::book_money(g, int(m), -int32_t(win), true, true); } mem.set32(at, 0); // (also clears the "settled" bit 7 of byte 3 just set) + extra.clear(); } } diff --git a/src/modern/game/modern_state.hpp b/src/modern/game/modern_state.hpp index b1a4e3d..5952891 100644 --- a/src/modern/game/modern_state.hpp +++ b/src/modern/game/modern_state.hpp @@ -8,7 +8,9 @@ // always prefers the Modern season function over a Classic one of the same name. // Modern-only data (world layout, UTF-8 names, ...) is added here, never to GameState. +#include #include +#include #include #include #include @@ -52,6 +54,15 @@ struct ModernState : GameState { std::vector training_camps; // The football almanac (docs/new_engine/almanach.md): every match of the career. Almanac almanac; + // Toto with up to six columns (docs/new_engine/toto.md), per manager. Column 1 is the + // original coupon (Coupon + manager * 0x14); columns 2-6 and the last settlement live here. + struct PoolsColumns { + std::vector> extra; // columns 2-6, tips 1 home, 0 draw, 2 away + std::vector hits; // hits per column of the last settlement + uint32_t paid = 0, won = 0; // stakes and fee, winnings of the last settlement + bool operator==(const PoolsColumns&) const = default; + }; + std::vector pools; // Players whose age the data set gives (birth date); the others carry a placeholder the // career start replaces as in the original. Needed only while a career starts (not saved). std::vector world_age_known; diff --git a/tests/modern_season_sim.cpp b/tests/modern_season_sim.cpp index 40e536c..5f30c66 100644 --- a/tests/modern_season_sim.cpp +++ b/tests/modern_season_sim.cpp @@ -92,6 +92,21 @@ int g_high_scores = 0; // matches with 13-15 goals (outside shoot-outs) int g_human_team = -1, g_human_for = 0, g_human_against = 0, g_human_matches = 0; int g_league_goals = 0, g_league_matches = 0; +// A club's strength for the Toto tips of SIM_TOTO: mean of technique and condition of its +// first eleven squad slots. +int club_strength(const modern::ModernState& g, int team) { + const SquadRange r = squad_range(team); + int sum = 0, n = 0; + for (size_t s = r.first; s < r.first + std::min(11, r.count); ++s) { + const int id = g.squad_slots.at(s) & 0xfff; + if (id == 0xfff) continue; + sum += (g.players.at(size_t(id)).technique() + g.players.at(size_t(id)).condition()) / 2, ++n; + } + return n ? sum / n : 0; +} +uint64_t toto_paid = 0, toto_won = 0; +int toto_coupons = 0, toto_hits[12] = {}; + // The almanac of the run (docs/new_engine/almanach.md): size, consistency of the recorded // goals with the results, and the top scorers over all seasons by stable player id. void print_almanac(const modern::ModernState& g) { @@ -476,6 +491,37 @@ int main(int argc, char** argv) { modern::book_training_camp(g, 0, resort, session.rand())) ++camp_stays; } + // SIM_TOTO=: the manager plays the Toto whenever a coupon is open, 400,000 in + // all spread over the columns: the stronger side (team strength) wins, column k > 1 + // tips a draw in match k - 1 instead (docs/new_engine/toto.md). + if (const char* toto = std::getenv("SIM_TOTO")) { + auto& pools = g.pools; + if (!pools.empty() && !pools[0].hits.empty()) { // the last settlement + toto_paid += pools[0].paid, toto_won += pools[0].won, ++toto_coupons; + for (uint8_t h : pools[0].hits) toto_hits[std::min(h, 11)]++; + pools[0].hits.clear(); + } + const int columns = std::clamp(std::atoi(toto), 1, 6); + if (g.memory.has(::bmh::layout::CareerSession_DispatchToto_RuntimeField) && + g.memory.u8(::bmh::layout::CareerSession_DispatchToto_RuntimeField) == 11) { + std::array base{}; + for (uint32_t k = 0; k < 11; ++k) { + const int home = g.memory.u16(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField + k * 4); + const int away = g.memory.u16(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField + k * 4 + 2); + const int hs = home < modern::league_clubs() ? club_strength(g, home) : 0; + const int as = away < modern::league_clubs() ? club_strength(g, away) : 0; + base[k] = as > hs + 2 ? 2 : 1; + } + std::vector> tips{base}; + for (int c = 1; c < columns; ++c) { + auto column = base; + column[size_t(c - 1)] = 0; + tips.push_back(column); + } + const uint32_t stake = std::max(10000, 400000 / uint32_t(columns) / 10000 * 10000); + modern::submit_pools_columns(g, 0, stake, tips); + } + } if (const char* ads = std::getenv("SIM_ADVERTISING"); ads && std::string(ads) == "1") { for (int slot = 15; slot >= 0; --slot) { AdvertisingOfferList list = modern::advertising_offers(g, 0, slot); @@ -582,7 +628,7 @@ int main(int argc, char** argv) { h.player_last == g.player_last && h.world_player_id == g.world_player_id; const bool same_layout = world_layout().league_teams == layout.league_teams && world_layout().total_slots == layout.total_slots; - const bool same_almanac = h.almanac == g.almanac && h.world_league_id == g.world_league_id; + const bool same_almanac = h.almanac == g.almanac && h.world_league_id == g.world_league_id && h.pools == g.pools; std::printf("save check at turn %d: state %s, names %s, layout %s, almanac %s, %ju bytes\n", played, same_state ? "same" : "DIFFERS", same_names ? "same" : "DIFFER", same_layout ? "same" : "DIFFERS", same_almanac ? "same" : "DIFFERS", @@ -621,6 +667,15 @@ int main(int argc, char** argv) { } if (std::getenv("SIM_ADVERTISING")) std::printf("%d advertising contracts accepted (SIM_ADVERTISING=1)\n", ad_contracts); if (std::getenv("SIM_CAMP")) std::printf("%d training camp stays (SIM_CAMP=%s)\n", camp_stays, std::getenv("SIM_CAMP")); + if (std::getenv("SIM_TOTO")) { + int won_coupons = 0; + std::printf("toto (SIM_TOTO=%s): %d coupons, paid %llu, won %llu, return %.1f %%; hits per column:", std::getenv("SIM_TOTO"), + toto_coupons, (unsigned long long)toto_paid, (unsigned long long)toto_won, + toto_paid ? 100.0 * double(toto_won) / double(toto_paid) : 0.0); + for (int h = 0; h <= 11; ++h) std::printf(" %d:%d", h, toto_hits[h]); + for (int h = 9; h <= 11; ++h) won_coupons += toto_hits[h]; + std::printf(" (winning columns %d)\n", won_coupons); + } if (std::getenv("SIM_INTERVENE")) std::printf("%d interventions (substitution at minute 30, re-rated)\n", interventions); if (sim_contracts_env && std::string(sim_contracts_env) == "1") std::printf("contract expiry policy: %d decisions, %d renewals, %d rejected offers/releases, %d no-demand releases, %d errors (SIM_CONTRACTS=1)\n", diff --git a/tests/modern_toto_tests.cpp b/tests/modern_toto_tests.cpp new file mode 100644 index 0000000..c1fccd9 --- /dev/null +++ b/tests/modern_toto_tests.cpp @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: GPL-3.0-only +// The Modern Toto with up to six columns (docs/new_engine/toto.md): the rules of a coupon +// (columns, stakes, total, duplicates) and its cost, on a synthetic coupon block. +#include + +#include "formats/executable_layout.hpp" +#include "modern/game/desk_actions.hpp" +#include "modern/game/modern_state.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; + } +} + +// One manager, an open coupon of eleven matches. +ModernState coupon() { + ModernState g; + g.manager_teams = {0}; + g.manager_records.assign(0xb0c, 0); + g.memory.add_block(::bmh::layout::Coupon, 5 * 0x14); + g.memory.add_block(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField, 44); + g.memory.add_block(::bmh::layout::CareerSession_DispatchToto_RuntimeField, 1); + g.memory.set8(::bmh::layout::CareerSession_DispatchToto_RuntimeField, 11); + return g; +} + +std::array column(uint8_t first) { + std::array c{}; + c.fill(1); + c[0] = first; + return c; +} +} // namespace + +int main() { + { + ModernState g = coupon(); + check(submit_pools_columns(g, 0, 50000, {column(1), column(0), column(2)}) == PoolsColumnsResult::ok, "three columns"); + check(g.memory.u32(::bmh::layout::Coupon) == 50000 && g.pools.at(0).extra.size() == 2, "column 1 on the coupon, 2-3 extra"); + check(submit_pools_columns(g, 0, 50000, {column(1), column(1)}) == PoolsColumnsResult::duplicate_column, "no two columns alike"); + check(submit_pools_columns(g, 0, 100000, {column(0), column(1), column(2), std::array{}}) == PoolsColumnsResult::ok, + "four columns of 100,000: 400,000 in all"); + check(submit_pools_columns(g, 0, 100000, {column(0), column(1), column(2), std::array{}, column(2)}) == + PoolsColumnsResult::total_too_high, "five columns of 100,000 exceed 400,000"); + std::vector> seven; + for (int i = 0; i < 7; ++i) { + auto c = column(1); + c[1] = uint8_t(i % 3), c[2] = uint8_t(i / 3); + seven.push_back(c); + } + check(submit_pools_columns(g, 0, 10000, seven) == PoolsColumnsResult::too_many_columns, "at most six columns"); + check(submit_pools_columns(g, 0, 90000, {seven[0], seven[1], seven[2], seven[3], seven[4]}) == PoolsColumnsResult::total_too_high, + "five columns of 90,000 exceed 400,000"); + check(submit_pools_columns(g, 0, 5000, {column(1)}) == PoolsColumnsResult::stake_out_of_range, "stake at least 10,000"); + check(submit_pools_columns(g, 0, 0, {}) == PoolsColumnsResult::ok && g.memory.u32(::bmh::layout::Coupon) == 0 && + g.pools.at(0).extra.empty(), "a stake of 0 clears every column"); + g.memory.set8(::bmh::layout::CareerSession_DispatchToto_RuntimeField, 9); + check(submit_pools_columns(g, 0, 50000, {column(1)}) == PoolsColumnsResult::invalid, "only with eleven matches"); + } + // the cost: the stake per column, 10 % more for every column beyond the first + check(pools_cost(100000, 1) == 100000, "one column costs the stake"); + check(pools_cost(100000, 4) == 430000, "four columns of 100,000 cost 430,000"); + check(pools_cost(60000, 6) == 390000, "six columns of 60,000 cost 390,000"); + if (failures) return 1; + std::puts("modern toto checks passed"); + return 0; +}