#include "runtime_fixture_tables.hpp" // SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "test_inputs.hpp" #include // Tests of the file formats and game rules against an original BMH installation. // // Usage: format_tests [ []] // // The data directory is an original installation (supported game edition 2026/27 in development). // The optional reference directory holds savegames recorded in the running original // (measured in the original): SP1VOR.FBM right before and SP2VOR.FBM right after // matchday 1. Expected values in these tests were read off the original's screens. #include #include #include #include "formats/fbm.hpp" #include "formats/font.hpp" #include "formats/le.hpp" #include "formats/m3d.hpp" #include "formats/palette.hpp" #include "formats/savestate.hpp" #include "formats/textd.hpp" #include "formats/vga.hpp" #include "game/random.hpp" #include "game/schedule.hpp" #include "game/state.hpp" namespace fs = std::filesystem; using namespace bmh; static int failures = 0; #define CHECK(cond) \ do { \ if (!(cond)) { \ std::printf("FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \ failures++; \ } \ } while (0) static void test_random() { // reference values computed by hand from the formulas verified in the machine code GameRandom g(0); CHECK(g.range(0, 99) == 0); // seed 167 -> 167*100/4e6 = 0 CHECK(g.seed() == 167); // seed 2839, 2839 * 4000000 overflows int32 to -1528901888 -> /4e6 = -382 (like imul/idiv) CHECK(g.range(0, 3999999) == -382); GameRandom neg(-1000); // negative seeds stay negative int32_t v = neg.range(0, 10); CHECK(neg.seed() == (-16000 + 167) % 4000000); CHECK(v == 0); // -15833*11/4e6 truncates to 0 WatcomRandom w(1); CHECK(w.rand() == 16838); // Watcom/MSVC-compatible LCG, first value for seed 1 CHECK(w.range(5, 5) == 5); } // Every byte in these fixtures is generated by this test, not extracted from a game. static void test_generated_formats() { const auto directory = fs::temp_directory_path() / "openbmh-generated-formats"; fs::create_directories(directory); const auto write_file = [](const fs::path& path, const Bytes& bytes) { std::ofstream out(path, std::ios::binary); out.write(reinterpret_cast(bytes.data()), std::streamsize(bytes.size())); if (!out) throw std::runtime_error("Cannot write generated format fixture"); }; Bytes palette(768); for (size_t i = 0; i < palette.size(); ++i) palette[i] = uint8_t((i * 11 + 7) % 64); write_file(directory / "generated.col", palette); const auto loaded = load_palette(directory / "generated.col"); for (size_t i = 0; i < 256; ++i) { const auto expand = [](uint8_t value) { return (unsigned(value) * 255 + 31) / 63; }; CHECK(loaded.argb[i] == (0xff000000u | expand(palette[i * 3]) << 16 | expand(palette[i * 3 + 1]) << 8 | expand(palette[i * 3 + 2]))); } Bytes text(7, 0); for (int i = 0; i < TEXT_COUNT; ++i) { const std::string value = "Synthetic entry " + std::to_string(i); text.insert(text.end(), value.begin(), value.end()); text.push_back(0); } write_file(directory / "generated.blk", text); const auto db = load_textd(directory / "generated.blk"); CHECK(db[0] == "Synthetic entry 0" && db[TEXT_COUNT - 1] == "Synthetic entry " + std::to_string(TEXT_COUNT - 1)); CHECK(iso646de_to_utf8("[\\]{|}~") == "ÄÖÜäöüß"); Bytes font(28 + 2 + 8, 0); font[0] = 2; font[3] = 2; font[4] = 2; font[6] = 1; font[8] = 'A'; font[9] = 'A'; font[16] = 1; font[28] = 0x80; font[29] = 0x40; font[32] = 2; font[36] = 2; write_file(directory / "generated.fnt", font); const auto glyphs = load_font(directory / "generated.fnt"); Image canvas(5, 3, 0); CHECK(glyphs.text_width("AA") == 4 && glyphs.draw(canvas, 0, 0, "A", 9) == 2); CHECK(canvas.at(0, 0) == 9 && canvas.at(1, 1) == 9 && canvas.at(1, 0) == 0); CHECK(glyphs.glyph('Z').advance == 2); fs::remove_all(directory); } static void test_images(const fs::path& data) { Palette pal = load_palette(data / "M3PC.COL"); CHECK((pal.argb[0] >> 24) == 0xFF); CHECK(vga_dac_rgb8(11) == 45 && vga_dac_rgb8(32) == 130); CHECK(vga_dac_rgb8(0x8b) == 45); // preserve the format's low-six-bit mask CHECK(vga_dac_rgb8(0) == 0 && vga_dac_rgb8(63) == 255); int count = 0; for (const char* dir : {"KB", "W"}) { for (const auto& e : fs::directory_iterator(data / dir)) { std::string ext = e.path().extension().string(); for (auto& ch : ext) ch = char(toupper(ch)); std::string stem = e.path().stem().string(); if (ext != ".VGA" || stem.find_first_not_of("0123456789") != std::string::npos) continue; try { Image img = load_vga(e.path()); CHECK(img.width > 0 && img.height > 0 && img.width <= 320 && img.height <= 250); count++; } catch (const FormatError& ex) { std::printf("FAIL %s: %s\n", e.path().string().c_str(), ex.what()); failures++; } } } std::printf(" decoded %d VGA images\n", count); CHECK(count == 107); } static void test_fonts_and_text(const fs::path& data) { Font f2 = load_font(data / "F" / "BMH2.FNT"); Font f3 = load_font(data / "F" / "BMH3.FNT"); CHECK(f2.height == 8 && f3.height == 6); CHECK(f2.text_width("A") > 0); TextDb t = load_textd(data / "TEXTD.BLK"); CHECK(t[0] == bmh::test::expected_text("format.text.0")); CHECK(iso646de_to_utf8(t[1].c_str()) == bmh::test::expected_text("format.text.1")); } static void test_executable(const fs::path& data) { LeImage exe = bmh::test::load_executable(data / "BMH.exe"); CHECK(exe.base() == 0x10000); CHECK(exe.u32(::bmh::layout::MatchdaySetup_Attendance_ExecutableField) == 35000); // first entry of the stadium capacity table CHECK(exe.cstring(::bmh::layout::FixtureTextDatabaseFilename) == "textd.blk"); // file name used by legacy routine } static void test_database(const fs::path& data) { Database db = load_database(data / "M3D.MAN"); CHECK(db.club_names.size() == 419); CHECK(iso646de_to_utf8(db.club_names[0].c_str()) == bmh::test::expected_text("format.text.2")); CHECK(db.players.size() == 2574); CHECK(db.players[0].position() == 0); CHECK(db.referees.at(0) == bmh::test::expected_text("format.text.3")); CHECK(db.stadiums.at(0) == bmh::test::expected_text("format.text.4")); std::printf(" %zu clubs, %zu players, %zu referees, %zu stadiums\n", db.club_names.size(), db.players.size(), db.referees.size(), db.stadiums.size()); } static void test_savegame(const fs::path& data) { Savegame s = load_savegame(bmh::test::external_input("format-start.fbm")); CHECK(s.version == "V2.24"); CHECK(s.checksum_ok); CHECK(s.stream.size() == 165311); // The block table must reproduce the stream length exactly (125 state blocks + 4 pools). SaveState st(s.stream); CHECK(st.blocks().size() == 125); // Compare decoded records with an explicitly supplied external expectation table. std::ifstream player_input(bmh::test::external_input("format-players.tsv")); CHECK(bool(player_input)); size_t id; int condition, technique, form, age, position, strength; size_t checked = 0; while (player_input >> id >> condition >> technique >> form >> age >> position >> strength) { const Player p{"", le32(s.stream, st.block(::bmh::layout::PlayerConditionTechniqueForm).offset + id * 4), le32(s.stream, st.block(::bmh::layout::PlayerSkillWords).offset + id * 4), le32(s.stream, st.block(::bmh::layout::PlayerIdentityWords).offset + id * 4)}; CHECK(p.condition() == condition && p.technique() == technique && p.form() == form && p.age() == age && p.position() == position && p.strength() == strength); ++checked; } CHECK(player_input.eof() && checked > 0); // encrypt/decrypt roundtrip Bytes copy = s.stream; fbm_encrypt(copy.data(), copy.size(), s.key); fbm_decrypt(copy.data(), copy.size(), s.key); CHECK(copy == s.stream); } // Club name of a team id in a running game: offset table *ClubIdentities into the club name pool. static std::string team_name(const SaveState& st, int team) { const Bytes& pool = st.pool(0); size_t ofs = le16(Bytes(st.data(::bmh::layout::ClubIdentities) + team * 2, st.data(::bmh::layout::ClubIdentities) + team * 2 + 2), 0); return iso646de_to_utf8(reinterpret_cast(pool.data() + ofs)); } static void test_schedule(const fs::path& data) { // Round strings: every round is a perfect matching of the league's teams. for (int teams : {18, 20, 16, 12, 6, 4}) { for (int md = 1; md <= 2 * (teams - 1); md++) { std::vector seen(teams, 0); for (const Fixture& f : generate_fixtures(teams, md, teams - 1, 0)) { seen.at(f.home)++; seen.at(f.away)++; } for (int n : seen) CHECK(n == 1); } } // Second half repeats the first with home and away swapped. auto first = league_fixtures(0, 1), second = league_fixtures(0, 18); CHECK(first[0].home == second[0].away && first[0].away == second[0].home); // Team order of the recorded career (clubs are shuffled when a new game starts). Savegame s = load_savegame(bmh::test::external_input("format-start.fbm")); SaveState st(s.stream); CHECK(team_name(st, 0) == bmh::test::expected_text("format.text.5")); CHECK(team_name(st, 14) == bmh::test::expected_text("format.text.2")); CHECK(team_league(14) == 0 && team_league(90) == 5 && team_league(138) == kLeagueCount); // Before the season every result is "not played". const uint8_t* results = st.data(::bmh::layout::LeagueResults); for (size_t i = 0; i < kResultsSize; i++) CHECK(!decode_result(results[i]).played); } // Matchday 1 of the Bundesliga as shown by the original. static void test_matchday1(const fs::path& refs) { Savegame s = load_savegame(refs / "SP2VOR.FBM"); CHECK(s.checksum_ok); SaveState st(s.stream); struct Expected { std::string home, away; int hg, ag; }; std::ifstream expected_input(bmh::test::external_input("format-matches.tsv")); std::vector expected; for (std::string line; std::getline(expected_input, line);) { std::istringstream row(line); Expected value; std::getline(row, value.home, '\t'); std::getline(row, value.away, '\t'); if (!(row >> value.hg >> value.ag)) throw std::runtime_error("Invalid match expectation"); expected.push_back(std::move(value)); } CHECK(expected.size() == 9); auto fixtures = league_fixtures(0, 1); CHECK(fixtures.size() == 9); for (size_t m = 0; m < fixtures.size() && m < 9; m++) { Result r = decode_result(st.data(::bmh::layout::LeagueResults)[result_index(0, 1, m)]); bool ok = team_name(st, fixtures[m].home) == expected[m].home && team_name(st, fixtures[m].away) == expected[m].away && r.played && r.home_goals == expected[m].hg && r.away_goals == expected[m].ag; if (!ok) std::printf(" match %zu: %s - %s %d:%d\n", m, team_name(st, fixtures[m].home).c_str(), team_name(st, fixtures[m].away).c_str(), r.home_goals, r.away_goals); CHECK(ok); } // Matchday 2 has not been played yet. CHECK(!decode_result(st.data(::bmh::layout::LeagueResults)[result_index(0, 2, 0)]).played); } // Team values K/T/F/M/Ø right before matchday 1. The original showed them on the results // screen at 90'; for these nine teams nothing changed during their match, so the values // equal the pre-match ones. Ø is also the "Stärke" shown on the desktop (Bayern 84, // Frankfurt 91 before the match). static void test_team_values(const fs::path& refs) { Savegame s = load_savegame(refs / "SP1VOR.FBM"); SaveState st(s.stream); GameState g = GameState::from_save(st); using namespace avg; const uint16_t lineup = LINEUP_ONLY | ALL_POSITIONS; struct Expected { int team, k, t, f, m, strength; }; std::ifstream expected_input(bmh::test::external_input("format-team-values.tsv")); std::vector expected; for (Expected value; expected_input >> value.team >> value.k >> value.t >> value.f >> value.m >> value.strength;) expected.push_back(value); CHECK(expected_input.eof() && !expected.empty()); for (const Expected& e : expected) { CHECK(team_average(g, e.team, lineup | CONDITION).value == e.k); CHECK(team_average(g, e.team, lineup | TECHNIQUE).value == e.t); CHECK(team_average(g, e.team, lineup | FORM).value == e.f); CHECK(team_average(g, e.team, lineup | MORALE).value == e.m); CHECK(team_average(g, e.team, lineup | CONDITION | TECHNIQUE | FORM | MORALE).value == e.strength); } } int main(int argc, char** argv) { test_random(); test_generated_formats(); if (argc < 2) { std::printf("no data directory given, skipping data tests\n"); } else { fs::path data = argv[1]; try { test_images(data); test_fonts_and_text(data); test_database(data); test_executable(data); test_savegame(data); test_schedule(data); if (argc >= 3 && *argv[2]) test_matchday1(argv[2]), test_team_values(argv[2]); else std::printf("no reference directory given, skipping matchday tests\n"); } catch (const std::exception& ex) { std::printf("FAIL exception: %s\n", ex.what()); failures++; } } std::printf(failures ? "%d FAILURE(S)\n" : "all tests passed\n", failures); return failures ? 1 : 0; }