// 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 #include #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); // the same club again: two players from its previous line-up in a new order and a new one // (version 3 names them by their slot in the previous line-up) const uint16_t c = s.player({"player:3", "Carl", "Neu", "nation:at"}); AlmanacMatch next; next.date = 407, next.type = 0, next.league = 0, next.round = 3, next.home = away, next.away = home; next.lineup[1] = {b, c, a}; s.matches.push_back(next); AlmanacTable t; t.league = 0; t.rows.push_back({home, 1, 34, 25, 5, 4, 80, 30, 77}); t.rows.push_back({away, 2, 34, 20, 6, 8, 70, 40, -2}); s.tables.push_back(t); s.winners.push_back({0, 0, 0xff, 0, 300, home, away}); s.winners.push_back({12, 0xff, 4, 1, 310, away, 0xffff}); return s; } // A season in the row format of version 2 (one row per match), as older saves hold it. std::string encode_version_2(const AlmanacSeason& s) { std::string o = "OBAL"; auto u8 = [&](uint32_t v) { o.push_back(char(v & 0xff)); }; auto u16 = [&](uint32_t v) { u8(v), u8(v >> 8); }; auto u32 = [&](uint32_t v) { u16(v), u16(v >> 16); }; auto str = [&](const std::string& t) { u16(uint32_t(t.size())), o += t; }; u16(2), u16(uint32_t(int16_t(s.season))), u16(uint32_t(s.start_year)), u16(uint32_t(s.display_start_year)); u16(uint32_t(s.leagues.size())); for (const auto& l : s.leagues) u8(uint32_t(l.index)), str(l.id), str(l.name); u16(uint32_t(s.clubs.size())); for (const auto& c : s.clubs) str(c.id), str(c.name); u32(uint32_t(s.players.size())); for (const auto& p : s.players) str(p.id), str(p.first), str(p.last), str(p.nation); u8(uint32_t(s.managers.size())); for (const auto& m : s.managers) u8(uint32_t(uint8_t(int8_t(m.index)))), str(m.name); u16(uint32_t(s.referees.size())); for (const auto& r : s.referees) str(r); u32(uint32_t(s.matches.size())); for (const AlmanacMatch& m : s.matches) { u32(m.date), u8(m.type), u8(m.league), u8(m.stage), u8(m.round), u16(m.home), u16(m.away); u8(uint8_t(m.home_manager)), u8(uint8_t(m.away_manager)); u8(m.home_goals), u8(m.away_goals), u8(m.home_shootout), u8(m.away_shootout), u8(m.decided), u8(m.referee); u32(m.attendance), u8(uint8_t(m.temperature)), u8(m.rain); for (const auto& side : m.lineup) { u8(uint32_t(side.size())); for (uint16_t p : side) u16(p); } u16(uint32_t(m.events.size())); for (const AlmanacEvent& e : m.events) u8(uint32_t(e.kind)), u8(e.minute), u8(e.side), u8(e.detail), u16(e.player), u16(e.other); } u8(uint32_t(s.tables.size())); for (const AlmanacTable& t : s.tables) { u8(t.league), u8(uint32_t(t.rows.size())); for (const AlmanacStanding& r : t.rows) u16(r.club), u8(r.rank), u8(r.played), u8(r.won), u8(r.drawn), u8(r.lost), u8(r.goals_for), u8(r.goals_against), u16(uint32_t(uint16_t(r.points))); } u16(uint32_t(s.winners.size())); for (const AlmanacWinner& x : s.winners) u8(x.type), u8(x.league), u8(x.stage), u8(x.detail), u32(x.date), u16(x.winner), u16(x.runner_up); return o; } } // 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"); check(decode_almanac_season(encode_version_2(s)) == s, "version 2 saves still read"); check(bytes.size() > 6 && bytes[4] == 3 && bytes[5] == 0, "written as version 3"); 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; }