Files
Dreierpack-Manager/src/ui/league_table_tests.cpp
T
ClaudeandClaude Sonnet 5.5 287b5a9251 Add header comments to the source files
Every source file in ui, app, game, formats, cli, audio and launch that had none
now starts with a short English comment: what it implements, what state it owns
and how it relates to its neighbours (request/acknowledge flow, pairs of files,
random generator use). Comment lines only; the full build and the runnable
tests are unchanged.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-06 09:15:23 +01:00

443 lines
29 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
// Tests for the league table projection, controls and family requests (ui/league_table.hpp).
#include "formats/executable_layout.hpp"
#include "ui/league_table.hpp"
#include <algorithm>
#include <array>
#include <filesystem>
#include <functional>
#include <iostream>
#include <stdexcept>
#include "app/career_session.hpp"
#include "game/messages.hpp"
#include "game/schedule.hpp"
#include "game/table.hpp"
#include "ui/desktop.hpp"
#include "ui/manager.hpp"
#include "ui/setup.hpp"
using namespace bmh;
using namespace bmh::ui;
namespace {
int counted_draws = 0;
void count_draw(int) { ++counted_draws; }
void check(bool ok, const char* message) {
if (!ok) throw std::runtime_error(message);
}
void rejected(const std::function<void()>& action) {
try { action(); } catch (const FormatError&) { return; }
throw std::runtime_error("expected rejected league table input");
}
std::string original_league_title(const GameState& game, const LeImage& exe, int league) {
check(game.texts != nullptr, "independent title oracle needs Native TEXTD strings");
if (league < 5) {
// legacy routine chooses the shared domestic TEXTD row from the EXE's
// following suffix bytes. legacy routine appends this league's suffix
// through the literal TEXTD suffix template.
size_t text = size_t((::bmh::layout::Achievements_FormatError_TextPointer3 - ::bmh::layout::TextPointerTable) / 4);
for (int previous = 0; previous < league; ++previous)
if (exe.u8(::bmh::layout::Manager_FormatError_RuntimeField + uint32_t(previous) * 2) < 'B') ++text;
std::string name = (*game.texts)[text];
const uint8_t suffix = exe.u8(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField3 + uint32_t(league) * 2);
if (suffix != 0) {
std::string tail = (*game.texts)[size_t((::bmh::layout::Manager_FormatError_TextPointer2 - ::bmh::layout::TextPointerTable) / 4)];
check(!tail.empty(), "Original TEXTD league suffix template is present");
tail.back() = char(suffix);
name += tail;
}
return original_to_utf8(name);
}
// legacy routine maps foreign league n to Native nation/team 0x165+n-4.
return original_to_utf8(game.club_name(0x165 + league - 4));
}
}
int main(int argc, char** argv) {
try {
if (argc != 2) throw std::runtime_error("usage: ui_league_table_tests <BMH data>");
const std::filesystem::path data(argv[1]);
app::CareerSession session(data, 8128);
SetupOptions options;
ManagerChoice choice;
choice.name = "SIM";
choice.master_club = 0;
choice.strength = 2;
std::string error;
check(session.confirm_manager(options, choice, error), "engine manager setup failed");
CareerInitializationResult initialized;
check(session.finish(initialized, error), "engine career initialization failed");
// Keep the declared 60-event table fixture independent of F6 desk filtering.
session.state().memory.set8(::bmh::layout::MatchdaySetup_MatchdayNeedsManagerDesks_RuntimeField,1);
uint64_t revision = initialized.desktop.revision;
for (int turn = 0; turn < 60; ++turn) {
const auto desk = session.desktop_projection(revision);
DeskRequest request;
request.kind = DeskRequestKind::advance_turn;
request.manager_slot = desk.manager_slot;
request.revision = revision;
const auto advanced = session.dispatch_kickoff(request, revision, error);
check(advanced.kind != TurnDeskKind::Failed, "engine turn failed before table projection");
}
const int manager = session.desktop_projection(revision).manager_slot;
const auto exe = load_le(asset_path(data, "BMH.exe"));
const auto& game = session.state();
const auto old_draw_hook = draw_hook;
counted_draws = 0;
draw_hook = count_draw;
const auto tables = league_tables_from_game(game, manager);
int played_games = 0;
for (int league = 0; league < kLeagueCount; ++league) {
const auto& actual = tables[size_t(league)];
const auto reference = compute_league_table(game, league, 0, league_matchdays(league), 7, 1);
check(actual.manager_slot == manager && actual.league_id == league &&
actual.rows.size() == size_t(kLeagueSizes[league]) && actual.points_mode == 1,
"all leagues project an owned state with the engine's configured points rule");
check(!actual.league_name.empty() && actual.league_name == original_league_title(game, exe, league),
"league heading follows the independent EXE-suffix/TEXTD/Nation-ID oracle");
std::array<int, 20> order{};
for (int club = 0; club < reference.size; ++club) order[size_t(club)] = club;
std::sort(order.begin(), order.begin() + reference.size,
[&](int a, int b) { return reference.rank(a) < reference.rank(b); });
for (int row_index = 0; row_index < reference.size; ++row_index) {
const int club = order[size_t(row_index)];
const int runtime = league_first_team(league) + club;
const auto& row = actual.rows[size_t(row_index)];
check(row.rank == reference.rank(club) + 1 && row.runtime_team_id == runtime &&
row.club_identity_key == game.club_ids[size_t(runtime)] &&
row.name == original_to_utf8(game.club_name(runtime)) &&
row.games == reference.games(club) && row.wins == reference.wins[size_t(club)] &&
row.draws == reference.games(club) - reference.wins[size_t(club)] - reference.defeats[size_t(club)] &&
row.losses == reference.defeats[size_t(club)] && row.goals_for == reference.goals_for[size_t(club)] &&
row.goals_against == reference.goals_against[size_t(club)] &&
row.points == reference.points[size_t(club)],
"owned row preserves actual engine rank, identity, name and aggregate data");
played_games += row.games;
}
}
// Every domestic title was compared above with an independent reader of
// the externally supplied edition's text and suffix tables.
GameState localized = game;
constexpr int localized_nation = 0x166; // foreign league 5: 0x165 + 5 - 4
const std::string localized_bytes = utf8_to_original("Österreich");
check(localized.club_names.size() <= 0xffffu, "Native name pool leaves a representable offset");
const uint16_t localized_offset = uint16_t(localized.club_names.size());
localized.club_names.insert(localized.club_names.end(), localized_bytes.begin(), localized_bytes.end());
localized.club_names.push_back(0);
localized.club_ids.at(size_t(localized_nation)) = localized_offset;
const auto localized_table = league_table_from_game(localized, manager, 5);
check(localized_table.league_name == "Österreich" &&
localized_table.league_name == original_league_title(localized, exe, 5),
"foreign title follows a localized Native nation name, not a TEXTD league slot");
check(played_games > 0, "60 deterministic engine turns yield played league-table rows");
check(counted_draws == 0, "table projection consumes no random values");
auto display_tables = tables;
display_tables[0].rows[0].name = "München";
LeagueTableScreen screen(data, display_tables, 0);
check(screen.selected_league() == 0 && !screen.close_requested(), "screen starts on its explicit league");
const auto rendered = screen.render();
check(rendered.width == 320 && rendered.height == 240 && rendered.pixels == screen.render().pixels,
"native-sized table render is stable");
const auto font = load_font(asset_path(data / "F", "BMH3.FNT"));
Image expected = load_vga(asset_path(data / "KB", "129.VGA"));
const auto background = load_vga(asset_path(data / "KB", "56.VGA"));
const auto mode5 = SpriteFont(data);
const int title_width = mode5.text_width(display_tables[0].league_name);
check(SpriteFont::centered_title_x(9) == 223,
"mode-5 title uses source integer-division order for odd widths");
mode5.draw(expected, SpriteFont::centered_title_x(title_width),
13, display_tables[0].league_name);
const int crop_height = int(display_tables[0].rows.size()) * 7 + 9;
for (int y = 0; y < crop_height; ++y)
for (int x = 0; x < 318; ++x)
expected.pixels[size_t(y + 21) * 320 + x + 1] = background.pixels[size_t(y + 1) * background.width + x];
font.draw(expected, 30, 0x23 - font.baseline, "M}nchen", display_tables[0].rows[0].name_color);
const auto& first_row = display_tables[0].rows[0];
uint8_t expected_name_color = 0x5f;
bool matched_manager = false;
const int active_manager = game.memory.has(::bmh::layout::ActiveManager) ? game.memory.u8(::bmh::layout::ActiveManager) : -1;
const int manager_count = game.memory.has(::bmh::layout::ManagerCount) ? game.memory.u8(::bmh::layout::ManagerCount) : int(game.manager_teams.size());
const bool current_human = game.memory.has(::bmh::layout::DeskPosition) && game.memory.u8(::bmh::layout::DeskPosition) < manager_count;
for (size_t slot = 0; slot < game.manager_teams.size() && slot < 4; ++slot) {
const size_t record = slot * 0xb0c;
if (record + 0x291 >= game.manager_records.size() || game.manager_records.at(record + 0xa8) == 0) continue;
const int team = game.manager_teams.at(slot);
if (team == first_row.runtime_team_id) {
expected_name_color = int(slot) == active_manager && current_human ? 0x7a : 0x75;
matched_manager = true;
break;
}
}
if (!matched_manager && game.memory.has(::bmh::layout::AlltimeTable_TeamColor_RuntimeField) && game.memory.u16(::bmh::layout::AlltimeTable_TeamColor_RuntimeField) == first_row.runtime_team_id)
expected_name_color = 0xf7;
check(first_row.name_color == expected_name_color,
"name emphasis follows the manager/world color-source rules");
const int baseline = 0x23;
const std::string wuv = format_number(game, first_row.games, 0x82) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer4) +
format_number(game, first_row.wins, 2) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer5) +
format_number(game, first_row.draws, 2) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer5) +
format_number(game, first_row.losses, 2) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer4);
const std::string points = exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer6) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer7) +
format_number(game, first_row.points, 2) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer8) + exe.cstring(::bmh::layout::LeagueTable_Glyph_TextPointer);
const int difference = first_row.goals_for - first_row.goals_against;
const std::string goals = format_number(game, first_row.goals_for, 0x83) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer9) +
format_number(game, first_row.goals_against, 3) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer10) +
exe.cstring(difference < 0 ? ::bmh::layout::Bank_OriginalToUtf8_ExecutableField5 : difference > 0 ? ::bmh::layout::Bank_OriginalToUtf8_ExecutableField6 : ::bmh::layout::Bank_OriginalToUtf8_ExecutableField7) +
format_number(game, std::abs(difference), 3) + exe.cstring(::bmh::layout::CupDraw_DrawGroupOverview_TextPointer11);
font.draw(expected, 0x72, baseline - font.baseline, wuv, 0x6a);
font.draw(expected, 0xce, baseline - font.baseline, points, 0x6a);
font.draw(expected, 0xff, baseline - font.baseline, goals, 0x6a);
for (int y = baseline - font.baseline; y < baseline - font.baseline + font.height; ++y)
for (int x = 30; x < 108; ++x)
check(rendered.pixels[size_t(y) * 320 + x] == expected.at(x, y),
"source-cropped VGA backdrop, source row baseline and UTF-8 font boundary are preserved");
for (const auto [left, right] : {std::pair{0x72,0xce}, std::pair{0xce,0xff}, std::pair{0xff,319}})
for (int y = baseline - font.baseline; y < baseline - font.baseline + font.height; ++y)
for (int x = left; x < right; ++x)
check(rendered.pixels[size_t(y) * 320 + x] == expected.at(x, y),
"original numeric widths, separators and column coordinates are preserved");
check(rendered.pixels.front() == expected.pixels.front() &&
rendered.pixels.back() == expected.pixels.back(),
"KB/129 desktop backdrop remains outside the exact legacy routine panel crop");
const int bottom = int(screen.state().rows.size()) * 7 + 30;
check(rendered.pixels[20 * 320] == 0x46 && rendered.pixels[20 * 320 + 319] == 0x40 &&
rendered.pixels[bottom * 320 + 100] == 0x40,
"original panel border surrounds the same crop in both display modes");
auto flat_tables = tables;
for (auto& t : flat_tables) { t.original_table_panel = false; t.decorated_background = false; }
LeagueTableScreen flat_screen(data, flat_tables, 0);
const auto flat = flat_screen.render();
check(flat.pixels[28 * 320 + 200] == 0x42 && flat.pixels[20 * 320] == 0x46 &&
flat.pixels[20 * 320 + 319] == 0x40 && flat.pixels[5 * 320 + 1] == 0x39 &&
flat.pixels[238 * 320 + 100] == 0,
"saved undecorated/flat options preserve Original panel fill, borders and outer frame");
for (int y = 13 - 6; y < 13 + 1; ++y)
for (int x = 172; x < 282; ++x)
check(rendered.pixels[size_t(y) * 320 + x] == expected.at(x, y),
"league name is rendered at the source title position over KB/129");
const auto initial_json = league_table_json(screen.state());
check(initial_json.find("\"name\":\"München\"") != std::string::npos,
"owned JSON retains UTF-8 names");
check(!screen.click(50, 180) && screen.selected_league() == 0,
"no unsupported mouse hitbox is exposed");
check(screen.key("LEFT") && screen.selected_league() == kLeagueCount - 1 &&
screen.key("RIGHT") && screen.selected_league() == 0,
"local left/right paging changes only the selected owned league projection");
check(league_table_json(screen.state()) == initial_json && counted_draws == 0,
"rendering and ignored input remain presentation-only and drawless");
check(screen.key("ESC") && screen.close_requested() && !screen.key("RIGHT"),
"escape closes the screen without dispatching an engine action");
LeagueTableScreen picker(data,tables,0,LeagueTableScreen::OpponentMode{});
bool selected_third=false;
for (int y=176;y<=216&&!selected_third;++y) {
for (int x=205;x<=260;++x) {
picker.pointer_down(x,y);
if (picker.selected_league()!=3) continue;
std::cout << "Opponent selector league3: " << x << ',' << y << '\n';
selected_third=true;break;
}
}
check(selected_third && !picker.pending_family_action() && !picker.close_requested(),
"Source opponent league map selects an owned league without a family transaction");
bool toggled=false;
for (int y=176;y<=216&&!toggled;++y) {
for (int x=262;x<=317;++x) {
if (!picker.pointer_down(x,y)) continue;
check(picker.selected_league()==5 && !picker.pending_family_action(),
"Source opponent country selector opens the foreign base league");
check(picker.pointer_down(x,y) && picker.selected_league()==0,
"returning from foreign group restores the opponent picker's manager default league");
std::cout << "Opponent country selector: " << x << ',' << y << '\n';
toggled=true;break;
}
}
check(toggled && picker.state()==tables[0] && counted_draws==0,
"map and country paging preserve the immutable projections and consume no random draws");
check(picker.pointer_down(162,207) && !picker.close_requested() && picker.click(162,207) &&
picker.close_requested() && !picker.pending_family_action(),
"mode2 footer closes only after matching button release, without a family request");
StrengthsIdentity family_identity;
family_identity.manager = manager;
family_identity.runtime_club = game.manager_teams.at(size_t(manager));
family_identity.club_identity = int(game.club_ids.at(size_t(family_identity.runtime_club)));
family_identity.league = 0;
family_identity.day_counter = game.date;
family_identity.league_group = 0;
family_identity.manager_default_league = game.manager_records.at(size_t(manager) * 0xb0c + 0x210);
family_identity.revision = 17;
family_identity.scope = 9;
family_identity.sequence = 0;
family_identity.expected_family_word = tables[0].display_word;
LeagueTableScreen family_screen(data, tables, 0,
LeagueTableScreen::FamilyMode{family_identity});
const auto family_image = family_screen.render();
check(family_image.width == 320 && family_image.height == 240,
"family mode renders the Original 12-button footer and league selectors at screen size");
const auto family_texts = load_textd(asset_path(data, "TEXTD.BLK"));
const auto family_title = original_to_utf8(family_texts[(::bmh::layout::LeagueTable_OriginalToUtf8_TextPointer - ::bmh::layout::TextPointerTable) / 4]) + tables[0].league_name;
const int raw_family_round = game.league_rounds.at(0);
const int family_round = (raw_family_round & 0x7f) + 1;
const auto family_subtitle = original_to_utf8(
message_text(game, raw_family_round & 0x80 ? ::bmh::layout::LeaguePairings_FormatError_TextPointer4 : ::bmh::layout::CareerSession_FormatError_TextPointer2) +
format_number(game, family_round, 1) + exe.cstring(::bmh::layout::CareerSession_FormatError_TextPointer) + message_text(game, ::bmh::layout::CareerSession_FormatError_TextPointer4));
Image expected_family_headings = load_vga(asset_path(data / "KB", "129.VGA"));
mode5.draw(expected_family_headings, SpriteFont::centered_title_x(mode5.text_width(family_title)),
13, family_title);
mode5.draw(expected_family_headings, 5, 235, family_subtitle);
for (int y = 7; y < 20; ++y)
for (int x = 0; x < 320; ++x)
check(family_image.pixels[size_t(y) * 320 + x] == expected_family_headings.pixels[size_t(y) * 320 + x],
"family title uses legacy routine's German TextD prefix and league name");
for (int y = 229; y < 240; ++y)
for (int x = 0; x < 320; ++x)
check(family_image.pixels[size_t(y) * 320 + x] == expected_family_headings.pixels[size_t(y) * 320 + x],
"family round subtitle uses Source TextD, high-bit selector and EXE number separator");
auto flagged_round_tables = tables;
flagged_round_tables[0].rounds_played |= 0x80;
LeagueTableScreen flagged_round_screen(data, flagged_round_tables, 0,
LeagueTableScreen::FamilyMode{family_identity});
const auto flagged_round_image = flagged_round_screen.render();
Image expected_flagged_subtitle = load_vga(asset_path(data / "KB", "129.VGA"));
const auto flagged_subtitle = original_to_utf8(
message_text(game, ::bmh::layout::LeaguePairings_FormatError_TextPointer4) + format_number(game, family_round, 1) +
exe.cstring(::bmh::layout::CareerSession_FormatError_TextPointer) + message_text(game, ::bmh::layout::CareerSession_FormatError_TextPointer4));
mode5.draw(expected_flagged_subtitle, 5, 235, flagged_subtitle);
for (int y = 229; y < 240; ++y)
for (int x = 0; x < 320; ++x)
check(flagged_round_image.pixels[size_t(y) * 320 + x] == expected_flagged_subtitle.pixels[size_t(y) * 320 + x],
"saved round high-bit selects legacy routine's alternate round fragment");
auto footer_word_set = family_identity;
footer_word_set.expected_family_word |= 0x80;
auto footer_word_clear = family_identity;
footer_word_clear.expected_family_word &= uint16_t(~0x80);
LeagueTableScreen footer_word_set_screen(data, tables, 0,
LeagueTableScreen::FamilyMode{footer_word_set});
LeagueTableScreen footer_word_clear_screen(data, tables, 0,
LeagueTableScreen::FamilyMode{footer_word_clear});
const auto footer_set_image = footer_word_set_screen.render();
const auto footer_clear_image = footer_word_clear_screen.render();
for (int y = 215; y <= 225; ++y)
for (int x = 66; x <= 129; ++x)
check(footer_set_image.pixels[size_t(y) * 320 + x] == footer_clear_image.pixels[size_t(y) * 320 + x],
"legacy routine masks display bit 7 before drawing the Norm. Modus footer control");
check(!family_screen.click(162, 207) && !family_screen.pending_family_action(),
"family semantic action cannot be activated without a physical button-down");
check(family_screen.pointer_down(162, 207) && !family_screen.pending_family_action(),
"footer pointer-down provides pressed state without dispatching its family action");
check(family_screen.render().pixels != family_image.pixels && family_screen.move(230, 220) &&
!family_screen.click(162, 207) && !family_screen.pending_family_action(),
"held footer feedback is visible and moving off the original hit cancels its release");
check(family_screen.pointer_down(162, 207), "footer can be pressed again after a canceled gesture");
check(family_screen.click(162, 207) && family_screen.pending_family_action() &&
family_screen.pending_family_action()->kind == LeagueFamilyRequestKind::navigate &&
family_screen.pending_family_action()->from_child == 1 &&
family_screen.pending_family_action()->target_child == 2,
"Original table footer index 10 routes to pairings with a typed family request");
family_screen.reject_family_action("test acknowledgement");
check(family_screen.pointer_down(162, 220) && family_screen.click(162, 220) && family_screen.pending_family_action() &&
family_screen.pending_family_action()->target_child == 3,
"Original table footer index 11 routes to strengths with a typed family request");
family_screen.reject_family_action("test acknowledgement");
check(family_screen.pointer_down(10, 180) && family_screen.click(10, 180) && family_screen.pending_family_action() &&
family_screen.pending_family_action()->kind == LeagueFamilyRequestKind::control &&
family_screen.pending_family_action()->control_index == 0,
"non-navigation footer actions are emitted as explicit typed controls");
family_screen.reject_family_action("test acknowledgement");
bool found_selector = false;
for (int y = 176; y <= 216 && !found_selector; ++y) {
for (int x = 205; x <= 317; ++x) {
if (!family_screen.pointer_down(x, y)) continue;
check(family_screen.selected_league() == 0,
"league/group selector action does not mutate the child before owner acknowledgement");
const auto& action = family_screen.pending_family_action();
if (action && action->kind == LeagueFamilyRequestKind::select_league) {
check(action->league_id >= 0 && action->league_id < kLeagueCount &&
family_screen.selected_league() == 0,
"Original league selector emits a bounded semantic selection without local mutation");
found_selector = true;
break;
}
}
}
check(found_selector, "original KB/1 league map or group selector exposes a semantic action");
family_screen.reject_family_action("test acknowledgement");
bool found_group_toggle = false;
for (int y = 176; y <= 216 && !found_group_toggle; ++y) {
for (int x = 262; x <= 317; ++x) {
if (!family_screen.pointer_down(x, y)) continue;
const auto& action = family_screen.pending_family_action();
if (action && action->kind == LeagueFamilyRequestKind::toggle_league_group) {
check(action->league_id == int(exe.u8(::bmh::layout::CareerSession_FormatError_RuntimeField4)) && family_screen.selected_league() == 0,
"domestic-to-secondary toggle selects Source foreign base without local mutation");
found_group_toggle = true;
break;
}
}
}
check(found_group_toggle, "Source group selector dispatches on physical DOWN");
family_screen.reject_family_action("test acknowledgement");
auto foreign_identity = family_identity;
foreign_identity.league = exe.u8(::bmh::layout::CareerSession_FormatError_RuntimeField4);
foreign_identity.league_group = 1;
LeagueTableScreen foreign_family_screen(data, tables, foreign_identity.league,
LeagueTableScreen::FamilyMode{foreign_identity});
bool found_return_toggle = false;
for (int y = 176; y <= 216 && !found_return_toggle; ++y) {
for (int x = 262; x <= 317; ++x) {
if (!foreign_family_screen.pointer_down(x, y)) continue;
const auto& action = foreign_family_screen.pending_family_action();
if (action && action->kind == LeagueFamilyRequestKind::toggle_league_group) {
check(action->league_id == family_identity.manager_default_league &&
foreign_family_screen.selected_league() == foreign_identity.league,
"secondary-to-domestic toggle returns to the owner manager's saved league");
found_return_toggle = true;
break;
}
}
}
check(found_return_toggle, "Source group selector uses manager-default return league");
check(family_screen.pointer_down(310, 153) && family_screen.pending_family_action() &&
family_screen.pending_family_action()->kind == LeagueFamilyRequestKind::team_info &&
family_screen.pending_family_action()->runtime_team == tables[0].rows.back().runtime_team_id &&
family_screen.pending_family_action()->expected_club_identity == tables[0].rows.back().club_identity_key,
"last valid 18-team row y=153 resolves the typed TeamInfo runtime and stable identities");
family_screen.reject_family_action("test acknowledgement");
check(!family_screen.pointer_down(310, 154) && !family_screen.click(310, 154) && !family_screen.pending_family_action(),
"strict Original row lower bound rejects y=154 for an 18-row table");
check(family_screen.pointer_down(310, 29) && family_screen.pending_family_action() &&
family_screen.pending_family_action()->runtime_team == tables[0].rows.front().runtime_team_id,
"first row band begins at y=29 without inventing an x-only name hitbox");
family_screen.reject_family_action("test acknowledgement");
check(family_screen.pointer_down(297, 132, true) && family_screen.pending_family_action() &&
family_screen.pending_family_action()->kind == LeagueFamilyRequestKind::close &&
family_screen.pending_family_action()->target_child == 0,
"right-button close requests the family owner, not a local table teardown");
family_screen.reject_family_action("test acknowledgement");
check(!family_screen.key("ESC") && !family_screen.pending_family_action(),
"family mode does not invent an unverified Source Escape mapping");
rejected([&] { (void)league_table_from_game(game, -1, 0); });
rejected([&] { (void)league_table_from_game(game, manager, kLeagueCount); });
auto incomplete = tables;
incomplete[3].rows.pop_back();
rejected([&] { LeagueTableScreen invalid(data, incomplete, 0); });
rejected([&] { LeagueTableScreen invalid(data, tables, kLeagueCount); });
draw_hook = old_draw_hook;
std::cout << "Owned league table projection and read-only screen passed.\n";
return 0;
} catch (const std::exception& e) {
draw_hook = nullptr;
std::cerr << e.what() << '\n';
return 1;
}
}