#include "../../tests/runtime_fixture_tables.hpp" // SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "../../tests/test_inputs.hpp" #include "ui/flow.hpp" #include #include #include #include #include #include #include #include #include "formats/fbm.hpp" #include "formats/savestate.hpp" #include "formats/vga.hpp" #include "game/messages.hpp" #include "game/matchday_setup.hpp" #include "game/save.hpp" #include "game/state.hpp" #include "game/turn_driver.hpp" #include "ui/calendar_state.hpp" #include "ui/strengths_state.hpp" #include "ui/desk_records.hpp" #include "ui/desk_drawers.hpp" 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& action) { static int index = 0; ++index; try { action(); } catch (const FormatError&) { return; } throw std::runtime_error("expected rejected action #" + std::to_string(index)); } void write16(Bytes& b, size_t at, uint16_t value) { b.at(at) = uint8_t(value); b.at(at + 1) = uint8_t(value >> 8); } void write32(Bytes& b, size_t at, uint32_t value) { write16(b, at, uint16_t(value)); write16(b, at + 2, uint16_t(value >> 16)); } int calendar_rng_draws = 0; void count_calendar_rng_draw(int) { ++calendar_rng_draws; } void paired_closing_selection() { DeskState state;state.runtime_club=29;state.next_opponent=-1; state.items={{40,69,22,42,42,66,0,0,true,false}, {41,213,22,42,42,67,0,0,true,false}}; check(source_drawer_team(state,16)==29 && !source_drawer_team(state,17), "Source closing drawers keep own badge first and no-opponent computer second"); } void paired_selection_matrix(const LeImage& exe) { const std::array table{3,4,11,12,16,17,20,21}; for(size_t i=0;i=2. const int mask=shape<4?shape:3; state.items.push_back({1,0,0,42,42,table[pair*2]+50,0,0,bool(mask&1),shape==4}); state.items.push_back({2,50,0,42,42,table[pair*2+1]+50,0,0,bool(mask&2),shape==4}); if(shape==5)state.items.push_back(state.items[0]); int source_count=0; if(gate && rival!=-1)for(const auto& item:state.items)if(item.open) { for(size_t i=0;i{source_first}) && source_drawer_team(state,table[pair*2+1])== (source21<0?std::nullopt:std::optional{source21}), "all four pairs follow Source count/gate/opponent/open/disabled rules"); } } DeskState unknown;unknown.runtime_club=12;unknown.paired_drawers_away_order=true; unknown.items={{1,0,0,42,42,66,0,0,true,false},{2,50,0,42,42,67,0,0,true,false}}; check(source_drawer_team(unknown,16)==12 && !source_drawer_team(unknown,17), "unknown opponent does not become a guessed away-side swap"); } void paired_saved_projection(const std::filesystem::path& path,const LeImage& exe) { const auto fbm=load_savegame(path);check(fbm.checksum_ok,"real closing fixture checksum"); const auto original=GameState::from_save(SaveState(fbm.stream)); check(original.date==1461 && original.manager_teams==std::vector{29},"actual SIM/Bayern closing context"); const std::vector groups; for(int option:{0,1})for(int away:{0,1}) { auto g=original;g.memory.set8(::bmh::layout::DeskState_FormatError_RuntimeField2,uint8_t(option));g.manager_records.at(0x28a)=uint8_t(away); const auto native=save_stream(g);const bool expected=option==0 && away!=0; const auto saved=desk_from_save(SaveState(native),exe,1); const DeskMatchCallargs closing{32,-1}; const auto live=desk_from_game(g,exe,1,&groups,32,&closing); check(saved.paired_drawers_away_order==expected && live.paired_drawers_away_order==expected && !live.next_match_away,"saved/raw pair gate is independent of absent closing match labels"); check(source_drawer_team(live,16)==29 && !source_drawer_team(live,17), "real closing badge remains own first for every option/raw-away combination"); const DeskMatchCallargs match{34,13}; const auto matched=desk_from_game(g,exe,1,&groups,34,&match); check(matched.paired_drawers_away_order==expected && matched.next_match_away==bool(away), "pair setting does not change actual match-label home/away semantics"); check(save_stream(g)==native,"all Source gate projections preserve the complete Native state"); } auto g=original;g.memory.set8(::bmh::layout::DeskState_FormatError_RuntimeField2,0);g.manager_records.at(0x28a)=1; const DeskMatchCallargs match{34,13}; const auto both=desk_from_game(g,exe,1,&groups,34,&match); check(source_drawer_team(both,16)==13 && source_drawer_team(both,17)==29, "genuine away pair with two visible open badges reverses exactly once"); const auto first=std::find_if(both.items.begin(),both.items.end(),[](const auto& i){return i.kind==66;}); check(first!=both.items.end() && first->open,"real first badge exists and is open"); const uint32_t at=::bmh::layout::Desktops+uint32_t(first->id)*16; auto hidden=g;hidden.memory.set16(at,uint16_t(hidden.memory.u16(at)|0x1000)); const auto hidden_desk=desk_from_game(hidden,exe,1,&groups,34,&match); check(std::none_of(hidden_desk.items.begin(),hidden_desk.items.end(),[](const auto& i){return i.kind==66;}) && source_drawer_team(hidden_desk,17)==13,"native hidden badge is omitted before Source pair counting"); auto collapsed=g;collapsed.memory.set8(at+13,uint8_t(collapsed.memory.u8(at+13)&0x7f)); const auto collapsed_desk=desk_from_game(collapsed,exe,1,&groups,34,&match); check(source_drawer_team(collapsed_desk,17)==13,"native collapsed first badge leaves count1, not count2"); } GameState fixture() { GameState g; for (auto [address, size] : std::vector>{{::bmh::layout::CareerDuration,1},{::bmh::layout::GameMode,1},{::bmh::layout::ManagerCount,1}, {::bmh::layout::CompetitionSelection,4},{::bmh::layout::ActiveManager,1},{::bmh::layout::CareerSession_Save_RuntimeField,4},{::bmh::layout::LeaguePresentationOptions,0xb4},{::bmh::layout::FundBlock,0xa8},{::bmh::layout::Loans,0x1e0},{::bmh::layout::Desktops,0x10e0}, {::bmh::layout::Difficulty,1},{::bmh::layout::CalendarDay,4},{::bmh::layout::CoachActive,1},{::bmh::layout::CareerSession_AnyOf_ExecutableField,10},{::bmh::layout::ClubShortNameOffsets,512}, {::bmh::layout::Coupon,0x14},{::bmh::layout::CareerSession_DispatchToto_RuntimeField,1},{::bmh::layout::DeskRecords_Teams_RuntimeField,138*2}}) g.memory.add_block(address, size); g.memory.set8(::bmh::layout::CareerDuration,5); g.memory.set8(::bmh::layout::GameMode,3); g.memory.set8(::bmh::layout::ManagerCount,1); g.memory.set32(::bmh::layout::CompetitionSelection,1); g.level = 2; g.memory.set8(::bmh::layout::Difficulty,9); // typed level intentionally differs from stale memory copy g.memory.set32(::bmh::layout::CareerSession_Save_RuntimeField,0x12345678); g.manager_teams = {12}; g.manager_records.resize(5 * 0xb0c); const std::string name = "Nobody"; std::copy(name.begin(), name.end(), g.manager_records.begin() + 0xa8); write16(g.manager_records,0x290,2); // authoritative runtime club comes from manager_teams g.club_ids.resize(419); std::iota(g.club_ids.begin(),g.club_ids.end(),0); g.club_names.resize(419,0); std::copy_n("UNITFC",6,g.club_names.begin()+12); g.club_names[18]=0; g.club_heap_78.resize(419 * 2); g.stocks.resize(0x450); g.manager_options.resize(20); g.league_rounds.resize(9); g.squad_slots.resize(3096,0x0fff); g.players.resize(24); g.team_morale.resize(419,25); g.player_cards.resize(24); g.player_bonus.resize(24); g.player_name_offsets.resize(24,0); g.player_names={'P','L','A','Y','E','R',0}; g.tactics.resize(0x2940); g.formations.resize(0x160); for (int row = 0; row < 24; ++row) { g.squad_slots.at(12 * 24 + row) = uint16_t(row | (row < 11 ? 0x8000 : row < 16 ? 0x4000 : 0)); g.players[row].w35c = 50 | (90 << 7) | (90 << 14); g.tactics.at(size_t(row) * 0x58 + 0x0c) = 4; } // Layout: calendar, lineup, training, tactics, kickoff; no screen coordinates in controller code. const std::array kinds = {58,3,16,18,12}; g.memory.set8(::bmh::layout::Desktops + 5,1); for (int i = 0; i < 5; ++i) { const auto at = ::bmh::layout::DesktopsUnsigned + uint32_t(i + 1) * 16; g.memory.set16(at,uint16_t(i == 0 ? 4 : i * 40)); g.memory.set8(at + 2,uint8_t(i == 0 ? 22 : 120)); g.memory.set8(at + 3,uint8_t(i == 0 ? 61 : 32)); g.memory.set8(at + 4,uint8_t(i == 0 ? 62 : 25)); g.memory.set8(at + 5,uint8_t(i == 4 ? 0 : i + 2)); g.memory.set8(at + 12,uint8_t(kinds[i])); g.memory.set8(at + 13,uint8_t(i == 0 ? 0x80 : 0)); } return g; } GameState calendar_fixture(const LeImage& exe, uint32_t season_start, uint32_t day_offset) { auto game = fixture(); game.season_start = season_start; game.date = season_start + day_offset; game.season = 0; game.memory.add_block(::bmh::layout::CalendarState_FormatError_RuntimeField3, 2); game.memory.set16(::bmh::layout::CalendarState_FormatError_RuntimeField3, uint16_t(season_start)); game.memory.add_block(::bmh::layout::DaysIntoSeason, 2); game.memory.set16(::bmh::layout::DaysIntoSeason, uint16_t(day_offset)); game.memory.add_block(::bmh::layout::CompetitionCalendar, 366 * 2); game.memory.add_block(::bmh::layout::CalendarState_FormatError_RuntimeField2, 1); game.memory.add_block(::bmh::layout::CalendarState_FormatError_RuntimeField, 1); game.memory.set8(::bmh::layout::CalendarState_FormatError_RuntimeField2, 0); game.memory.set8(::bmh::layout::CalendarState_FormatError_RuntimeField, 0); for (int league = 0; league < 9; ++league) check(exe.u8(::bmh::layout::LeagueCalendarBits + uint32_t(league)) <= 31,"league calendar class fits Source bitmap"); return game; } void calendar_projection_tests(const LeImage& exe) { auto regular = calendar_fixture(exe, 0, 364); regular.memory.set16(::bmh::layout::CompetitionCalendar, uint16_t(1u << exe.u8(::bmh::layout::LeagueCalendarBits))); regular.memory.set16(::bmh::layout::CompetitionCalendar + 4, uint16_t(1u << exe.u8(::bmh::layout::LeagueCalendarBits))); regular.memory.set16(::bmh::layout::CompetitionCalendar + 6, uint16_t(1u << exe.u8(::bmh::layout::FixtureCalendarSecondLeagueBit))); const Bytes before_native = save_stream(regular); GameRandom game_rng(1234); WatcomRandom watcom_rng(5678); const auto game_seed = game_rng.seed(); const auto game_calls = game_rng.calls(); const auto watcom_seed = watcom_rng.seed(); const auto watcom_calls = watcom_rng.calls(); calendar_rng_draws = 0; auto previous_hook = draw_hook; draw_hook = count_calendar_rng_draw; const auto state = calendar_from_game(regular,exe); draw_hook = previous_hook; check(state.days.size() == 365 && state.current_day == 364 && state.days.back().current_day, "regular season ends at June 30 with its final day included"); check(state.days[0].date.month == 7 && state.days[0].date.day == 1 && state.days[364].date.month == 6 && state.days[364].date.day == 30, "calendar rows use the Source July-to-June date conversion"); check(state.days[0].league_matchdays[0] == 1 && state.days[1].league_matchdays[0] == 0 && state.days[2].league_matchdays[0] == 2, "league matchday ordinals count effective Source class bits inclusively"); check(state.days[0].raw_entry == uint16_t(1u << exe.u8(::bmh::layout::LeagueCalendarBits)) && state.days[0].competitions == (1u << exe.u8(::bmh::layout::LeagueCalendarBits)), "projection preserves the saved calendar word and its effective competition bitmap"); check(calendar_rng_draws == 0 && game_rng.seed() == game_seed && game_rng.calls() == game_calls && watcom_rng.seed() == watcom_seed && watcom_rng.calls() == watcom_calls && save_stream(regular) == before_native, "calendar projection leaves the complete serialized native state and RNG untouched"); // legacy routine starts native calendar word zero on the first Wednesday, while // legacy routine draws from July 1. The two leading display cells have no word. auto first_wednesday = calendar_fixture(exe,1463,262); first_wednesday.memory.set16(::bmh::layout::CompetitionCalendar + 262 * 2, uint16_t(1u << exe.u8(::bmh::layout::LeagueCalendarBits))); const auto wednesday_state = calendar_from_game(first_wednesday,exe); check(wednesday_state.leading_days == 2 && wednesday_state.current_day == 264 && wednesday_state.season_start_counter == 1461, "cold-loaded first-Wednesday season keeps display and native cursors distinct"); check(wednesday_state.days[0].date.month == 7 && wednesday_state.days[0].date.day == 1 && wednesday_state.days[0].season_day == -2 && wednesday_state.days[0].raw_entry == 0 && wednesday_state.days[2].date.day == 3 && wednesday_state.days[2].season_day == 0 && wednesday_state.days[264].date.month == 3 && wednesday_state.days[264].date.day == 22 && wednesday_state.days[264].season_day == 262 && wednesday_state.days[264].current_day && wednesday_state.days[264].raw_entry == uint16_t(1u << exe.u8(::bmh::layout::LeagueCalendarBits)), "native day 262 maps to displayed March 22 after two empty July cells"); auto marked = calendar_fixture(exe,0,0); marked.memory.set16(::bmh::layout::CompetitionCalendar,uint16_t(0x8001)); const auto marked_state = calendar_from_game(marked,exe); check(marked_state.days[0].raw_entry == 0x8001 && marked_state.days[0].competitions == 1, "saved high marker remains in raw word while the effective bitmap follows Source masking"); auto leap = calendar_fixture(exe,365,365); leap.date = leap.season_start + 365; const auto leap_state = calendar_from_game(leap,exe); check(leap_state.days.size() == 366 && leap_state.current_day == 365 && leap_state.days.back().season_day == 365 && leap_state.days.back().date.month == 6 && leap_state.days.back().date.day == 30 && leap_state.days.back().current_day, "leap season includes valid June 30 at season index 365"); for (int season = 0; season < 4; ++season) { auto rotated = calendar_fixture(exe,0,0); rotated.season = season; rotated.memory.set16(::bmh::layout::CompetitionCalendar,0x1e00); const auto rotated_state = calendar_from_game(rotated,exe); const uint32_t expected = uint32_t(1) << (12 - season); check(rotated_state.days[0].competitions == expected, "rotating calendar competition follows the four-season Source cycle"); } auto one_rotation_bit = calendar_fixture(exe,0,0); one_rotation_bit.memory.set16(::bmh::layout::CompetitionCalendar,0x0200); auto one_rotation_state = calendar_from_game(one_rotation_bit,exe); check(one_rotation_state.days[0].competitions == 0, "a single rotation bit is absent when the current season selects another class"); one_rotation_bit.season = 3; one_rotation_state = calendar_from_game(one_rotation_bit,exe); check(one_rotation_state.days[0].competitions == 0x0200, "the same rotation bit appears in its selected Source season"); auto all_leagues = calendar_fixture(exe,0,0); all_leagues.memory.set8(::bmh::layout::CompetitionSelection,3); for (int league = 0; league < 9; ++league) { const uint32_t mask = uint32_t(1) << exe.u8(::bmh::layout::LeagueCalendarBits + uint32_t(league)); uint16_t raw = 0; bool found = false; for (uint32_t candidate = 0; candidate <= 0xffff; ++candidate) { const auto word = uint16_t(candidate); if (day_competitions(all_leagues,word) == mask) { raw = word; found = true; break; } } check(found,"each executable league class has a representable calendar entry"); all_leagues.memory.set16(::bmh::layout::CompetitionCalendar + uint32_t(league) * 2,raw); } const auto all_league_state = calendar_from_game(all_leagues,exe); for (int league = 0; league < 9; ++league) { const uint32_t mask = uint32_t(1) << exe.u8(::bmh::layout::LeagueCalendarBits + uint32_t(league)); int inclusive_ordinal = 0; for (int day = 0; day < 9; ++day) { const uint16_t raw = all_leagues.memory.u16(::bmh::layout::CompetitionCalendar + uint32_t(day) * 2); const bool plays = (day_competitions(all_leagues,raw) & mask) != 0; if (plays) ++inclusive_ordinal; check(all_league_state.days[size_t(day)].league_matchdays[size_t(league)] == (plays ? inclusive_ordinal : 0), "each league ordinal is the inclusive count of its class through a playing day"); } } auto specials = calendar_fixture(exe,0,0); specials.memory.set16(::bmh::layout::CompetitionCalendar,0x4001); specials.memory.set16(::bmh::layout::CompetitionCalendar+2,0x4002); specials.memory.set16(::bmh::layout::CompetitionCalendar+4,0x4004); specials.memory.set16(::bmh::layout::CompetitionCalendar+6,0x4006); auto special_state = calendar_from_game(specials,exe); check(special_state.days[0].competitions == 0x8000 && special_state.days[1].competitions == 0x10000 && special_state.days[2].competitions == 0x40000 && special_state.days[3].competitions == 0, "special calendar words preserve Source masks and disable tournament without its flag"); specials.memory.set8(::bmh::layout::CompetitionSelection,3); special_state = calendar_from_game(specials,exe); check(special_state.days[3].competitions == 0x800000, "0x4006 tournament entry is effective only when the saved tournament flag is set"); specials.memory.set8(::bmh::layout::CalendarState_FormatError_RuntimeField,1); special_state = calendar_from_game(specials,exe); check(special_state.days[1].competitions == 0, "saved special-event disable flag is applied by the Source competition projection"); auto filtered = calendar_fixture(exe,0,0); filtered.memory.set16(::bmh::layout::CompetitionCalendar,0x8010); auto filtered_state = calendar_from_game(filtered,exe); check(filtered_state.days[0].raw_entry == 0x8010 && filtered_state.days[0].competitions == 0x10, "calendar raw high marker is retained while effective flags omit that marker"); filtered.memory.set8(::bmh::layout::CalendarState_FormatError_RuntimeField2,1); filtered_state = calendar_from_game(filtered,exe); check(filtered_state.days[0].raw_entry == 0x8010 && filtered_state.days[0].competitions == 0, "saved calendar mask 0xa2594 clears effective bit 0x10"); auto malformed = calendar_fixture(exe,0,0); malformed.memory.set16(::bmh::layout::CalendarState_FormatError_RuntimeField3,1); rejected([&]{ calendar_from_game(malformed,exe); }); auto outside = calendar_fixture(exe,0,0); outside.date = 365; rejected([&]{ calendar_from_game(outside,exe); }); auto missing = fixture(); rejected([&]{ calendar_from_game(missing,exe); }); auto present_table = calendar_fixture(exe,0,0); LeImage missing_executable; rejected([&]{ calendar_from_game(present_table,missing_executable); }); } void source_sort_reference(std::vector>& rows, size_t begin, size_t count, bool ascending) { if (count <= 1) return; std::ptrdiff_t left = -1, right = std::ptrdiff_t(count); const uint32_t pivot = rows[begin + count / 2].first; for (;;) { if (!ascending) { do { ++left; } while (pivot < rows[begin + size_t(left)].first); do { --right; } while (rows[begin + size_t(right)].first < pivot); } else { do { ++left; } while (rows[begin + size_t(left)].first < pivot); do { --right; } while (pivot < rows[begin + size_t(right)].first); } if (right <= left) break; std::swap(rows[begin + size_t(left)], rows[begin + size_t(right)]); } source_sort_reference(rows, begin, size_t(left), ascending); source_sort_reference(rows, begin + size_t(left), count - size_t(left), ascending); } void strengths_projection_tests() { const auto none = strengths_draw_words_source(0x0000); check(none.raw_settings_word == 0 && none.row_settings_word == 0x00ff && none.effective_average_flags == 0x00ff && none.post_draw_settings_word == 0x01ff, "Strengths defaults row criteria and normalizes the persisted word after the draw"); const auto full = strengths_draw_words_source(0x00ff); check(full.row_settings_word == 0x00ff && full.post_draw_settings_word == 0x01ff, "all eight filters set saved word bit 8 without changing row calculation flags"); const auto header = strengths_draw_words_source(0x8000); check(header.effective_average_flags == 0x01ff && header.post_draw_settings_word == 0x81ff, "post-draw high-byte mask preserves Source header bit 15 before the zero-word default"); const auto age_draw = strengths_draw_words_source(0x0200); check(age_draw.row_settings_word == 0x00ff && age_draw.post_draw_settings_word == 0x0200, "age-sort word is retained by the Source 0xf2 high-byte mask"); check(strengths_control_word_source(0x00ff, StrengthsControl::condition) == 0x00fe, "filter control toggles its exact bit from normalized settings"); check(strengths_control_word_source(0x01ff, StrengthsControl::condition) == 0x00fe, "a changed filter clears Source's line-up bit unless the full low nine bits remain set"); check(!strengths_control_word_source(0x02ff, StrengthsControl::condition), "Source locks the eight filters while age sorting is active"); check(strengths_control_word_source(0x02ff, StrengthsControl::age) == 0x0000, "age control applies Source high-byte mask and toggle"); check(strengths_control_word_source(0x8000, StrengthsControl::lineup) == 0x0000, "line-up header control toggles word bit 15"); check(strengths_control_word_source(0x2200, StrengthsControl::reset) == 0x01ff, "zero-value control writes the full Source 0x1ff word"); check(strengths_family_word_source(0xffff, 0) == 0xfd7f && strengths_family_word_source(0xffff, 1) == 0xfdff, "family entry preserves Source 0xfc0f bits and sets values from points mode"); auto game = fixture(); game.memory.add_block(::bmh::layout::ManagerSettings, 10); game.memory.add_block(::bmh::layout::DeskPosition, 1); game.manager_records[0xa8] = 'A'; game.manager_teams[0] = 12; game.memory.set16(::bmh::layout::ManagerSettings, 0x8000); game.memory.set8(::bmh::layout::ActiveManager, 0); game.memory.set8(::bmh::layout::DeskPosition, 0); for (size_t i = 0; i < game.players.size(); ++i) game.players[i].w364 = (uint32_t(i % 24) << 21) | (i == 0 ? 0x00010000u : 0); constexpr std::array foreign_titles{"ENGLAND", "ITALY", "SPAIN", "FRANCE"}; for (size_t i = 0; i < foreign_titles.size(); ++i) { const size_t title_team = size_t(0x166) + i; const size_t title_offset = 300 + i * 16; game.club_ids[title_team] = uint16_t(title_offset); std::copy(foreign_titles[i].begin(), foreign_titles[i].end(), game.club_names.begin() + std::ptrdiff_t(title_offset)); game.club_names[title_offset + foreign_titles[i].size()] = 0; } static TextDb texts; if (texts.strings.empty()) texts.strings.resize(TEXT_COUNT); texts.strings.at((::bmh::layout::Achievements_FormatError_TextPointer3 - ::bmh::layout::TextPointerTable) / 4) = "League"; texts.strings.at((::bmh::layout::Manager_FormatError_TextPointer2 - ::bmh::layout::TextPointerTable) / 4) = " "; game.texts = &texts; const Bytes before = save_stream(game); calendar_rng_draws = 0; auto previous_hook = draw_hook; draw_hook = count_calendar_rng_draw; const auto projection = strengths_from_game(game, 0, 0); draw_hook = previous_hook; check(projection.rows.size() == 18 && projection.first_team == 0 && projection.manager_slot == 0 && projection.age_scratch.basis == StrengthsAgeBasis::entry_or_league_change_bit10 && !projection.age_scratch.lineup_only, "league zero projects its exact eighteen teams and uses raw bit 10 on entry"); check(projection.rows.front().runtime_team == 12 && projection.rows.front().team_name == "UNITFC" && projection.rows.front().name_color == 0x7a, "league projection carries save-remapped name and Source active-manager color"); check(projection.rows.front().criterion_values == std::array{90,90,50,50} && projection.rows.front().aggregate_value == 90, "strength columns and aggregate honor the Source eleven-player lineup divisor"); check(projection.age_scratch.tenths.at(12) == 115, "Source age scratch averages all squad slots in byte tenths with integer truncation"); check(save_stream(game) == before, "Strengths projection leaves the complete serialized game state unchanged"); check(calendar_rng_draws == 0, "domestic Strengths projection does not call the random draw hook"); auto high_identity = game; high_identity.manager_records[0xa8] = 0; high_identity.manager_teams[0] = 0x0100; const auto high_identity_projection = strengths_from_game(high_identity, 0, 0); const auto low_byte_alias = std::find_if(high_identity_projection.rows.begin(), high_identity_projection.rows.end(), [](const StrengthsRow& row){ return row.runtime_team == 0; }); check(low_byte_alias != high_identity_projection.rows.end() && low_byte_alias->name_color == 0x5f, "Source current-club name highlight compares the complete 16-bit team identity"); auto fallback_color = game; fallback_color.manager_records[0xa8] = 0; const auto fallback_projection = strengths_from_game(fallback_color, 0, 0); const auto active_team_row = std::find_if(fallback_projection.rows.begin(), fallback_projection.rows.end(), [](const StrengthsRow& row){ return row.runtime_team == 12; }); check(active_team_row != fallback_projection.rows.end() && active_team_row->name_color == 0xf7, "Source favorite-club fallback uses the active manager's complete runtime team ID"); const auto header_age = strengths_from_game(game, 0, 0, StrengthsProjectionContext{std::nullopt, StrengthsAgeBasis::header_toggle_bit15}); check(header_age.age_scratch.lineup_only && header_age.age_scratch.tenths.at(12) == 50, "header-toggle age scratch uses bit 15 and only the eleven starting players"); StrengthsProjectionContext cached_context{projection.age_scratch, StrengthsAgeBasis::entry_or_league_change_bit10}; const auto cached = strengths_from_game(game, 0, 0, cached_context); check(cached.age_scratch.basis == StrengthsAgeBasis::entry_or_league_change_bit10 && cached.age_scratch.tenths == projection.age_scratch.tenths, "same-league redraw retains the original age-source basis and cached bytes"); auto stale_context = cached_context; stale_context.cached_age->tenths[12]++; rejected([&]{ strengths_from_game(game, 0, 0, stale_context); }); auto hole = game; const size_t squad = squad_range(12).first; hole.squad_slots[squad + 2] = kEmptySlot; const auto hole_projection = strengths_from_game(hole, 0, 0); check(hole_projection.age_scratch.tenths.at(12) == 5, "age scratch stops at the first empty slot rather than counting later squad entries"); auto byte_wrap = game; for (size_t i = 0; i < byte_wrap.players.size(); ++i) byte_wrap.players[i].w364 = 31u << 21; const auto wrapped_age = strengths_from_game(byte_wrap, 0, 0); check(wrapped_age.age_scratch.tenths.at(12) == uint8_t(310), "age scratch preserves Source byte narrowing after the tenths division"); auto empty = game; for (size_t i = 0; i < squad_range(12).count; ++i) empty.squad_slots[squad + i] = kEmptySlot; const auto empty_projection = strengths_from_game(empty, 0, 0); check(empty_projection.age_scratch.tenths.at(12) == 0x22, "clubs with no qualifying players preserve Source age sentinel 0x22"); for (int league = 0; league < 9; ++league) { const int expected_first = league < 5 ? league * 18 : 90 + (league - 5) * 12; const int expected_count = league < 5 ? 18 : 12; const auto rows = strengths_from_game(game, 0, league); check(rows.first_team == expected_first && rows.rows.size() == size_t(expected_count), "each of the nine Source domestic league bounds is exact"); if (league >= 5) check(rows.league_name == iso646de_to_utf8( game.club_name(0x165 + league - 4).c_str()), "foreign league title comes from its saved country-club name, not domestic TEXTD"); } auto foreign_without_textd = game; foreign_without_textd.texts = nullptr; check(strengths_from_game(foreign_without_textd, 0, 5).league_name == "ENGLAND", "foreign league projection does not index the domestic league-name table"); rejected([&]{ strengths_from_game(game, 0, -1); }); rejected([&]{ strengths_from_game(game, 0, 9); }); rejected([&]{ strengths_from_game(game, 5, 0); }); rejected([&]{ strengths_from_game(GameState{}, 0, 0); }); auto five_managers = game; five_managers.memory.set8(::bmh::layout::ManagerCount, 5); rejected([&]{ strengths_from_game(five_managers, 0, 0); }); auto invalid_basis = StrengthsProjectionContext{ std::nullopt, static_cast(0xff)}; rejected([&]{ strengths_from_game(game, 0, 0, invalid_basis); }); auto no_morale = game; no_morale.team_morale.clear(); rejected([&]{ strengths_from_game(no_morale, 0, 0); }); auto age_sorted_game = game; age_sorted_game.memory.set16(::bmh::layout::ManagerSettings, 0x8200); const auto age_sorted = strengths_from_game(age_sorted_game, 0, 0); std::vector> two_equal{{5, 10}, {5, 11}}; source_sort_reference(two_equal, 0, two_equal.size(), true); check(two_equal[0].second == 11 && two_equal[1].second == 10, "literal Source quicksort swaps a two-element equal-key pair"); std::vector> expected; for (int team = 0; team < 18; ++team) { const auto row = std::find_if(age_sorted.rows.begin(), age_sorted.rows.end(), [team](const StrengthsRow& r){ return r.runtime_team == team; }); check(row != age_sorted.rows.end(), "age-sort rows retain every source team"); expected.emplace_back(row->source_sort_key, team); } source_sort_reference(expected, 0, expected.size(), true); for (size_t i = 0; i < expected.size(); ++i) check(age_sorted.rows[i].runtime_team == expected[i].second, "age ordering matches the independent literal Source quicksort including ties"); auto all_equal_game = game; all_equal_game.memory.set16(::bmh::layout::ManagerSettings, 0x8000); for (int team = 0; team < 18; ++team) { const SquadRange range = squad_range(team); for (size_t slot = 0; slot < range.count; ++slot) all_equal_game.squad_slots[range.first + slot] = kEmptySlot; } const auto all_equal = strengths_from_game(all_equal_game, 0, 0); constexpr std::array source_equal_order{ 11,12,9,10,16,17,13,15,14,2,3,0,1,7,8,4,6,5 }; for (size_t index = 0; index < all_equal.rows.size(); ++index) check(all_equal.rows[index].runtime_team == source_equal_order[index], "Source quicksort follows its exact recursive 18-row equal-key order"); } void begin(StartupFlow& flow) { flow.click(150,215); flow.click(5,225,true); flow.click(5,225,true); check(flow.click(90,169).request == FlowRequest::new_career,"one career request"); } void confirm_managers(StartupFlow& flow, int count, bool national = false) { if (national) flow.click(95,215); // league off; world remains enabled, one manager only else flow.click(150,215); // world off for (int i = 1; i < count; ++i) flow.click(260,135); flow.click(5,225,true); for (int i = 0; i < count; ++i) { flow.click(5,225,true); const auto result = flow.click(90,169); if (i + 1 < count) { check(result.request == FlowRequest::manager_confirmed,"manager selection awaits the next club order"); SelectionContext context; context.revision = uint64_t(i + 1); context.source = "test_fixture"; context.club_order.resize(168); std::iota(context.club_order.begin(),context.club_order.end(),0); flow.resume_manager_selection(context); } else check(result.request == FlowRequest::new_career,"last manager confirms career request"); } } GameState career_game(const LeImage& exe, const NewCareerRequest& request, bool national = false) { auto game = fixture(); const auto count = request.managers.size(); game.memory.set8(::bmh::layout::ManagerCount,uint8_t(count)); game.memory.set32(::bmh::layout::CompetitionSelection,national ? 2 : (request.options.league ? 1 : 0) | (request.options.world ? 2 : 0)); game.manager_teams.resize(count); const auto template_record = Bytes(game.manager_records.begin(),game.manager_records.begin()+0xb0c); for(size_t i=0;i(25,choice.name.size()),game.manager_records.begin()+base+0xa8); game.manager_records[base+0x210]=uint8_t(choice.start_league); game.manager_records[base+0x221]=uint8_t(choice.portrait); write16(game.manager_records,base+0x290,uint16_t(game.manager_teams[i])); } game.memory.set8(::bmh::layout::ActiveManager,0); return game; } void set_preparation_revision_source(PreparationState& state, uint64_t revision, const std::string& source) { state.desktop.revision=revision; state.desktop.source=source; state.lineup.revision=state.tactics.revision=revision; state.lineup.source=state.tactics.source=source; if(state.training){state.training->revision=revision;state.training->source=source;} if(state.training_camp){state.training_camp->revision=revision;state.training_camp->source=source;} if(state.bank){state.bank->revision=revision;state.bank->source=source;} if(state.stadium){state.stadium->revision=revision;state.stadium->source=source;} if(state.toto){state.toto->revision=revision;state.toto->source=source;} if(state.pitch){state.pitch->revision=revision;state.pitch->source=source;} for(auto& card:state.player_cards){card.lineup.revision=revision;card.lineup.source=source;} } } // namespace int main(int argc, char** argv) { try { paired_closing_selection(); if (argc < 2) throw std::runtime_error("data directory required"); const std::filesystem::path data = argv[1]; const auto exe = bmh::test::load_executable(asset_path(data,"BMH.exe")); paired_selection_matrix(exe); if(argc>3)paired_saved_projection(argv[3],exe); // The date arithmetic is checked against a controlled epoch aligned with // the original leap cycle, independently of the installation's start year. auto oracle_exe = exe; const uint8_t oracle_year[] = {0xea,0x07,0,0}; const uint8_t oracle_weekday = 2; oracle_exe.patch(layout::CalendarDateSetup+13,oracle_year,4); oracle_exe.patch(layout::CalendarDateSetup+4,&oracle_weekday,1); using namespace std::chrono; const sys_days epoch = year{2026}/7/1; for (uint32_t i = 0; i < 1461; ++i) { const auto d = desk_date(i,oracle_exe); const year_month_day oracle(epoch + days{i}); check(d.year == int(oracle.year()) && d.month == int(unsigned(oracle.month())) && d.day == int(unsigned(oracle.day())),"calendar/leap boundary mismatch"); } rejected([&]{ desk_date(0xffff,exe); }); calendar_projection_tests(exe); strengths_projection_tests(); auto g = fixture(); const auto before_records = g.manager_records; const auto before_squads = g.squad_slots; auto d = desk_from_game(g,exe,7); DesktopScreen timed_desk(data,d); const auto deadline=timed_desk.process_timer_expired(); check(deadline.kind==DeskRequestKind::advance_turn&&deadline.manager_slot==d.manager_slot&& deadline.revision==d.revision&&deadline.item_id==-1&&timed_desk.pending()==deadline, "Original deadline owns one typed turn request without a guessed icon hit"); check(timed_desk.process_timer_expired().kind==DeskRequestKind::none, "repeated expired polls cannot duplicate the pending calendar turn"); check(d.options.difficulty == 2 && d.runtime_club == 12 && d.strength == 90,"typed projection / strength"); check(!d.table_position,"table rank stays absent before any league round is recorded"); check(d.warnings[2] == true && d.warnings[5] == false && d.warnings[6] == false,"initial warnings"); check(before_records == g.manager_records && before_squads == g.squad_slots,"projection must be read-only"); check(desk_menu_name(25)=="fair_play"&&desk_menu_name(26)=="highscore", "ordinary menu 25/26 names match their Original desk functions"); auto fair_fixture=fixture(); for(int team=0;team<18;++team) fair_fixture.memory.set16(::bmh::layout::DeskRecords_Teams_RuntimeField+uint32_t(team)*2,uint16_t(team)); fair_fixture.memory.set16(::bmh::layout::DeskRecords_Teams_RuntimeField+uint32_t(4)*2,0); // avoid a tied four-point team in this ordering assertion fair_fixture.memory.set16(::bmh::layout::DeskRecords_Teams_RuntimeField,0x0100); // one red card: four points, after scores 1..3 const auto fair= fair_play_state_from_game(fair_fixture,0,{},0); check(fair.fair_play_rows.size()==18&&fair.fair_play_rows.front().team==4&& fair.fair_play_rows.front().points==0&&fair.fair_play_rows[4].team==0&& fair.fair_play_rows[4].points==4&&fair.fair_play_rows.back().team==17&& fair.fair_play_rows.back().points==17, "legacy routine ascending fair-play ordering uses four points per red card"); auto fair_view=fair;fair_view.underlay=Image(320,240); DeskRecordsScreen fair_screen(data,std::move(fair_view)); check(fair_screen.render().pixels.size()==320u*240u&&!fair_screen.closed(), "menu-25 Original panel renders the full Source league row set"); DeskRecordsState high_view;high_view.kind=DeskRecordKind::highscore;high_view.underlay=Image(320,240); DeskRecordsScreen high_screen(data,std::move(high_view)); check(high_screen.render().pixels.size()==320u*240u&&!high_screen.closed(), "menu-26 uses the five-row highscore presentation, not the game-end calculator"); const auto high_backdrop=high_screen.render(); check(high_screen.key_input("ENTER"),"Source calculator ENTER accepts its value"); while(high_screen.advance_point()) {} check(high_screen.finish_points()&&high_screen.render().pixels!=high_backdrop.pixels, "signature-zero acceptance advances every Original points frame and retains the points image"); check(high_screen.pointer_down(4,4)&&high_screen.closed(), "signature-zero points screen waits for its own mouse-down acknowledgement"); DeskRecordsState ranked_high_view;ranked_high_view.kind=DeskRecordKind::highscore; ranked_high_view.highscore.ranked=true; ranked_high_view.underlay=Image(320,240); DeskRecordsScreen ranked_high_screen(data,std::move(ranked_high_view)); const auto ranked_high_frame=ranked_high_screen.render(); const auto source_ranked_art=load_vga(asset_path(data/"KB","51.VGA")); check(ranked_high_frame.pixels[size_t(50)*size_t(ranked_high_frame.width)+150]== source_ranked_art.pixels[size_t(25)*size_t(source_ranked_art.width)+50], "ranked menu-26 copies Source decimal asset 51 (legacy routine argument 0x33)"); auto menu_game = fixture(); menu_game.memory.set8(::bmh::layout::Desktops + 44 * 16 + 12, 63); // mailbox occurs before the menu shortcut in this scan menu_game.memory.set8(::bmh::layout::Desktops + 53 * 16 + 12, 72); // final compact-bar cell dispatches MEN auto menu_desk = desk_from_game(menu_game, exe, 6); check(menu_desk.mailbox_shortcut && menu_desk.menu_layout_shortcut && menu_desk.menu_layout_shortcut->id == 53, "Source final compact-bar cell resolves record 53/kind 72 independently of linked drawers"); menu_desk.shortcut_bar_always = false; DesktopScreen edge_bar(data, menu_desk); const auto edge_hidden = edge_bar.render(); check(!edge_bar.pointer_move(160, 238), "Source quickbar edge requires exactly y239"); check(edge_bar.pointer_move(160, 239) && edge_bar.render().pixels != edge_hidden.pixels && !edge_bar.pending() && edge_bar.state().layout_records == menu_desk.layout_records, "lower-edge motion shows quickbar without an action or Native layout edits"); const auto edge_shown = edge_bar.render(); const auto quickbar_art = load_vga(asset_path(data / "KB", "3.VGA")); for (int y = 0; y < 20; ++y) for (int x = 0; x < 20; ++x) check(edge_shown.pixels[size_t(207 + y) * 320 + 299 + x] == quickbar_art.pixels[size_t(75 + y) * quickbar_art.width + exe.u8(::bmh::layout::Desktop_Render_RuntimeField3) + x], "visible Source quickbar copies the complete normal socket sprite before any press"); check(!edge_bar.pointer_move(250, 239) && edge_bar.click(250, 239).kind == DeskRequestKind::none && edge_bar.render().pixels == edge_shown.pixels, "motion along edge and click at the same edge do not toggle the Source y latch twice"); check(edge_bar.pointer_move(292, 221), "MEN quickbar cell motion selects its Source hover label"); const auto hover_frame = edge_bar.render(); int hover_pixels = 0; for (int y = 0; y < 240; ++y) for (int x = 0; x < 320; ++x) if (hover_frame.pixels[size_t(y) * 320 + x] != edge_shown.pixels[size_t(y) * 320 + x]) { check(y >= 230 && y <= 235, "Source quickbar label changes only the footer Font3 rows"); ++hover_pixels; } check(hover_pixels > 0 && !edge_bar.pointer_move(291, 221), "Source hover title renders once and stays stable inside the same cell"); check(edge_bar.pointer_move(160, 238) && edge_bar.render().pixels == edge_shown.pixels, "leaving the cell restores the footer without hiding the quickbar"); check(edge_bar.pointer_move(160, 239) && edge_bar.render().pixels == edge_hidden.pixels, "re-entering the lower edge toggles the quickbar off without a click"); auto always_desk = menu_desk; always_desk.shortcut_bar_always = true; DesktopScreen always_bar(data, always_desk); const auto always_frame = always_bar.render(); always_bar.pointer_move(160, 239); always_bar.pointer_move(160, 238); always_bar.pointer_move(160, 239); check(always_bar.render().pixels == always_frame.pixels && !always_bar.pending(), "format field bit1 keeps Always quickbar visible through both bit0 edge transitions"); DesktopScreen menu_bar(data, menu_desk); check(menu_bar.click(292,221).kind == DeskRequestKind::none, "MEN shortcut is unavailable before the original compact bar is shown"); menu_bar.pointer_move(64,239); auto menu_save = menu_bar.click(292,221); check(menu_save.kind == DeskRequestKind::open_menu && menu_save.menu_kind == 53 && menu_save.item_id == 53 && menu_save.value == 1, "compact last-cell left click opens the Original menu-layout save path from record 53"); menu_bar.resolve_local_menu(); auto menu_load = menu_bar.click(292,221,true); check(menu_load.kind == DeskRequestKind::open_menu && menu_load.menu_kind == 53 && menu_load.item_id == 53 && menu_load.value == 0, "compact last-cell right click opens the Original menu-layout load path from record 53"); auto quickbar_drawer = menu_desk; quickbar_drawer.layout_records[50][5]=0xff; quickbar_drawer.layout_records[50][6]=0xff; quickbar_drawer.layout_records[50][12]=50; DesktopScreen quickbar_open(data,quickbar_drawer); quickbar_open.pointer_move(64,239); const auto append_drawer=quickbar_open.click(22,221); check(quickbar_open.take_sound_ids()==std::vector{15} && quickbar_open.take_sound_ids().empty(), "Source drawer append emits ID15 exactly once through the application boundary"); quickbar_open.render(); quickbar_open.pointer_move(23,221); quickbar_open.click(22,221); check(quickbar_open.take_sound_ids().empty(),"render/hover/pending input never replay a drawer sound"); check(append_drawer.kind==DeskRequestKind::change_layout&& append_drawer.layout_operation==DeskLayoutOperation::toggle_quickbar_drawer&& append_drawer.layout_after[50*16+5]==0&&append_drawer.layout_after[50*16+13]&0x80, "Original quickbar LMB appends a hidden drawer record and sets its open bit"); auto quickbar_close_state=menu_desk; quickbar_close_state.layout_records[0][5]=50; quickbar_close_state.layout_records[50][5]=0; quickbar_close_state.layout_records[50][6]=0; quickbar_close_state.layout_records[50][12]=50; DesktopScreen quickbar_close(data,quickbar_close_state); quickbar_close.pointer_move(64,239); const auto unlink_drawer=quickbar_close.click(22,221,true); check(quickbar_close.take_sound_ids()==std::vector{12},"Source drawer unlink emits ID12"); check(unlink_drawer.kind==DeskRequestKind::change_layout&& unlink_drawer.layout_operation==DeskLayoutOperation::toggle_quickbar_drawer&& unlink_drawer.layout_after[0*16+5]==0&&unlink_drawer.layout_after[50*16+5]==0xff&& unlink_drawer.layout_after[50*16+6]==0xff, "Original quickbar RMB unlinks a visible drawer record with cleared links"); auto child_desk=menu_desk; child_desk.layout_records[3][5]=child_desk.layout_records[3][6]=0xff; child_desk.layout_records[3][12]=2; child_desk.layout_records[3][13]=0; child_desk.layout_records[49][12]=50; child_desk.layout_records[49][13]=0x80; child_desk.layout_records[0][5]=49; child_desk.layout_records[49][5]=child_desk.layout_records[49][6]=0; child_desk.folder_icon_slots[0]={3}; child_desk.drawer_handles=true; child_desk.items.push_back(DeskItem{49,40,40,100,65,50,0,0,true,false}); DesktopScreen folder_click(data,child_desk); const auto child_action=folder_click.click(50,49); check(child_action.kind==DeskRequestKind::open_menu&&child_action.item_id==3&&child_action.menu_kind==2, "Source folder child uses its native record/kind on ordinary LMB activation"); DesktopScreen folder_drag(data,child_desk); folder_drag.pointer_down(50,49,true); check(folder_drag.take_sound_ids()==std::vector({15,12,15}), "folder-child RMB start preserves Source restore/unlink/append ordering"); folder_drag.pointer_move(176,100); const auto child_return=folder_drag.pointer_up(176,100,true); check(child_return.kind==DeskRequestKind::change_layout&& child_return.layout_operation==DeskLayoutOperation::return_folder_child&& child_return.layout_before[3*16+5]==0xff&&child_return.layout_after[0*16+5]==49&& child_return.layout_after[49*16+5]==3&&child_return.layout_after[3*16+5]==0&& child_return.layout_after[3*16+6]==49, "RMB drag from the rendered 32×25 folder tile returns it to the visible chain"); check(folder_drag.take_sound_ids().empty(),"folder-child release cannot replay its down-event append"); DesktopScreen folder_drop(data,child_desk); folder_drop.pointer_down(50,49,true); folder_drop.take_sound_ids(); folder_drop.pointer_move(55,52); const auto dropped_child=folder_drop.pointer_up(55,52,true); check(dropped_child.layout_operation==DeskLayoutOperation::set_folder && folder_drop.take_sound_ids()==std::vector{12}, "Source fully enclosed drop unlinks the dragged child exactly once"); DesktopScreen unchanged_handle(data,child_desk); unchanged_handle.pointer_down(41,41); check(!unchanged_handle.pending() && unchanged_handle.take_sound_ids().empty(), "existing LMB handle gesture has no invented RMB sound mapping"); unchanged_handle.pointer_up(41,41); check(unchanged_handle.take_sound_ids().empty(),"handle release remains silent at this Source boundary"); auto covered_child=child_desk; covered_child.items.push_back(DeskItem{6,60,48,32,25,21,0,0,false,false}); covered_child.layout_records[49][5]=6; covered_child.layout_records[6][5]=0; covered_child.layout_records[6][6]=49; covered_child.layout_records[6][12]=21; DesktopScreen stacked_icon(data,covered_child); const auto exposed_folder_frame=folder_click.render(); const auto covered_folder_frame=stacked_icon.render(); const auto desktop_atlas=load_vga(asset_path(data/"KB","3.VGA")); for(int y=0;y<25;++y) for(int x=0;x<32;++x) check(covered_folder_frame.pixels[size_t(48+y)*320+60+x]== desktop_atlas.pixels[size_t(50+y)*desktop_atlas.width+160+x], "top icon renders over the folder child using its own native KB3 tile"); check(covered_folder_frame.pixels[size_t(49)*320+50]==exposed_folder_frame.pixels[size_t(49)*320+50], "the uncovered part of a folder child remains visible below the stacked icon"); const auto covering_icon_action=stacked_icon.click(65,49); check(covering_icon_action.kind==DeskRequestKind::open_menu&&covering_icon_action.item_id==6&& covering_icon_action.menu_kind==21&&stacked_icon.state().layout_records==covered_child.layout_records, "LMB activates the rendered top icon rather than the covered folder child without layout edits"); DesktopScreen stacked_drag(data,covered_child); stacked_drag.pointer_down(65,49,true); check(stacked_drag.take_sound_ids()==std::vector({12,15}), "visible RMB drag starts with the Source unlink/append pair"); stacked_drag.pointer_move(200,120); const auto covering_icon_drag=stacked_drag.pointer_up(200,120,true); check(covering_icon_drag.kind==DeskRequestKind::change_layout&&covering_icon_drag.item_id==6&& covering_icon_drag.layout_operation==DeskLayoutOperation::move_item&& covering_icon_drag.layout_after[3*16+5]==0xff&&covering_icon_drag.layout_after[3*16+6]==0xff, "RMB drags the rendered top icon and leaves the covered child outside the visible link chain"); check(stacked_drag.take_sound_ids().empty(),"ordinary move release adds no structural sound"); DesktopScreen still_drag(data,covered_child); still_drag.pointer_down(65,49,true); still_drag.pointer_up(65,49,true); check(still_drag.take_sound_ids()==std::vector({12,15}), "Source RMB reordering sounds happen even without pointer motion"); DesktopScreen exposed_child(data,covered_child); check(exposed_child.click(50,49).item_id==3,"an exposed folder tile still opens its native child action"); auto status_cover=child_desk; status_cover.items.push_back(DeskItem{48,48,48,42,35,56,0,0,true,false}); DesktopScreen stacked_status(data,status_cover); check(stacked_status.render().pixels!=exposed_folder_frame.pixels&& stacked_status.pointer_down(50,49).kind==DeskRequestKind::none&& stacked_status.pointer_up(50,49).kind==DeskRequestKind::none&&!stacked_status.pending(), "an open status drawer covers a folder child and its inert body cannot activate that child"); auto empty_folder_cover=child_desk; empty_folder_cover.items.push_back(DeskItem{48,48,48,45,35,51,0,1,true,false}); DesktopScreen stacked_empty_folder(data,empty_folder_cover); check(stacked_empty_folder.click(50,49).kind==DeskRequestKind::none&&!stacked_empty_folder.pending(), "an empty part of the top folder blocks a lower folder child"); DesktopScreen covered_bin_restore(data,empty_folder_cover); covered_bin_restore.pointer_move(160,239); covered_bin_restore.click(10,215); check(covered_bin_restore.pointer_down(50,49,true).kind==DeskRequestKind::none&& covered_bin_restore.pointer_up(50,49,true).kind==DeskRequestKind::none&& !covered_bin_restore.pending()&&covered_bin_restore.state().layout_records==empty_folder_cover.layout_records, "bin-mode RMB on a covering empty folder cannot restore the lower child or change links"); check(covered_bin_restore.take_sound_ids().empty(),"covered bin child cannot emit a restore sound"); DesktopScreen exposed_bin_restore(data,covered_child); exposed_bin_restore.pointer_move(160,239); exposed_bin_restore.click(10,215); const auto exposed_restore=exposed_bin_restore.click(50,49,true); check(exposed_bin_restore.take_sound_ids()==std::vector{15},"bin-mode restore emits only append ID15"); check(exposed_restore.layout_operation==DeskLayoutOperation::restore_folder_child&&exposed_restore.item_id==3, "bin-mode RMB still restores an exposed folder child using its native owner"); DesktopScreen bin_send(data,covered_child); bin_send.pointer_move(160,239); bin_send.click(10,215); const auto sent_icon=bin_send.click(65,49,true); check(sent_icon.layout_operation==DeskLayoutOperation::send_to_folder && bin_send.take_sound_ids()==std::vector{12},"bin-mode send emits only unlink ID12"); auto closed_cover=child_desk; closed_cover.items.push_back(DeskItem{48,48,48,14,14,63,0,0,false,false}); DesktopScreen stacked_closed_drawer(data,closed_cover); check(stacked_closed_drawer.click(50,49).kind==DeskRequestKind::none&&!stacked_closed_drawer.pending(), "a closed drawer blocks hits inside its Source dimensions minus eight"); DesktopScreen outside_closed_drawer(data,closed_cover); check(outside_closed_drawer.click(55,49).item_id==3, "the eight-pixel closed drawer inset allows hits on the exposed lower folder child"); const auto menu_test_dir = std::filesystem::temp_directory_path() / ("openbmh-menu-layout-picker-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count())); std::filesystem::create_directories(menu_test_dir / "load"); std::filesystem::create_directories(menu_test_dir / "save"); { std::ofstream(menu_test_dir / "load" / "LAYOUT.MEN") << "fixture"; std::ofstream(menu_test_dir / "load" / "NOTGAME.FBM") << "fixture"; } SaveLoadScreen menu_load_picker(data, menu_test_dir / "load", SaveLoadMode::load, 0, 6, menu_bar.render(), true, SaveLoadFileKind::menu_layout, 52); check(menu_load_picker.entries().size() == 1 && menu_load_picker.entries()[0].path.extension() == ".MEN" && !menu_load_picker.info_press(60,45), "menu-layout picker filters to MEN and never interprets a layout as an FBM information header"); menu_load_picker.click(60,45); menu_load_picker.click(60,45); check(menu_load_picker.pending() && menu_load_picker.pending()->file_kind == SaveLoadFileKind::menu_layout && menu_load_picker.pending()->origin_item_id == 52 && menu_load_picker.pending()->path.extension() == ".MEN", "MEN load request retains its typed file kind and source drawer identity"); SaveLoadScreen menu_save_picker(data, menu_test_dir / "save", SaveLoadMode::save, 0, 6, menu_bar.render(), true, SaveLoadFileKind::menu_layout, 52); menu_save_picker.click(120,214); menu_save_picker.text("LAYOUT"); menu_save_picker.key("ENTER"); check(menu_save_picker.pending() && menu_save_picker.pending()->file_kind == SaveLoadFileKind::menu_layout && menu_save_picker.pending()->path.filename() == "LAYOUT.MEN" && save_load_request_json(*menu_save_picker.pending()).find("\"file_kind\":\"menu_layout\"") != std::string::npos, "MEN save request uses the native extension and an explicit JSON file-kind discriminator"); std::filesystem::remove_all(menu_test_dir); TextDb desk_texts = load_textd(asset_path(data,"TEXTD.BLK")); auto match_game = g; match_game.texts = &desk_texts; match_game.club_names.assign(32,0); std::copy_n("UNITFC",6,match_game.club_names.begin()); std::copy_n("TESTCITY",8,match_game.club_names.begin()+7); std::copy_n("BREMEN",6,match_game.club_names.begin()+16); match_game.club_ids[12]=0; match_game.club_ids[13]=7; match_game.club_ids[14]=16; match_game.results.assign(9 * 0x17c, 0xcc); check(desk_texts[(::bmh::layout::FixtureDesktopFirstLabelPointer-::bmh::layout::TextPointerTable)/4]==bmh::test::expected_text("desktop_tests.0") && desk_texts[(::bmh::layout::FixtureDesktopSecondLabelPointer-::bmh::layout::TextPointerTable)/4]==bmh::test::expected_text("desktop_tests.1"), "kind-61 rank suffix and strength label resolve from the Source TEXTD addresses"); check(format_number(match_game,6,2)=="%6" && format_number(match_game,95,2)=="95", "legacy routine width 2 keeps a transparent leading cell only for one-digit strength"); const Font small_font=load_font(data/"F"/"BMH3.FNT"); check(small_font.glyph('%').bit_width==0 && small_font.glyph('%').advance==5, "FNT3 renders legacy routine's percent width placeholder as a leading space"); auto ranked_game = match_game; ranked_game.league_rounds[0] = 1; ranked_game.position_history.resize(340); write16(ranked_game.position_history, 12 * 13 * 2, 6); write16(ranked_game.position_history, 13 * 13 * 2, 2); auto ranked_desk = desk_from_game(ranked_game,exe,8); check(ranked_desk.table_position==6 && ranked_desk.strength==90, "desk projects Core table_position as a zero-based rank beside strength"); auto current_club_game = ranked_game; current_club_game.manager_teams[0] = 13; write16(current_club_game.manager_records,0x290,13); auto current_club_desk = desk_from_game(current_club_game,exe,8); check(current_club_desk.runtime_club==13 && current_club_desk.club_name=="TESTCITY" && current_club_desk.table_position==2, "table rank follows the current runtime club identity after club remapping"); auto rank_item_desk = ranked_desk; rank_item_desk.items.clear(); rank_item_desk.items.push_back({42,213,16,94,15,61,0,0,false,false}); const auto ranked_image = DesktopScreen(data,rank_item_desk).render(); auto unranked_item_desk = rank_item_desk; unranked_item_desk.table_position.reset(); const auto unranked_image = DesktopScreen(data,unranked_item_desk).render(); int min_x=320, min_y=240, max_x=-1, max_y=-1; for (int y=0;y<240;++y) for (int x=0;x<320;++x) if (ranked_image.pixels[size_t(y)*320+x]!=unranked_image.pixels[size_t(y)*320+x]) { min_x=std::min(min_x,x); min_y=std::min(min_y,y); max_x=std::max(max_x,x); max_y=std::max(max_y,y); } check(max_x>=0 && min_x>=214 && max_x<307 && min_y==17 && max_y==22, "rank changes only the centered Source kind-61 text line at its saved position and clip"); auto flat_text_desk = rank_item_desk; flat_text_desk.gradient_text=false; check(DesktopScreen(data,flat_text_desk).render().pixels!=ranked_image.pixels, "kind-61 rank and strength use the existing Source gradient text renderer"); check(desk_json(ranked_desk).find("\"table_position\":6")!=std::string::npos && desk_json(d).find("\"table_position\":null")!=std::string::npos, "desk JSON reports the optional zero-based table position"); MatchGroup league_fixture; league_fixture.desc.assign(0xd0,0); league_fixture.desc[0]=0; write32(league_fixture.desc,0xcc,0); league_fixture.fixtures={12,13}; league_fixture.results={0xcc}; std::vector prepared{league_fixture}; auto matched = desk_from_game(match_game,exe,8,&prepared,34); check(matched.next_opponent==13 && matched.next_competition==exe.u8(::bmh::layout::LeagueCalendarBits) && matched.next_opponent_name=="TESTCITY" && matched.next_opponent_badge.has_value() && !matched.next_opponent_badge_fallback, "current prepared league fixture maps opponent, Source competition and badge"); check(!matched.next_competition_label.empty(),"league fixture resolves Source label and matchday"); auto setup_group = league_fixture; setup_group.results.clear(); std::vector setup_groups{setup_group}; auto setup_desk = desk_from_game(match_game,exe,8,&setup_groups,34); check(setup_desk.next_opponent==13, "fresh setup_matchday uses typed raw 0xCC season result when MatchGroup results are empty"); auto played_game = match_game; played_game.results[0] = 0; setup_desk = desk_from_game(played_game,exe,8,&setup_groups,34); check(setup_desk.next_opponent==-1 && setup_desk.next_competition==34, "fresh setup_matchday suppresses a fixture whose typed raw season result is played"); matched.items.push_back({40,100,149,33,29,15,0,0,false,false}); matched.items.push_back({41,140,149,33,29,17,0,0,false,false}); check(DesktopScreen(data,matched).render().pixels.size()==320*240, "resolved league opponent renders its Source competition, names and badge"); auto played_league = league_fixture; played_league.results={0}; played_league.kickoff_void_mask=0; std::vector played_group{played_league}; auto played_desk=desk_from_game(match_game,exe,8,&played_group,34); check(played_desk.next_competition==34 && played_desk.next_opponent==-1 && !played_desk.next_opponent_badge, "Source played league result keeps competition default 34 and clears the opponent"); auto later_played = played_league; later_played.fixtures={12,14}; write32(later_played.desc,0xcc,2); std::vector mixed_results{league_fixture,later_played}; auto mixed_desk=desk_from_game(match_game,exe,8,&mixed_results,34); check(mixed_desk.next_competition==exe.u8(::bmh::layout::LeagueCalendarBits) && mixed_desk.next_opponent==-1, "later played fixture clears opponent while preserving the earlier competition write"); auto away_game = match_game; away_game.manager_records.at(0x28a) = 1; auto away_fixture = league_fixture; away_fixture.fixtures={13,12}; std::vector away_groups{away_fixture}; auto away_desk = desk_from_game(away_game,exe,8,&away_groups,34); check(away_desk.next_opponent==13 && away_desk.next_match_away, "Source manager record +0x28a marks the manager's fixture as away"); away_desk.items.push_back({40,100,149,33,29,15,0,0,false,false}); auto rendered_away = DesktopScreen(data,away_desk).render(); auto expected_order = away_desk; std::swap(expected_order.club_name, expected_order.next_opponent_name); expected_order.next_match_away = false; check(rendered_away.pixels == DesktopScreen(data,expected_order).render().pixels, "Source desk renders the home side before the away side for an away manager"); MatchGroup cup_fixture; cup_fixture.desc.assign(0xd0,0); cup_fixture.desc[0]=6; cup_fixture.fixtures={12,14}; cup_fixture.cup_results={0}; prepared.push_back(cup_fixture); matched = desk_from_game(match_game,exe,9,&prepared,34); check(matched.next_opponent==14 && matched.next_competition==10 && matched.next_opponent_name=="BREMEN", "later matching group deterministically overrides earlier Source values"); auto special_game=match_game;special_game.memory.add_block(::bmh::layout::CompetitionCalendar,2); special_game.memory.set16(::bmh::layout::CompetitionCalendar,0x4006); auto special=desk_from_game(special_game,exe,10,&prepared,34); check(special.next_competition_label==desk_texts[(::bmh::layout::DeskState_FormatError_RuntimeField4-::bmh::layout::TextPointerTable)/4], "Source calendar entry 4006 selects the special competition title"); MatchGroup fallback_badge_group=cup_fixture;fallback_badge_group.fixtures={12,100}; std::vector fallback_badge_groups{fallback_badge_group}; auto fallback_badge=desk_from_game(match_game,exe,10,&fallback_badge_groups,34); check(fallback_badge.next_opponent==100&&fallback_badge.next_opponent_badge_fallback&& !fallback_badge.next_opponent_badge, "legacy routine special team range uses its computer-portrait fallback"); prepared.clear(); auto other_fixture = league_fixture; other_fixture.fixtures={13,14}; prepared.push_back(other_fixture); auto unmatched = desk_from_game(match_game,exe,10,&prepared,34); check(unmatched.next_competition==34 && unmatched.next_opponent==-1, "active-event fallback is competition 34 with the Source no-opponent portrait"); check(unmatched.next_competition_label==desk_texts[(::bmh::layout::DeskState_DeskFromGame_TextPointer-::bmh::layout::TextPointerTable)/4+34] && !unmatched.next_competition_detail.empty(), "active-event no-opponent desk shows the Source free-day title and parenthesized first league"); MatchGroup cup_fallback; cup_fallback.desc.assign(0xd0,0); cup_fallback.desc[0]=6; cup_fallback.fixtures={13,14}; std::vector cup_fallback_groups{cup_fallback}; auto cup_day = desk_from_game(match_game,exe,10,&cup_fallback_groups,34); const size_t cup_detail_id=(::bmh::layout::DeskState_FormatError_ExecutableField3-::bmh::layout::TextPointerTable)/4+cup_fallback.desc[0]; check(cup_day.next_competition_detail=="("+desk_texts.strings.at(cup_detail_id)+")", "free-day cup detail resolves its name through runtime TEXTD"); check(!exe.cstring(::bmh::layout::DeskDrawers_Recent_TextPointer).empty(),"Source executable contains the opponent separator string"); cup_day.items.push_back({40,100,149,33,29,15,0,0,false,false}); cup_day.next_opponent=13; cup_day.next_opponent_name="TESTCITY"; check(DesktopScreen(data,cup_day).render().pixels.size()==320*240, "Source separator and runtime cup detail render on desk item 15"); unmatched = desk_from_game(match_game,exe,11,&prepared,33); check(unmatched.next_competition==33 && unmatched.next_opponent==-1, "no-event desk retains Source defaults 33 and no opponent"); unmatched = desk_from_game(match_game,exe,12,&prepared,32); check(unmatched.next_competition==32 && unmatched.next_opponent==-1, "season-end desk retains Source defaults 32 and no opponent"); // The international-phase manager uses the special kNoTeam slot and // the 24-player squad at 3072; projection is display-only. auto nat = fixture(); nat.manager_teams[0] = kNoTeam; nat.memory.set32(::bmh::layout::CompetitionSelection,2); nat.memory.set8(::bmh::layout::Desktops + 5 * 16 + 5,6); for (int i=0;i<2;++i) { const auto at=::bmh::layout::DesktopsUnsigned+uint32_t(i+6)*16; nat.memory.set16(at,uint16_t(200+i*40)); nat.memory.set8(at+2,120); nat.memory.set8(at+3,32); nat.memory.set8(at+4,25); nat.memory.set8(at+5,uint8_t(i?0:7)); nat.memory.set8(at+12,uint8_t(i?22:14)); } nat.club_names = {'D','E','U','T','S','C','H','L','A','N','D',0}; nat.club_ids[kNoTeam] = 0; nat.squad_slots.assign(3096,0x0fff); nat.players.resize(24); nat.team_morale.resize(419,25); for (int row=0; row<24; ++row) { nat.squad_slots[3072 + row] = uint16_t(row | (row < 11 ? 0x8000 : row < 16 ? 0x4000 : 0)); nat.players[row].w35c = 50 | (90 << 7) | (90 << 14); nat.tactics[size_t(row)*0x58 + 0x0c] = 4; } const auto nat_seed = nat.memory.u32(::bmh::layout::CareerSession_Save_RuntimeField); const auto nat_records = nat.manager_records; const auto nat_squads = nat.squad_slots; auto nd = desk_from_game(nat,exe,41); check(nd.national_team && nd.runtime_club==kNoTeam && nd.club_name=="DEUTSCHLAND" && nd.strength==90, "national team identity and squad projection"); check(nat_records==nat.manager_records && nat_squads==nat.squad_slots && nat.memory.u32(::bmh::layout::CareerSession_Save_RuntimeField)==nat_seed, "national projection is read-only and drawless"); check(std::count_if(nd.items.begin(),nd.items.end(),[](const DeskItem& item){return item.kind==14&&item.disabled;})==1 && std::count_if(nd.items.begin(),nd.items.end(),[](const DeskItem& item){return item.kind==22&&item.disabled;})==1, "national bank/stadium entries disabled"); check(desk_json(nd).find("\"national_team\":true")!=std::string::npos,"national mode is exposed to UI clients"); DesktopScreen national_desk(data,nd); check(national_desk.key("A").kind==DeskRequestKind::open_menu,"national lineup remains available"); national_desk.reject_action("test"); check(national_desk.click(205,125).kind==DeskRequestKind::none,"national bank request is suppressed"); check(national_desk.click(245,125).kind==DeskRequestKind::none,"national stadium request is suppressed"); g.date = 1; g.memory.set32(::bmh::layout::CalendarDay,100); d = desk_from_game(g,exe,8); check(d.date.day == 2 && d.day_counter == 1,"typed date overrides stale memory"); g.date = 0; g.tactics[0x0f] = 69; check(desk_from_game(g,exe,9).warnings[4] == false,"exhaustion 69"); g.tactics[0x0f] = 70; check(desk_from_game(g,exe,9).warnings[4] == true,"exhaustion 70"); g.tactics[0x0f] = 0; g.manager_records[0xd9] = 8; check(desk_from_game(g,exe,9).warnings[7] == false,"important 8"); g.manager_records[0xd9] = 9; check(desk_from_game(g,exe,9).warnings[7] == true,"important 9"); g.manager_records[0xd9] = 0; g.tactics[0x0c] = 3; check(desk_from_game(g,exe,9).warnings[8] == true,"contract below four months"); g.tactics[0x0c] = 4; g.manager_records[0xcb] = 14; check(desk_from_game(g,exe,9).warnings[3] == false,"training sum fourteen"); g.manager_records[0xcb] = 15; check(desk_from_game(g,exe,9).warnings[3] == true,"training sum fifteen"); g.manager_records[0xcb] = 0; write16(g.stocks,0x50,2); write32(g.stocks,4,20); write16(g.stocks,0x4e,10); check(desk_from_game(g,exe,9).warnings[0] == false,"stock break-even"); write16(g.stocks,0x4e,11); check(desk_from_game(g,exe,9).warnings[0] == true,"stock profit"); g.stocks.assign(0x450,0); write32(g.manager_records,0x314,uint32_t(-6000000)); check(desk_from_game(g,exe,9).warnings[9] == false,"licence six million boundary"); write32(g.manager_records,0x314,uint32_t(-6000001)); check(desk_from_game(g,exe,9).warnings[9] == true,"licence debt exceeds boundary"); write32(g.manager_records,0x314,0); auto invalid = fixture(); invalid.memory.set8(::bmh::layout::Desktops + 5 * 16 + 5,1); rejected([&]{ desk_from_game(invalid,exe,0); }); auto supported = d.options; supported.world = true; validate_desk_profile(supported); supported.managers = 4; validate_desk_profile(supported); auto wrong = d.options; wrong.managers = 5; rejected([&]{ validate_desk_profile(wrong); }); wrong = d.options; wrong.world = false; wrong.league = false; rejected([&]{ validate_desk_profile(wrong); }); d = desk_from_game(g,exe,10); DesktopScreen desk(data,d); const auto pixels = desk.render().pixels; check(desk.render().pixels == pixels,"repeat render is deterministic"); check(desk.click(5,23).kind == DeskRequestKind::none,"calendar handle must not advance a turn"); auto action = desk.click(50,125); check(action.kind == DeskRequestKind::open_menu && action.menu_kind == 3 && action.manager_slot == 0 && action.revision == 10,"lineup request"); check(desk.click(20,40).kind == DeskRequestKind::none,"pending command blocks another turn"); rejected([&]{ desk.acknowledge(d); }); ++d.revision; desk.acknowledge(d); check(desk.click(20,40).kind == DeskRequestKind::advance_turn,"open calendar advances"); check(desk.click(20,40).kind == DeskRequestKind::none,"no duplicate advance request"); ++d.revision; desk.acknowledge(d); check(desk.click(165,125).kind == DeskRequestKind::advance_turn,"kickoff icon advances"); check(desk.render().pixels == pixels,"commands cannot mutate the saved game view"); desk.reject_action("unsupported_menu"); check(!desk.pending() && desk.render().pixels == pixels,"rejected command preserves state"); check(desk.key("A").menu_kind == 3,"original A hotkey opens lineup"); desk.reject_action("not_implemented"); check(desk.key("D").menu_kind == 18,"original D hotkey opens tactics"); desk.reject_action("not_implemented"); check(desk.key("I").menu_kind == 16 && desk_menu_name(16)=="training" && desk_menu_name(15)=="training_camp", "original I and dispatch distinguish training from training camp"); StartupFlow flow(data); begin(flow); auto result = CareerInitializationResult{d,{{0,0,12}}}; result.desktop.source = "original_save_read_only"; rejected([&]{ flow.attach_initialized_career(result); }); // The desk boundary accepts every UI-supported manager count only when // all confirmed choices match contiguous engine slots and runtime clubs. for(int count=1;count<=4;++count) { StartupFlow multi_flow(data); confirm_managers(multi_flow,count); const auto request=*multi_flow.pending_career(); auto game=career_game(exe,request); auto career_desk=desk_from_game(game,exe,20); std::vector initialized; for(int slot=0;slot1) malformed.managers.back().slot=0; else malformed.managers.clear(); rejected([&]{multi_flow.attach_initialized_career(malformed);}); check(multi_flow.pending_career()!=nullptr,"missing/duplicate slots leave the career request untouched"); malformed=accepted; malformed.managers[0].master_club++; rejected([&]{multi_flow.attach_initialized_career(malformed);}); malformed=accepted; malformed.managers[0].runtime_club++; rejected([&]{multi_flow.attach_initialized_career(malformed);}); malformed=accepted; malformed.desktop.runtime_club++; rejected([&]{multi_flow.attach_initialized_career(malformed);}); if(count>1) { auto duplicate_club=game; duplicate_club.manager_teams[1]=duplicate_club.manager_teams[0]; rejected([&]{desk_from_game(duplicate_club,exe,20);}); } multi_flow.attach_initialized_career(accepted); check(multi_flow.desktop() && multi_flow.desktop()->state().manager_teams.size()==size_t(count),"1-4 manager career attaches with explicit runtime map"); if(count>=2) { auto next_game=game; next_game.memory.set8(::bmh::layout::ActiveManager,1); auto next=desk_from_game(next_game,exe,21); next.league=uint8_t((request.managers[1].start_league+1)%9); next.managers[1].league=next.league; next.badge=8; next.managers[1].badge=8; // exercise a different W/*.VGA sheet auto menu=multi_flow.send_key("A"); check(menu.request==FlowRequest::desk_action,"manager action is pending before a handoff"); rejected([&]{multi_flow.acknowledge_desk(next);}); check(multi_flow.desktop()->pending().has_value() && multi_flow.desktop()->state().manager_slot==0,"ordinary action cannot switch managers"); multi_flow.reject_desk_action("test action rejected"); auto action=multi_flow.click(20,40); check(action.request==FlowRequest::kickoff,"multi-manager turn action accepted"); auto stale=next; stale.revision=20; rejected([&]{multi_flow.acknowledge_desk(stale);}); check(multi_flow.desktop()->pending().has_value() && multi_flow.desktop()->state().manager_slot==0,"stale handoff leaves request and previous manager intact"); auto wrong_map=next; wrong_map.runtime_club=12; rejected([&]{multi_flow.acknowledge_desk(wrong_map);}); check(multi_flow.desktop()->pending().has_value(),"wrong runtime club does not consume handoff request"); multi_flow.acknowledge_desk(next); check(multi_flow.desktop()->state().manager_slot==1 && multi_flow.desktop()->state().runtime_club==13,"newer validated ACK can hand off to another manager"); check(multi_flow.render().pixels.size()==320*240,"manager handoff loads the new badge sheet before rendering"); } } StartupFlow national_flow(data); confirm_managers(national_flow,1,true); auto national_request=*national_flow.pending_career(); check(!national_request.options.league && national_request.options.world,"world-only UI setup is preserved"); auto national_game=career_game(exe,national_request,true); national_game.club_names={'D','E','U','T','S','C','H','L','A','N','D',0}; national_game.club_ids[kNoTeam]=0; national_game.squad_slots[3072]=0x8000; auto national_projection=desk_from_game(national_game,exe,30); auto national_manager=InitializedManager{0,national_request.managers[0].master_club,kNoTeam}; national_flow.attach_initialized_career({national_projection,{national_manager},{}}); check(national_flow.desktop()->state().national_team,"national career reaches the desktop with kNoTeam mapping"); auto national_preparation=preparation_from_game(national_game,exe,30); check(national_preparation.lineup.players.size()==24 && national_preparation.lineup.runtime_club==kNoTeam && national_preparation.tactics.runtime_club==kNoTeam, "national career projects its special 24-player lineup and tactics"); check(!national_preparation.training && !national_preparation.training_camp && !national_preparation.bank && !national_preparation.stadium && !national_preparation.toto && !national_preparation.pitch, "national preparation omits club-only contexts"); check(LineupScreen(data,national_preparation.lineup).render().pixels.size()==320*240 && TacticsScreen(data,national_preparation.tactics).render().pixels.size()==320*240, "national lineup and tactics render from the projected game state"); check(national_preparation.player_cards.size()==1 && national_preparation.player_cards[0].club_short_name=="DEUTSCHLAND", "national player card retains the full country label"); StartupFlow world_flow(data); confirm_managers(world_flow,1,true); auto world_request=*world_flow.pending_career(); auto world_game=career_game(exe,world_request); auto world_desk=desk_from_game(world_game,exe,40); world_flow.attach_initialized_career({world_desk,{{0,world_request.managers[0].master_club,12}}, {}}); check(world_flow.click(20,40).request==FlowRequest::kickoff,"world-only manager can reach an international phase"); world_game.manager_teams[0]=kNoTeam; world_game.memory.set32(::bmh::layout::CompetitionSelection,2); world_game.memory.set8(::bmh::layout::CoachActive,1); world_game.memory.add_block(::bmh::layout::OriginalManagerCount,1); world_game.memory.set8(::bmh::layout::OriginalManagerCount,1); std::copy_n(world_game.manager_records.begin(),0xb0c,world_game.manager_records.begin()+4*0xb0c); write16(world_game.manager_records,4*0xb0c+0x290,12); std::copy_n("DEUTSCHLAND",11,world_game.club_names.begin()); world_game.club_names[11]=0; world_game.club_ids[kNoTeam]=0; auto world_national=desk_from_game(world_game,exe,41); check(world_national.managers[0].club_identity_key==world_desk.managers[0].club_identity_key, "national duty preserves the stable home-club identity"); world_flow.acknowledge_desk(world_national); check(world_flow.desktop()->state().national_team && world_flow.desktop()->state().runtime_club==kNoTeam, "single-manager world transition accepts the national runtime club"); check(world_flow.click(20,40).request==FlowRequest::kickoff, "national desk accepts the next turn request"); auto other_home=world_game; other_home.manager_teams[0]=13; write16(other_home.manager_records,0x290,13); auto wrong_home=desk_from_game(other_home,exe,42); rejected([&]{world_flow.acknowledge_desk(wrong_home);}); check(world_flow.desktop()->pending().has_value() && world_flow.desktop()->state().national_team, "national handback to another club is rejected without consuming the turn"); world_game.manager_teams[0]=12; write16(world_game.manager_records,0x290,12); auto home_handback=desk_from_game(world_game,exe,42); world_flow.acknowledge_desk(home_handback); check(!world_flow.desktop()->state().national_team && world_flow.desktop()->state().runtime_club==12, "national duty returns to the same home club"); check(flow.pending_career()!=nullptr,"rejected attachment preserves request"); result.desktop.source = "engine_projection"; result.managers[0].master_club = 9; rejected([&]{ flow.attach_initialized_career(result); }); result.managers[0].master_club = 0; flow.attach_initialized_career(result); check(flow.screen_name()=="desktop" && !flow.pending_career(),"accepted career reaches desktop"); check(flow.state_json().find("\"engine_attached\":true") != std::string::npos,"engine attachment is explicit"); rejected([&]{ flow.attach_initialized_career(result); }); StartupFlow results_flow(data); confirm_managers(results_flow,1); const auto results_request=*results_flow.pending_career(); auto results_game=career_game(exe,results_request); std::fill_n(results_game.manager_records.begin()+0xc5,4,2); std::fill_n(results_game.manager_records.begin()+0xc9,9,1); auto results_desk=desk_from_game(results_game,exe,100); results_flow.attach_initialized_career({results_desk, {{0,results_request.managers[0].master_club,results_game.manager_teams[0]}},{}}); results_flow.attach_preparation_context(preparation_from_game(results_game,exe,100)); check(results_flow.click(20,40).request==FlowRequest::kickoff, "prepared desktop emits one turn request before the result display"); auto next_results_desk=desk_from_game(results_game,exe,101); results_flow.acknowledge_desk(next_results_desk); results_flow.attach_preparation_context(preparation_from_game(results_game,exe,101)); MatchdayResults visible_results; visible_results.valid=true; visible_results.matchday=4; visible_results.date=12; visible_results.date_label="12.07.2003"; MatchdayResultGroup visible_group; visible_group.competition="Liga"; visible_group.matches.push_back({"UNITFC","TESTCITY",2,1,MatchResultStatus::played}); visible_results.groups.push_back(std::move(visible_group)); results_flow.show_matchday_results(std::move(visible_results)); check(results_flow.screen_name()=="matchday_results" && results_flow.state_json().find("\"screen\":\"matchday_results\"")!=std::string::npos, "results modal holds the prepared following desk"); check(results_flow.click(20,40).request==FlowRequest::none && results_flow.screen_name()=="matchday_results", "desk input cannot start a second turn while results remain open"); const auto closed_results=results_flow.send_key("ESC"); check(closed_results.request==FlowRequest::results_closed && results_flow.screen_name()=="desktop" && !results_flow.desktop()->pending(), "Escape closes results without issuing another kickoff"); if (argc > 2 && std::string(argv[2]).size()) { const auto original = read_file(argv[2]); auto state = load_reference_desk(argv[2],exe); check(state.manager_name=="BMHLAB" && state.runtime_club==12 && state.balance==6243300 && state.strength==86,"captured single-manager baseline"); const std::array lamps{false,false,true,false,false,false,false,false,false,false}; for (size_t i=0;i<10;++i) check(state.warnings[i]==lamps[i],"RAM-observed warning vector"); StartupFlow reference(data); reference.load_reference(argv[2]); check(reference.state_json().find("\"engine_attached\":false")!=std::string::npos,"reference is not a new career/attached engine"); check(read_file(argv[2])==original,"original save unchanged after projection/render"); // Loading replaces the confirmed-career choice source with the // loaded runtime roster. Exercise a following turn and save ACK. const auto temp_dir=std::filesystem::temp_directory_path() / ("openbmh-u7b-load-"+std::to_string(std::chrono::steady_clock::now().time_since_epoch().count())); std::filesystem::create_directories(temp_dir); const auto staged_save=temp_dir/"BASELINE.FBM"; std::filesystem::copy_file(argv[2],staged_save); StartupFlow load_flow(data,temp_dir); check(load_flow.click(214,215).request==FlowRequest::submenu_opened,"setup opens load dialog"); load_flow.click(40,50); check(load_flow.click(240,192).request==FlowRequest::file_action,"load dialog emits one file request"); auto loaded=load_preparation_reference(staged_save,exe); set_preparation_revision_source(loaded,1,"engine_projection"); loaded.desktop.menu_layout_shortcut=DeskItem{53,286,215,12,11,53,0,0,false,false}; loaded.desktop.shortcut_bar_always=false; loaded.desktop.drawer_handles=true; DeskItem calendar; calendar.id=50; calendar.kind=58; calendar.x=10; calendar.y=80; calendar.width=32; calendar.height=32; calendar.open=true; DeskItem saver; saver.id=51; saver.kind=11; saver.x=60; saver.y=80; saver.width=32; saver.height=32; loaded.desktop.items.push_back(calendar); loaded.desktop.items.push_back(saver); { DesktopScreen drag_screen(data,loaded.desktop); drag_screen.pointer_down(65,85,true); check(drag_screen.pointer_move(83,101),"desktop drag changes only the local preview before release"); auto drag_request=drag_screen.pointer_up(83,101,true); check(drag_request.kind==DeskRequestKind::change_layout && drag_request.layout_operation==DeskLayoutOperation::move_item && drag_request.layout_before!=drag_request.layout_after && drag_screen.pending().has_value(), "desktop drag release emits an owner/revision-bound native layout request"); DesktopScreen cancelled(data,loaded.desktop); cancelled.pointer_down(65,85,true); cancelled.pointer_move(83,101); check(cancelled.pointer_up(83,101,false).kind==DeskRequestKind::none && !cancelled.pending(), "opposite-button release cancels the local drag without a native request"); } loaded.lineup.source=loaded.tactics.source="engine_projection"; check(loaded.desktop.manager_teams.size()==size_t(loaded.desktop.options.managers),"loaded projection contains complete manager roster"); auto stale_loaded=loaded; set_preparation_revision_source(stale_loaded,0,"engine_projection"); rejected([&]{load_flow.attach_loaded_game(stale_loaded.desktop,stale_loaded);}); check(load_flow.state_json().find("\"mode\":\"load\"")!=std::string::npos,"stale load leaves file request pending"); load_flow.attach_loaded_game(loaded.desktop,loaded); check(load_flow.desktop() && load_flow.state_json().find("\"engine_attached\":true")!=std::string::npos,"loaded projection attaches as authoritative manager baseline"); auto turn=load_flow.click(15,85); check(turn.request==FlowRequest::kickoff,"loaded desk accepts next-turn request"); auto next_loaded=loaded; set_preparation_revision_source(next_loaded,2,"engine_projection"); load_flow.acknowledge_desk(next_loaded.desktop); auto open_save=load_flow.click(65,85); check(open_save.request==FlowRequest::submenu_opened,"loaded manager can open save dialog"); load_flow.click(240,192); load_flow.click(240,192); check(load_flow.state_json().find("\"action\":\"save\"")!=std::string::npos,"save dialog emits save request"); auto saved=next_loaded; set_preparation_revision_source(saved,3,"engine_projection"); load_flow.acknowledge_saved_game(saved.desktop,saved); check(load_flow.desktop()->state().revision==3,"save ACK retains loaded multi-view manager baseline"); load_flow.click(64,239); auto open_menu_save=load_flow.click(292,221); check(open_menu_save.request==FlowRequest::submenu_opened && open_menu_save.desk_action.menu_kind==53 && !load_flow.pending_file(), "Source last-cell record-53 left action opens the MEN save picker before a request exists"); load_flow.click(120,214); load_flow.text("MENU"); load_flow.send_key("ENTER"); check(load_flow.pending_file() && load_flow.pending_file()->file_kind==SaveLoadFileKind::menu_layout && load_flow.pending_file()->origin_item_id==53 && load_flow.pending_file()->action==SaveLoadAction::save && load_flow.pending_file()->path.extension()==".MEN", "submitting a filename emits a typed MEN save request with the Source suffix and record-53 origin"); { std::ofstream(load_flow.pending_file()->path) << "menu-layout fixture"; } auto menu_saved=saved; set_preparation_revision_source(menu_saved,4,"engine_projection"); load_flow.acknowledge_menu_layout(menu_saved.desktop,menu_saved); check(load_flow.desktop()->state().revision==4 && load_flow.desktop()->state().manager_teams==saved.desktop.manager_teams, "MEN acknowledgement advances the UI revision while retaining active career ownership"); load_flow.click(64,239); auto open_menu_load=load_flow.click(292,221,true); check(open_menu_load.request==FlowRequest::submenu_opened && !load_flow.pending_file(), "Source last-cell record-53 right action opens the MEN load picker before a request exists"); load_flow.click(60,49); load_flow.click(60,49); check(load_flow.pending_file() && load_flow.pending_file()->file_kind==SaveLoadFileKind::menu_layout && load_flow.pending_file()->origin_item_id==53 && load_flow.pending_file()->action==SaveLoadAction::load, "selecting the saved MEN entry emits the typed load request"); rejected([&]{load_flow.attach_loaded_game(menu_saved.desktop,menu_saved);}); load_flow.reject_file_action("cancelled MEN fixture load"); std::cout << "Original LABA0012 baseline verified.\n"; } std::cout << "Desktop projection, calendar, command boundary and career attachment tests passed.\n"; return 0; } catch (const std::exception& e) { std::cerr << "desktop test: " << e.what() << '\n'; return 1; } }