// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "app/career_session.hpp" #include "formats/le.hpp" #include "formats/vga.hpp" #include "game/bank_credit.hpp" #include "game/save.hpp" #include "ui/bank.hpp" #include #include #include #include #include #include using namespace bmh; using namespace bmh::ui; namespace { void check(bool ok, const char* message) { if (!ok) throw std::runtime_error(message); } std::unique_ptr career(const std::filesystem::path& data, int manager_count) { auto session = std::make_unique(data, uint32_t(0x31415926 + manager_count)); SetupOptions options; options.managers = manager_count; std::string error; std::vector selected; for (int slot = 0; slot < manager_count; ++slot) { const auto context = session->selection_context(uint64_t(slot + 1)); const auto selected_club = std::find_if(context.club_order.begin(), context.club_order.end(), [&](int club) { return std::find(selected.begin(), selected.end(), club) == selected.end(); }); check(selected_club != context.club_order.end(), "career fixture provides distinct manager clubs"); ManagerChoice choice; choice.slot = slot; choice.name = slot == 0 ? "Bank UI Test" : "Lender UI Test"; choice.master_club = *selected_club; choice.start_league = 0; choice.strength = 2; choice.portrait = slot; choice.selection_club = int(selected_club - context.club_order.begin()); choice.roster_revision = context.revision; check(session->confirm_manager(options, choice, error), "career fixture manager setup succeeds"); selected.push_back(*selected_club); } CareerInitializationResult initialized; check(session->finish(initialized, error), "career fixture reaches its first bank desk"); return session; } void set_record_u32(GameState& game, size_t manager, size_t offset, uint32_t value) { const size_t at = manager * 0xb0c + offset; for (unsigned b = 0; b < 4; ++b) game.manager_records.at(at + b) = uint8_t(value >> (b * 8)); } void copy_source_opaque(Image& target, const Image& source, int sx, int sy, int dx, int dy, int width, int height) { for (int y = 0; y < height; ++y) for (int x = 0; x < width; ++x) { if (sx + x < 0 || sy + y < 0 || sx + x >= source.width || sy + y >= source.height || dx + x < 0 || dy + y < 0 || dx + x >= target.width || dy + y >= target.height) continue; target.at(dx + x, dy + y) = source.pixels[size_t(sy + y) * size_t(source.width) + size_t(sx + x)]; } } void mark_body_text(std::vector& mask, int screen_width, int screen_height, const Font& font, int x, int baseline, std::string_view utf8) { const std::string bytes = utf8_to_original(utf8); const int top = baseline - font.baseline; int pen_x = x; for (const unsigned char ch : bytes) { const auto& glyph = font.glyph(ch); for (int row = 0; row < font.height; ++row) { for (int col = 0; col < glyph.bit_width; ++col) { const int bit = glyph.bit_offset + col; if (!(font.bitmap[size_t(row) * font.modulo + size_t(bit / 8)] & (0x80 >> (bit % 8)))) continue; const int px = pen_x + col, py = top + row; if (px >= 0 && py >= 0 && px < screen_width && py < screen_height) mask[size_t(py) * size_t(screen_width) + size_t(px)] = 1; } } pen_x += glyph.advance; } } void mark_large_text(std::vector& mask, int screen_width, int screen_height, const Font& font, int x, int baseline, std::string_view utf8) { mark_body_text(mask, screen_width, screen_height, font, x, baseline, utf8); } void source_lender_crop_rectangles(const std::filesystem::path& data, const LeImage& exe, const BankState& projection) { struct Crop { int sx1, sy1, dx1, dy1, w1, h1; int sx2, sy2, dx2, dy2, w2, h2; }; // Literal legacy routine emitted-lender crop tuples, independently transcribed // from Original EXE rows 0, 1, and 2. The separate hit-box rows are 5, 6, // and 7 and are tested by manager_count_projection_and_hitboxes(). constexpr std::array source{{ {0, 0, 24, 122, 91, 80, 179, 95, 1, 103, 55, 38}, {91, 0, 45, 113, 88, 89, 91, 89, 1, 68, 81, 73}, {179, 0, 74, 107, 70, 90, 0, 80, 24, 62, 70, 79}, }}; const Image kb64 = load_vga(asset_path(data / "KB", "64.VGA")); const Image background = load_vga(asset_path(data / "KB", "23.VGA")); Image expected = background; check(projection.credit_lenders.size() <= source.size(), "literal crop fixture has at most three emitted lender alternatives"); if (projection.credit_lenders.empty()) { const Image actual = BankScreen(data, projection).render(); for (int y = 45; y < 187; ++y) for (int x = 49; x < 261; ++x) check(actual.pixels[size_t(y) * size_t(actual.width) + size_t(x)] == background.pixels[size_t(y) * size_t(background.width) + size_t(x)], "no-lender room keeps the unpatched KB/23 image"); return; } std::vector covered(expected.pixels.size()); for (size_t ordinal = 0; ordinal < projection.credit_lenders.size(); ++ordinal) { const Crop& crop = source[ordinal]; copy_source_opaque(expected, kb64, crop.sx1, crop.sy1, crop.dx1, crop.dy1, crop.w1, crop.h1); for (int y = 0; y < crop.h1; ++y) for (int x = 0; x < crop.w1; ++x) { const size_t target = size_t(crop.dy1 + y) * size_t(expected.width) + size_t(crop.dx1 + x); covered[target] = 1; } } BankScreen screen(data, projection); const Image actual = screen.render(); for (size_t pixel = 0; pixel < covered.size(); ++pixel) if (covered[pixel]) check(actual.pixels[pixel] == expected.pixels[pixel], "room lender pass matches literal Source crop/destination rectangle and opaque pixel value"); // The second KB/64 pass modifies KB/5 for bank subviews; it is not // composited over the room. Derive the frame from literal tuples and // require a visible 0xff source pixel to survive the opaque copy (0xff is // deliberately included because a transparent-key blit would drop it). Image expected_frame = load_vga(asset_path(data / "KB", "5.VGA")); std::vector panel_covered(expected_frame.pixels.size()); for (size_t ordinal = 0; ordinal < projection.credit_lenders.size(); ++ordinal) { const Crop& crop = source[ordinal]; copy_source_opaque(expected_frame, kb64, crop.sx2, crop.sy2, crop.dx2, crop.dy2, crop.w2, crop.h2); for (int y = 0; y < crop.h2; ++y) for (int x = 0; x < crop.w2; ++x) { const int px = crop.dx2 + x, py = crop.dy2 + y; if (px >= 0 && py >= 0 && px < expected_frame.width && py < expected_frame.height) panel_covered[size_t(py) * size_t(expected_frame.width) + size_t(px)] = 1; } } BankState no_lenders = projection; no_lenders.credit_lenders.clear(); BankScreen control(data, no_lenders); control.click(exe.u16(::bmh::layout::Bank_FinishCredit_RuntimeField + 2), exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField3 + 1)); const Image control_view = control.render(); BankScreen finance(data, projection); finance.click(exe.u16(::bmh::layout::Bank_FinishCredit_RuntimeField + 2), exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField3 + 1)); const Image view = finance.render(); // Build the expected visible room independently from Source's emitted // crop tuples. The control render supplies the same text/KB/5 subview; // pass 1 is then applied only where the modal does not cover the room. Image expected_visible_base = control_view; for (size_t ordinal = 0; ordinal < projection.credit_lenders.size(); ++ordinal) { const Crop& crop = source[ordinal]; for (int y = 0; y < crop.h1; ++y) for (int x = 0; x < crop.w1; ++x) { const int px = crop.dx1 + x, py = crop.dy1 + y; if (px < 0 || py < 0 || px >= expected_visible_base.width || py >= expected_visible_base.height) continue; const bool covered_by_modal = px >= 49 && px < 261 && py >= 45 && py < 187; if (!covered_by_modal) expected_visible_base.at(px, py) = kb64.pixels[size_t(crop.sy1 + y) * size_t(kb64.width) + size_t(crop.sx1 + x)]; } } // Mask only Source's known finance-view glyph pixels: the centered title, // the seven labels/currency markers/values, and any displayed holdings. // Every other screen pixel is compared exactly either to the unpatched // control render or to the independently composed opaque KB/5 crop. std::vector overlay(size_t(view.width) * size_t(view.height)); const Font body = load_font(asset_path(data / "F", "BMH3.FNT")); const Font large = load_font(asset_path(data / "F", "BMH2.FNT")); const TextDb textd = load_textd(asset_path(data, "TEXTD.BLK")); if (textd.strings.size() > 1272) mark_large_text(overlay, view.width, view.height, large, 111, 54, original_to_utf8(textd[1272])); for (int x = 51; x <= 258; ++x) overlay[size_t(55) * size_t(view.width) + size_t(x)] = 1; int held_row = 0; for (size_t i = 0; i < projection.funds.size(); ++i) if (projection.funds[i].owned) { const int baseline = 85 + held_row * 6; mark_body_text(overlay, view.width, view.height, body, 53, baseline, projection.finance_fund_labels[i]); mark_body_text(overlay, view.width, view.height, body, 169, baseline, projection.finance_fund_prices[i]); ++held_row; } held_row = 0; for (size_t i = 0; i < projection.stocks.size(); ++i) if (projection.stocks[i].owned) { const int x = held_row < 6 ? 53 : 156; const int baseline = 131 + (held_row % 6) * 6; mark_body_text(overlay, view.width, view.height, body, x, baseline, projection.finance_stock_labels[i]); mark_body_text(overlay, view.width, view.height, body, x + 70, baseline, projection.finance_stock_prices[i]); ++held_row; } for (int i = 0; i < 7; ++i) { const int x = exe.u8(::bmh::layout::Bank_OriginalToUtf8_RuntimeField2 + size_t(i)); const int baseline = exe.u8(::bmh::layout::Bank_OriginalToUtf8_RuntimeField3 + size_t(i)); const size_t label_id = size_t((::bmh::layout::Bank_OriginalToUtf8_RuntimeField6 - ::bmh::layout::TextPointerTable) / 4) + size_t(i); if (label_id < textd.strings.size()) mark_body_text(overlay, view.width, view.height, body, x, baseline, original_to_utf8(textd[label_id])); mark_body_text(overlay, view.width, view.height, body, x + 42, baseline, exe.cstring(::bmh::layout::Bank_OriginalToUtf8_ExecutableField)); const int value_x = x + ((i == 4 || i == 6) ? 44 : 49); mark_body_text(overlay, view.width, view.height, body, value_x, baseline, projection.finance_value_text[size_t(i)]); } bool opaque_ff = false; size_t visible_outer_source_pixels = 0; for (int y = 0; y < view.height; ++y) for (int x = 0; x < view.width; ++x) { const size_t screen_at = size_t(y) * size_t(view.width) + size_t(x); const bool in_frame = x >= 49 && y >= 45 && x < 49 + expected_frame.width && y < 45 + expected_frame.height; const int fx = x - 49, fy = y - 45; const size_t frame_at = in_frame ? size_t(fy) * size_t(expected_frame.width) + size_t(fx) : 0; if (in_frame && panel_covered[frame_at] && !overlay[screen_at]) { if (view.pixels[screen_at] != expected_frame.pixels[frame_at]) throw std::runtime_error("KB/5 literal crop mismatch at screen " + std::to_string(x) + "," + std::to_string(y) + " expected=" + std::to_string(expected_frame.pixels[frame_at]) + " actual=" + std::to_string(view.pixels[screen_at])); opaque_ff |= expected_frame.pixels[frame_at] == 0xff; } else { const bool visible_pass1 = x >= 24 && x < 115 && y >= 122 && y < 202 && !(x >= 49 && x < 261 && y >= 45 && y < 187); if (visible_pass1 && !overlay[screen_at]) ++visible_outer_source_pixels; if (view.pixels[screen_at] != expected_visible_base.pixels[screen_at]) throw std::runtime_error("unexpected pixel outside declared KB/5 crop/glyph regions at screen " + std::to_string(x) + "," + std::to_string(y) + " expected=" + std::to_string(expected_visible_base.pixels[screen_at]) + " actual=" + std::to_string(view.pixels[screen_at])); } } check(opaque_ff, "literal KB/5 projection preserves visible 0xff crop pixels opaquely"); check(visible_outer_source_pixels > 2500, "ordinary bank subview retains the visible outer region of Source lender-room artwork"); } void manager_count_projection_and_hitboxes(const std::filesystem::path& data, const LeImage& exe, int count) { auto session = career(data, count); auto& game = session->state(); const int active = int(game.memory.u8(::bmh::layout::ActiveManager)); check(game.memory.u8(::bmh::layout::ManagerCount) == count, "career fixture saves configured human manager count"); // Give every potential lender ample Source liquidity so case-5 editing is testable. for (int slot = 0; slot < count; ++slot) { set_record_u32(game, size_t(slot), 0x314, 2'000'000); set_record_u32(game, size_t(slot), 0x31c, 100'000); } const auto native = save_stream(game); const auto w_seed = session->rand().seed(); const auto w_calls = session->rand().calls(); const auto g_seed = session->game().seed(); const auto g_calls = session->game().calls(); const BankState projection = bank_from_game(game, exe, 17); check(int(projection.credit_lenders.size()) == count - 1, "configured count yields one to three lenders"); if (!projection.credit_lenders.empty()) { BankState forged_bank = projection; forged_bank.credit.counterparty = projection.credit_lenders.front().counterparty; bool rejected_bank_context = false; try { (void)BankScreen(data, forged_bank); } catch (const FormatError&) { rejected_bank_context = true; } check(rejected_bank_context, "constructor refuses a lender context forged into the bank base identity"); } for (size_t i = 0; i < projection.credit_lenders.size(); ++i) { const auto& lender = projection.credit_lenders[i]; const int expected_slot = int(i) < active ? int(i) : int(i) + 1; check(lender.manager_slot == expected_slot && lender.counterparty == expected_slot + 1, "lender alternatives retain ascending Source manager slots and slot-plus-one IDs"); check(lender.credit.counterparty == lender.counterparty, "each lender context uses the selected counterparty loan record"); } source_lender_crop_rectangles(data, exe, projection); BankScreen stable(data, projection); const Image first = stable.render(); check(first.width == 320 && first.height == 240 && stable.render().pixels == first.pixels, "opaque selector rendering is repeatable"); check(save_stream(game) == native && session->rand().seed() == w_seed && session->rand().calls() == w_calls && session->game().seed() == g_seed && session->game().calls() == g_calls, "projection and rendering preserve full Native and both random streams"); if (count >= 2) { GameState switched = game; const int next_active = (active + 1) % count; switched.memory.set8(::bmh::layout::ActiveManager, uint8_t(next_active)); const auto other_owner = bank_from_game(switched, exe, 18); check(other_owner.credit_lenders.size() == size_t(count - 1) && std::none_of(other_owner.credit_lenders.begin(), other_owner.credit_lenders.end(), [&](const auto& lender) { return lender.manager_slot == next_active; }), "current borrower exclusion follows the live active-manager slot"); GameState no_liquidity = game; const int first_lender = projection.credit_lenders.front().manager_slot; set_record_u32(no_liquidity, size_t(first_lender), 0x314, 0); set_record_u32(no_liquidity, size_t(first_lender), 0x31c, 0); const auto no_funds_projection = bank_from_game(no_liquidity, exe, 19); const auto no_funds = std::find_if(no_funds_projection.credit_lenders.begin(), no_funds_projection.credit_lenders.end(), [&](const auto& lender) { return lender.manager_slot == first_lender; }); check(no_funds != no_funds_projection.credit_lenders.end() && no_funds->credit.lender_liquidity == 0 && !bank_credit_bounds(no_funds->credit, bank_credit_draft(no_funds->credit), 0).available, "Source still shows a manager lender with no credit limit; affordability is enforced in its editor"); } for (size_t i = 0; i < projection.credit_lenders.size(); ++i) { const size_t table = i + 5; const int left = exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField5 + table), top = exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField6 + table); for (const auto [x, y] : std::array, 4>{{ {left, top}, {left + 0x11, top}, {left, top + 0x11}, {left + 0x11, top + 0x11}}}) { BankScreen screen(data, projection); screen.click(x, y); check(screen.credit_open() && screen.state().credit_counterparty == projection.credit_lenders[i].counterparty, "all inclusive lender hitbox corners select their projected counterparty"); check(screen.state().credit.saved == projection.credit_lenders[i].credit.saved, "lender selection opens that lender’s live loan matrix, not the bank’s"); screen.key("ESC"); check(!screen.credit_open() && screen.state().credit_counterparty == 0 && screen.state().credit.saved == projection.credit.saved, "cancel returns to bank context without mutating the loan projection"); } } if (count >= 2) { const auto& lender = projection.credit_lenders.front(); const size_t table = 5; BankScreen screen(data, projection); screen.click(exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField5 + table), exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField6 + table)); screen.click(80, 74); // case-5 principal (field 0) check(screen.calculator_open(), "case 5 opens principal input from the first editable row"); screen.key("ENTER"); screen.click(80, 92); // case-5 monthly payment (field 2, bank case 4 leaves this row inert) check(screen.calculator_open(), "only the selected manager-credit screen enables monthly-payment input"); screen.key("ENTER"); const BankRequest request = screen.click(80, 178); check(request.kind == BankRequestKind::bank_credit && request.credit_counterparty == lender.counterparty && !request.accept_credit_fees && request.expected_credit == lender.credit.saved, "case-5 typed credit request carries fresh lender identity and no bank fee acceptance"); check(std::any_of(request.credit_edits.begin(), request.credit_edits.end(), [](const BankCreditEdit& edit) { return edit.field == 0; }) && std::any_of(request.credit_edits.begin(), request.credit_edits.end(), [](const BankCreditEdit& edit) { return edit.field == 2; }), "case-5 editor request replays principal and the separately adjustable monthly payment"); check(bank_request_json(request).find("\"credit_counterparty\":" + std::to_string(lender.counterparty)) != std::string::npos, "JSON protocol preserves manager-credit counterparty"); const std::string shown_before_bad_ack = screen.state_json(); BankState wrong_counterparty = projection; ++wrong_counterparty.revision; wrong_counterparty.credit_counterparty = lender.counterparty + 1; bool wrong_cp_rejected = false; try { screen.acknowledge(wrong_counterparty); } catch (const FormatError&) { wrong_cp_rejected = true; } check(wrong_cp_rejected && screen.pending().has_value() && screen.state_json() == shown_before_bad_ack, "ACK naming a different lender preserves the exact shown state and pending request"); BankState stale = projection; ++stale.revision; stale.credit_lenders.clear(); bool rejected = false; try { screen.acknowledge(stale); } catch (const FormatError&) { rejected = true; } check(rejected && screen.pending().has_value() && screen.credit_open() && screen.state_json() == shown_before_bad_ack, "ACK without the pending lender in its fresh projection is rejected and retryable"); GameState accepted = game; const auto booked = commit_bank_credit(accepted, exe, active, request.expected_credit, request.credit_edits, request.accept_credit_fees, request.credit_counterparty); check(booked.status == BankCreditStatus::accepted, "test lender request is accepted by existing Core path"); BankState next = bank_from_game(accepted, exe, projection.revision + 1); const std::string before_forged_bank_ack = screen.state_json(); BankState forged_bank_ack = next; forged_bank_ack.credit.counterparty = lender.counterparty; bool forged_bank_rejected = false; try { screen.acknowledge(forged_bank_ack); } catch (const FormatError&) { forged_bank_rejected = true; } check(forged_bank_rejected && screen.pending().has_value() && screen.state_json() == before_forged_bank_ack, "ACK rejects nonzero bank base context without consuming the selected-lender request"); screen.acknowledge(next); check(!screen.pending() && !screen.credit_open() && screen.state().credit_counterparty == 0 && screen.state().credit.saved == bank_credit_context(accepted, exe, active).saved, "accepted ACK rebuilds and retains the fresh lender context without default-row leakage"); } check(save_stream(game) == native && session->rand().seed() == w_seed && session->rand().calls() == w_calls && session->game().seed() == g_seed && session->game().calls() == g_calls, "selection, editor, cancel, request and ACK probes leave owner Native and W/G unchanged"); // A non-credit ACK still carries the bank base credit context. Exercise a // real deposit request, reject a one-field forged nested counterparty, // then retry the same valid changed projection successfully. BankScreen deposit(data, projection); deposit.click(exe.u16(::bmh::layout::Bank_FinishCredit_RuntimeField + 3 * 2), exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField3 + 3)); deposit.click(80, 180); check(deposit.calculator_open() && deposit.text("1"), "deposit action opens its source calculator and accepts a typed amount"); const int accept_x = 103 + exe.u16(::bmh::layout::Advertising_Click_RuntimeField + 13 * 2); const int accept_y = 55 + exe.u8(::bmh::layout::Advertising_Click_RuntimeField2 + 13); const BankRequest deposit_request = deposit.click(accept_x, accept_y); check(deposit_request.kind == BankRequestKind::move_to_deposit && deposit_request.amount == 1 && deposit.pending().has_value(), "deposit calculator emits a pending non-credit transaction"); BankState accepted_deposit = projection; ++accepted_deposit.revision; --accepted_deposit.balance; ++accepted_deposit.deposit; BankState forged_deposit = accepted_deposit; forged_deposit.credit.counterparty = projection.credit_lenders.empty() ? 1 : projection.credit_lenders.front().counterparty; const std::string before_forged_deposit = deposit.state_json(); bool forged_deposit_rejected = false; try { deposit.acknowledge(forged_deposit); } catch (const FormatError&) { forged_deposit_rejected = true; } check(forged_deposit_rejected && deposit.pending().has_value() && deposit.state_json() == before_forged_deposit, "non-credit ACK rejects a forged lender nested in the bank context without consuming pending state"); deposit.acknowledge(accepted_deposit); check(!deposit.pending() && deposit.state().balance == accepted_deposit.balance && deposit.state().deposit == accepted_deposit.deposit, "valid non-credit ACK retries and caches the canonical bank context"); } void configured_count_beats_hidden_manager(const std::filesystem::path& data, const LeImage& exe) { auto session = career(data, 4); auto game = session->state(); game.manager_teams.push_back(kNoTeam); // session-only national manager can extend the runtime vector game.memory.set8(::bmh::layout::ManagerCount, 4); const auto projected = bank_from_game(game, exe, 1); check(projected.credit_lenders.size() == 3 && std::none_of(projected.credit_lenders.begin(), projected.credit_lenders.end(), [](const auto& lender) { return lender.manager_slot == 4; }), "lender scan follows saved configured count, not hidden national manager vector size"); game.memory.set8(::bmh::layout::ManagerCount, 5); bool rejected = false; try { (void)bank_from_game(game, exe, 1); } catch (const FormatError&) { rejected = true; } check(rejected, "unsupported five-manager lender domain fails closed"); } void manager_loan_refinance_and_monthly_presets(const std::filesystem::path& data, const LeImage& exe) { auto session = career(data, 2); GameState game = session->state(); const int borrower = int(game.memory.u8(::bmh::layout::ActiveManager)); const int counterparty = borrower == 0 ? 2 : 1; for (int slot = 0; slot < 2; ++slot) { set_record_u32(game, size_t(slot), 0x314, 2'000'000); set_record_u32(game, size_t(slot), 0x31c, 100'000); } auto context = bank_credit_context(game, exe, borrower, counterparty); auto draft = bank_credit_draft(context); check(edit_bank_credit(context, draft, 0, 1'000'000), "controlled case-5 loan principal is valid"); auto opened = commit_bank_credit(game, exe, borrower, context.saved, draft.edits, false, counterparty); check(opened.status == BankCreditStatus::accepted, "existing lender loan fixture uses the shared Core commit"); context = bank_credit_context(game, exe, borrower, counterparty); draft = bank_credit_draft(context); check(edit_bank_credit(context, draft, 3, 12), "controlled case-5 loan term can be set to twelve months"); auto shortened = commit_bank_credit(game, exe, borrower, context.saved, draft.edits, false, counterparty); check(shortened.status == BankCreditStatus::accepted, "controlled case-5 loan term uses the shared Core commit"); const size_t loan = ::bmh::layout::Loans + size_t(borrower) * 0x78 + size_t(counterparty) * 0x18; context = bank_credit_context(game, exe, borrower, counterparty); game.memory.set32(uint32_t(loan + 16), 6); game.memory.set32(uint32_t(loan + 20), context.saved[2] * 6); context = bank_credit_context(game, exe, borrower, counterparty); check(context.saved[0] == 1'000'000 && context.saved[3] == 12 && context.saved[4] == 6, "fixture exposes Source-shaped existing principal, term and elapsed months"); auto refinance = bank_credit_draft(context); check(edit_bank_credit(context, refinance, 3, 1) && refinance.interest_adjustment != 0, "existing case-5 refinance produces the nonzero interest adjustment that must not ask bank fees"); BankState projection = bank_from_game(game, exe, 40); const auto lender = std::find_if(projection.credit_lenders.begin(), projection.credit_lenders.end(), [&](const auto& candidate) { return candidate.counterparty == counterparty; }); check(lender != projection.credit_lenders.end() && lender->credit.saved == context.saved, "fresh screen projection carries the outstanding manager loan"); BankScreen editor(data, projection); const int lender_index = int(lender - projection.credit_lenders.begin()); const size_t hitbox_table = size_t(5 + lender_index); editor.click(exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField5 + hitbox_table), exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField6 + hitbox_table)); editor.click(80, 100); // Source term row, away from the preceding inclusive field-2 edge. editor.key("ENTER"); // Source minimum term is accepted. check(editor.state_json().find("\"credit_fee_confirmation_open\":true") == std::string::npos, "case-5 nonzero interest adjustment never opens the bank-only fee prompt"); const BankRequest request = editor.click(80, 178); check(request.kind == BankRequestKind::bank_credit && request.credit_counterparty == counterparty && !request.accept_credit_fees && editor.state_json().find("\"credit_fee_confirmation_open\":true") == std::string::npos, "existing manager refinance submits directly without fee acceptance"); const auto bounds = bank_credit_bounds(context, bank_credit_draft(context), 2); check(bounds.available, "controlled outstanding loan permits monthly-payment editing"); if (bounds.initial != 93296 || bounds.minimum != 74637 || bounds.maximum != 111955) throw std::runtime_error("monthly fixture bounds differ from its pinned Source inputs: initial=" + std::to_string(bounds.initial) + " min=" + std::to_string(bounds.minimum) + " max=" + std::to_string(bounds.maximum)); const std::array source_presets{{74637, 83966, 93295, 102624, 111953, UINT32_MAX, 74637, 111955}}; std::array clicked_values = source_presets; clicked_values[5] = bounds.initial; // UINT32_MAX is Source's disabled cell; clicking leaves the annuity selected. for (size_t button = 0; button < clicked_values.size(); ++button) { BankScreen presets(data, projection); presets.click(exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField5 + hitbox_table), exe.u8(::bmh::layout::Bank_FinishCredit_RuntimeField6 + hitbox_table)); presets.click(80, 92); // case-5 monthly row, away from the preceding inclusive field-1 edge. const size_t cell = button + 15; const int x = 103 + exe.u16(::bmh::layout::Advertising_Click_RuntimeField + cell * 2); const int y = 55 + exe.u8(::bmh::layout::Advertising_Click_RuntimeField2 + cell); presets.click(x, y); const std::string shown = presets.state_json(); if (shown.find("\"calculator_value\":" + std::to_string(clicked_values[button])) == std::string::npos) throw std::runtime_error("monthly Source preset mismatch at cell " + std::to_string(button) + " expected clicked value=" + std::to_string(clicked_values[button]) + " state=" + shown); } } } int main(int argc, char** argv) { try { if (argc != 2) throw std::runtime_error("bank_lender_ui_tests requires the BMH data directory"); const std::filesystem::path data = argv[1]; const LeImage exe = load_le(asset_path(data, "BMH.exe")); for (int count = 1; count <= 4; ++count) manager_count_projection_and_hitboxes(data, exe, count); configured_count_beats_hidden_manager(data, exe); manager_loan_refinance_and_monthly_presets(data, exe); std::cout << "Source lender crop rectangles and opaque pixels, no-lender baseline, configured count/order, inclusive hitboxes, case-5 fee/preset behavior, typed counterparty ACK, and read-only Native/W/G invariants passed\n"; return 0; } catch (const std::exception& error) { std::cerr << error.what() << '\n'; return 1; } }