Files
Dreierpack-Manager/tests/driver_barrier_tests.cpp

277 lines
16 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include <cassert>
#include <cstdint>
#include <vector>
#include <cstdio>
#include <stdexcept>
#include "game/driver.hpp"
using namespace bmh;
static MatchGroup league_group(uint32_t id, bool played) {
MatchGroup g;
g.desc.resize(0xD0);
g.desc[0xcc] = uint8_t(id);
g.end_minute = {0};
g.fixtures = {1, 2};
g.results = {0x21};
g.ended = played ? 1u : 0u;
return g;
}
// legacy routine uses one local_48 for the whole phase (Original instructions
// 36ae7/3705c/38ae8), including league groups already settled at minute 90.
// Verify the caller policy and the exact 53435 -> 21213 W/G consequence;
// do not use end_phase/stir_random as the expected-value oracle.
static void mixed_extra_time_policy() {
auto require = [](bool value, const char* message) {
if (!value) throw std::runtime_error(message);
};
for (int last : {105, 120}) {
for (bool cup_first : {false, true}) {
for (bool league_visible : {false, true}) {
GameState state;
state.memory.add_block(0, ::bmh::layout::FixtureBankMemoryImageSize);
state.memory.set16(0x15 + 0x18, 0);
state.memory.set8(::bmh::layout::FriendlyPlanCount, 1);
auto league = league_group(0, false);
league.desc[0xb8] = 1; // finished/void, NOT active in extra time
league.end_minute[0] = 90;
auto cup = league_group(0x15, true);
cup.desc[1] = 8;
cup.results.clear();
cup.cup_results = {0x400}; // tied and going into extra time
std::vector<MatchGroup> groups = cup_first
? std::vector<MatchGroup>{cup, league} : std::vector<MatchGroup>{league, cup};
const uint32_t league_index = cup_first ? 1 : 0;
const uint32_t cup_index = 1 - league_index;
const auto old_league = groups[league_index];
std::vector<uint8_t> switches(0xb4, 1);
switches[last == 120 ? 2 : 1] = league_visible ? 0 : 1;
switches[5 * 9 + 2] = 0; // cup's saved result switch
GameRandom game(17);
WatcomRandom rand(29);
MinuteReport report;
PhaseEndCursor cursor;
auto out = begin_phase_end(cursor, 900 + last, state, groups, last,
switches, game, rand, report);
uint32_t expected_w = 29;
int32_t expected_g = 17;
uint64_t expected_g_calls = 0, expected_w_calls = 0;
std::vector<uint32_t> seen;
while (out.status == PhaseEndStatus::Waiting && out.request) {
const auto request = *out.request;
seen.push_back(request.group_index);
require(request.phase_end_minute == last && request.matches.size() == 1,
"mixed phase retains Source minute and actual fixture");
if (request.kind == PhaseResultKind::League) {
require(request.group_index == league_index && request.matches[0].home_score == 2 &&
request.matches[0].away_score == 1,
"global phase gate includes settled league's actual score");
expected_w = expected_w * 0x41c64e6du + 0x3039u;
const uint32_t n = 100 + (((expected_w >> 16) & 0x7fffu) * 201u >> 15);
++expected_w_calls;
expected_g_calls += n;
for (uint32_t i = 0; i < n; ++i)
expected_g = int32_t(uint32_t(expected_g) * 16u + 0xa7u) % 4000000;
} else {
require(request.group_index == cup_index && request.competition_id == 0,
"mixed phase retains actual cup identity");
}
const PhaseResultReply ack{request.phase_id, request.group_index, request.revision};
out = continue_phase_end(cursor, ack);
require(game.seed() == expected_g && game.calls() == expected_g_calls &&
rand.seed() == expected_w && rand.calls() == expected_w_calls,
"each ACK follows independent Original W/G arithmetic");
const auto duplicate = continue_phase_end(cursor, ack);
require(duplicate.status == out.status && game.seed() == expected_g &&
game.calls() == expected_g_calls && rand.seed() == expected_w &&
rand.calls() == expected_w_calls,
"duplicate mixed-group ACK cannot repeat Source draws");
require(bool(duplicate.request) == bool(out.request) &&
(!out.request || duplicate.request->group_index == out.request->group_index),
"duplicate ACK preserves the next result request");
}
const std::vector<uint32_t> expected = league_visible
? std::vector<uint32_t>{0, 1} : std::vector<uint32_t>{cup_index};
require(out.status == PhaseEndStatus::Complete && seen == expected,
"global gate follows Original group order and saved phase switches");
require(groups[league_index].desc == old_league.desc &&
groups[league_index].end_minute == old_league.end_minute &&
groups[league_index].results == old_league.results,
"showing a settled league never settles its match again");
require(state.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField3) == 7 && groups[cup_index].cup_results[0] ==
(last == 120 ? 0x800 : 0x400) &&
groups[cup_index].end_minute[0] == (last == 120 ? 120 : 0),
"cup effects and extra-time settlement remain at their Source boundaries");
// The reused cursor must discard the previous phase's global gate.
for (auto& group : groups) group.ended = 0;
out = begin_phase_end(cursor, 1200 + last, state, groups, 105,
switches, game, rand, report);
require(out.status == PhaseEndStatus::Complete &&
game.calls() == expected_g_calls && rand.calls() == expected_w_calls,
"a wholly unplayed later phase opens no result and draws nothing");
}
}
}
}
int main() {
mixed_extra_time_policy();
GameState s;
MinuteReport report;
std::vector<uint8_t> buttons(0xB4, 0);
GameRandom game(17), sync_game(17);
WatcomRandom rand(29), sync_rand(29);
auto groups = std::vector<MatchGroup>{league_group(0, true), league_group(1, true)};
auto sync_groups = groups;
PhaseEndCursor c;
auto out = begin_phase_end(c, 77, s, groups, 90, buttons, game, rand, report);
assert(out.status == PhaseEndStatus::Waiting && out.request);
assert(out.request->group_index == 0 && out.request->phase_id == 77);
assert(out.request->matches.size() == 1 && out.request->matches[0].home_team == 1);
assert(out.request->matches[0].score_known && out.request->matches[0].home_score == 2);
const auto req0 = *out.request;
auto same_begin = begin_phase_end(c, 77, s, groups, 90, buttons, game, rand, report);
assert(same_begin.status == PhaseEndStatus::Waiting && same_begin.request->revision == req0.revision);
auto different_begin = begin_phase_end(c, 999, s, groups, 90, buttons, game, rand, report);
assert(different_begin.status == PhaseEndStatus::Rejected && game.calls() == 0 && rand.calls() == 0);
auto polled = continue_phase_end(c);
assert(polled.status == PhaseEndStatus::Waiting && polled.request->revision == req0.revision);
assert(game.calls() == 0 && rand.calls() == 0);
assert(groups[0].end_minute[0] == 0);
auto wrong = continue_phase_end(c, PhaseResultReply{77, 1, req0.revision});
assert(wrong.status == PhaseEndStatus::Rejected && game.calls() == 0 && rand.calls() == 0);
out = continue_phase_end(c, PhaseResultReply{req0.phase_id, req0.group_index, req0.revision});
assert(out.status == PhaseEndStatus::Waiting && out.request->group_index == 1);
assert(groups[0].end_minute[0] == 90);
auto duplicate = continue_phase_end(c, PhaseResultReply{req0.phase_id, req0.group_index, req0.revision});
assert(duplicate.status == PhaseEndStatus::Waiting && duplicate.request->group_index == 1);
const uint64_t game_calls = game.calls(), rand_calls = rand.calls();
auto stale = continue_phase_end(c, PhaseResultReply{77, 0, req0.revision});
assert(stale.status == PhaseEndStatus::Waiting && game.calls() == game_calls && rand.calls() == rand_calls);
const auto req1 = *out.request;
out = continue_phase_end(c, PhaseResultReply{req1.phase_id, req1.group_index, req1.revision});
assert(out.status == PhaseEndStatus::Complete);
auto duplicate_final = continue_phase_end(c, PhaseResultReply{req1.phase_id, req1.group_index, req1.revision});
assert(duplicate_final.status == PhaseEndStatus::Complete);
auto completed_begin = begin_phase_end(c, 77, s, groups, 90, buttons, game, rand, report);
assert(completed_begin.status == PhaseEndStatus::Complete);
end_phase(s, sync_groups, 90, buttons, sync_game, sync_rand, report);
assert(game.calls() == sync_game.calls() && game.seed() == sync_game.seed());
assert(rand.calls() == sync_rand.calls() && rand.seed() == sync_rand.seed());
assert(groups[0].desc == sync_groups[0].desc && groups[1].desc == sync_groups[1].desc);
auto hidden_groups = std::vector<MatchGroup>{league_group(0, true)};
buttons[2] = 1; // second-half result screen for league 0 is switched off
GameRandom hidden_game(7);
WatcomRandom hidden_rand(8);
PhaseEndCursor hidden;
auto hidden_out = begin_phase_end(hidden, 78, s, hidden_groups, 90, buttons,
hidden_game, hidden_rand, report);
assert(hidden_out.status == PhaseEndStatus::Complete);
assert(hidden_game.calls() == 0 && hidden_rand.calls() == 0);
GameState cup_state;
cup_state.memory.add_block(0, ::bmh::layout::FixtureBankMemoryImageSize);
cup_state.memory.set16(0x15 + 0x18, 0);
cup_state.memory.set8(::bmh::layout::FriendlyPlanCount, 1); // avoid the unrelated competition-closure path
auto cup = league_group(0x15, true);
cup.end_minute = {0};
std::vector<MatchGroup> cup_groups{cup};
GameRandom cup_game(5);
WatcomRandom cup_rand(6);
PhaseEndCursor cup_cursor;
auto cup_out = begin_phase_end(cup_cursor, 80, cup_state, cup_groups, 90, {},
cup_game, cup_rand, report);
assert(cup_out.status == PhaseEndStatus::Waiting && cup_out.request);
assert(cup_out.request->kind == PhaseResultKind::Cup && cup_out.request->competition_id == 0);
assert(cup_state.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField3) == 7 && cup_groups[0].end_minute[0] == 0);
if (cup_state.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField3) != 7 || cup_groups[0].end_minute[0] != 0)
throw std::runtime_error("Source cup entry effects precede presentation and settlement");
cup_state.memory.set8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField, 0x82); // synthetic edited byte: ACK must not reinitialize it
cup_out = continue_phase_end(cup_cursor, PhaseResultReply{80, 0, cup_out.request->revision});
assert(cup_out.status == PhaseEndStatus::Complete);
assert(cup_state.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField3) == 7 && cup_groups[0].end_minute[0] == 90);
assert(cup_state.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField) == 0x82);
if (cup_state.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField) != 0x82)
throw std::runtime_error("cup ACK must preserve the viewer's Source preference edit");
auto tied_cup = league_group(0x15, true);
tied_cup.desc[1] = 8;
tied_cup.end_minute = {0};
tied_cup.results.clear();
tied_cup.cup_results = {0};
std::vector<MatchGroup> extra_groups{tied_cup};
PhaseEndCursor extra_time;
auto extra_out = begin_phase_end(extra_time, 81, cup_state, extra_groups, 90, {},
cup_game, cup_rand, report);
assert(extra_out.status == PhaseEndStatus::Waiting && extra_groups[0].cup_results[0] == 0);
extra_out = continue_phase_end(extra_time,
PhaseResultReply{81, 0, extra_out.request->revision});
assert(extra_out.status == PhaseEndStatus::Complete && extra_groups[0].cup_results[0] == 0x400);
PhaseEndCursor final_time;
extra_out = begin_phase_end(final_time, 82, cup_state, extra_groups, 120, {},
cup_game, cup_rand, report);
assert(extra_out.status == PhaseEndStatus::Waiting && extra_groups[0].cup_results[0] == 0x400);
assert(extra_groups[0].end_minute[0] == 0);
extra_out = continue_phase_end(final_time,
PhaseResultReply{82, 0, extra_out.request->revision});
assert(extra_out.status == PhaseEndStatus::Complete && extra_groups[0].cup_results[0] == 0x800);
assert(extra_groups[0].end_minute[0] == 120);
auto unplayed_groups = std::vector<MatchGroup>{league_group(0, false)};
buttons[2] = 0;
PhaseEndCursor unplayed;
auto unplayed_out = begin_phase_end(unplayed, 79, s, unplayed_groups, 90, buttons,
hidden_game, hidden_rand, report);
assert(unplayed_out.status == PhaseEndStatus::Complete);
assert(hidden_game.calls() == 0 && hidden_rand.calls() == 0);
// The synchronous presenter observes each existing barrier before its ACK.
// This must not bypass the saved switch or move Source effects into the UI.
auto require = [](bool value, const char* message) {
if (!value) throw std::runtime_error(message);
};
auto presented_groups = std::vector<MatchGroup>{league_group(0, true), league_group(1, true)};
auto quiet_groups = presented_groups;
GameRandom pg(17), qg(17); WatcomRandom pw(29), qw(29);
std::vector<PhaseResultRequest> shown;
std::vector<uint8_t> enabled(0xb4, 0);
auto presenter = [&](const PhaseResultRequest& request, const std::vector<MatchGroup>& view,
const GameState& state) {
require(&state == &s && request.group_index == shown.size() && request.phase_end_minute == 90,
"presenter receives the real state and Source group order");
require(view[request.group_index].end_minute[0] == 0 && request.matches[0].home_score == 2 &&
request.matches[0].away_score == 1, "owned scores precede group settlement");
shown.push_back(request);
};
end_phase(s, presented_groups, 90, enabled, pg, pw, report, presenter);
end_phase(s, quiet_groups, 90, enabled, qg, qw, report);
require(shown.size() == 2 && pg.seed() == qg.seed() && pg.calls() == qg.calls() &&
pw.seed() == qw.seed() && pw.calls() == qw.calls() &&
presented_groups[0].desc == quiet_groups[0].desc && presented_groups[1].desc == quiet_groups[1].desc,
"presentation preserves single Source ACK effects and both RNG streams");
shown.clear(); enabled[2] = 1;
auto disabled = std::vector<MatchGroup>{league_group(0, true)};
GameRandom dg(17); WatcomRandom dw(29);
end_phase(s, disabled, 90, enabled, dg, dw, report, presenter);
require(shown.empty() && dg.calls() == 0 && dw.calls() == 0,
"disabled Source result switch suppresses presenter and ACK RNG");
enabled[2] = 0;
auto aborted = std::vector<MatchGroup>{league_group(0, true)};
GameRandom ag(17); WatcomRandom aw(29);
bool interrupted = false;
try {
end_phase(s, aborted, 90, enabled, ag, aw, report,
[](const auto&, const auto&, const auto&) { throw std::runtime_error("presenter stopped"); });
} catch (const std::runtime_error&) { interrupted = true; }
require(interrupted && ag.calls() == 0 && aw.calls() == 0 && aborted[0].end_minute[0] == 0 &&
aborted[0].void_mask() == 0, "interrupted presenter cannot silently ACK or settle its group");
std::puts("PASS: global Original phase gate, mixed 105/120 groups in both orders, saved switches, independent W/G, duplicate ACKs, settled league preservation and empty next phase; synchronous presenter invariants");
}