// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "../../tests/test_inputs.hpp" #include "ui/lineup.hpp" #include #include #include #include #include #include #include "formats/fbm.hpp" #include "formats/savestate.hpp" #include "game/lineup.hpp" #include "game/save.hpp" #include "game/state.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) { try { action(); } catch(const FormatError&) { return; } throw std::runtime_error("expected rejected lineup operation"); } int source_draws = 0; void count_source_draw(int) { ++source_draws; } struct DrawHookGuard { void (*previous)(int) = draw_hook; DrawHookGuard() { source_draws = 0; draw_hook = count_source_draw; } ~DrawHookGuard() { draw_hook = previous; } }; GameState fixture() { GameState g; for(auto [at,size]:std::vector>{{::bmh::layout::ActiveManager,1},{::bmh::layout::CareerSession_AnyOf_ExecutableField,8},{::bmh::layout::LeaguePresentationOptions,0xb4}}) g.memory.add_block(at,size); g.memory.set16(::bmh::layout::CareerSession_AnyOf_ExecutableField,0x15); g.manager_teams={12}; g.manager_options.resize(20,0); g.manager_options[0]=1; g.squad_slots.resize(3096,0x0fff);g.players.resize(24);g.player_cards.resize(24);g.player_bonus.resize(24); g.tactics.resize(0x2940);g.player_name_offsets.resize(24);g.club_ids.resize(419); g.club_heap_78.resize(419*2);g.team_flags.resize(168); g.manager_records.resize(5*0xB0C);g.formations.resize(5*0x160); g.manager_records[0x290]=12; g.club_names={'B','A','Y','E','R','N',0}; for(int row=0;row<24;++row){ const auto n="PLAYER"+std::to_string(row); g.player_name_offsets[row]=uint16_t(g.player_names.size()); g.player_names.insert(g.player_names.end(),n.begin(),n.end());g.player_names.push_back(0); g.squad_slots[12*24+row]=uint16_t(row|(row<11?0x8000:row<17?0x4000:0)); g.players[row].w35c=50|(90<<7)|(80<<14); g.players[row].w364=uint32_t(row%4)|((row%16)<<21); g.player_cards[row]=uint16_t(row);g.player_bonus[row]=uint8_t(row); g.tactics[size_t(row)*0x58+0xf]=uint8_t(row+1); } return g; } void test_prepare_lineup_entry_modes() { constexpr int team=12; constexpr size_t first=size_t(team)*24; auto set_badge=[](GameState& g,uint16_t word) { g.club_heap_78[size_t(team)*2]=uint8_t(word); g.club_heap_78[size_t(team)*2+1]=uint8_t(word>>8); }; auto marker_fixture=[](GameState& g) { for(size_t row=0;row<24;++row)g.squad_slots[first+row]&=0x3fff; g.squad_slots[first+16]|=0x4000; // last Original-marked row is 16 }; auto expected_native=[](const GameState& input) { GameState expected=input; for(size_t row=0;row<=16;++row) expected.squad_slots[first+row]=uint16_t((expected.squad_slots[first+row]&0x3fff)| (row<11?0x8000:0x4000)); return save_stream(expected); }; for(const auto [indoor,badge_indoor]:std::array,4>{{ {false,false},{false,true},{true,false},{true,true}}}) { auto g=fixture();g.indoor=indoor;marker_fixture(g); const uint16_t badge=uint16_t(0x0045|(badge_indoor?0x0200:0));set_badge(g,badge); const auto before_badge=g.club_heap_78; const auto native_expected=expected_native(g); const auto save_before=save_stream(g); const auto rng_before=source_draws; DrawHookGuard draws; prepare_lineup_entry(g,team); check(save_stream(g)==native_expected && native_expected!=save_before, "Source entry only normalizes marker bits through the last marked row"); check(g.club_heap_78==before_badge, "lineup entry does not repair or otherwise mutate the stored club badge"); check(source_draws==0 && rng_before==0, "lineup entry consumes no observed GameRandom or WatcomRandom draws"); } // A valid stored assistant formation skips legacy routine's manual bit-9 // normalization. legacy routine still accepts the subsequent indoor entry. { auto g=fixture();g.indoor=true;set_badge(g,0x0045);marker_fixture(g); g.manager_options[0]=1; const auto badge_before=g.club_heap_78; DrawHookGuard draws; auto_lineup(g,team,0xe4); check(g.club_heap_78==badge_before && ((uint16_t(g.club_heap_78[team*2]| uint16_t(g.club_heap_78[team*2+1])<<8)>>9)&1)==0, "assistant-manager branch retains its mismatched stored bit 9"); prepare_lineup_entry(g,team); check((g.squad_slots[first]&0xc000)==0x8000 && source_draws==0, "assistant-managed indoor entry proceeds and stays RNG-neutral"); } // The manual-only branch keeps its Source mode correction before the same // entry helper. This test prevents deleting that separate correction. { auto g=fixture();g.indoor=true;set_badge(g,0xA145);marker_fixture(g); g.manager_options[0]=0; DrawHookGuard draws; auto_lineup(g,team,0xe4); const uint16_t badge=uint16_t(g.club_heap_78[team*2]| uint16_t(g.club_heap_78[team*2+1])<<8); check(badge==uint16_t((0xA145&0x01ff)|0x0200), "manual mismatch retains legacy routine bit-9 normalization"); prepare_lineup_entry(g,team); check(source_draws==0,"manual normalization and entry consume no observed RNG draws"); } // Removing the mode gate must not weaken the existing compact-roster and // player-ID validation. Rejections happen before any marker write. for(int bad_case=0;bad_case<3;++bad_case) { auto g=fixture();g.indoor=true;set_badge(g,0x0045);marker_fixture(g); if(bad_case==0)g.squad_slots[first+4]=0x0fff; // sparse IDs else if(bad_case==1)for(size_t row=10;row<24;++row)g.squad_slots[first+row]=0x0fff; // only ten players else g.squad_slots[first+4]=0x03e8; // ID beyond the player table const auto before=save_stream(g); bool threw=false; try { prepare_lineup_entry(g,team); } catch(const std::invalid_argument&) { threw=true; } check(threw && save_stream(g)==before, "indoor mismatch does not bypass sparse, minimum-roster or player-ID guards"); } auto outside=fixture(); const auto outside_before=save_stream(outside); bool bounds_threw=false; try { prepare_lineup_entry(outside,138); } catch(const std::invalid_argument&) { bounds_threw=true; } check(bounds_threw && save_stream(outside)==outside_before, "removing the badge-mode check leaves manager/team bounds validation intact"); } } int main(int argc,char**argv) { try { if(argc<2)throw std::runtime_error("original data directory required"); test_prepare_lineup_entry_modes(); const std::filesystem::path data=argv[1];const auto exe=load_le(asset_path(data,"BMH.exe")); auto g=fixture(); const auto squads=g.squad_slots;const auto records=g.tactics;const auto names=g.player_names; const auto options=g.manager_options; auto state=lineup_from_game(g,exe,7); check(state.manager_slot==0&&state.runtime_club==12&&state.revision==7,"authoritative manager identity"); check(state.source=="engine_projection"&&!state.entry_prepared,"projection never claims original entry effects"); check(state.players.size()==24&&state.players[13].name=="PLAYER13"&&state.players[13].board[0xf]==14,"owned names and tactics projection"); check(state.players[13].cards==13&&state.players[13].bonus==13,"typed player card and bonus projection"); check(state.players[0].attributes.condition()==80&&state.players[0].attributes.strength()==85,"original player display strength"); check(g.squad_slots==squads&&g.tactics==records&&g.player_names==names&&g.manager_options==options,"projection has no engine writes"); g.player_names[0]='X';g.tactics[0xf]=99; check(state.players[0].name=="PLAYER0"&&state.players[0].board[0xf]==1,"projection owns its data"); g=fixture(); g.memory.set8(::bmh::layout::ActiveManager,4);rejected([&]{lineup_from_game(g,exe,8);}); g.memory.set8(::bmh::layout::ActiveManager,0);g.manager_teams[0]=138;rejected([&]{lineup_from_game(g,exe,8);}); g.manager_teams[0]=12;g.player_name_offsets[0]=uint16_t(g.player_names.size());rejected([&]{lineup_from_game(g,exe,8);}); g=fixture();g.player_names.pop_back();rejected([&]{lineup_from_game(g,exe,8);}); LineupScreen entry(data,state); const auto prepare=entry.initialize(); check(prepare.kind==LineupRequestKind::prepare_lineup&&prepare.manager_slot==0&&prepare.runtime_club==12&&prepare.revision==7,"entry command carries exact context"); check(entry.initialize().kind==LineupRequestKind::none&&entry.click(20,33).kind==LineupRequestKind::none&&!entry.selected_row(),"pending entry blocks input/repeat"); auto updated=state;updated.revision=8; rejected([&]{entry.acknowledge(updated);}); check(entry.pending().has_value(),"failed entry acknowledgement preserves pending"); updated.entry_prepared=true;entry.acknowledge(updated); check(!entry.pending()&&entry.state().entry_prepared&&entry.initialize().kind==LineupRequestKind::none,"prepared entry is not repeated"); LineupScreen list(data,updated);const auto before=list.render().pixels; check(list.render().pixels==before,"render is pure"); check(list.move(20,33)&&list.render().pixels!=before,"player name hover is local visual state"); check(!list.move(20,33)&&list.move(306,228)&&list.render().pixels==before,"stable hover and leaving the name column"); check(list.click(20,33).kind==LineupRequestKind::none&&list.selected_row()==0,"first click is local selection"); const auto swap=list.click(20,40); check(swap.kind==LineupRequestKind::swap_players&&swap.first_row==0&&swap.second_row==1&&swap.first_player==0&&swap.second_player==1, "two name clicks request exact player exchange"); check(swap.first_slot==0x8000&&swap.second_slot==0x8001&&swap.revision==8,"command carries optimistic concurrency slot words"); check(list.state().players[0].player_id==0&&list.state().players[1].player_id==1,"pending exchange does not reorder projection"); check(list.click(20,47).kind==LineupRequestKind::none&&list.key("ESC").kind==LineupRequestKind::none&&!list.close_requested(),"pending exchange blocks repeats and exit"); rejected([&]{list.acknowledge(updated);}); auto wrong=updated;wrong.revision=9;wrong.manager_slot=1;rejected([&]{list.acknowledge(wrong);}); wrong=updated;wrong.revision=9;wrong.runtime_club=11;rejected([&]{list.acknowledge(wrong);}); wrong=updated;wrong.revision=9;wrong.players[0].player_id=4;rejected([&]{list.acknowledge(wrong);}); list.reject_action("engine rejected selection"); check(!list.pending()&&!list.selected_row()&&list.render().pixels==before,"rejection preserves original squad/frame"); rejected([&]{list.reject_action("no request");}); const auto flags=list.state().saved_display_flags; list.click(28,219); check(list.state().view==LineupView::data_b&&list.state().saved_display_flags==flags&&!list.pending(),"data view toggle is local and preserves saved flags"); check(list.click(70,33).kind==LineupRequestKind::open_player_info,"click behind player name requests info"); list.reject_action("player info not yet implemented"); check(list.click(85,219).kind==LineupRequestKind::open_pitch,"pitch navigation remains an explicit request"); list.reject_action("pitch renderer not yet implemented"); list.click(20,33);list.click(0,0,true); check(!list.selected_row()&&!list.close_requested(),"right click cancels local selection"); const auto idle_sheet=list.state_json();const auto idle_pixels=list.render().pixels; list.key("ESC");list.key("ESCAPE"); check(list.state_json()==idle_sheet&&list.render().pixels==idle_pixels&&!list.close_requested(), "Original desktop data sheet ignores Escape without state or pixel changes"); list.click(0,0,true);check(list.close_requested(),"next right click closes menu"); g=fixture();g.manager_teams.push_back(11);g.memory.set8(::bmh::layout::ActiveManager,1);g.memory.set16(::bmh::layout::FixtureSecondManagerClub,0x16); g.manager_options[5]=2; // Explicit empty second-manager squad is a valid state; no guessed manager order. auto second=lineup_from_game(g,exe,19); check(second.manager_slot==1&&second.runtime_club==11&&second.view==LineupView::data_b&&second.automatic_formation==2,"manager context remains separate"); if(argc>2&&!std::string(argv[2]).empty()) { const auto bytes=read_file(argv[2]);const auto savegame=load_savegame(argv[2]); check(savegame.checksum_ok&&savegame.version=="V2.24","reference container validation"); SaveState save(savegame.stream,{exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField),exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField3),exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField2),exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField4)}); auto reference=lineup_from_save(save,exe,3); check(reference.runtime_club==12&&reference.players.size()==24&&reference.club_name==bmh::test::expected_text("lineup_tests.0"),"original reference identity"); check(reference.players[0].player_id>=0&&reference.source=="original_save_read_only"&&!reference.entry_prepared,"reference is read-only and requires explicit live preparation"); LineupScreen original(data,reference);check(original.render().pixels.size()==320*240,"original assets render both data lists"); original.click(28,219);check(original.render().pixels.size()==320*240,"other original list view renders"); check(read_file(argv[2])==bytes,"reference save unchanged"); } std::cout<<"Lineup projection, entry, command and rendering checks passed\n"; } catch(const std::exception& e) { std::cerr<