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

+345
View File
@@ -0,0 +1,345 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <filesystem>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>
#include "app/controller.hpp"
#include "game/desk.hpp"
#include "game/matchday_setup.hpp"
#include "game/save.hpp"
#include "game/weekly.hpp"
using namespace bmh;
namespace fs = std::filesystem;
namespace {
void require(bool ok, const char* why) { if (!ok) throw std::runtime_error(why); }
struct TemporarySaves {
fs::path path;
explicit TemporarySaves(const fs::path& input) {
static unsigned serial = 0;
path = fs::temp_directory_path() / ("openbmh-loaded-manager-app-" +
std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()) + "-" + std::to_string(++serial));
require(fs::create_directory(path), "create isolated loaded-loop test save directory");
fs::copy_file(input, path / "AUTOSAVE.FBM");
}
~TemporarySaves() { std::error_code ignored; fs::remove_all(path, ignored); }
};
struct Context {
fs::path data;
TemporarySaves saves;
ui::StartupFlow flow;
std::unique_ptr<app::CareerSession> session;
uint64_t revision = 0;
openbmh::audio::Playback playback;
std::optional<uint64_t> audio;
Context(const fs::path& d, const fs::path& input) : data(d), saves(input), flow(d, saves.path) {
require(load_savegame(input).checksum_ok, "input Native fixture checksum");
playback.set_muted(true);
flow.click(214, 215);
const auto request = flow.send_key("ENTER");
require(request.request == ui::FlowRequest::file_action && request.file_action.action == ui::SaveLoadAction::load,
"actual StartupFlow requests Native load");
require(serve(request).empty() && session && revision == 1 && flow.screen_name() == "desktop",
"actual controller loads two-manager Native desk");
const auto driver = session->manager_join_checkpoint().driver;
require(session->state().manager_teams.size() == 2 && driver.loaded_matchday_resume &&
!driver.suppress_remaining_pre_match_offers && driver.stage == TurnDriver::Stage::MatchdayDesks,
"successful actual FBM restore owns provenance without automatically selecting suppression");
}
std::string serve(const ui::FlowResult& request, PendingOfferHooks hooks = {},
app::PendingOfferEntryPolicy policy = app::PendingOfferEntryPolicy::normal_interactive) {
return app::serve_flow_request(flow, request, session, data, saves.path, 1, revision, playback, audio, false,
{}, {}, {}, {}, {}, {}, {}, {}, std::move(hooks), policy);
}
ui::FlowResult advance() {
require(flow.desktop() && !flow.desktop()->pending(), "real desktop owns no previous request");
const auto& items = flow.desktop()->state().items;
const auto item = std::find_if(items.begin(), items.end(), [](const auto& i) {
return !i.disabled && (i.kind == 12 || (i.kind == 58 && i.open));
});
require(item != items.end(), "actual enabled ADVANCE/Weiter item exists");
auto request = flow.click(item->x + item->width / 2, item->y + item->height / 2);
require(request.request == ui::FlowRequest::kickoff && flow.desktop()->pending() &&
request.desk_action.revision == revision, "actual flow issues current owned kickoff request");
return request;
}
};
struct Snapshot { Bytes native; WatcomRandom w; GameRandom g; };
Snapshot snapshot(const GameState& s, const WatcomRandom& w, const GameRandom& g) { return {save_stream(s), w, g}; }
Snapshot snapshot(app::CareerSession& s) { return snapshot(s.state(), s.rand(), s.game()); }
bool equal(const Snapshot& a, const Snapshot& b) {
return a.native == b.native && a.w.seed() == b.w.seed() && a.w.calls() == b.w.calls() &&
a.g.seed() == b.g.seed() && a.g.calls() == b.g.calls();
}
void same(const Snapshot& a, const Snapshot& b) { require(equal(a, b), "entire Native stream and W/G seeds/counts match Source oracle"); }
bool same_group(const MatchGroup& a, const MatchGroup& b) {
return a.desc == b.desc && a.fixtures == b.fixtures && a.results == b.results &&
a.cup_results == b.cup_results && a.cup_other_leg == b.cup_other_leg &&
a.cup_result_address[0] == b.cup_result_address[0] && a.cup_result_address[1] == b.cup_result_address[1] &&
a.phase == b.phase && a.records == b.records && a.end_minute == b.end_minute &&
a.spectators == b.spectators && a.log == b.log && a.ended == b.ended && a.kickoff_void_mask == b.kickoff_void_mask;
}
bool same_groups(const std::vector<MatchGroup>& a, const std::vector<MatchGroup>& b) {
return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin(), same_group);
}
void same_driver(const TurnDriver& a, const TurnDriver& b) {
require(a.stage == b.stage && a.manager_position == b.manager_position && a.revision == b.revision &&
a.calendar_entry == b.calendar_entry && a.session_id == b.session_id && a.next_event_id == b.next_event_id &&
a.loaded_matchday_resume == b.loaded_matchday_resume &&
a.suppress_remaining_pre_match_offers == b.suppress_remaining_pre_match_offers &&
a.referee_source == b.referee_source && a.referees == b.referees && same_groups(a.groups, b.groups) &&
a.last_results.valid == b.last_results.valid && a.last_results.date == b.last_results.date &&
a.last_results.calendar_entry == b.last_results.calendar_entry && a.last_results.matchday == b.last_results.matchday &&
same_groups(a.last_results.groups, b.last_results.groups), "rollback retains complete bound driver including both loop flags");
}
void restored(Context& c) {
require(c.session->pending_offer_entry_policy() == app::PendingOfferEntryPolicy::legacy_unpresented &&
!c.session->pending_offer_hooks().answer && !c.session->pending_offer_hooks().select_transfer &&
!c.session->pending_offer_hooks().notice, "controller restores previous policy and empty pending hooks");
}
PendingOfferHooks supported_answers() {
PendingOfferHooks hooks;
hooks.answer = [](const GameState&, const PendingOfferQuestion&) { return PendingOfferAnswer::yes; };
// Explicit test answer to an actual presented quote; never a default/fabricated NO.
hooks.select_transfer = [](const GameState&, const TransferOfferListView&) {
return PendingOfferTransferChoice{PendingOfferTransferChoiceKind::decline, -1};
};
hooks.notice = [](const GameState&, const PendingOfferNotice&) {};
return hooks;
}
struct QuestionPoint { Bytes native; PendingOfferQuestion question; };
struct Oracle {
Snapshot pending, final;
TurnDriver driver;
std::vector<QuestionPoint> questions;
unsigned processed = 0;
};
Oracle next_desk_oracle(app::CareerSession::ManagerJoinCheckpoint checkpoint, bool process_pending,
bool include_pre_match_offer, uint64_t revision) {
Oracle out; MinuteReport report;
if (process_pending) {
const auto result = process_natural_pending_offers_after_desk(checkpoint.state,
{PendingOfferDeskRuntimeMode::normal_interactive, 2, checkpoint.driver.manager_position},
checkpoint.game, checkpoint.rand, supported_answers(), report);
require(result.completed && !report.unsupported, "Source Core pending phase completes before independent next-desk composition");
}
out.pending = snapshot(checkpoint.state, checkpoint.rand, checkpoint.game);
// Independent format field-22561 composition, deliberately not enter_event_desk(false).
const int position = checkpoint.driver.manager_position + 1;
const int manager = checkpoint.state.memory.u16(::bmh::layout::NextDeskManager + uint32_t(position) * 2);
checkpoint.state.memory.set8(::bmh::layout::DeskPosition, uint8_t(position));
checkpoint.state.memory.set8(::bmh::layout::ActiveManager, uint8_t(manager));
if (include_pre_match_offer) pre_match_offer(checkpoint.state, manager, checkpoint.game, checkpoint.rand, report);
build_pools_coupon(checkpoint.state, checkpoint.driver.groups, &checkpoint.rand);
enter_desk(checkpoint.state, manager, checkpoint.game, checkpoint.rand);
require(!report.unsupported, "Source coupon/desk composition supported");
checkpoint.driver.manager_position = position;
checkpoint.driver.revision = revision + 1;
out.final = snapshot(checkpoint.state, checkpoint.rand, checkpoint.game);
out.driver = std::move(checkpoint.driver);
return out;
}
Oracle pending_oracle(Context& c, const ui::FlowResult& request) {
auto checkpoint = c.session->manager_join_checkpoint(); Oracle out;
auto hooks = supported_answers();
hooks.answer = [&](const GameState& state, const PendingOfferQuestion& q) {
out.questions.push_back({save_stream(state), q}); return PendingOfferAnswer::yes;
};
MinuteReport report;
const auto pending = process_natural_pending_offers_after_desk(checkpoint.state,
{PendingOfferDeskRuntimeMode::normal_interactive, 2, checkpoint.driver.manager_position},
checkpoint.game, checkpoint.rand, hooks, report);
require(pending.completed && !report.unsupported && pending.salary_accepted == 1 && pending.processed == 1,
"actual generated salary demand has one complete direct Core oracle");
out.processed = pending.processed;
out.pending = snapshot(checkpoint.state, checkpoint.rand, checkpoint.game);
require(out.questions.size() == 1, "one actual Source question per offered manager");
if (checkpoint.driver.manager_position == 0) {
auto desk = next_desk_oracle(checkpoint, false, false, c.revision);
out.final = std::move(desk.final); out.driver = std::move(desk.driver);
out.driver.suppress_remaining_pre_match_offers = true;
} else {
checkpoint.driver.suppress_remaining_pre_match_offers = checkpoint.driver.loaded_matchday_resume;
checkpoint.driver.revision = c.revision;
MinuteReport turn_report;
const auto result = advance_to_next_desk(checkpoint.driver, checkpoint.state,
{request.desk_action.manager_slot, request.desk_action.revision}, checkpoint.game, checkpoint.rand, turn_report);
require(result.kind == TurnDeskKind::NextDesk && !turn_report.unsupported,
"bound direct driver oracle completes last manager and reaches fresh event");
out.final = snapshot(checkpoint.state, checkpoint.rand, checkpoint.game);
out.driver = std::move(checkpoint.driver);
}
return out;
}
void original_empty_handoff(const fs::path& data, const fs::path& input) {
Context normal(data, input);
const auto initial = normal.session->manager_join_checkpoint();
require(initial.state.date == 0 && initial.driver.manager_position == 0 &&
initial.state.memory.u16(::bmh::layout::NextDeskManager) == 0 && initial.state.memory.u16(::bmh::layout::FixtureSecondDeskCursor) == 1 &&
initial.state.manager_teams == std::vector<int>{1, 54} && initial.state.memory.u32(::bmh::layout::CompetitionSelection) != 2 &&
initial.state.memory.u8(::bmh::layout::GameMode) != 1, "untouched genuine2PNWK001 permits observable pre-match offer draws");
for (int raw = 0; raw < 4; ++raw) require(initial.state.memory.u32(::bmh::layout::OfferSlots + uint32_t(raw) * 4) == 0xffffffffu,
"genuine fixture has no pending offers");
const auto expected = next_desk_oracle(initial, true, false, 1);
const auto legacy_expected = next_desk_oracle(initial, false, true, 1);
require(expected.final.w.seed() != legacy_expected.final.w.seed() ||
expected.final.w.calls() != legacy_expected.final.w.calls() || expected.final.g.seed() != legacy_expected.final.g.seed() ||
expected.final.g.calls() != legacy_expected.final.g.calls(), "counterfactual actual30f2d has observable RNG effect");
require(normal.serve(normal.advance()).empty() && normal.revision == 2, "actual loaded normal GUI handoff completes once");
same(snapshot(*normal.session), expected.final); restored(normal);
auto driver = normal.session->manager_join_checkpoint().driver;
require(driver.loaded_matchday_resume && driver.suppress_remaining_pre_match_offers && driver.manager_position == 1 &&
normal.session->state().date == 0 && normal.session->state().memory.u8(::bmh::layout::ActiveManager) == 1,
"loaded provenance/suppression survive real handoff to ordered second manager");
// This is a product-generated second-manager checkpoint, not an Original recording.
const auto save_path = normal.saves.path / "SECOND.FBM"; std::string error;
auto save_w = normal.session->rand();
const auto expected_save = make_savegame(normal.session->state(), save_w);
require(normal.session->save_game(save_path, 1, false, error), "actual second-manager desk save succeeds");
require(load_savegame(save_path).stream == expected_save.stream && normal.session->rand().seed() == save_w.seed() &&
normal.session->rand().calls() == save_w.calls(), "production save has explicit expected save draws and full native bytes");
Context reloaded(data, save_path);
const auto reload_driver = reloaded.session->manager_join_checkpoint().driver;
require(reload_driver.loaded_matchday_resume && !reload_driver.suppress_remaining_pre_match_offers &&
reload_driver.manager_position == 1 && reloaded.session->state().memory.u8(::bmh::layout::ActiveManager) == 1,
"new actual load regenerates provenance without serializing borrowed suppression");
const auto reloaded_message = reloaded.serve(reloaded.advance());
if (!reloaded_message.empty() || reloaded.revision != 2) {
const auto after = reloaded.session->manager_join_checkpoint();
throw std::runtime_error("reloaded last manager advances to a fresh loop: message=" + reloaded_message +
" revision=" + std::to_string(reloaded.revision) + " stage=" + std::to_string(int(after.driver.stage)) +
" position=" + std::to_string(after.driver.manager_position) + " calendar=" + std::to_string(after.driver.calendar_entry) +
" date=" + std::to_string(after.state.date) + " flow=" + reloaded.flow.state_json());
}
const auto fresh = reloaded.session->manager_join_checkpoint();
require(!fresh.driver.loaded_matchday_resume && !fresh.driver.suppress_remaining_pre_match_offers &&
fresh.driver.manager_position == 0, "last departure consumes both runtime flags before fresh event");
const auto fresh_expected = next_desk_oracle(fresh, true, true, reloaded.revision);
const auto falsely_suppressed = next_desk_oracle(fresh, true, false, reloaded.revision);
require(!equal(fresh_expected.final, falsely_suppressed.final), "fresh loop fixture detects accidental offer suppression");
require(reloaded.serve(reloaded.advance(), supported_answers()).empty(), "actual fresh loop still enters later manager desk");
same(snapshot(*reloaded.session), fresh_expected.final); restored(reloaded);
require(!reloaded.session->manager_join_checkpoint().driver.loaded_matchday_resume &&
!reloaded.session->manager_join_checkpoint().driver.suppress_remaining_pre_match_offers,
"fresh GUI handoff retains fresh provenance");
Context legacy(data, input);
require(legacy.serve(legacy.advance(), {}, app::PendingOfferEntryPolicy::legacy_unpresented).empty(),
"default legacy-compatible loaded path completes handoff");
same(snapshot(*legacy.session), legacy_expected.final); restored(legacy);
require(legacy.session->manager_join_checkpoint().driver.loaded_matchday_resume &&
!legacy.session->manager_join_checkpoint().driver.suppress_remaining_pre_match_offers,
"legacy retains provenance without selecting suppression");
require(legacy.serve(legacy.advance(), {}, app::PendingOfferEntryPolicy::legacy_unpresented).empty(),
"legacy last manager completes its original driver path");
driver = legacy.session->manager_join_checkpoint().driver;
require(!driver.loaded_matchday_resume && !driver.suppress_remaining_pre_match_offers,
"legacy also consumes provenance at completed loop");
}
GameState generated_demands(Context& c) {
GameState state = c.session->state();
for (int manager = 0; manager < 2; ++manager) {
bool found = false;
for (uint32_t seed = 1; seed <= 16384 && !found; ++seed) {
auto candidate = state; auto game = c.session->game(); WatcomRandom rand(seed); MinuteReport report;
if (!pre_match_offer(candidate, manager, game, rand, report) || report.unsupported) continue;
const uint32_t word = candidate.memory.u32(::bmh::layout::OfferSlots + uint32_t(manager) * 4);
if (!(word & 0x80000000u) || (word & 31) != uint32_t(manager)) continue;
// Owner1 is validated after the actual handoff; generation does not
// fabricate its cursor or run a known-invalid continuation request.
if (manager == 0) {
auto checked = candidate; auto checked_g = c.session->game(); auto checked_w = c.session->rand();
MinuteReport check_report;
const auto result = process_natural_pending_offers_after_desk(checked,
{PendingOfferDeskRuntimeMode::normal_interactive, 2, manager}, checked_g, checked_w,
supported_answers(), check_report);
if (!result.completed || check_report.unsupported || result.salary_accepted != 1) continue;
}
std::printf("controlled pre_match_offer-generated fixture: owner%d seed%u Wcalls%llu Gcalls%llu\n",
manager, seed, static_cast<unsigned long long>(rand.calls()), static_cast<unsigned long long>(game.calls()));
state = std::move(candidate); found = true;
}
require(found, "actual Source pre_match_offer produces bounded supported salary fixture for each manager");
}
return state;
}
void waiting(Context& c, const Snapshot& before, const TurnDriver& driver, uint64_t revision) {
same(snapshot(*c.session), before); same_driver(c.session->manager_join_checkpoint().driver, driver); restored(c);
require(c.revision == revision && c.flow.desktop()->state().revision == revision && !c.flow.desktop()->pending() &&
c.flow.screen_name() == "desktop" && c.playback.queued_bytes() == 0,
"Waiting rejects owned UI request at same revision without audio or simulation");
}
void generated_offer_handoffs(const fs::path& data, const fs::path& input) {
Context c(data, input);
// Controlled transformation of the genuine2P state through actual Source helper
// calls; no offer word, salary, bid row, player or manager is fabricated.
c.session->state() = generated_demands(c);
const auto later_word = c.session->state().memory.u32(::bmh::layout::Weekly_PreMatchOffer_RuntimeField);
const auto later_pool = c.session->state().squad_slots.at(0xb70 + 41);
for (int position = 0; position < 2; ++position) {
const auto before = snapshot(*c.session); const auto checkpoint = c.session->manager_join_checkpoint();
const auto revision = c.revision;
require(checkpoint.driver.loaded_matchday_resume && checkpoint.driver.manager_position == position &&
checkpoint.driver.suppress_remaining_pre_match_offers == (position != 0),
"correct durable flags enter each actual offered manager desk");
require(c.serve(c.advance()).empty(), "empty real presenter leaves owned offer at Waiting instead of implicit NO");
waiting(c, before, checkpoint.driver, revision);
if (position == 1) {
PendingOfferHooks stopped;
stopped.answer = [](const GameState&, const PendingOfferQuestion&) -> PendingOfferAnswer {
throw std::runtime_error("loaded manager presenter stopped");
};
require(c.serve(c.advance(), std::move(stopped)).empty(), "throwing second-manager answer returns controlled Waiting");
waiting(c, before, checkpoint.driver, revision);
}
const auto request = c.advance(); const auto expected = pending_oracle(c, request); unsigned answers = 0;
auto hooks = supported_answers();
hooks.answer = [&](const GameState& staged, const PendingOfferQuestion& q) {
require(answers < expected.questions.size() && save_stream(staged) == expected.questions[answers].native &&
q.manager == position && q.raw_offer_slot == position && q.source_flags == 1 &&
q.clicked_source_slot == expected.questions[answers].question.clicked_source_slot &&
q.amount == expected.questions[answers].question.amount, "actual offered manager borrows exact staged Core question");
++answers; same(snapshot(*c.session), before); same_driver(c.session->manager_join_checkpoint().driver, checkpoint.driver);
require(c.revision == revision && c.flow.desktop()->state().revision == revision,
"pending question has no intermediate live revision");
std::string error;
require(c.session->dispatch_kickoff(request.desk_action, c.revision, error).kind == TurnDeskKind::Failed &&
error == "pending_offer_decision_active", "nested kickoff cannot consume loaded-loop provenance");
require(!c.session->save_game(c.saves.path / "PARTIAL.FBM", position, false, error) &&
error == "pending_offer_decision_active", "staged loaded-loop state cannot be saved");
return PendingOfferAnswer::yes;
};
require(c.serve(request, std::move(hooks)).empty() && answers == 1 && c.revision == revision + 1,
"fresh owned retry resolves manager once with single outer revision");
same(snapshot(*c.session), expected.final); same_driver(c.session->manager_join_checkpoint().driver, expected.driver); restored(c);
if (position == 0) require(c.session->state().memory.u32(::bmh::layout::OfferSlots) == 0xffffffffu &&
c.session->state().memory.u32(::bmh::layout::Weekly_PreMatchOffer_RuntimeField) == later_word &&
c.session->state().squad_slots.at(0xb70 + 41) == later_pool,
"earlier offered manager clears only its own word and preserves later owner through loaded handoff");
const auto settled = snapshot(*c.session); const auto settled_driver = c.session->manager_join_checkpoint().driver;
require(c.serve(request).empty(), "consumed old UI request is ignored before decision dispatch");
same(snapshot(*c.session), settled); same_driver(c.session->manager_join_checkpoint().driver, settled_driver);
}
require(!c.session->manager_join_checkpoint().driver.loaded_matchday_resume &&
!c.session->manager_join_checkpoint().driver.suppress_remaining_pre_match_offers,
"actual last offered manager consumes loaded-loop flags before fresh preparation");
}
} // namespace
int main(int argc, char** argv) {
try {
require(argc == 3, "usage: loaded_manager_loop_app_tests ORIGINAL_DATA 2PNWK001.FBM");
if (!*argv[1]) { std::puts("loaded manager loop app tests skipped: Original data not configured"); return 77; }
original_empty_handoff(argv[1], argv[2]); generated_offer_handoffs(argv[1], argv[2]);
std::puts("loaded manager loop app tests: genuine handoff, Source helper oracle, legacy/fresh lifetime, save/reload and generated pending rollback passed");
return 0;
} catch (const std::exception& e) { std::fprintf(stderr, "loaded_manager_loop_app_tests: %s\n", e.what()); return 1; }
}