// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include #include #include #include #include #include "formats/fbm.hpp" #include "formats/savestate.hpp" #include "formats/textd.hpp" #include "game/desk_actions.hpp" #include "game/matchday.hpp" #include "game/messages.hpp" #include "game/month.hpp" #include "game/national.hpp" #include "game/pending_offer.hpp" #include "game/prediction.hpp" #include "game/save.hpp" #include "game/season.hpp" // Private QA composition of format field -> IncomingTransferScreen/ProjectTransferOfferList -> Void2 -> // SettleHumanBuyerSale -> PendingOfferAnswer -> 42707. No production pending adapter is called. // Contract: ordinary two-human-club/count24 SALE, validated Native control, // explicit EXE gate and scripted answers. Caller supplies independent copies // of input/state/W/G and compares complete snapshots, not just selected fields. // This shares only previously reviewed small primitives. It is not an Original // runtime oracle for those primitives or the renderer/input loop. #include #include #include #include #include #include #include #include #include #include "game/lineup.hpp" #include "game/matchday.hpp" #include "game/messages.hpp" #include "game/month.hpp" #include "game/national.hpp" #include "game/prediction.hpp" #include "game/save.hpp" #include "game/schedule.hpp" namespace human_buyer_source_oracle { using namespace bmh; constexpr uint32_t offers = ::bmh::layout::OfferSlots, list_first = ::bmh::layout::EditorList; constexpr size_t pool = 0xb70, record_size = 0xb0c, board_size = 0x840, row_size = 0x58; enum class Gate { unset, zero, blocked }; enum class Reply { unset, yes, no }; enum class Choice { unset, bid0, decline }; struct Script { int clicked_manager = 0; int clicked_row = 0; Gate gate = Gate::unset; // MUST be selected from actual EXE observation by test caller. std::array salary{}; std::array severance{}; std::array choice{}; }; struct Snapshot { std::string point; int raw = -1, manager = -1; uint32_t text_address = 0; uint16_t question_flags = 0; uint8_t manager_flags = 0; std::string text; Bytes native; uint32_t w_seed = 0; int32_t g_seed = 0; uint64_t w_calls = 0, g_calls = 0; uint8_t active = 0; int bdb7e = -1, bdb8c = -1, bdb93 = -1; // -1 means absent, never inferred zero. }; struct Result { int processed = 0, moved = 0, salary_accepted = 0; int funds_refused = 0, allocator_blocked = 0, no_room = 0; bool sticky_salary_no = false; std::vector snapshots; }; inline void require(bool ok, const char* why) { if (!ok) throw std::runtime_error(std::string("Source human-buyer oracle: ") + why); } inline uint32_t read32(const std::vector& bytes, size_t at) { uint32_t v = 0; for (size_t k = 0; k < 4; ++k) v |= uint32_t(bytes.at(at + k)) << (k * 8); return v; } inline void write32(std::vector& bytes, size_t at, uint32_t v) { for (size_t k = 0; k < 4; ++k) bytes.at(at + k) = uint8_t(v >> (k * 8)); } inline void optional_byte(GameState& g, uint32_t at, uint8_t value) { if (g.memory.has(at)) g.memory.set8(at, value); } inline size_t find_player(const GameState& g, int team, int player) { const auto range = squad_range(team); for (size_t at = range.first; at < range.first + range.count; ++at) if ((g.squad_slots.at(at) & 0xfff) == player) return at; throw std::runtime_error("Source human-buyer oracle: missing seller player/error32"); } inline void snapshot(Result& result, const GameState& g, const GameRandom& game, const WatcomRandom& rand, std::string point, int raw = -1, int manager = -1, uint32_t address = 0, std::string text = {}, uint16_t flags = 0, uint8_t manager_flags = 0) { Snapshot out; out.point = std::move(point); out.raw = raw; out.manager = manager; out.text_address = address; out.text = std::move(text); out.question_flags = flags; out.manager_flags = manager_flags; out.w_seed = rand.seed(); out.g_seed = game.seed(); out.w_calls = rand.calls(); out.g_calls = game.calls(); out.active = g.memory.u8(::bmh::layout::ActiveManager); const auto transient = [&](uint32_t at) { return g.memory.has(at) ? int(g.memory.u8(at)) : -1; }; out.bdb7e = transient(::bmh::layout::FinanceStatisticsEnabled); out.bdb8c = transient(::bmh::layout::DeskActions_EditorFail_RuntimeField2); out.bdb93 = transient(::bmh::layout::Weekly_PendingSettleHumanBuyer_RuntimeField); out.native = save_stream(g); // no make_savegame, therefore no encryption W draws. require(rand.seed() == out.w_seed && rand.calls() == out.w_calls && game.seed() == out.g_seed && game.calls() == out.g_calls, "snapshot consumed RNG"); result.snapshots.push_back(std::move(out)); } inline void notice(Result& result, const GameState& g, const GameRandom& game, const WatcomRandom& rand, int raw, int manager, uint32_t at, bool timed, std::string composed = {}) { snapshot(result, g, game, rand, timed ? "timed_notice" : "ack", raw, manager, at, composed.empty() ? message_text(g, at) : std::move(composed), 0, uint8_t(manager) | uint8_t(timed ? 0x40 : 0x80)); } inline void history(GameState& g, int manager, int other, int player, uint32_t fee, bool buyer) { const size_t base = size_t(manager) * record_size; // format field shifts exactly 0x74 bytes: 29 old entries into rows1..29. for (size_t n = 29; n > 0; --n) { write32(g.manager_records, base + 0x760 + n * 4, read32(g.manager_records, base + 0x760 + (n - 1) * 4)); write32(g.manager_records, base + 0x7d8 + n * 4, read32(g.manager_records, base + 0x7d8 + (n - 1) * 4)); } write32(g.manager_records, base + 0x760, g.date * 4u + uint32_t(buyer) + (fee / 10000u) * 0x80000u); write32(g.manager_records, base + 0x7d8, uint32_t(g.player_name_offsets.at(size_t(player))) + uint32_t(g.club_ids.at(size_t(other))) * 0x10000u); auto& count = g.manager_records.at(base + 0x21d); if (count < 25) ++count; } inline void remove_seller(GameState& g, int seller, int manager, int player) { // Independent composition of ReleasePlayer, not production remove_from_seller. const auto range = squad_range(seller); const size_t found = find_player(g, seller, player); for (size_t at = pool; at < 0xb9c; ++at) if ((g.squad_slots.at(at) & 0xfff) == player) g.squad_slots.at(at) = 0xfff; for (size_t at = found; at + 1 < range.first + range.count; ++at) g.squad_slots.at(at) = g.squad_slots.at(at + 1); g.squad_slots.at(range.first + range.count - 1) = 0xfff; const size_t row = found - range.first; if (row != 23) { const size_t start = size_t(manager) * board_size + row * row_size; std::memmove(g.tactics.data() + start, g.tactics.data() + start + row_size, (23 - row) * row_size); } // ReleasePlayer embedded call; 42707 calls seller again afterwards. auto_lineup(g, seller, 100); } inline uint32_t interested(const GameState& g, int seller, int buyer) { // format field, with real Native option bytes required rather than defaulted. if (g.memory.u8(::bmh::layout::Weekly_InterestedManagers_RuntimeField) != 0) return 0; uint32_t mask = 0; for (size_t m = 0; m < g.manager_teams.size(); ++m) { const int league = g.manager_records.at(m * record_size + 0x210); if (team_league(seller) != league && team_league(buyer) != league) continue; const int own = int8_t(table_position(g, g.manager_teams.at(m))); if (std::abs(own - int16_t(table_position(g, seller))) <= 5 || std::abs(own - int16_t(table_position(g, buyer))) <= 5) mask |= 1u << m; } return mask; } inline uint32_t stack_board_bonus(GameState& g, int buyer_manager, int player, uint32_t salary, uint32_t list) { // ProjectTransferOfferList's local board has +50 salary and +12 seven bidder bonuses. The // reviewed primitive indexes GameState boards, so temporarily lend row0, // restore that row exactly, and KEEP any native table-prediction side effects. const size_t at = size_t(buyer_manager) * board_size; std::array previous{}; std::copy_n(g.tactics.begin() + std::ptrdiff_t(at), row_size, previous.begin()); struct Restore { GameState& g; size_t at; const std::array& previous; ~Restore() { std::copy(previous.begin(), previous.end(), g.tactics.begin() + std::ptrdiff_t(at)); } } restore{g, at, previous}; std::fill_n(g.tactics.begin() + std::ptrdiff_t(at), row_size, uint8_t(0)); write32(g.tactics, at + 0x50, salary); for (size_t n = 0; n < 7; ++n) g.tactics.at(at + 0x12 + n) = g.memory.u8(list + 0x38 + uint32_t(n)); return expected_bonus(g, buyer_manager, 0xff, 0, player, true); } inline Result run(GameState& g, GameRandom& game, WatcomRandom& rand, const Script& script) { require(script.gate != Gate::unset, "actual EXE allocator gate must be supplied"); require(g.manager_teams.size() == 2 && script.clicked_manager >= 0 && script.clicked_manager < 2, "requires genuine two-manager ordinary control"); require(g.memory.u8(::bmh::layout::ActiveManager) == script.clicked_manager, "clicked manager must be active"); for (int team : g.manager_teams) require(team >= 0 && team < 90 && squad_range(team).count == 24, "only ordinary24-slot human clubs are supported"); require(script.clicked_row >= 0 && script.clicked_row < 24 && g.texts, "fixed clicked board/texts"); const size_t clicked_slot = squad_range(g.manager_teams.at(size_t(script.clicked_manager))).first + size_t(script.clicked_row); const size_t clicked_board = size_t(script.clicked_manager) * board_size + size_t(script.clicked_row) * row_size; Result result; snapshot(result, g, game, rand, "entry"); for (int raw = 0; raw < 4; ++raw) { const uint32_t offer_at = offers + uint32_t(raw) * 4; const uint32_t word = g.memory.u32(offer_at); const int owner = g.memory.u8(::bmh::layout::ActiveManager); if (word == 0xffffffffu || int(word & 31) != owner) continue; const int player = int((word >> 10) & 0xfff); const int seller = g.manager_teams.at(size_t(owner)); const uint32_t list = list_first + uint32_t(raw + 40) * row_size; const size_t seller_slot = find_player(g, seller, player); const size_t seller_board = size_t(owner) * board_size + (seller_slot - squad_range(seller).first) * row_size; const int buyer = int16_t(g.memory.u16(list)); const int buyer_manager = g.manager_of(buyer); require(buyer_manager >= 0 && buyer_manager < 2 && buyer_manager != owner && buyer != seller, "distinct human buyer"); require(g.memory.u16(list + 2) == 0xffff && g.memory.u16(list + 4) == 0xffff && g.memory.u16(list + 6) == 0xffff && (g.memory.u16(list + 8) & 0x7fff) == seller, "one genuine control bid and matching seller"); const uint8_t term = g.memory.u8(list + 0x34); require(term <= 127, "loans excluded"); for (uint32_t n = 0; n < 200; ++n) { const uint32_t loan = g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + n * 4); require(loan == 0 || int(loan & 0xfff) != player, "error30 boundary excluded"); } bool negotiate = true; if (word & 0x80000000u) { require(script.salary[size_t(raw)] != Reply::unset, "salary answer must be scripted"); const uint32_t demanded = g.memory.u32(list + 0x0c); const auto name = g.player_name(g.squad_slots.at(clicked_slot) & 0xfff); snapshot(result, g, game, rand, "salary_question", raw, owner, ::bmh::layout::Weekly_ProcessPendingBatch_TextPointer, name + message_text(g, ::bmh::layout::Weekly_ProcessPendingBatch_TextPointer) + format_amount(g, int32_t(demanded)) + message_text(g, ::bmh::layout::Weekly_ProcessPendingBatch_TextPointer2), 1, uint8_t(owner)); if (script.salary[size_t(raw)] == Reply::yes) { if (!(word & 0x20u)) { uint32_t fee = 0, reference = 0; market_value(g, int(clicked_slot), 0, 98, fee, reference, (int(g.tactics.at(clicked_board + 0x0c)) + 6) / 12, 0, rand); require(reference != 0, "salary-JA divide-by-zero excluded"); write32(g.tactics, clicked_board + 0x50, demanded); g.tactics.at(clicked_board + 0x0d) = uint8_t((demanded * 100u) / reference); } ++result.salary_accepted; negotiate = false; } else result.sticky_salary_no = true; } bool settle = negotiate; if (negotiate && !result.sticky_salary_no) { require(script.choice[size_t(raw)] != Choice::unset, "normal bid answer must be scripted"); // OpenTransferEditor redraw: reset G to CareerSession_Invalid_RuntimeField2, ONE G92..108, optional market W. const int previous_suppression = g.memory.has(::bmh::layout::DeskActions_EditorFail_RuntimeField2) ? int(g.memory.u8(::bmh::layout::DeskActions_EditorFail_RuntimeField2)) : -1; optional_byte(g, ::bmh::layout::DeskActions_EditorFail_RuntimeField2, 0); game.set_seed(int32_t(g.memory.u32(::bmh::layout::CareerSession_Invalid_RuntimeField2))); const int percent = game.range(92, 108); uint32_t quote_fee = 0, quote_salary = 0; const int years = (int(g.tactics.at(seller_board + 0x0c)) - 1) / 12 + 1; market_value(g, int(pool + size_t(raw + 40)), 0, percent, quote_fee, quote_salary, years, 0, rand); quote_fee = ((quote_fee + (quote_fee >> 2)) / 10000u) * 10000u; quote_salary = (quote_salary / 100u) * 100u; (void)quote_fee; (void)quote_salary; g.memory.set32(list + 0x10, 0); g.memory.set32(list + 0x20, 0); g.memory.set8(list + 0x35, 24); if (previous_suppression >= 0) optional_byte(g, ::bmh::layout::DeskActions_EditorFail_RuntimeField2, uint8_t(previous_suppression)); snapshot(result, g, game, rand, "chooser", raw, owner); if (script.choice[size_t(raw)] == Choice::decline) { if (previous_suppression <= 0 && !g.transfer_notice_suppressed) notice(result, g, game, rand, raw, owner, ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField, false); settle = false; } else { // IncomingTransferScreen/ProjectTransferOfferList: temporary salary inflation; exact buyer fitness, // predicted season bonus and its Native side effects; W90..100. const uint32_t original_salary = g.memory.u32(list + 0x0c); const uint32_t inflated_salary = (original_salary * 10u) >> 3; g.memory.set32(list + 0x0c, inflated_salary); const uint8_t extra_years = uint8_t((int(term) - 1) / 12); const uint32_t fee_base = (g.memory.u32(list + 0x2c) / 10000u) * 12500u; const uint32_t salary_base = (((uint32_t(extra_years) * 20u + 100u) * g.memory.u32(list + 0x30)) / 10000u) * 100u; require(fee_base != 0 && salary_base != 0, "425ee denominator zero excluded"); uint32_t fee_percent = (g.memory.u32(list + 0x1c) * 100u) / fee_base; const uint32_t bonus = stack_board_bonus(g, buyer_manager, player, inflated_salary, list); uint32_t salary_percent = ((inflated_salary + bonus) * 100u) / salary_base; if (fee_percent < uint32_t(rand.range(90, 100))) fee_percent = 0; if (salary_percent < g.memory.u8(list + 0x55)) salary_percent = 0; (void)fee_percent; // IncomingTransferScreen manual branch tests salary percentage only. g.memory.set32(list + 0x0c, original_salary); snapshot(result, g, game, rand, "selected_bid_evaluated", raw, owner); if (salary_percent == 0) { notice(result, g, game, rand, raw, owner, ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField3, true); g.memory.set16(list, 0xffff); settle = false; } } } uint32_t severance = 0; if (settle) { // Void2 human seller always draws this W, even without a question. const uint32_t months = g.tactics.at(seller_board + 0x0c); const uint32_t old_total = read32(g.tactics, seller_board + 0x50) * months; const uint32_t new_total = g.memory.u32(list + 0x0c) * months; const uint32_t threshold = old_total * uint32_t(rand.range(90, 100)); if (threshold >= new_total * 100u && threshold - new_total * 100u != 0) { severance = ((old_total - new_total) / 1000u) * 1000u; if (severance < 1000) severance = 1000; snapshot(result, g, game, rand, "severance_question", raw, owner, ::bmh::layout::Weekly_PendingSettle_TextPointer, message_text(g, ::bmh::layout::Weekly_PendingSettle_TextPointer) + format_amount(g, int32_t(severance)) + ".", 0x305, uint8_t(owner)); require(script.severance[size_t(raw)] != Reply::unset, "severance answer must be scripted"); if (script.severance[size_t(raw)] == Reply::no) { g.memory.set8(::bmh::layout::ActiveManager, uint8_t(owner)); notice(result, g, game, rand, raw, owner, ::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField4, true); settle = false; } } } if (settle) { const uint32_t raw_fee = g.memory.u32(list + 0x1c); uint32_t adjusted_fee = raw_fee; const size_t buyer_record = size_t(buyer_manager) * record_size; const size_t seller_record = size_t(owner) * record_size; const uint8_t subsidy = g.manager_records.at(buyer_record + 0x170); if (raw_fee <= read32(g.manager_records, buyer_record + 0x314) && subsidy != 0 && (subsidy & 3) == (g.players.at(size_t(player)).w364 & 3)) { uint32_t league = g.manager_records.at(buyer_record + 0x210); if (league > 2) --league; const uint32_t limit = (((uint32_t(subsidy) >> 2) & 7u) * 50000u + 150000u) * (4u - league); if (raw_fee < limit) { const uint32_t discount = (((uint32_t(subsidy) >> 5) + 3u) * raw_fee * 10u) / 100u; notice(result, g, game, rand, raw, buyer_manager, ::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer, false, message_text(g, ::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer) + format_amount(g, int32_t(discount)) + message_text(g, ::bmh::layout::Weekly_Fail_TextPointer) + format_amount(g, int32_t(raw_fee)) + ")."); adjusted_fee -= discount; } else notice(result, g, game, rand, raw, buyer_manager, ::bmh::layout::PendingOffer_FormatError_ExecutableField3, false); g.manager_records.at(buyer_record + 0x170) = 0; } optional_byte(g, ::bmh::layout::FinanceStatisticsEnabled, 1); const uint8_t active_before = g.memory.u8(::bmh::layout::ActiveManager); if (!book_money(g, buyer_manager, int32_t(adjusted_fee), false, true)) { g.memory.set8(::bmh::layout::ActiveManager, uint8_t(buyer_manager)); notice(result, g, game, rand, raw, buyer_manager, ::bmh::layout::Advertising_FormatError_TextPointer18, true); optional_byte(g, ::bmh::layout::FinanceStatisticsEnabled, 0); g.memory.set8(::bmh::layout::ActiveManager, active_before); ++result.funds_refused; settle = false; } else { if (g.level != 0) optional_byte(g, ::bmh::layout::FinanceStatisticsEnabled, 0); write32(g.manager_records, buyer_record + 0x330, read32(g.manager_records, buyer_record + 0x330) + adjusted_fee); optional_byte(g, ::bmh::layout::FinanceStatisticsEnabled, 1); book_money(g, owner, int32_t(0u - adjusted_fee), true, true); if (g.level != 0) optional_byte(g, ::bmh::layout::FinanceStatisticsEnabled, 0); write32(g.manager_records, seller_record + 0x330, read32(g.manager_records, seller_record + 0x330) - adjusted_fee); if (severance != 0) { optional_byte(g, ::bmh::layout::FinanceStatisticsEnabled, 1); book_money(g, owner, int32_t(severance), true, true); if (g.level != 0) optional_byte(g, ::bmh::layout::FinanceStatisticsEnabled, 0); } if (!result.sticky_salary_no) notice(result, g, game, rand, raw, buyer_manager, ::bmh::layout::PendingOffer_FormatError_ExecutableField2, false); g.transfer_notice_suppressed = false; optional_byte(g, ::bmh::layout::DeskActions_EditorFail_RuntimeField2, 0); uint32_t mask = 0x80000000u | (1u << owner) | (1u << buyer_manager); if (g.memory.u8(::bmh::layout::Weekly_ExecuteTransfer_RuntimeField) == 0) mask = 0xffffffffu; mask |= interested(g, seller, buyer); if (mask != 0x80000000u) post_composed(g, int64_t(mask), message_text(g, ::bmh::layout::Month_SearchProfileNews_TextPointer) + g.player_name(player) + message_text(g, ::bmh::layout::Weekly_ExecuteTransfer_TextPointer) + g.club_name(seller) + message_text(g, ::bmh::layout::Weekly_ExecuteTransfer_TextPointer2) + format_amount(g, int32_t(raw_fee)) + message_text(g, ::bmh::layout::ClubPlayerDetail_RenderCard_TextPointer7) + g.club_name(buyer) + message_text(g, ::bmh::layout::Weekly_ExecuteTransfer_TextPointer4)); snapshot(result, g, game, rand, "accounting_and_news_complete", raw, owner); if (script.gate == Gate::blocked) { ++result.allocator_blocked; } else { const auto buyer_range = squad_range(buyer); size_t destination = buyer_range.first; // PendingOfferAnswer unconditionally scans 24 FULL words; scope validated above. while (destination < buyer_range.first + 24 && g.squad_slots.at(destination) != 0x0fff) ++destination; if (destination == buyer_range.first + 24) { notice(result, g, game, rand, raw, int(g.memory.u8(::bmh::layout::ActiveManager)), ::bmh::layout::PendingOffer_FormatError_ExecutableField, true); ++result.no_room; } else { const size_t dest_row = destination - buyer_range.first; const size_t dest_board = size_t(buyer_manager) * board_size + dest_row * row_size; g.squad_slots.at(destination) = g.squad_slots.at(pool + size_t(raw + 40)); // Exact initializer draws remain observable despite copy-over. new_board_entry(g, buyer_manager, int(dest_row), int(destination), rand); snapshot(result, g, game, rand, "allocator_initialized", raw, buyer_manager); std::copy_n(g.tactics.begin() + std::ptrdiff_t(seller_board), row_size, g.tactics.begin() + std::ptrdiff_t(dest_board)); const uint32_t salary = g.memory.u32(list + 0x0c); write32(g.tactics, dest_board + 0x50, salary); uint32_t reference_fee = 0, reference_salary = 0; market_value(g, int(pool + size_t(raw + 40)), 0, 100, reference_fee, reference_salary, term & 127, 0, rand); require(reference_salary != 0, "42707 divide-by-zero excluded"); for (size_t n = 0; n < 7; ++n) g.tactics.at(dest_board + 0x12 + n) = g.memory.u8(list + 0x38 + uint32_t(n)); const uint32_t bonus = expected_bonus(g, buyer_manager, 0xff, int(dest_row), player, true); // EXE VA4292c..42949: signed bonus IDIV, unsigned final DIV. const int32_t bonus_part = int32_t(bonus * 80u) / 100; const uint32_t numerator = (salary + uint32_t(bonus_part)) * 100u; const uint32_t quotient = numerator / reference_salary; g.tactics.at(dest_board + 0x0d) = uint8_t(std::clamp(int32_t(quotient), 0, 255)); write32(g.tactics, dest_board + 0x54, raw_fee); g.tactics.at(dest_board + 0x0c) = term; history(g, owner, buyer, player, raw_fee, false); history(g, buyer_manager, seller, player, raw_fee, true); remove_seller(g, seller, owner, player); auto_lineup(g, seller, 100); auto_lineup(g, buyer, 100); ++result.moved; } } optional_byte(g, ::bmh::layout::Weekly_PendingSettleHumanBuyer_RuntimeField, 1); } } // DispatchClubPlayerPendingOffers consumes owned row/pool for every expected outcome; list bytes stay. g.squad_slots.at(pool + size_t(raw + 40)) = 0x0fff; g.memory.set32(offer_at, 0xffffffffu); ++result.processed; snapshot(result, g, game, rand, "owned_cleanup", raw, owner); } snapshot(result, g, game, rand, "batch_complete"); return result; } } // namespace human_buyer_source_oracle using namespace bmh; namespace { constexpr uint32_t kOffers=::bmh::layout::OfferSlots, kList=::bmh::layout::EditorList+40*0x58; constexpr size_t kPool=0xb70+40, kRecord=0xb0c, kBoard=0x840, kBoardSlot=0x58; void check(bool v,const char* what){if(!v)throw std::runtime_error(what);} uint32_t read32(const std::vector& b,size_t at){uint32_t v=0;for(int i=0;i<4;++i)v|=uint32_t(b.at(at+size_t(i)))<<(8*i);return v;} void write32(std::vector& b,size_t at,uint32_t v){for(int i=0;i<4;++i)b.at(at+size_t(i))=uint8_t(v>>(i*8));} bool contains(const GameState& g,int team,int player){const auto r=squad_range(team);for(size_t i=r.first;i=0&&c.seller<138&&c.buyer>=0&&c.buyer<138&&c.seller!=c.buyer,"distinct ordinary clubs"); check(g.manager_of(c.seller)==0&&g.manager_of(c.buyer)==1,"fixture manager mapping"); const auto sr=squad_range(c.seller),br=squad_range(c.buyer); check(sr.count==24&&br.count==24,"ordinary 24-slot manager squads"); // Use the actual source-backed listing and bid helpers on the unchanged Native // two-manager input. The special-row copy below is a declared TEST ONLY adapter, // not an Original QA_INPUT offer. WatcomRandom helper_rand(37);MinuteReport helper_report; const auto listing=list_manager_player(g,0,5,helper_rand,helper_report); check(listing.status==TransferActionStatus::accepted&&!helper_report.unsupported&&listing.player>=0, "Source human listing helper creates control seller entry"); c.player=listing.player;c.seller_row=player_row(g,c.seller,c.player); check(c.seller_row>=0,"listed player remains in a concrete seller row"); const uint32_t ordinary=::bmh::layout::EditorList+uint32_t(listing.list_entry)*0x58; const uint32_t fee_base=(g.memory.u32(ordinary+0x2c)/10000)*0x30d4; const uint32_t salary_base=((100u*g.memory.u32(ordinary+0x30))/10000)*100; TransferBidRequest bid;bid.manager=1;bid.list_entry=listing.list_entry;bid.player=listing.player; bid.fee=int32_t(fee_base);bid.annual_salary=int32_t(salary_base*2);bid.contract_years=1; for(size_t i=0;i<7;++i)bid.bonuses[i]=uint32_t(i+3); const auto submitted=submit_transfer_bid(g,bid,helper_rand); check(submitted.status==TransferActionStatus::pending,"Source bid helper forms two-human pending bid"); int raw_bid=-1;for(int i=0;i<4;++i)if(g.memory.u16(ordinary+uint32_t(i)*2)==c.buyer)raw_bid=i; check(raw_bid>=0,"human bidder remains in the real ordinary offer row"); c.fee=g.memory.u32(ordinary+0x1c+uint32_t(raw_bid)*4); c.salary=g.memory.u32(ordinary+0x0c+uint32_t(raw_bid)*4); c.term=g.memory.u8(ordinary+0x34+uint32_t(raw_bid)); constexpr uint32_t special=::bmh::layout::EditorList+40*0x58; for(uint32_t i=0;i<0x58;++i)g.memory.set8(special+i,g.memory.u8(ordinary+i)); for(int i=0;i<4;++i)g.memory.set16(special+uint32_t(i)*2,i==0?uint16_t(c.buyer):0xffff); g.squad_slots.at(kPool)=g.squad_slots.at(0xb70+size_t(listing.list_entry)); g.memory.set32(kOffers,uint32_t(c.player)<<10); // explicit TEST ONLY special-row promotion if(fee!=0){c.fee=fee;g.memory.set32(special+0x1c,fee);} if(salary!=0){c.salary=salary;g.memory.set32(special+0x0c,salary);} if(fee!=0)g.memory.set32(special+0x2c,(fee/12500u)*10000u); g.memory.set32(special+0x30,10000); g.memory.set8(special+0x55,0); const size_t seller_board=size_t(c.seller_row)*kBoardSlot; g.tactics.at(seller_board+0x0c)=24; write32(g.tactics,seller_board+0x50,52300); g.tactics.at(seller_board+0x06)=0x6d; // opaque board byte proves full-row inheritance const int buyer_player=find_player(g,c.buyer);check(buyer_player>=0,"buyer needs one real player for Source fitness average"); c.buyer_row=-1; for(size_t i=0;i=0),"controlled buyer capacity"); for(int i=1;i<4;++i){g.memory.set32(kOffers+uint32_t(i)*4,0xffffffff);g.squad_slots.at(kPool+size_t(i))=0x0fff;} g.memory.set32(kOffers,uint32_t(c.player)<<10 | (salary_question?0x80000000u:0)); g.squad_slots.at(kPool)=g.squad_slots.at(sr.first+size_t(c.seller_row)); g.memory.set8(::bmh::layout::ActiveManager,0); write32(g.manager_records,kRecord+0x314,10000000); write32(g.manager_records,kRecord+0x31c,0); g.manager_records.at(kRecord+0x170)=0; // scenario applies subsidy bits explicitly return c; } PendingOfferHooks hooks_for(PendingOfferAllocatorGate gate,std::vector& notices,bool loan=false){ PendingOfferHooks h;h.human_buyer_allocator_gate=gate; h.answer=[](const GameState&,const PendingOfferQuestion&){return PendingOfferAnswer::no;}; h.select_transfer=[loan](const GameState&,const TransferOfferListView& v){ check(v.valid&&v.offer_count==1&&v.offers[0].present&&v.offers[0].buyer_manager==1&& v.offers[0].loan==loan,"human-buyer bid is projected as one supported source offer"); return PendingOfferTransferChoice{PendingOfferTransferChoiceKind::bid,0}; }; h.notice=[&](const GameState&,const PendingOfferNotice& n){notices.push_back(n.text_address);}; return h; } PendingOfferResult run(GameState& g,const Control& c,PendingOfferHooks& hooks,GameRandom& game, WatcomRandom& rand,MinuteReport& report){ return process_player_card_pending_offers(g,{c.seller,c.player,c.seller_row,c.seller_row,-1},game,rand,hooks,report); } struct ObservedBoundary { std::string point,text;int raw=-1,manager=-1;uint32_t address=0;uint16_t question_flags=0; uint8_t manager_flags=0;Bytes native;uint32_t w_seed=0;int32_t g_seed=0; uint64_t w_calls=0,g_calls=0;uint8_t active=0;int bdb7e=-1,bdb8c=-1,bdb93=-1; }; void observe_boundaries(PendingOfferHooks& h,std::vector& out, GameRandom& game,WatcomRandom& rand){ const auto record=[&](const GameState& g,ObservedBoundary e){ e.native=save_stream(g);e.w_seed=rand.seed();e.g_seed=game.seed();e.w_calls=rand.calls();e.g_calls=game.calls(); e.active=g.memory.u8(::bmh::layout::ActiveManager); e.bdb7e=g.memory.has(::bmh::layout::FinanceStatisticsEnabled)?int(g.memory.u8(::bmh::layout::FinanceStatisticsEnabled)):-1; e.bdb8c=g.memory.has(::bmh::layout::DeskActions_EditorFail_RuntimeField2)?int(g.memory.u8(::bmh::layout::DeskActions_EditorFail_RuntimeField2)):-1; e.bdb93=g.memory.has(::bmh::layout::Weekly_PendingSettleHumanBuyer_RuntimeField)?int(g.memory.u8(::bmh::layout::Weekly_PendingSettleHumanBuyer_RuntimeField)):-1; out.push_back(std::move(e)); }; const auto old_answer=h.answer;h.answer=[record,old_answer](const GameState& g,const PendingOfferQuestion& q){ ObservedBoundary e;e.point=q.kind==PendingOfferQuestionKind::salary_demand?"salary_question":"severance_question"; e.raw=q.raw_offer_slot;e.manager=q.manager;e.address=e.point=="salary_question"?::bmh::layout::Weekly_ProcessPendingBatch_TextPointer : ::bmh::layout::Weekly_PendingSettle_TextPointer; e.question_flags=q.source_flags;e.manager_flags=uint8_t(q.manager);e.text=q.original_message;record(g,std::move(e)); return old_answer?old_answer(g,q):PendingOfferAnswer::unsupported; }; const auto old_notice=h.notice;h.notice=[record,old_notice](const GameState& g,const PendingOfferNotice& n){ ObservedBoundary e;e.point=(n.text_address==::bmh::layout::Advertising_FormatError_TextPointer18||n.text_address==::bmh::layout::PendingOffer_FormatError_ExecutableField||n.text_address==::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField2|| n.text_address==::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField3||n.text_address==::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField4)?"timed_notice":"ack"; e.raw=n.raw_offer_slot;e.manager=n.manager;e.address=n.text_address;e.text=n.original_message; e.manager_flags=uint8_t(n.manager)|uint8_t(e.point=="timed_notice"?0x40:0x80);record(g,std::move(e)); if(old_notice)old_notice(g,n); }; const auto old_choice=h.select_transfer;h.select_transfer=[record,old_choice](const GameState& g,const TransferOfferListView& v){ ObservedBoundary e;e.point="chooser";e.raw=v.list_entry-40;e.manager=v.seller_manager;record(g,std::move(e)); return old_choice?old_choice(g,v):PendingOfferTransferChoice{}; }; } void compare_boundaries(const std::vector& observed, const human_buyer_source_oracle::Result& expected){ std::vector points; for(const auto& s:expected.snapshots)if(s.point=="salary_question"||s.point=="severance_question"|| s.point=="chooser"||s.point=="ack"||s.point=="timed_notice")points.push_back(&s); check(observed.size()==points.size(),"all Original-facing answer/chooser/notice callbacks are observed in order"); for(size_t i=0;i notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices); std::vector observed;observe_boundaries(h,observed,product_game,product_w); MinuteReport report;const auto result=run(product,c,h,product_game,product_w,report); check(!report.unsupported&&result.completed&&result.transferred==oracle.moved&&oracle.moved==1, "independent Source composition and product both complete the human sale"); check(save_stream(product)==save_stream(source),"complete Native state matches independent Source composition"); check(product_game.seed()==source_game.seed()&&product_game.calls()==source_game.calls()&& product_w.seed()==source_w.seed()&&product_w.calls()==source_w.calls(), "both RNG streams match independent Source composition at the normal chooser"); compare_boundaries(observed,oracle); } // Force wrapped salary arithmetic in both legacy routine and legacy routine while taking // the real human-buyer chooser branch. This catches accidental 64-bit // widening or unsigned/signed division changes in the EXE's 32-bit math. { auto source=original;const auto c=make_control(source,0,false,false,2500000,0xf0000000u); auto product=source; human_buyer_source_oracle::Script script;script.clicked_manager=0;script.clicked_row=c.seller_row; script.gate=human_buyer_source_oracle::Gate::zero;script.choice[0]=human_buyer_source_oracle::Choice::bid0; script.severance[0]=human_buyer_source_oracle::Reply::yes; GameRandom source_game(73),product_game(73);WatcomRandom source_w(1),product_w(1); const auto oracle=human_buyer_source_oracle::run(source,source_game,source_w,script); std::vector notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices); h.answer=[](const GameState&,const PendingOfferQuestion&){return PendingOfferAnswer::yes;}; std::vector observed;observe_boundaries(h,observed,product_game,product_w); MinuteReport report;const auto result=run(product,c,h,product_game,product_w,report); check(!report.unsupported&&result.completed&&result.transferred==oracle.moved&&oracle.moved==1, "overflow chooser outcome matches independent Source composition"); check(save_stream(product)==save_stream(source)&&product_game.seed()==source_game.seed()&& product_game.calls()==source_game.calls()&&product_w.seed()==source_w.seed()&& product_w.calls()==source_w.calls(), "wrapped salary chooser and post-move board ratio match full Native/G/W oracle"); compare_boundaries(observed,oracle); } // Successful subsidy settlement uses the adjusted amount for cash/ledger, // while board, transfer history and composed news retain the raw fee. { auto source=original;const auto c=make_control(source,-1,false,true,250000,70000); const size_t buyer_record=kRecord; const uint8_t pos=uint8_t(source.players.at(size_t(c.player)).w364&3); source.manager_records.at(buyer_record+0x170)=uint8_t(0x1c|pos); const uint32_t before_cash=read32(source.manager_records,buyer_record+0x314); auto product=source; human_buyer_source_oracle::Script script;script.clicked_manager=0;script.clicked_row=c.seller_row; script.gate=human_buyer_source_oracle::Gate::zero;script.salary[0]=human_buyer_source_oracle::Reply::no; script.choice[0]=human_buyer_source_oracle::Choice::bid0; GameRandom source_game(73),product_game(73);WatcomRandom source_w(1),product_w(1); const auto oracle=human_buyer_source_oracle::run(source,source_game,source_w,script); std::vector notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices); std::vector observed;observe_boundaries(h,observed,product_game,product_w); MinuteReport report;const auto result=run(product,c,h,product_game,product_w,report); check(!report.unsupported&&result.transferred==1&&oracle.moved==1&& read32(product.manager_records,buyer_record+0x314)==before_cash-175000&& read32(product.manager_records,buyer_record+0x330)==175000, "discounted buyer cash and ledger use exact adjusted fee"); expect_history(product,0,c.buyer,c.player,c.fee,false); expect_history(product,1,c.seller,c.player,c.fee,true); check(save_stream(product)==save_stream(source)&&product_game.seed()==source_game.seed()&& product_game.calls()==source_game.calls()&&product_w.seed()==source_w.seed()&& product_w.calls()==source_w.calls(), "successful subsidy notices and raw/adjusted accounting match independent oracle"); compare_boundaries(observed,oracle); } // Ordinary bid path: explicit control row, buyer success ACK, exact Source // history direction bits/raw fee, seller-board inheritance and only real moves // increment the public transferred counter. { auto g=original;const auto c=make_control(g,0,false,false);const auto seller_before=g; check(seller_before.tactics.at(size_t(c.seller_row)*kBoardSlot+0x06)==0x6d,"seller row marker installed"); const size_t br=size_t(1)*kRecord,sr=0; const int32_t buyer_balance=int32_t(read32(g.manager_records,br+0x314)); std::vector notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices); bool selected=false;h.select_transfer=[&](const GameState&,const TransferOfferListView& v){ selected=true;check(v.offer_count==1&&v.offers[0].buyer==c.buyer&&v.offers[0].fee==c.fee, "real raw bidder/fee reaches the chooser"); return PendingOfferTransferChoice{PendingOfferTransferChoiceKind::bid,0};}; GameRandom game(73);WatcomRandom rand(1);MinuteReport report; const auto r=run(g,c,h,game,rand,report); check(r.completed&&r.processed==1&&r.transferred==1&&r.buyer_funds_refused==0&& r.buyer_no_room==0&&!report.unsupported&&selected,"supported human-to-human sale completes"); check(contains(g,c.buyer,c.player)&&!contains(g,c.seller,c.player),"seller removal and buyer insertion"); const int buyer_row=player_row(g,c.buyer,c.player); check(buyer_row>=0,"transferred player retains a buyer board row after lineup"); check(g.memory.u32(kOffers)==0xffffffffu&&g.squad_slots.at(kPool)==0x0fff,"owned pending word/pool cleanup"); check((read32(g.manager_records,br+0x314)==uint32_t(buyer_balance)-c.fee)||g.level==0, "buyer pays adjusted fee exactly once"); check(read32(g.manager_records,br+0x330)==read32(seller_before.manager_records,br+0x330)+c.fee, "buyer transfer ledger uses adjusted transaction fee"); check(read32(g.manager_records,sr+0x330)==read32(seller_before.manager_records,sr+0x330)-c.fee, "seller transfer ledger receives same amount in Source direction"); check(g.tactics.at(size_t(1)*kBoard+size_t(buyer_row)*kBoardSlot+0x06)==0x6d, "seller 0x58-byte board is inherited before buyer offer fields"); check(read32(g.tactics,size_t(1)*kBoard+size_t(buyer_row)*kBoardSlot+0x50)==c.salary&& read32(g.tactics,size_t(1)*kBoard+size_t(buyer_row)*kBoardSlot+0x54)==c.fee&& g.tactics.at(size_t(1)*kBoard+size_t(buyer_row)*kBoardSlot+0x0c)==c.term, "raw salary/fee and sale term override inherited board fields"); for(int i=0;i<7;++i)check(g.tactics.at(size_t(1)*kBoard+size_t(buyer_row)*kBoardSlot+0x12+size_t(i))==uint8_t(i+3), "all seven raw bidder bonus bytes copied"); expect_history(g,0,c.buyer,c.player,c.fee,false);expect_history(g,1,c.seller,c.player,c.fee,true); check(std::find(notices.begin(),notices.end(),::bmh::layout::PendingOffer_FormatError_ExecutableField2)!=notices.end(),"normal accepted-sale ACK is shown to human buyer"); check(!report.unsupported&&game.calls()>0&&rand.calls()>0,"quote and Source allocator consume their owning RNG streams"); } // Subsidy eligibility/threshold and raw-vs-adjusted fields. Buyer has enough // cash for the raw fee but a negative credit makes the discounted fee refuse; // subsidy ACK precedes timed funds notice and the refusal retains only that flag // clear/ACK, not ledgers, seller credit, news, allocator, histories or move. { auto g=original;const auto c=make_control(g,-1,false,true,250000,70000); const size_t br=kRecord;const uint8_t position=uint8_t(g.players.at(size_t(c.player)).w364&3); g.manager_records.at(br+0x170)=uint8_t(0x1c|position); // full tax tier, matching position write32(g.manager_records,br+0x314,c.fee); write32(g.manager_records,br+0x31c,uint32_t(-200000)); const auto seller_balance=read32(g.manager_records,0x314); const auto before=save_stream(g);const auto buyer_ledger=read32(g.manager_records,br+0x330); const auto seller_ledger=read32(g.manager_records,0x330);std::vector order; PendingOfferHooks h;h.human_buyer_allocator_gate=PendingOfferAllocatorGate::zero; h.answer=[](const GameState&,const PendingOfferQuestion&){return PendingOfferAnswer::no;}; h.notice=[&](const GameState& state,const PendingOfferNotice& n){ order.push_back(n.text_address); if(n.text_address==::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer)check(state.manager_records.at(br+0x170)!=0&& n.original_message==message_text(state,::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer)+format_amount(state,75000)+message_text(state,::bmh::layout::Weekly_Fail_TextPointer)+ format_amount(state,int32_t(c.fee))+").","Source subsidy message amounts/order"); if(n.text_address==::bmh::layout::Advertising_FormatError_TextPointer18)check(state.memory.u8(::bmh::layout::ActiveManager)==1&& (!state.memory.has(::bmh::layout::FinanceStatisticsEnabled)||state.memory.u8(::bmh::layout::FinanceStatisticsEnabled)==1), "funds refusal notice runs with buyer active and bdb7e set"); }; GameRandom game(73);WatcomRandom rand(1);std::vector observed; observe_boundaries(h,observed,game,rand);MinuteReport report;const auto r=run(g,c,h,game,rand,report); check(r.completed&&r.buyer_funds_refused==1&&r.transferred==0&&!report.unsupported, "expected Source buyer funds refusal still completes row"); check(order==std::vector({::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer,::bmh::layout::Advertising_FormatError_TextPointer18}),"subsidy ACK then insufficient-funds timed notice"); check(g.manager_records.at(br+0x170)==0&&read32(g.manager_records,br+0x330)==buyer_ledger&& read32(g.manager_records,0x330)==seller_ledger,"refusal clears eligible subsidy but writes neither transfer ledger"); check(g.memory.u8(::bmh::layout::ActiveManager)==0&&(!g.memory.has(::bmh::layout::FinanceStatisticsEnabled)||g.memory.u8(::bmh::layout::FinanceStatisticsEnabled)==0), "buyer active manager and transient bdb7e restored after refusal notice"); check(!contains(g,c.buyer,c.player)&&contains(g,c.seller,c.player)&&g.memory.u32(kOffers)==0xffffffffu&& g.squad_slots.at(kPool)==0x0fff,"funds refusal preserves squads and completes pending cleanup"); check(read32(g.manager_records,0x314)==seller_balance,"refusal does not credit seller"); check(before!=save_stream(g),"qualifying subsidy byte and pending cleanup are retained on expected refusal"); auto source=original;const auto source_control=make_control(source,-1,false,true,250000,70000); source.manager_records.at(br+0x170)=uint8_t(0x1c|(source.players.at(size_t(source_control.player)).w364&3)); write32(source.manager_records,br+0x314,source_control.fee);write32(source.manager_records,br+0x31c,uint32_t(-200000)); human_buyer_source_oracle::Script script;script.clicked_manager=0;script.clicked_row=source_control.seller_row; script.gate=human_buyer_source_oracle::Gate::zero;script.salary[0]=human_buyer_source_oracle::Reply::no; script.choice[0]=human_buyer_source_oracle::Choice::bid0; GameRandom sg(73);WatcomRandom sw(1);const auto expected=human_buyer_source_oracle::run(source,sg,sw,script); check(expected.funds_refused==1&&save_stream(g)==save_stream(source)&&game.seed()==sg.seed()&& game.calls()==sg.calls()&&rand.seed()==sw.seed()&&rand.calls()==sw.calls(), "subsidy/refusal notice boundary matches independent full Native and RNG oracle"); compare_boundaries(observed,expected); } // Threshold equality is the no-discount branch; a position mismatch bypasses // both subsidy notices and preserves the subsidy byte. Both cases still use raw // fee for history/news and adjusted fee only for settlement. { auto g=original;auto c=make_control(g,-1,false,true,2000000,70000); const size_t br=kRecord;const uint8_t pos=uint8_t(g.players.at(size_t(c.player)).w364&3); g.manager_records.at(br+0x170)=uint8_t(0x1c|pos); g.manager_records.at(br+0x210)=0; // explicitly fix Source threshold league at zero const uint32_t exact_threshold=(((uint32_t(g.manager_records.at(br+0x170))>>2)&7u)*50000u+150000u)*4u; check(exact_threshold==c.fee,"test vector is at strict Source subsidy threshold"); write32(g.manager_records,br+0x314,exact_threshold+100000u); std::vector notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices); h.answer=[](const auto&,const auto&){return PendingOfferAnswer::no;}; GameRandom game(73);WatcomRandom rand(1);MinuteReport report;const auto r=run(g,c,h,game,rand,report); check(r.completed&&r.transferred==1&&!report.unsupported,"threshold-equality full-fee sale succeeds"); check(std::find(notices.begin(),notices.end(),::bmh::layout::PendingOffer_FormatError_ExecutableField3)!=notices.end()&& std::find(notices.begin(),notices.end(),::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer)==notices.end(),"threshold branch shows no-discount ACK"); check(g.manager_records.at(br+0x170)==0,"qualifying above-threshold offer still clears subsidy"); expect_history(g,0,c.buyer,c.player,c.fee,false);expect_history(g,1,c.seller,c.player,c.fee,true); } { auto g=original;auto c=make_control(g,-1,false,true,1000000,70000); const size_t br=kRecord;const uint8_t pos=uint8_t(g.players.at(size_t(c.player)).w364&3); g.manager_records.at(br+0x170)=uint8_t(0x1c|((pos+1)&3));write32(g.manager_records,br+0x314,3000000); std::vector notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices); h.answer=[](const auto&,const auto&){return PendingOfferAnswer::no;}; GameRandom game(73);WatcomRandom rand(1);MinuteReport report;const auto r=run(g,c,h,game,rand,report); check(r.completed&&r.transferred==1&&!report.unsupported&&g.manager_records.at(br+0x170)!=0, "position mismatch leaves subsidy eligible for a later transfer"); check(std::find(notices.begin(),notices.end(),::bmh::layout::PendingOffer_FormatError_ExecutableField3)==notices.end()&& std::find(notices.begin(),notices.end(),::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer)==notices.end(),"position mismatch shows no subsidy ACK"); } // Source's no-room and EXE-gate suppression are expected partial successes: // settlement/news/cleanup commit, but no allocator RNG, history or movement. for(bool blocked:{false,true}){ auto g=original;const auto c=make_control(g,-1,true,true,2500000,70000); const auto buyer_before=read32(g.manager_records,kRecord+0x314); const auto seller_ledger_before=read32(g.manager_records,0x330); std::vector notices;auto h=hooks_for(blocked?PendingOfferAllocatorGate::blocked:PendingOfferAllocatorGate::zero,notices); h.answer=[](const auto&,const auto&){return PendingOfferAnswer::no;}; GameRandom game(73);WatcomRandom rand(1);std::vector observed; observe_boundaries(h,observed,game,rand);MinuteReport report;const auto r=run(g,c,h,game,rand,report); check(r.completed&&!report.unsupported&&r.transferred==0&& (blocked?r.buyer_allocator_blocked==1:r.buyer_no_room==1),"expected no-move partial result is typed"); check((read32(g.manager_records,kRecord+0x314)==buyer_before-c.fee)||g.level==0, "partial result keeps buyer settlement"); check(!contains(g,c.buyer,c.player)&&contains(g,c.seller,c.player)&& read32(g.manager_records,0x330)==seller_ledger_before-c.fee,"partial result keeps seller credit without move"); check(read32(g.manager_records,0x760)==read32(original.manager_records,0x760)&& read32(g.manager_records,kRecord+0x760)==read32(original.manager_records,kRecord+0x760), "partial result writes no transfer histories"); check(g.memory.u32(kOffers)==0xffffffffu&&g.squad_slots.at(kPool)==0x0fff, "partial result still reaches legacy routine row cleanup"); if(blocked)check(std::find(notices.begin(),notices.end(),::bmh::layout::PendingOffer_FormatError_ExecutableField)==notices.end(),"match_events_disabled suppression has no invented no-room notice"); else check(std::find(notices.begin(),notices.end(),::bmh::layout::PendingOffer_FormatError_ExecutableField)!=notices.end(),"full buyer shows Source no-room timed notice"); auto source=original;const auto source_control=make_control(source,-1,true,true,2500000,70000); human_buyer_source_oracle::Script script;script.clicked_manager=0;script.clicked_row=source_control.seller_row; script.gate=blocked?human_buyer_source_oracle::Gate::blocked:human_buyer_source_oracle::Gate::zero; script.salary[0]=human_buyer_source_oracle::Reply::no;script.choice[0]=human_buyer_source_oracle::Choice::bid0; GameRandom sg(73);WatcomRandom sw(1);const auto expected=human_buyer_source_oracle::run(source,sg,sw,script); check((blocked?expected.allocator_blocked==1:expected.no_room==1)&&save_stream(g)==save_stream(source)&& game.seed()==sg.seed()&&game.calls()==sg.calls()&&rand.seed()==sw.seed()&&rand.calls()==sw.calls(), "blocked/no-room partial result and both RNGs match independent full Source composition"); compare_boundaries(observed,expected); } // Missing gate provenance, human-buyer loan, same-club and error30 boundaries // fail the staged transaction; the direct API caller must discard state and RNG. for(int variant: {0,2,3}){ auto g=original;auto c=make_control(g,-1,false,true); if(variant==1)g.memory.set8(kList+0x34,0x98); if(variant==2)g.memory.set16(kList,uint16_t(c.seller)); // actual self-bid, not an AI buyer if(variant==3)g.memory.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField,uint32_t(c.player)|(uint32_t(c.seller)<<12)); const auto before=save_stream(g);GameRandom game(73);WatcomRandom rand(1);MinuteReport report; std::vector notices;auto h=hooks_for(variant==0?PendingOfferAllocatorGate::unsupported:PendingOfferAllocatorGate::zero,notices); const auto r=run(g,c,h,game,rand,report); check(!r.completed&&report.unsupported&&save_stream(g)==before&&game.calls()==0&&rand.calls()==0, "unsupported human-buyer boundary is mutation-free before the caller discards staged state"); } // A human seller's accepted loan to the other human manager performs the // complete Source fee, buyer board, owner snapshot, history and return-ledger // transaction, then survives the Native save/load boundary and month expiry. { auto g=original;const auto c=make_control(g,-1,false,true,2500000,70000); g.memory.set8(kList+0x34,0x8c); // Source loan flag with a 12-month term. std::array owner_board{}; const size_t seller_board=size_t(c.seller_row)*kBoardSlot; std::copy_n(g.tactics.begin()+std::ptrdiff_t(seller_board),kBoardSlot,owner_board.begin()); int ledger=-1,snapshot=-1; for(int n=0;n<200&&ledger<0;++n)if(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(n)*4)==0)ledger=n; for(int n=0;n<12&&snapshot<0;++n)if(g.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField+uint32_t(n)*2)==0xfff)snapshot=n; check(ledger>=0&&snapshot>=0,"complete loan ledger/snapshot capacity fixture"); const uint8_t prior_count=g.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField); std::vector notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices,true); GameRandom game(73);WatcomRandom rand(1);MinuteReport report; const auto result=run(g,c,h,game,rand,report); check(result.completed&&result.transferred==1&&!report.unsupported&&contains(g,c.buyer,c.player)&& !contains(g,c.seller,c.player),"accepted human-to-human loan moves both club rosters"); check(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4)==uint32_t(c.player+c.seller*0x1000+c.buyer*0x400000)&& g.memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField+uint32_t(ledger))==12,"accepted loan writes packed return owner/borrower and duration"); check(g.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField+uint32_t(snapshot)*2)==uint16_t(c.player)&& g.memory.u8(::bmh::layout::ClubInfo_FormatError_RuntimeField2+uint32_t(snapshot))==0&&g.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField)==uint8_t(prior_count+1), "human owner snapshot index, manager and count are recorded"); for(size_t n=0;n=0&&g.tactics.at(kBoard+size_t(borrower_row)*kBoardSlot+0x0c)==0xff, "human borrower board uses Source permanent-loan marker"); expect_history(g,0,c.buyer,c.player,c.fee,false,true); expect_history(g,1,c.seller,c.player,c.fee,true,true); auto loaded=GameState::from_save(SaveState(save_stream(g)));loaded.texts=&texts; check(save_stream(loaded)==save_stream(g)&&loaded.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4)== g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4),"loan ledger and snapshot round-trip through native save state"); loaded.memory.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField+uint32_t(ledger),1); const auto expired_ledger=loaded.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4); GameRandom ownerless_game(73);WatcomRandom ownerless_rand(1);MinuteReport ownerless_report; month_change(loaded,ownerless_rand,ownerless_report,&ownerless_game); check(ownerless_report.unsupported&&loaded.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4)==expired_ledger&& contains(loaded,c.buyer,c.player),"missing Source loan-return dialog owner aborts before loan commit"); auto declined=loaded; int declined_manager=-1; declined.loan_return_screen=[&](GameState&,int manager,const std::string&){declined_manager=manager;return 0;}; GameRandom declined_game(73);WatcomRandom declined_rand(1);MinuteReport declined_report; month_change(declined,declined_rand,declined_report,&declined_game); check(!declined_report.unsupported&&declined_manager==declined.manager_of(c.buyer)&& contains(declined,c.seller,c.player)&&!contains(declined,c.buyer,c.player)&& declined.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4)==0, "Source NO declines re-offer but still completes the expiring return"); auto editor_aborted=loaded; editor_aborted.loan_return_screen=[](GameState&,int,const std::string&){return 1;}; editor_aborted.loan_return_offer_screen=[](GameState&,GameRandom&,WatcomRandom&,int,int,int, const HumanBuyerSaleHooks&){return -1;}; const auto editor_abort_ledger=editor_aborted.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4); const auto editor_abort_owner=editor_aborted.squad_slots.at(squad_range(c.seller).first); const auto editor_abort_borrower=editor_aborted.squad_slots.at(squad_range(c.buyer).first); const auto editor_abort_snapshot=editor_aborted.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField+uint32_t(snapshot)*2); GameRandom abort_game(73);WatcomRandom abort_rand(1);MinuteReport abort_report; month_change(editor_aborted,abort_rand,abort_report,&abort_game); check(abort_report.unsupported&& editor_aborted.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4)==editor_abort_ledger&& editor_aborted.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField+uint32_t(snapshot)*2)==editor_abort_snapshot&& editor_aborted.squad_slots.at(squad_range(c.seller).first)==editor_abort_owner&& editor_aborted.squad_slots.at(squad_range(c.buyer).first)==editor_abort_borrower&& contains(editor_aborted,c.buyer,c.player)&&!contains(editor_aborted,c.seller,c.player), "legacy routine runtime-owner abort discards the staged loan return; preceding month work remains committed"); int dialog_manager=-1;std::string dialog_text; loaded.memory.set32(::bmh::layout::OfferSlots,0x12345678u); // legacy routine must choose the next free row. loaded.squad_slots.at(0xb70+41)=uint16_t(c.player); loaded.loan_return_screen=[&](GameState&,int manager,const std::string& question){ dialog_manager=manager;dialog_text=question;return 1; }; bool actual_return_editor_opened=false; loaded.loan_return_offer_screen=[&](GameState& staged,GameRandom& game,WatcomRandom& random, int manager,int source_slot,int list_entry,const HumanBuyerSaleHooks&)->int { const uint32_t row=::bmh::layout::EditorList+uint32_t(list_entry)*0x58; int bid_slot=-1;for(int i=0;i<4;++i)if(staged.memory.u16(row+uint32_t(i)*2)==0xffff){bid_slot=i;break;} TransferOfferEditorRequest request{manager,staged.manager_teams.at(size_t(manager)),list_entry, source_slot,int(staged.squad_slots.at(size_t(source_slot))&0x0fff),staged.memory.u16(row+8),bid_slot}; request.loan_return_entry = true; const auto editor=open_transfer_offer_editor_source(staged,request,game,random); if(!editor.supported)return -1; actual_return_editor_opened=true; (void)cancel_transfer_offer_editor_source(staged,editor); // User closes legacy routine without submitting. return 0; }; GameRandom return_game(73);WatcomRandom return_rand(1);MinuteReport return_report; month_change(loaded,return_rand,return_report,&return_game); check(!return_report.unsupported&&contains(loaded,c.seller,c.player)&&!contains(loaded,c.buyer,c.player), "month expiry returns human-borrowed player to human owner"); check(dialog_manager==loaded.manager_of(c.buyer)&&dialog_text.ends_with(message_text(loaded,::bmh::layout::Month_ReturnLoans_TextPointer6)), "human borrower receives exact format field yes/no return question"); check(actual_return_editor_opened,"Source YES opens real legacy routine before user declines the re-offer"); check(loaded.memory.u32(::bmh::layout::OfferSlots+4)==0xffffffffu&&loaded.squad_slots.at(0xb70+41)==0x0fff&& loaded.memory.u32(::bmh::layout::OfferSlots)==0x12345678u, "Source yes path selects, then clears, its temporary return-offer pool row/marker"); check(loaded.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4)==0&& loaded.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField+uint32_t(snapshot)*2)==0xfff&& loaded.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField)==prior_count,"expiry clears loan ledger/snapshot ownership and decrements count"); } // Normal manager rows 0, 1 and >=2 exercise first-FULL-word allocation rather // than masked-ID or synthetic-row selection. The control board positions are // intentionally varied while every other destination is occupied by a valid ID. for(int row:{0,1,4}){ auto g=original;const auto c=make_control(g,row,false,true,2500000,70000); std::vector notices;auto h=hooks_for(PendingOfferAllocatorGate::zero,notices); h.answer=[](const auto&,const auto&){return PendingOfferAnswer::no;}; GameRandom game(73);WatcomRandom rand(1);MinuteReport report;const auto r=run(g,c,h,game,rand,report); const int actual_row=player_row(g,c.buyer,c.player); check(c.buyer_row==row&&actual_row>=0&&r.completed&&r.transferred==1&&!report.unsupported, "one requested first-full-word row is allocated and follows player through lineup"); check(g.tactics.at(kBoard+size_t(actual_row)*kBoardSlot+0x06)==0x6d, "selected row inherits seller board before offer fields and lineup"); } std::puts("human buyer pending offer tests: passed");return 0; }catch(const std::exception& e){std::fprintf(stderr,"human_buyer_pending_offer_tests: %s\n",e.what());return 1;}}