Record every match in a football almanac (Modern, M8)

Modern careers keep every match they play: season, date, competition
type, league or cup stage, matchday, both clubs by world id with their
human managers, result with extra time and shoot-out, referee,
attendance, weather, both line-ups and all events (goals with assists
and kind, misses, cards, injuries, substitutions, shoot-out kicks).
Events come from the group event log the engine keeps for every match,
substitutions from the players on the pitch after each minute; nothing
draws random numbers (a 60-turn Modern run is unchanged).

Player indices reused for a new person get a new stable id. Saves hold
finished seasons as immutable history/season-<year>.bin files plus the
running season; modern-state@1.1 adds league names and the id counter.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Opus 5.5 committed 2026-10-23 23:49:13 +02:00
1 parent 57d75ab2f5
commit 201eef88e4
14 files changed
+935 -8

No files matched your search

+84
View File
@@ -0,0 +1,84 @@
// SPDX-License-Identifier: GPL-3.0-only
// The football almanac (docs/new_engine/almanach.md, M8) on synthetic data: the binary
// season round trip, damaged input, the calendar dates and new player identities.
#include <cstdio>
#include <string>
#include "formats/binary.hpp"
#include "modern/game/almanac.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;
}
}
AlmanacSeason sample() {
AlmanacSeason s;
s.season = 3, s.start_year = 2029, s.display_start_year = 2026;
s.leagues.push_back({0, "comp:bundesliga", "Bundesliga"});
s.referees.push_back({});
const uint16_t home = s.club({"club:sued", "FC Südstadt"});
const uint16_t away = s.club({"club:nord", "SV Nordstadt"});
const uint16_t a = s.player({"player:1", "Anton", "Beispiel", "nation:de"});
const uint16_t b = s.player({"player:gen-7", "", "Größer", "nation:de"});
AlmanacMatch m;
m.date = 400, m.type = 2, m.stage = 5, m.round = 2, m.home = home, m.away = away;
m.home_manager = s.manager({0, "Testmanager"});
m.home_goals = 1, m.away_goals = 1, m.home_shootout = 5, m.away_shootout = 3, m.decided = 2;
m.referee = s.referee("Schiri A");
m.attendance = 75000, m.temperature = -3, m.rain = 6;
m.lineup[0] = {a, b};
m.events.push_back({AlmanacEventKind::Goal, 12, 0, 3, a, b});
m.events.push_back({AlmanacEventKind::SecondYellow, 77, 1, 0, b, kAlmanacNone});
m.events.push_back({AlmanacEventKind::Substitution, 80, 0, 0, b, a});
m.events.push_back({AlmanacEventKind::ShootoutKick, 121, 1, 1, a, kAlmanacNone});
s.matches.push_back(m);
return s;
}
} // namespace
int main() {
const AlmanacSeason s = sample();
const std::string bytes = encode_almanac_season(s);
const AlmanacSeason back = decode_almanac_season(bytes);
check(back == s, "season round trip");
check(encode_almanac_season(back) == bytes, "stable encoding");
AlmanacSeason grown = back; // the lookups survive decoding: no duplicate entries
check(grown.club({"club:sued", "FC Südstadt"}) == 0 && grown.clubs.size() == 2, "club lookup after decode");
check(grown.referee("Schiri A") == 1 && grown.referees.size() == 2, "referee lookup after decode");
bool refused = false;
try { decode_almanac_season(bytes.substr(0, bytes.size() - 3)); } catch (const FormatError&) { refused = true; }
check(refused, "truncated season refused");
refused = false;
try { decode_almanac_season(bytes + "x"); } catch (const FormatError&) { refused = true; }
check(refused, "trailing bytes refused");
refused = false;
try { decode_almanac_season("OBAL\x09\x00"); } catch (const FormatError&) { refused = true; }
check(refused, "unknown version refused");
// Day 0 is 1 July of the display start year; the calendar's first leap year comes after one year.
const AlmanacDate d0 = almanac_date(0, 2026), d1 = almanac_date(183, 2026), d2 = almanac_date(365, 2026);
check(d0.year == 2026 && d0.month == 7 && d0.day == 1, "date of day 0");
check(d1.year == 2026 && d1.month == 12 && d1.day == 31, "date of day 183");
check(d2.year == 2027 && d2.month == 7 && d2.day == 1, "date of day 365");
ModernState g;
g.players.resize(5);
new_player_identity(g, 3);
new_player_identity(g, 3);
check(g.world_player_id.size() == 5 && g.world_player_id[3] == "player:gen-2" && g.almanac.generated_players == 2,
"new player identities");
if (failures == 0) std::printf("modern almanac tests passed\n");
return failures == 0 ? 0 : 1;
}
+50 -2
View File
@@ -91,6 +91,51 @@ 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;
// 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) {
std::vector<modern::AlmanacSeason> seasons;
size_t bytes = 0;
for (const auto& [name, data] : g.almanac.finished) {
seasons.push_back(modern::decode_almanac_season(data));
bytes += data.size();
}
if (g.almanac.current.season >= 0) {
const std::string data = modern::encode_almanac_season(g.almanac.current);
bytes += data.size();
if (!(modern::decode_almanac_season(data) == g.almanac.current)) std::printf("almanac: current season does not round-trip\n");
seasons.push_back(g.almanac.current);
}
size_t matches = 0, events = 0, mismatched = 0, without_lineup = 0;
std::map<std::string, std::pair<int, std::string>> scorers; // player id -> goals, name
for (const auto& s : seasons) {
matches += s.matches.size();
for (const auto& m : s.matches) {
events += m.events.size();
int goals[2] = {0, 0};
for (const auto& e : m.events) {
if (e.kind != modern::AlmanacEventKind::Goal) continue;
++goals[e.side];
if (e.player == modern::kAlmanacNone) continue;
const auto& p = s.players.at(e.player);
auto& row = scorers[p.id];
++row.first;
row.second = (p.first.empty() ? "" : p.first + " ") + p.last;
}
if (goals[0] != m.home_goals || goals[1] != m.away_goals) ++mismatched;
if (m.lineup[0].empty() && m.lineup[1].empty()) ++without_lineup;
}
}
std::printf("almanac: %zu seasons, %zu matches, %zu events, %zu bytes uncompressed, %u new player identities\n",
seasons.size(), matches, events, bytes, g.almanac.generated_players);
std::printf("almanac: %zu matches whose goal events differ from the result, %zu without line-ups\n", mismatched, without_lineup);
std::vector<std::pair<int, std::string>> top;
for (const auto& [id, row] : scorers) top.emplace_back(row.first, row.second + " (" + id + ")");
std::sort(top.begin(), top.end(), [](const auto& a, const auto& b) { return a.first > b.first; });
for (size_t i = 0; i < std::min<size_t>(5, top.size()); ++i)
std::printf("almanac top scorer %zu: %d goals, %s\n", i + 1, top[i].first, top[i].second.c_str());
}
// Read only the current season's first-league results. A complete German Bundesliga
// season has 34 rounds x 9 fixtures = 306 matches. Unlike the historical snapshot
// counters, this includes background fixtures played while seeking the next desk.
@@ -407,13 +452,16 @@ 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;
std::printf("save check at turn %d: state %s, names %s, layout %s, %ju bytes\n", played,
const bool same_almanac = h.almanac == g.almanac && h.world_league_id == g.world_league_id;
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", uintmax_t(std::filesystem::file_size(file)));
same_layout ? "same" : "DIFFERS", same_almanac ? "same" : "DIFFERS",
uintmax_t(std::filesystem::file_size(file)));
}
}
}
print_first_league_results(g, "run end");
if (modern::current_world()) print_almanac(g);
if (std::getenv("SIM_ADVERTISING")) std::printf("%d advertising contracts accepted (SIM_ADVERTISING=1)\n", ad_contracts);
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")