Initial public OpenBMH 0.1 source (by Codex)

This commit is contained in:
Codex committed 2026-10-16 19:36:32 +02:00
commit 558fbf166b
613 files changed
+168029

No files matched your search

+463
View File
@@ -0,0 +1,463 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
// capture_check - compares the ported match engine with a matchday recorded from the
// original (runtime verification).
//
// The capture holds one JSON object per line: minute snapshots (seeds, per match group
// the fixtures, results and the 18-byte side records) and one "state" object with the
// tables the engine used at kick-off. This tool rebuilds a GameState from that dump and
// compares the six side ratings (bytes 0-5 of each side record) with team_rating().
//
// Usage: capture_check <capture.jsonl>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <string>
#include <vector>
#include "formats/binary.hpp"
#include "runtime_fixture_tables.hpp"
#include "formats/fbm.hpp"
#include "formats/m3d.hpp"
#include "formats/savestate.hpp"
#include "game/lineup.hpp"
#include "game/match.hpp"
#include "game/match_engine.hpp"
#include "game/rating.hpp"
#include "game/state.hpp"
using namespace bmh;
#include "capture_io.hpp"
using namespace bmh::capture;
int main(int argc, char** argv) {
if (argc < 2) {
std::printf("usage: capture_check <capture.jsonl>\n");
return 1;
}
std::setvbuf(stdout, nullptr, _IONBF, 0);
std::ifstream in(argv[1]);
std::string line, first_minute, dump;
while (std::getline(in, line)) {
if (first_minute.empty() && line.rfind("{\"minute\":1,", 0) == 0) first_minute = line;
// the kick-off state: the first state line after the minute-1 snapshot
if (line.rfind("{\"state\"", 0) == 0 && dump.empty() && !first_minute.empty()) dump = line;
}
if (first_minute.empty() || dump.empty()) {
std::printf("capture has no minute-1 snapshot or no state dump\n");
return 1;
}
GameState base = state_from_dump(dump);
int checked = 0, exact = 0;
size_t pos = first_minute.find("\"groups\":[");
for (int group = 0;; group++) {
size_t gpos = first_minute.find("{\"type\":", pos);
if (gpos == std::string::npos) break;
pos = gpos + 1;
int matches = std::stoi(field(first_minute, "matches", gpos));
Bytes fixtures = unhex(field(first_minute, "fixtures", gpos));
Bytes sides = unhex(field(first_minute, "sides", gpos));
std::printf("group %d: %d matches\n", group, matches);
for (int m = 0; m < matches && size_t(m * 4 + 3) < fixtures.size(); m++) {
for (int side = 0; side < 2; side++) {
int team = le16(fixtures, m * 4 + side * 2);
const uint8_t* rec = sides.data() + m * 18 + side * 9;
std::printf(" match %d %s team %3d original:", m, side ? "away" : "home", team);
for (int i = 0; i < 6; i++) std::printf(" %3d", rec[i]);
if (base.manager_of(team) >= 0 || team >= 168) {
std::printf(" (not comparable: %s)\n", team >= 168 ? "no squad" : "human manager");
continue;
}
std::printf(" ported:");
bool same = true;
for (int i = 0; i < 6; i++) {
GameState g = base;
int v = team_rating(g, team, kRatingProfiles[i]);
std::printf(" %3d", v);
if (i != 2 && v != rec[i]) same = false; // byte 2 gets a home/away modifier afterwards
}
std::printf("%s\n", same ? " OK" : " DIFF");
checked++;
exact += same;
}
}
}
std::printf("\n%d of %d computer sides match (bytes 0,1,3,4,5)\n", exact, checked);
// Full side records via build_side_records. Spectators are not captured, so the home
// bonus is unknown: byte 2 must equal the computed value or the computed value + 6.
std::printf("\nfull side records (bytes 0-8):\n");
int full_checked = 0, full_exact = 0;
pos = first_minute.find("\"groups\":[");
for (int group = 0;; group++) {
size_t gpos = first_minute.find("{\"type\":", pos);
if (gpos == std::string::npos) break;
pos = gpos + 1;
int matches = std::stoi(field(first_minute, "matches", gpos));
int flags = std::stoi(field(first_minute, "flags", gpos));
Bytes desc = unhex(field(first_minute, "desc", gpos));
Bytes fixtures = unhex(field(first_minute, "fixtures", gpos));
Bytes sides = unhex(field(first_minute, "sides", gpos));
for (int m = 0; m < matches && size_t(m * 4 + 3) < fixtures.size(); m++) {
MatchSetup setup;
setup.home = le16(fixtures, m * 4);
setup.away = le16(fixtures, m * 4 + 2);
setup.match_index = m;
setup.climate_effect = (flags & 2) != 0;
setup.temperature = int8_t(desc.at(0x30 + m));
setup.spectators = 0;
setup.month = 8; // format field read from the running original in August
if (base.manager_of(setup.home) >= 0 || base.manager_of(setup.away) >= 0 || setup.home >= 168 ||
setup.away >= 168)
continue;
GameState g = base;
WatcomRandom rand(1);
auto rec = build_side_records(g, setup, rand);
for (int side = 0; side < 2; side++) {
const uint8_t* orig = sides.data() + m * 18 + side * 9;
bool ok = true;
for (int i = 0; i < 8; i++) {
if (i == 2) {
int d = orig[2] - rec[side].b[2];
ok = ok && (d == 0 || (side == 0 && d == 6));
} else {
ok = ok && orig[i] == rec[side].b[i];
}
}
// Attitude (byte 8). Home: compared against uninitialised heap memory in the
// original, so the "stronger by more than 10" step may or may not apply.
// Away: recompute with the original's home byte 2 (it includes the home bonus).
int base_attitude = 2 - side;
int own2 = orig[2], other2 = sides[m * 18 + (1 - side) * 9 + 2];
int expected = base_attitude;
if (own2 + 10 < other2) expected = 1 - side;
if (other2 < own2 - 10 && m != 0) expected++;
if (side == 0) ok = ok && (orig[8] == 2 || orig[8] == 3 || orig[8] == 1);
else ok = ok && orig[8] == expected;
full_checked++;
full_exact += ok;
if (!ok) {
std::printf(" group %d match %d %s:", group, m, side ? "away" : "home");
for (int i = 0; i < 9; i++) std::printf(" %3d/%-3d", orig[i], rec[side].b[i]);
std::printf("\n");
}
}
}
}
std::printf("%d of %d full side records match (original/ported shown for mismatches)\n", full_exact, full_checked);
// Line-ups: apply auto_lineup to the savegame taken right before the matchday and
// compare the first 11 squad slots (ids and flags) with the kick-off dump.
if (argc >= 4 && !std::getenv("BMH_TRACE")) { // line-up tests (skipped when tracing a minute)
Savegame sg = load_savegame(argv[3]);
SaveState st(sg.stream);
GameState before = GameState::from_save(st);
for (int mode : {-1, 0, 100, 200}) {
int teams = 0, same = 0, same_players = 0;
pos = first_minute.find("\"groups\":[");
size_t gpos;
while ((gpos = first_minute.find("{\"type\":", pos)) != std::string::npos) {
pos = gpos + 1;
Bytes fixtures = unhex(field(first_minute, "fixtures", gpos));
for (size_t k = 0; k + 1 < fixtures.size(); k += 2) {
int team = le16(fixtures, k);
if (team >= 138 || base.manager_of(team) >= 0) continue;
GameState g = before;
if (mode == 200) {
// Scramble: reverse the used part of the squad and clear all flags, then
// select from scratch. The same starting eleven must come out.
SquadRange rr = squad_range(team);
size_t used = 0;
while (used < rr.count && (g.squad_slots[rr.first + used] & 0x0FFF) != 0x0FFF) used++;
for (size_t a = 0, b = used - 1; a < b; a++, b--)
std::swap(g.squad_slots[rr.first + a], g.squad_slots[rr.first + b]);
for (size_t a = 0; a < used; a++) g.squad_slots[rr.first + a] &= 0x0FFF;
auto_lineup(g, team, 100);
}
if (mode == 100) auto_lineup(g, team, 100);
if (mode >= 0 && mode < 200) auto_lineup(g, team, 0); // -1: unchanged savegame, as a baseline
SquadRange r = squad_range(team);
bool ok = true;
for (size_t s = 0; s < 11; s++) {
uint16_t mine = g.squad_slots[r.first + s], orig = base.squad_slots[r.first + s];
if (mode == 200) {
// Tie-insensitive: the scrambled order decides between equal players,
// so compare line-up flag, position type and value per slot instead of ids.
const Player &pm = before.players[mine & 0x0FFF], &po = before.players[orig & 0x0FFF];
auto val = [](const Player& p) { return p.form() / 3 + p.condition() + p.technique(); };
if ((mine & 0x8000) != (orig & 0x8000) || pm.position() != po.position() || val(pm) != val(po))
ok = false;
} else if ((mine & 0x8FFF) != (orig & 0x8FFF)) {
ok = false;
}
}
teams++;
same += ok;
if (!ok && mode == 200) {
// same eleven players regardless of order?
std::vector<int> a, b;
for (size_t s = 0; s < 11; s++) {
a.push_back(g.squad_slots[r.first + s] & 0x0FFF);
b.push_back(base.squad_slots[r.first + s] & 0x0FFF);
}
std::sort(a.begin(), a.end());
std::sort(b.begin(), b.end());
if (a == b) same_players++;
if (teams - same <= 2) {
std::printf(" team %3d formation %d\n", team, g.formation(team));
for (size_t s = 0; s < 11; s++) {
int pid = g.squad_slots[r.first + s] & 0x0FFF, oid = base.squad_slots[r.first + s] & 0x0FFF;
const Player &pp = before.players[pid], &op = before.players[oid];
int x, y;
g.formation_position(team, int(s), x, y);
std::printf(" slot %2zu x%2d ported %4d pos%d val%3d original %4d pos%d val%3d\n", s, x, pid,
pp.position(), pp.form() / 3 + pp.condition() + pp.technique(), oid, op.position(),
op.form() / 3 + op.condition() + op.technique());
}
}
}
if (!ok && mode == 0 && teams - same <= 3) {
std::printf(" team %3d ported :", team);
for (size_t s = 0; s < 11; s++) std::printf(" %04x", g.squad_slots[r.first + s]);
std::printf("\n original:");
for (size_t s = 0; s < 11; s++) std::printf(" %04x", base.squad_slots[r.first + s]);
std::printf("\n");
}
}
}
std::printf("line-up mode %s: %d of %d computer teams match the kick-off line-up\n",
mode < 0 ? "none (baseline)"
: mode == 0 ? "<100 (re-sort 11)"
: mode == 100 ? "100 then <100"
: "scrambled squad, 100",
same, teams);
if (mode == 200) std::printf(" (same eleven players in another order: %d more)\n", same_players);
}
}
// Minute by minute: start from the recorded state of minute n, simulate it, compare
// with the recording of minute n + 1 (both RNG states and all results).
if (argc >= 3) {
Database db = load_database(argv[2]);
bmh::test::load_executable(std::filesystem::path(argv[2]).parent_path() / "BMH.exe");
// Button settings (block data-field offset, 0xb4 bytes, same layout as the .EIN files): they
// switch the live-match animations on and off. Taken from the savegame if given.
// Tactics boards, manager records and the game level are not in the per-minute
// dumps either; they come from the savegame as well.
std::vector<uint8_t> buttons;
GameState saved;
if (argc >= 4) {
Savegame sg = load_savegame(argv[3]);
SaveState st(sg.stream);
buttons.assign(st.data(::bmh::layout::LeaguePresentationOptions), st.data(::bmh::layout::LeaguePresentationOptions) + 0xb4);
saved = GameState::from_save(st);
std::printf("\nbutton settings: a2507=%d a2510=%d a2543=%d a2570=%d, game level %d\n", buttons[0x10], buttons[0x19],
buttons[0x4c], buttons[0x79], saved.level);
}
// minute lines, each with the state line that follows it (newer captures) if any
std::vector<std::pair<std::string, std::string>> minutes;
{
std::ifstream again(argv[1]);
while (std::getline(again, line)) {
if (line.rfind("{\"minute\":", 0) == 0 && line.rfind("{\"minute\":-1", 0) != 0) minutes.push_back({line, ""});
else if (line.rfind("{\"state\"", 0) == 0 && !minutes.empty() && minutes.back().second.empty())
minutes.back().second = line;
}
}
// Field of one group: search only between this group's start and the next group.
auto group_field = [](const std::string& l, const std::string& key, size_t start) {
size_t end = l.find("{\"type\":", start + 1);
std::string v = field(l, key, start);
size_t at = l.find("\"" + key + "\":", start);
return (at == std::string::npos || (end != std::string::npos && at > end)) ? std::string() : v;
};
std::printf("\nminute simulation (%zu snapshots):\n", minutes.size());
int ok = 0, bad = 0, skipped = 0;
// Stoppage time: from minute last + 1 on, the game draws the end-of-match rolls right
// after storing the minute, so the recorder reads the seeds about one draw late.
// Those minutes are therefore simulated in a chain from the last reliable snapshot
// (the regular last minute) instead of restarting from each recording.
struct Chain {
std::vector<MatchGroup> groups;
GameState state;
GameRandom game{0};
WatcomRandom rand{0};
int minute = -1;
} chain;
for (size_t i = 0; i + 1 < minutes.size(); i++) {
const std::string &a = minutes[i].first, &b = minutes[i + 1].first;
int minute = std::stoi(field(a, "minute")), next = std::stoi(field(b, "minute"));
// Regular league/cup phases (legacy routine(1, 45, 0) and (46, 90, 4)); extra time
// and indoor tournaments are not covered here yet.
const int phase_first = minute <= 45 ? 1 : 46, last = minute <= 45 ? 45 : 90, stoppage = minute <= 45 ? 0 : 4;
if (next != minute + 1 || minute > last + stoppage) continue;
if (std::getenv("BMH_TRACE") && std::stoi(std::getenv("BMH_TRACE")) != minute) continue; // one minute only
std::vector<MatchGroup> groups;
size_t p = a.find("\"groups\":[");
while ((p = a.find("{\"type\":", p)) != std::string::npos) {
MatchGroup g;
g.desc = unhex(group_field(a, "desc", p));
Bytes fx = unhex(group_field(a, "fixtures", p));
for (size_t k = 0; k + 1 < fx.size(); k += 2) g.fixtures.push_back(le16(fx, k));
g.results = unhex(group_field(a, "results", p));
g.records = unhex(group_field(a, "sides", p));
Bytes cup = unhex(group_field(a, "cup0", p));
for (size_t k = 0; k + 1 < cup.size(); k += 2) g.cup_results.push_back(le16(cup, k));
Bytes crowd = unhex(group_field(a, "spectators", p));
for (size_t k = 0; k + 3 < crowd.size(); k += 4) g.spectators.push_back(le32(crowd, k));
g.end_minute = unhex(group_field(a, "end_minutes", p));
g.end_minute.resize(g.matches(), 0);
// Matches that ended earlier in this phase (end minute recorded since then).
for (int m = 0; m < g.matches(); m++)
if (g.end_minute[m] >= phase_first && g.end_minute[m] < minute) g.ended |= 1u << m;
groups.push_back(g);
p++;
}
bool cup_recorded = a.find("\"cup0\":") != std::string::npos;
GameState gs = minutes[i].second.empty() ? base : state_from_dump(minutes[i].second);
gs.tactics = saved.tactics;
gs.manager_records = saved.manager_records;
gs.level = saved.level;
gs.manager_options = saved.manager_options;
GameRandom game(int32_t(std::stoll(field(a, "game_seed"))));
WatcomRandom rnd(uint32_t(std::stoull(field(a, "rand_seed"))));
const bool chained = minute > last && chain.minute == minute - 1;
if (chained) {
groups = chain.groups;
gs = chain.state;
game = chain.game;
rnd = chain.rand;
}
MatchEngine engine{gs, groups, game, rnd, db.raw_referee_properties};
if (!field(a, "alternate_event_roll").empty()) engine.alternate_event_roll = field(a, "alternate_event_roll") != "0";
if (!field(a, "match_events_disabled").empty()) engine.match_events_disabled = field(a, "match_events_disabled") != "0";
if (!field(a, "live_desk_disabled").empty()) engine.live_desk_disabled = field(a, "live_desk_disabled") != "0";
engine.month = field(a, "month").empty() ? 8 : std::stoi(field(a, "month"));
engine.buttons = buttons;
engine.trace = std::getenv("BMH_TRACE") && std::stoi(std::getenv("BMH_TRACE")) == minute;
MinuteReport rep;
try {
rep = engine.minute(minute, last, stoppage);
} catch (const std::exception& ex) {
rep.fail(std::string("exception: ") + ex.what());
}
chain.minute = rep.unsupported ? -1 : minute;
if (!rep.unsupported) {
chain.groups = groups;
chain.state = gs;
chain.game = game;
chain.rand = rnd;
}
if (rep.unsupported) {
skipped++;
std::printf(" minute %2d: not checkable (%s)\n", minute, rep.reason.c_str());
continue;
}
bool seeds = game.seed() == int32_t(std::stoll(field(b, "game_seed"))) &&
rnd.seed() == uint32_t(std::stoull(field(b, "rand_seed")));
// A late snapshot of a stoppage minute: the recorded Watcom seed may be one draw
// (the first end-of-match roll) ahead.
bool late = false;
if (!seeds && next > last && game.seed() == int32_t(std::stoll(field(b, "game_seed")))) {
WatcomRandom probe = rnd;
probe.range(0, 1);
late = seeds = probe.seed() == uint32_t(std::stoull(field(b, "rand_seed")));
}
// End minutes of this phase up to the simulated minute. The recorder reads the
// groups after the seeds while the game runs on, so later entries may already
// belong to the next minute; they are left out on both sides.
auto end_key = [&](int e) {
char h[3];
std::snprintf(h, 3, "%02x", e >= phase_first && e <= minute ? e : 0);
return std::string(h);
};
std::string ours;
for (auto& g : groups) {
for (uint8_t r : g.results) { char h[3]; std::snprintf(h, 3, "%02x", r); ours += h; }
for (uint8_t e : g.end_minute) ours += end_key(e);
if (cup_recorded)
for (uint16_t r : g.cup_results) { char h[5]; std::snprintf(h, 5, "%02x%02x", r & 0xFF, r >> 8); ours += h; }
}
std::string theirs;
size_t q = b.find("\"groups\":[");
while ((q = b.find("{\"type\":", q)) != std::string::npos) {
theirs += group_field(b, "results", q);
for (uint8_t e : unhex(group_field(b, "end_minutes", q))) theirs += end_key(e);
if (cup_recorded) theirs += group_field(b, "cup0", q);
q++;
}
bool results = ours == theirs;
if (seeds && results) ok++; else bad++;
std::printf(" minute %2d: %s game rng calls %llu%s%s%s\n", minute, seeds && results ? "OK " : "MISMATCH",
(unsigned long long)game.calls(), results ? "" : " (results differ)", chained ? " (chained)" : "",
late ? " (snapshot 1 draw late)" : "");
if (!seeds) {
// The recorder may read the seeds a little late (the game runs on); find out
// whether the recorded Watcom seed is a few draws ahead of ours.
WatcomRandom probe = rnd;
int ahead = -1;
for (int k = 1; k <= 64 && ahead < 0; k++) {
probe.range(0, 1);
if (probe.seed() == uint32_t(std::stoull(field(b, "rand_seed")))) ahead = k;
}
bool game_ok = game.seed() == int32_t(std::stoll(field(b, "game_seed")));
if (ahead > 0 && game_ok) std::printf(" recorded Watcom seed is %d draws ahead (late snapshot)\n", ahead);
else std::printf(" seeds differ (game %s)\n", game_ok ? "same" : "differs");
// ... or ours ahead of the recording (we drew too much)
WatcomRandom back(uint32_t(std::stoull(field(b, "rand_seed"))));
for (int k = 1; k <= 64; k++) {
back.range(0, 1);
if (back.seed() == rnd.seed()) {
std::printf(" ported Watcom seed is %d draws ahead of the recording\n", k);
break;
}
}
if (ahead > 0 && !game_ok) std::printf(" recorded Watcom seed is %d draws ahead\n", ahead);
}
if ((!seeds || !results) && !minutes[i + 1].second.empty()) {
// Which tables differ from the state recorded at the next minute?
GameState o = state_from_dump(minutes[i + 1].second);
int shown = 0;
for (size_t k = 0; k < gs.players.size() && k < o.players.size() && shown < 6; k++) {
const Player &x = gs.players[k], &y = o.players[k];
if (x.w35c != y.w35c || x.w368 != y.w368 || x.w364 != y.w364) {
std::printf(" player %zu: ported %08x %08x %08x, original %08x %08x %08x\n", k, x.w35c, x.w368,
x.w364, y.w35c, y.w368, y.w364);
shown++;
}
}
for (size_t k = 0; k < gs.squad_slots.size() && k < o.squad_slots.size() && shown < 12; k++)
if (gs.squad_slots[k] != o.squad_slots[k]) {
std::printf(" slot %zu (team ~%zu): ported %04x, original %04x\n", k, k / 24, gs.squad_slots[k], o.squad_slots[k]);
shown++;
}
for (size_t k = 0; k < gs.team_flags.size() && k < o.team_flags.size(); k++)
if (gs.team_flags[k] != o.team_flags[k])
std::printf(" team_flags %zu: ported %04x, original %04x\n", k, gs.team_flags[k], o.team_flags[k]);
}
if (!results) {
std::printf(" ported : %s\n original: %s\n", ours.c_str(), theirs.c_str());
// name the first differing league match (cup results follow the league bytes)
size_t at = 0, diff = 0;
while (diff < ours.size() && diff < theirs.size() && ours[diff] == theirs[diff]) diff++;
for (size_t gi = 0; gi < groups.size(); gi++) {
size_t len = groups[gi].results.size() * 2;
if (diff < at + len) {
int mi = int((diff - at) / 2);
int home = groups[gi].fixtures.at(mi * 2), away = groups[gi].fixtures.at(mi * 2 + 1);
std::printf(" first difference: group %zu match %d, teams %d-%d%s\n", gi, mi, home, away,
gs.manager_of(home) >= 0 || gs.manager_of(away) >= 0 ? " (human manager)" : "");
break;
}
at += len + groups[gi].end_minute.size() * 2 + (cup_recorded ? groups[gi].cup_results.size() * 4 : 0);
}
}
}
std::printf("%d minutes exact, %d mismatched, %d not checkable\n", ok, bad, skipped);
}
return exact == checked && full_exact == full_checked ? 0 : 2;
}