#include "runtime_fixture_tables.hpp" // SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "test_inputs.hpp" #include #include #include #include #include #include #include #include #include #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(expired.submenu_action), "deadline emits a changed coupon through the ordinary typed action"); const auto request=std::get(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& 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& 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::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 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 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::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(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(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 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{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 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 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(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 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=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(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(submitted.submenu_action), "deposit emits typed request"); const auto request = std::get(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(buy.submenu_action).kind == BankRequestKind::buy_shares, "stock purchase is an explicit request"); check(session.dispatch_bank(std::get(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(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(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(fund_buy.submenu_action).kind == BankRequestKind::buy_fund, "fund purchase is an explicit request"); check(session.dispatch_bank(std::get(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(fund_sell.submenu_action).kind == BankRequestKind::sell_fund, "fund sale is an explicit request"); check(session.dispatch_bank(std::get(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(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(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(event.submenu_action), "stadium dispatch has an owned typed request"); check(session.dispatch_stadium(std::get(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(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(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(decline.submenu_action).kind == StadiumRequestKind::decline_periphery, "NEIN emits a drawless offer-resolution request"); check(session.dispatch_stadium(std::get(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(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(build.submenu_action).kind == StadiumRequestKind::build_periphery, "JA emits construction request"); check(session.dispatch_stadium(std::get(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(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(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(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(toto_submit.submenu_action), "Tipp abgeben emits typed request"); const auto toto_request = std::get(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(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(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 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 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{"event-089.FBM", 11}, std::pair{"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(kLeagueSizes[league], round + 1, league_matchdays(league) / 2, league_first_team(league)); const std::vector 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; }