// SPDX-License-Identifier: GPL-3.0-only #include "app/career_session.hpp" #include "app/controller.hpp" #include "content/save.hpp" #include "launch/mods.hpp" #include "launch/game_data.hpp" #include "ui/setup.hpp" #include "ui/sportschau.hpp" #include "game/save.hpp" #include "audio/original.hpp" #include #include #include using namespace bmh; namespace fs = std::filesystem; void check(bool value, const std::string &text) { if (!value) throw std::runtime_error(text); } int main(int argc, char **argv) try { if (argc < 2) return 77; const auto root = fs::temp_directory_path() / ("openbmh-native-career-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count())); fs::create_directories(root); struct Cleanup { fs::path p; ~Cleanup() { std::error_code ec; fs::remove_all(p, ec); } } cleanup{root}; launch::ModLibrary library(root); launch::AddMod request; request.source = argv[1]; request.name = "Test Classic"; request.start_year = 1994; request.migrate = false; const auto result = library.add(request, {}); const auto package = result.mod.directory / "content.obw"; auto content = content::open(package); content::Mount mount(package, content); openbmh::audio::OriginalAssets sound; for (size_t i = 0; i < 4; ++i) sound.containers[i] = read_file(mount.root() / "S" / std::to_string(2000 + i)); for (size_t i = 0; i < 96; ++i) sound.tables.frequencies[i] = content->executable.u16(layout::Audio_OriginalAudioAssets_RuntimeField2 + uint32_t(i) * 2); for (size_t i = 0; i < 9; ++i) sound.tables.operators[i] = content->executable.u8(layout::Audio_OriginalAudioAssets_RuntimeField + uint32_t(i) * 16); openbmh::audio::OriginalSynth synth; std::string sound_error; check(synth.load(std::move(sound), 22050, sound_error), sound_error); // Exercise renderers through aliases while the mod contains only content.obw. check(ui::SetupScreen(mount.root()).render().pixels.size() == 320 * 240, "OBW-only setup renderer"); (void)ui::SportschauIntro(mount.root()).render_frame(0); const auto resolved = launch::resolve_game(request.source, root / "legacy-test-cache"); check(resolved.error.empty(), resolved.error); auto legacy_directory = resolved.check.directory; if (!fs::exists(legacy_directory / "BMH.exe")) { // The legacy oracle uses fixed filename casing. Only its private test // copy needs aliases on case-sensitive filesystems; OBW does not. const auto aliases = root / "legacy-case-reference"; fs::create_directory(aliases); for (const char *name : {"BMH.exe", "M3D.MAN", "TEXTD.BLK", "M3.MEN", "M3.DAT"}) { const auto source = launch::find_file(legacy_directory, name); check(bool(source), "legacy reference file missing"); fs::copy_file(*source, aliases / name); } legacy_directory = aliases; } app::CareerSession old(legacy_directory, 12345); app::CareerSession session(mount.root(), 12345); check(save_stream(old.state()) == save_stream(session.state()) && old.rand().seed() == session.rand().seed() && old.game().seed() == session.game().seed(), "OBW bootstrap matches legacy state and RNG"); ui::SetupOptions options; options.managers = 1; ui::ManagerChoice manager; manager.slot = 0; manager.master_club = 0; manager.start_league = 0; manager.strength = 1; manager.portrait = 0; manager.name = "Native QA"; std::string error; check(session.confirm_manager(options, manager, error), error); const auto personal = library.user_directory(result.mod); session.configure_autosave_directory(personal); session.state().memory.set8(layout::Desk_EnterDesk_RuntimeField, 1); ui::CareerInitializationResult initial; check(session.finish(initial, error), error); check(initial.desktop.date.year == 1994 && initial.desktop.date.weekday == 2, "selected start year changes the year display while retaining the Classic Wednesday epoch"); const auto before = cli::dump_json(encode_native_state(session.state())); const auto random = session.rand(); const auto game = session.game(); const auto save = library.user_directory(result.mod) / "QA.obs"; check(session.save_game(save, 0, false, error), error); check(session.rand().seed() == random.seed() && session.rand().calls() == random.calls() && session.game().seed() == game.seed() && session.game().calls() == game.calls(), "native saving is RNG-neutral"); app::CareerSession loaded(mount.root(), 999, save); check(cli::dump_json(encode_native_state(loaded.state())) == before, "native career state round-trip"); check(loaded.rand().seed() == random.seed() && loaded.rand().calls() == random.calls() && loaded.game().seed() == game.seed() && loaded.game().calls() == game.calls(), "both RNG states and counters restored"); check(cli::dump_json(content::driver_checkpoint(session.manager_join_checkpoint().driver)) == cli::dump_json(content::driver_checkpoint(loaded.manager_join_checkpoint().driver)), "native turn cursor round-trip"); { ui::StartupFlow flow(mount.root(), personal); check(flow.click(215, 220).request == ui::FlowRequest::submenu_opened, "GUI opens native load browser from setup"); const auto request = flow.send_key("ENTER"); check(request.request == ui::FlowRequest::file_action && request.file_action.path == save, "GUI selects native save from personal directory"); std::unique_ptr gui_session; uint64_t gui_revision = 0; openbmh::audio::Playback playback; std::optional audio_session; check(app::serve_flow_request(flow, request, gui_session, mount.root(), personal, 999, gui_revision, playback, audio_session, false) .empty(), "GUI controller accepts native save path"); check(gui_session && flow.screen_name() == "desktop" && gui_revision == 1, "GUI controller attaches loaded native desktop: " + flow.state_json()); const auto save_item = std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(), [](const ui::DeskItem &item) { return item.kind == 11 && !item.disabled; }); check(save_item != flow.desktop()->state().items.end(), "native desktop exposes Save"); const auto serve = [&](const ui::FlowResult &event) { check(app::serve_flow_request(flow, event, gui_session, mount.root(), personal, 999, gui_revision, playback, audio_session, false) .empty(), "native GUI file action dispatch"); }; serve(flow.click(save_item->x + save_item->width / 2, save_item->y + save_item->height / 2)); check(flow.screen_name() == "save_load" && flow.text("GUI Roundtrip"), "native GUI Save accepts a new filename"); const auto gui_random = gui_session->rand(); serve(flow.send_key("ENTER")); check(flow.screen_name() == "desktop" && fs::exists(personal / "GUI Roundtrip.obs"), "native GUI Save publishes OBS and returns to desktop: " + flow.state_json()); check(gui_session->rand().seed() == gui_random.seed() && gui_session->rand().calls() == gui_random.calls(), "GUI saving preserves random state"); } session.state().memory.set8(layout::Desk_EnterDesk_RuntimeField, 1); loaded.state().memory.set8(layout::Desk_EnterDesk_RuntimeField, 1); session.state().autosave_month = 0; loaded.state().autosave_month = 0; uint64_t first_revision = 1, second_revision = 1; for (int step = 0; step < 8; ++step) { const auto first_desk = session.desktop_projection(first_revision), second_desk = loaded.desktop_projection(second_revision); ui::DeskRequest first_request; first_request.kind = ui::DeskRequestKind::advance_turn; first_request.manager_slot = first_desk.manager_slot; first_request.revision = first_revision; auto second_request = first_request; second_request.manager_slot = second_desk.manager_slot; second_request.revision = second_revision; std::string first_error, second_error; const auto first = session.dispatch_kickoff(first_request, first_revision, first_error); const auto second = loaded.dispatch_kickoff(second_request, second_revision, second_error); check(first.kind == second.kind && first_error == second_error, "native continuation has identical outcome"); check(cli::dump_json(encode_native_state(session.state())) == cli::dump_json(encode_native_state(loaded.state())), "native continuation preserves every game-state field"); check(session.rand().seed() == loaded.rand().seed() && session.rand().calls() == loaded.rand().calls() && session.game().seed() == loaded.game().seed() && session.game().calls() == loaded.game().calls(), "native continuation preserves both random streams"); if (first.kind == TurnDeskKind::Failed || first.kind == TurnDeskKind::WaitingAtDesk) break; if (step == 0) { const auto autosave_error = session.take_autosave_error(); check(fs::exists(personal / "AUTOSAVE.obs"), "native autosave at stable desk: " + autosave_error); app::CareerSession autosaved(mount.root(), 0, personal / "AUTOSAVE.obs"); check(cli::dump_json(encode_native_state(autosaved.state())) == cli::dump_json(encode_native_state(session.state())), "autosave matches completed desk, including runtime flags"); } check(session.save_game(save, first.manager_slot, true, error), error); auto fresh = std::make_unique(mount.root(), 0, save); check(cli::dump_json(content::driver_checkpoint(session.manager_join_checkpoint().driver)) == cli::dump_json(content::driver_checkpoint(fresh->manager_join_checkpoint().driver)), "prepared match groups and previous results survive saving"); } // Original save migration must not require the original installation afterwards. auto old_save = make_savegame(session.state(), session.rand()); write_savegame(root / "legacy.FBM", old_save); app::CareerSession migrated(mount.root(), 4321, root / "legacy.FBM", true); check(migrated.save_game(root / "migrated.obs", 0, false, error), error); app::CareerSession continued(mount.root(), 1, root / "migrated.obs"); check(continued.state().players.size() == session.state().players.size(), "legacy save migrates to native continuation"); if (argc > 2) { app::CareerSession original(mount.root(), 0x12345678, argv[2], true); check(original.save_game(root / "original-import.obs", original.state().memory.u8(layout::ActiveManager), false, error), error); app::CareerSession resumed(mount.root(), 0, root / "original-import.obs"); check(cli::dump_json(encode_native_state(original.state())) == cli::dump_json(encode_native_state(resumed.state())), "original edition save migration round-trip"); } auto changed = content->documents; changed["assets/classic/images/kb/29.pixels"][0] ^= 1; bool rejected = false; try { content::verify(changed); } catch (const std::exception &) { rejected = true; } check(rejected, "modified Classic assets rejected"); std::cout << "OBW-only GUI/bootstrap, career/RNG round-trip and migration passed\n"; return 0; } catch (const std::exception &e) { std::cerr << e.what() << '\n'; return 1; }