Fork the Classic season core into src/modern and add the world layout (M1)

- src/modern/game: the season modules as bmh::modern, working on ModernState
  (a GameState). Data types stay shared with Classic; Modern code calls its
  season functions qualified (modern::...), so a missing Modern function is a
  compile error instead of a silent call into Classic.
- src/modern/app/modern_session: the session on the Modern core. It still uses
  the Classic UI projections until the Modern projections exist.
- SeasonHooks: the shared match core reaches player statistics and the table
  prediction of the season core that owns the game (Classic: unchanged).
- WorldLayout: team ranges, squad slots and pools of the running world. Shared
  code and the Modern fork read them; Classic keeps the original numbers.
- Transfer list views moved to game/transfer_offer_view.hpp (shared).
- tools/modern/check_fork_calls.sh, modern_season_sim and world_layout_tests.

Verified: Classic tests and replay regression unchanged; season_sim and
modern_season_sim produce identical output with Classic data.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Opus 5.5 committed 2026-10-23 18:08:54 +02:00
1 parent badd08f05e
commit f2fcb28f65
81 files changed
+29351 -91

No files matched your search

+594
View File
@@ -0,0 +1,594 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include "modern/game/modern_state.hpp"
#include "modern/game/turn_driver.hpp"
#include <algorithm>
#include <array>
#include <exception>
#include "modern/game/desk.hpp"
#include "modern/game/driver.hpp"
#include "modern/game/matchday.hpp"
#include "modern/game/matchday_setup.hpp"
#include "game/trace.hpp"
#include "modern/game/national.hpp"
#include "modern/game/season.hpp"
#include "modern/game/turn.hpp"
#include "modern/game/week.hpp"
namespace bmh::modern {
namespace {
constexpr uint32_t kCalendar = ::bmh::layout::CompetitionCalendar;
// The calendar entry of a season day. The table has 366 days (0-365); a season that starts
// on 1 July and spans 29 February ends on day 366, where the original reads the next bytes
// of its data (the fixture pointer table at CareerSession_RuntimeError_ExecutableField) - no competition. OpenBMH deviates from
// the original here: such a day has no calendar entry (0) instead of whatever lies behind.
uint16_t calendar_day(const ModernState& g, int day) {
const uint32_t at = kCalendar + uint32_t(day) * 2;
return day >= 0 && g.memory.has(at + 1) && at + 1 < ::bmh::layout::CareerSession_RuntimeError_ExecutableField ? g.memory.u16(at) : uint16_t(0);
}
constexpr uint32_t kDeskButtons = ::bmh::layout::LeaguePresentationOptions;
constexpr uint32_t kSavedCompetition = ::bmh::layout::SavedCompetition;
constexpr uint32_t kCoachActive = ::bmh::layout::CoachActive;
constexpr uint32_t kOriginalManagerCount = ::bmh::layout::OriginalManagerCount;
constexpr uint32_t kManagerCount = ::bmh::layout::ManagerCount;
constexpr uint32_t kManagerOrder = ::bmh::layout::NextDeskManager;
constexpr uint32_t kDeskPosition = ::bmh::layout::DeskPosition;
constexpr uint32_t kActiveManager = ::bmh::layout::ActiveManager;
constexpr uint32_t kEventPasses = ::bmh::layout::EventPasses;
// DailyInterest sets the saved loop count once per calendar date: three Hall
// rounds on the first of two consecutive Hall days, two on the last day.
// Completing a round does not run another date/training/interest step.
void start_event_passes(ModernState& g, uint16_t entry) {
if (!g.memory.has(kEventPasses)) return;
uint8_t passes = 1;
if (entry == 0x4002) {
const uint32_t next = kCalendar + uint32_t(g.season_day() + 1) * 2;
passes = g.memory.has(next + 1) && g.memory.u16(next) == 0x4002 ? 3 : 2;
}
g.memory.set8(kEventPasses, passes);
}
bool consume_event_pass(TurnDriver& driver, ModernState& g) {
if (!g.memory.has(kEventPasses)) return false;
// Only the Hall calendar cell has multiple passes. Old OpenBMH saves
// carried a stale Hall count into ordinary dates; do not repeat leagues.
const bool hall = driver.calendar_entry == 0x4002 && g.indoor;
const uint8_t count = hall ? g.memory.u8(kEventPasses) : 1;
const uint8_t remaining = count == 0 ? 0 : uint8_t(count - 1);
g.memory.set8(kEventPasses, remaining);
return hall && remaining != 0;
}
std::vector<uint8_t> read_buttons(const ModernState& g) {
std::vector<uint8_t> result;
if (!g.memory.has(kDeskButtons + 0xb3)) return result;
result.reserve(0xb4);
for (uint32_t i = 0; i < 0xb4; ++i) result.push_back(g.memory.u8(kDeskButtons + i));
return result;
}
MatchdayContext matchday_context(const ModernState& g, std::vector<uint8_t>& referees) {
MatchdayContext context;
context.month = modern::month_code(g.date);
context.season_day = g.season_day();
context.weekday = modern::weekday_code(g.date);
context.referees = &referees;
return context;
}
bool saved_national_nomination_desk(const ModernState& g, const std::vector<MatchGroup>& groups,
uint16_t calendar_entry) {
const auto& mem = g.memory;
if (!groups.empty() || g.manager_teams.size() != 1 || g.manager_teams[0] != no_team() ||
!mem.has(kCalendar + uint32_t(g.season_day()) * 2 + 1) ||
!mem.has(kSavedCompetition + 3) || !mem.has(kCoachActive) ||
!mem.has(kOriginalManagerCount) || !mem.has(kManagerCount) ||
!mem.has(kManagerOrder + 1) || !mem.has(kDeskPosition) || !mem.has(kActiveManager))
return false;
const uint16_t saved_entry = mem.u16(kCalendar + uint32_t(g.season_day()) * 2);
if (saved_entry != calendar_entry || modern::day_competitions(g, saved_entry) != 0x800000 ||
mem.u32(kSavedCompetition) != 0 || mem.u8(kCoachActive) == 0 ||
mem.u8(kManagerCount) != 1 || mem.u8(kOriginalManagerCount) < 1 ||
mem.u8(kOriginalManagerCount) > 4 || mem.u16(kManagerOrder) >= mem.u8(kOriginalManagerCount) ||
mem.u8(kDeskPosition) != 0 || mem.u8(kActiveManager) != 0)
return false;
return true;
}
TurnAdvanceResult fail(TurnDriver& driver, const ModernState& g, const MinuteReport& report,
const char* fallback) {
driver.stage = TurnDriver::Stage::Failed;
TurnAdvanceResult out;
out.kind = TurnDeskKind::Failed;
out.manager_slot = g.memory.has(::bmh::layout::ActiveManager) ? int(g.memory.u8(::bmh::layout::ActiveManager)) : -1;
out.date = g.date;
out.revision = driver.revision;
out.reason = report.reason.empty() ? fallback : report.reason;
return out;
}
TurnAudioEvent audio_event(TurnDriver& driver, TurnAudioKind kind) {
// Cue mapping is deliberately absent until a concrete original call site is proven.
return {driver.session_id, driver.next_event_id++, kind, std::nullopt};
}
TurnAdvanceResult desk_result(TurnDriver& driver, const ModernState& g, TurnDeskKind kind,
bool offer_pending = false) {
TurnAdvanceResult out;
out.kind = kind;
out.manager_slot = g.memory.has(::bmh::layout::ActiveManager) ? int(g.memory.u8(::bmh::layout::ActiveManager)) : -1;
out.date = g.date;
out.revision = driver.revision;
out.offer_pending = offer_pending;
return out;
}
bool run_current_matchday(TurnDriver& driver, ModernState& g, GameRandom& game,
WatcomRandom& rand, MinuteReport& report,
std::vector<TurnAudioEvent>& events) {
const std::vector<uint8_t> saved_records = g.manager_records;
const std::vector<uint8_t> saved_options = g.manager_options;
MatchdayContext context = matchday_context(g, driver.referees);
turn_step = "kick_off";
modern::kick_off(g, driver.groups, context, rand, game, report,
driver.sportschau_source.intro_after_matchday != 0,
driver.sportschau_source.rated_club_threshold);
if (report.unsupported) return false;
if (driver.sportschau_source.intro_after_matchday != 0 && driver.sportschau.kickoff) {
const auto intro = matchday_intro_view(g, driver.groups);
if (intro) driver.sportschau.kickoff(g, *intro);
}
bool manager_match_played = false;
for (const MatchGroup& group : driver.groups)
for (int m = 0; m < group.matches(); ++m) {
if (group.void_mask() >> m & 1) continue;
const size_t fixture = size_t(m * 2);
if (fixture + 1 < group.fixtures.size() &&
(g.manager_of(group.fixtures[fixture]) >= 0 ||
g.manager_of(group.fixtures[fixture + 1]) >= 0))
manager_match_played = true;
}
// Matchday resolution is synchronous. Emit cues only for fixtures involving a
// human-managed club so background AI schedules do not flood the audio queue.
if (manager_match_played) events.push_back(audio_event(driver, TurnAudioKind::kickoff_whistle));
MatchEngine engine{g, driver.groups, game, rand, driver.referees};
if (driver.original_sound) {
engine.original_sound = [&driver, &g](uint8_t id) { driver.original_sound(id, g); };
if (manager_match_played) engine.original_sound(3); // EndPhase / ReadButtons, crowd.
}
std::vector<ShowEvent> sportschau_show_events;
if (driver.sportschau.fixture) engine.show = &sportschau_show_events;
engine.month = context.month;
engine.buttons = read_buttons(g);
engine.reality_rules = driver.reality_rules;
engine.live_scene_visible = g.live_scene && driver.reality_rules;
engine.phase_results = driver.phase_results;
if (driver.live_reality) {
engine.live_reality = [&driver, &g](const LiveRealityEvent& event) {
return driver.live_reality(event, driver.groups, g);
};
}
// LiveDeskDisabled is a saved settings byte. It also changes attitude, assistant
// substitutions and RNG consumption, so a background driver must preserve it.
engine.live_desk_disabled = g.memory.has(::bmh::layout::LiveDeskDisabled) && g.memory.u8(::bmh::layout::LiveDeskDisabled) != 0;
engine.alternate_event_roll = driver.alternate_match_event_roll;
engine.match_events_disabled = driver.disable_match_events;
engine.leave_screens = true;
if (driver.live_shootout) {
engine.live_shootout = [&driver, &g](const LiveShootoutEvent& event) {
driver.live_shootout(event, driver.groups, g);
};
}
if (driver.live_booking) {
engine.live_booking = [&driver, &g](const LiveBookingEvent& event) {
driver.live_booking(event, driver.groups, g);
};
}
if (driver.live_set_piece) {
engine.live_set_piece = [&driver, &g](const LiveSetPieceEvent& event) {
driver.live_set_piece(event, driver.groups, g);
};
}
if (driver.live_shot) {
engine.live_shot = [&driver, &g](const LiveShotEvent& event) {
driver.live_shot(event, driver.groups, g);
};
}
if (driver.live_chance) {
engine.live_chance = [&driver, &g](const LiveChanceEvent& event) {
driver.live_chance(event, driver.groups, g);
};
}
if (driver.live_ball) {
engine.live_ball = [&driver, &g](const LiveBallEvent& event) {
driver.live_ball(event, driver.groups, g);
};
}
if (driver.live_event) {
engine.live_event = [&driver, &engine](const LiveMatchEvent& event) {
driver.live_event(event, engine, driver.groups, static_cast<ModernState&>(engine.state));
};
}
std::vector<std::vector<std::array<int, 2>>> previous(driver.groups.size());
for (size_t gi = 0; gi < driver.groups.size(); ++gi) {
const MatchGroup& group = driver.groups[gi];
previous[gi].resize(size_t(group.matches()));
for (int m = 0; m < group.matches(); ++m) {
int home = 0, away = 0;
modern::match_score(group, m, home, away);
previous[gi][size_t(m)] = {home, away};
}
}
bool manager_match_scored = false;
auto collect_goals = [&](int) {
for (size_t gi = 0; gi < driver.groups.size(); ++gi) {
const MatchGroup& group = driver.groups[gi];
for (int m = 0; m < group.matches(); ++m) {
const size_t fixture = size_t(m * 2);
if ((group.void_mask() >> m & 1) || fixture + 1 >= group.fixtures.size() ||
(g.manager_of(group.fixtures[fixture]) < 0 &&
g.manager_of(group.fixtures[fixture + 1]) < 0))
continue;
int home = 0, away = 0;
if (!modern::match_score(group, m, home, away)) continue;
auto& old = previous[gi][size_t(m)];
const int goals = std::max(0, home - old[0]) + std::max(0, away - old[1]);
manager_match_scored = manager_match_scored || goals > 0;
old = {home, away};
}
}
};
auto after_minute = [&](int minute) {
collect_goals(minute);
if (driver.live_minute) driver.live_minute(minute, engine, driver.groups, g);
};
turn_step = "play_matchday";
modern::play_matchday(engine, g, driver.groups, engine.buttons, game, rand, report, after_minute);
if (report.unsupported) return false;
// The app receives the whole synchronous turn at once. One summary goal cue
// per manager matchday is bounded and avoids replaying a stream of missed goals.
if (manager_match_scored) events.push_back(audio_event(driver, TurnAudioKind::goal));
if (manager_match_played) events.push_back(audio_event(driver, TurnAudioKind::full_time_whistle));
turn_step = "finish_event";
modern::store_group_descriptors(g, driver.groups, true);
modern::finish_event(g, driver.groups, driver.calendar_entry, engine.buttons,
saved_records, saved_options, game, rand, report, driver.season_cup_draw,
&driver.sportschau, &sportschau_show_events,
driver.sportschau_source.intro_after_matchday != 0,
driver.sportschau_source.ratings ? &*driver.sportschau_source.ratings : nullptr);
return !report.unsupported;
}
bool next_event(TurnDriver& driver, ModernState& g, GameRandom& game, WatcomRandom& rand,
MinuteReport& report, bool& offer_pending, bool after_event,
bool first_day_preprocessed = false, bool repeat_event = false) {
for (int day = 0; day < 366 * 5; ++day) {
// DailyInterest enters AdvanceTurn on season day zero even when its
// calendar cell is empty. The prepared first Wednesday is a manager
// desk, not a day to skip while seeking the first scheduled fixture.
const bool opening_desk = first_day_preprocessed && g.season_day() == 0;
// DailyInterest advances DaysIntoSeason before DayStepRest on a quiet day,
// but after DayStepRest when completing an event. Preserve that Source-visible
// context for a nested Bundestrainer re-takeover; the typed date is already one
// day ahead in the latter case.
const uint16_t source_rest_day = uint16_t(
g.date - g.season_start - uint32_t(after_event ? 1 : 0));
turn_step = "day_step_rest";
if (!first_day_preprocessed &&
!modern::day_step_rest(g, game, rand, report, source_rest_day,
driver.transfer_allocator_context)) return false;
// DailyInterest tests for 1 July only after DayStepRest has advanced a day. The
// prepared first day of a new season is not such a step: when 1 July is itself the
// first Wednesday (2037), the season change leaves the date there, and testing it
// again started the season change over and over (endless loop after ten seasons).
const bool day_stepped = !first_day_preprocessed;
first_day_preprocessed = false;
if (day_stepped && modern::is_season_end(g)) {
turn_step = "season_end_day";
modern::season_end_day(g);
// DailyInterest calls AdvanceTurn after the annual awards. DayCompetitions2's
// closing branch supplies FF opponents / competition32 without
// preparing teams, fixtures or cycling manager options. Its old
// descriptors remain available to BuildPoolsCoupon's coupon scan.
if (modern::full_game(g)) { // DailyInterest calls this desk loop only with leagues.
driver.calendar_entry = calendar_day(g, g.season_day());
const uint32_t closing_competitions = modern::day_competitions(g, driver.calendar_entry);
g.memory.set32(kSavedCompetition, closing_competitions == 0x800000 ? 0 : closing_competitions);
modern::draw_matchday_number(g, rand);
modern::shuffle_manager_order(g, game);
driver.manager_position = 0;
driver.national_nomination_desk = false;
turn_step = "enter_closing_desk";
offer_pending = modern::enter_event_desk(g, 0, driver.groups, game, rand, report, true, driver.desk_autosave);
if (report.unsupported) return false;
}
driver.stage = TurnDriver::Stage::SeasonEndDesk;
++driver.revision;
return true;
}
turn_step = "stock market";
if (after_event) modern::day_stock_market(g, game);
after_event = false;
const uint16_t entry = calendar_day(g, g.season_day());
if (!(entry & 0x7fff) && !opening_desk) {
turn_step = "plain_day";
modern::plain_day(g, game, rand);
continue;
}
turn_step = "calendar day";
const uint32_t competitions = modern::day_competitions(g, entry);
driver.referees = driver.referee_source; // clear the per-day chosen flags
MatchdayContext context = matchday_context(g, driver.referees);
if (competitions == 0 && !opening_desk) {
turn_step = "empty_event_day";
if (!modern::empty_event_day(g, context, game, rand, report)) return false;
after_event = true;
continue;
}
if (competitions == 0x800000 && !opening_desk) {
// The return means that a human national-coach desk follows, not
// that the calendar step succeeded. The ordinary no-coach case
// still performs the Source national-team preparation and continues.
const bool has_national_coach = modern::national_team_day(g, rand, report);
if (report.unsupported) return false;
const bool enter_national_desk = has_national_coach && driver.enable_national_nomination_desks;
// AdvanceTurn clears the transient competition result before its empty
// setup. Keep the legacy/no-coach behavior byte-identical; the opted-in
// coach path clears it before preparing the real national desk.
if (enter_national_desk) {
if (g.manager_teams.size() != 1 || g.manager_teams[0] != no_team()) {
report.fail("national nomination returned a coach without the one-manager national context");
return false;
}
if (g.memory.has(kSavedCompetition + 3)) g.memory.set32(kSavedCompetition, 0);
context.national_team_day = true;
}
turn_step = "modern::setup_matchday (national)";
const std::vector<MatchGroup> none = modern::setup_matchday(g, 0, context, game, rand, report);
if (report.unsupported) return false;
if (!none.empty()) {
report.fail("national team day unexpectedly prepared match groups");
return false;
}
modern::draw_matchday_number(g, rand);
modern::shuffle_manager_order(g, game);
if (enter_national_desk) {
driver.calendar_entry = entry;
driver.groups = none;
driver.manager_position = 0;
turn_step = "enter_event_desk";
offer_pending = modern::enter_event_desk(g, 0, driver.groups, game, rand, report, true, driver.desk_autosave);
if (report.unsupported) return false;
driver.national_nomination_desk = true;
driver.stage = TurnDriver::Stage::MatchdayDesks;
++driver.revision;
return true;
}
modern::event_end(g);
++g.date;
modern::daily_interest(g, rand);
after_event = true;
continue;
}
driver.calendar_entry = entry;
if (!repeat_event) start_event_passes(g, entry);
repeat_event = false;
turn_step = "prepare_event";
driver.groups = modern::prepare_event(g, entry, context, game, rand, report);
if (report.unsupported) return false;
if (!modern::matchday_needs_manager_desks(g, entry, driver.groups)) {
std::vector<TurnAudioEvent> background_events;
if (!run_current_matchday(driver, g, game, rand, report, background_events)) return false;
if (consume_event_pass(driver, g)) {
first_day_preprocessed = true;
repeat_event = true;
continue;
}
++g.date;
modern::daily_interest(g, rand);
after_event = true;
continue;
}
driver.manager_position = 0;
turn_step = "enter_event_desk";
offer_pending = modern::enter_event_desk(g, 0, driver.groups, game, rand, report, true, driver.desk_autosave);
if (report.unsupported) return false;
driver.stage = TurnDriver::Stage::MatchdayDesks;
++driver.revision;
return true;
}
report.fail("turn driver exceeded five seasons without a manager desk");
return false;
}
} // namespace
bool begin_turn_driver(TurnDriver& driver, const ModernState& g, std::vector<MatchGroup> groups,
uint16_t calendar_entry, std::vector<uint8_t> referees,
uint64_t session_id, uint64_t revision, std::string& error) {
if (driver.stage != TurnDriver::Stage::Empty || revision == 0 || session_id == 0) {
error = "turn driver is already active or has invalid identity";
return false;
}
if (g.manager_teams.empty()) {
error = "turn driver needs at least one human manager";
return false;
}
driver.stage = TurnDriver::Stage::MatchdayDesks;
driver.calendar_entry = calendar_entry;
driver.manager_position = g.memory.has(::bmh::layout::DeskPosition) ? int(g.memory.u8(::bmh::layout::DeskPosition)) : 0;
driver.revision = revision;
driver.session_id = session_id;
driver.groups = std::move(groups);
driver.referee_source = std::move(referees);
driver.referees = driver.referee_source;
driver.national_nomination_desk = saved_national_nomination_desk(
g, driver.groups, calendar_entry);
return true;
}
TurnAdvanceResult advance_to_next_desk(TurnDriver& driver, ModernState& g,
const TurnAdvanceRequest& request,
GameRandom& game, WatcomRandom& rand,
MinuteReport& report) {
const int active_manager = g.memory.has(::bmh::layout::ActiveManager) ? int(g.memory.u8(::bmh::layout::ActiveManager)) : -1;
// AdvanceTurn restores the retained club-order owner after every temporary
// national desk, including desks with real fixtures. That owner can be1–3
// although the visible/runtime national manager is0. Qualify the completed
// pending batch below without turning an actual match into a nomination day.
const bool national_handoff = driver.enable_national_nomination_desks &&
(driver.national_nomination_desk ||
(g.manager_teams.size() == 1 && g.manager_teams[0] == no_team() &&
g.memory.has(kCoachActive) && g.memory.u8(kCoachActive) != 0));
if (national_handoff) {
const int original_count = g.memory.has(kOriginalManagerCount)
? int(g.memory.u8(kOriginalManagerCount)) : 0;
const int source_owner = g.memory.has(kManagerOrder + 1)
? int(g.memory.u16(kManagerOrder)) : -1;
const bool completed_pending = g.memory.has(kDeskPosition) &&
g.memory.u8(kDeskPosition) == 1 && active_manager == source_owner &&
original_count >= 1 && original_count <= 4 && source_owner >= 0 &&
source_owner < original_count;
if (!completed_pending) {
TurnAdvanceResult out;
out.kind = TurnDeskKind::Failed;
out.manager_slot = active_manager;
out.date = g.date;
out.revision = driver.revision;
out.reason = "national_nomination_pending_not_completed";
return out;
}
if (driver.stage != TurnDriver::Stage::MatchdayDesks ||
request.manager_slot != 0 || driver.manager_position != 0 ||
request.revision != driver.revision || g.manager_teams.size() != 1 ||
g.manager_teams[0] != no_team() || !g.memory.has(kCoachActive) ||
g.memory.u8(kCoachActive) == 0 || !g.memory.has(kManagerCount) ||
g.memory.u8(kManagerCount) != 1) {
TurnAdvanceResult out;
out.kind = TurnDeskKind::Failed;
out.manager_slot = active_manager;
out.date = g.date;
out.revision = driver.revision;
out.reason = "stale_national_coach_manager_or_revision";
return out;
}
} else if ((driver.stage != TurnDriver::Stage::MatchdayDesks && driver.stage != TurnDriver::Stage::SeasonEndDesk) ||
request.manager_slot != active_manager || request.revision != driver.revision) {
TurnAdvanceResult out;
out.kind = TurnDeskKind::Failed;
out.manager_slot = active_manager;
out.date = g.date;
out.revision = driver.revision;
out.reason = "stale_manager_or_revision";
return out;
}
// Claim the request before any RNG or state mutation. A failure is terminal for this
// cursor, so replaying the same request cannot repeat a partially completed turn.
const auto previous_stage = driver.stage;
driver.stage = TurnDriver::Stage::Failed;
std::vector<TurnAudioEvent> events;
bool offer_pending = false;
try {
if (driver.manager_position + 1 < int(g.manager_teams.size())) {
++driver.manager_position;
const bool prepare_pre_match_offer =
!(driver.loaded_matchday_resume && driver.suppress_remaining_pre_match_offers);
turn_step = "enter_event_desk";
offer_pending = modern::enter_event_desk(g, driver.manager_position, driver.groups,
game, rand, report, prepare_pre_match_offer, driver.desk_autosave);
if (report.unsupported) return fail(driver, g, report, "manager pre-match desk unsupported");
driver.stage = previous_stage;
++driver.revision;
return desk_result(driver, g, previous_stage == TurnDriver::Stage::SeasonEndDesk
? TurnDeskKind::SeasonEndDesk : TurnDeskKind::NextDesk, offer_pending);
}
if (previous_stage == TurnDriver::Stage::SeasonEndDesk) {
// Every manager has now left the closing desk. Do not carry the
// loaded desk-resume policy into the annual transition or a new event.
driver.complete_loaded_manager_loop();
// AdvanceTurn's completed manager-desk loop leaves DeskPosition == ManagerCount
// before DailyInterest enters the annual transition. This native byte is
// serialized at modal checkpoints; the next real desk resets it.
if (g.memory.has(::bmh::layout::DeskPosition))
g.memory.set8(::bmh::layout::DeskPosition, g.memory.has(::bmh::layout::ManagerCount)
? g.memory.u8(::bmh::layout::ManagerCount) : uint8_t(g.manager_teams.size()));
const auto outcome = modern::season_transition(g, game, rand, report, driver.season_pause
? std::function<void(const char*)>([&](const char* screen) { driver.season_pause(screen, g); })
: std::function<void(const char*)>{}, driver.season_highscore, driver.season_tax,
driver.season_promotion, driver.season_cup_draw, driver.transfer_allocator_context);
if (report.unsupported || outcome == SeasonTransitionOutcome::Failed)
return fail(driver, g, report, "season transition unsupported");
if (outcome == SeasonTransitionOutcome::CareerComplete) {
driver.stage = TurnDriver::Stage::CareerComplete;
++driver.revision;
return desk_result(driver, g, TurnDeskKind::CareerComplete);
}
driver.stage = TurnDriver::Stage::MatchdayDesks;
// season_end_steps has already performed the calendar days up to the new
// season's first Wednesday; the next loop starts from that prepared date.
if (!next_event(driver, g, game, rand, report, offer_pending, false, true))
return fail(driver, g, report, "season transition could not reach a desk");
auto out = desk_result(driver, g, driver.stage == TurnDriver::Stage::SeasonEndDesk
? TurnDeskKind::SeasonEndDesk : TurnDeskKind::NextDesk, offer_pending);
out.audio_events = std::move(events);
return out;
}
// The current manager desk loop is complete, so these flags have no further
// desk to govern. Consume them before match simulation and future event setup.
driver.complete_loaded_manager_loop();
if (driver.enable_national_nomination_desks && driver.national_nomination_desk) {
// AdvanceTurn's national nomination event has an empty desk, not a
// matchday: Source skips kick_off/play/finish and advances the event
// calendar directly after the pending cleanup performed by App.
driver.national_nomination_desk = false;
modern::event_end(g);
++g.date;
modern::daily_interest(g, rand);
if (!next_event(driver, g, game, rand, report, offer_pending, true))
return fail(driver, g, report, "national nomination could not advance to next desk");
auto out = desk_result(driver, g, driver.stage == TurnDriver::Stage::SeasonEndDesk
? TurnDeskKind::SeasonEndDesk : TurnDeskKind::NextDesk, offer_pending);
out.audio_events = std::move(events);
return out;
}
// A legacy caller can bind a genuine saved national desk, but it keeps the
// historic matchday path unless the App explicitly opted into this lifecycle.
driver.national_nomination_desk = false;
const auto result_tournament_name = g.tournament_name;
if (!run_current_matchday(driver, g, game, rand, report, events))
return fail(driver, g, report, "matchday unsupported");
driver.last_results.valid = true;
driver.last_results.date = g.date;
driver.last_results.calendar_entry = driver.calendar_entry;
driver.last_results.matchday = g.memory.has(::bmh::layout::CurrentMatchday) ? g.memory.u16(::bmh::layout::CurrentMatchday) : 0;
driver.last_results.groups = driver.groups;
driver.last_results.tournament_name = result_tournament_name;
const bool repeat = consume_event_pass(driver, g);
if (!repeat) {
++g.date;
modern::daily_interest(g, rand);
}
if (!next_event(driver, g, game, rand, report, offer_pending, !repeat, repeat, repeat))
return fail(driver, g, report, "could not advance to next desk");
auto out = desk_result(driver, g, driver.stage == TurnDriver::Stage::SeasonEndDesk
? TurnDeskKind::SeasonEndDesk : TurnDeskKind::NextDesk, offer_pending);
out.audio_events = std::move(events);
return out;
} catch (const std::exception& ex) {
report.fail(std::string("turn driver exception: ") + ex.what() + " (in " + std::string(turn_step.load()) + ")");
return fail(driver, g, report, "turn driver exception");
}
}
} // namespace bmh::modern