// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include #include #include #include #include #include #include #include #include #include "app/career_session.hpp" #include "app/controller.hpp" #include "formats/fbm.hpp" #include "game/save.hpp" #include "game/month.hpp" using namespace bmh; namespace fs = std::filesystem; namespace { void require(bool value, const char* reason) { if (!value) throw std::runtime_error(reason); } struct Snapshot { Bytes native; GameRandom game; WatcomRandom rand; uint64_t revision; Snapshot(app::CareerSession& session, uint64_t rev) : native(save_stream(session.state())), game(session.game()), rand(session.rand()), revision(rev) {} bool same(app::CareerSession& session, uint64_t rev) const { return native == save_stream(session.state()) && revision == rev && game.seed() == session.game().seed() && game.calls() == session.game().calls() && rand.seed() == session.rand().seed() && rand.calls() == session.rand().calls(); } }; struct Context { fs::path directory, data; ui::StartupFlow flow; std::unique_ptr session; uint64_t revision = 0; openbmh::audio::Playback playback; std::optional audio_session; Context(const fs::path& root, const fs::path& genuine, bool low, bool preserve = false) : directory(fs::temp_directory_path() / ("openbmh-preview-app-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()))), data(root), flow(root, directory) { fs::create_directory(directory); auto input = load_savegame(genuine); require(input.checksum_ok, "genuine Native fixture checksum"); auto control = GameState::from_save(SaveState(input.stream)); // Declared Native scalar controls retain every pool/seller/roster // identity. They force the independently tested Source value vectors. for (int entry = 0; !preserve && entry < 40; ++entry) { const auto player = control.squad_slots.at(2928 + size_t(entry)) & 0xfff; if (player == 0xfff) continue; auto& p = control.players.at(player); p.w35c = (p.w35c & ~((127u << 7) | (127u << 14))) | (low ? 0u : (70u << 7) | (70u << 14)); p.w364 = (p.w364 & ~((31u << 21) | 3u | (63u << 10) | (63u << 26))) | (low ? 0u : (10u << 21)) | 1u; p.w368 &= ~(63u << 7); } WatcomRandom serializer(1); write_savegame(directory / "AUTOSAVE.FBM", make_savegame(control, serializer)); playback.set_muted(true); flow.click(214, 215); const auto load = flow.send_key("ENTER"); require(load.request == ui::FlowRequest::file_action, "physical load request"); require(serve(load).empty() && session && revision == 1 && flow.screen_name() == "desktop", "production controller loads the Native scalar control"); require(save_stream(session->state()) == save_stream(control) && session->game().calls() == 0 && session->rand().calls() == 0, "productive load preserves Native and consumes no RNG"); const auto& items = flow.desktop()->state().items; const auto menu = std::find_if(items.begin(), items.end(), [](const auto& item) { return item.kind == 17 && !item.disabled; }); require(menu != items.end(), "real desk exposes ordinary transfer menu"); const auto opened = flow.click(menu->x + menu->width / 2, menu->y + menu->height / 2); require(serve(opened).empty() && flow.screen_name() == "transfer_market", "physical menu opens the production Original overview"); } ~Context() { std::error_code ignored; fs::remove_all(directory, ignored); } std::string serve(const ui::FlowResult& action) { return app::serve_flow_request(flow, action, session, data, directory, 37, revision, playback, audio_session, false, {}, {}, {}, {}, {}, {}, {}, {}, {}, app::PendingOfferEntryPolicy::legacy_unpresented, {}, app::HumanBuyerMarketEntryPolicy::normal_interactive); } ui::FlowResult hover() { const auto request = flow.move_action(210, 28); require(request.request == ui::FlowRequest::submenu_action && std::holds_alternative(request.submenu_action) && std::get(request.submenu_action).kind == ui::TransferMarketRequestKind::preview_quote, "physical mouse motion emits the Source quote request"); return request; } }; void natural_snapshot_preview(const fs::path& data, const fs::path& input) { Context c(data, input, false, true); const Snapshot before(*c.session, c.revision); const auto identity = transfer_market_snapshot_preview(c.session->state(), 0, 1, 0); require(identity && identity->player == 118 && identity->source_slot >= 0, "normal loan identifies BURKARDT in the real borrower squad"); const auto action = c.flow.move_action(25, 207); require(action.request == ui::FlowRequest::submenu_action, "physical lender snapshot hover requests preview"); const auto request = std::get(action.submenu_action); require(request.kind == ui::TransferMarketRequestKind::preview_quote && request.preview_snapshot_index == 0 && request.expected_player == 118 && request.preview_source_slot == identity->source_slot && request.squad_row == identity->displayed_row, "snapshot preview retains owner/borrower identity separately from listing rows"); auto expected_rand = c.session->rand(); uint32_t fee = 0, salary = 0; market_value(c.session->state(), identity->source_slot, 0, 100, fee, salary, 1, 0, expected_rand); std::printf("Natural snapshot: player=%d displayed_row=%d borrower_source_slot=%d fee=%u W=%llu\n", identity->player, identity->displayed_row, identity->source_slot, fee, static_cast(expected_rand.calls() - before.rand.calls())); require(c.serve(action).empty() && !c.flow.pending_transfer_market(), "real controller acknowledges snapshot hover"); const auto json = c.flow.state_json(); require(json.find("\"delta\":" + std::to_string(fee / 10000 * 10000)) != std::string::npos && json.find("\"selected_squad\":null") != std::string::npos, "actual player valuation is displayed without a selectable sale row"); require(save_stream(c.session->state()) == before.native && c.session->game().calls() == before.game.calls() && c.session->rand().calls() == expected_rand.calls(), "snapshot preview changes no Native bytes or G and uses only normal valuation W"); const Snapshot quoted(*c.session, c.revision); c.serve(c.flow.move_action(25, 207)); c.serve(c.flow.send_key("V")); c.serve(c.flow.send_key("ENTER")); c.serve(c.flow.click(25, 207)); require(quoted.same(*c.session, c.revision) && c.flow.screen_name() == "transfer_market", "repeat hover and snapshot sale inputs neither submit nor mutate"); for (int failure = 0; failure < 4; ++failure) { auto invalid = request; if (failure == 0) invalid.squad_row = 0; if (failure == 1) invalid.preview_source_slot = int(squad_range(1).first) + identity->displayed_row; if (failure == 2) invalid.preview_snapshot_index = 1; if (failure == 3) invalid.preview_is_purchase = true; invalid.revision = c.revision; std::string error; require(!c.session->preview_transfer_market(invalid, c.revision, error) && !error.empty() && quoted.same(*c.session, c.revision), "forged snapshot preview rolls back all state/RNG"); } // Broken/ambiguous relations remain noninteractive; no guessed player quote. for (int failure = 0; failure < 7; ++failure) { auto invalid = c.session->state(); if (failure == 0) invalid.memory.set8(::bmh::layout::ClubInfo_FormatError_RuntimeField2, 1); if (failure == 1) invalid.memory.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField, 0); if (failure == 2) invalid.memory.set32(::bmh::layout::FixtureTransferSecondIdentityValue, invalid.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField)); if (failure == 3) invalid.squad_slots[size_t(identity->source_slot)] = 0x0fff; if (failure == 4) invalid.memory.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField, invalid.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField) ^ (1u << 12)); if (failure == 5) { const auto range = squad_range(54); const size_t duplicate = range.first == size_t(identity->source_slot) ? range.first + 1 : range.first; invalid.squad_slots[duplicate] = 118; } if (failure == 6) { invalid.memory.set16(::bmh::layout::FixtureTransferSecondPlayerValue, 118); invalid.memory.set8(::bmh::layout::FixtureTransferCapacityFlag, 0); } const auto original = save_stream(invalid); WatcomRandom rand(37); const auto result = quote_transfer_market_preview_source(invalid, {0, 1, identity->source_slot, 118, 1, false, false, 0}, rand); require(!result.supported && !transfer_market_snapshot_preview(invalid, 0, 1, 0) && rand.calls() == 0 && save_stream(invalid) == original, "unreliable snapshot relation rejects without Native/RNG writes"); ui::TransferMarketScreen screen(data, ui::transfer_market_from_game(invalid, 1)); require(screen.move(25, 207).kind == ui::TransferMarketRequestKind::none, "unreliable nonregular row has no fabricated UI quote"); } c.serve(c.flow.click(310, 230, true)); std::string error; require(c.session->save_game(c.directory / "SNAPSHOT.FBM", 0, false, error), "snapshot preview leaves normal saving available"); app::CareerSession reloaded(data, 37, c.directory / "SNAPSHOT.FBM"); require(save_stream(reloaded.state()) == before.native, "fresh save reload preserves the entire normal Native state"); } void natural_return_editor(const fs::path& data, const fs::path& input) { const auto file = load_savegame(input); require(file.checksum_ok, "natural return input checksum"); auto state = GameState::from_save(SaveState(file.stream)); const auto texts = load_textd(data / "TEXTD.BLK"); state.texts = &texts; require(state.date == 395 && state.memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField) == 1 && state.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField) == 118 && state.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField) == 1, "unmodified naturally played human loan before expiry"); bool edited = false; std::exception_ptr editor_failure; state.loan_return_screen = [](GameState&, int, const std::string&) { return 1; }; state.loan_return_offer_screen = [&](GameState& staged, GameRandom& game, WatcomRandom& rand, int manager, int source_slot, int list_entry, const HumanBuyerSaleHooks&) { try { require(staged.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField) == 0 && staged.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField) == 0xfff && staged.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField) == 0, "return removes old ledger and snapshot before the actual editor"); const uint32_t row = ::bmh::layout::EditorList + uint32_t(list_entry) * 0x58; TransferOfferEditorRequest request{manager, staged.manager_teams.at(size_t(manager)), list_entry, source_slot, 118, staged.memory.u16(row + 8), 0}; request.loan_return_entry = true; auto owner = open_transfer_offer_editor_source(staged, request, game, rand); require(owner.supported && owner.editable, "natural return opens the real editor"); ui::OutgoingTransferScreen screen(data, app::loan_return_offer_editor_projection(staged, owner, 1, false)); const auto edit = [&](int x, int y, const char* digits) { (void)screen.click(x, y, false); require(screen.text(digits), "return KB6 accepts physical numeric input"); const auto action = screen.key("ENTER"); require(action.kind == ui::OutgoingTransferRequestKind::quote_change, "KB6 commit also requests a quote refresh"); owner = app::edit_transfer_offer_from_ui(staged, owner, action, game, rand); require(owner.supported, "return presenter applies concrete KB6 field"); screen.acknowledge(app::loan_return_offer_editor_projection(staged, owner, 1, false)); }; const uint32_t fee = owner.money_profiles[0].maximum; require(fee > 0 && fee < 5000000, "natural return fee calculator has its Source upper bound"); edit(80, 124, "5000000"); require(owner.fee == fee && owner.salary == 0 && !owner.quote_loan, "fee commit changes Native fee without toggling loan quote"); edit(220, 124, "250000"); require(owner.fee == fee && owner.salary == 200000 && !owner.quote_loan, "salary commit retains fee and purchase quote"); edit(280, 140, "1"); require(owner.years == 1 && owner.term == 12 && !owner.quote_loan, "term calculator remains a term event in the return presenter"); const auto toggle = screen.click(160, 25, false, true); owner = app::edit_transfer_offer_from_ui(staged, owner, toggle, game, rand); require(owner.quote_loan && owner.fee == fee && owner.salary == 200000 && owner.term == 12, "only the header action toggles the quote loan class"); screen.acknowledge(app::loan_return_offer_editor_projection(staged, owner, 1, false)); (void)screen.key("ESC"); require(cancel_transfer_offer_editor_source(staged, owner).supported, "return editor closes normally after concrete field commits"); edited = true; return 0; } catch (...) { editor_failure = std::current_exception(); return -1; } }; GameRandom game(73); WatcomRandom rand(1); MinuteReport report; month_change(state, rand, report, &game); if (editor_failure) std::rethrow_exception(editor_failure); if (report.unsupported) throw std::runtime_error("natural return: " + report.reason); require(edited && !report.unsupported && state.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField) == 0 && state.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField) == 0xfff && state.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField) == 0, "natural return completes after the real calculator event bridge"); } } int main(int argc, char** argv) try { require(argc == 5, "usage: transfer_market_preview_app_tests DATA genuine.FBM natural-return.FBM natural-borrow.FBM"); natural_return_editor(argv[1], argv[3]); natural_snapshot_preview(argv[1], argv[4]); for (const bool low : {false, true}) { Context c(argv[1], argv[2], low); const Snapshot before(*c.session, c.revision); const auto action = c.hover(); require(before.same(*c.session, c.revision), "UI motion alone never advances Native or RNG"); require(c.serve(action).empty() && !c.flow.pending_transfer_market(), "real controller acknowledges the hover quote"); require(save_stream(c.session->state()) == before.native && c.session->game().seed() == before.game.seed() && c.session->game().calls() == before.game.calls(), "preview preserves all Native and G state"); require(c.session->rand().calls() == before.rand.calls() + uint64_t(low) && c.revision == before.revision + uint64_t(low) && c.flow.desktop()->state().revision == c.revision, "optional one-W fallback publishes exactly one coherent revision"); const auto request = std::get(action.submenu_action); require(c.flow.state_json().find(low ? "-50000" : "-1020000") != std::string::npos, "Source scalar rounded purchase delta reaches the actual visible quote"); const Snapshot quoted(*c.session, c.revision); for (int i = 0; i < 3; ++i) { (void)c.flow.render(); const auto repeated = c.flow.move_action(210, 28); require(repeated.request == ui::FlowRequest::none && quoted.same(*c.session, c.revision), "repeated hover and rendering never reroll the selected quote"); } require(c.serve(action).empty() && quoted.same(*c.session, c.revision), "replayed already-consumed controller request cannot reroll"); const auto marked = c.flow.click(210, 28); require(marked.request == ui::FlowRequest::none && quoted.same(*c.session, c.revision), "marking the already hovered Source row does not trigger another quote"); c.flow.move_action(160, 180); const auto second = c.hover(); auto bad = std::get(second.submenu_action); bad.preview_seller ^= 1; std::string error; require(!c.session->preview_transfer_market(bad, c.revision, error) && !error.empty() && quoted.same(*c.session, c.revision), "stale seller rejects before any live Native/W/G/revision change"); bad = std::get(second.submenu_action); --bad.revision; require(!c.session->preview_transfer_market(bad, c.revision, error) && quoted.same(*c.session, c.revision), "stale revision rejects before valuation"); require(request.preview_source_slot >= 2928 && request.preview_source_slot < 2968, "real quote uses the projected ordinary source slot"); } { Context c(argv[1], argv[2], false); const auto hovered = c.hover(); c.serve(hovered); c.flow.click(210, 28); const Snapshot before(*c.session, c.revision); const auto opened = c.flow.send_key("B"); require(opened.request == ui::FlowRequest::submenu_action, "marked ordinary player requests the Original outgoing editor"); c.serve(opened); require(c.flow.screen_name() == "outgoing_transfer" && c.session->transfer_offer_owner() && c.session->game().calls() == before.game.calls() + 1 && c.revision == before.revision + 1, "real controller opens KB31 with the owned Source G draw and coherent revision"); const auto owner = *c.session->transfer_offer_owner(); require(owner.editable && owner.bid_slot >= 0, "Source picks the real editable raw row"); const uint32_t list = ::bmh::layout::EditorList + uint32_t(owner.request.list_entry) * 0x58; const uint32_t bid = uint32_t(owner.bid_slot); const auto buyer = c.session->state().memory.u16(list + bid * 2); const auto term = c.session->state().memory.u8(list + 0x34 + bid); const auto g_calls = c.session->game().calls(); const auto focused = c.flow.click(40, 123); require(focused.request == ui::FlowRequest::none && c.flow.text("10000"), "physical fee rectangle opens the Source KB6 calculator locally"); const auto committed = c.flow.send_key("ENTER"); require(committed.request == ui::FlowRequest::submenu_action && c.flow.pending_transfer_offer(), "KB6 commit produces the typed Source field event"); c.serve(committed); require(!c.flow.pending_transfer_offer() && c.flow.screen_name() == "outgoing_transfer" && c.session->state().memory.u32(list + 0x1c + bid * 4) == 10000 && c.session->state().memory.u16(list + bid * 2) == buyer && c.session->state().memory.u8(list + 0x34 + bid) == term && c.session->game().calls() == g_calls, "Source field event immediately writes the Native fee without buyer/term/G changes"); const Snapshot edited(*c.session, c.revision); c.serve(committed); require(edited.same(*c.session, c.revision), "consumed editor commit cannot be replayed"); std::string error; require(!c.session->save_game(c.directory / "BLOCKED.FBM", 0, false, error) && !fs::exists(c.directory / "BLOCKED.FBM") && edited.same(*c.session, c.revision), "saving cannot escape the active Source editor modal"); const auto canceled = c.flow.send_key("ESC"); c.serve(canceled); require(c.flow.screen_name() == "transfer_market" && !c.session->transfer_offer_owner() && edited.same(*c.session, c.revision), "Source cancel returns to the overview while retaining every committed Native edit"); require(c.session->save_game(c.directory / "EDITED.FBM", 0, false, error), "completed Source cancel makes the ordinary Native state saveable again"); app::CareerSession reloaded(c.data, 37, c.directory / "EDITED.FBM"); require(save_stream(reloaded.state()) == save_stream(c.session->state()) && reloaded.state().memory.u32(list + 0x1c + bid * 4) == 10000, "fresh productive reload retains the Source empty/own-row fee edit"); } { Context c(argv[1], argv[2], true); const Snapshot before(*c.session, c.revision); const auto action = c.hover(); require(draw_hook == nullptr, "exclusive draw observer ownership"); draw_hook = [](int) { throw std::runtime_error("controlled Source fallback interruption"); }; c.serve(action); draw_hook = nullptr; require(before.same(*c.session, c.revision) && !c.flow.pending_transfer_market(), "controller rolls back the interrupted staged W fallback and consumes rejection once"); } std::puts("PASS Original market hover input/Source quote/revision/RNG/rollback controller integration"); return 0; } catch (const std::exception& e) { draw_hook = nullptr; std::fprintf(stderr, "transfer_market_preview_app_tests: %s\n", e.what()); return 1; }