Files
Dreierpack-Manager/tests/bank_app_tests.cpp
T
ClaudeandClaude cb6d3b6035 League system: the league tables of the loaded game as one structure
The mutable globals of schedule.hpp (league sizes, calendar groups, promotion
ladder, European places, league suffixes, newcomers, English competitions) are
members of LeagueSystem in world_layout.hpp, read through league_system() and
written only by the installer of a game version. Values and uses are unchanged.
The size check of set_league_sizes asks the world layout for the league teams.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 22:13:40 +01:00

3906 lines
266 KiB
C++

#include "runtime_fixture_tables.hpp"
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include "test_inputs.hpp"
#include <algorithm>
#include <array>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <limits>
#include <stdexcept>
#include "app/career_session.hpp"
#include "app/window_actions.hpp"
#include "formats/m3d.hpp"
#include "formats/fbm.hpp"
#include "game/career.hpp"
#include "game/cup.hpp"
#include "game/matchday_setup.hpp"
#include "game/schedule.hpp"
#include "game/table.hpp"
#include "game/desk_actions.hpp"
#include "game/bank_credit.hpp"
#include "game/match_engine.hpp"
#include "game/month.hpp"
#include "game/weekly.hpp"
#include "game/matchday.hpp"
#include "game/matchday_setup.hpp"
#include "game/messages.hpp"
#include "game/season.hpp"
#include "game/save.hpp"
#include "game/turn.hpp"
#include "game/week.hpp"
#include "ui/flow.hpp"
#include "ui/pending_offer.hpp"
using namespace bmh;
using namespace bmh::ui;
namespace { void check(bool ok, const char* text) { if (!ok) throw std::runtime_error(text); } }
namespace {
bool expected_symlink_unavailable(const std::error_code& error) {
#if defined(_WIN32)
// MSVC's system_category does not map ERROR_PRIVILEGE_NOT_HELD to errc.
if (error.category() == std::system_category() && error.value() == 1314)
return true;
#endif
return error == std::errc::permission_denied ||
error == std::errc::operation_not_permitted ||
error == std::errc::function_not_supported ||
error == std::errc::operation_not_supported;
}
void test_toto_deadline_native_save(const std::filesystem::path& data) {
const auto input = bmh::test::external_input("bank-deadline.fbm");
check(std::filesystem::exists(input), "captured Original WEEK196 fixture is available");
const auto directory=std::filesystem::temp_directory_path() /
("openbmh-toto-deadline-"+std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
std::filesystem::create_directories(directory);
for (int scenario : {0,1,2,3,4}) {
const bool change=scenario==1 || scenario==4;
const auto captured=scenario==3 ? bmh::test::external_input("bank-timer.fbm") : input;
const auto file=directory/"AUTOSAVE.FBM";
std::filesystem::copy_file(captured,file,std::filesystem::copy_options::overwrite_existing);
app::CareerSession session(data, 8128, file);
uint64_t revision=1;
StartupFlow flow(data, directory);
flow.click(190,215);
// Authenticate a normal load request; the production session reads
// the unchanged captured save. No Native availability/coupon setters.
auto load=flow.send_key("ENTER");
check(load.request==FlowRequest::file_action && flow.pending_file() && flow.pending_file()->path==file,
"ordinary startup request authenticates the actual captured input path");
flow.attach_loaded_game(session.desktop_projection(revision),session.preparation_projection(revision));
const auto& items=flow.desktop()->state().items;
const auto item=std::find_if(items.begin(),items.end(),[](const DeskItem& v){return v.kind==13&&!v.disabled;});
check(item!=items.end(), "Original save exposes the Toto desk entry");
flow.click(item->x+item->width/2,item->y+item->height/2);
check(flow.toto() && flow.toto()->state().available && flow.toto()->state().matches.size()==11,
"captured save has eleven real coupon pairings");
const auto before=save_stream(session.state());
const auto w=session.rand(); const auto g=session.game();
if(change) {
const auto pick=flow.toto()->state().matches[0].pick;
flow.click(pick==1?280:266,25);
}
if(scenario==2 || scenario==4) {
flow.click(100,200);
const auto initial=flow.state_json();
check(flow.in_toto_calculator() && !flow.process_timer_expired().changed && flow.state_json()==initial,
"deadline cannot consume the calculator before its initial Present");
(void)flow.render(); (void)flow.after_toto_present(100);
flow.send_key("2");
check(!flow.process_timer_expired().changed, "deadline does not interrupt an unpresented digit flash");
(void)flow.render(); (void)flow.after_toto_present(100);
check(!flow.tick_toto_source_units(103).changed && !flow.process_timer_expired().changed,
"deadline retains the four-unit key wait");
check(flow.tick_toto_source_units(104).changed && !flow.process_timer_expired().changed,
"released key must be presented before raw event8 is serviced");
(void)flow.render(); (void)flow.after_toto_present(104);
const auto cancel=flow.process_timer_expired();
check(cancel.changed && cancel.request==FlowRequest::none && flow.in_toto_calculator() &&
!flow.toto()->pending() && save_stream(session.state())==before,
"raw event8 cancels locally without a Core request or saved writes");
const auto restoring=flow.state_json();
check(!flow.process_timer_expired().changed && flow.state_json()==restoring,
"repeated deadline cannot skip the calculator's restored-frame Present");
(void)flow.render();
check(flow.after_toto_present(104).changed && !flow.in_toto_calculator() &&
flow.screen_name()=="toto" && save_stream(session.state())==before,
"restored-frame ACK returns to coupon before the outer close");
}
const auto expired=flow.process_timer_expired(0,0);
if(change) {
check(expired.request==FlowRequest::submenu_action && std::holds_alternative<TotoRequest>(expired.submenu_action),
"deadline emits a changed coupon through the ordinary typed action");
const auto request=std::get<TotoRequest>(expired.submenu_action);
if(scenario==4) check(request.stake==0, "cancelled calculator clears stake while retaining changed tips");
auto expected=session.state();
check(submit_pools_coupon(expected,request.manager_slot,request.stake,request.tips),
"independent Source coupon mutation accepts the requested values");
const auto pending=flow.state_json();
check(!flow.process_timer_expired(0,0).changed && flow.state_json()==pending && save_stream(session.state())==before,
"deadline before ACK has no saved writes and keeps its exact request");
std::string error;
check(session.dispatch_toto(request,revision,error), "normal session accepts the deadline coupon");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(save_stream(session.state())==save_stream(expected) && flow.screen_name()=="desktop",
"coupon ACK performs exactly Source writes, preserves all other bytes and returns to desk");
const auto accepted=save_stream(session.state()); const auto accepted_revision=revision;
check(!session.dispatch_toto(request,revision,error) && revision==accepted_revision && save_stream(session.state())==accepted,
"replayed coupon is inert after the ACK");
} else {
check(expired.request==FlowRequest::submenu_closed && flow.screen_name()=="desktop" &&
save_stream(session.state())==before && revision==1, "unchanged deadline has no coupon write or revision change");
}
check(session.rand().seed()==w.seed() && session.rand().calls()==w.calls() &&
session.game().seed()==g.seed() && session.game().calls()==g.calls(), "coupon expiry and ACK preserve both RNG streams");
check(flow.process_timer_expired(0,0).request==FlowRequest::kickoff && !flow.process_timer_expired(0,0).changed,
"returned coupon desk emits exactly one ordinary deadline kickoff");
std::printf("PASS: captured Toto deadline scenario=%d change=%d H8=%u\n",scenario,int(change),unsigned(session.state().memory.u8(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField)));
}
std::filesystem::remove_all(directory);
}
void throw_ad_spending_draw(int) { throw std::runtime_error("injected merchandise draw failure"); }
void test_toto_source_calculator(const std::filesystem::path& data) {
Image backdrop(320, 240);
std::fill(backdrop.pixels.begin(), backdrop.pixels.end(), 0x42);
LeagueTableRangeDialog stake(data, backdrop, TotoStakeDialogProfile{TableRangeTextMode::flat});
check(stake.minimum() == 10000 && stake.maximum() == 400000 && stake.value() == 0,
"Toto format field has fixed bounds and zero initial value");
const auto presets = stake.presets();
for (size_t i = 0; i < 6; ++i)
check(presets[i] == 20000u * uint32_t(i + 1), "Toto Source presets advance by 20,000");
check(presets[6] == 10000 && presets[7] == 400000, "Toto minimum and maximum preset keys");
(void)stake.render(); (void)stake.after_present();
const auto press = [&](std::string_view key) {
check(stake.source_input_ready(), "Toto input is ready after its previous frame/wait");
stake.key(key); (void)stake.render(); (void)stake.after_present();
check(!stake.tick_source_units(3), "Toto calculator needs all four Source wait units");
check(stake.tick_source_units(1), "fourth Toto Source unit completes the key flash");
(void)stake.render(); (void)stake.after_present();
};
press("ENTER");
check(stake.value() == 10000 && stake.open(), "below-minimum J clamps and leaves the calculator open");
press("SPACE");
for (char c : std::string("999999")) press(std::string(1, c));
check(stake.value() == 400000, "Toto digit overflow clamps to the Source maximum");
press("ENTER");
check(stake.waiting_for_exit_present(), "Toto accepted amount still requires the exit frame");
(void)stake.render();
const auto accepted = stake.after_present();
check(accepted && accepted->result == TableRangeDialogResult::accept && accepted->value == 400000,
"Toto accepts only after the final restored-frame Present");
LeagueTableRangeDialog cancelled(data, backdrop, TotoStakeDialogProfile{TableRangeTextMode::flat});
(void)cancelled.render(); (void)cancelled.after_present();
check(cancelled.cancel_from_source_event(), "Toto raw event 8 cancels its calculator");
auto restored = cancelled.render();
check(restored.pixels == backdrop.pixels, "Toto calculator cancel restores the exact owned backdrop");
const auto cancelled_result = cancelled.after_present();
check(cancelled_result && cancelled_result->result == TableRangeDialogResult::cancel,
"Toto calculator cancel has no accepted payment value");
LeagueTableRangeDialog by_mouse(data, backdrop, TotoStakeDialogProfile{TableRangeTextMode::flat});
(void)by_mouse.render(); (void)by_mouse.after_present();
check(by_mouse.pointer_down(10, 10, true), "the right button is consumed by the calculator");
check(by_mouse.render().pixels == backdrop.pixels, "the right button restores the owned backdrop");
const auto by_mouse_result = by_mouse.after_present();
check(by_mouse_result && by_mouse_result->result == TableRangeDialogResult::cancel,
"the right button closes the calculator as a cancel");
TableRangeDialogProfile table_profile;
table_profile.text_mode = TableRangeTextMode::flat;
LeagueTableRangeDialog table(data, backdrop, table_profile);
check(table.presets()[0] == 1 && table.presets()[5] == 32 && table.maximum() == 34,
"shared calculator keeps the original Table preset profile");
TotoState coupon;
coupon.manager_slot = 0; coupon.runtime_club = 0; coupon.revision = 1; coupon.available = true;
coupon.matches.resize(11);
TotoScreen screen(data, coupon);
const auto source_background = load_vga(asset_path(data / "KB", "49.VGA"));
auto frame = screen.render();
check(frame.at(255, 100) == source_background.pixels[100 * 320 + 255],
"Toto retains the source coupon raster rather than painting a generic panel");
const auto widgets = load_vga(asset_path(data / "KB", "0.VGA"));
GameRandom cross_oracle(0x340f1); // row 0, middle (draw) column
for (int discard = 0; discard < 10; ++discard) (void)cross_oracle.range(0, 8);
const int cross_y = cross_oracle.range(0, 2) * 12;
int transparent_pixels = 0, painted_pixels = 0;
for (int y = 0; y < 12; ++y) for (int x = 0; x < 16; ++x) {
const auto sprite_pixel = widgets.pixels[size_t(cross_y + y) * widgets.width + 48 + x];
if (sprite_pixel == 0) {
check(frame.at(275 + x, 20 + y) == source_background.pixels[size_t(20 + y) * 320 + 275 + x],
"Toto cross zero pixels preserve the KB49 raster underneath");
++transparent_pixels;
} else {
check(frame.at(275 + x, 20 + y) == sprite_pixel,
"Toto cross copies nonzero ink including palette ff (Source mode is not a comparekey)");
++painted_pixels;
}
}
check(transparent_pixels > 0 && painted_pixels > 0, "Original cross oracle covers transparency and painted ink");
screen.click(266, 25);
const auto request = screen.click(300, 220, true);
check(request.kind == TotoRequestKind::submit && request.stake == 10000 && request.tips[0] == 1 &&
!screen.close_requested(), "source home pick defaults stake and right-close waits for ACK");
screen.reject_action("stale_manager_or_revision");
check(!screen.close_requested() && !screen.pending(), "a rejected right-close retains the coupon for retry");
const auto retry = screen.click(300, 220, true);
coupon.revision = 2; coupon.stake = retry.stake;
for (size_t i = 0; i < 11; ++i) coupon.matches[i].pick = retry.tips[i];
screen.acknowledge(coupon);
check(screen.close_requested(), "only authoritative right-close ACK dismisses the coupon");
GameState projection_game;
projection_game.manager_teams = {0, 1};
projection_game.manager_records.resize(2 * 0xb0c);
projection_game.club_ids = {0, 2}; projection_game.club_names = {'A', 0, 'B', 0};
projection_game.memory.add_block(::bmh::layout::ActiveManager, 1); projection_game.memory.set8(::bmh::layout::ActiveManager, 1);
projection_game.memory.add_block(::bmh::layout::Coupon, 2 * 0x14);
projection_game.memory.add_block(::bmh::layout::Toto_FormatError_RuntimeField, 0x14);
projection_game.memory.add_block(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField, 44);
projection_game.memory.add_block(::bmh::layout::CareerSession_DispatchToto_RuntimeField, 1); projection_game.memory.set8(::bmh::layout::CareerSession_DispatchToto_RuntimeField, 11);
for (int i = 0; i < 11; ++i) {
projection_game.memory.set16(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField + uint32_t(i) * 4 + 2, 1);
projection_game.memory.set8(::bmh::layout::Toto_FormatError_RuntimeField + 8 + uint32_t(i), 2);
}
projection_game.memory.set32(::bmh::layout::Toto_FormatError_RuntimeField + 4, 111111); projection_game.memory.set8(::bmh::layout::Toto_FormatError_RuntimeField + 19, 9);
projection_game.memory.set32(::bmh::layout::Coupon + 4, 333333); projection_game.memory.set8(::bmh::layout::Coupon + 19, 10);
const uint32_t active_coupon = ::bmh::layout::Coupon + 0x14;
projection_game.memory.set32(active_coupon + 4, 222222); projection_game.memory.set8(active_coupon + 19, 3);
const auto projected = toto_from_game(projection_game, 77);
check(projected.previous_tips[0] == 2 && projected.previous_tips[10] == 2,
"previous Toto tips remain global across managers");
check(projected.manager_slot == 1 && projected.previous_correct == 3 && projected.previous_winnings == 222222,
"Toto hits and winnings come from the active manager coupon, not global or other-manager values");
}
void test_source_empty_issue3_cup_day(const std::filesystem::path& data,
const std::filesystem::path& temp_path) {
const auto qa06 = bmh::test::external_input("bank-cup.fbm");
check(std::filesystem::exists(qa06), "Issue-3 QA06 native save exists");
const Savegame stored = load_savegame(qa06);
constexpr uint32_t watcom_seed = 0x41386a06;
app::CareerSession loaded(data, watcom_seed, qa06);
const uint32_t entry = cup_entry_address(23);
const auto& mem = loaded.state().memory;
check(stored.checksum_ok, "Issue-3 QA06 checksum is valid");
check(loaded.state().date == 388 && loaded.state().season_day() == 17,
"Issue-3 QA06 is the captured date-388/day-17 desk");
check(find_cup(mem, 8) == 23 && mem.u32(::bmh::layout::SavedCompetition) == 0x2000 &&
int16_t(mem.u16(entry + 0x18)) == 8 && mem.u8(entry + 0x1a) == 0 &&
mem.pointer(entry) == ::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField28,
"QA06 identifies the zero-team cup-8 entry-23 stage and its rebound list pointer");
const uint32_t game_seed = mem.has(::bmh::layout::CareerSession_Save_RuntimeField) ? mem.u32(::bmh::layout::CareerSession_Save_RuntimeField) : 0;
const auto desk = loaded.desktop_projection(1);
check(desk.next_competition == 34 && desk.next_opponent == -1,
"QA06 empty cup desk projects Source defaults 34/-1");
check(save_stream(loaded.state()) == stored.stream && loaded.game().seed() == int32_t(game_seed) &&
loaded.game().calls() == 0 && loaded.rand().seed() == watcom_seed && loaded.rand().calls() == 0,
"QA06 binds and projects byte-exactly without random draws");
std::string error;
uint64_t revision = 1;
const auto next = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, int(loaded.state().memory.u8(::bmh::layout::ActiveManager)), -1, -1, -1, revision},
revision, error);
check(next.kind == TurnDeskKind::NextDesk && loaded.state().date > 388,
(std::string("QA06 empty cup desk advances to the next real desk: ") + error).c_str());
// A nonempty stage whose saved descriptor does not contain its fixtures is malformed.
GameState malformed_state = app::CareerSession(data, watcom_seed, qa06).state();
malformed_state.memory.set8(entry + 0x1a, 2);
WatcomRandom save_rand(watcom_seed);
const auto malformed_dir = temp_path / "empty-cup-tests";
std::filesystem::create_directories(malformed_dir);
const auto malformed_path = malformed_dir / "QA06-BAD-NONEMPTY-CUP.FBM";
write_savegame(malformed_path, make_savegame(malformed_state, save_rand));
app::CareerSession malformed(data, watcom_seed, malformed_path);
const Bytes malformed_before = save_stream(malformed.state());
const uint32_t malformed_game_seed = malformed.game().seed();
const uint64_t malformed_game_calls = malformed.game().calls();
uint64_t malformed_revision = 1;
const auto rejected = malformed.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, int(malformed.state().memory.u8(::bmh::layout::ActiveManager)), -1, -1, -1,
malformed_revision}, malformed_revision, error);
check(rejected.kind == TurnDeskKind::Failed && save_stream(malformed.state()) == malformed_before &&
malformed.game().seed() == malformed_game_seed && malformed.game().calls() == malformed_game_calls &&
malformed.rand().calls() == 0,
"nonempty cup descriptor without saved fixtures remains guarded without mutation");
}
struct TemporaryDirectory {
std::filesystem::path path = std::filesystem::temp_directory_path() /
("openbmh-save-load-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
TemporaryDirectory() { std::filesystem::create_directories(path); }
~TemporaryDirectory() { std::error_code ec; std::filesystem::remove_all(path, ec); }
};
uint32_t record_u32(const std::vector<uint8_t>& bytes, size_t at) {
return uint32_t(bytes.at(at)) | uint32_t(bytes.at(at + 1)) << 8 |
uint32_t(bytes.at(at + 2)) << 16 | uint32_t(bytes.at(at + 3)) << 24;
}
bool prepared_league_fixture(const GameState& g, int team, int& opponent, bool& home_side) {
for (uint32_t gi = 0; gi < 6; gi++) {
const uint32_t d = ::bmh::layout::MatchdayGroupDescriptors + gi * 0xd0;
if (!g.memory.has(d + 0xd0) || g.memory.u8(d) != 0) continue;
const int league = int(g.memory.u32(d + 0xcc));
if (league < 0 || size_t(league) >= g.league_rounds.size()) continue;
for (const auto& fixture : league_fixtures(league, int(g.league_rounds[size_t(league)]) + 1)) {
if (fixture.home == team) opponent = fixture.away, home_side = true;
else if (fixture.away == team) opponent = fixture.home, home_side = false;
else continue;
return true;
}
}
return false;
}
void set_test_record_u32(std::vector<uint8_t>& bytes, size_t at, uint32_t value) {
for (int k = 0; k < 4; ++k) bytes.at(at + size_t(k)) = uint8_t(value >> (8 * k));
}
void test_season_profit_tax(const std::filesystem::path& data, const SetupOptions& career_options,
const ManagerChoice& first) {
check(season_profit_tax(99999) == 0 && season_profit_tax(100000) == 0 &&
season_profit_tax(100001) == 0 && season_profit_tax(100010) == 1 &&
season_profit_tax(200000) == 10000 && season_profit_tax(500000) == 100000 &&
season_profit_tax(600009) == 150000,
"progressive tax follows source threshold, six bands and integer rounding");
check(season_profit_tax_refund(100000, 600000, 150000) == 0 &&
season_profit_tax_refund(0, 600000, 150000) == 50000 &&
season_profit_tax_refund(-500000, 600000, 150000) == 150000,
"next-season refund follows the source floor, proportional retention and strict threshold");
app::CareerSession session(data, 0x22aa7712);
SetupOptions options = career_options;
options.managers = 2;
std::string error;
check(session.confirm_manager(options, first, error), "profit-season first manager confirmed");
const auto context = session.selection_context(2);
const auto other = std::find_if(context.club_order.begin(), context.club_order.end(),
[&](int master) { return master != first.master_club; });
check(other != context.club_order.end(), "profit-season second club available");
ManagerChoice second = first;
second.slot = 1;
second.master_club = *other;
second.name += " B";
check(session.confirm_manager(options, second, error), "profit-season second manager confirmed");
CareerInitializationResult initialized;
check(session.finish(initialized, error), (std::string("profit-season career setup: ") + error).c_str());
// This two-season tax scenario owns its contract decisions explicitly.
// CareerSession no longer invents renewals for an absent presenter.
int contract_decisions = 0;
session.set_contract_expiry_presenter([&](GameState& state, WatcomRandom& random,
int manager, int row) -> int {
++contract_decisions;
const auto demands = contract_demands(state, manager, row, false, random);
const auto valid = [&](int term) {
const uint32_t demand = demands[size_t(term)];
return demand && demand != UINT32_MAX && demand <= 200000;
};
int term = valid(1) ? 1 : -1;
if (term < 0)
for (int i = 0; i < int(demands.size()); ++i)
if (valid(i)) { term = i; break; }
if (term < 0) return 0;
const uint32_t demand = demands[size_t(term)];
return contract_offer(state, manager, row, term, demand, demand,
false, true, random, nullptr) ? 1 : 0;
});
uint64_t revision = initialized.desktop.revision;
TurnAdvanceResult at_end;
int dispatches = 0;
for (; dispatches < 700; ++dispatches) {
const int active = int(session.state().memory.u8(::bmh::layout::ActiveManager));
at_end = session.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active, -1, -1, -1, revision}, revision, error);
check(at_end.kind != TurnDeskKind::Failed,
(std::string("two-manager career reaches its real season-end desk at dispatch ") +
std::to_string(dispatches) + " date " + std::to_string(session.state().date) + ": " + error).c_str());
if (at_end.kind == TurnDeskKind::SeasonEndDesk) break;
}
check(at_end.kind == TurnDeskKind::SeasonEndDesk && dispatches < 700,
"two-manager production driver reaches SeasonEndDesk");
// format field visits every manager before34e24 starts annual accounts.
// The tax fixture seeds its balances only after all closing desk hooks.
const auto finish_closing_desks = [&] {
const auto date = session.state().date;
const auto season = session.state().season;
while (session.state().memory.u8(::bmh::layout::DeskPosition) + 1 < session.state().manager_teams.size()) {
const int position = session.state().memory.u8(::bmh::layout::DeskPosition);
const auto remaining = session.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, int(session.state().memory.u8(::bmh::layout::ActiveManager)),
-1, -1, -1, revision}, revision, error);
check(remaining.kind == TurnDeskKind::SeasonEndDesk && session.state().date == date &&
session.state().season == season && session.state().memory.u8(::bmh::layout::DeskPosition) == position + 1,
"remaining manager acknowledges closing desktop before annual tax");
}
};
finish_closing_desks();
constexpr size_t record_size = 0xb0c;
for (int manager = 0; manager < 2; ++manager) {
const size_t rec = size_t(manager) * record_size;
const int64_t seeded_balance = int64_t(int32_t(record_u32(session.state().manager_records, rec + 0x324))) +
int32_t(record_u32(session.state().manager_records, rec + 0x30c)) + 10000000;
check(seeded_balance < std::numeric_limits<int32_t>::max(),
"profit-season seed remains within the source money field");
set_test_record_u32(session.state().manager_records, rec + 0x314, uint32_t(seeded_balance));
}
std::array<bool, 2> tax_notices{}, tax_questions{};
SeasonTaxHooks tax_hooks;
tax_hooks.observe = [&](const GameState& state, const SeasonTaxEvent& event) {
check(event.kind == SeasonTaxEventKind::notice && event.manager_slot >= 0 && event.manager_slot < 2,
"legal annual tax presents one Original ACK for each manager");
const size_t slot = size_t(event.manager_slot), rec = slot * record_size;
check(!tax_notices[slot] && event.legal_tax == season_profit_tax(event.profit) &&
record_u32(state.manager_records, rec + 0x328) == 0 &&
record_u32(state.manager_records, rec + 0x32c) == 0,
"annual tax notice is shown once before carry values are stored");
tax_notices[slot] = true;
};
tax_hooks.choose = [&](const GameState&, const SeasonTaxEvent& event) {
const size_t slot = size_t(event.manager_slot);
check(event.kind == SeasonTaxEventKind::question && tax_notices.at(slot) && !tax_questions.at(slot),
"Original tax question follows its manager's ACK once");
tax_questions.at(slot) = true;
return false;
};
session.set_season_tax(std::move(tax_hooks));
const auto profit_turn = session.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, int(session.state().memory.u8(::bmh::layout::ActiveManager)), -1, -1, -1, revision},
revision, error);
check(profit_turn.kind != TurnDeskKind::Failed,
(std::string("profitable two-manager SeasonEndDesk continues: ") + error).c_str());
session.set_season_tax({});
check(tax_notices[0] && tax_notices[1] && tax_questions[0] && tax_questions[1],
"both managers acknowledge the Original notice and explicitly answer NO");
for (int manager = 0; manager < 2; ++manager) {
const size_t rec = size_t(manager) * record_size;
const int32_t taxable = int32_t(record_u32(session.state().manager_records, rec + 0x32c));
const int32_t paid = int32_t(record_u32(session.state().manager_records, rec + 0x328));
check(taxable > 100000 && paid == season_profit_tax(taxable),
"each manager stores the real-season taxable profit and full legal tax");
}
const auto& mailbox_bytes = session.state().mailbox;
// The notice prefix is also used by unrelated qualification messages;
// distinguish the tax notice using its additional message segment.
const std::string source_tax_prefix = message_text(session.state(), ::bmh::layout::Season_SeasonApplyProfitTax_TextPointer2);
size_t source_notices = 0;
if (!source_tax_prefix.empty()) {
for (size_t entry = 0; entry + kMailboxEntry <= mailbox_bytes.size(); entry += kMailboxEntry) {
const std::string text(mailbox_bytes.begin() + long(entry + 10),
mailbox_bytes.begin() + long(entry + kMailboxEntry));
if (text.find(source_tax_prefix) != std::string::npos) ++source_notices;
}
}
check(source_notices == 0,
"Original legacy routine tax acknowledgement is not delivered as mailbox mail");
std::array<int32_t, 2> previous_profit{}, previous_tax{};
for (int manager = 0; manager < 2; ++manager) {
const size_t rec = size_t(manager) * record_size;
previous_profit[size_t(manager)] = int32_t(record_u32(session.state().manager_records, rec + 0x32c));
previous_tax[size_t(manager)] = int32_t(record_u32(session.state().manager_records, rec + 0x328));
}
TurnAdvanceResult next_season_end;
for (int next = 0; next < 700; ++next) {
const int active = int(session.state().memory.u8(::bmh::layout::ActiveManager));
next_season_end = session.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active, -1, -1, -1, revision}, revision, error);
check(next_season_end.kind != TurnDeskKind::Failed,
(std::string("second season reaches its real end desk: ") + error).c_str());
if (next_season_end.kind == TurnDeskKind::SeasonEndDesk) break;
}
check(next_season_end.kind == TurnDeskKind::SeasonEndDesk,
"taxed career reaches the following SeasonEndDesk");
finish_closing_desks();
check(contract_decisions > 0, "two-season tax scenario handles real contract expiries explicitly");
for (int manager = 0; manager < 2; ++manager) {
const size_t rec = size_t(manager) * record_size;
const int64_t loss_balance = int64_t(int32_t(record_u32(session.state().manager_records, rec + 0x324))) +
int32_t(record_u32(session.state().manager_records, rec + 0x30c)) - 10000000;
check(loss_balance > std::numeric_limits<int32_t>::min(),
"refund-season seed remains within the source money field");
set_test_record_u32(session.state().manager_records, rec + 0x314, uint32_t(loss_balance));
}
const auto refund_turn = session.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, int(session.state().memory.u8(::bmh::layout::ActiveManager)), -1, -1, -1, revision},
revision, error);
check(refund_turn.kind != TurnDeskKind::Failed,
(std::string("loss-making second SeasonEndDesk continues with refund: ") + error).c_str());
for (int manager = 0; manager < 2; ++manager) {
const size_t rec = size_t(manager) * record_size;
check(previous_profit[size_t(manager)] > 100000 && previous_tax[size_t(manager)] > 0 &&
int32_t(record_u32(session.state().manager_records, rec + 0x32c)) == 0,
"next season clears the taxable-profit carry after refund calculation");
const std::string refund_amount = format_amount(session.state(), previous_tax[size_t(manager)]);
const std::string second_mail(session.state().mailbox.begin(), session.state().mailbox.end());
const std::string refund_notice = message_text(session.state(), ::bmh::layout::Season_SeasonAccounts_TextPointer4) + refund_amount + ".";
check(second_mail.find(refund_notice) != std::string::npos,
"next-season mailbox reports the source-computed tax refund amount");
}
}
int first_source_reset_player(const GameState& g, int team) {
const SquadRange range = squad_range(team);
for (size_t i = range.first; i < range.first + range.count; i++) {
const uint16_t slot = g.squad_slots.at(i);
if ((slot & 0x0fff) == 0x0fff) continue;
const int player = slot & 0x0fff;
if (size_t(player) < g.players.size() && (g.players[size_t(player)].w35c >> 27) == 0) return player;
}
return -1;
}
void check_forfeit_reset(const GameState& before, const GameState& after, int player) {
check(player >= 0, "forfeit source-reset fixture has eligible player");
const uint32_t old368 = before.players.at(size_t(player)).w368;
const uint32_t old364 = before.players.at(size_t(player)).w364;
const uint16_t cards = before.player_cards.at(size_t(player));
const uint32_t expected368 = (old368 & 0xf8fc3fffu) |
(uint32_t(cards >> 9 & 7) << 24) |
(uint32_t(cards >> 5 & 0xf) << 14);
const uint32_t expected364 = (old364 & 0xffe0ffffu) |
(uint32_t(old364 >> 13 & 7) << 16);
check(after.players.at(size_t(player)).w368 == expected368 &&
after.players.at(size_t(player)).w364 == expected364,
"forfeit restores card and injury attributes through legacy routine");
}
void test_friendly_booking(const GameState& source, int manager) {
const int own_team = source.manager_teams.at(size_t(manager));
int opponent = -1;
for (int team = 0; team < 168; ++team) {
if (team != own_team) { opponent = team; break; }
}
check(opponent >= 0, "friendly test has a club opponent");
const int today = source.memory.u16(::bmh::layout::DaysIntoSeason);
uint16_t day = 0;
const FriendlyBookingQuote quote = quote_friendly_match(source, manager, opponent, true);
check(quote.status == FriendlyQuoteStatus::quoted, "friendly fee quote is available before date selection");
for (int candidate = today + 1; candidate < 0x16e; ++candidate) {
const FriendlyDateStatus status = friendly_match_date_status(source, quote, uint16_t(candidate));
if (status == FriendlyDateStatus::available || status == FriendlyDateStatus::available_with_calendar_event) {
day = uint16_t(candidate); break;
}
}
check(day != 0, "source-calendar fixture has an available friendly date");
const Bytes before_bytes = save_stream(source);
const auto pure_quote = quote_friendly_match(source, manager, opponent, true);
check(pure_quote.status == FriendlyQuoteStatus::quoted && pure_quote.cost == quote.cost &&
save_stream(source) == before_bytes,
"friendly quote is read-only and returns the source cost");
GameState full_plan = source;
int fill_slot = 0;
for (int candidate = today + 3; candidate < 0x16e && fill_slot < 30; ++candidate) {
if (std::abs(candidate - int(day)) <= 1) continue;
const uint32_t date_at = ::bmh::layout::FriendlyDays + uint32_t(fill_slot) * 2;
const uint32_t teams_at = ::bmh::layout::FriendlyTeams + uint32_t(fill_slot) * 4;
full_plan.memory.set16(date_at, uint16_t(candidate));
full_plan.memory.set16(teams_at, uint16_t((own_team + 1) % 168));
full_plan.memory.set16(teams_at + 2, uint16_t((own_team + 2) % 168));
++fill_slot;
}
check(fill_slot == 30, "full friendly plan fixture fills all 30 source slots");
const Bytes full_plan_before = save_stream(full_plan);
FriendlyBookingRequest full_request;
full_request.quote = quote; full_request.season_day = day;
full_request.accept_cost = true; full_request.approving_manager = quote.payer_manager;
check(friendly_match_date_status(full_plan, quote, day) == FriendlyDateStatus::plan_full &&
book_friendly_match(full_plan, full_request).status == FriendlyBookingStatus::plan_full &&
save_stream(full_plan) == full_plan_before,
"full 30-slot plan rejects before fee and preserves every previously booked fixture");
FriendlyBookingRequest request;
request.quote = pure_quote; request.season_day = day; request.accept_cost = false;
GameState declined = source;
const auto declined_result = book_friendly_match(declined, request);
check(declined_result.status == FriendlyBookingStatus::declined &&
save_stream(declined) == before_bytes,
"declining the home-game cost leaves planner, calendar and finances untouched");
if (source.level != 0) {
GameState cannot_pay = source;
const size_t rec = size_t(manager) * 0xb0c;
for (size_t i = 0; i < 4; ++i) {
cannot_pay.manager_records.at(rec + 0x314 + i) = 0;
cannot_pay.manager_records.at(rec + 0x31c + i) = 0;
}
const Bytes no_funds_before = save_stream(cannot_pay);
request.accept_cost = true;
request.approving_manager = pure_quote.payer_manager;
check(book_friendly_match(cannot_pay, request).status == FriendlyBookingStatus::insufficient_funds &&
save_stream(cannot_pay) == no_funds_before,
"unaffordable friendly booking is rejected without partial planner or finance writes");
}
GameState adjacent_conflict = source;
adjacent_conflict.memory.set16(::bmh::layout::FriendlyDays, uint16_t(day + 1));
adjacent_conflict.memory.set16(::bmh::layout::FriendlyTeams, uint16_t(own_team));
adjacent_conflict.memory.set16(::bmh::layout::FixtureSecondBookedFriendly, uint16_t(opponent));
check(friendly_match_date_status(adjacent_conflict, pure_quote, day) == FriendlyDateStatus::unavailable,
"source three-day conflict window rejects a fixture on the following day");
for (const uint16_t raw_event : {uint16_t(0x0040), uint16_t(0x0100)}) {
GameState raw_calendar = source;
raw_calendar.memory.set16(::bmh::layout::CompetitionCalendar + uint32_t(day) * 2, raw_event);
const Bytes raw_before = save_stream(raw_calendar);
check(friendly_match_date_status(raw_calendar, pure_quote, day) == FriendlyDateStatus::unavailable &&
book_friendly_match(raw_calendar, request).status == FriendlyBookingStatus::date_unavailable &&
save_stream(raw_calendar) == raw_before,
"selected raw 0x40/0x100 calendar flags fail legacy routine without UI bit 15 and stay inert");
}
GameState wrapped_counter = source;
wrapped_counter.memory.set8(::bmh::layout::FriendlyPlanCount, 254);
const FriendlyBookingQuote wrapped_quote = quote_friendly_match(wrapped_counter, manager, opponent, true);
const Bytes wrapped_before = save_stream(wrapped_counter);
FriendlyBookingRequest wrapped_request{wrapped_quote, day, false, -1, true, wrapped_quote.payer_manager};
check(friendly_match_date_status(wrapped_counter, wrapped_quote, day) == FriendlyDateStatus::plan_full &&
book_friendly_match(wrapped_counter, wrapped_request).status == FriendlyBookingStatus::plan_full &&
save_stream(wrapped_counter) == wrapped_before,
"counter overflow is rejected before charging or shifting the planner");
request.accept_cost = true;
request.approving_manager = pure_quote.payer_manager;
GameState accepted = source;
const size_t record = size_t(manager) * 0xb0c;
const int32_t cash_before = int32_t(record_u32(accepted.manager_records, record + 0x314));
const uint32_t expense_before = record_u32(accepted.manager_records, record + 0x8a0);
const uint8_t planner_count_before = accepted.memory.u8(::bmh::layout::FriendlyPlanCount);
const uint16_t calendar_before = accepted.memory.u16(::bmh::layout::CompetitionCalendar + uint32_t(day) * 2);
const auto accepted_result = book_friendly_match(accepted, request);
check(accepted_result.status == FriendlyBookingStatus::booked &&
accepted_result.home_team == own_team && accepted_result.away_team == opponent,
"accepted booking stores the manager club at home");
bool found = false;
for (int i = 0; i < 30; ++i) {
if (accepted.memory.u16(::bmh::layout::FriendlyDays + uint32_t(i) * 2) != day) continue;
found = accepted.memory.u16(::bmh::layout::FriendlyTeams + uint32_t(i) * 4) == uint16_t(own_team) &&
accepted.memory.u16(::bmh::layout::FixtureSecondBookedFriendly + uint32_t(i) * 4) == uint16_t(opponent);
}
check(found && accepted.memory.u16(::bmh::layout::CompetitionCalendar + uint32_t(day) * 2) == uint16_t(calendar_before | 0x4001),
"accepted booking inserts a sorted team pair and marks its calendar day");
check(accepted.memory.u8(::bmh::layout::FriendlyPlanCount) == uint8_t(planner_count_before + 2),
"accepted booking increments the original planned-team counter by two");
if (source.level != 0) {
check(int32_t(record_u32(accepted.manager_records, record + 0x314)) == cash_before - pure_quote.cost &&
record_u32(accepted.manager_records, record + 0x8a0) == expense_before + uint32_t(pure_quote.cost),
"successful home booking permanently charges the quoted fee and books expense-other");
}
FriendlyBookingRequest forged = request;
forged.season_day = uint16_t(day + 4);
for (; forged.season_day < 0x16e; ++forged.season_day) {
const FriendlyDateStatus status = friendly_match_date_status(source, pure_quote, forged.season_day);
if (status == FriendlyDateStatus::available || status == FriendlyDateStatus::available_with_calendar_event) break;
}
forged.approving_manager = manager == pure_quote.payer_manager ? manager + 1 : manager;
GameState forged_state = source;
const Bytes forged_bytes = save_stream(forged_state);
check(forged.season_day < 0x16e &&
book_friendly_match(forged_state, forged).status == FriendlyBookingStatus::invalid_request &&
save_stream(forged_state) == forged_bytes,
"stale or forged cost approval is rejected without mutation");
FriendlyBookingRequest repeat = request;
GameState repeated = accepted;
const Bytes accepted_bytes = save_stream(repeated);
check(book_friendly_match(repeated, repeat).status == FriendlyBookingStatus::stale_quote &&
save_stream(repeated) == accepted_bytes,
"same-day duplicate fixture is rejected without another charge");
}
void test_friendly_season_end_dates(const GameState& source, int manager) {
int opponent = -1;
for (int team = 0; team < 168; ++team) {
if (team != source.manager_teams.at(size_t(manager))) { opponent = team; break; }
}
check(opponent >= 0, "season-boundary fixture has an opponent");
auto at_season_start = [&](uint32_t start) {
GameState g = source;
g.season_start = start;
g.date = start;
g.memory.set16(::bmh::layout::DaysIntoSeason, 0);
g.memory.set8(::bmh::layout::FriendlyPlanCount, 0);
for (size_t i = 0; i < 30; ++i) {
g.memory.set16(::bmh::layout::FriendlyDays + uint32_t(i) * 2, 0);
g.memory.set16(::bmh::layout::FriendlyTeams + uint32_t(i) * 4, 0xffff);
g.memory.set16(::bmh::layout::FixtureSecondBookedFriendly + uint32_t(i) * 4, 0xffff);
}
for (uint32_t day = 0; day <= 365; ++day)
g.memory.set16(::bmh::layout::CompetitionCalendar + day * 2, 0);
return g;
};
GameState regular = at_season_start(0);
const auto regular_quote = quote_friendly_match(regular, manager, opponent, true);
check(friendly_match_date_status(regular, regular_quote, 365) == FriendlyDateStatus::invalid_date &&
friendly_match_date_status(regular, regular_quote, 366) == FriendlyDateStatus::invalid_date,
"regular-year July 1 season-end and out-of-calendar day cannot be booked");
GameState leap = at_season_start(365);
const auto leap_quote = quote_friendly_match(leap, manager, opponent, true);
check(friendly_match_date_status(leap, leap_quote, 365) == FriendlyDateStatus::available &&
friendly_match_date_status(leap, leap_quote, 366) == FriendlyDateStatus::invalid_date,
"leap-year June 30 remains bookable while following July 1 is outside the calendar");
}
// legacy routine: an expired contract (months 0, old duration in byte +6) is renewed on the
// manager's yes, freed on his no, and freed with a notice when the sponsor's demand is
// above the club's attraction; boards of the same bundle follow.
void test_advertising_renewal(const std::filesystem::path& data) {
app::CareerSession session(data, 0x2a3b4c52);
const auto choices = session.selection_context(1);
SetupOptions options;
ManagerChoice choice;
choice.slot = 0;
choice.name = "Verlaengerung";
choice.master_club = choices.club_order.front();
choice.selection_club = 0;
choice.roster_revision = choices.revision;
std::string error;
check(session.confirm_manager(options, choice, error), "renewal test manager confirms");
CareerInitializationResult initialized;
check(session.finish(initialized, error), "renewal test career starts");
GameState& g = session.state();
const int manager = int(g.memory.u8(::bmh::layout::ActiveManager));
const size_t contracts = size_t(manager) * 0xb0c + 0xa34;
const int attraction = bmh::club_attraction(g, g.manager_teams.at(size_t(manager)));
check(attraction > 0, "the renewal test club has an attraction above zero");
auto expired = [&](int slot, uint8_t group, uint16_t demand) {
const size_t at = contracts + size_t(slot) * 0x0c;
set_test_record_u32(g.manager_records, at, 40000);
g.manager_records.at(at + 4) = group;
g.manager_records.at(at + 5) = 0;
g.manager_records.at(at + 6) = 12;
g.manager_records.at(at + 7) = 3;
g.manager_records.at(at + 8) = uint8_t(demand);
g.manager_records.at(at + 9) = uint8_t(demand >> 8);
};
WatcomRandom rand(7);
// the shirt: a modest demand is offered, yes renews the old twelve months
expired(14, 1, 0);
auto shirt = check_advertising_renewal(g, manager, 14, rand);
check(shirt.status == AdvertisingRenewal::Status::offered && shirt.contract_slot == 14 && !shirt.question.empty(),
"an expired shirt contract with a low demand offers the renewal");
check(answer_advertising_renewal(g, manager, 14, true) && g.manager_records.at(contracts + 14 * 0x0c + 5) == 12 &&
g.manager_records.at(contracts + 14 * 0x0c + 6) == 0,
"yes renews the shirt contract for its old duration");
// TV: no frees the place
expired(15, 1, 0);
check(check_advertising_renewal(g, manager, 15, rand).status == AdvertisingRenewal::Status::offered &&
answer_advertising_renewal(g, manager, 15, false) && record_u32(g.manager_records, contracts + 15 * 0x0c) == 0,
"no frees the TV place");
// a demand far above the attraction: the sponsor declines and the place is free
expired(14, 1, 0xffff);
const auto declined = check_advertising_renewal(g, manager, 14, rand);
check(declined.status == AdvertisingRenewal::Status::declined_by_sponsor && !declined.notice.empty() &&
record_u32(g.manager_records, contracts + 14 * 0x0c) == 0,
"a sponsor demanding more than the attraction declines and frees the place");
// not expired: nothing to renew
check(check_advertising_renewal(g, manager, 14, rand).status == AdvertisingRenewal::Status::not_expired,
"a free place has nothing to renew");
// Exercise the Session transaction used by the UI, rather than only the two
// underlying Core calls above. The click binds display 14 to physical slot 14.
expired(14, 1, 0);
ui::AdvertisingRequest request;
request.request_id = 1;
request.manager_slot = manager;
request.runtime_club = g.manager_teams.at(size_t(manager));
request.revision = 90;
request.kind = ui::AdvertisingActionKind::check_renewal;
request.renewal_display_slot = 14;
request.renewal_contract_slot = 14;
std::copy_n(g.manager_records.begin() + std::ptrdiff_t(contracts + 14 * 0x0c), 12,
request.renewal_expected_contract.begin());
const auto calls_before = session.rand().calls();
const auto game_calls_before = session.game().calls();
uint64_t revision = request.revision;
const auto before_wrong_slot=save_stream(g);
auto wrong_slot=request; wrong_slot.renewal_contract_slot=13;
const auto wrong_slot_result=session.dispatch_advertising_renewal(wrong_slot,revision,error,
[](const GameState&,const AdvertisingRenewal&) {return app::CareerSession::AdvertisingRenewalPresentation::renew;});
check(!wrong_slot_result && save_stream(g)==before_wrong_slot &&
revision==request.revision && session.rand().calls()==calls_before,
"a display-to-physical slot mismatch is rejected without W, Native or revision changes");
const auto applied = session.dispatch_advertising_renewal(request, revision, error,
[](const GameState&, const AdvertisingRenewal& q) {
return q.status == AdvertisingRenewal::Status::offered
? app::CareerSession::AdvertisingRenewalPresentation::renew
: app::CareerSession::AdvertisingRenewalPresentation::abort;
});
check(applied && applied->status == AdvertisingRenewal::Status::offered &&
revision == request.revision + 1 && session.rand().calls() == calls_before + 1 &&
session.game().calls() == game_calls_before &&
g.manager_records.at(contracts + 14 * 0x0c + 5) == 12 &&
g.manager_records.at(contracts + 14 * 0x0c + 6) == 0,
"Session commits one source-bound renewal answer and exactly one W draw");
const auto committed = save_stream(g);
const auto committed_w = session.rand().calls();
request.request_id = 2;
request.revision = revision;
revision = request.revision;
expired(14, 1, 0); // prepare a fresh offer, then decline modal completion
std::copy_n(g.manager_records.begin() + std::ptrdiff_t(contracts + 14 * 0x0c), 12,
request.renewal_expected_contract.begin());
const auto before_abort = save_stream(g);
const auto before_abort_w = session.rand().calls();
const auto rejected = session.dispatch_advertising_renewal(request, revision, error,
[](const GameState&, const AdvertisingRenewal&) { return app::CareerSession::AdvertisingRenewalPresentation::abort; });
check(!rejected && revision == request.revision && save_stream(g) == before_abort &&
session.rand().calls() == before_abort_w && !error.empty(),
"unsupported modal completion rolls back the staged renewal and W draw");
// These runtime-only bytes are intentionally absent from the freshly loaded
// SaveState layout. Create explicit test-owned cells so this case exercises
// the Session's optional-byte fingerprint and checkpoint restoration path.
check(!g.memory.has(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField) && !g.memory.has(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField),
"fresh-career fixture starts without the unsaved club-modal runtime bytes");
const auto serialized_without_runtime_cells = save_stream(g);
g.memory.add_block(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField, 1);
g.memory.add_block(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField, 1);
g.memory.set8(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField, 0x2c);
g.memory.set8(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField, 0x35);
check(save_stream(g) == serialized_without_runtime_cells,
"controlled afb5b/afb5e fixture cells remain outside the serialized Native stream");
const auto runtime_before = g.chance_rain;
const auto managers_before = g.manager_teams;
const auto word_b5b = g.memory.u8(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField), word_b5e = g.memory.u8(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField);
const auto native_before_mutation = save_stream(g);
const auto w_before_mutation = session.rand().calls();
const auto g_before_mutation = session.game().calls();
const auto revision_before_mutation = revision;
const auto runtime_reject = session.dispatch_advertising_renewal(request, revision, error,
[&](const GameState&, const AdvertisingRenewal&) {
g.chance_rain = runtime_before + 7;
g.manager_teams.at(size_t(manager)) = (managers_before.at(size_t(manager)) + 1) % 89;
g.memory.set8(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField, uint8_t(word_b5b ^ 0x20));
g.memory.set8(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField, uint8_t(word_b5e ^ 0x10));
return app::CareerSession::AdvertisingRenewalPresentation::abort;
});
check(!runtime_reject && save_stream(g) == native_before_mutation &&
g.chance_rain == runtime_before && g.manager_teams == managers_before &&
g.memory.u8(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField) == word_b5b && g.memory.u8(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField) == word_b5e &&
session.rand().calls() == w_before_mutation && session.game().calls() == g_before_mutation &&
revision == revision_before_mutation,
"presenter abort restores Native, tested runtime values, manager binding, source bytes, RNGs and revision");
const auto before_answer_error = save_stream(g);
const auto answer_error_w = session.rand().calls();
const auto answer_error_revision = revision;
const auto answer_error = session.dispatch_advertising_renewal(request, revision, error,
[&](const GameState& staged, const AdvertisingRenewal&) {
auto& altered=const_cast<GameState&>(staged);
altered.manager_records.at(contracts + 14 * 0x0c + 6)=0;
return app::CareerSession::AdvertisingRenewalPresentation::renew;
});
check(!answer_error && save_stream(g)==before_answer_error &&
session.rand().calls()==answer_error_w && revision==answer_error_revision,
"a failed staged Core answer restores the entire live session before returning");
(void)committed; (void)committed_w;
request.request_id = 2; request.revision = revision;
const auto before_reentry_w = session.rand().calls();
const auto before_reentry_game = session.game().calls();
const auto before_reentry_scope = session.strengths_checkpoint().next_scope;
const auto before_reentry_stream = save_stream(g);
bool nested_strengths_opened=false;
const auto outer = session.dispatch_advertising_renewal(request, revision, error,
[&](const GameState&, const AdvertisingRenewal&) {
const auto opening = session.strengths_open_request(revision);
if (opening) nested_strengths_opened=session.dispatch_strengths(*opening, revision, error).has_value();
return app::CareerSession::AdvertisingRenewalPresentation::renew;
});
check(!outer && nested_strengths_opened && !session.strengths_owner() &&
session.strengths_checkpoint().next_scope==before_reentry_scope &&
session.rand().calls()==before_reentry_w && session.game().calls()==before_reentry_game &&
revision==request.revision && save_stream(g)==before_reentry_stream,
"a reentrant valid Strengths-open restores its owner ID, Native, both RNGs and the outer revision");
request.request_id = 2; request.revision = revision;
const auto retry = session.dispatch_advertising_renewal(request, revision, error,
[](const GameState&, const AdvertisingRenewal&) { return app::CareerSession::AdvertisingRenewalPresentation::decline; });
check(retry && g.manager_records.at(contracts + 14 * 0x0c) == 0 &&
revision == request.revision + 1,
"an aborted/reentrant offer remains safely retryable and Source No frees its contract");
request.request_id = 3;
request.revision = revision;
expired(14, 1, 0xffff);
std::copy_n(g.manager_records.begin() + std::ptrdiff_t(contracts + 14 * 0x0c), 12,
request.renewal_expected_contract.begin());
const auto before_refusal_w = session.rand().calls();
const auto refusal_bytes = save_stream(g);
const auto refusal_revision = revision;
const auto refusal_abort = session.dispatch_advertising_renewal(request, revision, error,
[](const GameState&, const AdvertisingRenewal&) { return app::CareerSession::AdvertisingRenewalPresentation::abort; });
check(!refusal_abort && save_stream(g) == refusal_bytes && session.rand().calls() == before_refusal_w &&
revision == refusal_revision,
"aborting the required sponsor refusal acknowledgement rolls back its staged mailbox/contract/W changes");
// The notice projection is the Original interactive legacy routine(manager|0x80,text,0) ACK.
AdvertisingRenewal expected_notice; expected_notice.status=AdvertisingRenewal::Status::declined_by_sponsor;
expected_notice.contract_slot=14; expected_notice.notice="Source sponsor refusal";
const auto notice_view=ui::advertising_renewal_notice_dialog(g,manager,expected_notice);
check(notice_view.kind==TaxDialogKind::acknowledgement &&
notice_view.source_manager_flags==uint8_t(manager|0x80) && notice_view.body==expected_notice.notice,
"sponsor refusal uses the existing interactive manager ACK notice adapter");
const auto refusal = session.dispatch_advertising_renewal(request, revision, error,
[](const GameState&, const AdvertisingRenewal&) {
return app::CareerSession::AdvertisingRenewalPresentation::acknowledged;
});
check(refusal && refusal->status == AdvertisingRenewal::Status::declined_by_sponsor &&
!refusal->notice.empty() && session.rand().calls() == before_refusal_w + 1 &&
revision == request.revision + 1 && record_u32(g.manager_records, contracts + 14 * 0x0c) == 0,
"Source sponsor refusal settles the contract and mailbox notice without opening a question");
}
void test_advertising_acceptance(const std::filesystem::path& data,
const std::filesystem::path& temp_path) {
app::CareerSession session(data, 0x2a3b4c51);
const auto choices = session.selection_context(1);
check(!choices.club_order.empty(), "advertising acceptance has a startup manager choice");
SetupOptions options;
ManagerChoice choice;
choice.slot = 0;
choice.name = "Werbung";
choice.master_club = choices.club_order.front();
choice.selection_club = 0;
choice.roster_revision = choices.revision;
std::string error;
check(session.confirm_manager(options, choice, error),
(std::string("advertising manager confirms: ") + error).c_str());
CareerInitializationResult initialized;
check(session.finish(initialized, error),
(std::string("advertising test career starts: ") + error).c_str());
GameState& g = session.state();
const int manager = int(g.memory.u8(::bmh::layout::ActiveManager));
const size_t rec = size_t(manager) * 0xb0c;
const size_t contracts = rec + 0xa34;
const size_t pool = rec + 0x8cc;
check(g.memory.has(::bmh::layout::AdGroupId), "advertising group counter is saved in the native state");
std::fill(g.manager_records.begin() + std::ptrdiff_t(contracts),
g.manager_records.begin() + std::ptrdiff_t(contracts + 16 * 0x0c), 0);
std::fill(g.manager_records.begin() + std::ptrdiff_t(pool),
g.manager_records.begin() + std::ptrdiff_t(pool + 3 * 0x78), 0);
auto offer = [&](size_t at, uint32_t amount, uint8_t bundle, uint8_t sponsor) {
set_test_record_u32(g.manager_records, at, amount);
g.manager_records.at(at + 4) = bundle;
g.manager_records.at(at + 5) = 12;
g.manager_records.at(at + 7) = sponsor;
};
offer(pool, 32000, 2, 2);
offer(pool + 0x0c, 18000, 1, 3);
offer(pool + 0x78, 12000, 1, 1);
offer(pool + 0xf0, 50000, 1, 4);
g.memory.set8(::bmh::layout::AdGroupId, 41);
const Bytes before_projection = save_stream(g);
const uint64_t game_draws = session.game().calls();
const uint64_t watcom_draws = session.rand().calls();
auto view = advertising_offers(g, manager, 13);
check(view.status == AdvertisingOfferStatus::available && view.pool_group == 0 &&
view.free_boards == 14 && view.offers.size() == 10 && view.offers[0].present &&
view.offers[0].monthly_amount == 32000 && view.offers[0].bundle_units == 2 &&
view.offers[0].sponsor_id == 2 && view.offers[2].present == false,
"read-only projection exposes every raw slot and reads the bundle byte at +4");
check(save_stream(g) == before_projection && session.game().calls() == game_draws &&
session.rand().calls() == watcom_draws,
"advertising offer projection changes neither saved state nor either RNG stream");
check(view.contract_slot >= 0 && view.contract_slot < 14,
"screen index is explicitly mapped to the physical contract row");
auto request_for = [&](const AdvertisingOfferList& projection, int raw) {
AdvertisingOfferRequest request;
request.manager = manager;
request.display_slot = projection.display_slot;
request.contract_slot = projection.contract_slot;
const size_t target = contracts + size_t(request.contract_slot) * 0x0c;
std::copy_n(g.manager_records.begin() + std::ptrdiff_t(target), 12, request.expected_contract.begin());
request.raw_slot = raw;
const size_t offer_at = pool + size_t(projection.pool_group) * 0x78 + size_t(raw) * 0x0c;
std::copy_n(g.manager_records.begin() + std::ptrdiff_t(offer_at), 12, request.expected_offer.begin());
return request;
};
auto stale = request_for(view, 0);
const size_t stale_pool = pool;
g.manager_records.at(stale_pool + 11) ^= 1;
const Bytes before_stale = save_stream(g);
check(accept_advertising_offer(g, stale).status == AdvertisingOfferStatus::stale_offer &&
save_stream(g) == before_stale,
"stale projected offer is rejected without partial writes");
g.manager_records.at(stale_pool + 11) ^= 1;
const uint32_t cash_before = record_u32(g.manager_records, rec + 0x314);
auto accepted = accept_advertising_offer(g, request_for(view, 0));
check(accepted.status == AdvertisingOfferStatus::accepted &&
g.memory.u8(::bmh::layout::AdGroupId) == 42 && record_u32(g.manager_records, pool) == 0,
"accepted two-board bundle consumes its saved offer and advances the saved group id once");
int bundled = 0;
for (int slot = 0; slot < 14; ++slot) {
const size_t at = contracts + size_t(slot) * 0x0c;
if (record_u32(g.manager_records, at) == 32000 && g.manager_records.at(at + 4) == 41 &&
g.manager_records.at(at + 7) == 2) ++bundled;
}
check(bundled == 2 && record_u32(g.manager_records, rec + 0x314) == cash_before &&
session.game().calls() == game_draws && session.rand().calls() == watcom_draws,
"bundle copy writes group byte +4, books no immediate money, and draws no RNG");
// The high bit is a replaceable option marker on a selected shirt slot.
g.manager_records.at(contracts + 14 * 0x0c + 6) = 0x80;
set_test_record_u32(g.manager_records, contracts + 14 * 0x0c, 777);
auto shirt = advertising_offers(g, manager, 14);
check(shirt.status == AdvertisingOfferStatus::available && shirt.offers.size() == 10 &&
shirt.offers[0].can_accept, "shirt offer is available over its source option slot");
check(accept_advertising_offer(g, request_for(shirt, 0)).status == AdvertisingOfferStatus::accepted &&
record_u32(g.manager_records, contracts + 14 * 0x0c) == 12000 &&
record_u32(g.manager_records, pool + 0x78) == 0,
"shirt contract copies into slot 14 and consumes only its own offer amount");
auto television = advertising_offers(g, manager, 15);
check(television.status == AdvertisingOfferStatus::available && television.offers.size() == 5 &&
accept_advertising_offer(g, request_for(television, 0)).status == AdvertisingOfferStatus::accepted &&
record_u32(g.manager_records, contracts + 15 * 0x0c) == 50000 &&
record_u32(g.manager_records, pool + 0xf0) == 0,
"television offer uses the five-entry pool and fixed slot 15");
GameState extension = g;
const auto extension_view = advertising_offers(extension, manager, 0);
const size_t extension_target = contracts + size_t(extension_view.contract_slot) * 0x0c;
extension.manager_records.at(extension_target + 5) = 0;
extension.manager_records.at(extension_target + 6) = 1;
const auto extension_reoffer = advertising_offers(extension, manager, 0);
const auto extension_before = save_stream(extension);
AdvertisingOfferRequest extension_request;
extension_request.manager = manager;
extension_request.display_slot = 0;
extension_request.contract_slot = extension_view.contract_slot;
std::copy_n(extension.manager_records.begin() + std::ptrdiff_t(extension_target), 12,
extension_request.expected_contract.begin());
extension_request.raw_slot = 1;
extension_request.expected_offer = extension_reoffer.offers[1].bytes;
check(extension_reoffer.status == AdvertisingOfferStatus::unsupported_extension &&
accept_advertising_offer(extension, extension_request).status ==
AdvertisingOfferStatus::unsupported_extension &&
save_stream(extension) == extension_before,
"source extension prompt stays unavailable and leaves state unchanged");
GameState full = g;
for (int slot = 0; slot < 14; ++slot) {
const size_t at = contracts + size_t(slot) * 0x0c;
set_test_record_u32(full.manager_records, at, uint32_t(100000 + slot));
full.manager_records.at(at + 6) = 0;
}
auto full_view = advertising_offers(full, manager, 0);
check(full_view.status == AdvertisingOfferStatus::available && full_view.free_boards == 0 &&
!full_view.offers[0].can_accept,
"full fourteen-board inventory disables an otherwise present bundle");
auto full_request = request_for(full_view, 1);
std::copy_n(full.manager_records.begin() + std::ptrdiff_t(
contracts + size_t(full_request.contract_slot) * 0x0c),
12, full_request.expected_contract.begin());
std::copy_n(full.manager_records.begin() + std::ptrdiff_t(pool + 0x0c),
12, full_request.expected_offer.begin());
const Bytes full_before = save_stream(full);
const auto full_result = accept_advertising_offer(full, full_request);
check(full_result.status == AdvertisingOfferStatus::insufficient_boards &&
save_stream(full) == full_before,
"full board inventory rejects acceptance atomically");
GameState selected_regular = g;
for (int slot = 0; slot < 14; ++slot) {
const size_t at = contracts + size_t(slot) * 0x0c;
std::fill_n(selected_regular.manager_records.begin() + std::ptrdiff_t(at), 12, 0);
if (slot < 13) set_test_record_u32(selected_regular.manager_records, at, uint32_t(100000 + slot));
}
const auto selected_regular_view = advertising_offers(selected_regular, manager, 0);
check(selected_regular_view.status == AdvertisingOfferStatus::available &&
selected_regular_view.offers[1].can_accept,
"a regular selected board can open the offer list when another board is free");
auto selected_regular_request = request_for(selected_regular_view, 1);
// Bind the expected data from this independent fixture, not from the parent session.
std::copy_n(selected_regular.manager_records.begin() + std::ptrdiff_t(
contracts + size_t(selected_regular_request.contract_slot) * 0x0c),
12, selected_regular_request.expected_contract.begin());
const auto selected_regular_before = save_stream(selected_regular);
selected_regular_request.expected_offer = selected_regular_view.offers[1].bytes;
check(accept_advertising_offer(selected_regular, selected_regular_request).status ==
AdvertisingOfferStatus::accepted,
"acceptance targets a free row rather than overwriting the clicked occupied board");
for (int slot = 0; slot < 13; ++slot) {
bool found = false;
for (int row = 0; row < 14; ++row)
found |= record_u32(selected_regular.manager_records, contracts + size_t(row) * 0x0c) ==
uint32_t(100000 + slot);
check(found, "accepted ad preserves every existing regular board contract");
}
check(record_u32(selected_regular.manager_records, contracts + 13 * 0x0c) !=
record_u32(selected_regular_before, contracts + 13 * 0x0c),
"accepted offer fills the remaining board without mutating the selected regular slot");
GameState ambiguous = g;
for (int slot = 0; slot < 14; ++slot) {
const size_t at = contracts + size_t(slot) * 0x0c;
set_test_record_u32(ambiguous.manager_records, at, uint32_t(100000 + slot));
ambiguous.manager_records.at(at + 6) = 0;
}
set_test_record_u32(ambiguous.manager_records, contracts, 2'000'000);
ambiguous.manager_records.at(contracts + 6) = 0x80;
// A very large option key can sort ahead of ordinary active keys. The source
// insertion writes at the tail, so guard every destination before committing.
const auto ambiguous_view = advertising_offers(ambiguous, manager, 0);
AdvertisingOfferRequest ambiguous_request;
ambiguous_request.manager = manager;
ambiguous_request.display_slot = ambiguous_view.display_slot;
ambiguous_request.contract_slot = ambiguous_view.contract_slot;
std::copy_n(ambiguous.manager_records.begin() + std::ptrdiff_t(
contracts + size_t(ambiguous_request.contract_slot) * 0x0c),
12, ambiguous_request.expected_contract.begin());
ambiguous_request.raw_slot = 1;
std::copy_n(ambiguous.manager_records.begin() + std::ptrdiff_t(pool + 0x0c),
12, ambiguous_request.expected_offer.begin());
const auto ambiguous_before = save_stream(ambiguous);
const auto ambiguous_result = accept_advertising_offer(ambiguous, ambiguous_request);
check((ambiguous_result.status == AdvertisingOfferStatus::stale_offer ||
ambiguous_result.status == AdvertisingOfferStatus::unavailable_target) &&
save_stream(ambiguous) == ambiguous_before,
"ambiguous option sort cannot overwrite a regular occupied advertising row");
const auto roundtrip_dir = temp_path / "advertising-roundtrip";
std::filesystem::create_directories(roundtrip_dir);
const auto save_path = roundtrip_dir / "ADVERTISING.FBM";
check(session.save_game(save_path, manager, true, error),
(std::string("accepted advertising state saves: ") + error).c_str());
app::CareerSession loaded(data, 0x74102513, save_path);
check(save_stream(loaded.state()) == load_savegame(save_path).stream &&
loaded.state().memory.u8(::bmh::layout::AdGroupId) == 42 &&
record_u32(loaded.state().manager_records, rec + 0x8cc) == 0 &&
record_u32(loaded.state().manager_records, rec + 0xa34 + 14 * 0x0c) == 12000 &&
record_u32(loaded.state().manager_records, rec + 0xa34 + 15 * 0x0c) == 50000,
"accepted board group, shirt, TV and cleared offers survive FBM save/load");
}
void test_advertising_spending(const std::filesystem::path& data,
const std::filesystem::path& temp_path) {
app::CareerSession session(data, 0x1a2b3c4d);
const auto choices = session.selection_context(1);
check(!choices.club_order.empty(), "advertising spend fixture has a manager choice");
SetupOptions options;
ManagerChoice choice;
choice.slot = 0;
choice.name = "Werbungskosten";
choice.master_club = choices.club_order.front();
choice.selection_club = 0;
choice.roster_revision = choices.revision;
std::string error;
check(session.confirm_manager(options, choice, error), "advertising spend manager confirms");
CareerInitializationResult initialized;
check(session.finish(initialized, error), "advertising spend career starts");
GameState& g = session.state();
const int manager = int(g.memory.u8(::bmh::layout::ActiveManager));
const size_t rec = size_t(manager) * 0xb0c;
auto request = [&](int slot, uint32_t amount, uint32_t expected, uint8_t weeks) {
return AdvertisingSpendingRequest{manager, slot, amount, expected, weeks};
};
set_test_record_u32(g.manager_records, rec + 0x850, 5000);
set_test_record_u32(g.manager_records, rec + 0x854, 7000);
set_test_record_u32(g.manager_records, rec + 0x858, 9000);
g.manager_records.at(rec + 0x287) = 0;
set_test_record_u32(g.manager_records, rec + 0x314, 1000000);
set_test_record_u32(g.manager_records, rec + 0x31c, 1000000);
const auto goods_view = advertising_spending(g, manager, 16);
const auto press_view = advertising_spending(g, manager, 17);
const auto fan_view = advertising_spending(g, manager, 18);
check(goods_view.available && goods_view.current_amount == 5000 &&
goods_view.maximum_amount == 350000 && goods_view.delivery_weeks == 0 &&
press_view.available && press_view.maximum_amount == 35000 && press_view.current_amount == 7000 &&
fan_view.available && fan_view.current_amount == 9000 && fan_view.maximum_amount == 35000,
"advertising projection reads the three saved fields and source limits");
WatcomRandom rand(0x12344321);
const uint32_t game_seed = session.game().seed();
const uint64_t game_draws = session.game().calls();
const Bytes before_projection = save_stream(g);
const auto zero_goods = set_advertising_spending(g, request(16, 0, 5000, 0), rand);
check(zero_goods.status == AdvertisingSpendingStatus::no_change &&
save_stream(g) == before_projection && rand.calls() == 0 &&
session.game().seed() == game_seed && session.game().calls() == game_draws,
"zero merchandise performs no write and consumes no RNG");
const uint32_t balance_before = record_u32(g.manager_records, rec + 0x314);
const uint32_t expense_stats_before = record_u32(g.manager_records, rec + 0x8a0);
const auto purchase = set_advertising_spending(g, request(16, 125000, 5000, 0), rand);
const uint8_t delivery = g.manager_records.at(rec + 0x287);
check(purchase.status == AdvertisingSpendingStatus::accepted && purchase.changed &&
purchase.message_address == ::bmh::layout::DeskActions_Reject_ExecutableField && record_u32(g.manager_records, rec + 0x850) == 125000 &&
delivery >= 6 && delivery <= 9 &&
record_u32(g.manager_records, rec + 0x314) == balance_before - 125000 &&
record_u32(g.manager_records, rec + 0x8a0) == expense_stats_before + 125000 &&
rand.calls() == 1 && session.game().seed() == game_seed && session.game().calls() == game_draws,
"successful merchandise charges once, stores delivery and draws one 6..9 week value");
const Bytes pending_before = save_stream(g);
auto pending = set_advertising_spending(g, request(16, 90000, 125000, delivery), rand);
check(pending.status == AdvertisingSpendingStatus::delivery_pending && !pending.changed &&
save_stream(g) == pending_before && rand.calls() == 1,
"merchandise is inert while its saved delivery countdown is pending");
const auto stale = set_advertising_spending(g, request(16, 90000, 0, 0), rand);
check(stale.status == AdvertisingSpendingStatus::stale_request &&
save_stream(g) == pending_before && rand.calls() == 1,
"stale merchandise snapshot is rejected without writes or RNG");
const uint32_t monthly_balance = record_u32(g.manager_records, rec + 0x314);
const auto press = set_advertising_spending(g, request(17, 35000, 7000, 0), rand);
const auto fan = set_advertising_spending(g, request(18, 0, 9000, 0), rand);
check(press.status == AdvertisingSpendingStatus::accepted && fan.status == AdvertisingSpendingStatus::accepted &&
record_u32(g.manager_records, rec + 0x854) == 35000 &&
record_u32(g.manager_records, rec + 0x858) == 0 &&
record_u32(g.manager_records, rec + 0x314) == monthly_balance && rand.calls() == 1,
"monthly press and fan-work budgets only write their saved DWORDs");
const Bytes monthly_before = save_stream(g);
check(set_advertising_spending(g, request(17, 35001, 35000, 0), rand).status ==
AdvertisingSpendingStatus::invalid_amount && save_stream(g) == monthly_before &&
set_advertising_spending(g, request(17, 35000, 35000, 0), rand).status ==
AdvertisingSpendingStatus::no_change && save_stream(g) == monthly_before && rand.calls() == 1,
"monthly bounds and repeated values are inert");
GameState legacy_value = g;
set_test_record_u32(legacy_value.manager_records, rec + 0x854, 40000);
const auto legacy_view = advertising_spending(legacy_value, manager, 17);
WatcomRandom legacy_rand(0x12121212);
const auto clamped = set_advertising_spending(legacy_value,
request(17, 35000, 40000, 0), legacy_rand);
check(legacy_view.available && legacy_view.current_amount == 40000 && clamped.changed &&
clamped.status == AdvertisingSpendingStatus::accepted &&
record_u32(legacy_value.manager_records, rec + 0x854) == 35000 && legacy_rand.calls() == 0,
"legacy over-limit monthly value remains editable down to the Source cap");
GameState insufficient = g;
set_test_record_u32(insufficient.manager_records, rec + 0x850, 15000);
insufficient.manager_records.at(rec + 0x287) = 0;
set_test_record_u32(insufficient.manager_records, rec + 0x314, 0);
set_test_record_u32(insufficient.manager_records, rec + 0x31c, 0);
const Bytes insufficient_before = save_stream(insufficient);
WatcomRandom no_funds_rand(0x76543210);
const auto no_funds = set_advertising_spending(insufficient,
request(16, 350000, 15000, 0), no_funds_rand);
const Bytes insufficient_after = save_stream(insufficient);
check(no_funds.status == AdvertisingSpendingStatus::insufficient_funds && no_funds.changed &&
record_u32(insufficient.manager_records, rec + 0x850) == 0 && no_funds_rand.calls() == 0 &&
no_funds.message_address == ::bmh::layout::Advertising_FormatError_TextPointer18 &&
insufficient_before != insufficient_after &&
record_u32(insufficient.manager_records, rec + 0x314) == 0,
"failed merchandise payment preserves Original clear-to-zero side effect without RNG");
GameState draw_failure = g;
draw_failure.manager_records.at(rec + 0x287) = 0;
set_test_record_u32(draw_failure.manager_records, rec + 0x850, 0);
const Bytes draw_failure_before = save_stream(draw_failure);
WatcomRandom draw_failure_rand(0x01020304);
const uint32_t draw_failure_seed = draw_failure_rand.seed();
const auto old_draw_hook = draw_hook;
draw_hook = throw_ad_spending_draw;
bool threw = false;
try { (void)set_advertising_spending(draw_failure, request(16, 1000, 0, 0), draw_failure_rand); }
catch (const std::runtime_error&) { threw = true; }
draw_hook = old_draw_hook;
check(threw && save_stream(draw_failure) == draw_failure_before &&
draw_failure_rand.seed() == draw_failure_seed && draw_failure_rand.calls() == 0,
"failed delivery draw cannot leave a half-charged merchandise purchase");
GameState level_zero = g;
level_zero.level = 0;
level_zero.manager_records.at(rec + 0x287) = 0;
set_test_record_u32(level_zero.manager_records, rec + 0x850, 0);
const uint32_t level_zero_balance = record_u32(level_zero.manager_records, rec + 0x314);
WatcomRandom level_zero_rand(0xabcdef01);
const auto level_zero_result = set_advertising_spending(level_zero,
request(16, 1000, 0, 0), level_zero_rand);
check(level_zero_result.status == AdvertisingSpendingStatus::accepted &&
record_u32(level_zero.manager_records, rec + 0x850) == 1000 &&
record_u32(level_zero.manager_records, rec + 0x314) == level_zero_balance &&
level_zero_rand.calls() == 1,
"level zero follows the source no-charge book_money success then stores/draws delivery");
const auto roundtrip_dir = temp_path / "advertising-spending-roundtrip";
std::filesystem::create_directories(roundtrip_dir);
const auto path = roundtrip_dir / "SPENDING.FBM";
check(session.save_game(path, manager, true, error), "advertising spending state saves");
app::CareerSession loaded(data, 0x8899aabb, path);
const size_t loaded_rec = size_t(manager) * 0xb0c;
check(record_u32(loaded.state().manager_records, loaded_rec + 0x850) == 125000 &&
loaded.state().manager_records.at(loaded_rec + 0x287) == delivery &&
record_u32(loaded.state().manager_records, loaded_rec + 0x854) == 35000 &&
record_u32(loaded.state().manager_records, loaded_rec + 0x858) == 0 &&
loaded.rand().calls() == 0,
"goods, delivery, and monthly budget values survive native FBM save/load");
}
void test_bank_credit(const std::filesystem::path& data, const std::filesystem::path& temp_path) {
app::CareerSession session(data, 0x1a2b3c4d);
const auto choices = session.selection_context(1);
SetupOptions options;
ManagerChoice choice;
choice.slot = 0; choice.name = "Bankkredit";
choice.master_club = choices.club_order.front(); choice.selection_club = 0;
choice.roster_revision = choices.revision;
std::string error;
check(session.confirm_manager(options, choice, error), "credit manager confirms");
CareerInitializationResult initialized;
check(session.finish(initialized, error), "credit career starts");
auto& g = session.state(); const int manager = int(g.memory.u8(::bmh::layout::ActiveManager));
const size_t rec = size_t(manager) * 0xb0c;
const uint32_t loan = ::bmh::layout::Loans + uint32_t(manager) * 0x78;
g.level = 1;
set_test_record_u32(g.manager_records, rec + 0x314, 2000000);
set_test_record_u32(g.manager_records, rec + 0x31c, 100000);
for (uint32_t i = 0; i < 6; ++i) g.memory.set32(loan + i * 4, 0);
const auto exe = bmh::test::load_executable(asset_path(data, "BMH.exe"));
const auto credit_projection = bank_from_game(g,exe,initialized.desktop.revision);
check(credit_projection.credit_labels[0]==bmh::test::expected_text("bank_app_tests-external-1").c_str()
&& credit_projection.credit_value_text[3].find("Monat")!=std::string::npos
&& credit_projection.credit_value_text[7].find("EU")!=std::string::npos,
"credit labels and units come from loaded TEXTD, not uninitialized EXE pointers");
const auto context = bank_credit_context(g, exe, manager);
check(context.available && context.rate_table[0] == 101 && context.divisor == 100.0,
"credit context projects native EXE constants and the empty bank slot");
struct Golden { uint32_t p, months, monthly; };
const Golden goldens[] = {{123456,1,124690},{123456,3,42382},{123456,12,11517},
{123456,24,5973},{123456,48,3239},{1000,48,26},{100000,48,2624},
{100001,48,2624},{500000,48,13121}};
const auto initial = save_stream(g); const auto wr = session.rand(); const auto gr = session.game();
for (const auto& golden : goldens) {
auto d = bank_credit_draft(context);
check(edit_bank_credit(context,d,0,golden.p) && edit_bank_credit(context,d,3,golden.months)
&& d.values[2] == golden.monthly && d.values[1] == golden.monthly*golden.months,
"credit rate uses Source integer steps and x87 truncation including midpoint");
}
auto draft = bank_credit_draft(context);
check(!edit_bank_credit(context,draft,2,1000) && !edit_bank_credit(context,draft,6,1)
&& !edit_bank_credit(context,draft,0,999) && draft.edits.empty(),
"bank rejects manager-only rate, repayment of empty slot and too-small loan");
check(edit_bank_credit(context,draft,0,100000) && draft.values[3] == 48 && draft.values[2] == 2624
&& draft.values[7] == 2100000 && save_stream(g) == initial,
"new credit draft is read-only and defaults to the Source 48-month term");
uint64_t revision = initialized.desktop.revision;
BankRequest request;
request.kind=BankRequestKind::bank_credit; request.manager_slot=manager;
request.runtime_club=g.manager_teams.at(size_t(manager)); request.revision=revision;
request.expected_credit=context.saved; request.credit_edits=draft.edits;
check(session.dispatch_bank(request,revision,error), "new credit commits through career dispatch");
check(record_u32(g.manager_records,rec+0x314)==2100000 && g.memory.u32(loan)==100000
&& g.memory.u32(loan+4)==125952 && g.memory.u32(loan+8)==2624 && g.memory.u32(loan+12)==48,
"new bank credit stores the Source six-word installment record");
GameState baseline = g;
set_test_record_u32(baseline.manager_records,rec+0x314,2000000);
for(uint32_t i=0;i<6;++i) baseline.memory.set32(loan+i*4,0);
check(save_stream(baseline)==initial && session.rand().seed()==wr.seed() && session.rand().calls()==wr.calls()
&& session.game().seed()==gr.seed() && session.game().calls()==gr.calls(),
"credit changes only cash and loan record, preserves statistics/investments and both RNGs");
const auto unchanged_context = bank_credit_context(g,exe,manager);
check(commit_bank_credit(g,exe,manager,unchanged_context.saved,{{0,100000}},false).status==BankCreditStatus::no_change,
"unchanged edited credit closes without a fabricated changed-projection ACK");
const auto committed=save_stream(g); const auto rev=revision;
check(!session.dispatch_bank(request,revision,error) && revision==rev && save_stream(g)==committed,
"replayed credit request cannot borrow twice");
auto current=bank_credit_context(g,exe,manager); auto partial=bank_credit_draft(current);
check(edit_bank_credit(current,partial,6,20000) && partial.fees==5200
&& partial.values[2]==2099 && partial.values[1]==100752,
"partial repayment includes format field fee and one-month interest on repayment");
check(commit_bank_credit(g,exe,manager,current.saved,partial.edits,false).status==BankCreditStatus::confirmation_required
&& save_stream(g)==committed, "declined repayment fees leave the complete save state untouched");
auto stale=current.saved; ++stale[0];
check(commit_bank_credit(g,exe,manager,stale,partial.edits,true).status==BankCreditStatus::stale_request
&& save_stream(g)==committed, "changed native loan record rejects stale credit edits");
check(commit_bank_credit(g,exe,manager,current.saved,{{3,0}},true).status==BankCreditStatus::invalid_request
&& save_stream(g)==committed, "zero-month request cannot enter the native monthly loan loop");
check(commit_bank_credit(g,exe,manager,current.saved,partial.edits,true).status==BankCreditStatus::accepted
&& record_u32(g.manager_records,rec+0x314)==2074800 && g.memory.u32(loan)==80000,
"accepted partial repayment books principal plus fees once");
const auto save_dir=temp_path/"credit-roundtrip";
std::filesystem::create_directories(save_dir);
const auto save=save_dir/"CREDIT.FBM";
check(session.save_game(save,manager,true,error), "credit saves as native FBM");
app::CareerSession loaded(data,0x99887766,save);
check(loaded.state().memory.u32(loan)==80000 && loaded.state().memory.u32(loan+8)==2099
&& save_stream(loaded.state())==load_savegame(save).stream,
"native credit and balance survive FBM reload without reconstructed values");
GameState monthly = loaded.state(), no_credit = monthly;
for(uint32_t i=0;i<6;++i) no_credit.memory.set32(loan+i*4,0);
auto month_random=session.rand(), baseline_random=month_random;
auto month_game=session.game(), baseline_game=month_game;
MinuteReport monthly_report, baseline_report;
month_change(monthly,month_random,monthly_report,&month_game);
month_change(no_credit,baseline_random,baseline_report,&baseline_game);
check(!monthly_report.unsupported && !baseline_report.unsupported
&& monthly.memory.u32(loan+16)==1 && monthly.memory.u32(loan+20)==2099
&& record_u32(monthly.manager_records,rec+0x314)==record_u32(no_credit.manager_records,rec+0x314)-2099
&& record_u32(monthly.manager_records,rec+0x89c)==record_u32(no_credit.manager_records,rec+0x89c)+2099
&& month_random.seed()==baseline_random.seed() && month_random.calls()==baseline_random.calls()
&& month_game.seed()==baseline_game.seed() && month_game.calls()==baseline_game.calls(),
"saved credit enters the existing monthly installment loop once with unchanged RNG consumption");
current=bank_credit_context(g,exe,manager); auto full=bank_credit_draft(current);
check(edit_bank_credit(current,full,6,80000) && full.fees==5800 && full.values[1]==0,
"full repayment produces zero total and Source closing fees");
check(commit_bank_credit(g,exe,manager,current.saved,full.edits,true).status==BankCreditStatus::accepted
&& record_u32(g.manager_records,rec+0x314)==1989000,
"full repayment books its remaining principal and fee");
for(uint32_t i=0;i<6;++i) check(g.memory.u32(loan+i*4)==0,"full repayment clears all six native loan words");
const uint32_t old[] = {100000,125952,2624,48,12,31488};
for(uint32_t i=0;i<6;++i) g.memory.set32(loan+i*4,old[i]);
set_test_record_u32(g.manager_records,rec+0x314,2000000);
current=bank_credit_context(g,exe,manager); auto elapsed=bank_credit_draft(current);
check(elapsed.initial_display && elapsed.values[5]==0 && current.saved[5]==31488,
"Source shows saved payments initially then clears the local working payments");
check(edit_bank_credit(current,elapsed,6,20000) && elapsed.refund==24996
&& elapsed.interest_adjustment==187 && elapsed.fees==5200 && elapsed.values[7]==1999609,
"elapsed repayment uses Source principal refund and remaining-interest adjustment");
request.revision=revision; request.expected_credit=current.saved; request.credit_edits=elapsed.edits;
request.accept_credit_fees=true;
check(session.dispatch_bank(request,revision,error) && g.memory.u32(loan+16)==0 && g.memory.u32(loan+20)==0
&& record_u32(g.manager_records,rec+0x314)==1999609,
"elapsed repayment resets elapsed and paid words after booking the actual refund");
const auto notice=session.preparation_projection(revision).bank->credit_notice;
check(notice && notice->refund==24996 && notice->text.find("24.996")!=std::string::npos,
"credit dispatch returns the original already-booked principal-refund notice");
}
void leave_six_fit_starters(GameState& g, int team) {
const SquadRange range = squad_range(team);
int starters = 0;
for (size_t i = range.first; i < range.first + range.count; i++) {
uint16_t& slot = g.squad_slots.at(i);
if ((slot & 0x0fff) == 0x0fff || !(slot & 0x8000)) continue;
if (starters++ >= 6) slot &= 0x7fff;
}
}
void test_loaded_manager_forfeit(const std::filesystem::path& data,
const std::filesystem::path& temp_path) {
StartupFlow flow(data, temp_path / "forfeit-startup");
flow.click(150, 215); flow.click(5, 225, true); flow.click(5, 225, true); flow.click(90, 169);
check(flow.pending_career() != nullptr, "forfeit test new-career flow yields manager setup");
app::CareerSession source(data, 0x74102513);
const SetupOptions options = [&] { auto o = flow.pending_career()->options; o.managers = 2; return o; }();
ManagerChoice first = flow.pending_career()->managers.at(0); first.slot = 0;
auto c1 = source.selection_context(1);
auto p1 = std::find(c1.club_order.begin(), c1.club_order.end(), first.master_club);
check(p1 != c1.club_order.end(), "first manager club exists in selection context");
first.selection_club = int(p1 - c1.club_order.begin()); first.roster_revision = c1.revision;
std::string error;
check(source.confirm_manager(options, first, error), "first manager confirms for forfeit test");
auto c2 = source.selection_context(2);
auto p2 = std::find_if(c2.club_order.begin(), c2.club_order.end(),
[&](int club) { return club != first.master_club; });
check(p2 != c2.club_order.end(), "second manager has a distinct club");
ManagerChoice second = first; second.slot = 1; second.master_club = *p2;
second.selection_club = int(p2 - c2.club_order.begin()); second.roster_revision = c2.revision;
second.name += " B";
check(source.confirm_manager(options, second, error), "second manager confirms for forfeit test");
CareerInitializationResult init;
check(source.finish(init, error), "two-manager forfeit test starts a career");
// Without the World Cup mode legacy routine removes the international days from the
// calendar: the first eight desk dispatches of a fresh career have no national team
// fixture (it used to reach an unmanned national team there and award it 0:2).
SetupOptions early_options = options;
early_options.world = false;
app::CareerSession early(data, 0x74102513);
auto early_c1 = early.selection_context(1);
ManagerChoice early_first = first;
auto early_p1 = std::find(early_c1.club_order.begin(), early_c1.club_order.end(), early_first.master_club);
check(early_p1 != early_c1.club_order.end(), "early forfeit manager is selectable");
early_first.selection_club = int(early_p1 - early_c1.club_order.begin());
early_first.roster_revision = early_c1.revision;
check(early.confirm_manager(early_options, early_first, error), "early forfeit first manager confirms");
auto early_c2 = early.selection_context(2);
ManagerChoice early_second = second;
auto early_p2 = std::find(early_c2.club_order.begin(), early_c2.club_order.end(), early_second.master_club);
check(early_p2 != early_c2.club_order.end(), "early forfeit second manager is selectable");
early_second.selection_club = int(early_p2 - early_c2.club_order.begin());
early_second.roster_revision = early_c2.revision;
check(early.confirm_manager(early_options, early_second, error), "early forfeit second manager confirms");
CareerInitializationResult early_init;
check(early.finish(early_init, error), "early forfeit career finishes setup");
uint64_t early_revision = early_init.desktop.revision;
bool special_award_found = false;
for (int i = 0; i < 8; i++) {
const int slot = early.state().memory.u8(::bmh::layout::ActiveManager);
const auto result = early.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, early_revision},
early_revision, error);
check(result.kind != TurnDeskKind::Failed, "first eight new-career desk dispatches complete");
for (const MatchGroup& grp : early.last_turn_results().groups)
for (int m = 0; m < grp.matches(); m++)
if (grp.fixtures.at(size_t(m) * 2) == kNoTeam || grp.fixtures.at(size_t(m) * 2 + 1) == kNoTeam)
special_award_found = true;
}
check(!special_award_found, "no national team fixture without the World Cup mode");
const int managed_team = source.state().manager_teams.at(0);
uint64_t revision = init.desktop.revision;
int opponent = -1; bool home_side = false;
for (int i = 0; i < 100; i++) {
if (prepared_league_fixture(source.state(), managed_team, opponent, home_side)) break;
const int active = source.state().memory.u8(::bmh::layout::ActiveManager);
const auto result = source.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active, -1, -1, -1, revision}, revision, error);
check(result.kind != TurnDeskKind::Failed, "career advances until manager league fixture");
}
check(opponent >= 0, "a prepared league fixture for the manager is found");
leave_six_fit_starters(source.state(), managed_team);
check(team_average(source.state(), managed_team, 0x1f1).players < 8,
"saved manager fixture has fewer than eight active fit players");
const int manager_index = source.state().manager_of(managed_team);
check(manager_index >= 0, "manager club maps to its manager record");
const uint32_t manager_rec = uint32_t(manager_index) * 0xb0c;
const int active = source.state().memory.u8(::bmh::layout::ActiveManager);
const auto save_path = temp_path / "LOADED-MANAGER-FORFEIT.FBM";
check(source.save_game(save_path, active, true, error), "unfit-manager desk save is written");
app::CareerSession loaded(data, 0x74102513, save_path);
check(save_stream(loaded.state()) == load_savegame(save_path).stream,
"loaded manager-forfeit save remains byte-identical");
check(loaded.game().calls() == 0 && loaded.rand().calls() == 0,
"loaded manager-forfeit save binds without either RNG stream");
const uint64_t game_calls_before = loaded.game().calls();
const uint64_t rand_calls_before = loaded.rand().calls();
// Inspect the immediate forfeit reset before later F6 background events/training.
loaded.state().memory.set8(::bmh::layout::MatchdaySetup_MatchdayNeedsManagerDesks_RuntimeField,1);
uint64_t loaded_revision = 1;
bool forfeit_found = false;
GameState before_forfeit;
uint32_t cash_before = 0, expense_before = 0;
int manager_player = -1, opponent_player = -1;
for (int i = 0; i < 100 && !forfeit_found; i++) {
leave_six_fit_starters(loaded.state(), managed_team);
if (prepared_league_fixture(loaded.state(), managed_team, opponent, home_side))
check(team_average(loaded.state(), managed_team, 0x1f1).players < 8,
"loaded prepared manager fixture has fewer than eight fit starters");
before_forfeit = loaded.state();
cash_before = record_u32(before_forfeit.manager_records, manager_rec + 0x314);
expense_before = record_u32(before_forfeit.manager_records, manager_rec + 0x8a0);
manager_player = first_source_reset_player(before_forfeit, managed_team);
opponent_player = first_source_reset_player(before_forfeit, opponent);
check(manager_player >= 0 && opponent_player >= 0,
"both fixture squads have resettable source players");
const auto advanced = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, loaded.state().memory.u8(::bmh::layout::ActiveManager), -1, -1, -1,
loaded_revision}, loaded_revision, error);
check(advanced.kind != TurnDeskKind::Failed, "loaded manager-forfeit desk advances");
for (const MatchGroup& grp : loaded.last_turn_results().groups)
for (int m = 0; m < grp.matches(); m++)
if (grp.fixtures.at(size_t(m) * 2) == managed_team ||
grp.fixtures.at(size_t(m) * 2 + 1) == managed_team) forfeit_found = true;
}
check(forfeit_found, "loaded manager fixture reaches its matchday and is awarded");
const uint32_t cash_after = record_u32(loaded.state().manager_records, manager_rec + 0x314);
const uint32_t expense_after = record_u32(loaded.state().manager_records, manager_rec + 0x8a0);
check(cash_after < cash_before && expense_after == expense_before + 200000,
"loaded manager forfeiture debits cash and records exactly 200000 expense");
check(loaded.game().calls() > game_calls_before && loaded.rand().calls() > rand_calls_before,
"forfeit continuation keeps both event RNG streams valid");
check_forfeit_reset(before_forfeit, loaded.state(), manager_player);
check_forfeit_reset(before_forfeit, loaded.state(), opponent_player);
bool score_found = false;
MatchGroup manager_group;
int manager_match = -1;
for (const MatchGroup& grp : loaded.last_turn_results().groups) {
for (int m = 0; m < grp.matches(); m++) {
if (grp.fixtures.at(size_t(m) * 2) != managed_team &&
grp.fixtures.at(size_t(m) * 2 + 1) != managed_team) continue;
int home_goals = -1, away_goals = -1;
check(match_score(grp, m, home_goals, away_goals), "awarded manager score is readable");
check((grp.kickoff_void_mask >> m & 1) != 0, "awarded manager fixture is marked void");
check(home_side ? (home_goals == 0 && away_goals == 2)
: (home_goals == 2 && away_goals == 0),
"loaded manager fixture stores the source 0:2 or 2:0 award");
score_found = true;
manager_group = grp;
manager_match = m;
}
}
check(score_found, "last matchday snapshot retains the awarded manager result");
MatchGroup forfeit_only = manager_group;
const size_t fixture_at = size_t(manager_match) * 2;
forfeit_only.fixtures = {manager_group.fixtures.at(fixture_at), manager_group.fixtures.at(fixture_at + 1)};
if (!forfeit_only.results.empty()) forfeit_only.results = {manager_group.results.at(size_t(manager_match))};
if (!forfeit_only.cup_results.empty())
forfeit_only.cup_results = {manager_group.cup_results.at(size_t(manager_match))};
forfeit_only.kickoff_void_mask = 1;
GameState skipped_state = loaded.state();
GameRandom skipped_game = loaded.game();
WatcomRandom skipped_rand = loaded.rand();
const Bytes skipped_bytes = save_stream(skipped_state);
const uint32_t skipped_game_seed = uint32_t(skipped_game.seed());
const uint64_t skipped_game_calls = skipped_game.calls();
const uint32_t skipped_rand_seed = skipped_rand.seed();
const uint64_t skipped_rand_calls = skipped_rand.calls();
MinuteReport skipped_report;
process_group(skipped_state, forfeit_only, skipped_game, skipped_rand, skipped_report);
check(!skipped_report.unsupported && save_stream(skipped_state) == skipped_bytes &&
uint32_t(skipped_game.seed()) == skipped_game_seed && skipped_game.calls() == skipped_game_calls &&
uint32_t(skipped_rand.seed()) == skipped_rand_seed && skipped_rand.calls() == skipped_rand_calls,
"kickoff-voided fixture has no morale, manager, development, or RNG effects");
GameState played_state = loaded.state();
GameRandom played_game = loaded.game();
WatcomRandom played_rand = loaded.rand();
const uint64_t played_game_calls = played_game.calls();
const uint64_t played_rand_calls = played_rand.calls();
MinuteReport played_report;
process_group(played_state, manager_group, played_game, played_rand, played_report);
check(!played_report.unsupported && played_game.calls() > played_game_calls &&
played_rand.calls() > played_rand_calls &&
played_state.team_morale != loaded.state().team_morale,
"normal matches still process morale and player development despite ended descriptor bits");
}
}
int main(int argc, char** argv) {
try {
if (argc != 2) throw std::runtime_error("bank_app_tests requires original data directory");
const std::filesystem::path data = argv[1];
test_toto_source_calculator(data);
test_toto_deadline_native_save(data);
TemporaryDirectory temp;
{ std::FILE* ignored = std::fopen((temp.path / "IGNORE.TXT").string().c_str(), "wb");
if (!ignored) throw std::runtime_error("cannot create non-save filter fixture");
std::fclose(ignored); }
test_source_empty_issue3_cup_day(data, temp.path);
StartupFlow flow(data, temp.path);
flow.click(150, 215); flow.click(5, 225, true); flow.click(5, 225, true);
const auto accepted = flow.click(90, 169);
check(accepted.request == FlowRequest::new_career && flow.pending_career(), "manager accepted");
app::CareerSession session(data, 0x22aa7711);
std::string error;
const ManagerChoice first_manager_choice = flow.pending_career()->managers[0];
test_season_profit_tax(data, flow.options(), first_manager_choice);
check(session.confirm_manager(flow.pending_career()->options, first_manager_choice, error), "manager initialized");
CareerInitializationResult result;
check(session.finish(result, error), "career reaches desktop");
test_friendly_booking(session.state(), 0);
test_friendly_season_end_dates(session.state(), 0);
test_advertising_acceptance(data, temp.path);
test_advertising_renewal(data);
test_advertising_spending(data, temp.path);
test_bank_credit(data, temp.path);
uint64_t revision = result.desktop.revision;
{
app::BankActions common(session);
const auto native=save_stream(session.state());const auto g=session.game();const auto w=session.rand();
const auto rev=revision;const auto checkpoint=session.bank_checkpoint();
auto observed=*session.preparation_projection(revision).bank;
++observed.revision;
check(!common.dispatch(app::BankActions::savings(observed,1),revision,error),
"shared bank boundary rejects a stale observed account");
bool acknowledged=false;
try {
--observed.revision;
common.dispatch(app::BankActions::savings(observed,1),revision,error,[&] {
acknowledged=true;session.state().date++;
session.game().range(0,10);session.rand().rand();
throw std::runtime_error("bank frontend ACK refused");
});
} catch(const std::runtime_error&) {}
check(acknowledged && save_stream(session.state())==native && revision==rev &&
session.game().seed()==g.seed() && session.game().calls()==g.calls() &&
session.rand().seed()==w.seed() && session.rand().calls()==w.calls() &&
session.bank_checkpoint().last_tip==checkpoint.last_tip &&
session.bank_checkpoint().property_notice==checkpoint.property_notice &&
session.bank_checkpoint().credit_notice==checkpoint.credit_notice,
"shared bank rejection restores Native, both RNGs, revision and bank notices after a real deposit");
}
auto preparation = std::move(result.preparation);
flow.attach_initialized_career(std::move(result)); flow.attach_preparation_context(std::move(preparation));
{
const auto cursor_saves = temp.path / "cursor-checks";
std::filesystem::create_directories(cursor_saves);
const auto initial_save = cursor_saves / "INITIAL.FBM";
const int initial_manager = int(session.state().memory.u8(::bmh::layout::ActiveManager));
check(session.save_game(initial_save, initial_manager, true, error),
"new career desk can be saved for continuation test");
app::CareerSession resumed(data, 0x22aa7712, initial_save);
uint64_t resumed_revision = 1;
const int resumed_manager = int(resumed.state().memory.u8(::bmh::layout::ActiveManager));
const uint32_t saved_date = resumed.state().date;
const auto resumed_turn = resumed.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, resumed_manager, -1, -1, -1, resumed_revision},
resumed_revision, error);
check(resumed_turn.kind != TurnDeskKind::Failed && resumed_turn.date >= saved_date,
(std::string("loaded single-manager save resumes its active turn: ") + error).c_str());
}
{
app::CareerSession multi_resume(data, 0x22aa7715);
SetupOptions multi_options = flow.options();
multi_options.managers = 2;
const ManagerChoice first = first_manager_choice;
check(multi_resume.confirm_manager(multi_options, first, error), "resume fixture first manager initialized");
const auto choices = multi_resume.selection_context(2);
const auto second_master = std::find_if(choices.club_order.begin(), choices.club_order.end(),
[&](int master) { return master != first.master_club; });
check(second_master != choices.club_order.end(), "resume fixture has a distinct second club");
ManagerChoice second = first;
second.slot = 1; second.master_club = *second_master; second.name += " B";
check(multi_resume.confirm_manager(multi_options, second, error), "resume fixture second manager initialized");
CareerInitializationResult multi_result;
check(multi_resume.finish(multi_result, error), "resume fixture reaches the first desk");
const auto multi_save = temp.path / "cursor-checks" / "MULTI.FBM";
const int saved_slot = int(multi_resume.state().memory.u8(::bmh::layout::ActiveManager));
check(multi_resume.save_game(multi_save, saved_slot, true, error), "multi-manager first desk saves");
app::CareerSession loaded_multi(data, 0x22aa7716, multi_save);
uint64_t loaded_revision = 1;
const int active_slot = int(loaded_multi.state().memory.u8(::bmh::layout::ActiveManager));
const uint32_t saved_date = loaded_multi.state().date;
const auto handoff = loaded_multi.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active_slot, -1, -1, -1, loaded_revision},
loaded_revision, error);
check(handoff.kind == TurnDeskKind::NextDesk && handoff.date == saved_date &&
handoff.manager_slot != active_slot,
(std::string("loaded shuffled multi-manager cursor preserves next slot: ") + error).c_str());
const GameState& multi_source = multi_resume.state();
const int other_human_team = multi_source.manager_teams.at(1);
const FriendlyBookingQuote home_quote = quote_friendly_match(multi_source, 0, other_human_team, true);
uint16_t home_day = 0;
for (int candidate = int(multi_source.memory.u16(::bmh::layout::DaysIntoSeason)) + 1; candidate < 0x16e; ++candidate) {
const auto status = friendly_match_date_status(multi_source, home_quote, uint16_t(candidate));
if (status == FriendlyDateStatus::available ||
status == FriendlyDateStatus::available_with_calendar_event) {
home_day = uint16_t(candidate); break;
}
}
check(home_day != 0 && home_quote.opponent_manager == 1 && home_quote.payer_manager == 0,
"home booking records the other human opponent separately from its payer");
FriendlyBookingRequest home_request;
home_request.quote = home_quote; home_request.season_day = home_day;
home_request.accept_cost = true; home_request.approving_manager = 0;
GameState home_unconfirmed = multi_source;
const Bytes home_unconfirmed_bytes = save_stream(home_unconfirmed);
check(book_friendly_match(home_unconfirmed, home_request).status == FriendlyBookingStatus::opponent_declined &&
save_stream(home_unconfirmed) == home_unconfirmed_bytes,
"own-home price acceptance cannot skip the opposing human manager's consent");
home_request.accept_opponent = true; home_request.consenting_manager = 1;
GameState home_confirmed = multi_source;
check(book_friendly_match(home_confirmed, home_request).status == FriendlyBookingStatus::booked,
"home booking proceeds after the distinct opponent manager consents");
GameState friendly_state = multi_resume.state();
const int host_team = friendly_state.manager_teams.at(1);
uint16_t friendly_day = 0;
const FriendlyBookingQuote away_quote = quote_friendly_match(friendly_state, 0, host_team, false);
const int current_day = friendly_state.memory.u16(::bmh::layout::DaysIntoSeason);
for (int candidate = current_day + 1; candidate < 0x16e; ++candidate) {
const FriendlyDateStatus status = friendly_match_date_status(friendly_state, away_quote,
uint16_t(candidate));
if (status == FriendlyDateStatus::available ||
status == FriendlyDateStatus::available_with_calendar_event) {
friendly_day = uint16_t(candidate); break;
}
}
check(friendly_day != 0 && away_quote.payer_manager == 1,
"away friendly requires the opposing human home manager's approval");
FriendlyBookingRequest away_request;
away_request.quote = away_quote; away_request.season_day = friendly_day;
away_request.accept_opponent = true; away_request.consenting_manager = 1;
away_request.accept_cost = true; away_request.approving_manager = 1;
const size_t host_record = 0xb0c;
const int32_t host_cash = int32_t(record_u32(friendly_state.manager_records, host_record + 0x314));
const uint32_t host_expenses = record_u32(friendly_state.manager_records, host_record + 0x8a0);
const auto away_booked = book_friendly_match(friendly_state, away_request);
check(away_booked.status == FriendlyBookingStatus::booked &&
away_booked.home_team == host_team && away_booked.away_team == multi_resume.state().manager_teams.at(0) &&
(multi_resume.state().level == 0 ||
(int32_t(record_u32(friendly_state.manager_records, host_record + 0x314)) == host_cash - away_quote.cost &&
record_u32(friendly_state.manager_records, host_record + 0x8a0) == host_expenses + uint32_t(away_quote.cost))),
"away booking charges only the consenting opposing home manager");
}
// Engine-side transfer actions use the same initialized CareerSession state as
// the desk. Keep this simulator-only mutable view out of the read-only app API.
GameState& transfer_state = const_cast<GameState&>(session.state());
WatcomRandom& transfer_rand = session.rand();
MinuteReport transfer_report;
const SquadRange own_squad = squad_range(transfer_state.manager_teams.at(0));
bool listed = false;
int own_list_entry = -1;
int own_list_player = -1;
for (int row = int(own_squad.count) - 1; row >= 11; --row) {
if ((transfer_state.squad_slots.at(own_squad.first + size_t(row)) & 0xfff) == 0xfff) continue;
const auto listing = list_manager_player(transfer_state, 0, row, transfer_rand, transfer_report);
listed = listing.status == TransferActionStatus::accepted && listing.list_entry >= 0;
own_list_entry = listing.list_entry;
own_list_player = listing.player;
break;
}
check(listed && !transfer_report.unsupported, "human manager can list a reserve player");
new_transfer_list_entries(transfer_state, transfer_rand, transfer_report);
check(!transfer_report.unsupported, "weekly transfer pool contains sellable AI players");
const GameState incoming_offer_base = transfer_state;
const WatcomRandom incoming_offer_rand = transfer_rand;
const int32_t transfer_cash = int32_t(uint32_t(transfer_state.manager_records.at(0x314)) |
uint32_t(transfer_state.manager_records.at(0x315)) << 8 | uint32_t(transfer_state.manager_records.at(0x316)) << 16 |
uint32_t(transfer_state.manager_records.at(0x317)) << 24);
int buy_entry = -1;
for (int entry = 0; entry < 40; ++entry) {
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(entry) * 0x58;
const int player = transfer_state.squad_slots.at(0xb70u + size_t(entry)) & 0xfff;
if (player == 0xfff || int16_t(transfer_state.memory.u16(at)) != -1 ||
(transfer_state.memory.u16(at + 8) & 0x7fff) == uint16_t(transfer_state.manager_teams.at(0))) continue;
const uint32_t fee = transfer_state.memory.u32(at + 0x2c);
const uint32_t salary = transfer_state.memory.u32(at + 0x30);
if (fee == 0 || salary == 0 || fee > uint32_t(transfer_cash / 2)) continue;
buy_entry = entry;
GameState direct_state = transfer_state;
WatcomRandom direct_rand = transfer_rand;
TransferBidRequest direct;
// Source mode III rolls salary demand through 120..190 and fee
// acceptance through 92..150; make this direct-path fixture clear
// both gates so it tests settlement, not a probabilistic pending bid.
direct.manager = 0; direct.list_entry = entry; direct.player = player; direct.fee = int32_t(uint64_t(fee) * 300 / 100);
direct.annual_salary = int32_t(uint64_t(salary) * 300 / 100); direct.contract_years = 2;
direct.source_slot = int(0xb70u + size_t(entry));
GameState stale_state = transfer_state;
WatcomRandom stale_rand = transfer_rand;
const uint64_t stale_draws = stale_rand.calls();
TransferBidRequest stale = direct;
stale.player = player == 0 ? 1 : 0;
const auto stale_result = submit_transfer_bid(stale_state, stale, stale_rand);
check(stale_result.status == TransferActionStatus::invalid_request &&
stale_state.squad_slots == transfer_state.squad_slots &&
stale_state.manager_records == transfer_state.manager_records &&
stale_state.memory.u16(::bmh::layout::EditorListUnsigned + uint32_t(entry) * 0x58) == 0xffff &&
stale_rand.calls() == stale_draws, "recycled list entry rejects stale player identity without state or RNG changes");
HumanBuyerSaleHooks direct_hooks;
direct_hooks.allocator_gate = HumanBuyerSaleAllocatorGate::zero;
direct_hooks.direct_mode = HumanBuyerSaleDirectMode::ordinary_ai_purchase;
direct_hooks.notice = [](const GameState&, const HumanBuyerSaleNotice&) {};
MinuteReport direct_report;
const auto direct_result = submit_transfer_bid_source_human_buyer(direct_state, direct, direct_rand,
direct_hooks, direct_report);
check(direct_result.status == TransferActionStatus::accepted && !direct_report.unsupported,
"source-qualified full-value offer is accepted immediately");
bool immediate_player = false;
for (size_t row = own_squad.first; row < own_squad.first + own_squad.count; ++row)
if ((direct_state.squad_slots.at(row) & 0xfff) == player) immediate_player = true;
check(immediate_player, "immediate agreement transfers player into the manager's squad");
TransferBidRequest unaffordable;
unaffordable.manager = 0; unaffordable.list_entry = entry; unaffordable.player = player; unaffordable.fee = 0x7fffffff;
unaffordable.annual_salary = int32_t(salary); unaffordable.contract_years = 2;
check(submit_transfer_bid(transfer_state, unaffordable, transfer_rand).status ==
TransferActionStatus::blocked_by_board, "board refuses fees above balance plus credit");
TransferBidRequest bid;
bid.manager = 0; bid.list_entry = entry; bid.player = player; bid.fee = int32_t(uint64_t(fee) * 130 / 100);
bid.annual_salary = int32_t(uint64_t(salary) * 120 / 100); bid.contract_years = 2;
check(submit_transfer_bid(transfer_state, bid, transfer_rand).status == TransferActionStatus::pending,
"human bid is recorded for the weekly decision");
check(transfer_state.memory.u16(at) == uint16_t(transfer_state.manager_teams.at(0)) &&
transfer_state.memory.u32(at + 0x1c) == uint32_t(bid.fee) &&
transfer_state.memory.u32(at + 0x0c) == uint32_t(bid.annual_salary),
"bid fee and contract terms persist in the shared transfer entry");
transfer_state.memory.set8(at + 0x56, 1);
for (int other = 0; other < 40; ++other)
if (other != entry && (transfer_state.squad_slots.at(0xb70u + size_t(other)) & 0xfff) != 0xfff)
transfer_state.memory.set8(::bmh::layout::EditorListUnsigned + uint32_t(other) * 0x58 + 0x56, 9);
const uint16_t player_before = uint16_t(player);
GameRandom transfer_game(0x1199);
transfer_list_countdown(transfer_state, transfer_game, transfer_rand, transfer_report, false,
TransferAllocatorContext::zero);
bool acquired = false;
for (size_t row = own_squad.first; row < own_squad.first + own_squad.count; ++row)
if ((transfer_state.squad_slots.at(row) & 0xfff) == player_before) acquired = true;
check(!transfer_report.unsupported && acquired, "weekly offer accepts a competitive human bid and registers the player");
const int32_t cash_after_transfer = int32_t(uint32_t(transfer_state.manager_records.at(0x314)) |
uint32_t(transfer_state.manager_records.at(0x315)) << 8 | uint32_t(transfer_state.manager_records.at(0x316)) << 16 |
uint32_t(transfer_state.manager_records.at(0x317)) << 24);
check(cash_after_transfer < transfer_cash, "accepted transfer books the fee against the manager account");
break;
}
check(buy_entry >= 0, "initialized career has an affordable external transfer candidate");
{
const uint32_t buyer_entry_at = ::bmh::layout::EditorListUnsigned + uint32_t(buy_entry) * 0x58;
const int ai_seller = int(incoming_offer_base.memory.u16(buyer_entry_at + 8) & 0x7fff);
const int buyer_player = int(incoming_offer_base.squad_slots.at(0xb70u + size_t(buy_entry)) & 0x0fff);
check(ai_seller >= 0 && incoming_offer_base.manager_of(ai_seller) < 0 &&
buyer_player >= 0 && buyer_player < int(incoming_offer_base.players.size()),
"last-week fixture has a valid AI seller/player row");
auto expire_others_later = [&](GameState& state, int selected) {
for (int row = 0; row < 40; ++row) {
if (state.squad_slots.at(0xb70u + size_t(row)) == 0x0fff) continue;
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(row) * 0x58;
state.memory.set8(at + 0x56, row == selected ? 2 : 9);
}
};
auto observe_last_week = [&](GameState state, int selected, bool all, bool expected_notice) {
expire_others_later(state, selected);
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(selected) * 0x58;
const int player = int(state.squad_slots.at(0xb70u + size_t(selected)) & 0x0fff);
const GameState before = state;
std::vector<TransferDecisionEvent> events;
state.transfer_decision_observer = [&](const TransferDecisionEvent& event) { events.push_back(event); };
GameRandom game(0x6141);
WatcomRandom rand = transfer_rand;
const auto game_before = game;
const auto rand_before = rand;
MinuteReport report;
transfer_list_countdown(state, game, rand, report, all);
check(!report.unsupported, "last-week countdown stays on the supported no-expiry path");
if (!expected_notice) {
check(events.empty(), "AI-only and all-at-season-end countdowns do not emit a last-week modal");
} else {
check(events.size() == 1 && events[0].kind == TransferDecisionEventKind::last_week &&
events[0].offers.valid && events[0].offers.list_entry == selected &&
events[0].offers.player == player && events[0].viewer_manager == -1 &&
events[0].result_text_address == ::bmh::layout::PendingOffer_TransferLastWeekDialog_ExecutableField,
"last-week observer carries one system event, its player, and TEXTD aedcc");
}
check(game.seed() == game_before.seed() && game.calls() == game_before.calls() &&
rand.seed() == rand_before.seed() && rand.calls() == rand_before.calls(),
"last-week observer is Native RNG-neutral");
if (!all) {
GameState expected = before;
for (int row = 0; row < 40; ++row) {
if (expected.squad_slots.at(0xb70u + size_t(row)) == 0x0fff) continue;
const uint32_t row_at = ::bmh::layout::EditorListUnsigned + uint32_t(row) * 0x58;
expected.memory.set8(row_at + 0x56,
uint8_t(expected.memory.u8(row_at + 0x56) - 1));
}
expected.memory.set8(at + 0x56, 1);
check(save_stream(state) == save_stream(expected),
"non-season countdown changes only Source timer bytes; observer is save-neutral");
}
};
GameState human_seller = incoming_offer_base;
expire_others_later(human_seller, own_list_entry);
observe_last_week(human_seller, own_list_entry, false, true);
GameState human_bidder = incoming_offer_base;
TransferBidRequest last_week_bid;
last_week_bid.manager = 0;
last_week_bid.list_entry = buy_entry;
last_week_bid.player = buyer_player;
last_week_bid.fee = int32_t(uint64_t(human_bidder.memory.u32(buyer_entry_at + 0x2c)) * 130 / 100);
last_week_bid.annual_salary = int32_t(uint64_t(human_bidder.memory.u32(buyer_entry_at + 0x30)) * 120 / 100);
last_week_bid.contract_years = 2;
WatcomRandom bidder_rand = transfer_rand;
check(submit_transfer_bid(human_bidder, last_week_bid, bidder_rand).status == TransferActionStatus::pending,
"controlled last-week row owns a real human bid");
observe_last_week(human_bidder, buy_entry, false, true);
// legacy routine scans all four raw rows, including an occupied row after
// an empty one; the system warning is independent of bid sorting.
GameState sparse_bidder = human_bidder;
for (int bid = 0; bid < 4; ++bid)
sparse_bidder.memory.set16(buyer_entry_at + uint32_t(bid) * 2, 0xffff);
sparse_bidder.memory.set16(buyer_entry_at + 6, uint16_t(sparse_bidder.manager_teams.at(0)));
observe_last_week(sparse_bidder, buy_entry, false, true);
GameState coach_bidder = human_bidder;
coach_bidder.memory.set16(::bmh::layout::CupDraw_FormatError_RuntimeField3, uint16_t(coach_bidder.manager_teams.at(0)));
coach_bidder.manager_teams = {0x165};
observe_last_week(coach_bidder, buy_entry, false, true);
GameState ai_only = incoming_offer_base;
observe_last_week(ai_only, buy_entry, false, false);
GameState season_all = incoming_offer_base;
for (int row = 0; row < 40; ++row)
if (row != own_list_entry)
season_all.squad_slots.at(0xb70u + size_t(row)) = 0x0fff;
observe_last_week(season_all, own_list_entry, true, false);
}
auto prepare_ai_offer = [&](GameState& state) {
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
int buyer = -1;
for (int team = 0; team < 138; ++team) {
if (state.manager_of(team) >= 0) continue;
const SquadRange target = squad_range(team);
bool free = false;
for (size_t row = target.first; row < target.first + target.count; ++row)
if (state.squad_slots.at(row) == 0x0fff) { free = true; break; }
if (free) { buyer = team; break; }
}
check(buyer >= 0, "AI buyer has squad room");
state.memory.set16(at, uint16_t(buyer));
state.memory.set32(at + 0x1c, state.memory.u32(at + 0x2c) * 130 / 100);
state.memory.set32(at + 0x0c, state.memory.u32(at + 0x30));
state.memory.set8(at + 0x34, 12);
state.memory.set8(at + 0x56, 1);
};
{
GameState projection_state = transfer_state;
prepare_ai_offer(projection_state);
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
int second_buyer = -1;
for (int team = 0; team < 138; ++team) {
if (projection_state.manager_of(team) >= 0 ||
team == int16_t(projection_state.memory.u16(at))) continue;
const SquadRange range = squad_range(team);
if (range.count == 0) continue;
bool free = false;
for (size_t row = range.first; row < range.first + range.count; ++row)
if (projection_state.squad_slots.at(row) == 0x0fff) { free = true; break; }
if (free) { second_buyer = team; break; }
}
check(second_buyer >= 0, "second offer candidate has a buyer with squad room");
projection_state.memory.set16(at + 2, uint16_t(second_buyer));
projection_state.memory.set32(at + 0x20, projection_state.memory.u32(at + 0x2c) * 140 / 100);
projection_state.memory.set32(at + 0x10, projection_state.memory.u32(at + 0x30) * 130 / 100);
projection_state.memory.set8(at + 0x35, 0x9c); // raw 28-month loan term
for (int bonus = 0; bonus < 7; ++bonus)
projection_state.memory.set8(at + 0x3f + uint32_t(bonus), uint8_t(bonus + 1));
const auto save_before_projection = save_stream(projection_state);
const auto projection = project_transfer_offer_list(projection_state, own_list_entry);
check(projection.valid && projection.player == own_list_player && projection.seller_manager == 0 &&
projection.offer_count == 2 && projection.offers[0].present &&
projection.offers[0].bid_index == 0 && projection.offers[1].present &&
projection.offers[1].bid_index == 1,
"read-only transfer projection preserves raw bidder row identities");
check(projection.offers[0].fee == projection_state.memory.u32(at + 0x1c) &&
projection.offers[0].monthly_salary == projection_state.memory.u32(at + 0x0c) &&
projection.offers[1].buyer == second_buyer &&
projection.offers[0].buyer != projection.offers[1].buyer &&
projection.offers[1].fee == projection_state.memory.u32(at + 0x20) &&
projection.offers[1].monthly_salary == projection_state.memory.u32(at + 0x10) &&
projection.offers[0].fee != projection.offers[1].fee &&
projection.offers[0].monthly_salary != projection.offers[1].monthly_salary &&
projection.offers[1].loan &&
projection.offers[1].contract_months == 0x1c &&
projection.offers[1].bonuses == std::array<uint8_t, 7>{1, 2, 3, 4, 5, 6, 7} &&
projection.offers[1].eligible && projection.offers[1].loan_permitted &&
projection.offers[1].transaction_supported &&
projection.offers[1].fee_reference > 0 && projection.offers[1].salary_reference > 0,
"projection exposes raw prices, bonuses, and the supported human-owner-to-AI loan path");
check(save_stream(projection_state) == save_before_projection &&
!project_transfer_offer_list(projection_state, -1).valid,
"offer projection leaves the complete serialized game state unchanged");
GameState full_buyer = projection_state;
const SquadRange full_range = squad_range(second_buyer);
for (size_t row = full_range.first; row < full_range.first + full_range.count; ++row)
if (full_buyer.squad_slots.at(row) == 0x0fff)
full_buyer.squad_slots[row] = uint16_t(own_list_player);
const auto full_projection = project_transfer_offer_list(full_buyer, own_list_entry);
check(!full_projection.offers[1].has_squad_room && !full_projection.offers[1].eligible,
"projection marks a source-full buyer ineligible without accepting the offer");
GameState no_cash_buyer = projection_state;
no_cash_buyer.manager_teams.push_back(second_buyer);
no_cash_buyer.manager_records.resize(2 * 0xb0c, 0);
const auto no_cash_projection = project_transfer_offer_list(no_cash_buyer, own_list_entry);
check(no_cash_projection.offers[1].buyer_manager == 1 &&
!no_cash_projection.offers[1].affordable && !no_cash_projection.offers[1].eligible,
"projection applies the signed balance-plus-credit gate for a human bidder");
GameState malformed_buyer = projection_state;
malformed_buyer.memory.set16(at + 2, 138);
const auto malformed_projection = project_transfer_offer_list(malformed_buyer, own_list_entry);
check(malformed_projection.offer_count == 2 && malformed_projection.offers[1].buyer == 138 &&
!malformed_projection.offers[1].has_squad_room &&
!malformed_projection.offers[1].passes_foreign_limit &&
!malformed_projection.offers[1].eligible,
"malformed buyer IDs remain safely visible but cannot pass source eligibility");
GameState terminated_rows = projection_state;
terminated_rows.memory.set16(at + 2, 0xffff);
terminated_rows.memory.set16(at + 4, uint16_t(second_buyer)); // stale bytes after terminator
const auto terminated_projection = project_transfer_offer_list(terminated_rows, own_list_entry);
check(terminated_projection.offer_count == 1 && terminated_projection.offers[0].bid_index == 0 &&
!terminated_projection.offers[1].present && terminated_projection.offers[1].bid_index == 1,
"projection stops at the original first-empty bid terminator");
}
{
auto with_second_offer = [&](GameState& state, uint32_t fee_percent) {
prepare_ai_offer(state);
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
int buyer = -1;
for (int team = 0; team < 138; ++team) {
if (state.manager_of(team) >= 0 || team == int16_t(state.memory.u16(at))) continue;
const SquadRange range = squad_range(team);
if (range.count == 0) continue;
for (size_t row = range.first; row < range.first + range.count; ++row)
if (state.squad_slots.at(row) == 0x0fff) { buyer = team; break; }
if (buyer >= 0) break;
}
check(buyer >= 0, "selector second buyer has room");
state.memory.set32(at + 0x1c, state.memory.u32(at + 0x2c) * 3);
state.memory.set32(at + 0x0c, state.memory.u32(at + 0x30) * 3);
state.memory.set16(at + 2, uint16_t(buyer));
state.memory.set32(at + 0x20, state.memory.u32(at + 0x2c) * fee_percent / 100);
state.memory.set32(at + 0x10, state.memory.u32(at + 0x30) * 3 / 2);
state.memory.set8(at + 0x35, 12);
return buyer;
};
auto run_selector = [&](GameState& state, GameRandom& game, WatcomRandom& rand,
std::function<int(const GameState&, const TransferOfferListView&)> selector,
MinuteReport& report) {
state.transfer_offer_selector = std::move(selector);
transfer_list_countdown(state, game, rand, report);
};
GameState direct = transfer_state;
const int selected_buyer = with_second_offer(direct, 160);
GameRandom direct_game(0x66a1);
WatcomRandom direct_rand = transfer_rand;
MinuteReport direct_report;
int direct_calls = 0;
run_selector(direct, direct_game, direct_rand,
[&](const GameState&, const TransferOfferListView& view) {
++direct_calls;
check(view.preferred_bid_index == 0 && view.offer_count == 2 && view.offers[1].present &&
view.quoted_fee != 0 && view.quoted_monthly_salary != 0 && view.quoted_years >= 1 &&
view.asking_fee != 0 && view.asking_monthly_salary != 0,
"selector receives ranked preference, raw rows, and Source quote/request values");
return 1; // choose the second raw row, not the pre-ranked row
}, direct_report);
bool selected_owned = false;
const SquadRange selected_range = squad_range(selected_buyer);
for (size_t row = selected_range.first; row < selected_range.first + selected_range.count; ++row)
if ((direct.squad_slots.at(row) & 0x0fff) == own_list_player) selected_owned = true;
check(!direct_report.unsupported && direct_calls == 1 && selected_owned,
"seller can select a non-top raw bid and complete that transfer");
GameState low_fee_selected = transfer_state;
const int low_fee_buyer = with_second_offer(low_fee_selected, 1);
const uint32_t low_fee_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
low_fee_selected.memory.set8(low_fee_at + 0x55, 0);
GameRandom low_fee_game(0x66a2);
WatcomRandom low_fee_rand = transfer_rand;
MinuteReport low_fee_report;
run_selector(low_fee_selected, low_fee_game, low_fee_rand,
[](const GameState&, const TransferOfferListView&) { return 1; }, low_fee_report);
bool low_fee_player_moved = false;
const SquadRange low_fee_range = squad_range(low_fee_buyer);
for (size_t row = low_fee_range.first; row < low_fee_range.first + low_fee_range.count; ++row)
if ((low_fee_selected.squad_slots.at(row) & 0x0fff) == own_list_player) low_fee_player_moved = true;
check(!low_fee_report.unsupported && low_fee_player_moved,
"human seller accepts a selected offer when Source salary_pct passes even if fee_pct is zero");
GameState invalid_then_direct = transfer_state;
with_second_offer(invalid_then_direct, 160);
const uint32_t invalid_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
GameRandom invalid_game(0x66a1);
WatcomRandom invalid_rand = transfer_rand;
MinuteReport invalid_report;
int invalid_calls = 0;
int invalid_ack_calls = 0;
invalid_then_direct.transfer_decision_observer = [&](const TransferDecisionEvent& event) {
++invalid_ack_calls;
bool buyer_owns = false;
const int buyer = event.offers.offers[1].buyer;
const SquadRange range = squad_range(buyer);
for (size_t row = range.first; row < range.first + range.count; ++row)
if ((invalid_then_direct.squad_slots.at(row) & 0x0fff) == own_list_player) buyer_owns = true;
check(invalid_calls == 2 && buyer_owns && event.kind == TransferDecisionEventKind::confirmation &&
event.accepted && event.selected_bid_index == 1 && event.viewer_manager == 0,
"malformed empty-row response emits no acknowledgement before the later real transfer");
};
uint32_t first_quote = 0;
run_selector(invalid_then_direct, invalid_game, invalid_rand,
[&](const GameState&, const TransferOfferListView& view) {
++invalid_calls;
if (invalid_calls == 1) { first_quote = view.quoted_fee; return 4; }
check(view.quoted_fee == first_quote && view.rejected_bid_index == -1,
"invalid raw-row input retries the same screen without a new quote or notice");
return 1;
}, invalid_report);
check(!invalid_report.unsupported && invalid_calls == 2 &&
invalid_ack_calls == 1 &&
save_stream(invalid_then_direct) == save_stream(direct) &&
invalid_game.seed() == direct_game.seed() && invalid_game.calls() == direct_game.calls() &&
invalid_rand.seed() == direct_rand.seed() && invalid_rand.calls() == direct_rand.calls(),
"invalid selector response has no extra transfer, game-state, or RNG effects");
GameState retry = transfer_state;
with_second_offer(retry, 160);
const uint32_t retry_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
const int retry_buyer = int16_t(retry.memory.u16(retry_at));
retry.memory.set8(retry_at + 0x55, 250); // row 1's 150% salary fails the Source recheck; row 0's 300% passes
GameRandom retry_game(0x7788);
WatcomRandom retry_rand = transfer_rand;
MinuteReport retry_report;
int retry_calls = 0;
run_selector(retry, retry_game, retry_rand,
[&](const GameState&, const TransferOfferListView& view) {
++retry_calls;
if (retry_calls == 1) return 1;
check(view.rejected_bid_index == 1 && view.notice_text_address == ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField3 &&
!view.offers[1].present && view.offers[0].present,
"failed salary/fee check removes only that raw bid and projects Source retry notice");
return 0;
}, retry_report);
check(!retry_report.unsupported && retry_calls == 2,
"rejected selected offer returns to the seller choice while another bid remains");
bool retry_buyer_owns = false;
const SquadRange retry_range = squad_range(retry_buyer);
for (size_t row = retry_range.first; row < retry_range.first + retry_range.count; ++row)
if ((retry.squad_slots.at(row) & 0x0fff) == own_list_player) retry_buyer_owns = true;
check(retry_buyer_owns, "after the salary rejection the seller can accept the remaining bid");
{
GameState top_retry = transfer_state;
const int second_buyer = with_second_offer(top_retry, 160);
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
const int first_buyer = int16_t(top_retry.memory.u16(at));
const uint32_t salary_base = top_retry.memory.u32(at + 0x30);
top_retry.memory.set32(at + 0x0c, salary_base * 180 / 100); // raw 0: 180%, passes after 125% recheck
top_retry.memory.set32(at + 0x10, salary_base); // raw 1: 100%, still fails at 125%
top_retry.memory.set8(at + 0x55, 200);
GameRandom game(0x7a19);
WatcomRandom rand = transfer_rand;
MinuteReport report;
int calls = 0;
run_selector(top_retry, game, rand,
[&](const GameState&, const TransferOfferListView& view) {
++calls;
if (calls == 1) {
check(view.preferred_bid_index == 1 && view.offer_count == 2 &&
view.offers[0].present && view.offers[1].present,
"top-ranked raw bid is row 1 before the seller's choice");
return 1;
}
check(calls == 2 && view.preferred_bid_index == -1 &&
view.rejected_bid_index == 1 && view.offer_count == 1 &&
!view.offers[1].present && view.offers[0].present &&
view.notice_text_address == ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField3,
"rejecting the preferred row clears its preferred marker before retry");
return 0;
}, report);
bool first_buyer_owns_player = false;
const SquadRange range = squad_range(first_buyer);
for (size_t row = range.first; row < range.first + range.count; ++row)
if ((top_retry.squad_slots.at(row) & 0x0fff) == own_list_player) first_buyer_owns_player = true;
check(!report.unsupported && calls == 2 && first_buyer_owns_player &&
second_buyer != first_buyer,
"the remaining raw row is selectable after the preferred row fails salary recheck");
}
GameState terminal = transfer_state;
prepare_ai_offer(terminal); // one bid only
const uint32_t terminal_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
terminal.memory.set8(terminal_at + 0x55, 255);
GameRandom terminal_game(0x7789);
WatcomRandom terminal_rand = transfer_rand;
MinuteReport terminal_report;
int terminal_calls = 0;
int terminal_observer_calls = 0;
terminal.transfer_decision_observer = [&](const TransferDecisionEvent&) { ++terminal_observer_calls; };
uint32_t terminal_quote = 0;
uint64_t terminal_game_calls = 0, terminal_rand_calls = 0;
run_selector(terminal, terminal_game, terminal_rand,
[&](const GameState&, const TransferOfferListView& view) {
++terminal_calls;
if (terminal_calls == 1) {
terminal_quote = view.quoted_fee;
terminal_game_calls = terminal_game.calls();
terminal_rand_calls = terminal_rand.calls();
return 0;
}
check(view.offer_count == 0 && view.preferred_bid_index == -1 &&
view.notice_text_address == ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField3 && view.quoted_fee == terminal_quote &&
terminal_game.calls() == terminal_game_calls &&
terminal_rand.calls() == terminal_rand_calls + 1,
"last salary refusal displays terminal Source notice without a fresh quote/RNG redraw");
return 0; // Source has already left the choice screen; this answer is ignored.
}, terminal_report);
check(!terminal_report.unsupported && terminal_calls == 2,
"last failed human bid shows one final refusal and then returns");
check(terminal_observer_calls == 0,
"terminal salary-refusal notice is not misreported as an explicit seller acknowledgement");
GameState loan_retry = transfer_state;
with_second_offer(loan_retry, 160);
const uint32_t loan_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
loan_retry.memory.set8(loan_at + 0x35, 0x8c);
loan_retry.memory.set8(::bmh::layout::DeskActions_Unsupported_RuntimeField, 3);
GameRandom loan_game(0x8899);
WatcomRandom loan_rand = transfer_rand;
MinuteReport loan_report;
int loan_calls = 0;
run_selector(loan_retry, loan_game, loan_rand,
[&](const GameState&, const TransferOfferListView& view) {
++loan_calls;
if (loan_calls <= 10) {
check(view.offers[1].present && view.notice_text_address == (loan_calls == 1 ? 0u : ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField2Unsigned),
"repeated valid selection of a loan blocked by the source manager limit redraws without dropping it");
return 1;
}
check(view.rejected_bid_index == 1 && view.notice_text_address == ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField2 &&
view.offers[1].present && view.offers[1].loan && !view.offers[1].loan_permitted,
"seller loan-limit refusal preserves the raw bid and returns the Source notice");
return 0;
}, loan_report);
check(!loan_report.unsupported && loan_calls == 11,
"legitimate Source loan-limit retries are not cut off by the malformed-input bound");
GameState owner_loan = transfer_state;
const int loan_buyer = with_second_offer(owner_loan, 160);
const uint32_t owner_loan_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
owner_loan.memory.set8(owner_loan_at + 0x35, 0x8c); // 12-month loan
owner_loan.memory.set8(::bmh::layout::DeskActions_Unsupported_RuntimeField, 0);
owner_loan.transfer_offer_selector = [](const GameState&, const TransferOfferListView&) { return 1; };
GameRandom owner_loan_game(0x9901);
WatcomRandom owner_loan_rand = transfer_rand;
MinuteReport owner_loan_report;
transfer_list_countdown(owner_loan, owner_loan_game, owner_loan_rand, owner_loan_report);
bool buyer_has_loaned_player = false;
for (size_t row = squad_range(loan_buyer).first;
row < squad_range(loan_buyer).first + squad_range(loan_buyer).count; ++row)
if ((owner_loan.squad_slots.at(row) & 0x0fff) == own_list_player) buyer_has_loaned_player = true;
int saved_owner_record = -1;
for (int i = 0; i < 12; ++i)
if (owner_loan.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(i) * 2) == uint16_t(own_list_player)) saved_owner_record = i;
check(!owner_loan_report.unsupported && buyer_has_loaned_player && saved_owner_record >= 0 &&
owner_loan.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField) == 1 &&
owner_loan.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField) == uint32_t(own_list_player +
transfer_state.manager_teams.at(0) * 0x1000 + loan_buyer * 0x400000),
"human owner completes an AI loan and persists Source owner snapshot plus loan ledger");
{
GameState full_owner = owner_loan;
const uint32_t ledger = full_owner.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField);
int ledger_slot = -1;
for (int i = 0; i < 200; ++i)
if (full_owner.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(i) * 4) == ledger) { ledger_slot = i; break; }
const SquadRange range = squad_range(transfer_state.manager_teams.at(0));
int filler = -1;
for (size_t i = 0; i < range.count; ++i) {
const int p = full_owner.squad_slots.at(range.first + i) & 0x0fff;
if (p != 0x0fff && p != own_list_player) { filler = p; break; }
}
check(ledger_slot >= 0 && filler >= 0, "full-owner return fixture has a live loan and roster filler");
for (size_t i = 0; i < range.count; ++i)
if (full_owner.squad_slots.at(range.first + i) == 0x0fff)
full_owner.squad_slots[range.first + i] = uint16_t(filler);
full_owner.memory.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(ledger_slot), 1);
GameRandom full_game(0x9904);
WatcomRandom full_rand = owner_loan_rand;
MinuteReport full_report;
month_change(full_owner, full_rand, full_report, &full_game);
check(full_report.unsupported && full_report.reason.find("cannot be restored safely") != std::string::npos &&
full_owner.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(ledger_slot) * 4) == ledger &&
full_owner.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(saved_owner_record) * 2) == uint16_t(own_list_player) &&
full_owner.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField) == 1,
"a full owner roster leaves the expiring loan ledger and owner snapshot intact");
}
{
GameState zero_term = owner_loan;
int ledger_slot = -1;
const uint32_t ledger = zero_term.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField);
for (int i = 0; i < 200; ++i)
if (zero_term.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(i) * 4) == ledger) { ledger_slot = i; break; }
check(ledger_slot >= 0, "byte-wrap fixture keeps the human-owner loan ledger");
zero_term.memory.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(ledger_slot), 0);
GameRandom wrap_game(0x9905);
WatcomRandom wrap_rand = owner_loan_rand;
MinuteReport wrap_report;
month_change(zero_term, wrap_rand, wrap_report, &wrap_game);
check(!wrap_report.unsupported && zero_term.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(ledger_slot) * 4) == ledger &&
zero_term.memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(ledger_slot)) == 0xff &&
zero_term.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(saved_owner_record) * 2) == uint16_t(own_list_player),
"zero loan month follows the Source unsigned-byte decrement wrap instead of returning immediately");
}
GameState no_loan_record = transfer_state;
with_second_offer(no_loan_record, 160);
const uint32_t no_record_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
no_loan_record.memory.set8(no_record_at + 0x35, 0x8c);
const uint32_t other_player = uint32_t(own_list_player == 0x0ffe ? 1 : own_list_player + 1);
for (int i = 0; i < 200; ++i)
no_loan_record.memory.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(i) * 4,
other_player | (uint32_t(transfer_state.manager_teams.at(0)) << 12));
const auto no_record_mail = no_loan_record.mailbox;
const auto no_record_money = no_loan_record.manager_records;
const auto no_record_squads = no_loan_record.squad_slots;
const auto no_record_snapshot_ids = [&] {
std::array<uint16_t, 12> ids{};
for (int i = 0; i < 12; ++i) ids[size_t(i)] = no_loan_record.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(i) * 2);
return ids;
}();
no_loan_record.transfer_offer_selector = [](const GameState&, const TransferOfferListView&) { return 1; };
GameRandom no_record_game(0x9903);
WatcomRandom no_record_rand = transfer_rand;
MinuteReport no_record_report;
transfer_list_countdown(no_loan_record, no_record_game, no_record_rand, no_record_report);
bool snapshot_ids_unchanged = true;
for (int i = 0; i < 12; ++i)
snapshot_ids_unchanged = snapshot_ids_unchanged &&
no_loan_record.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(i) * 2) == no_record_snapshot_ids[size_t(i)];
check(no_record_report.unsupported && no_record_report.reason.find("loan table full") != std::string::npos &&
no_loan_record.mailbox == no_record_mail && no_loan_record.manager_records == no_record_money &&
no_loan_record.squad_slots == no_record_squads && snapshot_ids_unchanged &&
no_loan_record.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField) == 0,
"full loan ledger is rejected before transfer news, seller payment, or roster/snapshot mutation");
{
GameState no_snapshot = transfer_state;
with_second_offer(no_snapshot, 160);
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
no_snapshot.memory.set8(at + 0x35, 0x8c);
for (int i = 0; i < 12; ++i)
no_snapshot.memory.set16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(i) * 2, uint16_t(other_player));
const auto before = save_stream(no_snapshot);
WatcomRandom copied_rand = transfer_rand;
MinuteReport no_snapshot_report;
check(!accept_transfer_bid_immediately(no_snapshot, own_list_entry, 1,
copied_rand, no_snapshot_report) &&
no_snapshot_report.unsupported &&
no_snapshot_report.reason.find("snapshots full") != std::string::npos &&
save_stream(no_snapshot) == before &&
copied_rand.seed() == transfer_rand.seed() &&
copied_rand.calls() == transfer_rand.calls(),
"all twelve occupied owner snapshots reject before state, RNG, news or finance mutation");
}
{
const uint32_t loan_record = owner_loan.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField);
int loan_slot = -1;
for (int i = 0; i < 200; ++i)
if (owner_loan.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(i) * 4) == loan_record) { loan_slot = i; break; }
check(loan_slot >= 0, "human-owner loan has an indexed Source ledger entry");
owner_loan.memory.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(loan_slot), 1);
WatcomRandom save_rand = owner_loan_rand;
const auto loan_dir = temp.path / "loan-roundtrip";
std::filesystem::create_directories(loan_dir);
const auto loan_save_path = loan_dir / "HUMAN-OWNER-LOAN.FBM";
write_savegame(loan_save_path, make_savegame(owner_loan, save_rand));
app::CareerSession loaded_loan(data, 0x7711, loan_save_path);
check(save_stream(loaded_loan.state()) == load_savegame(loan_save_path).stream &&
loaded_loan.game().calls() == 0 && loaded_loan.rand().calls() == 0 &&
loaded_loan.state().memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(loan_slot) * 4) == loan_record &&
loaded_loan.state().memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(saved_owner_record) * 2) == uint16_t(own_list_player),
"native FBM load preserves the owner snapshot and mid-loan ledger without RNG draws");
GameState& returning = const_cast<GameState&>(loaded_loan.state());
returning.mailbox.assign(kMailboxEntries * kMailboxEntry, 0);
MinuteReport return_report;
month_change(returning, loaded_loan.rand(), return_report, &loaded_loan.game());
bool owner_has_player = false, borrower_still_has_player = false;
const SquadRange owner_range = squad_range(transfer_state.manager_teams.at(0));
const SquadRange borrower_range = squad_range(loan_buyer);
for (size_t row = owner_range.first; row < owner_range.first + owner_range.count; ++row)
if ((returning.squad_slots.at(row) & 0x0fff) == own_list_player) owner_has_player = true;
for (size_t row = borrower_range.first; row < borrower_range.first + borrower_range.count; ++row)
if ((returning.squad_slots.at(row) & 0x0fff) == own_list_player) borrower_still_has_player = true;
bool owner_notice_mask = false;
for (size_t i = 0; i < kMailboxEntries; ++i)
if (record_u32(returning.mailbox, i * kMailboxEntry) == 0x80000001u) owner_notice_mask = true;
check(!return_report.unsupported && owner_has_player && !borrower_still_has_player &&
returning.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(loan_slot) * 4) == 0 &&
returning.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(saved_owner_record) * 2) == 0x0fff &&
returning.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField) == 0 &&
returning.memory.u8(::bmh::layout::ClubInfo_FormatError_RuntimeField2 + uint32_t(saved_owner_record)) == 0 && owner_notice_mask,
(std::string("monthly expiry returns loaned player to human owner with Source notice: ") +
(return_report.unsupported ? return_report.reason : "")).c_str());
bool snapshot_bytes_unchanged = true;
for (uint32_t b = 0; b < 0x58; ++b)
snapshot_bytes_unchanged = snapshot_bytes_unchanged &&
owner_loan.memory.u8(::bmh::layout::ClubInfo_FormatError_RuntimeField + uint32_t(saved_owner_record) * 0x58 + b) ==
returning.memory.u8(::bmh::layout::ClubInfo_FormatError_RuntimeField + uint32_t(saved_owner_record) * 0x58 + b);
check(snapshot_bytes_unchanged,
"loan return releases only the snapshot ID and count; saved board bytes remain Source-owned");
}
GameState human_borrower = transfer_state;
with_second_offer(human_borrower, 160);
const uint32_t human_borrower_at = ::bmh::layout::EditorListUnsigned + uint32_t(own_list_entry) * 0x58;
const int human_borrower_team = human_borrower.memory.u16(human_borrower_at + 2);
human_borrower.manager_teams.push_back(human_borrower_team);
human_borrower.manager_records.resize(2 * 0xb0c, 0);
human_borrower.memory.set8(human_borrower_at + 0x35, 0x8c);
GameRandom unsupported_game(0x9902);
WatcomRandom unsupported_rand = transfer_rand;
MinuteReport unsupported_report;
int unsupported_calls = 0;
int unsupported_observer_calls = 0;
human_borrower.transfer_decision_observer = [&](const TransferDecisionEvent&) {
++unsupported_observer_calls;
};
human_borrower.transfer_offer_selector = [&](const GameState& current, const TransferOfferListView& view) {
++unsupported_calls;
check(!view.offers[1].transaction_supported && view.offers[1].loan_permitted,
"loan to a human borrower remains visible but unavailable without its consent path");
(void)current;
return 1;
};
transfer_list_countdown(human_borrower, unsupported_game, unsupported_rand, unsupported_report);
check(!unsupported_report.unsupported && unsupported_calls == 8 &&
(human_borrower.squad_slots.at(0xb70u + size_t(own_list_entry)) & 0x0fff) == own_list_player &&
human_borrower.memory.u16(human_borrower_at + 2) != 0xffff,
"human borrower loan remains inert and preserves the listed player and bid");
check(unsupported_observer_calls == 0,
"preserved human borrower loan emits no acceptance or decline acknowledgement");
GameState decline = transfer_state;
with_second_offer(decline, 160);
GameRandom decline_game(0x66a1);
WatcomRandom decline_rand = transfer_rand;
MinuteReport decline_report;
run_selector(decline, decline_game, decline_rand,
[](const GameState&, const TransferOfferListView&) { return -1; }, decline_report);
bool kept_after_decline = false;
for (size_t row = own_squad.first; row < own_squad.first + own_squad.count; ++row)
if ((decline.squad_slots.at(row) & 0x0fff) == own_list_player) kept_after_decline = true;
check(!decline_report.unsupported && kept_after_decline,
"explicit source decline keeps the listed player with the seller");
GameState decline_silent = transfer_state;
GameState decline_observed = transfer_state;
with_second_offer(decline_silent, 160);
with_second_offer(decline_observed, 160);
int decline_ack_count = 0;
decline_observed.transfer_decision_observer = [&](const TransferDecisionEvent& event) {
++decline_ack_count;
check(event.kind == TransferDecisionEventKind::confirmation && !event.accepted &&
event.selected_bid_index == -1 && event.viewer_manager == 0 &&
event.result_text_address == ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField,
"explicit right-click decline emits a seller acknowledgement with the original text");
};
decline_silent.transfer_offer_selector = [](const GameState&, const TransferOfferListView&) { return -1; };
decline_observed.transfer_offer_selector = decline_silent.transfer_offer_selector;
GameRandom decline_silent_game(0x7661), decline_observed_game(0x7661);
WatcomRandom decline_silent_rand = transfer_rand, decline_observed_rand = transfer_rand;
MinuteReport decline_silent_report, decline_observed_report;
transfer_list_countdown(decline_silent, decline_silent_game, decline_silent_rand, decline_silent_report);
transfer_list_countdown(decline_observed, decline_observed_game, decline_observed_rand, decline_observed_report);
check(!decline_silent_report.unsupported && !decline_observed_report.unsupported &&
decline_ack_count == 1 &&
save_stream(decline_silent) == save_stream(decline_observed) &&
decline_silent_game.seed() == decline_observed_game.seed() &&
decline_silent_game.calls() == decline_observed_game.calls() &&
decline_silent_rand.seed() == decline_observed_rand.seed() &&
decline_silent_rand.calls() == decline_observed_rand.calls(),
"decline observer is RNG- and game-state-neutral");
GameState suppressed_decline = transfer_state;
with_second_offer(suppressed_decline, 160);
suppressed_decline.transfer_notice_suppressed = true; // format field is runtime-only, not a save block
suppressed_decline.transfer_offer_selector = [](const GameState&, const TransferOfferListView&) { return -1; };
int suppressed_ack_count = 0;
suppressed_decline.transfer_decision_observer = [&](const TransferDecisionEvent&) { ++suppressed_ack_count; };
GameRandom suppressed_game(0x7663);
WatcomRandom suppressed_rand = transfer_rand;
MinuteReport suppressed_report;
transfer_list_countdown(suppressed_decline, suppressed_game, suppressed_rand, suppressed_report);
check(!suppressed_report.unsupported && suppressed_ack_count == 0,
"Source suppression flag hides explicit-decline notice and its UI acknowledgement");
GameState selected_silent = transfer_state;
GameState selected_observed = transfer_state;
const int selected_ack_buyer = with_second_offer(selected_silent, 160);
check(with_second_offer(selected_observed, 160) == selected_ack_buyer,
"selected-offer observer fixtures have same raw-slot buyer");
selected_silent.transfer_offer_selector = [](const GameState&, const TransferOfferListView&) { return 1; };
selected_observed.transfer_offer_selector = selected_silent.transfer_offer_selector;
int selected_ack_count = 0;
selected_observed.transfer_decision_observer = [&](const TransferDecisionEvent& event) {
++selected_ack_count;
bool buyer_owns = false;
const SquadRange buyer_range = squad_range(selected_ack_buyer);
for (size_t row = buyer_range.first; row < buyer_range.first + buyer_range.count; ++row)
if ((selected_observed.squad_slots.at(row) & 0x0fff) == own_list_player) buyer_owns = true;
check(event.kind == TransferDecisionEventKind::confirmation && event.accepted &&
event.selected_bid_index == 1 && event.viewer_manager == 0 &&
event.result_text_address == ::bmh::layout::PendingOffer_FormatError_ExecutableField2 && event.offers.player == own_list_player &&
event.offers.offers[1].buyer == selected_ack_buyer && buyer_owns,
"non-top selected offer acknowledges the human seller only after the real move");
};
GameRandom selected_silent_game(0x7662), selected_observed_game(0x7662);
WatcomRandom selected_silent_rand = transfer_rand, selected_observed_rand = transfer_rand;
MinuteReport selected_silent_report, selected_observed_report;
transfer_list_countdown(selected_silent, selected_silent_game, selected_silent_rand, selected_silent_report);
transfer_list_countdown(selected_observed, selected_observed_game, selected_observed_rand, selected_observed_report);
check(!selected_silent_report.unsupported && !selected_observed_report.unsupported &&
selected_ack_count == 1 && save_stream(selected_silent) == save_stream(selected_observed) &&
selected_silent_game.seed() == selected_observed_game.seed() &&
selected_silent_game.calls() == selected_observed_game.calls() &&
selected_silent_rand.seed() == selected_observed_rand.seed() &&
selected_silent_rand.calls() == selected_observed_rand.calls(),
"successful manual selection emits one acknowledgement without changing state or RNG");
}
{
GameState seller_state = transfer_state;
WatcomRandom seller_rand = transfer_rand;
GameRandom seller_game(0x3399);
prepare_ai_offer(seller_state);
int decisions = 0;
int automatic_events=0;
seller_state.transfer_decision_observer=[&](const TransferDecisionEvent&){++automatic_events;};
seller_state.transfer_decision = [&](GameState&, int, int, int, int32_t, int32_t) { ++decisions; return true; };
MinuteReport sale_report;
const int32_t balance = int32_t(uint32_t(seller_state.manager_records.at(0x314)) |
uint32_t(seller_state.manager_records.at(0x315)) << 8 | uint32_t(seller_state.manager_records.at(0x316)) << 16 |
uint32_t(seller_state.manager_records.at(0x317)) << 24);
transfer_list_countdown(seller_state, seller_game, seller_rand, sale_report);
bool still_owned = false;
for (size_t row = own_squad.first; row < own_squad.first + own_squad.count; ++row)
if ((seller_state.squad_slots.at(row) & 0xfff) == own_list_player) still_owned = true;
const int32_t after_sale = int32_t(uint32_t(seller_state.manager_records.at(0x314)) |
uint32_t(seller_state.manager_records.at(0x315)) << 8 | uint32_t(seller_state.manager_records.at(0x316)) << 16 |
uint32_t(seller_state.manager_records.at(0x317)) << 24);
check(!sale_report.unsupported && decisions == 1 && automatic_events==0 && !still_owned && after_sale > balance,
"manager accepts an AI offer, sells the player and receives the fee");
}
{
// Source legacy routine presents an automatic decision when an AI seller
// receives at least one human bid. The observer must not participate in
// ranking, quote generation, acceptance RNG, or the transfer itself.
auto prepare_human_bid = [&](GameState& state, uint32_t multiplier) {
const uint32_t at = ::bmh::layout::EditorListUnsigned + uint32_t(buy_entry) * 0x58;
const int player = state.squad_slots.at(0xb70u + size_t(buy_entry)) & 0x0fff;
check(player != 0x0fff && state.manager_of(state.memory.u16(at + 8) & 0x7fff) < 0,
"observer fixture uses a listed AI-seller player");
const int human_team = state.manager_teams.at(0);
const uint32_t base_fee = state.memory.u32(at + 0x2c);
const uint32_t base_salary = state.memory.u32(at + 0x30);
state.memory.set16(at, uint16_t(human_team));
state.memory.set16(at + 2, 0xffff);
state.memory.set32(at + 0x1c, base_fee * multiplier);
state.memory.set32(at + 0x0c, base_salary * multiplier);
state.memory.set8(at + 0x34, 24);
state.memory.set8(at + 0x56, 1);
for (int other = 0; other < 40; ++other) {
if (other != buy_entry &&
(state.squad_slots.at(0xb70u + size_t(other)) & 0x0fff) != 0x0fff)
state.memory.set8(::bmh::layout::EditorListUnsigned + uint32_t(other) * 0x58 + 0x56, 9);
}
return player;
};
auto run_observer_case = [&](uint32_t multiplier, int seed, bool expected_acceptance) {
GameState silent = incoming_offer_base;
GameState observed = incoming_offer_base;
const int player = prepare_human_bid(silent, multiplier);
check(prepare_human_bid(observed, multiplier) == player, "observed and silent fixtures bind the same player");
std::vector<TransferDecisionEvent> events;
observed.transfer_decision_observer = [&](const TransferDecisionEvent& event) {
const auto human_squad=squad_range(observed.manager_teams.at(0));
bool owned=false;
for(size_t row=human_squad.first; row<human_squad.first+human_squad.count; ++row)
if((observed.squad_slots.at(row)&0xfff)==player) owned=true;
check(owned==(event.kind==TransferDecisionEventKind::confirmation),
"evaluation precedes the transfer and success confirmation follows actual ownership");
events.push_back(event); // copy only; presenter cannot mutate the game state
};
GameRandom silent_game(0x2300 + seed), observed_game(0x2300 + seed);
WatcomRandom silent_rand = incoming_offer_rand, observed_rand = incoming_offer_rand;
MinuteReport silent_report, observed_report;
transfer_list_countdown(silent, silent_game, silent_rand, silent_report, false,
TransferAllocatorContext::zero);
transfer_list_countdown(observed, observed_game, observed_rand, observed_report, false,
TransferAllocatorContext::zero);
check(!silent_report.unsupported && !observed_report.unsupported &&
save_stream(silent) == save_stream(observed) &&
silent.squad_slots == observed.squad_slots && silent.tactics == observed.tactics &&
silent.manager_records == observed.manager_records &&
silent_game.seed() == observed_game.seed() && silent_game.calls() == observed_game.calls() &&
silent_rand.seed() == observed_rand.seed() && silent_rand.calls() == observed_rand.calls(),
"observer on/off leaves saved state, transfer state, and both RNG streams identical");
check(events.size() == (expected_acceptance ? 2u : 1u) &&
!events.empty() && events[0].accepted == expected_acceptance,
"automatic decision emits evaluation and only emits confirmation after a successful transfer");
check(!events.empty() && events[0].kind == TransferDecisionEventKind::evaluation &&
events[0].offers.valid && events[0].offers.player == player &&
events[0].offers.seller_manager == -1 && events[0].offers.offer_count == 1 &&
events[0].selected_bid_index == 0 && events[0].viewer_manager == 0 &&
events[0].offers.quoted_years == 1 && events[0].offers.quoted_fee != 0 &&
events[0].offers.quoted_monthly_salary != 0 &&
events[0].offers.asking_fee != 0 && events[0].offers.asking_monthly_salary != 0 &&
events[0].result_text_address == (events[0].accepted ? ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer3Unsigned : ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer4Unsigned),
"observer receives an owned one-year decision snapshot and source outcome text");
if (expected_acceptance) {
check(events.size() == 2 && events[1].kind == TransferDecisionEventKind::confirmation &&
events[1].accepted && events[1].selected_bid_index == 0 &&
events[1].viewer_manager == 0 && events[1].result_text_address == ::bmh::layout::PendingOffer_FormatError_ExecutableField2Unsigned,
"successful human-buyer transfer emits the source confirmation only after the move");
} else {
check(events.size() == 1, "rejected automatic offer has no success confirmation");
}
};
run_observer_case(1, 0x51, false);
run_observer_case(3, 0x52, true);
for(bool human_loser : {false,true}) {
GameState ai_winner=incoming_offer_base;
prepare_human_bid(ai_winner,3);
const uint32_t at=::bmh::layout::EditorListUnsigned+uint32_t(buy_entry)*0x58;
int ai_buyer=-1;
for(int t=0;t<18;++t) {
if(ai_winner.manager_of(t)<0 && squad_count(ai_winner,t,3)<int(squad_range(t).count)-1) {ai_buyer=t;break;}
}
check(ai_buyer>=0,"AI-winner fixture has squad room");
ai_winner.memory.set16(at,uint16_t(ai_buyer));
if(human_loser) {
ai_winner.memory.set16(at+2,uint16_t(ai_winner.manager_teams.at(0)));
ai_winner.memory.set16(at+4,0xffff);
ai_winner.memory.set32(at+0x20,0); ai_winner.memory.set32(at+0x10,0);
ai_winner.memory.set8(at+0x35,12);
}
int evaluation_calls=0,confirmation_calls=0;
ai_winner.transfer_decision_observer=[&](const TransferDecisionEvent& event) {
if(event.kind==TransferDecisionEventKind::evaluation)++evaluation_calls;
else ++confirmation_calls;
check(event.selected_bid_index==0,"AI-winner retains the ranked raw slot");
};
GameRandom ai_game(0x2398);WatcomRandom ai_rand=incoming_offer_rand;MinuteReport ai_report;
transfer_list_countdown(ai_winner,ai_game,ai_rand,ai_report);
check(!ai_report.unsupported && evaluation_calls==(human_loser?1:0) && confirmation_calls==0,
"any human raw bidder sees evaluation even when AI wins; AI-only rows emit no UI events");
}
}
{
GameState seller_state = transfer_state;
WatcomRandom seller_rand = transfer_rand;
GameRandom seller_game(0x4499);
prepare_ai_offer(seller_state);
seller_state.transfer_decision = [](GameState&, int, int, int, int32_t, int32_t) { return false; };
MinuteReport sale_report;
transfer_list_countdown(seller_state, seller_game, seller_rand, sale_report);
bool still_owned = false;
for (size_t row = own_squad.first; row < own_squad.first + own_squad.count; ++row)
if ((seller_state.squad_slots.at(row) & 0xfff) == own_list_player) still_owned = true;
check(!sale_report.unsupported && still_owned, "declining a sale offer keeps the manager's player");
}
{
GameState departure_state = transfer_state;
WatcomRandom departure_rand = transfer_rand;
GameRandom departure_game(0x5599);
departure_state.squad_slots.at(0xb70u + 0x28) = uint16_t(own_list_player);
departure_state.memory.set32(::bmh::layout::OfferSlots, 0x80000000u | (uint32_t(own_list_player) << 10));
MinuteReport departure_report;
answer_offers(departure_state, 0, false, departure_rand, departure_report, &departure_game);
bool stayed = false;
for (size_t row = own_squad.first; row < own_squad.first + own_squad.count; ++row)
if ((departure_state.squad_slots.at(row) & 0xfff) == own_list_player) stayed = true;
check(!departure_report.unsupported && stayed, "declined release-clause salary demand keeps the player");
}
const auto item = std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(),
[](const DeskItem& v) { return v.kind == 14 && !v.disabled; });
check(item != flow.desktop()->state().items.end(), "bank menu in projected desk");
const auto open = flow.click(item->x + item->width / 2, item->y + item->height / 2);
check(flow.screen_name() == "bank" && open.request == FlowRequest::submenu_opened, "bank screen opens from desk");
flow.click(250, 80); // Original Bank_FinishCredit_RuntimeField/Bank_FinishCredit_RuntimeField3 cashier hitbox, index 3.
flow.click(80, 178); // Source EINZAHLEN button opens KB/6 calculator.
const int32_t balance_before = session.state().manager_records.at(0x314) |
int32_t(session.state().manager_records.at(0x315)) << 8 |
int32_t(session.state().manager_records.at(0x316)) << 16 |
int32_t(session.state().manager_records.at(0x317)) << 24;
check(balance_before > 1000, "career has transferable funds");
const int32_t amount = std::min<int32_t>(1000, balance_before);
const int32_t deposit_before = int32_t(uint32_t(session.state().manager_records.at(0x318)) |
uint32_t(session.state().manager_records.at(0x319)) << 8 | uint32_t(session.state().manager_records.at(0x31a)) << 16 |
uint32_t(session.state().manager_records.at(0x31b)) << 24);
flow.text(std::to_string(amount));
const auto submitted = flow.send_key("ENTER");
check(submitted.request == FlowRequest::submenu_action && std::holds_alternative<BankRequest>(submitted.submenu_action),
"deposit emits typed request");
const auto request = std::get<BankRequest>(submitted.submenu_action);
check(request.amount == amount && request.revision == revision && request.manager_slot == 0 &&
request.runtime_club == session.state().manager_teams.at(0), "request binds account context");
check(session.dispatch_bank(request, revision, error), "controller books fixed deposit");
flow.acknowledge_preparation(session.preparation_projection(revision));
const auto rec = session.state().manager_records;
const int32_t balance_after = int32_t(uint32_t(rec.at(0x314)) | uint32_t(rec.at(0x315)) << 8 |
uint32_t(rec.at(0x316)) << 16 | uint32_t(rec.at(0x317)) << 24);
const int32_t deposit_after = int32_t(uint32_t(rec.at(0x318)) | uint32_t(rec.at(0x319)) << 8 |
uint32_t(rec.at(0x31a)) << 16 | uint32_t(rec.at(0x31b)) << 24);
check(balance_before - balance_after == amount && deposit_after - deposit_before == amount, "authoritative account transfer returned");
flow.send_key("BACKSPACE"); flow.send_key("B");
check(flow.state_json().find("\"exchange_open\":true") != std::string::npos, "bank opens stock exchange locally");
int stock = -1;
for (int i = 0; i < kStocks; ++i) {
const size_t at = size_t(i) * 0x5c;
const uint16_t price = uint16_t(session.state().stocks.at(at + 0x4e) |
uint16_t(session.state().stocks.at(at + 0x4f)) << 8);
if (price != 0 && max_shares_to_buy(session.state(), 0, i) > 0) { stock = i; break; }
}
check(stock >= 0, "at least one stock can be bought in the initialized career");
const size_t holding = size_t(stock) * 0x5c + 0x50;
const uint16_t held_before = uint16_t(session.state().stocks.at(holding) | uint16_t(session.state().stocks.at(holding + 1)) << 8);
flow.click(55, 64 + stock * 8); flow.click(80, 178); flow.text("1");
auto buy = flow.send_key("ENTER");
check(buy.request == FlowRequest::submenu_action && std::get<BankRequest>(buy.submenu_action).kind == BankRequestKind::buy_shares,
"stock purchase is an explicit request");
check(session.dispatch_bank(std::get<BankRequest>(buy.submenu_action), revision, error), "controller buys one share");
flow.acknowledge_preparation(session.preparation_projection(revision));
const uint16_t held_after = uint16_t(session.state().stocks.at(holding) | uint16_t(session.state().stocks.at(holding + 1)) << 8);
check(held_after == held_before + 1, "share count returns from authoritative engine projection");
const auto calls_before_tip = session.rand().calls();
auto tip = flow.click(80, 165);
check(tip.request == FlowRequest::submenu_action && std::get<BankRequest>(tip.submenu_action).kind == BankRequestKind::stock_tip,
"expert advice is requested only on explicit click");
check(flow.click(80, 165).request == FlowRequest::none, "duplicate advice click suppressed");
check(session.dispatch_bank(std::get<BankRequest>(tip.submenu_action), revision, error), "controller executes paid advice");
const uint64_t tip_draws = session.rand().calls() - calls_before_tip;
check(tip_draws == 1 || tip_draws == 2, "expert advice uses original conditional Watcom draw count");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(flow.state_json().find("\"last_tip\":") != std::string::npos, "returned bank state contains advice result");
flow.send_key("BACKSPACE"); flow.send_key("I");
check(flow.state_json().find("\"funds_open\":true") != std::string::npos, "bank opens fund menu locally");
int fund = -1;
for (int i = 0; i < kFunds; ++i) {
if (session.state().memory.u32(::bmh::layout::FundBlock + uint32_t(i) * 0x1c) != 0 && max_fund_units(session.state(), 0, i) > 0) {
fund = i; break;
}
}
check(fund >= 0, "at least one fund can be bought in the initialized career");
const uint32_t held_offset = ::bmh::layout::FundBlock + uint32_t(fund) * 0x1c + 0x14;
const uint16_t fund_before = session.state().memory.u16(held_offset);
for (int i = 0; i < fund; ++i) flow.click(205, 130);
flow.click(80, 178); flow.text("1");
const auto fund_buy = flow.send_key("ENTER");
check(fund_buy.request == FlowRequest::submenu_action &&
std::get<BankRequest>(fund_buy.submenu_action).kind == BankRequestKind::buy_fund,
"fund purchase is an explicit request");
check(session.dispatch_bank(std::get<BankRequest>(fund_buy.submenu_action), revision, error), "controller buys one fund unit");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(session.state().memory.u16(held_offset) == fund_before + 1, "fund unit returns from authoritative projection");
if (fund > 0) flow.send_key("ENTER"); // Acknowledge the already-booked Source renovation notice.
flow.click(205, 178); flow.text("1");
const auto fund_sell = flow.send_key("ENTER");
check(fund_sell.request == FlowRequest::submenu_action &&
std::get<BankRequest>(fund_sell.submenu_action).kind == BankRequestKind::sell_fund,
"fund sale is an explicit request");
check(session.dispatch_bank(std::get<BankRequest>(fund_sell.submenu_action), revision, error), "controller sells one fund unit");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(session.state().memory.u16(held_offset) == fund_before, "fund sale returns authoritative holding");
check(flow.send_key("ESC").request == FlowRequest::none && flow.screen_name() == "bank",
"first escape restores the Original bank room");
check(flow.send_key("ESC").request == FlowRequest::submenu_closed, "second escape returns to desk without extra action");
const auto stadium_item = std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(),
[](const DeskItem& v) { return v.kind == 22 && !v.disabled; });
check(stadium_item != flow.desktop()->state().items.end(), "stadium menu in projected desk");
const int stadium_x = stadium_item->x + stadium_item->width / 2;
const int stadium_y = stadium_item->y + stadium_item->height / 2;
const auto stadium_open = flow.click(stadium_x, stadium_y);
check(stadium_open.request == FlowRequest::submenu_action &&
std::get<StadiumRequest>(stadium_open.submenu_action).kind == StadiumRequestKind::open,
"stadium entry emits original opening action");
const auto opening_draws = session.game().calls();
check(session.dispatch_stadium(std::get<StadiumRequest>(stadium_open.submenu_action), revision, error), "controller opens stadium");
check(session.game().calls() == opening_draws + 1, "stadium entry consumes exactly the opening discount draw");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(flow.state_json().find("\"opened\":true") != std::string::npos, "opening price projection returned");
const auto stadium_click = [&](int x, int y) {
flow.pointer_down(x,y);
return flow.click(x,y);
};
const auto stadium_apply = [&](const FlowResult& event) {
check(event.request == FlowRequest::submenu_action && std::holds_alternative<StadiumRequest>(event.submenu_action),
"stadium dispatch has an owned typed request");
check(session.dispatch_stadium(std::get<StadiumRequest>(event.submenu_action), revision, error),
"session accepts the source stadium action");
flow.acknowledge_preparation(session.preparation_projection(revision));
};
stadium_click(30,220); // Original button0 switches inside to periphery.
stadium_click(160,220); // Source button1 enables missing-building selection.
int object = -1;
for (int i = 0; i < 14; ++i) {
const size_t rec_at = size_t(i);
const uint8_t level = session.state().manager_records.at(rec_at);
const uint8_t days = session.state().manager_records.at(0x1e + rec_at);
if (!days && (i == 0 ? level < 0xab : level == 0)) { object = i; break; }
}
check(object >= 0, "at least one peripheral construction is selectable");
const auto before_no = session.state().manager_records;
const auto draws_before_no = session.rand().calls();
const auto periphery_exe = bmh::test::load_executable(asset_path(data, "BMH.exe"));
const int object_x = (periphery_exe.u16(::bmh::layout::Stadium_PeripheryObjectContains_ExecutableField + object * 8) + periphery_exe.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField2 + object * 8)) / 2;
const int object_y = (periphery_exe.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField + object * 8) + periphery_exe.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField3 + object * 8)) / 2;
const auto quote = stadium_click(object_x, object_y);
check(quote.request == FlowRequest::submenu_action &&
std::get<StadiumRequest>(quote.submenu_action).kind == StadiumRequestKind::quote_periphery,
"periphery selection requests real offer");
const auto offer_draws = session.game().calls();
check(session.dispatch_stadium(std::get<StadiumRequest>(quote.submenu_action), revision, error), "controller quotes periphery");
check(session.game().calls() == offer_draws + uint64_t(object + 1), "periphery quote consumes skipped entries then one price draw");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(flow.state_json().find("\"quoted_object\":" + std::to_string(object)) != std::string::npos,
"offer projection returned");
const auto game_draws_before_decline = session.game().calls();
const auto decline = stadium_click(200, 170);
check(decline.request == FlowRequest::submenu_action &&
std::get<StadiumRequest>(decline.submenu_action).kind == StadiumRequestKind::decline_periphery,
"NEIN emits a drawless offer-resolution request");
check(session.dispatch_stadium(std::get<StadiumRequest>(decline.submenu_action), revision, error), "controller declines offer");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(session.state().manager_records == before_no && session.rand().calls() == draws_before_no &&
session.game().calls() == game_draws_before_decline,
"declining offer leaves engine state and RNG untouched");
const auto quote_again = stadium_click(object_x, object_y);
check(session.dispatch_stadium(std::get<StadiumRequest>(quote_again.submenu_action), revision, error), "second quote accepted");
flow.acknowledge_preparation(session.preparation_projection(revision));
const auto build = stadium_click(100, 170);
check(build.request == FlowRequest::submenu_action &&
std::get<StadiumRequest>(build.submenu_action).kind == StadiumRequestKind::build_periphery,
"JA emits construction request");
check(session.dispatch_stadium(std::get<StadiumRequest>(build.submenu_action), revision, error), "controller books construction");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(session.state().manager_records.at(0x1e + size_t(object)) != 0, "authoritative construction countdown returned");
stadium_apply(flow.send_key("ESC"));
check(flow.screen_name() == "desktop", "stadium closes after the owned ACK");
const auto stadium_reopen = flow.click(stadium_x, stadium_y);
check(stadium_reopen.request == FlowRequest::submenu_action, "stadium may be opened again");
const auto repeat_open_draws = session.game().calls();
check(session.dispatch_stadium(std::get<StadiumRequest>(stadium_reopen.submenu_action), revision, error),
"repeat opening refreshes the quote context");
check(session.game().calls() == repeat_open_draws + 1, "repeat entry consumes one opening discount draw");
flow.acknowledge_preparation(session.preparation_projection(revision));
const auto facilities = session.preparation_projection(revision).stadium;
check(facilities.has_value(), "real facility projection is available after reopening");
int facility = -1;
for (int choice = 0; choice < 8; ++choice) {
const auto& row = facilities->investments[size_t(choice)];
if (row.available && !row.options.empty() &&
uint64_t(row.options.front().base_price) <= uint64_t(std::max<int32_t>(0,facilities->balance))) {
facility = choice; break;
}
}
check(facility >= 0, "at least one Original facility tier is payable");
const auto text_draws = session.game().calls();
stadium_apply(stadium_click(10 + facility % 4 * 54,160 + facility / 4 * 30));
check(session.game().calls() == text_draws + 1, "facility entry draws one Source G header");
check(!flow.stadium()->state().selected_option && stadium_click(10,140).request == FlowRequest::none,
"facility entry has no invented default tier");
stadium_apply(stadium_click(10,80));
const auto selected = flow.stadium()->state().investments[size_t(facility)].options.front();
auto expected = session.state(); auto expected_w = session.rand();
auto offer = prepare_stand_block_offer(selected.base_price,selected.base_weeks,expected_w);
stadium_apply(stadium_click(10,140));
check(session.rand().seed() == expected_w.seed() && session.rand().calls() == expected_w.calls(),
"Ausbauen prepares exactly one Source W tip quote");
resolve_stand_block_offer(offer,false,expected_w);
StadiumInvestmentConstants constants;
const auto stadium_exe = bmh::test::load_executable(asset_path(data, "BMH.exe"));
for(unsigned c=0;c<8;++c) {
constants.price[c] = stadium_exe.u32(::bmh::layout::CareerSession_DispatchStadium_RuntimeField+c*4);
constants.weeks[c] = stadium_exe.u8(::bmh::layout::CareerSession_DispatchStadium_RuntimeField2+(14+c)*5);
}
check(build_stadium_investment_source(expected,0,static_cast<StadiumInvestment>(facility),
facilities->construction_percent,constants,selected,offer,expected_w), "Source base-price construction is payable");
stadium_apply(stadium_click(180,170)); // No declines the tip, not construction.
check(save_stream(session.state()) == save_stream(expected) &&
session.rand().seed() == expected_w.seed() && session.rand().calls() == expected_w.calls(),
"real App tip No pays and starts exactly the expected facility construction");
int cancellable = -1;
for(int c=0;c<8;++c)if(flow.stadium()->state().investments[size_t(c)].available){cancellable=c;break;}
check(cancellable >= 0, "another Original facility remains for initial Abbruch");
stadium_apply(stadium_click(10+cancellable%4*54,160+cancellable/4*30));
const auto cancel_native=save_stream(session.state()); const auto cancel_w=session.rand();
stadium_apply(stadium_click(110,140));
check(save_stream(session.state()) == cancel_native && session.rand().calls() == cancel_w.calls(),
"initial Abbruch performs no payment or W tip draw");
stadium_apply(flow.send_key("ESC"));
check(flow.screen_name() == "desktop", "reopened stadium closes only after the session ACK");
auto& game = session.state();
check(game.memory.has(::bmh::layout::Coupon + 0x13) && game.memory.has(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField + 43) && game.memory.has(::bmh::layout::CareerSession_DispatchToto_RuntimeField),
"original coupon storage exists in the current game state");
game.memory.set8(::bmh::layout::CareerSession_DispatchToto_RuntimeField, 11);
for (int i = 0; i < 11; ++i) {
game.memory.set16(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField + uint32_t(i) * 4, uint16_t(i * 2));
game.memory.set16(::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField + uint32_t(i) * 4 + 2, uint16_t(i * 2 + 1));
}
const uint32_t coupon = ::bmh::layout::Coupon;
game.memory.set32(coupon, 0);
flow.attach_preparation_context(session.preparation_projection(revision));
const auto toto_item = std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(),
[](const DeskItem& v) { return v.kind == 13 && !v.disabled; });
check(toto_item != flow.desktop()->state().items.end(), "toto menu in projected desk");
const int toto_x = toto_item->x + toto_item->width / 2, toto_y = toto_item->y + toto_item->height / 2;
auto toto_open = flow.click(toto_x, toto_y);
check(flow.screen_name() == "toto" && toto_open.request == FlowRequest::submenu_opened,
"Toto coupon opens from the desk");
flow.click(260, 25);
check(game.memory.u32(coupon) == 0 && game.memory.u8(coupon + 8) == 0,
"ESC discards local picks without engine writes");
check(flow.send_key("ESC").request == FlowRequest::submenu_closed, "cancelled Toto dialog returns to desk");
toto_open = flow.click(toto_x, toto_y);
check(flow.screen_name() == "toto", "Toto dialog can be reopened");
flow.click(280, 25); // Source middle column: draw (stored 0).
const auto toto_underlay = flow.render();
flow.click(100, 200);
uint64_t toto_units = 100;
const auto toto_present = [&] { (void)flow.render(); return flow.after_toto_present(toto_units); };
const auto toto_key = [&](std::string_view value) {
flow.send_key(value); toto_present(); toto_units += 4;
flow.tick_toto_source_units(toto_units); toto_present(); toto_present();
};
toto_present();
for (char digit : std::string("20000")) toto_key(std::string(1, digit));
flow.send_key("ENTER"); // SDL handle also redraws keys whose numeric value stays unchanged.
toto_present();
toto_units += 3;
check(!flow.tick_toto_source_units(toto_units).changed && flow.in_toto_calculator(),
"Toto accept stays modal until the full Source four-unit wait");
++toto_units;
check(flow.tick_toto_source_units(toto_units).changed,
"Toto accept requests its final modal redraw without further input");
check(toto_present().changed && flow.in_toto_calculator(),
"presented final modal requests the restored-underlay exit frame");
check(flow.render().pixels == toto_underlay.pixels,
"Toto exit Present restores the original coupon before applying the new amount");
check(flow.after_toto_present(toto_units).changed && !flow.in_toto_calculator(),
"fresh exit Present ACK applies Toto amount without a mouse or keyboard wake-up");
check(flow.state_json().find("\"local_stake\":20000") != std::string::npos &&
flow.render().pixels != toto_underlay.pixels && game.memory.u32(coupon) == 0 &&
!flow.toto()->pending(),
"exit ACK requests the 20,000 coupon preview while authoritative coupon stays untouched");
flow.click(100, 200);
toto_present();
for (char digit : std::string("50000")) toto_key(std::string(1, digit));
toto_key("ENTER");
check(!flow.in_toto_calculator(), "Toto amount commits after source wait and exit Present");
const auto toto_submit = flow.send_key("ENTER");
check(toto_submit.request == FlowRequest::submenu_action &&
std::holds_alternative<TotoRequest>(toto_submit.submenu_action), "Tipp abgeben emits typed request");
const auto toto_request = std::get<TotoRequest>(toto_submit.submenu_action);
check(toto_request.manager_slot == 0 && toto_request.runtime_club == game.manager_teams.at(0) &&
toto_request.revision == revision && toto_request.stake == 50000 && toto_request.tips[0] == 0,
"coupon request binds manager, revision, stake and picks");
check(preparation_request_json(toto_submit.submenu_action).find("\"kind\":\"submit\"") != std::string::npos,
"Toto submission is serializable in the UI JSONL contract");
const int32_t toto_balance_before = session.state().manager_records.at(0x314) |
int32_t(session.state().manager_records.at(0x315)) << 8 |
int32_t(session.state().manager_records.at(0x316)) << 16 |
int32_t(session.state().manager_records.at(0x317)) << 24;
auto stale_toto = toto_request; ++stale_toto.revision;
check(!session.dispatch_toto(stale_toto, revision, error) && error == "stale_manager_or_revision",
"stale Toto request is rejected before coupon mutation");
check(session.state().memory.u32(coupon) == 0 && session.state().memory.u8(coupon + 8) == 0,
"stale Toto request preserves coupon bytes");
check(session.dispatch_toto(toto_request, revision, error), "controller submits Toto coupon");
check(session.state().memory.u32(coupon) == 50000 && session.state().memory.u8(coupon + 8) == 0,
"stake and draw are persisted in original coupon bytes");
check((session.state().manager_records.at(0x314) |
int32_t(session.state().manager_records.at(0x315)) << 8 |
int32_t(session.state().manager_records.at(0x316)) << 16 |
int32_t(session.state().manager_records.at(0x317)) << 24) == toto_balance_before,
"stake is charged only later during matchday settlement");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(flow.state_json().find("\"feedback\":\"TIPP ABGEGEBEN\"") != std::string::npos,
"accepted coupon returns authoritative state and confirmation");
check(flow.send_key("ESC").request == FlowRequest::submenu_closed, "Toto returns to desk after submission");
flow.click(toto_x, toto_y);
check(flow.process_timer_expired(10, 10).request == FlowRequest::submenu_closed,
"unchanged available Toto deadline returns without a request");
flow.click(toto_x, toto_y);
flow.click(295, 25);
const auto right_submit = flow.process_timer_expired(10, 10);
check(right_submit.request == FlowRequest::submenu_action && flow.screen_name() == "toto",
"changed Toto deadline waits for authoritative coupon ACK");
const auto pending_toto = flow.state_json();
check(!flow.process_timer_expired(10,10).changed && flow.state_json()==pending_toto,
"repeated deadline preserves the exact pending coupon rather than resubmitting it");
check(session.dispatch_toto(std::get<TotoRequest>(right_submit.submenu_action), revision, error),
"original right-click coupon submits through the normal controller action");
flow.acknowledge_preparation(session.preparation_projection(revision));
check(flow.screen_name() == "desktop" && session.state().memory.u8(coupon + 8) == 2,
"right-click ACK saves the away pick and returns to the desk");
const auto kickoff_item = std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(),
[](const DeskItem& v) { return v.kind == 12 && !v.disabled; });
check(kickoff_item != flow.desktop()->state().items.end(), "kickoff icon in projected desk");
const auto game_seed_before_kickoff = session.game().seed();
const auto game_draws_before_kickoff = session.game().calls();
const auto watcom_seed_before_kickoff = session.rand().seed();
const auto watcom_draws_before_kickoff = session.rand().calls();
const auto date_before_kickoff = game.date;
const auto kickoff = flow.click(kickoff_item->x + kickoff_item->width / 2,
kickoff_item->y + kickoff_item->height / 2);
check(kickoff.request == FlowRequest::kickoff && kickoff.desk_action.kind == DeskRequestKind::advance_turn,
"kickoff emits its own flow request and the typed desk request");
check(kickoff.desk_action.manager_slot == game.memory.u8(::bmh::layout::ActiveManager) && kickoff.desk_action.revision == revision,
"kickoff request binds current manager and revision");
check(desk_request_json(kickoff.desk_action).find("\"kind\":\"advance_turn\"") != std::string::npos,
"kickoff request is serialized for JSONL/app adapters");
const auto duplicate_kickoff = flow.click(kickoff_item->x + kickoff_item->width / 2,
kickoff_item->y + kickoff_item->height / 2);
check(duplicate_kickoff.request == FlowRequest::none, "a pending kickoff cannot be submitted twice");
check(game.date == date_before_kickoff && session.game().seed() == game_seed_before_kickoff &&
session.game().calls() == game_draws_before_kickoff && session.rand().seed() == watcom_seed_before_kickoff &&
session.rand().calls() == watcom_draws_before_kickoff, "UI kickoff request and duplicate draw no engine state or RNG");
const auto advanced = session.dispatch_kickoff(kickoff.desk_action, revision, error);
check(advanced.kind == TurnDeskKind::NextDesk && advanced.date > date_before_kickoff &&
advanced.manager_slot == int(game.memory.u8(::bmh::layout::ActiveManager)), "kickoff drives the engine to the next manager desk");
int kickoff_cues = 0, goal_cues = 0, full_time_cues = 0;
for (size_t i = 0; i < advanced.audio_events.size(); ++i) {
check(advanced.audio_events[i].session_id == advanced.audio_events.front().session_id &&
advanced.audio_events[i].event_id == advanced.audio_events.front().event_id + i &&
!advanced.audio_events[i].original_id, "audio events have monotone identity and no guessed original cue");
kickoff_cues += advanced.audio_events[i].kind == TurnAudioKind::kickoff_whistle;
goal_cues += advanced.audio_events[i].kind == TurnAudioKind::goal;
full_time_cues += advanced.audio_events[i].kind == TurnAudioKind::full_time_whistle;
}
check(kickoff_cues <= 1 && goal_cues <= 1 && full_time_cues <= 1,
"synchronous matchday audio is bounded to one cue per semantic kind");
const auto& last_results = session.last_turn_results();
check(last_results.valid, "completed matchday results are marked as retained");
check(last_results.date == date_before_kickoff,
"retained matchday result keeps the played date after the next desk advances");
bool manager_fixture = false, manager_goal = false;
for (const MatchGroup& group : last_results.groups)
for (int m = 0; m < group.matches(); ++m) {
if (group.void_mask() >> m & 1) continue;
const bool managed = game.manager_of(group.fixtures[size_t(m * 2)]) >= 0 ||
game.manager_of(group.fixtures[size_t(m * 2 + 1)]) >= 0;
manager_fixture = manager_fixture || managed;
int home = 0, away = 0;
if (managed && match_score(group, m, home, away) && (home > 0 || away > 0)) manager_goal = true;
}
check(kickoff_cues == int(manager_fixture) && full_time_cues == int(manager_fixture) &&
goal_cues == int(manager_goal),
"only manager fixtures emit matchday cues, with one goal summary when one scored");
check(game.date == advanced.date && revision == advanced.revision && revision > kickoff.desk_action.revision,
"accepted kickoff advances authoritative date and revision");
auto stale_kickoff = kickoff.desk_action;
const auto stale_game_seed = session.game().seed();
const auto stale_game_calls = session.game().calls();
const auto stale_watcom_seed = session.rand().seed();
const auto stale_watcom_calls = session.rand().calls();
const auto stale_date = session.state().date;
const auto rejected = session.dispatch_kickoff(stale_kickoff, revision, error);
check(rejected.kind == TurnDeskKind::Failed && error == "stale_manager_or_revision",
"duplicate old kickoff revision is rejected");
check(session.state().date == stale_date && session.game().seed() == stale_game_seed &&
session.game().calls() == stale_game_calls && session.rand().seed() == stale_watcom_seed &&
session.rand().calls() == stale_watcom_calls, "stale kickoff has no state or RNG side effects");
flow.acknowledge_desk(session.desktop_projection(revision));
flow.attach_preparation_context(session.preparation_projection(revision));
auto find_menu = [&](int kind) {
return std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(),
[kind](const DeskItem& v) { return v.kind == kind && !v.disabled; });
};
auto save_item = find_menu(11);
check(save_item != flow.desktop()->state().items.end(), "save menu in projected desk");
auto save_open = flow.click(save_item->x + save_item->width / 2, save_item->y + save_item->height / 2);
check(save_open.request == FlowRequest::submenu_opened && flow.screen_name() == "save_load",
"save menu opens a local file dialog");
check(flow.state_json().find("IGNORE.TXT") == std::string::npos,
"file browser lists only regular .FBM saves");
check(!flow.text("IGNORED"), "typing without the Original filename field focus is inert");
flow.click(150, 214); check(flow.text("TESTSAVE"), "Original filename field accepts DOS-safe text");
const auto save_action = flow.send_key("ENTER");
check(save_action.request == FlowRequest::file_action && save_action.file_action.action == SaveLoadAction::save &&
save_action.file_action.manager_slot == int(game.memory.u8(::bmh::layout::ActiveManager)) && save_action.file_action.revision == revision &&
save_action.file_action.path.filename() == "TESTSAVE.FBM" && !save_action.file_action.overwrite,
"save request binds active manager, revision and a new filename");
const auto save_draws = session.rand().calls();
check(session.save_game(save_action.file_action.path, save_action.file_action.manager_slot,
save_action.file_action.overwrite, error), "controller writes the selected temporary save");
check(session.rand().calls() == save_draws + 4 && std::filesystem::exists(save_action.file_action.path),
"successful save performs exactly four Watcom draws and writes only to the temporary directory");
++revision;
flow.acknowledge_saved_game(session.desktop_projection(revision), session.preparation_projection(revision));
check(flow.screen_name() == "desktop" && flow.desktop()->state().revision == revision,
"saved-game acknowledgement refreshes the desk projection");
save_item = find_menu(11);
save_open = flow.click(save_item->x + save_item->width / 2, save_item->y + save_item->height / 2);
check(save_open.request == FlowRequest::submenu_opened, "save browser reopens for overwrite path");
flow.click(150, 214);
check(flow.send_key("ENTER").request == FlowRequest::none, "existing filename needs explicit overwrite confirmation");
const auto overwrite_action = flow.send_key("ENTER");
check(overwrite_action.request == FlowRequest::file_action && overwrite_action.file_action.overwrite,
"confirmed overwrite is explicit in the save request");
const auto overwrite_draws = session.rand().calls();
check(session.save_game(overwrite_action.file_action.path, overwrite_action.file_action.manager_slot,
overwrite_action.file_action.overwrite, error), "controller overwrites selected temporary save");
check(session.rand().calls() == overwrite_draws + 4, "overwrite consumes the original four save draws once");
++revision;
flow.acknowledge_saved_game(session.desktop_projection(revision), session.preparation_projection(revision));
auto load_item = find_menu(10);
check(load_item != flow.desktop()->state().items.end(), "load menu in projected desk");
auto load_open = flow.click(load_item->x + load_item->width / 2, load_item->y + load_item->height / 2);
check(load_open.request == FlowRequest::submenu_opened && flow.screen_name() == "save_load",
"load menu opens the temporary-save list");
const auto load_action = flow.send_key("ENTER");
check(load_action.request == FlowRequest::file_action && load_action.file_action.action == SaveLoadAction::load &&
load_action.file_action.manager_slot == int(game.memory.u8(::bmh::layout::ActiveManager)) && load_action.file_action.revision == revision,
"selected save emits a manager-/revision-bound load request");
auto loaded = std::make_unique<app::CareerSession>(data, 0x1199, load_action.file_action.path);
const auto loaded_revision = revision + 1;
flow.attach_loaded_game(loaded->desktop_projection(loaded_revision), loaded->preparation_projection(loaded_revision));
session = std::move(*loaded); revision = loaded_revision;
check(flow.screen_name() == "desktop" && flow.desktop()->state().source == "engine_projection" &&
flow.desktop()->state().revision == revision && session.state().date == game.date,
"loaded state replaces the session and is projected without setup defaults");
{
app::CareerSession multi(data, 0x22aa7712);
SetupOptions options = flow.options();
options.managers = 2;
check(multi.confirm_manager(options, first_manager_choice, error), "first multi-manager choice initialized");
const auto remapped = multi.selection_context(1);
const auto other = std::find_if(remapped.club_order.begin(), remapped.club_order.end(),
[&](int master) { return master != first_manager_choice.master_club; });
check(other != remapped.club_order.end(), "second manager has a distinct club choice");
ManagerChoice second = first_manager_choice;
second.slot = 1;
second.master_club = *other;
second.name += " B";
check(multi.confirm_manager(options, second, error), "second multi-manager choice initialized");
career_managers_end(multi.state(), false);
MinuteReport multi_report;
check(career_season_setup(multi.state(), multi.game(), multi.rand(), multi_report),
"two-manager season setup completes");
check(career_first_steps(multi.state(), multi.game(), multi.rand(), multi_report),
"two-manager first steps complete");
auto refs = load_database(data / "M3D.MAN").raw_referee_properties;
MatchdayContext context;
context.month = month_code(multi.state().date);
context.season_day = multi.state().season_day();
context.weekday = weekday_code(multi.state().date);
context.referees = &refs;
const uint16_t entry = multi.state().memory.u16(::bmh::layout::CompetitionCalendar + uint32_t(context.season_day) * 2);
auto groups = prepare_event(multi.state(), entry, context, multi.game(), multi.rand(), multi_report);
check(!multi_report.unsupported,
(std::string("two-manager event setup: ") + multi_report.reason).c_str());
(void)enter_event_desk(multi.state(), 0, groups, multi.game(), multi.rand(), multi_report);
check(!multi_report.unsupported,
(std::string("two-manager first desk: ") + multi_report.reason).c_str());
TurnDriver driver;
const uint64_t driver_revision = 1;
check(begin_turn_driver(driver, multi.state(), std::move(groups), entry, refs,
multi.session_id(), driver_revision, error),
"two-manager turn driver binds prepared event");
uint64_t multi_revision = driver_revision;
const uint32_t event_date = multi.state().date;
const int first_slot = int(multi.state().memory.u8(::bmh::layout::ActiveManager));
const auto next_manager = advance_to_next_desk(driver, multi.state(),
TurnAdvanceRequest{first_slot, multi_revision}, multi.game(), multi.rand(), multi_report);
check(next_manager.kind == TurnDeskKind::NextDesk && next_manager.date == event_date &&
next_manager.manager_slot != first_slot,
"first manager kickoff opens the next manager desk on the same event date");
multi_revision = next_manager.revision;
const auto game_seed = multi.game().seed();
const auto watcom_seed = multi.rand().seed();
const auto game_calls = multi.game().calls(), watcom_calls = multi.rand().calls();
const auto stale_revision_result = advance_to_next_desk(driver, multi.state(),
TurnAdvanceRequest{next_manager.manager_slot, driver_revision}, multi.game(), multi.rand(), multi_report);
check(stale_revision_result.kind == TurnDeskKind::Failed && multi.state().date == event_date &&
multi.game().seed() == game_seed && multi.rand().seed() == watcom_seed &&
multi.game().calls() == game_calls && multi.rand().calls() == watcom_calls,
"stale revision for the current manager is rejected without RNG or date effects");
const auto stale_result = advance_to_next_desk(driver, multi.state(),
TurnAdvanceRequest{first_slot, multi_revision}, multi.game(), multi.rand(), multi_report);
check(stale_result.kind == TurnDeskKind::Failed && multi.state().date == event_date &&
multi.game().seed() == game_seed && multi.rand().seed() == watcom_seed &&
multi.game().calls() == game_calls && multi.rand().calls() == watcom_calls,
"wrong-manager multi-manager kickoff is rejected without RNG or date effects");
const int final_slot = int(multi.state().memory.u8(::bmh::layout::ActiveManager));
const auto after_matchday = advance_to_next_desk(driver, multi.state(),
TurnAdvanceRequest{final_slot, multi_revision}, multi.game(), multi.rand(), multi_report);
check(after_matchday.kind == TurnDeskKind::NextDesk && after_matchday.date > event_date &&
driver.last_results.valid && driver.last_results.date == event_date,
"final manager kickoff alone resolves the event and preserves its result snapshot");
}
{
app::CareerSession four(data, 0x22aa7714);
SetupOptions options = flow.options();
options.managers = 4;
std::vector<int> selected;
ManagerChoice choice = first_manager_choice;
check(four.confirm_manager(options, choice, error), "four-manager first career choice");
selected.push_back(choice.master_club);
for (int slot = 1; slot < 4; ++slot) {
const auto context = four.selection_context(uint64_t(slot));
const auto next = std::find_if(context.club_order.begin(), context.club_order.end(),
[&](int master) { return std::find(selected.begin(), selected.end(), master) == selected.end(); });
check(next != context.club_order.end(), "four-manager choice is distinct");
choice = first_manager_choice;
choice.slot = slot;
choice.master_club = *next;
choice.name += " M";
check(four.confirm_manager(options, choice, error), "four-manager career choice");
selected.push_back(*next);
}
CareerInitializationResult initialized;
check(four.finish(initialized, error), (std::string("four-manager finish: ") + error).c_str());
uint64_t rev = initialized.desktop.revision;
const uint32_t event_date = four.state().date;
for (int desk = 0; desk < 4; ++desk) {
const int slot = int(four.state().memory.u8(::bmh::layout::ActiveManager));
const auto result = four.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, rev}, rev, error);
check(result.kind == TurnDeskKind::NextDesk, "four-manager CareerSession accepts current desk ACK");
if (desk < 3)
check(result.date == event_date, "four-manager intermediate desks keep the event date");
else
check(result.date > event_date && four.last_turn_results().valid &&
four.last_turn_results().date == event_date,
"only the fourth manager ACK resolves and retains the matchday");
}
}
{
// Core's source path narrows the result-array offset to uint8_t before
// indexing. A valid 16-team, two-leg group at played=16 wraps 8*16*2 to 0.
GameState cup_state;
cup_state.memory.add_block(0, ::bmh::layout::FixtureBankMemoryImageSize);
cup_state.team_flags.resize(0x200);
StaticMemory& mem = cup_state.memory;
const uint32_t entry = cup_entry_address(0);
constexpr uint32_t teams = ::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField24;
constexpr uint32_t first_leg = ::bmh::layout::SyntheticCupFirstLegBegin;
constexpr uint32_t second_leg = ::bmh::layout::SyntheticCupSecondLegBegin;
mem.set_pointer(entry, teams);
mem.set_pointer(entry + 8, ::bmh::layout::CareerSession_RuntimeError_ExecutableField3); // original sixteen-team round strings
mem.set_pointer(entry + 0x0c, first_leg);
mem.set_pointer(entry + 0x10, second_leg);
mem.set8(entry + 0x14, 1); // group stage, two legs
mem.set16(entry + 0x18, 0);
mem.set8(entry + 0x1a, 16);
mem.set8(entry + 0x1b, 30); // 15 rounds per leg
mem.set8(entry + 0x1d, 16); // active leg 2; uint8_t(8 * 16 * 2) == 0
mem.set8(entry + 0x1e, 1);
for (int i = 0; i < 16; ++i) mem.set16(teams + uint32_t(i) * 2, uint16_t(i));
for (int i = 0; i < 16; ++i) {
mem.set16(first_leg + uint32_t(i) * 2, uint16_t(0x120 + i));
mem.set16(second_leg + uint32_t(i) * 2, uint16_t(0x220 + i));
}
std::vector<MatchGroup> cup_groups;
MinuteReport cup_report;
setup_cup_groups(cup_state, 0, cup_groups, cup_report);
check(!cup_report.unsupported && cup_groups.size() == 1 &&
cup_groups[0].fixtures.size() == 16 && cup_groups[0].cup_results.size() == 8 &&
cup_groups[0].cup_other_leg.size() == 8,
"Core accepts a valid two-leg cup group at the uint8 result-offset wrap");
check(cup_groups[0].cup_results.front() == 0x120 &&
cup_groups[0].cup_other_leg.front() == 0x220,
"Core cup result arrays use wrapped byte offset zero for the active leg");
}
if (const char* regression_dir = std::getenv("BMH_CUP_REGRESSION_DIR")) {
const std::filesystem::path saves(regression_dir);
if (std::filesystem::exists(saves / "BACKUP.FBM")) {
const auto backup = saves / "BACKUP.FBM";
const Savegame stored = load_savegame(backup);
app::CareerSession loaded(data, 0x22aa7729, backup);
const StaticMemory& mem = loaded.state().memory;
check(mem.pointer(::bmh::layout::CupTable) == ::bmh::layout::Field && mem.pointer(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField11) == ::bmh::layout::ReplayFixtures &&
mem.pointer(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField12) == ::bmh::layout::ReplayResults && mem.pointer(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField13) == ::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField28,
"BACKUP rebinds competition-table pointers as the original load path does");
check(loaded.game().calls() == 0 && loaded.rand().calls() == 0,
"BACKUP competition-pointer rebind consumes no random draws");
uint64_t revision = 1;
const int active = int(mem.u8(::bmh::layout::ActiveManager));
const auto resumed = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active, -1, -1, -1, revision}, revision, error);
check(resumed.kind != TurnDeskKind::Failed,
(std::string("BACKUP resumes without stale competition pointers: ") + error).c_str());
check(load_savegame(backup).stream == stored.stream,
"BACKUP source file remains unchanged by pointer rebinding and kickoff");
}
if (const char* stress_dir = std::getenv("BMH_CUP_STRESS_DIR")) {
struct SavedCupAnchor { const char* file; int cup; int entry; uint8_t desc_flags; };
static constexpr SavedCupAnchor anchors[] = {
{"event-028.FBM", 8, 23, 0x0c},
{"event-152.FBM", 8, 23, 0x0c},
{"event-020.FBM", 0, 0, 0x2c},
{"event-144.FBM", 0, 0, 0x2c},
};
for (size_t n = 0; n < std::size(anchors); ++n) {
const SavedCupAnchor& anchor = anchors[n];
const auto path = std::filesystem::path(stress_dir) / anchor.file;
app::CareerSession loaded(data, uint32_t(0x22aa7730 + n), path);
const StaticMemory& mem = loaded.state().memory;
const uint32_t entry = cup_entry_address(anchor.entry);
check(find_cup(mem, anchor.cup) == anchor.entry &&
int16_t(mem.u16(entry + 0x18)) == anchor.cup &&
(mem.u8(entry + 0x14) & 4) &&
mem.u8(entry + 0x1a) == (anchor.cup == 8 ? 2 : 64),
(std::string(anchor.file) + " identifies the captured active knockout stage").c_str());
bool descriptor_matches = false;
for (int group = 0; group < 6; ++group) {
const uint32_t desc = ::bmh::layout::MatchdayGroupDescriptors + uint32_t(group) * 0xd0;
if (mem.u8(desc) == anchor.cup + 1 &&
mem.u32(desc + 0xcc) == entry + kGuestDataBase) {
descriptor_matches = mem.u8(desc + 1) == anchor.desc_flags && mem.u8(desc + 2) == 1;
break;
}
}
check(descriptor_matches,
(std::string(anchor.file) + " preserves the source-built final/Type-8 descriptor flags").c_str());
const Savegame stored = load_savegame(path);
check(save_stream(loaded.state()) == stored.stream && loaded.game().calls() == 0 &&
loaded.rand().calls() == 0,
(std::string(anchor.file) + " loads byte-exactly without RNG or event preparation").c_str());
const int slot = int(mem.u8(::bmh::layout::ActiveManager));
uint64_t revision = 1;
const auto resumed = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, revision}, revision, error);
check(resumed.kind != TurnDeskKind::Failed,
(std::string(anchor.file) + " resumes its special cup round: " + error).c_str());
}
}
for (const char* name : {"2PNWK060.FBM", "NATWK001.FBM", "NATWK008.FBM", "NATWK012.FBM"}) {
const auto path = saves / name;
constexpr uint32_t watcom_seed = 0x22aa7750;
app::CareerSession loaded(data, watcom_seed, path);
const GameState& state = loaded.state();
const int active = int(state.memory.u8(::bmh::layout::ActiveManager));
const uint32_t entry_at = ::bmh::layout::CompetitionCalendar + uint32_t(state.season_day()) * 2;
check(state.memory.u16(entry_at) == 0x4006 &&
day_competitions(state, state.memory.u16(entry_at)) == 0x800000 &&
state.memory.u32(::bmh::layout::SavedCompetition) == 0,
(std::string(name) + " has the source-defined no-fixture national-team marker").c_str());
const Savegame stored = load_savegame(path);
const Bytes rebound = save_stream(state);
bool canonical_stream = rebound == stored.stream;
if (!canonical_stream && state.memory.u8(::bmh::layout::CoachActive) != 0 && rebound.size() == stored.stream.size()) {
SaveState original_state(stored.stream);
const size_t coach_byte = original_state.block(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField3).offset;
canonical_stream = rebound[coach_byte] == state.memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField3);
for (size_t i = 0; canonical_stream && i < rebound.size(); ++i)
if (i != coach_byte && rebound[i] != stored.stream[i]) canonical_stream = false;
}
check(canonical_stream && loaded.game().calls() == 0 &&
loaded.rand().calls() == 0 && loaded.rand().seed() == watcom_seed,
(std::string(name) + " binds with only the documented national-coach save transform and no RNG").c_str());
uint64_t revision = 1;
const auto resumed = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active, -1, -1, -1, revision}, revision, error);
check(resumed.kind != TurnDeskKind::Failed,
(std::string(name) + " accepts its national no-fixture desk: " + error).c_str());
}
auto reject_competition_mismatch = [&](const char* name, uint32_t corrupt_mask) {
const auto original = saves / name;
app::CareerSession source(data, 0x22aa7751, original);
const int active = int(source.state().memory.u8(::bmh::layout::ActiveManager));
const uint32_t original_mask = source.state().memory.u32(::bmh::layout::SavedCompetition);
check((original_mask & corrupt_mask) != 0,
(std::string(name) + " fixture has the expected active bit").c_str());
source.state().memory.set32(::bmh::layout::SavedCompetition, original_mask ^ corrupt_mask);
const auto corrupt_save = temp.path / (std::string(name) + ".BAD-CALENDAR.FBM");
check(source.save_game(corrupt_save, active, true, error),
(std::string(name) + " corrupted calendar fixture saves: " + error).c_str());
bool rejected = false;
try { app::CareerSession bad(data, 0x22aa7752, corrupt_save); }
catch (const std::runtime_error& e) {
rejected = std::string(e.what()) ==
"saved turn cursor: current calendar and saved competition flags disagree";
}
check(rejected, (std::string(name) + " rejects a corrupted saved league/cup bit").c_str());
};
if (std::filesystem::exists(saves / "WEEK196.FBM"))
reject_competition_mismatch("WEEK196.FBM", 1u); // active league bit
if (std::filesystem::exists(saves / "NATWK009.FBM"))
reject_competition_mismatch("NATWK009.FBM", 1u << 11); // active cup bit
const auto week196 = saves / "WEEK196.FBM";
if (std::filesystem::exists(week196)) {
const auto roundtrip_dir = temp.path / "league-voidmask-roundtrip";
std::filesystem::create_directories(roundtrip_dir);
app::CareerSession source(data, 0x22aa7713, week196);
uint64_t source_revision = 1;
std::filesystem::path third_save;
for (int event = 0; event < 3; ++event) {
const int active = int(source.state().memory.u8(::bmh::layout::ActiveManager));
const auto advanced = source.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active, -1, -1, -1, source_revision},
source_revision, error);
check(advanced.kind != TurnDeskKind::Failed,
(std::string("WEEK196 setup event advances: ") + error).c_str());
third_save = roundtrip_dir / ("event-" + std::to_string(event + 1) + ".FBM");
check(source.save_game(third_save, int(source.state().memory.u8(::bmh::layout::ActiveManager)), true, error),
"WEEK196 intermediate desk saves without touching the original fixture");
}
const Savegame stored = load_savegame(third_save);
SaveState stored_state(stored.stream);
const GameState decoded = GameState::from_save(stored_state);
const uint32_t descriptor = ::bmh::layout::MatchdayGroupDescriptors;
const int matches = decoded.memory.u8(descriptor + 2);
const uint32_t mask = decoded.memory.u32(descriptor + 0xb8);
const uint32_t valid_mask = matches == 32 ? 0xffffffffu : ((1u << matches) - 1u);
check((mask & ~valid_mask) != 0,
"WEEK196 event-3 save reproduces stale void-mask padding from the previous larger group");
app::CareerSession restored(data, 0x22aa7714, third_save);
const int active = int(restored.state().memory.u8(::bmh::layout::ActiveManager));
const int32_t stored_game_seed = restored.state().memory.has(::bmh::layout::CareerSession_Save_RuntimeField)
? int32_t(restored.state().memory.u32(::bmh::layout::CareerSession_Save_RuntimeField)) : 0;
check(save_stream(restored.state()) == stored.stream &&
restored.game().seed() == stored_game_seed &&
restored.game().calls() == 0 && restored.rand().seed() == 0x22aa7714 &&
restored.rand().calls() == 0,
"loading the self-saved stale-padding desk preserves GameState and consumes no RNG");
uint64_t restored_revision = 1;
const auto resumed = restored.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, active, -1, -1, -1, restored_revision},
restored_revision, error);
check(resumed.kind != TurnDeskKind::Failed,
(std::string("self-saved stale-padding desk loads and advances: ") + error).c_str());
}
for (const char* name : {"NATWK009.FBM", "NATWK004.FBM"}) {
const auto path = saves / name;
app::CareerSession loaded(data, 0x22aa7718, path);
const int slot = int(loaded.state().memory.u8(::bmh::layout::ActiveManager));
check(loaded.rand().calls() == 0, "national cup save binds without Watcom RNG");
uint64_t rev = 1;
const auto resumed = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, rev}, rev, error);
check(resumed.kind != TurnDeskKind::Failed && loaded.last_turn_results().valid &&
!loaded.last_turn_results().groups.empty(),
(std::string(name) + " resumes its saved cup matchday: " + error).c_str());
}
for (const char* name : {"WEEK204N.FBM", "WEEK204.FBM", "WEEK205.FBM"}) {
const auto path = saves / name;
constexpr uint32_t watcom_seed = 0x22aa7740;
app::CareerSession loaded(data, watcom_seed, path);
const int slot = int(loaded.state().memory.u8(::bmh::layout::ActiveManager));
const Savegame stored = load_savegame(path);
const uint32_t stored_game_seed = loaded.state().memory.has(::bmh::layout::CareerSession_Save_RuntimeField)
? loaded.state().memory.u32(::bmh::layout::CareerSession_Save_RuntimeField) : 0;
check(save_stream(loaded.state()) == stored.stream &&
loaded.game().seed() == int32_t(stored_game_seed) && loaded.game().calls() == 0 &&
loaded.rand().seed() == watcom_seed && loaded.rand().calls() == 0,
(std::string(name) + " restores friendly desk bytes without setup or RNG").c_str());
check((loaded.state().memory.u32(::bmh::layout::SavedCompetition) & (1u << 15)) != 0,
(std::string(name) + " retains its active friendly competition").c_str());
uint64_t revision = 1;
const auto resumed = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, revision}, revision, error);
const bool friendly_group = std::any_of(loaded.last_turn_results().groups.begin(),
loaded.last_turn_results().groups.end(), [](const MatchGroup& group) {
return !group.fixtures.empty() && group.desc[0] == 11 && group.matches() == 1;
});
check(resumed.kind != TurnDeskKind::Failed && loaded.last_turn_results().valid && friendly_group,
(std::string(name) + " resumes the saved friendly match: " + error).c_str());
}
if (std::filesystem::exists(week196)) {
app::CareerSession source(data, 0x22aa7721, week196);
bool verified_ko_resume = false;
uint64_t source_revision = 1;
for (int event = 0; event < 40 && !verified_ko_resume; ++event) {
const uint32_t competitions = source.state().memory.u32(::bmh::layout::SavedCompetition);
int ko_entry = -1;
for (int bit = 5; bit < 0x13 && ko_entry < 0; ++bit) {
if (!((competitions >> bit) & 1u)) continue;
int entry = find_cup(source.state().memory, bit - 5);
for (int guard = 0; entry >= 0 && guard < kCupEntries; ++guard) {
const uint32_t address = cup_entry_address(entry);
if (cup_round(source.state().memory, entry) < source.state().memory.u8(address + 0x1b)) {
if ((bit - 5) <= 8 && (source.state().memory.u8(address + 0x14) & 4))
ko_entry = entry;
break;
}
entry = int8_t(source.state().memory.u8(address + 0x16));
}
}
if (ko_entry >= 0) {
const int slot = int(source.state().memory.u8(::bmh::layout::ActiveManager));
const auto ko_save = temp.path / "generated-ko-round.FBM";
check(source.save_game(ko_save, slot, true, error),
(std::string("generated KO-round save: ") + error).c_str());
const Savegame stored = load_savegame(ko_save);
app::CareerSession restored(data, 0x22aa7722, ko_save);
const int32_t stored_seed = restored.state().memory.has(::bmh::layout::CareerSession_Save_RuntimeField)
? int32_t(restored.state().memory.u32(::bmh::layout::CareerSession_Save_RuntimeField)) : 0;
check(save_stream(restored.state()) == stored.stream &&
restored.game().seed() == stored_seed && restored.game().calls() == 0 &&
restored.rand().calls() == 0,
"KO round reload preserves saved bytes and consumes no RNG or setup work");
app::CareerSession malformed_source(data, 0x22aa7723, ko_save);
const uint32_t entry_address = cup_entry_address(ko_entry);
const int round = cup_round(source.state().memory, ko_entry);
const int first = uint8_t(cup_round_offset(source.state().memory, ko_entry, round));
const uint32_t team_list = malformed_source.state().memory.pointer(entry_address);
malformed_source.state().memory.set16(team_list + uint32_t(first) * 2, 0x7fff);
const auto malformed_path = temp.path / "generated-ko-round-bad-team.FBM";
check(malformed_source.save_game(malformed_path, slot, true, error),
"malformed KO save is written from a real generated round");
app::CareerSession malformed(data, 0x22aa7724, malformed_path);
const Bytes malformed_before = save_stream(malformed.state());
const uint32_t malformed_seed = malformed.game().seed();
const uint64_t malformed_calls = malformed.game().calls();
uint64_t malformed_revision = 1;
const auto rejected = malformed.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, malformed_revision},
malformed_revision, error);
check(rejected.kind == TurnDeskKind::Failed &&
save_stream(malformed.state()) == malformed_before &&
malformed.game().seed() == malformed_seed &&
malformed.game().calls() == malformed_calls && malformed.rand().calls() == 0,
"malformed active KO team is rejected without state or RNG mutation");
uint64_t restored_revision = 1;
const auto resumed = restored.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, restored_revision},
restored_revision, error);
check(resumed.kind != TurnDeskKind::Failed,
(std::string("generated saved KO round resumes and advances: ") + error).c_str());
verified_ko_resume = true;
break;
}
const int slot = int(source.state().memory.u8(::bmh::layout::ActiveManager));
const auto advanced = source.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, source_revision},
source_revision, error);
check(advanced.kind != TurnDeskKind::Failed,
(std::string("WEEK196 advances toward a generated KO round: ") + error).c_str());
}
check(verified_ko_resume,
"WEEK196 generated a saved KO round within the bounded resume probe");
}
const auto source_path = saves / "NATWK009.FBM";
const auto cup_dir = temp.path / "cup-corruptions";
std::filesystem::create_directories(cup_dir);
auto reject_corruption = [&](const char* name, auto corrupt) {
app::CareerSession source(data, 0x22aa7719, source_path);
const int slot = int(source.state().memory.u8(::bmh::layout::ActiveManager));
corrupt(source.state().memory);
const auto damaged_path = cup_dir / name;
check(source.save_game(damaged_path, slot, true, error),
"corrupt cup test save is written from a real national save");
app::CareerSession damaged(data, 0x22aa7720, damaged_path);
const uint32_t before_date = damaged.state().date;
const uint16_t before_fixture = damaged.state().memory.u16(::bmh::layout::MatchdayGroupDescriptors + 0x88);
const uint32_t before_stage = damaged.state().memory.u32(::bmh::layout::MatchdayGroupDescriptors + 0xcc);
const auto game_seed = damaged.game().seed();
const auto game_calls = damaged.game().calls();
const auto rand_seed = damaged.rand().seed();
const auto rand_calls = damaged.rand().calls();
uint64_t rev = 1;
const auto rejected = damaged.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, rev}, rev, error);
check(rejected.kind == TurnDeskKind::Failed && damaged.state().date == before_date &&
damaged.state().memory.u16(::bmh::layout::MatchdayGroupDescriptors + 0x88) == before_fixture &&
damaged.state().memory.u32(::bmh::layout::MatchdayGroupDescriptors + 0xcc) == before_stage &&
damaged.game().seed() == game_seed && damaged.game().calls() == game_calls &&
damaged.rand().seed() == rand_seed && damaged.rand().calls() == rand_calls,
"corrupt cup save is rejected without state or RNG mutation");
};
reject_corruption("NATWK009-BAD-FIXTURE.FBM", [](StaticMemory& mem) {
mem.set16(::bmh::layout::MatchdayGroupDescriptors + 0x8a, mem.u16(::bmh::layout::MatchdayGroupDescriptors + 0x88));
});
reject_corruption("NATWK009-BAD-STAGE.FBM", [](StaticMemory& mem) {
mem.set_pointer(::bmh::layout::MatchdayGroupDescriptors + 0xcc, cup_entry_address(11));
});
}
if (const char* indoor_dir = std::getenv("BMH_CUP_STRESS_DIR")) {
const std::filesystem::path saves(indoor_dir);
for (const auto& [filename, cup_type] : {
std::pair<const char*, int>{"event-089.FBM", 11},
std::pair<const char*, int>{"event-145.FBM", 13}}) {
const auto path = saves / filename;
const uint32_t watcom_seed = 0x22aa7730u + unsigned(cup_type);
app::CareerSession loaded(data, watcom_seed, path);
const int slot = int(loaded.state().memory.u8(::bmh::layout::ActiveManager));
const uint32_t saved_seed = loaded.state().memory.has(::bmh::layout::CareerSession_Save_RuntimeField)
? loaded.state().memory.u32(::bmh::layout::CareerSession_Save_RuntimeField) : 0;
const Savegame stored = load_savegame(path);
check(save_stream(loaded.state()) == stored.stream &&
loaded.game().seed() == int32_t(saved_seed) && loaded.game().calls() == 0 &&
loaded.rand().calls() == 0 && loaded.rand().seed() == watcom_seed,
(std::string(filename) + " binds saved cup cursor byte-for-byte without RNG").c_str());
check(loaded.state().indoor == (cup_type == 11),
(std::string(filename) + " restores the active indoor/outdoor runtime mode").c_str());
uint64_t revision = 1;
const auto advanced = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, revision}, revision, error);
const bool result_group = std::any_of(loaded.last_turn_results().groups.begin(),
loaded.last_turn_results().groups.end(), [cup_type](const MatchGroup& group) {
return !group.fixtures.empty() && group.desc[0] == cup_type + 1;
});
check(advanced.kind != TurnDeskKind::Failed && loaded.last_turn_results().valid && result_group,
(std::string(filename) + " resumes its saved special-cup fixtures: " + error).c_str());
}
}
if (const char* replay_dir = std::getenv("BMH_REPLAY_STRESS_DIR")) {
// Four ordinary advances from WEEK196 lead to the recorded replay at day 271.
// The test saves that live state and exercises the public CareerSession loader.
const auto week196 = std::filesystem::path(replay_dir) / "WEEK196.FBM";
app::CareerSession path_to_replay(data, 0x77112233, week196);
for (int event = 0; event < 4; ++event) {
const int slot = int(path_to_replay.state().memory.u8(::bmh::layout::ActiveManager));
uint64_t rev = uint64_t(event + 1);
const auto advanced = path_to_replay.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, rev}, rev, error);
check(advanced.kind != TurnDeskKind::Failed,
(std::string("WEEK196 replay path advance: ") + error).c_str());
}
const GameState& at_replay = path_to_replay.state();
check(at_replay.season_day() == 271 && at_replay.memory.u32(::bmh::layout::SavedCompetition) == 0x4000 &&
at_replay.memory.u8(cup_entry_address(22) + 0x1a) == 2,
"four advances from WEEK196 reach the saved postponed replay day");
const auto replay_dir_temp = temp.path / "replay-resume";
std::filesystem::create_directories(replay_dir_temp);
const auto replay_save = replay_dir_temp / "REPLAY.FBM";
const int slot = int(at_replay.memory.u8(::bmh::layout::ActiveManager));
check(path_to_replay.save_game(replay_save, slot, true, error),
"replay-day state saves before continuation");
const Bytes source_stream = load_savegame(replay_save).stream;
app::CareerSession replay_loaded(data, 0x77112234, replay_save);
const GameState& rebound = replay_loaded.state();
check(replay_loaded.rand().calls() == 0 && replay_loaded.game().calls() == 0 &&
replay_loaded.game().seed() == (rebound.memory.has(::bmh::layout::CareerSession_Save_RuntimeField)
? int32_t(rebound.memory.u32(::bmh::layout::CareerSession_Save_RuntimeField)) : 0) &&
rebound.memory.has(::bmh::layout::ReplayFixtures) &&
rebound.memory.has(::bmh::layout::ReplayResults) && save_stream(rebound) == source_stream,
"replay load rebuilds only transient buffers, preserving save bytes and load RNG");
const int postponed_slot = [&] {
for (int i = 0; i < 0x28; ++i)
if (rebound.memory.u16(::bmh::layout::Postponed + uint32_t(i) * 6) == 271) return i;
return -1;
}();
check(postponed_slot >= 0, "replay save retains its current six-byte record");
const int league = rebound.memory.u8(::bmh::layout::Postponed + uint32_t(postponed_slot) * 6 + 3);
const int round = rebound.memory.u8(::bmh::layout::Postponed + uint32_t(postponed_slot) * 6 + 2);
const int match = rebound.memory.u8(::bmh::layout::Postponed + uint32_t(postponed_slot) * 6 + 4);
const size_t result_at = size_t(league) * 0x17c + size_t(round) * 10 + size_t(match);
const auto scheduled = generate_fixtures(league_system().sizes[league], round + 1,
league_matchdays(league) / 2, league_first_team(league));
const std::vector<int> expected_replay{
scheduled.at(size_t(match)).home, scheduled.at(size_t(match)).away};
uint64_t replay_revision = 1;
const auto replayed = replay_loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, replay_revision},
replay_revision, error);
check(replayed.kind != TurnDeskKind::Failed && replay_loaded.last_turn_results().valid &&
replay_loaded.last_turn_results().groups.size() == 1 &&
replay_loaded.last_turn_results().groups[0].fixtures == expected_replay &&
replay_loaded.last_turn_results().groups[0].cup_results.size() == 1 &&
replay_loaded.state().memory.u16(::bmh::layout::Postponed + uint32_t(postponed_slot) * 6) == 0 &&
replay_loaded.state().results.at(result_at) != 0xcd,
(std::string("loaded postponed replay completes and is stored once: ") + error).c_str());
// A malformed match index must fail during cursor binding, before transient
// list allocation or any saved-state/RNG mutation at the next desk ACK.
app::CareerSession bad_source(data, 0x77112235, replay_save);
bad_source.state().memory.set8(::bmh::layout::Postponed + uint32_t(postponed_slot) * 6 + 4, 0xff);
const auto bad_path = replay_dir_temp / "REPLAY-BAD-RECORD.FBM";
check(bad_source.save_game(bad_path, slot, true, error),
"malformed replay fixture save is written from the valid replay save");
app::CareerSession bad_replay(data, 0x77112236, bad_path);
const Bytes before = save_stream(bad_replay.state());
const uint32_t game_seed = uint32_t(bad_replay.game().seed());
const uint64_t game_calls = bad_replay.game().calls();
const uint32_t rand_seed = bad_replay.rand().seed();
const uint64_t rand_calls = bad_replay.rand().calls();
uint64_t bad_revision = 1;
const auto rejected = bad_replay.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, bad_revision},
bad_revision, error);
check(rejected.kind == TurnDeskKind::Failed &&
error == "Der Pokalspieltag kann mit den gespeicherten Paarungen nicht sicher fortgesetzt werden." &&
!bad_replay.state().memory.has(::bmh::layout::ReplayFixtures) && !bad_replay.state().memory.has(::bmh::layout::ReplayResults) &&
save_stream(bad_replay.state()) == before &&
uint32_t(bad_replay.game().seed()) == game_seed && bad_replay.game().calls() == game_calls &&
bad_replay.rand().seed() == rand_seed && bad_replay.rand().calls() == rand_calls,
"invalid replay record is rejected without save-state, transient-buffer, or RNG effects");
}
if (const char* anchors_dir = std::getenv("BMH_REPLAY_ANCHORS_DIR")) {
for (const char* name : {"event-004.FBM", "event-005.FBM"}) {
const auto anchor = std::filesystem::path(anchors_dir) / name;
app::CareerSession loaded(data, 0x77112237, anchor);
const GameState& before = loaded.state();
const int slot = int(before.memory.u8(::bmh::layout::ActiveManager));
const int day = before.season_day();
check(loaded.rand().calls() == 0 &&
save_stream(before) == load_savegame(anchor).stream,
"recorded replay anchor binds without save-byte or load-RNG changes");
uint64_t rev = 1;
const auto resumed = loaded.dispatch_kickoff(
DeskRequest{DeskRequestKind::advance_turn, slot, -1, -1, -1, rev}, rev, error);
bool cleared_today = true;
for (int i = 0; i < 0x28; ++i) {
const uint32_t at = ::bmh::layout::Postponed + uint32_t(i) * 6;
if (loaded.state().memory.u16(at) == day) cleared_today = false;
}
check(resumed.kind != TurnDeskKind::Failed && loaded.last_turn_results().valid &&
loaded.last_turn_results().groups.size() == 1 &&
loaded.last_turn_results().groups[0].cup_results.size() == 1 && cleared_today,
(std::string(name) + " replays and stores its current postponement once: " + error).c_str());
}
}
test_loaded_manager_forfeit(data, temp.path);
{
const auto many_saves = temp.path / "many-saves";
std::filesystem::create_directories(many_saves);
for (int i = 0; i < 16; ++i) {
char name[16];
std::snprintf(name, sizeof(name), "SAVE%02d.FBM", i);
std::ofstream(many_saves / name, std::ios::binary).put('x');
}
const auto outside_save = temp.path / "OUTSIDE.FBM";
std::ofstream(outside_save, std::ios::binary).put('x');
const auto symlink_path = many_saves / "ESCAPE.FBM";
std::error_code symlink_error;
std::filesystem::create_symlink(outside_save, symlink_path, symlink_error);
if (symlink_error && !expected_symlink_unavailable(symlink_error)) {
throw std::filesystem::filesystem_error(
"create symlink for save selector test", outside_save, symlink_path, symlink_error);
}
SaveLoadScreen browser(data, many_saves, SaveLoadMode::load, 0, revision, flow.desktop()->render());
check(browser.entries().size() == 16 && browser.state_json().find("\"scroll\":0") != std::string::npos,
"Original save selector retains all sixteen saves and begins at its first fifteen-row page");
if (!symlink_error) {
check(browser.entries().size() == 16,
"Original save selector excludes symlinks");
} else {
std::fprintf(stderr,
"SKIP: save selector symlink exclusion subcase (symlinks unavailable: %s)\n",
symlink_error.message().c_str());
}
(void)browser.render();
check(browser.click(210, 188) && browser.state_json().find("\"scroll\":15") != std::string::npos,
"Original Seite button advances to the next fifteen-row page");
check(browser.click(210, 188) && browser.state_json().find("\"scroll\":0") != std::string::npos,
"Original Seite button cycles back to the first page");
}
{
const auto utf8 = [](const std::u8string& value) {
return std::string(value.begin(), value.end());
};
const auto modern_dir = temp.path / std::filesystem::path(u8"Gr\u00fc\u00dfe \u4fdd\u5b58 Saison");
std::filesystem::create_directory(modern_dir);
const auto original_native = save_stream(session.state());
const auto w_seed = session.rand().seed();
const auto g_seed = session.game().seed();
const auto w_calls = session.rand().calls(), g_calls = session.game().calls();
SaveLoadScreen modern(data, modern_dir, SaveLoadMode::save, 0, revision, flow.desktop()->render());
check(modern.click(150, 214) && modern.text("Mein HSV Saison 2026"),
"modern save names accept spaces, mixed case and more than eight characters");
check(!modern.text("/outside") && !modern.text("\\outside"),
"modern file input stays a single directory-confined filename");
check(modern.key("ENTER") && modern.pending() &&
modern.pending()->path.filename() == "Mein HSV Saison 2026.FBM",
"modern save request preserves the exact entered case");
SaveLoadScreen unicode(data, modern_dir, SaveLoadMode::save, 0, revision, flow.desktop()->render());
check(unicode.click(150, 214) && unicode.text(utf8(u8"K\u00f6ln \u4fdd\u5b58 \u00e4")) &&
unicode.key("BACKSPACE") && unicode.key("ENTER") && unicode.pending() &&
unicode.pending()->path == modern_dir / std::filesystem::path(u8"K\u00f6ln \u4fdd\u5b58 .FBM"),
"SDL UTF-8 text and Backspace preserve the exact Unicode save path");
check(unicode.state_json().find("\"directory\":" + json_quote(utf8(modern_dir.u8string()))) != std::string::npos &&
save_load_request_json(*unicode.pending()).find("\"path\":" +
json_quote(utf8(unicode.pending()->path.u8string()))) != std::string::npos,
"save dialog state and pending save JSON preserve UTF-8 paths");
(void)unicode.render();
const auto existing = modern_dir / std::filesystem::path(u8"MiXeD K\u00f6ln \u4fdd\u5b58.fBm");
auto rng_copy = session.rand();
write_savegame(existing, make_savegame(session.state(), rng_copy));
SaveLoadScreen overwrite(data, modern_dir, SaveLoadMode::save, 0, revision, flow.desktop()->render());
check(overwrite.state_json().find("\"filename\":" +
json_quote(utf8(existing.stem().u8string()))) != std::string::npos &&
overwrite.click(70, 45) && overwrite.key("ENTER") && !overwrite.pending() && overwrite.key("ENTER") &&
overwrite.pending() && overwrite.pending()->overwrite && overwrite.pending()->path == existing,
"selected Unicode filename with mixed-case extension overwrites that exact path");
SaveLoadScreen info(data, modern_dir, SaveLoadMode::load, 0, revision, flow.desktop()->render());
check(info.entries().size() == 1 && info.entries().front().path == existing &&
info.click(70, 45) && info.selected() == 0 &&
info.state_json().find("\"directory\":" + json_quote(utf8(modern_dir.u8string()))) != std::string::npos &&
info.state_json().find("\"entries\":[" + json_quote(utf8(existing.filename().u8string())) + "]") != std::string::npos,
"load dialog selects a real Unicode FBM and reports UTF-8 directory and entry JSON");
const auto list = info.render();
check(info.info_press(70, 45) && info.info_open() && !info.pending(),
"right DOWN opens Original native save information without a load request");
const auto popup = info.render();
check(popup.pixels[128 * 320 + 264] == 0x40 && popup.pixels != list.pixels,
"Original information well includes its two-pixel Source shadow");
check(!info.key("ENTER") && !info.text("IGNORED") && info.info_open(),
"keyboard and filename input cannot act while Source information waits for mouse release");
check(info.click(70, 45, true) && !info.info_open() && !info.pending() && info.render().pixels == list.pixels,
"mouse release restores the exact file browser and never starts a load");
check(info.key("ENTER") && info.pending() && info.pending()->action == SaveLoadAction::load &&
info.pending()->path == existing && save_load_request_json(*info.pending()).find("\"path\":" +
json_quote(utf8(existing.u8string()))) != std::string::npos,
"normal selected-file load request and JSON retain the exact Unicode path");
check(save_stream(session.state()) == original_native && session.rand().seed() == w_seed &&
session.rand().calls() == w_calls && session.game().seed() == g_seed && session.game().calls() == g_calls,
"information, hover and filename interactions leave full native state and both RNGs unchanged");
}
std::puts("bank app: account, investments, stadium, Toto, kickoff and temporary save/load flows OK");
} catch (const std::exception& e) { std::fprintf(stderr, "FAIL: %s\n", e.what()); return 1; }
return 0;
}