// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "../../tests/test_inputs.hpp" #include "ui/training_camp.hpp" #include "ui/source_notice_test_helpers.hpp" #include "ui/setup.hpp" #include "game/desk_actions.hpp" #include "game/messages.hpp" #include #include using namespace bmh; using namespace bmh::ui; namespace { void check(bool ok, const char* message) { if (!ok) throw std::runtime_error(message); } void rejected(const std::function& fn) { try { fn(); } catch (const FormatError&) { return; } throw std::runtime_error("expected rejected operation"); } TrainingCampState fixture() { TrainingCampState s; s.manager_slot = 1; s.runtime_club = 12; s.revision = 42; s.source = "engine_projection"; s.club_name = "UNITFC"; s.manager_name = "Player1"; s.balance = 1000000; s.focus = {0, 1, 14, 10}; s.prices = {50000, 250000, 150000, 400000, 300000, 450000, 550000, 650000}; return s; } } int main(int argc, char** argv) { try { if (argc < 2) throw std::runtime_error("original data directory required"); const std::filesystem::path data = argv[1]; TrainingCampScreen screen(data, fixture()); const auto exe = load_le(asset_path(data, "BMH.exe")); auto entry = screen.render(); check(entry.pixels == screen.render().pixels, "rendering is deterministic and has no game effects"); check(screen.selected_resort() == -1 && screen.chosen_resort() == -1, "entry has no resort while retaining the fixed Original controls"); auto expected = load_vga(asset_path(data / "KB", "129.VGA")); const auto texts = load_textd(asset_path(data, "TEXTD.BLK")); const auto font = load_font(asset_path(data / "F", "BMH3.FNT")); auto content = fixture(); content.currency_multiplier = int32_t(exe.u32(::bmh::layout::CurrencyMultiplier)); content.currency_divisor = int32_t(exe.u32(::bmh::layout::CurrencyDivisor)); content.currency_suffix = exe.cstring(::bmh::layout::CurrencySuffixText); GameState money; money.currency_suffix = content.currency_suffix; money.memory.add_block(::bmh::layout::CurrencyMultiplier, 8); money.memory.set32(::bmh::layout::CurrencyMultiplier, uint32_t(content.currency_multiplier)); money.memory.set32(::bmh::layout::CurrencyDivisor, uint32_t(content.currency_divisor)); check(format_number(money, 12843000, 1) == "12.843.000", "ordinary numbers have neither a currency affix nor currency conversion"); if (content.currency_suffix == " &") { check(content.currency_multiplier == 1 && content.currency_divisor == 2, "FLTD money checks use its loaded one-half currency conversion"); check(format_amount(money, 12843000) == "& 6.421.500" && format_amount(money, -12843000) == "& -6.421.500" && format_amount(money, 0) == "& 0", "FLTD common money formatter prefixes pounds, including negative and zero amounts"); check(format_number(money, 2000, 0x108) == "& %%%%1.000" && format_number(money, 2000, 0x188) == "& %%%%1.000" && format_number(money, 12843000, 0x141) == "& 6421500", "FLTD finance padding and optional grouping remain inside the currency prefix"); } else { check(content.currency_multiplier == 1 && content.currency_divisor == 1, "German money checks use its loaded identity currency conversion"); check(format_amount(money, 12843000) == "12.843.000" + content.currency_suffix && format_amount(money, -12843000) == "-12.843.000" + content.currency_suffix && format_amount(money, 0) == "0" + content.currency_suffix && format_number(money, 2000, 0x108) == " %%%%2.000" + content.currency_suffix && format_number(money, 12843000, 0x141) == "12843000" + content.currency_suffix, "German money formatting retains its suffix, padding, sign and optional grouping"); } for (size_t r = 0; r < 8; ++r) { content.prices[r] = int32_t(exe.u32(::bmh::layout::DeskActions_ConfigureTrainingCampData_RuntimeField2 + uint32_t(r * 4))) + 100000; for (size_t q = 0; q < 4; ++q) content.quality[r][q] = exe.u8(::bmh::layout::DeskActions_ConfigureTrainingCampData_RuntimeField + uint32_t(r * 4 + q)); TrainingCampScreen place(data, content); const int x = exe.u8(::bmh::layout::TrainingCamp_Click_RuntimeField + uint32_t(r)), y = exe.u8(::bmh::layout::TrainingCamp_Click_RuntimeField2 + uint32_t(r)); check(place.move(x + 9, y + 8) && place.selected_resort() == int(r), "each loaded map hitbox identifies its matching resort"); auto rendered = place.render(); auto atlas = load_vga(asset_path(data / "KB", r < 4 ? "8.VGA" : "9.VGA")); const int sx = int(r % 2) * 110, sy = int((r % 4) / 2) * 68; for (int yy = 0; yy < 68; ++yy) for (int xx = 0; xx < 110; ++xx) if (atlas.at(sx + xx, sy + yy) != 0xc0) check(rendered.at(198 + xx, 25 + yy) == atlas.at(sx + xx, sy + yy), "all eight loaded resort names and hitboxes use their original photograph cell"); } if (content.currency_suffix == " &") { const auto source_colors = read_file(bmh::test::external_input("camp-label-colors.bin")); check(source_colors.size() == 9, "external label-colour expectation has nine entries"); for (size_t i = 0; i < source_colors.size(); ++i) check(exe.u8(::bmh::layout::TrainingCamp_FocusControls_TextPointer + uint32_t(i)) == source_colors[i], "FLTD label colours skip its three alignment bytes"); check(training_camp_price_text(content, 0) == "& %50.000" && training_camp_price_text(content, 7) == "& 350.000", "FLTD prices use its actual base price, pound prefix and one-half conversion"); } else { auto currency_sample = content; currency_sample.prices[0] = 150000; check(training_camp_price_text(currency_sample, 0) == "150.000" + texts[17], "German currency suffix is retained independently of edition resort prices"); } auto widgets = load_vga(asset_path(data / "KB", "52.VGA")); for(int i=0;i<9;++i){ const auto& label=texts[243+size_t(i)]; const int baseline=exe.u8(::bmh::layout::TrainingCamp_FocusControls_RuntimeField2+uint32_t(i)); font.draw(expected,200,baseline+2-font.baseline,label,0x40); Image mask(font.text_width(label),font.height); font.draw(mask,0,0,label,1); int gradient=0; while(gradient<32&&exe.u8(::bmh::layout::Advertising_Text_RuntimeField2+uint32_t(gradient))!=exe.u8(::bmh::layout::TrainingCamp_FocusControls_TextPointer+uint32_t(i)))++gradient; for(int y=0;y{7, 1, 14, 8} && req.manager_slot == 1 && req.runtime_club == 12 && req.revision == 42, "focus can change before any resort hover and derives slider four without applying state locally"); check(focus_screen.selected_resort()==-1&&focus_screen.chosen_resort()==-1, "entry focus editing does not select or book a resort"); auto updated = fixture(); ++updated.revision; updated.focus = req.focus; focus_screen.acknowledge(updated); check(focus_screen.state().focus == req.focus && !focus_screen.pending(), "authoritative focus acknowledgment updates the screen"); auto right_edge=TrainingCampScreen(data,fixture()); req=right_edge.click(306,174); check(req.kind==TrainingCampRequestKind::set_focus&&req.focus[1]==15, "Source slider input clamps its extended x hitbox and includes row gaps"); auto derived=TrainingCampScreen(data,fixture()); check(derived.click(276,204).kind==TrainingCampRequestKind::none&&!derived.pending(), "fourth focus slider remains derived on entry"); auto stale_screen = TrainingCampScreen(data, fixture()); stale_screen.move(hx + 1, hy + 1); stale_screen.click(255 + 7 * 3, y + 2); auto stale = fixture(); stale.focus = {7, 1, 14, 8}; rejected([&] { stale_screen.acknowledge(stale); }); auto raw = fixture(); raw.focus = {3, 6, 9, 9}; raw.focus_normalization_required = true; TrainingCampScreen normalize(data, raw); const auto normalize_request = normalize.initialize_focus(); check(normalize_request.kind == TrainingCampRequestKind::set_focus && normalize_request.focus == std::array{3, 6, 9, 9} && normalize_request.revision == raw.revision, "engine entry normalizes original derived slider four as a drawless request"); auto gated = fixture(); gated.stays = 0x80; TrainingCampScreen weekly(data, gated); weekly.click(hx + 1, hy + 1); check(!weekly.pending() && weekly.state().feedback == TrainingCampFeedback::booked_this_week, "weekly gate is applied before any booking request"); bmh::ui::test::expect_notice_symbols(weekly.render(),load_vga(asset_path(data/"KB","0.VGA"))); const auto before_expiry=weekly.state(); check(weekly.timed_notice_open()&&weekly.expire_timed_notice()&&!weekly.timed_notice_open()&& !weekly.close_requested()&&!weekly.pending()&&weekly.state().revision==before_expiry.revision&& weekly.state().stays==before_expiry.stays&&weekly.state().balance==before_expiry.balance, "timed warning restores the camp locally without another booking or parent close"); auto complete=fixture();complete.stays=0x81;complete.feedback=TrainingCampFeedback::booked; TrainingCampScreen success_notice(data,complete); check(!success_notice.timed_notice_open()&&!success_notice.expire_timed_notice(), "successful booking waits for interactive acknowledgement rather than warning expiry"); TrainingCampScreen acknowledged_success(data,complete); acknowledged_success.click(150,170); check(acknowledged_success.close_requested()&&!acknowledged_success.pending(), "legacy routine returns to the desk after57eca acknowledges the successful booking"); success_notice.click(0,0,true); check(success_notice.close_requested()&&!success_notice.pending(), "right close after successful booking preserves the outer camp handback"); TrainingCampScreen right_warning(data,gated);right_warning.click(hx+1,hy+1); right_warning.click(0,0,true); check(!right_warning.timed_notice_open()&&!right_warning.close_requested()&&!right_warning.pending(), "right-down warning acknowledgement restores the camp instead of closing it"); auto capped = fixture(); capped.stays = 3; TrainingCampScreen limit(data, capped); limit.click(hx + 1, hy + 1); check(!limit.pending() && limit.state().feedback == TrainingCampFeedback::visit_limit, "three-visit gate is independent from focus values"); auto no = TrainingCampScreen(data, fixture()); check(no.key("ESC").kind == TrainingCampRequestKind::none && no.close_requested() && !no.pending(), "ESC exits without booking"); std::cout << "training camp UI: typed requests, gates, rejection and authoritative update OK\n"; return 0; } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } }