Initial public OpenBMH 0.1 source (by Codex)
This commit is contained in:
commit
558fbf166b
613 files changed
+168029
No files matched your search
@@ -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;
|
||||
}
|
||||
Reference in new issue
Block a user