#include "test_inputs.hpp" // SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include #include #include #include #include #include "app/controller.hpp" #include "formats/textd.hpp" #include "game/save.hpp" #include "ui/season_entrants.hpp" using namespace bmh; namespace { void require(bool value, const char* text) { if (!value) throw std::runtime_error(text); } struct Result { Bytes state; uint32_t game_seed, watcom_seed; unsigned game_calls, watcom_calls; }; void require_initial_hooks_cleared(const app::CareerSession& session, const char* message) { const auto driver = session.manager_join_checkpoint().driver; require(!driver.season_pause && !driver.season_cup_draw, message); } Result advance(const std::filesystem::path& data, const std::filesystem::path& input, bool observe) { ui::StartupFlow flow(data, input.parent_path()); auto session = std::make_unique(data, 1, input); uint64_t revision = 1; flow.click(214, 215); require(flow.send_key("ENTER").request == ui::FlowRequest::file_action, "native load screen"); flow.attach_loaded_game(session->desktop_projection(revision), session->preparation_projection(revision)); const auto& items = flow.desktop()->state().items; const auto item = std::find_if(items.begin(), items.end(), [](const auto& i) { return !i.disabled && (i.kind == 12 || (i.kind == 58 && i.open)); }); require(item != items.end(), "season-end Weiter is reachable"); const auto request = flow.click(item->x + item->width / 2, item->y + item->height / 2); require(request.request == ui::FlowRequest::kickoff, "pending production season advance"); std::vector events; SeasonCupDrawHook hook; if (observe) hook = [&](const GameState& state, const SeasonCupDrawEvent& event) { for (unsigned offer = 0; offer < 4; ++offer) { require(state.memory.u32(::bmh::layout::OfferSlots + offer * 4) == 0xffffffffu, "first-round modal follows Source empty-offer boundary"); } const auto before = save_stream(state); const auto game = session->game(); const auto watcom = session->rand(); require(event.phase == (events.empty() ? SeasonCupDrawPhase::draw : SeasonCupDrawPhase::overview), "draw precedes native sorted overview"); require(event.participants.size() == event.count && event.count == 64, "owned first-round field contains all 64 participants"); events.push_back(event); // owned projection can outlive the callback require(before == save_stream(state) && game.seed() == session->game().seed() && game.calls() == session->game().calls() && watcom.seed() == session->rand().seed() && watcom.calls() == session->rand().calls(), "presentation leaves state and both RNGs unchanged"); }; openbmh::audio::Playback playback; std::optional audio; const auto message = app::serve_flow_request(flow, request, session, data, input.parent_path(), 1, revision, playback, audio, false, {}, {}, {}, {}, {}, {}, {}, hook); require(message.empty() && revision == 2 && flow.desktop() != nullptr, "transition reaches the new-season desk"); if (observe) require(events.size() == 2, "both cup phases presented once"); const auto settled = save_stream(session->state()); const auto game = session->game(); const auto watcom = session->rand(); (void)app::serve_flow_request(flow, request, session, data, input.parent_path(), 1, revision, playback, audio, false, {}, {}, {}, {}, {}, {}, {}, hook); require(settled == save_stream(session->state()) && revision == 2 && (!observe || events.size() == 2) && game.seed() == session->game().seed() && game.calls() == session->game().calls() && watcom.seed() == session->rand().seed() && watcom.calls() == session->rand().calls(), "replayed stale kickoff has no callback, mutation or random draws"); return {settled, uint32_t(game.seed()), watcom.seed(), unsigned(game.calls()), unsigned(watcom.calls())}; } Result start(const std::filesystem::path& data, bool observe) { ui::StartupFlow flow(data); flow.click(150, 215); flow.click(5, 225, true); flow.click(5, 225, true); const auto request = flow.click(90, 169); require(request.request == ui::FlowRequest::new_career, "production new-career request"); std::unique_ptr session; uint64_t revision = 0; openbmh::audio::Playback playback; std::optional audio; std::vector events; std::vector entrant_competitions; const auto exe = load_le(ui::asset_path(data, "BMH.exe")); const auto texts = load_textd(ui::asset_path(data, "TEXTD.BLK")); app::SeasonPresenter season_hook; int national_cup_pauses = 0; if (observe) season_hook = [&](const char* checkpoint, const GameState& state) { if (std::string(checkpoint) == "the German entrants (legacy routine)") { require(events.empty(), "initial German entrants pause precedes the national cup draw"); const auto before = save_stream(state); const auto game_before = session->game(); const auto watcom_before = session->rand(); const auto pages = ui::season_entrants_from_game(state, exe, texts); require(pages.size() == 3 && pages[0].footer == bmh::test::expected_text("season_cup_draw_app_tests-external-3").c_str() && pages[1].footer == bmh::test::expected_text("season_cup_draw_app_tests-external-1").c_str() && pages[2].footer == bmh::test::expected_text("season_cup_draw_app_tests-external-2").c_str(), "initial career exposes the three original competitions in order"); entrant_competitions = {pages[0].competition, pages[1].competition, pages[2].competition}; require(before == save_stream(state) && game_before.seed() == session->game().seed() && game_before.calls() == session->game().calls() && watcom_before.seed() == session->rand().seed() && watcom_before.calls() == session->rand().calls(), "initial entrant projection leaves native state and both RNGs unchanged"); } else { if (std::string(checkpoint) == "the national cup draw (legacy routine)") { require(entrant_competitions == std::vector({0, 1, 2}) && events.size() == 1 && events.front().phase == SeasonCupDrawPhase::draw, "national cup pause follows the original European entrants"); ++national_cup_pauses; } } }; SeasonCupDrawHook hook; if (observe) hook = [&](const GameState& state, const SeasonCupDrawEvent& event) { require(session && event.participants.size() == 64, "initial draw owned field"); require(event.phase == (events.empty() ? SeasonCupDrawPhase::draw : SeasonCupDrawPhase::overview), "initial draw/overview order"); for (unsigned offer = 0; offer < 4; ++offer) { require(state.memory.u32(::bmh::layout::OfferSlots + offer * 4) == 0xffffffffu, "first-round modal follows Source empty-offer boundary"); } const auto before = save_stream(state); const auto game = session->game(); const auto watcom = session->rand(); events.push_back(event); require(before == save_stream(state) && game.seed() == session->game().seed() && game.calls() == session->game().calls() && watcom.seed() == session->rand().seed() && watcom.calls() == session->rand().calls(), "initial presentation leaves state/RNG unchanged"); }; const auto message = app::serve_flow_request(flow, request, session, data, data, 0x1789abcd, revision, playback, audio, false, {}, {}, {}, season_hook, {}, {}, {}, hook); require(message.empty() && session && flow.screen_name() == "desktop", "initial draw reaches first desk"); require_initial_hooks_cleared(*session, "initial presenters are cleared after successful controller start"); if (observe) require(events.size() == 2, "initial cup phases both presented exactly once"); require(observe ? entrant_competitions == std::vector({0, 1, 2}) && national_cup_pauses == 1 : entrant_competitions.empty() && national_cup_pauses == 0, "initial season presenter is scoped to the observed career start"); const auto game = session->game(); const auto watcom = session->rand(); return {save_stream(session->state()), uint32_t(game.seed()), watcom.seed(), unsigned(game.calls()), unsigned(watcom.calls())}; } void throwing_initial_presenter(const std::filesystem::path& data) { ui::StartupFlow flow(data); flow.click(150, 215); flow.click(5, 225, true); flow.click(5, 225, true); const auto request = flow.click(90, 169); require(request.request == ui::FlowRequest::new_career, "throwing-presentation fixture requests a new career"); std::unique_ptr session; uint64_t revision = 0; openbmh::audio::Playback playback; std::optional audio; bool installed_inside_callback = false; app::SeasonPresenter season_hook = [&](const char* checkpoint, const GameState&) { require(std::string(checkpoint) == "the German entrants (legacy routine)", "throwing fixture reaches the original German entrants checkpoint"); const auto driver = session->manager_join_checkpoint().driver; installed_inside_callback = bool(driver.season_pause) && bool(driver.season_cup_draw); throw std::runtime_error("initial presenter sentinel"); }; SeasonCupDrawHook cup_hook = [](const GameState&, const SeasonCupDrawEvent&) {}; bool caught = false; try { (void)app::serve_flow_request(flow, request, session, data, data, 0x1789abcd, revision, playback, audio, false, {}, {}, {}, season_hook, {}, {}, {}, cup_hook); } catch (const std::runtime_error& e) { caught = std::string(e.what()) == "initial presenter sentinel"; } require(caught && installed_inside_callback, "initial presenter exception propagates after both hooks were installed"); require_initial_hooks_cleared(*session, "initial presenters are cleared while unwinding the controller"); } void same(const Result& a, const Result& b) { require(a.state == b.state && a.game_seed == b.game_seed && a.watcom_seed == b.watcom_seed && a.game_calls == b.game_calls && a.watcom_calls == b.watcom_calls, "cup presentation preserves full native state and RNG at both entry paths"); } void detail_actions(const std::filesystem::path& data, const std::filesystem::path& input) { app::CareerSession session(data, 1, input); const auto exe = load_le(data / "BMH.exe"); const auto range = squad_range(4); // the real runtime club, not the active manager size_t row = 0; while (row < range.count && (session.state().squad_slots.at(range.first + row) & 0x0fff) == 0x0fff) ++row; require(row < range.count, "native detail fixture has a real player"); const int player = session.state().squad_slots[range.first + row] & 0x0fff; const ClubPlayerDetailSelection selection{4, player, int(row), int(row), -1}; const auto native = save_stream(session.state()); auto expected_game = session.game(); auto expected_rand = session.rand(); const auto expected = club_player_detail_redraw(session.state(), selection, exe, expected_game, expected_rand); std::string error; const auto actual = session.redraw_club_player_detail(selection, error); require(actual.has_value() && error.empty() && actual->context.selection.player_id == player && actual->portrait_base == expected.portrait_base && actual->portrait_features == expected.portrait_features && actual->market_value == expected.market_value && native == save_stream(session.state()), "session action uses the requested runtime player and leaves native tables unchanged"); require(session.game().seed() == expected_game.seed() && session.game().calls() == expected_game.calls() && session.rand().seed() == expected_rand.seed() && session.rand().calls() == expected_rand.calls(), "one real card redraw commits exactly the Source Core RNG action"); auto stale = selection; stale.player_id = -1; require(!session.redraw_club_player_detail(stale, error) && !error.empty() && native == save_stream(session.state()) && session.game().seed() == expected_game.seed() && session.game().calls() == expected_game.calls() && session.rand().seed() == expected_rand.seed() && session.rand().calls() == expected_rand.calls(), "invalid card identity leaves live native state and RNG intact"); require(!session.dispatch_club_player_national_action(selection, error) && !error.empty() && native == save_stream(session.state()) && session.rand().seed() == expected_rand.seed() && session.rand().calls() == expected_rand.calls(), "unavailable national action rejects without native writes or RNG"); } } int main(int argc, char** argv) { if (argc != 3) return 2; if (!*argv[1]) { std::puts("Cup app tests skipped: Original data not configured"); return 77; } try { const auto plain = advance(argv[1], argv[2], false); const auto observed = advance(argv[1], argv[2], true); require(plain.state == observed.state && plain.game_seed == observed.game_seed && plain.watcom_seed == observed.watcom_seed && plain.game_calls == observed.game_calls && plain.watcom_calls == observed.watcom_calls, "observer preserves the full transition and RNG order"); same(start(argv[1], false), start(argv[1], true)); throwing_initial_presenter(argv[1]); detail_actions(argv[1], argv[2]); std::puts("Production cup bridge, full-state/RNG neutrality and replay OK"); } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; } // SDL2main renames main to SDL_main, which has no implicit "return 0" return 0; }