Files
Dreierpack-Manager/src/app/career_session.cpp
T

8419 lines
532 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/native_save_version.hpp"
#include "formats/badge_policy.hpp"
#include "game/calendar.hpp"
#include "formats/executable_layout.hpp"
#include "app/career_session.hpp"
#include "formats/league_visibility.hpp"
#include <stdexcept>
#include <system_error>
#include <algorithm>
#include <array>
#include <atomic>
#include <cctype>
#include <bit>
#include <fstream>
#include <limits>
#include <utility>
#include "formats/binary.hpp"
#include "formats/fbm.hpp"
#include "formats/savestate.hpp"
#include "game/career.hpp"
#include "game/cup.hpp"
#include "game/driver.hpp"
#include "game/desk.hpp"
#include "game/desk_actions.hpp"
#include "game/match.hpp"
#include "game/messages.hpp"
#include "game/prediction.hpp"
#include "game/schedule.hpp"
#include "game/bank_credit.hpp"
#include "game/matchday_setup.hpp"
#include "game/matchday.hpp"
#include "game/lineup.hpp"
#include "game/month.hpp"
#include "game/national.hpp"
#include "game/schedule.hpp"
#include "game/table.hpp"
#include "game/table_forecast.hpp"
#include "game/save.hpp"
#include "game/season.hpp"
#include "game/turn.hpp"
#include "game/week.hpp"
#include "game/weekly.hpp"
#include "ui/desk_state.hpp"
#include "ui/league_table.hpp"
#include "ui/other_games_state.hpp"
#include "ui/manager.hpp"
#include "ui/pending_offer.hpp"
#include "ui/training.hpp"
namespace bmh::app {
namespace {
std::atomic<uint64_t> next_session_id{1};
constexpr uint32_t kSavedCalendar = ::bmh::layout::CompetitionCalendar;
constexpr uint32_t kSavedCompetitionBits = ::bmh::layout::SavedCompetition;
constexpr uint8_t kBlockSeat = 1;
constexpr uint8_t kBlockRoof = 2;
constexpr uint8_t kBlockFeatures = kBlockSeat | kBlockRoof;
bool is_block_expansion_action(ui::StadiumRequestKind kind) {
return kind == ui::StadiumRequestKind::expansion_select ||
kind == ui::StadiumRequestKind::expansion_set_total ||
kind == ui::StadiumRequestKind::expansion_toggle_feature ||
kind == ui::StadiumRequestKind::expansion_cancel ||
kind == ui::StadiumRequestKind::expansion_confirm ||
kind == ui::StadiumRequestKind::expansion_answer_tip;
}
int national_opportunities_rank(const GameState& game,int team,std::array<uint8_t,24>& ranks) {
ranks.fill(1);
const int rounds=game.league_rounds.empty()?0:int8_t(game.league_rounds.at(0));
if(rounds<2||rounds>=league_matchdays(0))return 0;
return team>=138?9:0;
}
uint8_t source_runtime_byte(const GameState& state,const std::map<uint32_t,uint8_t>& runtime,
const LeImage& exe,uint32_t address) {
if(state.memory.has(address))return state.memory.u8(address);
const auto found=runtime.find(address);return found==runtime.end()?exe.u8(address):found->second;
}
void source_runtime_set_byte(GameState& state,std::map<uint32_t,uint8_t>& runtime,
uint32_t address,uint8_t value) {
if(state.memory.has(address))state.memory.set8(address,value);
else runtime[address]=value;
}
uint32_t source_runtime_u32(const GameState& state,const std::map<uint32_t,uint8_t>& runtime,
const LeImage& exe,uint32_t address) {
return uint32_t(source_runtime_byte(state,runtime,exe,address)) |
uint32_t(source_runtime_byte(state,runtime,exe,address+1))<<8 |
uint32_t(source_runtime_byte(state,runtime,exe,address+2))<<16 |
uint32_t(source_runtime_byte(state,runtime,exe,address+3))<<24;
}
void apply_balance_source_style(ui::BalanceState& page,const GameState& state,
const std::map<uint32_t,uint8_t>& runtime,const LeImage& exe) {
page.decorated=source_runtime_byte(state,runtime,exe,::bmh::layout::PlainBackground)==0;
page.original_panel=source_runtime_byte(state,runtime,exe,::bmh::layout::SolidPanelBackground)==0;
page.gradient=source_runtime_byte(state,runtime,exe,::bmh::layout::TextGradientDisabled)==0 &&
source_runtime_byte(state,runtime,exe,::bmh::layout::TextGradientMode)==2;
page.cached_backdrop=source_runtime_u32(state,runtime,exe,::bmh::layout::CareerSession_ApplyBalanceSourceStyle_ExecutableField)!=0;
}
uint32_t saved_group_u32(const Bytes& bytes, size_t offset) {
return uint32_t(bytes.at(offset)) | (uint32_t(bytes.at(offset + 1)) << 8) |
(uint32_t(bytes.at(offset + 2)) << 16) | (uint32_t(bytes.at(offset + 3)) << 24);
}
void initialize_saved_match_group(MatchGroup& group, const GameState& state, size_t index,
int league) {
group.desc = group_descriptor(state, index);
if (group.desc.size() != 0xd0 || group.desc[0] != 0 ||
saved_group_u32(group.desc, 0xcc) != uint32_t(league))
throw std::runtime_error("saved turn cursor: league descriptor does not match the active calendar");
const int round = state.league_rounds.at(size_t(league));
const auto fixtures = league_fixtures(league, round + 1);
if (group.desc[2] != fixtures.size())
throw std::runtime_error("saved turn cursor: league fixture count is incomplete");
for (const Fixture& fixture : fixtures) {
group.fixtures.push_back(fixture.home);
group.fixtures.push_back(fixture.away);
}
const size_t result_at = size_t(league) * 0x17c + size_t(round) * 10;
if (result_at + fixtures.size() > state.results.size())
throw std::runtime_error("saved turn cursor: league result block is incomplete");
group.results.assign(state.results.begin() + long(result_at),
state.results.begin() + long(result_at + fixtures.size()));
// Assign2 and the match loop read exactly one mask bit per descriptor
// match. Before kickoff, a saved desk can retain high bits from the previous
// larger group; those padding bits are not fixture identities and are ignored
// by the original. Keep the saved descriptor intact and validate actual
// fixture count, result range, and active league above.
// These per-match arrays are transient runtime data. kick_off rebuilds them from
// the authoritative saved lineups; no setup/event replay belongs in the loader.
group.records.assign(fixtures.size() * 18, 0);
group.end_minute.assign(fixtures.size(), 0);
group.spectators.assign(fixtures.size(), 0);
}
void initialize_saved_cup_group(MatchGroup& group, const GameState& state, size_t index,
int cup_id, int entry_index) {
const StaticMemory& mem = state.memory;
group.desc = group_descriptor(state, index);
const uint32_t guest_entry = saved_group_u32(group.desc, 0xcc);
if (group.desc.size() != 0xd0 || group.desc[0] != cup_id + 1 ||
guest_entry < kGuestDataBase || (guest_entry - kGuestDataBase) != cup_entry_address(entry_index))
throw std::runtime_error("cup descriptor mismatch group=" + std::to_string(index) +
" type=" + std::to_string(group.desc[0]) +
" guest=" + std::to_string(guest_entry) +
" stage=" + std::to_string(entry_index));
const uint32_t entry = cup_entry_address(entry_index);
// In memory the descriptor stores a guest pointer; MatchGroup carries the data-object
// address, as setup_cup_groups does before store_group_descriptors adds the guest base.
for (int i = 0; i < 4; ++i) group.desc.at(0xcc + size_t(i)) = uint8_t(entry >> (i * 8));
const uint8_t flags = mem.u8(entry + 0x14);
const bool knockout = (flags & 4) != 0;
const int teams = mem.u8(entry + 0x1a);
if (int16_t(mem.u16(entry + 0x18)) != cup_id || teams < 2 || (teams & 1) ||
group.desc[2] == 0 || group.desc[2] > (knockout ? 32 : 18))
throw std::runtime_error("saved turn cursor: cup descriptor has invalid stage or match count");
const int round = cup_round(mem, entry_index);
int first = 0;
int expected_matches = 0;
if (knockout) {
if (round < 0 || round >= 8 || (1 << (round + 1)) > teams)
throw std::runtime_error("saved turn cursor: cup knockout round is outside the stage");
expected_matches = teams / (1 << (round + 1));
first = uint8_t(cup_round_offset(mem, entry_index, round));
} else {
if (teams / 2 > 18) throw std::runtime_error("saved turn cursor: cup group is too large");
expected_matches = teams / 2;
// Group-stage fixtures are stored in descriptor +0x88; KO descriptors do not
// contain fixture IDs there. Their IDs come from the stage's round-indexed list.
first = uint8_t(expected_matches * mem.u8(entry + 0x1d) * 2);
}
if (expected_matches != group.desc[2])
throw std::runtime_error("saved turn cursor: cup round match count disagrees with its descriptor");
const size_t fixture_count = size_t(group.desc[2]) * 2;
// As in Assign2, only bits [0, group.desc[2]) are read. The descriptor
// can carry stale high padding bits from the preceding event; preserve them
// in the copy rather than treating them as corrupt fixture references.
const uint32_t list = mem.pointer(entry);
if (list == 0 || (knockout
? !mem.has(list + uint32_t(first + expected_matches * 2) * 2 - 1)
: !mem.has(list + uint32_t(teams) * 2 - 1)))
throw std::runtime_error("saved turn cursor: cup team list is missing");
auto valid_team = [&](int team) {
return team >= 0 && size_t(team) < state.team_flags.size();
};
std::vector<int> cup_teams;
cup_teams.reserve(size_t(teams));
for (int i = 0; !knockout && i < teams; ++i) {
const int team = int16_t(mem.u16(list + uint32_t(i) * 2));
if (!valid_team(team) ||
std::find(cup_teams.begin(), cup_teams.end(), team) != cup_teams.end())
throw std::runtime_error("saved turn cursor: cup team list contains an invalid or duplicate team");
cup_teams.push_back(team);
}
if (!knockout) {
int table_teams = 0;
switch (mem.pointer(entry + 8)) {
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField: table_teams = 4; break;
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField2: table_teams = 6; break;
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField3: table_teams = 12; break;
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField3: table_teams = 16; break;
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField: table_teams = 18; break;
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField2: table_teams = 20; break;
default: throw std::runtime_error("saved turn cursor: cup group has unknown round strings");
}
const int rounds = mem.u8(entry + 0x1b) / ((flags & 1) + 1);
const std::vector<Fixture> expected = generate_fixtures(table_teams, round + 1, rounds, 0);
if (expected.size() < fixture_count / 2)
throw std::runtime_error("saved turn cursor: cup group round is incomplete");
std::vector<int> expected_fixture_ids;
expected_fixture_ids.reserve(fixture_count);
for (size_t i = 0; i < fixture_count / 2; ++i) {
if (expected[i].home < 0 || expected[i].home >= teams ||
expected[i].away < 0 || expected[i].away >= teams)
throw std::runtime_error("saved turn cursor: cup round exceeds the saved team list");
const int home = int16_t(mem.u16(list + uint32_t(expected[i].home) * 2));
const int away = int16_t(mem.u16(list + uint32_t(expected[i].away) * 2));
if (!valid_team(home) || !valid_team(away) || home == away ||
std::find(cup_teams.begin(), cup_teams.end(), home) == cup_teams.end() ||
std::find(cup_teams.begin(), cup_teams.end(), away) == cup_teams.end())
throw std::runtime_error("saved turn cursor: generated cup fixture references an invalid team");
expected_fixture_ids.push_back(home);
expected_fixture_ids.push_back(away);
}
for (size_t i = 0; i < fixture_count; ++i) {
const size_t at = 0x88 + i * 2;
const int team = int16_t(uint16_t(group.desc.at(at)) | (uint16_t(group.desc.at(at + 1)) << 8));
if (team != expected_fixture_ids[i])
throw std::runtime_error("saved turn cursor: cup fixture IDs disagree with the saved round");
group.fixtures.push_back(team);
}
} else {
// SetupCupGroups derives KO fixtures from the stage team list and
// cup_round_offset; descriptor +0x88 is not populated for KO stages.
std::vector<int> active_teams;
for (int i = 0; i < expected_matches * 2; ++i) {
const int team = int16_t(mem.u16(list + uint32_t(first + i) * 2));
if (!valid_team(team) || std::find(active_teams.begin(), active_teams.end(), team) != active_teams.end())
throw std::runtime_error("saved turn cursor: knockout fixture references an invalid team");
active_teams.push_back(team);
group.fixtures.push_back(team);
}
for (int m = 0; m < expected_matches; ++m)
if (group.fixtures[size_t(m) * 2] == group.fixtures[size_t(m) * 2 + 1])
throw std::runtime_error("saved turn cursor: knockout fixture contains the same team twice");
}
for (int leg = 0; leg < 2; ++leg) {
if (leg == 1 && !(flags & 1)) break;
const uint32_t address = mem.pointer(entry + 0x0c + uint32_t(leg) * 4);
// setup_cup_groups leaves the corresponding result vector empty when this stage
// has no result-array pointer; the match engine initializes its runtime scores.
if (address == 0) continue;
const uint32_t result_at = address + uint32_t(first / 2) * 2;
if (!mem.has(result_at + uint32_t(group.matches()) * 2 - 1))
throw std::runtime_error("saved turn cursor: cup result array is missing");
if (leg == 0) group.cup_result_address[0] = result_at;
else group.cup_result_address[1] = result_at;
std::vector<uint16_t>& results = leg == 0 ? group.cup_results : group.cup_other_leg;
for (int m = 0; m < group.matches(); ++m)
results.push_back(mem.u16(result_at + uint32_t(m) * 2));
}
group.records.assign(fixture_count * 9, 0);
group.end_minute.assign(size_t(group.matches()), 0);
group.spectators.assign(size_t(group.matches()), 0);
}
int current_cup_stage(const StaticMemory& mem, int cup_id) {
int entry = find_cup(mem, cup_id);
if (entry < 0) return -1;
for (int guard = 0; guard < kCupEntries; ++guard) {
const uint32_t address = cup_entry_address(entry);
if (cup_round(mem, entry) < mem.u8(address + 0x1b)) return entry;
const int next = int8_t(mem.u8(address + 0x16));
if (next < 0 || next >= kCupEntries) return -1;
entry = next;
}
return -1;
}
void initialize_saved_replay_group(MatchGroup& group, GameState& state, size_t index,
int entry_index, int day) {
constexpr uint32_t kPostponed = ::bmh::layout::Postponed;
constexpr uint32_t kReplayFixtures = ::bmh::layout::ReplayFixtures;
constexpr uint32_t kReplayResults = ::bmh::layout::ReplayResults;
constexpr uint8_t kPostponedMark = 0xcd;
constexpr int kMaxReplayMatches = 9; // AddBlock clears 0x12 result bytes.
StaticMemory& mem = state.memory;
const uint32_t entry = cup_entry_address(entry_index);
group.desc = group_descriptor(state, index);
const uint32_t saved_entry = saved_group_u32(group.desc, 0xcc);
const uint8_t flags = mem.u8(entry + 0x14);
if (group.desc.size() != 0xd0 || group.desc[0] != 10 ||
saved_entry != kGuestDataBase + entry || group.desc[1] != flags ||
int16_t(mem.u16(entry + 0x18)) != 9 || flags != 6 ||
mem.u8(entry + 0x1d) != 0 || (mem.u8(entry + 0x1e) & 0x0f) != 1 ||
mem.pointer(entry) != kReplayFixtures || mem.pointer(entry + 0x0c) != kReplayResults ||
mem.pointer(entry + 0x10) != 0)
throw std::runtime_error("saved replay descriptor or stage is inconsistent");
std::vector<Fixture> replay_fixtures;
std::vector<uint32_t> replay_keys;
replay_fixtures.reserve(kMaxReplayMatches);
for (int i = 0; i < 0x28; ++i) {
const uint32_t record = kPostponed + uint32_t(i) * 6;
if (mem.u16(record) != day) continue;
const int round = mem.u8(record + 2);
const int league = mem.u8(record + 3);
const int match = mem.u8(record + 4);
if (league < 0 || league >= kLeagueCount || round < 0 ||
round >= league_matchdays(league) ||
match >= int(kLeagueSizes[league] / 2))
throw std::runtime_error("saved replay record is outside the league schedule");
const std::vector<Fixture> fixtures = generate_fixtures(
league_table_teams(league), round + 1, league_matchdays(league) / 2,
league_first_team(league));
if (match >= int(fixtures.size()))
throw std::runtime_error("saved replay record has no corresponding fixture");
const size_t result = size_t(league) * 0x17c + size_t(round) * 10 + size_t(match);
if (result >= state.results.size() || state.results[result] != kPostponedMark)
throw std::runtime_error("saved replay record has no postponed result marker");
const uint32_t key = (uint32_t(league) << 16) | (uint32_t(round) << 8) | uint32_t(match);
if (std::find(replay_keys.begin(), replay_keys.end(), key) != replay_keys.end())
throw std::runtime_error("saved replay records contain a duplicate schedule key");
const Fixture fixture = fixtures[size_t(match)];
replay_keys.push_back(key);
replay_fixtures.push_back(fixture);
if (replay_fixtures.size() > kMaxReplayMatches)
throw std::runtime_error("saved replay day exceeds its result buffer");
}
if (replay_fixtures.empty() || group.desc[2] != replay_fixtures.size() ||
mem.u8(entry + 0x1a) != replay_fixtures.size() * 2)
throw std::runtime_error("saved replay match count disagrees with its records");
// Neither transient address is in SaveState's serialized block layout; a loaded
// GameState therefore has no valid prior runtime buffer to reuse.
if (mem.has(kReplayFixtures) || mem.has(kReplayResults))
throw std::runtime_error("saved replay transient blocks are unexpectedly present");
// The original rebuilds these two non-savegame buffers in AddBlock. Recreate
// only their current values, leaving the saved replay records/stage counters intact.
mem.add_block(kReplayFixtures, 0x50);
mem.add_block(kReplayResults, 0x12);
for (int i = 0; i < kMaxReplayMatches; ++i)
mem.set16(kReplayResults + uint32_t(i) * 2, 0xcccc);
for (size_t i = 0; i < replay_fixtures.size(); ++i) {
mem.set16(kReplayFixtures + uint32_t(i) * 4, uint16_t(replay_fixtures[i].home));
mem.set16(kReplayFixtures + uint32_t(i) * 4 + 2, uint16_t(replay_fixtures[i].away));
group.fixtures.push_back(replay_fixtures[i].home);
group.fixtures.push_back(replay_fixtures[i].away);
group.cup_results.push_back(0xcccc);
}
group.cup_result_address[0] = kReplayResults;
for (int i = 0; i < 4; ++i) group.desc.at(0xcc + size_t(i)) = uint8_t(entry >> (i * 8));
group.records.assign(replay_fixtures.size() * 18, 0);
group.end_minute.assign(replay_fixtures.size(), 0);
group.spectators.assign(replay_fixtures.size(), 0);
}
void restore_saved_turn_cursor(TurnDriver& driver, GameState& state, const Database& db,
uint64_t session_id, uint64_t revision,
std::string& unsupported_continuation) {
// Original DailyInterest's resume path skips new-event preparation. Rebind its saved
// desk position and event data directly; replaying prepare_event here would draw RNG,
// reshuffle managers, and rewrite saved team state.
if (revision == 0 || session_id == 0 || state.manager_teams.empty())
throw std::runtime_error("saved turn cursor: invalid session identity or manager roster");
const int manager_count = int(state.manager_teams.size());
if (manager_count > 4 || !state.memory.has(::bmh::layout::ActiveManager) || !state.memory.has(::bmh::layout::DeskPosition))
throw std::runtime_error("saved turn cursor: manager continuation fields are missing");
const int position = int(state.memory.u8(::bmh::layout::DeskPosition));
const int active = int(state.memory.u8(::bmh::layout::ActiveManager));
if (position < 0 || position >= manager_count)
throw std::runtime_error("saved turn cursor: manager position is outside the saved roster");
if (manager_count == 1) {
if (position != 0 || active != 0)
throw std::runtime_error("saved turn cursor: single-manager slot does not match the saved desk");
} else {
if (!state.memory.has(::bmh::layout::NextDeskManager + uint32_t(manager_count) * 2 - 1))
throw std::runtime_error("saved turn cursor: manager order is missing");
std::vector<bool> seen(size_t(manager_count), false);
for (int i = 0; i < manager_count; ++i) {
const int slot = int(state.memory.u16(::bmh::layout::NextDeskManager + uint32_t(i) * 2));
if (slot < 0 || slot >= manager_count || seen[size_t(slot)])
throw std::runtime_error("saved turn cursor: manager order is sparse or duplicated");
seen[size_t(slot)] = true;
}
if (active != int(state.memory.u16(::bmh::layout::NextDeskManager + uint32_t(position) * 2)))
throw std::runtime_error("saved turn cursor: active manager disagrees with saved order");
}
if (state.memory.has(::bmh::layout::CareerSession_RuntimeError_RuntimeField4) && state.memory.u8(::bmh::layout::CareerSession_RuntimeError_RuntimeField4)) {
driver.stage = TurnDriver::Stage::SeasonEndDesk;
driver.loaded_matchday_resume = true;
driver.manager_position = position;
driver.revision = revision;
driver.session_id = session_id;
driver.referee_source = db.raw_referee_properties;
driver.referees = driver.referee_source;
return;
}
const int day = state.season_day();
if (day < 0 || day >= 0x16d || !state.memory.has(kSavedCalendar + uint32_t(day) * 2 + 1) ||
!state.memory.has(kSavedCompetitionBits + 3))
throw std::runtime_error("saved turn cursor: current calendar entry is missing");
const uint16_t entry = state.memory.u16(kSavedCalendar + uint32_t(day) * 2);
const uint32_t calendar_competitions = day_competitions(state, entry);
const uint32_t saved_competitions = state.memory.u32(kSavedCompetitionBits);
// AdvanceTurn maps the national-team-only marker national-only flag to saved
// SavedCompetition=0 before it creates the no-fixture desk. Resume must compare
// against that canonical saved value, not treat the calendar marker as a cup.
const uint32_t competitions = calendar_competitions == 0x800000 && saved_competitions == 0
? 0 : calendar_competitions;
if (competitions != saved_competitions)
throw std::runtime_error("saved turn cursor: current calendar and saved competition flags disagree");
if (competitions & ~0x7ffffu)
unsupported_continuation = "Dieser Spieltag kann mit den verfügbaren Wettbewerbsdaten derzeit nicht fortgesetzt werden.";
if (!unsupported_continuation.empty()) return;
std::vector<int> active_leagues;
// DayCompetitions2's competition bits expand to group leagues in this original order;
// bit 2 owns both league 2 and 3. The stale descriptors after the active group count
// are intentionally ignored.
static constexpr int first_league[8] = {0, 1, 2, 4, 5, 6, 7, 8};
static constexpr int league_count[8] = {1, 1, 2, 1, 1, 1, 1, 1};
for (int bit = 0; bit < 5; ++bit) {
if (!((competitions >> bit) & 1u)) continue;
const int first = bit, last = bit < 4 ? bit + 1 : 8;
for (int k = first; k < last; ++k)
for (int league = first_league[k]; league < first_league[k] + league_count[k]; ++league)
active_leagues.push_back(league);
}
if (active_leagues.size() > 6)
throw std::runtime_error("saved turn cursor: too many league fixtures are active");
std::vector<MatchGroup> groups;
groups.reserve(active_leagues.size());
for (size_t i = 0; i < active_leagues.size(); ++i) {
MatchGroup group;
initialize_saved_match_group(group, state, i, active_leagues[i]);
groups.push_back(std::move(group));
}
// Rebind saved cup descriptors and their current stage fixtures/results. Group-stage
// IDs live at descriptor +0x88; KO IDs live in the stage list. Replays reconstruct
// only missing transient buffers. Calling setup_cup_groups would replay event work.
bool has_empty_cup = false;
try {
for (int bit = 5; bit < 0x13; ++bit) {
if (!((competitions >> bit) & 1u)) continue;
const int cup_id = bit - 5;
int entry = current_cup_stage(state.memory, cup_id);
if (entry < 0) throw std::runtime_error("cup stage is missing");
const uint32_t first_entry = cup_entry_address(entry);
const int type = int16_t(state.memory.u16(first_entry + 0x18));
// Type 9's daily fixtures can be reconstructed from the saved postponed-match
// records. Other special competitions need preparation hooks and stay guarded.
if (type < 0 || (type > 9 && type != 10 && type != 11 && type != 13))
throw std::runtime_error("this cup type requires event preparation");
// SetupCupGroups creates a group only inside its per-stage `teams != 0`
// branch. A validated type-8 stage with zero teams is therefore a valid
// no-group cup day. On FBM load, competition_pointers() rebinds the native
// null list pointer to its runtime address; the team-count gate is the
// stable Source behavior across both representations.
if (type == 8 && state.memory.u8(first_entry + 0x1a) == 0) {
has_empty_cup = true;
continue;
}
// SetupCupGroups sets CareerSessionRuntimeField while projecting competition 11.
// This runtime-only mode is absent from the saved byte stream, so infer
// it from the authoritative active cup while rebuilding its MatchGroup.
if (type == 11) state.indoor = true;
const int parallel = state.memory.u8(first_entry + 0x1e) & 0x0f;
if (parallel == 0) throw std::runtime_error("cup stage has no saved parallel groups");
const size_t groups_before_cup = groups.size();
for (int k = 0; k < parallel; ++k, ++entry) {
if (entry < 0 || entry >= kCupEntries)
throw std::runtime_error("cup stage points outside the saved cup table");
if (state.memory.u8(cup_entry_address(entry) + 0x1a) == 0) continue;
if (groups.size() >= 6)
throw std::runtime_error("too many saved match groups");
MatchGroup group;
if (type == 9)
initialize_saved_replay_group(group, state, groups.size(), entry, day);
else
initialize_saved_cup_group(group, state, groups.size(), cup_id, entry);
groups.push_back(std::move(group));
}
if (groups.size() == groups_before_cup)
throw std::runtime_error("cup stage has no saved fixture group");
}
if (competitions != 0 && groups.empty() && !has_empty_cup)
throw std::runtime_error("active matchday has no saved fixture groups");
} catch (const std::exception& e) {
(void)e; // Do not expose internal parser/descriptor details to the player.
unsupported_continuation = "Der Pokalspieltag kann mit den gespeicherten Paarungen nicht sicher fortgesetzt werden.";
return;
}
if (!groups.empty() && db.raw_referee_properties.empty())
throw std::runtime_error("saved turn cursor: referee source is missing");
std::vector<uint8_t> referees = db.raw_referee_properties;
for (uint8_t& ref : referees) ref &= 0x7f;
for (const MatchGroup& group : groups)
for (int m = 0; m < group.matches(); ++m) {
const uint8_t ref = group.desc.at(0x10 + size_t(m));
if (ref > 0 && ref < referees.size()) referees[ref] |= 0x80;
}
std::string error;
if (!begin_turn_driver(driver, state, std::move(groups), entry, db.raw_referee_properties,
session_id, revision, error))
throw std::runtime_error("saved turn cursor: " + error);
driver.referees = std::move(referees);
// Runtime provenance belongs to this successfully restored Native desk loop.
// It is not inferred from a nonzero cursor, and does not select a policy.
driver.loaded_matchday_resume = true;
}
}
// The league structure of the loaded game (schedule.hpp): sizes LeagueSizes (German
// 18 18 18 18 18 12 12 12 12, English 20 20 20 20 10 12 12 12 12) and calendar groups.
static void install_league_sizes(const LeImage& exe) {
uint8_t sizes[kLeagueCount];
for (int l = 0; l < kLeagueCount; ++l) sizes[l] = exe.u8(::bmh::layout::LeagueSizes + uint32_t(l));
set_league_sizes(sizes);
install_fixture_tables(exe);
kEnglishCompetitions = sizes[0] == 20;
// the calendar groups (CalendarFirstLeague first league, CalendarLeagueCounts league count per bit)
uint8_t first[8], count[8];
for (uint32_t b = 0; b < 8; ++b) first[b] = exe.u8(::bmh::layout::CalendarFirstLeague + b), count[b] = exe.u8(::bmh::layout::CalendarLeagueCounts + b);
set_league_groups(first, count);
// the promotion ladder (schedule.hpp)
for (uint32_t l = 0; l < uint32_t(kLeagueCount); ++l) {
kLeagueRelegation[l] = exe.u8(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField2 + l);
kLeagueEurope[l] = exe.u8(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField + l);
kLeagueSuffix[l] = char(l < 5 ? exe.u8(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField3 + l * 2) : 0);
}
for (uint32_t g = 0; g < 8; ++g) kGroupBelow[g] = exe.u8(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField5 + g), kGroupBelowCount[g] = exe.u8(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField4 + g);
kNewcomerFirst = exe.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField);
kNewcomerCount = exe.u16(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField6);
// EXE strings the engine posts (messages.hpp)
install_message_texts(exe);
install_career_rules(exe);
install_environment_rules(exe);
install_original_badge_policy(exe);
install_calendar_rules(exe);
}
CareerSession::CareerSession(const std::filesystem::path& data, uint32_t watcom_seed)
: data_directory_(data), exe_(load_le(ui::asset_path(data, "BMH.exe"))),
db_(load_database(ui::asset_path(data, "M3D.MAN"))),
texts_(load_textd(ui::asset_path(data, "TEXTD.BLK"))),
rand_(watcom_seed) {
install_league_sizes(exe_);
turn_driver_.alternate_match_event_roll = exe_.u8(::bmh::layout::AlternateEventRoll) != 0;
turn_driver_.disable_match_events = exe_.u8(::bmh::layout::MatchEventsDisabled) != 0;
turn_driver_.transfer_allocator_context = exe_.u8(::bmh::layout::MatchEventsDisabled) == 0
? TransferAllocatorContext::zero : TransferAllocatorContext::blocked;
session_id_ = next_session_id.fetch_add(1, std::memory_order_relaxed);
initialize_club_modal_runtime();
g_ = startup_state(exe_, db_, read_file(ui::asset_path(data, "M3.MEN")), read_file(ui::asset_path(data, "M3.DAT")));
g_.texts = &texts_;
g_.currency_suffix = exe_.cstring(::bmh::layout::CurrencySuffixText); // CurrencySuffixText
configure_training_camp_data(g_, exe_);
for (size_t i = 0; i < g_.credit_rate_table.size(); ++i) g_.credit_rate_table[i] = exe_.u8(::bmh::layout::BankCredit_BankCreditContext_RuntimeField3 + uint32_t(i));
g_.credit_divisor = std::bit_cast<double>(uint64_t(exe_.u32(::bmh::layout::BankCredit_BankCreditContext_RuntimeField)) | uint64_t(exe_.u32(::bmh::layout::BankCredit_BankCreditContext_RuntimeField2)) << 32);
g_.credit_rate_table_available = true;
install_default_hooks();
startup_players(g_, game_, rand_); // CareerFirstSteps2
MinuteReport report;
if (!new_career_before_dialog(g_, game_, rand_, report)) // InitializeCareer up to the dialog
throw std::runtime_error("career start: " + report.reason);
}
CareerSession::CareerSession(const std::filesystem::path& data, uint32_t watcom_seed,
const std::filesystem::path& save_path)
: data_directory_(data), exe_(load_le(ui::asset_path(data, "BMH.exe"))), db_(load_database(ui::asset_path(data, "M3D.MAN"))),
texts_(load_textd(ui::asset_path(data, "TEXTD.BLK"))), rand_(watcom_seed) {
install_league_sizes(exe_);
turn_driver_.alternate_match_event_roll = exe_.u8(::bmh::layout::AlternateEventRoll) != 0;
turn_driver_.disable_match_events = exe_.u8(::bmh::layout::MatchEventsDisabled) != 0;
turn_driver_.transfer_allocator_context = exe_.u8(::bmh::layout::MatchEventsDisabled) == 0
? TransferAllocatorContext::zero : TransferAllocatorContext::blocked;
session_id_ = next_session_id.fetch_add(1, std::memory_order_relaxed);
initialize_club_modal_runtime();
const Savegame file = load_savegame(save_path);
require_native_savegame(file);
const DbCounts counts{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)};
const SaveState save(file.stream, counts);
g_ = GameState::from_save(save, counts);
// CompetitionPointers2, after DeskDate2: these are process statics, not FBM fields.
// Resuming within this month must not count it as a newly elapsed month.
g_.autosave_months = 0;
g_.autosave_month = month_code(g_.date);
// Original CompetitionPointers2 calls CompetitionPointers after loading the stream. This
// rebinds pointer fields in the saved competition table before any resume
// path dereferences them (the serialized values may point into the old process).
competition_pointers(g_.memory, exe_);
g_.texts = &texts_;
g_.currency_suffix = exe_.cstring(::bmh::layout::CurrencySuffixText); // CurrencySuffixText
configure_training_camp_data(g_, exe_);
for (size_t i = 0; i < g_.credit_rate_table.size(); ++i) g_.credit_rate_table[i] = exe_.u8(::bmh::layout::BankCredit_BankCreditContext_RuntimeField3 + uint32_t(i));
g_.credit_divisor = std::bit_cast<double>(uint64_t(exe_.u32(::bmh::layout::BankCredit_BankCreditContext_RuntimeField)) | uint64_t(exe_.u32(::bmh::layout::BankCredit_BankCreditContext_RuntimeField2)) << 32);
g_.credit_rate_table_available = true;
install_default_hooks();
national_coach_after_load(g_); // (NationalCoachAfterLoad: a Bundestrainer takes the national team over again)
if (g_.memory.has(::bmh::layout::CareerSession_Save_RuntimeField)) game_.set_seed(int32_t(g_.memory.u32(::bmh::layout::CareerSession_Save_RuntimeField)));
restore_saved_turn_cursor(turn_driver_, g_, db_, session_id_, 1, saved_turn_error_);
capture_source_desk_callargs();
}
int CareerSession::runtime_club(int master) const { return runtime_club(g_, master); }
int CareerSession::runtime_club(const GameState& state, int master) const {
// ClubsChangePlaces moves a club together with its name: the club whose name offset is the
// master entry's is the one the manager chose
const uint16_t offset = uint16_t(db_.raw_club_name_offsets.at(size_t(master) * 2) | db_.raw_club_name_offsets.at(size_t(master) * 2 + 1) << 8);
for (size_t t = 0; t < state.club_ids.size(); t++)
if (state.club_ids[t] == offset) return int(t);
return -1;
}
ui::SelectionContext CareerSession::selection_context(uint64_t revision) const { return selection_context_for(g_, revision); }
ui::SelectionContext CareerSession::selection_context_for(const GameState& state, uint64_t revision) const {
ui::SelectionContext c;
c.revision = revision;
c.source = "engine";
for (size_t t = 0; t < state.club_ids.size(); t++) {
int master = int(t);
for (size_t m = 0; m * 2 + 1 < db_.raw_club_name_offsets.size(); m++)
if (uint16_t(db_.raw_club_name_offsets[m * 2] | db_.raw_club_name_offsets[m * 2 + 1] << 8) == state.club_ids[t]) {
master = int(m);
break;
}
c.club_order.push_back(master);
}
return c;
}
std::vector<ui::ManagerChoice> CareerSession::manager_choices(uint64_t revision) const {
const auto context = selection_context(revision);
std::vector<ui::ManagerChoice> choices;
for (size_t slot = 0; slot < g_.manager_teams.size(); ++slot) {
const int team = g_.manager_teams[slot];
if (team < 0 || size_t(team) >= context.club_order.size()) throw FormatError("join: invalid existing club");
ui::ManagerChoice c;
c.slot = int(slot); c.selection_club = team; c.master_club = context.club_order[size_t(team)];
c.roster_revision = revision;
const size_t at = slot * 0xb0c;
for (size_t i = 0; i < 25 && g_.manager_records.at(at + 0xa8 + i); ++i)
c.name.push_back(char(g_.manager_records[at + 0xa8 + i]));
c.start_league = g_.manager_records.at(at + 0x210);
c.portrait = g_.manager_records.at(at + 0x221);
choices.push_back(std::move(c));
}
return choices;
}
bool CareerSession::begin_manager_join(const ui::DeskRequest& origin, const ui::SetupOptions& options,
uint64_t revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
try {
const auto desk = desktop_projection(revision);
const auto& current = desk.options;
if (manager_join_ || origin.kind != ui::DeskRequestKind::open_menu || origin.menu_kind != 29 ||
origin.revision != revision || origin.manager_slot != desk.manager_slot || desk.national_team ||
revision > std::numeric_limits<uint64_t>::max() - 4 ||
options.managers < current.managers || options.managers > 4 ||
options.difficulty < 0 || options.difficulty > 9 ||
(current.difficulty == 0 && options.difficulty != 0) ||
options.duration != current.duration || options.mode != current.mode ||
options.league != current.league || options.world != current.world)
throw FormatError("join: options or origin no longer match the running career");
ManagerJoinDraft draft;
draft.state = g_; draft.rand = rand_; draft.game = game_;
draft.options = options; draft.origin = origin; draft.choices = manager_choices(revision);
draft.original_stream = save_stream(g_); draft.original_rand_seed = rand_.seed();
draft.original_game_seed = game_.seed(); draft.original_rand_calls = rand_.calls();
draft.original_game_calls = game_.calls(); draft.context_revision = revision;
auto& mem = draft.state.memory;
mem.set8(::bmh::layout::Difficulty, uint8_t(options.difficulty)); draft.state.level = options.difficulty;
mem.set8(::bmh::layout::ManagerCount, uint8_t(options.managers));
const uint16_t signature = uint16_t(options.mode + options.duration * 4 + options.difficulty * 0x40);
mem.add_block(::bmh::layout::CareerSession_FormatError_RuntimeField7, 2);
mem.set16(::bmh::layout::CareerSession_FormatError_RuntimeField7, mem.u16(::bmh::layout::CareerSession_FormatError_RuntimeField7) == signature ? signature : 0);
mem.add_block(::bmh::layout::CareerSession_FormatError_RuntimeField6, 1); mem.set8(::bmh::layout::CareerSession_FormatError_RuntimeField6, 1);
if (mem.u32(::bmh::layout::CompetitionSelection) == 1)
for (int slot = current.managers; slot < options.managers; ++slot)
draft.state.manager_options.at(size_t(slot) * 5 + 4) = 1;
career_managers_begin(draft.state, true);
manager_join_ = std::move(draft);
return true;
} catch (const std::exception& e) { error = e.what(); return false; }
}
ui::SelectionContext CareerSession::manager_join_context() const {
if (!manager_join_) throw FormatError("join: no draft");
return selection_context_for(manager_join_->state, manager_join_->context_revision);
}
bool CareerSession::manager_join_complete() const {
return manager_join_ && manager_join_->choices.size() == size_t(manager_join_->options.managers);
}
bool CareerSession::confirm_manager_join(const ui::ManagerChoice& choice, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
if (!manager_join_ || manager_join_complete()) { error = "join: no pending manager"; return false; }
auto before = *manager_join_;
try {
auto& draft = *manager_join_;
const auto context = manager_join_context();
if (choice.slot != int(draft.choices.size()) || choice.roster_revision != context.revision ||
choice.name.empty() || choice.name.size() > 24 || choice.name.find('\0') != std::string::npos ||
choice.start_league < 0 || choice.start_league > 4 || choice.strength < 0 || choice.strength > 2 ||
choice.portrait < 0 || choice.portrait > 11 || choice.selection_club < 0 ||
size_t(choice.selection_club) >= context.club_order.size() ||
context.club_order[size_t(choice.selection_club)] != choice.master_club ||
std::any_of(draft.choices.begin(), draft.choices.end(), [&](const auto& old) {
return old.master_club == choice.master_club || old.portrait == choice.portrait;
})) throw FormatError("join: invalid or stale manager choice");
CareerManager selected;
selected.name = choice.name; selected.team = runtime_club(draft.state, choice.master_club);
selected.league = choice.start_league; selected.strength = choice.strength; selected.portrait = choice.portrait;
if (selected.team < 0) throw FormatError("join: club not found");
const auto visible=player_league_count(exe_);
const auto club_league=team_league(selected.team);
if(selected.league>=visible||(club_league>=visible&&club_league<5))throw FormatError("join: league is not available for human management");
MinuteReport report;
if (!career_add_manager(draft.state, exe_, choice.slot, selected, true, draft.game, draft.rand, report))
throw FormatError(report.reason);
draft.choices.push_back(choice); ++draft.context_revision;
return true;
} catch (const std::exception& e) { manager_join_ = std::move(before); error = e.what(); return false; }
}
bool CareerSession::commit_manager_join(ui::CareerInitializationResult& result, uint64_t& revision,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
if (!manager_join_complete()) { error = "join: selection incomplete"; return false; }
auto before = manager_join_checkpoint();
const auto previous_revision = revision;
try {
const auto& draft = *manager_join_;
if (draft.origin.revision != revision || save_stream(g_) != draft.original_stream ||
rand_.seed() != draft.original_rand_seed || game_.seed() != draft.original_game_seed ||
rand_.calls() != draft.original_rand_calls || game_.calls() != draft.original_game_calls)
throw FormatError("join: career changed during selection");
g_ = draft.state; rand_ = draft.rand; game_ = draft.game;
career_managers_end(g_, true);
managers_.clear();
for (const auto& c : draft.choices)
managers_.push_back({c.slot, c.master_club, g_.manager_teams.at(size_t(c.slot))});
// ConfirmManager retains the current desk/cursor. Weiter performs the later handoff.
const auto next_revision = revision + 1;
turn_driver_.revision = next_revision;
ui::CareerInitializationResult next;
next.desktop = desktop_projection(next_revision); next.managers = managers_;
next.preparation = preparation_projection(next_revision);
ui::validate_preparation_context(next.preparation);
result = std::move(next); revision = next_revision; manager_join_.reset();
return true;
} catch (const std::exception& e) {
restore_manager_join_checkpoint(std::move(before)); revision = previous_revision;
error = e.what(); return false;
}
}
void CareerSession::apply_options(const ui::SetupOptions& o) {
// SetupScreen2 takes the four numbers over when the options dialog is left
StaticMemory& mem = g_.memory;
mem.set8(::bmh::layout::CareerDuration, uint8_t(o.duration));
mem.set8(::bmh::layout::Difficulty, uint8_t(o.difficulty));
g_.level = o.difficulty; // (the typed copy)
mem.set8(::bmh::layout::ManagerCount, uint8_t(o.managers));
mem.set8(::bmh::layout::GameMode, uint8_t(o.mode));
mem.set32(::bmh::layout::CompetitionSelection, (o.league ? 1u : 0u) | (o.world ? 2u : 0u));
// The end of SetupScreen2 at a new game (param_1 = 0, the first manager):
// - a one-manager game flags its manager as Bundestrainer (record +0x21c, CareerSessionRuntimeField2);
// - without the league game every calendar day (CompetitionCalendar, 0x16e words) except the
// World Cup finals (0x4006) loses its low byte and keeps only the international bits
// 0x1e of its high byte;
// - without the World Cup game the international bits go: the high byte keeps 0x61 only.
// So the national team plays (and its manager takes over, SwapManagerSlots2 on 0x1e00
// days) only when the World Cup mode is on, as the manual says (Handbuch 2, p. 11);
// - the league-only game sets option byte 4 (CareerSessionRuntimeField3) of every manager.
if (managers_.empty() && o.managers == 1 && g_.manager_records.size() >= 0xb0c)
g_.manager_records.at(0x21c) = 1;
if (mem.has(kSavedCalendar + 0x16e * 2 - 1))
for (uint32_t day = 0; day < 0x16e; ++day) {
const uint32_t at = kSavedCalendar + day * 2;
uint16_t word = mem.u16(at);
if (!o.league && word != 0x4006) word = uint16_t(word & 0x1e00);
if (!o.world) word = uint16_t(word & 0x61ff);
mem.set16(at, word);
}
if (o.league && !o.world)
for (int m = 0; m < o.managers && size_t(m) * 5 + 4 < g_.manager_options.size(); ++m)
g_.manager_options.at(size_t(m) * 5 + 4) = 1;
career_managers_begin(g_);
options_applied_ = true;
}
bool CareerSession::confirm_manager(const ui::SetupOptions& options, const ui::ManagerChoice& choice, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const auto visible=player_league_count(exe_);
const auto selected_team=runtime_club(choice.master_club);
const auto selected_league=selected_team>=0?team_league(selected_team):-1;
if(choice.start_league<0||choice.start_league>=visible||(selected_league>=visible&&selected_league<5)) {
error="league is not available for human management";return false;
}
if (!options_applied_) apply_options(options);
const int m = int(managers_.size());
if (m >= options.managers) {
error = "more managers than chosen in the options";
return false;
}
CareerManager c;
c.name = choice.name;
c.team = runtime_club(choice.master_club);
c.league = choice.start_league;
c.strength = choice.strength;
c.portrait = choice.portrait;
if (c.team < 0) {
error = "club not found";
return false;
}
MinuteReport report;
if (!career_add_manager(g_, exe_, m, c, false, game_, rand_, report)) {
error = report.reason;
return false;
}
managers_.push_back({choice.slot, choice.master_club, g_.manager_teams.at(size_t(m))});
return true;
}
std::optional<ClubInfoEntry> CareerSession::enter_club_information(int team, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
try { return prepare_club_info_entry(g_, team); }
catch (const std::invalid_argument& e) { error = e.what(); return std::nullopt; }
}
std::optional<uint8_t> CareerSession::change_club_information_category(int team, int requested,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
try { return set_club_info_category(g_, team, requested); }
catch (const std::invalid_argument& e) { error = e.what(); return std::nullopt; }
}
std::optional<ClubPlayerDetailRedraw> CareerSession::redraw_club_player_detail(
const ClubPlayerDetailSelection& selection, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
auto next_game = game_;
auto next_rand = rand_;
try {
auto redraw = club_player_detail_redraw(g_, selection, exe_, next_game, next_rand);
game_ = next_game;
rand_ = next_rand;
return redraw;
} catch (const std::invalid_argument& e) {
error = e.what();
return std::nullopt;
}
}
std::optional<bool> CareerSession::dispatch_club_player_national_action(
const ClubPlayerDetailSelection& selection, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
auto next_state = g_;
auto next_rand = rand_;
MinuteReport report;
try {
const bool applied = club_player_detail_national_action(next_state, selection, next_rand, report);
if (!report.reason.empty()) { error = report.reason; return std::nullopt; }
g_ = std::move(next_state);
rand_ = next_rand;
return applied; // Source still refreshes the lineup when an add finds a full squad.
} catch (const std::invalid_argument& e) {
error = e.what();
return std::nullopt;
}
}
std::optional<PendingOfferResult> CareerSession::dispatch_club_player_pending_offers(
const ClubPlayerDetailSelection& selection, uint64_t expected_revision,
const PendingOfferHooks& hooks, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (expected_revision != revision || pending_offer_dispatch_active_ || market_dispatch_active_ ||
revision == std::numeric_limits<uint64_t>::max()) {
error = "pending offer: stale or nested player-card action";
return std::nullopt;
}
auto next_state = g_;
auto next_game = game_;
auto next_rand = rand_;
pending_offer_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{pending_offer_dispatch_active_};
MinuteReport report;
try {
const auto result = process_player_card_pending_offers(
next_state, selection, next_game, next_rand, pending_hooks_for_dispatch(hooks), report);
if (report.unsupported || !result.completed) {
error = report.reason.empty() ? "pending offer: manual decision incomplete" : report.reason;
return std::nullopt;
}
if (result.processed != 0) {
g_ = std::move(next_state);
game_ = next_game;
rand_ = next_rand;
// A nested cup modal belongs to the current calendar transaction;
// its outer driver publishes that revision when advancement returns.
if (!calendar_advance_active_) ++revision;
}
return result;
} catch (const std::exception& e) {
error = e.what();
return std::nullopt;
}
}
void CareerSession::initialize_club_modal_runtime() {
// Setup clears the boot-only dialog mode before either creating or loading
// a career. This process flag is deliberately absent from native saves.
club_modal_runtime_.emplace(layout::CompactDialogFrame, 0);
// LE object4 has bb cdd/de/e1 in its zero-initialized virtual tail;
// CareerSession_InitializeClubModalRuntime_ExecutableField is file-backed zero. These are explicit process-start values,
// carried by this runtime owner across modal entry/return, not FBM bytes.
for(uint32_t address:{::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableFieldUnsigned,::bmh::layout::CareerSession_DispatchPoachUi_ExecutableFieldUnsigned,::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField2Unsigned,::bmh::layout::CareerSession_InitializeClubModalRuntime_ExecutableFieldUnsigned})
club_modal_runtime_.emplace(address,exe_.u8(address));
}
SportschauSourceOptions CareerSession::sportschau_source_options() const {
return {source_runtime_byte(g_, club_modal_runtime_, exe_, ::bmh::layout::CareerSession_SportschauSourceOptions_ExecutableField),
source_runtime_byte(g_, club_modal_runtime_, exe_, ::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField2), exe_.u16(::bmh::layout::TeamsWithSquads),
sportschau_rating_tables(exe_)};
}
ClubModalServices CareerSession::staged_club_modal_services(GameState& state,
GameRandom& game,WatcomRandom& rand,std::map<uint32_t,uint8_t>& runtime) {
ClubModalServices services;
auto* g=&state; auto* gr=&game; auto* wr=&rand; auto* bytes=&runtime;
services.state=[g]() -> GameState& { return *g; };
services.enter_club=[g](int team) { return prepare_club_info_entry(*g,team); };
services.change_category=[g](int team,int category) { return set_club_info_category(*g,team,category); };
services.redraw_player=[this,g,gr,wr](const ClubPlayerDetailSelection& selection) {
auto next_game=*gr; auto next_rand=*wr;
auto result=club_player_detail_redraw(*g,selection,exe_,next_game,next_rand);
*gr=next_game; *wr=next_rand; return result;
};
services.national_action=[g,wr](const ClubPlayerDetailSelection& selection) {
auto next=*g; auto next_rand=*wr; MinuteReport report;
const bool applied=club_player_detail_national_action(next,selection,next_rand,report);
if(!report.reason.empty())throw FormatError(report.reason);
*g=std::move(next); *wr=next_rand; return applied;
};
services.pending_offers=[this,g,gr,wr](const ClubPlayerDetailSelection& selection,const PendingOfferHooks& hooks) {
auto next=*g; auto next_game=*gr; auto next_rand=*wr; MinuteReport report;
auto result=process_player_card_pending_offers(next,selection,next_game,next_rand,
pending_hooks_for_dispatch(hooks),report);
if(report.unsupported||!result.completed)
throw FormatError(report.reason.empty()?"TeamInfo: nested pending decision incomplete":report.reason);
*g=std::move(next); *gr=next_game; *wr=next_rand; return result;
};
services.runtime_byte=[this,g,bytes](uint32_t address) {
if(g->memory.has(address))return g->memory.u8(address);
if(const auto at=bytes->find(address);at!=bytes->end())return at->second;
// Explicit original initialization supplies the transient input owner.
// Never serialize an absent BSS byte or infer Native absence as zero.
return exe_.u8(address);
};
services.set_runtime_byte=[g,bytes](uint32_t address,uint8_t value) {
if(g->memory.has(address))g->memory.set8(address,value);
else (*bytes)[address]=value;
};
return services;
}
ClubModalServices CareerSession::live_club_modal_services(uint64_t& revision) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) throw FormatError("strengths_active");
auto services=staged_club_modal_services(g_,game_,rand_,club_modal_runtime_);
services.transactional=false;
// Existing cup/club caller keeps its separately owned pending transaction.
services.pending_offers=[this,&revision](const ClubPlayerDetailSelection& selection,const PendingOfferHooks& hooks) {
std::string error;
auto result=dispatch_club_player_pending_offers(selection,revision,hooks,revision,error);
if(!result)throw FormatError(error);
return *result;
};
return services;
}
namespace {
void pairings_runtime_draw(GameState& g,std::map<uint32_t,uint8_t>& runtime,
const ui::LeaguePairingsState& page,const LeImage& exe) {
const auto put=[&](uint32_t at,uint8_t v) {
if(g.memory.has(at))g.memory.set8(at,v);else runtime[at]=v;
};
const uint32_t tip_preference=::bmh::layout::CareerSession_CloseLeagueFamily_ExecutableField+uint32_t(page.identity.manager);
const bool computer_tip=page.source.owner.computer_tip_active;
if(computer_tip)put(tip_preference,uint8_t(g.memory.u8(tip_preference)|0x10));
// Actual5147b entry/input globals; these are process bytes, not invented FBM blocks.
put(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2,uint8_t(page.identity.league));put(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField,page.source.owner.league_group);
put(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField,0);put(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2,0);
const auto date=[&](uint32_t counter) {
if(counter==0xffff)return; //21258's Wettbewerb-gesperrt branch changes no date scratch.
const auto d=ui::desk_date(counter,exe);
int cycle=3;uint32_t n=counter;
while(n>uint32_t(364+(cycle==4))) {if(cycle==4){cycle=0;--n;}n-=365;++cycle;}
put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField,uint8_t(28+(cycle==4)));
put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField4,uint8_t(d.day));put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField5,uint8_t(d.month));put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField6,uint8_t(d.weekday));
put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField2,uint8_t(d.year));put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField3,uint8_t(d.year>>8));
};
const bool selected_filter=page.source.owner.filter_active&&page.source.owner.filter_team>=0;
if(!selected_filter&&!page.source.owner.postponed_active)
date(page.source.match_date); //333f3 is absent in selected Mode4 and Mode8.
for(const auto& row:page.source.rows) {
if(row.scheduled_date)date(*row.scheduled_date);
else if(row.postponed_date)date(*row.postponed_date);
const uint8_t displayed=row.computer_tip_result.value_or(row.raw_result);
// In local28's referee phase, exact CC rows skip both 68164 calls.
// Preserve prior scratch when every row takes that branch; a mixed
// page leaves the last ordinary away-row value, in Source draw order.
if(page.source.owner.active_phase&&displayed==0xcc)continue;
//68164's final17295 call on the away team leaves Source CareerSession_FormatError_ExecutableField3.
const auto strength=team_average(g,row.away.runtime_team,0x1ff);
put(::bmh::layout::CareerSession_FormatError_ExecutableField3,uint8_t(strength.best_half_sum));put(::bmh::layout::CareerSession_FormatError_ExecutableField4,uint8_t(strength.best_half_sum>>8));
}
// Move clears its one-redraw local38 bit after the forecast has
// been projected. The returned page retains the pressed Original button.
if(computer_tip)put(tip_preference,uint8_t(g.memory.u8(tip_preference)&0xef));
}
bool other_games_source_manager_owned(const GameState& g,int team) {
if(team<0||!g.memory.has(::bmh::layout::ManagerCount))
throw FormatError("other games: missing Source manager count for club detail redraw");
const size_t count=g.memory.u8(::bmh::layout::ManagerCount);
if(count>4||count>g.manager_teams.size())
throw FormatError("other games: invalid Source manager count for club detail redraw");
for(size_t manager=0;manager<count;++manager)
if(g.manager_teams[manager]==team)return true;
constexpr size_t national_record=4*0xb0c+0x290;
if(!g.manager_teams.empty()&&g.manager_teams.front()==kNoTeam&&
g.manager_records.size()>=national_record+2)
return int(uint16_t(g.manager_records[national_record]|
uint16_t(g.manager_records[national_record+1])<<8))==team;
return false;
}
void other_games_source_redraw_effects(GameState& g,WatcomRandom& rand,
std::map<uint32_t,uint8_t>& runtime,const OtherGamesProjection& projection,
const LeImage& exe) {
const auto put=[&](uint32_t address,uint8_t value) {
if(g.memory.has(address))g.memory.set8(address,value);
else runtime[address]=value;
};
constexpr std::array<uint16_t,5> source_flags{0x0f1,0x0f2,0x0f4,0x0f8,0x0ff};
for(const auto& row:projection.rows) {
for(const int team:{row.home_team,row.away_team}) {
// Void6 emits a fixed foreign-strength label without calling QuoteNationalFriendlyMatch
// for a non-manager international club. All other displayed rows make
// five ordered Source average calls; overseas manager clubs use W there.
if(team>=exe.u16(::bmh::layout::NoTeamSquadStart)&&
!other_games_source_manager_owned(g,team))continue;
for(const uint16_t flags:source_flags) {
const auto value=team_average(g,team,flags,&rand);
// QuoteNationalFriendlyMatch resets/updates CareerSession_FormatError_ExecutableField3 only on the squad-backed branch;
// TeamRating's foreign-rating branch leaves the previous scratch intact.
if(team<exe.u16(::bmh::layout::NoTeamSquadStart)||team==kNoTeam) {
put(::bmh::layout::CareerSession_FormatError_ExecutableField3,uint8_t(value.best_half_sum));
put(::bmh::layout::CareerSession_FormatError_ExecutableField4,uint8_t(value.best_half_sum>>8));
}
}
}
}
}
bool same_other_games_live_baseline(const CareerSession::OtherGamesCheckpoint& before,
const CareerSession::OtherGamesCheckpoint& after) {
if(save_stream(before.state)!=save_stream(after.state)||
before.game.seed()!=after.game.seed()||before.game.calls()!=after.game.calls()||
before.rand.seed()!=after.rand.seed()||before.rand.calls()!=after.rand.calls()||
before.runtime!=after.runtime||
before.selection.competition!=after.selection.competition||
before.selection.linked_page!=after.selection.linked_page||
before.next_scope!=after.next_scope||before.owner.has_value()!=after.owner.has_value())
return false;
if(!before.owner)return true;
const auto& a=*before.owner;const auto& b=*after.owner;
return a.page.identity==b.page.identity&&a.desk_owner==b.desk_owner&&
a.round==b.round&&a.participant_offset==b.participant_offset&&
a.display_mode==b.display_mode&&a.native==b.native&&a.runtime==b.runtime&&
a.rand_seed==b.rand_seed&&a.game_seed==b.game_seed&&
a.rand_calls==b.rand_calls&&a.game_calls==b.game_calls&&
a.page.source_participant_offset==b.page.source_participant_offset&&
a.page.projection.competition==b.page.projection.competition&&
a.page.projection.entry_index==b.page.projection.entry_index&&
a.page.projection.linked_page==b.page.projection.linked_page&&
a.page.projection.round==b.page.projection.round&&
a.page.projection.display_mode==b.page.projection.display_mode;
}
bool same_strengths_runtime_state(const GameState& a,const GameState& b) {
const auto same_callback=[](const auto& lhs,const auto& rhs) {
return bool(lhs)==bool(rhs)&&(!lhs||lhs.target_type()==rhs.target_type());
};
return a.indoor==b.indoor&&a.currency_suffix==b.currency_suffix&&a.level==b.level&&
a.chance_rain==b.chance_rain&&a.chance_temperature==b.chance_temperature&&
a.last_shooter==b.last_shooter&&a.last_pick_quality==b.last_pick_quality&&
a.live_scene==b.live_scene&&a.reality==b.reality&&a.live_matches==b.live_matches&&a.list_toggle==b.list_toggle&&
a.lineups_frozen==b.lineups_frozen&&a.texts==b.texts&&a.date==b.date&&
a.season_start==b.season_start&&a.development_balance==b.development_balance&&
a.trend_rotation==b.trend_rotation&&a.season==b.season&&a.transfer_notice_suppressed==b.transfer_notice_suppressed&&
a.offer_answer==b.offer_answer&&a.pools_open==b.pools_open&&a.autosave_months==b.autosave_months&&
a.autosave_month==b.autosave_month&&same_callback(a.contract_screen,b.contract_screen)&&
same_callback(a.loan_return_screen,b.loan_return_screen)&&
same_callback(a.loan_return_offer_screen,b.loan_return_offer_screen)&&
same_callback(a.transfer_decision,b.transfer_decision)&&
same_callback(a.transfer_offer_selector,b.transfer_offer_selector)&&
same_callback(a.transfer_decision_observer,b.transfer_decision_observer);
}
int8_t source_byte(int value) { return static_cast<int8_t>(uint8_t(value)); }
std::string source_table_range_label(const TextDb& texts,int first,int end) {
// DE50860 patches offsets 4/7 of its nine-byte TEXTD82 buffer. EN1e83f
// patches 0/3 of the full " 0-34 only" string instead (the final y is live).
const auto fixed=texts.raw(82,9);
auto raw=kEnglishCompetitions ? texts[82] : std::string(fixed.begin(),fixed.end());
const size_t start=kEnglishCompetitions ? 0 : 4;
const size_t finish=kEnglishCompetitions ? 3 : 7;
if(raw.size()<finish+2)throw FormatError("league table: incomplete Source range label");
auto patch_number=[&](size_t at,int value) {
const int tens=value/10,ones=value%10;
raw[at]=uint8_t(char(tens+'0'));raw[at+1]=uint8_t(char(ones+'0'));
};
patch_number(start,first+1);patch_number(finish,end);
return raw;
}
void source_table_normalize_range(CareerSession::LeagueFamilyOwner::TableOwner& table,
const GameState& game,int league,const TextDb& texts) {
if(league<0||league>=int(game.league_rounds.size()))
throw FormatError("league table: missing Source round byte");
const int8_t raw_end=source_byte(table.end_round);
const int8_t raw_first=source_byte(table.first_round);
const uint8_t raw_round=game.league_rounds[size_t(league)];
const int max_round=bmh::league_matchdays(league);
if(max_round<int(raw_end)||raw_end<=raw_first||int(raw_round)<int(raw_end))
table.end_round=int(game.league_rounds[size_t(league)]);
if(source_byte(table.end_round)<=source_byte(table.first_round))
table.end_round=table.first_round+1;
table.retained_range_label_source_bytes=source_table_range_label(
texts,source_byte(table.first_round),source_byte(table.end_round));
}
bool source_table_identity_is_live(const GameState& game,const ui::StrengthsIdentity& id) {
if(id.manager<0||id.manager>3||id.league<0||id.league>=bmh::kLeagueCount||
!game.memory.has(::bmh::layout::ActiveManager)||game.memory.u8(::bmh::layout::ActiveManager)!=id.manager||
size_t(id.manager)>=game.manager_teams.size()||game.manager_teams[size_t(id.manager)]!=id.runtime_club||
game.date!=id.day_counter||id.runtime_club<0||size_t(id.runtime_club)>=game.club_ids.size()||
int(game.club_ids[size_t(id.runtime_club)])!=id.club_identity||
id.league_group>1) return false;
const size_t record=size_t(id.manager)*0xb0c;
if(record+0x212>game.manager_records.size()||
id.manager_default_league!=int(game.manager_records[record+0x210])) return false;
const uint32_t settings=::bmh::layout::ManagerSettings+uint32_t(id.manager)*2;
const uint32_t family=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
return game.memory.has(settings+1)&&game.memory.has(family+1)&&
game.memory.u16(settings)==id.expected_settings_word&&
game.memory.u16(family)==id.expected_family_word;
}
bool canonical_table_envelope(const ui::LeagueFamilyRequest& request,int control_index=-1,
bool allow_selector_league=false) {
return request.target_child==0&&request.runtime_team==-1&&request.expected_club_identity==-1&&
request.table_row_index==-1&&(allow_selector_league||request.league_id==-1)&&
request.control_index==control_index&&
!request.table_dialog_reply;
}
void source_table_apply_entry_flags(CareerSession::LeagueFamilyOwner::TableOwner& table,uint16_t word) {
if((word&4)==0)table.aggregation_flags=uint8_t(table.aggregation_flags|1);
if((word&2)==0)table.aggregation_flags=uint8_t(table.aggregation_flags|2);
}
ui::LeagueTableProjectionContext source_table_context(
const CareerSession::LeagueFamilyOwner::TableOwner& table,uint16_t display_word,
std::optional<bmh::LeagueTable> accepted={},bool forecast=false) {
ui::LeagueTableProjectionContext context;
context.first_round=table.first_round;context.end_round=table.end_round;
context.aggregation_flags=table.aggregation_flags;context.normal_mode=table.normal_mode;
context.display_word_override=display_word;
context.retained_range_label_source_bytes=table.retained_range_label_source_bytes;
if(accepted) {context.accepted_engine_league=accepted->league;context.accepted_engine_table=std::move(accepted);}
context.forecast=forecast;return context;
}
}
std::optional<ui::StrengthsRequest> CareerSession::strengths_open_request(uint64_t revision) const {
if(!g_.memory.has(::bmh::layout::ActiveManager))return {};
const int manager=g_.memory.u8(::bmh::layout::ActiveManager);
if(manager<0||manager>3||size_t(manager)>=g_.manager_teams.size())return {};
const int club=g_.manager_teams[size_t(manager)];
const uint32_t setting=::bmh::layout::ManagerSettings+uint32_t(manager)*2,family=::bmh::layout::LeagueTableDisplayModes+uint32_t(manager)*2;
if(club<0||size_t(club)>=g_.club_ids.size()||!g_.memory.has(setting+1)||!g_.memory.has(family+1))return {};
ui::StrengthsRequest request;
request.identity={manager,club,int(g_.club_ids[size_t(club)]),club>356?0:team_league(club),g_.date,
revision,0,0,g_.memory.u16(setting),g_.memory.u16(family)};
request.identity.league_group=uint8_t(request.identity.league>=5);
const size_t record=size_t(manager)*0xb0c;
if(record+0x212<=g_.manager_records.size())
request.identity.manager_default_league=int(g_.manager_records[record+0x210]);
else return {};
return request;
}
std::optional<ui::StrengthsIdentity> CareerSession::begin_league_family(
ui::StrengthsIdentity identity,uint8_t child,uint64_t revision,std::string& error) {
error.clear();
if(league_family_teaminfo_active_||league_family_owner_||child<1||child>3||revision==UINT64_MAX||identity.revision!=revision||
(identity.source_param2!=0&&!live_source_identity(identity))||identity.family_id||identity.manager<0||identity.manager>3||
identity.league<0||identity.league>8||!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=identity.manager||
size_t(identity.manager)>=g_.manager_teams.size()||g_.manager_teams[size_t(identity.manager)]!=identity.runtime_club||
identity.day_counter!=g_.date||identity.runtime_club<0||size_t(identity.runtime_club)>=g_.club_ids.size()||
int(g_.club_ids[size_t(identity.runtime_club)])!=identity.club_identity||next_league_family_id_==UINT64_MAX) {
error="league family: invalid or nested family entry";return {};
}
if(child==1&&(strengths_owner_||league_pairings_draft_)) {
error="league family: Table entry has another child owner";return {};
}
if(child==2&&(!league_pairings_draft_||strengths_owner_||
league_pairings_draft_->owner.manager!=identity.manager||
league_pairings_draft_->owner.runtime_club!=identity.runtime_club||
league_pairings_draft_->owner.club_identity!=identity.club_identity)) {
error="league family: Pairings entry has no matching child owner";return {};
}
if(child==3&&(!strengths_owner_||strengths_owner_->page.identity.manager!=identity.manager||
strengths_owner_->page.identity.runtime_club!=identity.runtime_club||
strengths_owner_->page.identity.revision!=revision)) {
error="league family: Strengths entry has no matching child owner";return {};
}
identity.family_id=next_league_family_id_++;
if(child==3) {
identity=strengths_owner_->page.identity;
identity.family_id=next_league_family_id_-1;
strengths_owner_->page.identity=identity;
strengths_owner_->native=save_stream(g_);
}
LeagueFamilyOwner owner;owner.identity=identity;owner.child=child;owner.native=save_stream(g_);
owner.rand_seed=rand_.seed();owner.game_seed=game_.seed();owner.rand_calls=rand_.calls();
owner.game_calls=game_.calls();owner.runtime=club_modal_runtime_;
if(child==1) {
LeagueFamilyOwner::TableOwner table;table.end_round=int(g_.league_rounds.at(size_t(identity.league)));
uint16_t word=uint16_t(g_.memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(identity.manager)*2)&0xff7f);
g_.memory.set16(::bmh::layout::LeagueTableDisplayModes+uint32_t(identity.manager)*2,word);
identity.expected_family_word=word;owner.identity=identity;
table.display_word_override=word;
source_table_apply_entry_flags(table,word);
table.normal_mode=source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField)&1;
table.runtime_font_id=exe_.u8(::bmh::layout::Advertising_Button_RuntimeField + 1);
source_table_normalize_range(table,g_,identity.league,texts_);
table.page=ui::league_table_from_game(g_,identity.manager,identity.league,
source_table_context(table,table.display_word_override));
owner.table=std::move(table);
}
owner.identity=identity;owner.native=save_stream(g_);owner.runtime=club_modal_runtime_;
owner.rand_seed=rand_.seed();owner.game_seed=game_.seed();owner.rand_calls=rand_.calls();owner.game_calls=game_.calls();
league_family_owner_=std::move(owner);
return identity;
}
std::optional<ui::StrengthsIdentity> CareerSession::begin_friendly_opponent_table(
uint64_t revision,std::string& error) {
error.clear();
const auto request=strengths_open_request(revision);
if(!request||request->identity.runtime_club>=168||request->identity.source_param2||
league_family_owner_||strengths_owner_||league_pairings_draft_) {
error="friendly table: unavailable club entry";return {};
}
const auto checkpoint=league_family_checkpoint();
try {
auto identity=request->identity;
// Desktop case6 initializes these before its direct FriendlyMatchScreen(2,0).
const uint32_t word_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(identity.manager)*2;
const auto mode=exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(identity.league));
uint16_t word=uint16_t((g_.memory.u16(word_at)&0xfc0f)|0x0170);
if(mode)word|=0x80;
g_.memory.set16(word_at,word);
club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2]=uint8_t(identity.league);
club_modal_runtime_[::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField]=0;identity.league_group=0;
club_modal_runtime_[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=mode;club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField]=0;
club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2]=0;
identity.expected_family_word=word;
const auto bound=begin_league_family(identity,1,revision,error);
if(!bound)throw FormatError(error.empty()?"friendly table: owner entry rejected":error);
league_family_owner_->friendly_opponent=true;
return bound;
} catch(const std::exception& e) {
restore_league_family_checkpoint(checkpoint);error=e.what();return {};
}
}
std::optional<int> CareerSession::resolve_friendly_table_opponent(
const ui::LeagueFamilyRequest& request,uint64_t revision,std::string& error) const {
error.clear();
if(!league_family_owner_||!league_family_owner_->friendly_opponent||
league_family_owner_->identity!=request.identity||request.identity.revision!=revision||
request.kind!=ui::LeagueFamilyRequestKind::select_opponent||request.from_child!=1||
request.target_child||request.control_index!=-1||request.league_id!=-1||request.table_dialog_reply) {
error="friendly table: stale opponent selection";return {};
}
const auto dispatch=current_league_table_dispatch(error);
if(!dispatch||dispatch->phase!=TableDispatchPhase::ready)return {};
const auto& table=*league_family_owner_->table;
const int row=request.table_row_index;
if(row<0||size_t(row)>=dispatch->page.rows.size()||size_t(row)>=table.page.rows.size()) {
error="friendly table: opponent row outside the owned page";return {};
}
const auto& visible=dispatch->page.rows[size_t(row)];
const auto& normal=table.page.rows[size_t(row)];
if(visible.runtime_team_id!=request.runtime_team||visible.club_identity_key!=request.expected_club_identity||
visible.runtime_team_id<0||size_t(visible.runtime_team_id)>=g_.club_ids.size()||
visible.club_identity_key!=int(g_.club_ids[size_t(visible.runtime_team_id)])||
normal.rank!=row+1||normal.runtime_team_id<0||normal.runtime_team_id>=168||
size_t(normal.runtime_team_id)>=g_.club_ids.size()||
normal.club_identity_key!=int(g_.club_ids[size_t(normal.runtime_team_id)])) {
error="friendly table: opponent row identity changed";return {};
}
// After a forecast Present FriendlyMatchScreen resolves TableRuntimeField6's restored normal ranks.
return normal.runtime_team_id;
}
std::optional<ui::StrengthsIdentity> CareerSession::acknowledge_friendly_own_club(
const ui::LeagueFamilyRequest& request,uint64_t revision,std::string& error) {
const auto team=resolve_friendly_table_opponent(request,revision,error);
if(!team||*team!=request.identity.runtime_club||request.identity.family_sequence==UINT64_MAX) {
if(error.empty())error="friendly table: invalid own-club return";
return {};
}
auto& owner=*league_family_owner_;auto next=owner.identity;
uint16_t word=uint16_t((next.expected_family_word&0x0f7f)|(owner.table->normal_mode?0x80:0));
auto state=g_;state.memory.set16(::bmh::layout::LeagueTableDisplayModes+uint32_t(next.manager)*2,word);
auto native=save_stream(state);
++next.family_sequence;next.expected_family_word=word;
g_=std::move(state);owner.native=std::move(native);owner.identity=next;
// Keep the visible forecast/body and normal ranks: this is the inner loop.
return next;
}
std::optional<ui::PreparationState> CareerSession::finish_friendly_opponent_table(
const ui::LeagueFamilyRequest& request,uint64_t& revision,std::string& error) {
error.clear();
if(!league_family_owner_||!league_family_owner_->friendly_opponent||
request.identity!=league_family_owner_->identity||request.identity.revision!=revision||
revision==UINT64_MAX||request.from_child!=1||request.target_child) {
error="friendly table: stale return";return {};
}
if(request.kind==ui::LeagueFamilyRequestKind::select_opponent) {
const auto team=resolve_friendly_table_opponent(request,revision,error);
if(!team||*team==request.identity.runtime_club) {
if(error.empty())error="friendly table: own club keeps the picker open";
return {};
}
} else if(request.kind!=ui::LeagueFamilyRequestKind::close||!canonical_table_envelope(request,-1)) {
error="friendly table: invalid return envelope";return {};
}
const auto dispatch=current_league_table_dispatch(error);
if(!dispatch||dispatch->phase!=TableDispatchPhase::ready)return {};
const auto checkpoint=league_family_checkpoint();
try {
const uint32_t word_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(request.identity.manager)*2;
uint16_t word=uint16_t(g_.memory.u16(word_at)&0x0f7f);
if(league_family_owner_->table->normal_mode)word|=0x80;
g_.memory.set16(word_at,word);
auto preparation=preparation_projection(revision+1);
ui::validate_preparation_context(preparation);
ui::DesktopScreen validate(data_directory_,preparation.desktop);
// Direct table return: no LeagueScreenShown family teardown / stir_random.
league_family_owner_.reset();++revision;
return preparation;
} catch(const std::exception& e) {
restore_league_family_checkpoint(checkpoint);error=e.what();return {};
}
}
bool CareerSession::advance_league_family(const ui::LeagueFamilyRequest& request,
ui::StrengthsIdentity next,uint8_t target,uint64_t revision,std::string& error) {
error.clear();
if(league_family_teaminfo_active_||!league_family_owner_||league_family_owner_->friendly_opponent||league_family_owner_->child!=request.from_child||
league_family_owner_->identity!=request.identity||request.identity.family_id==0||
request.kind!=ui::LeagueFamilyRequestKind::navigate||target<1||target>3||target!=request.target_child||
revision<request.identity.revision||revision-request.identity.revision>1u||
next.revision!=revision||next.family_id!=request.identity.family_id||
next.manager!=request.identity.manager||next.runtime_club!=request.identity.runtime_club||
next.club_identity!=request.identity.club_identity||next.day_counter!=request.identity.day_counter||
next.source_param2!=request.identity.source_param2||next.manager_default_league!=request.identity.manager_default_league||
request.identity.family_sequence==UINT64_MAX||next.family_sequence!=request.identity.family_sequence+1||
next.league<0||next.league>8||
(request.from_child==1&&league_family_owner_->table&&
league_family_owner_->table->phase!=TableDispatchPhase::ready)) {
error="league family: stale or mismatched child transition";return false;
}
auto owner=*league_family_owner_;owner.identity=next;owner.child=target;owner.native=save_stream(g_);
owner.rand_seed=rand_.seed();owner.game_seed=game_.seed();owner.rand_calls=rand_.calls();
owner.game_calls=game_.calls();owner.runtime=club_modal_runtime_;
owner.table.reset();
if(target==1) {
LeagueFamilyOwner::TableOwner table;table.end_round=int(g_.league_rounds.at(size_t(next.league)));
uint16_t word=uint16_t(g_.memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(next.manager)*2)&0xff7f);
g_.memory.set16(::bmh::layout::LeagueTableDisplayModes+uint32_t(next.manager)*2,word);
next.expected_family_word=word;owner.identity=next;
table.display_word_override=word;
source_table_apply_entry_flags(table,word);
table.normal_mode=source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField)&1;
table.runtime_font_id=exe_.u8(::bmh::layout::Advertising_Button_RuntimeField + 1);
source_table_normalize_range(table,g_,next.league,texts_);
table.page=ui::league_table_from_game(g_,next.manager,next.league,
source_table_context(table,table.display_word_override));
owner.table=std::move(table);
}
owner.identity=next;owner.native=save_stream(g_);owner.runtime=club_modal_runtime_;
owner.rand_seed=rand_.seed();owner.game_seed=game_.seed();owner.rand_calls=rand_.calls();owner.game_calls=game_.calls();
league_family_owner_=std::move(owner);return true;
}
bool CareerSession::live_source_identity(const ui::StrengthsIdentity& id) const {
return live_overview_owner_ &&
live_overview_owner_->kind != LiveOverviewKind::cup_other_games &&
live_overview_owner_->request.manager_slot == id.manager &&
live_overview_owner_->request.runtime_team == id.runtime_club &&
live_overview_owner_->request.minute >= 0 && live_overview_owner_->request.minute <= 255 &&
id.source_param2 == uint8_t(live_overview_owner_->request.minute) &&
id.day_counter == uint32_t(g_.date) &&
(live_overview_owner_->request.group_index == 0 ||
(live_overview_owner_->phase_result && phase_result_request_ &&
live_overview_owner_->request.group_index == int(phase_result_request_->group_index)));
}
std::optional<ui::PreparationState> CareerSession::close_league_family(
const ui::LeagueFamilyRequest& request,uint64_t& revision,std::string& error) {
error.clear();const auto& id=request.identity;
if(league_family_teaminfo_active_||request.kind!=ui::LeagueFamilyRequestKind::close||request.target_child!=0||
request.from_child<1||request.from_child>3||revision==UINT64_MAX||id.revision!=revision||
id.manager<0||id.manager>3||!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=id.manager||
size_t(id.manager)>=g_.manager_teams.size()||id.runtime_club!=g_.manager_teams[size_t(id.manager)]||
id.day_counter!=g_.date||id.runtime_club<0||size_t(id.runtime_club)>=g_.club_ids.size()||
id.club_identity!=int(g_.club_ids[size_t(id.runtime_club)])||
(id.source_param2!=0&&!live_source_identity(id))||
!league_family_owner_||league_family_owner_->friendly_opponent||league_family_owner_->child!=request.from_child||
league_family_owner_->identity!=id||
strengths_dispatch_active_||league_pairings_dispatch_active_||
(request.from_child==1&&(strengths_owner_||league_pairings_draft_))||
(request.from_child==2&&(!league_pairings_draft_||strengths_owner_||
save_stream(g_)!=league_pairings_draft_->original_stream||
rand_.seed()!=league_pairings_draft_->original_rand_seed||game_.seed()!=league_pairings_draft_->original_game_seed||
rand_.calls()!=league_pairings_draft_->original_rand_calls||game_.calls()!=league_pairings_draft_->original_game_calls||
club_modal_runtime_!=league_pairings_draft_->original_runtime))||
(request.from_child==3&&(!strengths_owner_||league_pairings_draft_||
strengths_owner_->page.identity!=id||save_stream(g_)!=strengths_owner_->native||
rand_.seed()!=strengths_owner_->rand_seed||game_.seed()!=strengths_owner_->game_seed||
rand_.calls()!=strengths_owner_->rand_calls||game_.calls()!=strengths_owner_->game_calls||
club_modal_runtime_!=strengths_owner_->runtime))||
(request.from_child==1&&(save_stream(g_)!=league_family_owner_->native||
rand_.seed()!=league_family_owner_->rand_seed||game_.seed()!=league_family_owner_->game_seed||
rand_.calls()!=league_family_owner_->rand_calls||game_.calls()!=league_family_owner_->game_calls||
club_modal_runtime_!=league_family_owner_->runtime||!league_family_owner_->table||
league_family_owner_->table->phase!=TableDispatchPhase::ready))) {
error="league family: stale or unavailable final close";return {};
}
try {
GameState next_state=g_;GameRandom next_game=game_;WatcomRandom next_rand=rand_;
auto next_runtime=club_modal_runtime_;
auto next_pairings=league_pairings_draft_;
if(request.from_child==2) {
next_state=std::move(next_pairings->state);next_game=next_pairings->game;
next_rand=next_pairings->rand;next_runtime=std::move(next_pairings->runtime);
const uint32_t pairings_word=::bmh::layout::CareerSession_CloseLeagueFamily_ExecutableField+uint32_t(id.manager);
if(!next_state.memory.has(pairings_word))throw FormatError("league family: missing Pairings return word");
next_state.memory.set8(pairings_word,uint8_t((next_state.memory.u8(pairings_word)&0xf0)|1));
}
// Phase viewers return to the pending engine ACK, which owns this draw.
// Keyboard/desk family callers still leave through their existing draw.
if(!live_overview_owner_ || !live_overview_owner_->phase_result)
stir_random(next_game,next_rand);
auto preparation=preparation_projection(next_state,revision+1);
ui::validate_preparation_context(preparation);
ui::DesktopScreen validate(data_directory_,preparation.desktop);
g_=std::move(next_state);game_=next_game;rand_=next_rand;
club_modal_runtime_=std::move(next_runtime);
if(request.from_child==2)league_pairings_draft_.reset();
if(request.from_child==3)strengths_owner_.reset();
league_family_owner_.reset();
++revision;return preparation;
} catch(const std::exception& e) {error=e.what();return {};}
}
bool CareerSession::suspend_strengths_for_family(const ui::LeagueFamilyRequest& request,
uint64_t revision,std::string& error) {
error.clear();const auto& id=request.identity;
if(league_family_teaminfo_active_||request.kind!=ui::LeagueFamilyRequestKind::navigate||request.from_child!=3||
(request.target_child!=1&&request.target_child!=2)||!strengths_owner_||strengths_dispatch_active_||
id.revision!=revision||strengths_owner_->page.identity!=id||save_stream(g_)!=strengths_owner_->native||
rand_.seed()!=strengths_owner_->rand_seed||rand_.calls()!=strengths_owner_->rand_calls||
game_.seed()!=strengths_owner_->game_seed||game_.calls()!=strengths_owner_->game_calls||
!league_family_owner_||league_family_owner_->child!=3||league_family_owner_->identity!=id) {
error="league family: stale Strengths child transition";return false;
}
// A nonzero Reset2 selector returns to LeagueScreenShown without a child close.
strengths_owner_.reset();return true;
}
bool CareerSession::suspend_pairings_for_family(const ui::LeagueFamilyRequest& request,
uint64_t revision,std::string& error) {
error.clear();const auto& id=request.identity;
if(league_family_teaminfo_active_||request.kind!=ui::LeagueFamilyRequestKind::navigate||request.from_child!=2||
(request.target_child!=1&&request.target_child!=3)||!league_pairings_draft_||
league_pairings_dispatch_active_||strengths_owner_||id.revision!=revision||
id.manager!=league_pairings_draft_->owner.manager||
id.runtime_club!=league_pairings_draft_->owner.runtime_club||
id.club_identity!=league_pairings_draft_->owner.club_identity||
(id.source_param2!=0&&!live_source_identity(id))||
save_stream(g_)!=league_pairings_draft_->original_stream||
rand_.seed()!=league_pairings_draft_->original_rand_seed||game_.seed()!=league_pairings_draft_->original_game_seed||
rand_.calls()!=league_pairings_draft_->original_rand_calls||game_.calls()!=league_pairings_draft_->original_game_calls||
club_modal_runtime_!=league_pairings_draft_->original_runtime||!league_family_owner_||
league_family_owner_->child!=2||league_family_owner_->identity!=id) {
error="league family: stale Pairings child transition";return false;
}
// A nonzero Move selector returns to LeagueScreenShown. Commit only its staged
// page/redraw changes; never invoke edit_league_pairings_source(close).
GameState next_state=std::move(league_pairings_draft_->state);
const uint32_t pairings_word=::bmh::layout::CareerSession_CloseLeagueFamily_ExecutableField+uint32_t(id.manager);
if(!next_state.memory.has(pairings_word)) {error="league family: missing Pairings return word";return false;}
next_state.memory.set8(pairings_word,uint8_t((next_state.memory.u8(pairings_word)&0xf0)|1));
g_=std::move(next_state);game_=league_pairings_draft_->game;
rand_=league_pairings_draft_->rand;club_modal_runtime_=std::move(league_pairings_draft_->runtime);
league_pairings_draft_.reset();return true;
}
bool CareerSession::prepare_league_family_child(const ui::StrengthsIdentity& id,uint8_t child,
uint64_t revision,std::string& error) {
error.clear();
if(league_family_teaminfo_active_||(league_family_owner_&&league_family_owner_->friendly_opponent)||child<1||child>3||revision==UINT64_MAX||id.revision!=revision||
(id.source_param2!=0&&!live_source_identity(id))||
id.manager<0||id.manager>3||id.league<0||id.league>8||!g_.memory.has(::bmh::layout::ActiveManager)||
g_.memory.u8(::bmh::layout::ActiveManager)!=id.manager||size_t(id.manager)>=g_.manager_teams.size()||
g_.manager_teams[size_t(id.manager)]!=id.runtime_club||g_.date!=id.day_counter||
id.runtime_club<0||size_t(id.runtime_club)>=g_.club_ids.size()||
int(g_.club_ids[size_t(id.runtime_club)])!=id.club_identity||strengths_dispatch_active_||
league_pairings_dispatch_active_||strengths_owner_||league_pairings_draft_) {
error="league family: stale child entry";return false;
}
if((id.family_id==0&&league_family_owner_)||
(id.family_id!=0&&(!league_family_owner_||league_family_owner_->identity.family_id!=id.family_id||
league_family_owner_->identity.manager!=id.manager||league_family_owner_->identity.runtime_club!=id.runtime_club||
league_family_owner_->identity.club_identity!=id.club_identity||league_family_owner_->identity.day_counter!=id.day_counter||
league_family_owner_->identity.source_param2!=id.source_param2||
league_family_owner_->identity.family_sequence==UINT64_MAX||
league_family_owner_->identity.family_sequence+1!=id.family_sequence))) {
error="league family: missing owner binding for child entry";return false;
}
const size_t record=size_t(id.manager)*0xb0c;
if(record+0x212>g_.manager_records.size()||id.manager_default_league!=int(g_.manager_records[record+0x210])) {
error="league family: stale manager default league";return false;
}
const uint32_t word=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
if(!g_.memory.has(word+1)) {error="league family: missing manager mode word";return false;}
g_.memory.set16(word,ui::strengths_family_word_source(g_.memory.u16(word),exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(id.league))));
club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2]=uint8_t(id.league);
club_modal_runtime_[::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField]=id.league_group;
club_modal_runtime_[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(id.league));
// Uint8T2's selector is child-specific: Table/Pairings use 0, Strengths 1.
// This is presentation context only; it must not be inferred from the prior page.
club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField]=uint8_t(child==3);club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2]=0;
return true;
}
void CareerSession::set_phase_results(decltype(TurnDriver::phase_results) hook) {
if (!hook) { turn_driver_.phase_results = {}; return; }
turn_driver_.phase_results = [this, hook=std::move(hook)](const PhaseResultRequest& request,
const std::vector<MatchGroup>& groups, const GameState& state) {
if (phase_result_request_ || &groups != &turn_driver_.groups || &state != &g_ ||
request.group_index >= groups.size())
throw FormatError("phase results: invalid synchronous Source boundary");
phase_result_request_ = &request;
struct Reset { const PhaseResultRequest*& request; ~Reset() { request = nullptr; } } reset{phase_result_request_};
hook(request, groups, state);
if (live_overview_owner_ && live_overview_owner_->phase_result)
throw FormatError("phase results: viewer must close before the engine ACK");
};
}
std::optional<CareerSession::LiveOverviewProjection> CareerSession::open_phase_results(
uint64_t& revision, const Image& underlay, std::string& error) {
error.clear();
if (!phase_result_request_ || !calendar_advance_active_ || live_overview_owner_ ||
phase_result_request_->group_index >= turn_driver_.groups.size()) {
error = "phase results: no current Source request or viewer already active"; return {};
}
try {
// Native result arrays and process descriptors share pointers in the
// Original. The Port owns separate vectors; publish their actual scores
// at this viewer boundary, without simulation or random draws. This also
// makes Source search/filter/forecast/TeamInfo read the current results.
GameState entered = g_;
for (const auto& group : turn_driver_.groups) {
const uint32_t id = le32(group.desc, 0xcc);
if (id < 0x15) {
const size_t at = size_t(id)*0x17c + size_t(entered.league_rounds.at(id))*10;
for (size_t m = 0; m < group.results.size(); ++m)
entered.results.at(at+m) = group.results[m];
} else store_cup_results(entered, group);
}
const int manager = entered.memory.u8(::bmh::layout::ActiveManager);
if (manager < 0 || size_t(manager) >= entered.manager_teams.size())
throw FormatError("phase results: unavailable active Source manager");
LiveOverviewRequest request;
request.key_slot = 1; request.minute = phase_result_request_->phase_end_minute;
request.group_index = int(phase_result_request_->group_index);
request.manager_slot = manager; request.runtime_team = entered.manager_teams[size_t(manager)];
request.revision = revision; request.sequence = next_live_overview_scope_;
const auto checkpoint = g_;
g_ = std::move(entered);
MatchEngine context{g_, turn_driver_.groups, game_, rand_, turn_driver_.referees};
auto page = open_running_overview(request, context, revision, underlay, error, true);
if (!page) g_ = checkpoint;
return page;
} catch (const std::exception& e) { error = e.what(); return {}; }
}
std::optional<CareerSession::LiveOverviewDispatch> CareerSession::dispatch_phase_results(
const LiveOverviewAction& action, uint64_t& revision, std::string& error,
const TransferOfferTeamInfoPresenter& team_info) {
if (!phase_result_request_ || !live_overview_owner_ || !live_overview_owner_->phase_result ||
live_overview_owner_->request.group_index != int(phase_result_request_->group_index)) {
error = "phase results: stale or unavailable Source viewer"; return {};
}
MatchEngine context{g_, turn_driver_.groups, game_, rand_, turn_driver_.referees};
return dispatch_live_overview(action, context, revision, error, team_info);
}
std::optional<CareerSession::LiveOverviewProjection> CareerSession::open_live_overview(
const LiveOverviewRequest& request, MatchEngine& engine, uint64_t& revision,
const Image& underlay, std::string& error) {
return open_running_overview(request, engine, revision, underlay, error, false);
}
std::optional<CareerSession::LiveOverviewProjection> CareerSession::open_running_overview(
const LiveOverviewRequest& request, MatchEngine& engine, uint64_t& revision,
const Image& underlay, std::string& error, bool phase_result) {
error.clear();
if (!calendar_advance_active_ || live_overview_owner_ || request.key_slot < 0 || request.key_slot > 1 ||
request.minute < 0 || request.minute > 255 || request.group_index < 0 ||
size_t(request.group_index) >= engine.groups.size() ||
(phase_result ? (!phase_result_request_ || request.group_index != int(phase_result_request_->group_index) ||
request.minute != phase_result_request_->phase_end_minute || request.key_slot != 1)
: request.group_index != 0) || engine.groups.empty() ||
engine.groups.size() != turn_driver_.groups.size() || turn_driver_.groups.empty() ||
request.manager_slot < 0 || request.manager_slot >= int(g_.manager_teams.size()) ||
request.revision != revision || revision == UINT64_MAX ||
next_live_overview_scope_ == UINT64_MAX || &engine.state != &g_ || &engine.game != &game_ ||
&engine.rand != &rand_ || !g_.memory.has(::bmh::layout::ActiveManager) ||
g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot || request.runtime_team < 0 ||
size_t(request.runtime_team) >= g_.team_flags.size() ||
g_.manager_teams[size_t(request.manager_slot)] != request.runtime_team ||
g_.manager_of(request.runtime_team) != request.manager_slot ||
engine.groups.front().desc != turn_driver_.groups.front().desc ||
engine.groups.front().fixtures != turn_driver_.groups.front().fixtures ||
strengths_owner_ || strengths_dispatch_active_ || league_family_owner_ || league_pairings_draft_ ||
league_pairings_dispatch_active_ || other_games_owner_ || other_games_dispatch_active_ ||
live_intervention_ || balance_draft_ || balance_dispatch_active_ || top_scorers_owner_ ||
top_scorers_dispatch_active_ || pending_offer_dispatch_active_ || market_dispatch_active_ ||
transfer_offer_editor_ || manager_join_ || contract_quote_ ||
stadium_.investment || stadium_.tip || stadium_.periphery_quote || stadium_.block_expansion) {
error = "live overview: stale, nested or unauthenticated Source key request";
return {};
}
const MatchGroup& active = engine.groups[size_t(request.group_index)];
if (active.desc.size() < 0xd0 || active.matches() <= 0 ||
(!phase_result && active.void_mask() == ((uint32_t(1) << active.matches()) - 1))) {
error = "live overview: missing active Source match descriptor";
return {};
}
struct LiveBoundaryFamilyScope {
bool& active;
bool previous;
explicit LiveBoundaryFamilyScope(bool& value) : active(value), previous(value) { active = false; }
~LiveBoundaryFamilyScope() { active = previous; }
} family_scope(calendar_advance_active_);
const uint64_t next_revision = revision + 1;
const auto family_checkpoint = league_family_checkpoint();
const auto pairings_checkpoint = league_pairings_checkpoint();
const auto other_checkpoint = other_games_checkpoint();
const auto scope_checkpoint = next_live_overview_scope_;
try {
LiveOverviewProjection result;
source_runtime_set_byte(g_,club_modal_runtime_,::bmh::layout::CareerSession_LiveBoundaryFamilyScope_ExecutableField,0);
result.owner = request;
result.owner.revision = next_revision;
result.owner.sequence = next_live_overview_scope_;
const uint32_t competition = le32(active.desc, 0xcc);
LiveOverviewOwner live;
live.phase_result = phase_result;
live.request = result.owner;
live.source_competition = int(competition);
live.original_native = save_stream(g_);
live.original_rand_seed = rand_.seed(); live.original_game_seed = game_.seed();
live.original_rand_calls = rand_.calls(); live.original_game_calls = game_.calls();
for (const auto& group : engine.groups) live.active_groups.emplace_back(group.desc, group.fixtures);
live.referees = engine.referees;
live_overview_owner_ = live;
if (active.desc[0] == 0) {
if (competition > 8)
throw FormatError("live overview: active Source descriptor is not a league");
result.kind = request.key_slot == 0 ? LiveOverviewKind::league_table : LiveOverviewKind::league_pairings;
auto strengths = strengths_open_request(next_revision);
if (!strengths) throw FormatError("live overview: active manager has no Source league identity");
strengths->identity.league = int(competition);
strengths->identity.league_group = uint8_t(competition >= 5);
strengths->identity.sequence = next_live_overview_scope_;
strengths->identity.source_param2 = uint8_t(request.minute);
if (request.key_slot == 0) {
auto family = begin_league_family(strengths->identity, 1, next_revision, error);
if (!family) throw FormatError(error.empty() ? "live overview: Source Table family entry rejected" : error);
result.family_identity = *family;
live.family_identity = *family;
auto table = current_league_table_dispatch(error);
if (!table) throw FormatError(error.empty() ? "live overview: Source Table projection unavailable" : error);
result.table = table->page;
} else {
LeaguePairingsDraft draft{g_,game_,rand_,club_modal_runtime_,club_modal_runtime_,{}, {},
save_stream(g_),rand_.seed(),game_.seed(),rand_.calls(),game_.calls()};
for (const auto& group : engine.groups) draft.original_active_groups.emplace_back(group.desc,group.fixtures);
draft.original_referee_profiles = engine.referees;
draft.owner = open_league_pairings_source(draft.state,request.manager_slot,ui::league_pairings_constants(exe_));
if (draft.owner.league != int(competition)) {
draft.owner.league=int(competition);
draft.owner.round=std::min<int>(draft.state.league_rounds.at(size_t(competition)),
league_matchdays(int(competition))-1);
draft.owner.title_round=draft.state.league_rounds.at(size_t(competition));
if(draft.owner.round>=league_matchdays(int(competition)))
throw FormatError("live overview: Source Pairings round is outside its league schedule");
}
draft.active_packet = validate_normal_pairings_group(draft.state,draft.owner,draft.runtime);
const uint64_t child_scope = ++league_pairings_scope_;
auto page = ui::league_pairings_from_game(draft.state,draft.owner,exe_,next_revision,child_scope,next_live_overview_scope_,draft.active_packet);
draft.identity = page.identity;
draft.runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField] = exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField + uint32_t(draft.owner.league));
pairings_runtime_draw(draft.state,draft.runtime,page,exe_);
league_pairings_draft_ = std::move(draft);
auto family = begin_league_family(strengths->identity,2,next_revision,error);
if (!family) throw FormatError(error.empty() ? "live overview: Source Pairings family entry rejected" : error);
result.family_identity = *family;
live.family_identity = *family;
result.pairings = std::move(page);
}
} else {
if (request.key_slot != 0 && request.key_slot != 1)
throw FormatError("live overview: invalid cup overview key slot");
const int entry_index = cup_entry_index(competition);
// CupGroupOverviewEffects owns this unsaved traversal cursor even in a freshly
// loaded career. Its absence in an FBM is not an invalid cup entry.
if (phase_result && !g_.memory.has(::bmh::layout::CareerSession_FormatError_RuntimeField8)) g_.memory.add_block(::bmh::layout::CareerSession_FormatError_RuntimeField8, 1);
if (entry_index < 0 || entry_index >= kCupEntries || !g_.memory.has(cup_entry_address(entry_index)+0x1e) ||
!g_.memory.has(::bmh::layout::CareerSession_FormatError_RuntimeField8) || !g_.memory.has(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(request.manager_slot)))
throw FormatError("live overview: active cup descriptor is outside the Source linked table");
// CupGroupOverviewEffects receives the cup-entry ID at entry+18. Match descriptor
// +6 is part of its end-minute pointer, not a competition selector.
const int selector = int16_t(g_.memory.u16(competition + 0x18));
const uint8_t old_view = g_.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(request.manager_slot));
if (!phase_result) {
g_.memory.set8(::bmh::layout::CareerSession_FormatError_RuntimeField3,uint8_t(7-(uint16_t(g_.season)%4)));
g_.memory.set8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(request.manager_slot),uint8_t(old_view|0x80));
}
// CupGroupOverviewEffects resolves this exact active descriptor through FindCup(selector, ordinal).
const int competition_id = int16_t(g_.memory.u16(cup_entry_address(entry_index)+0x18));
int stable_team = request.runtime_team;
if (stable_team > 0x164) {
const size_t backup = 4 * 0xb0c + 0x290;
if (request.manager_slot != 0 || backup + 2 > g_.manager_records.size())
throw FormatError("live overview: unsupported national cup owner");
stable_team = int(uint16_t(g_.manager_records[backup] | uint16_t(g_.manager_records[backup+1])<<8));
}
if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= g_.club_ids.size())
throw FormatError("live overview: missing stable cup owner identity");
ui::OtherGamesIdentity identity;
identity.manager_slot=request.manager_slot; identity.runtime_team=request.runtime_team;
identity.club_identity=int(g_.club_ids[size_t(stable_team)]); identity.day_counter=uint32_t(g_.date);
identity.revision=next_revision; identity.scope=next_live_overview_scope_; identity.sequence=next_live_overview_scope_;
identity.expected_view_byte=g_.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(request.manager_slot));
std::optional<ui::OtherGamesState> page;
int linked_page=-1;
for(int ordinal=0;ordinal<kCupEntries;++ordinal) {
try {
auto candidate=ui::other_games_state_from_game(g_,identity,texts_,exe_,selector,ordinal,-1,
OtherGamesDisplayMode::detail,int(g_.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(request.manager_slot))&0x7f),
false,underlay,club_modal_runtime_);
if(candidate.projection.entry_index==entry_index&&
candidate.projection.descriptor_competition==competition_id) {
linked_page=ordinal;page=std::move(candidate);break;
}
} catch(const std::exception&) {}
}
if (!page || linked_page<0)
throw FormatError("live overview: Source cup pointer resolved a different active descriptor");
g_.memory.set8(::bmh::layout::CareerSession_FormatError_RuntimeField8,uint8_t(linked_page));
page->source_participant_offset=int(g_.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(request.manager_slot))&0x7f);
OtherGamesOwner owner;
owner.page=*page; owner.round=page->projection.round; owner.participant_offset=page->source_participant_offset;
owner.display_mode=page->projection.display_mode; owner.native=save_stream(g_); owner.runtime=club_modal_runtime_;
owner.rand_seed=rand_.seed(); owner.game_seed=game_.seed(); owner.rand_calls=rand_.calls(); owner.game_calls=game_.calls();
owner.desk_owner.kind=ui::DeskRequestKind::open_menu; owner.desk_owner.menu_kind=5;
owner.desk_owner.manager_slot=request.manager_slot; owner.desk_owner.revision=next_revision;
other_games_owner_=std::move(owner);
other_games_selection_={selector,linked_page};
result.kind=LiveOverviewKind::cup_other_games; result.cup=std::move(*page);
}
live.kind=result.kind;
live.original_native=save_stream(g_); live.original_rand_seed=rand_.seed(); live.original_game_seed=game_.seed();
live.original_rand_calls=rand_.calls(); live.original_game_calls=game_.calls();
live_overview_owner_->kind=live.kind;
live_overview_owner_->family_identity=live.family_identity;
live_overview_owner_->request.revision=next_revision;
++next_live_overview_scope_;
revision=next_revision;
return result;
} catch(const std::exception& e) {
restore_league_family_checkpoint(family_checkpoint);
restore_league_pairings_checkpoint(pairings_checkpoint);
restore_other_games_checkpoint(other_checkpoint);
live_overview_owner_.reset();
next_live_overview_scope_=scope_checkpoint;
error=e.what();
return {};
}
}
std::optional<CareerSession::LeagueTableDispatch> CareerSession::current_league_table_dispatch(
std::string& error) const {
error.clear();
if(!league_family_owner_||league_family_owner_->child!=1||!league_family_owner_->table||
!source_table_identity_is_live(g_,league_family_owner_->identity)||
strengths_owner_||league_pairings_draft_) {
error="league table: no active Source family table owner";return {};
}
try {
const auto& owner=*league_family_owner_;const auto& table=*owner.table;
const uint32_t settings_at=::bmh::layout::ManagerSettings+uint32_t(owner.identity.manager)*2;
const uint32_t family_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(owner.identity.manager)*2;
if(save_stream(g_)!=owner.native||rand_.seed()!=owner.rand_seed||rand_.calls()!=owner.rand_calls||
game_.seed()!=owner.game_seed||game_.calls()!=owner.game_calls||club_modal_runtime_!=owner.runtime||
!g_.memory.has(settings_at+1)||!g_.memory.has(family_at+1)||
g_.memory.u16(settings_at)!=owner.identity.expected_settings_word||
g_.memory.u16(family_at)!=owner.identity.expected_family_word) {
error="league table: owned Source state changed before projection";return {};
}
const uint16_t word=table.display_word_override;
LeagueTableDispatch result;
result.identity=owner.identity;result.phase=table.phase;
if(table.phase==TableDispatchPhase::range_start||table.phase==TableDispatchPhase::range_end) {
const int league=owner.identity.league,maximum=bmh::league_matchdays(league);
ui::TableRangeDialogProfile profile;
profile.title_textd_address=table.phase==TableDispatchPhase::range_start?::bmh::layout::CareerSession_CurrentLeagueTableDispatch_ExecutableField: ::bmh::layout::CareerSession_CurrentLeagueTableDispatch_ExecutableField2;
profile.minimum=table.phase==TableDispatchPhase::range_start?1:uint32_t(source_byte(table.pending_start_round)+1);
profile.maximum=uint32_t(maximum);
profile.default_value=table.phase==TableDispatchPhase::range_start?1:
std::max<uint32_t>(1,std::min<uint32_t>(uint32_t(g_.league_rounds.at(size_t(league))),profile.maximum));
const bool gradient=source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::TextGradientDisabled)==0&&
table.runtime_font_id==3;
profile.text_mode=gradient?ui::TableRangeTextMode::source_gradient:ui::TableRangeTextMode::flat;
profile.x=table.dialog_x;profile.y=table.dialog_y;result.dialog=profile;
}
result.page=table.forecast_page?*table.forecast_page:table.page;
if(result.page.manager_slot!=owner.identity.manager||result.page.league_id!=owner.identity.league||
result.page.rows.empty())
throw FormatError("league table: owned active page is missing or mismatched");
return result;
} catch(const std::exception& e) {error=e.what();return {};}
}
std::optional<CareerSession::LeagueTableDispatch> CareerSession::dispatch_league_table_control(
const ui::LeagueFamilyRequest& request,uint64_t& revision,std::string& error) {
error.clear();const auto& id=request.identity;
if(league_family_teaminfo_active_||request.kind!=ui::LeagueFamilyRequestKind::control||
request.from_child!=1||!canonical_table_envelope(request,request.control_index)||
id.revision!=revision||request.control_index<0||request.control_index>9||
!source_table_identity_is_live(g_,id)||
!league_family_owner_||league_family_owner_->child!=1||league_family_owner_->identity!=id||
!league_family_owner_->table||league_family_owner_->table->phase!=TableDispatchPhase::ready||
strengths_owner_||league_pairings_draft_||
(id.source_param2!=0&&!live_source_identity(id))||id.family_sequence==UINT64_MAX||revision==UINT64_MAX||
save_stream(g_)!=league_family_owner_->native||rand_.seed()!=league_family_owner_->rand_seed||
rand_.calls()!=league_family_owner_->rand_calls||game_.seed()!=league_family_owner_->game_seed||
game_.calls()!=league_family_owner_->game_calls||club_modal_runtime_!=league_family_owner_->runtime||
strengths_owner_||league_pairings_draft_) {
error="league table: stale or unavailable control request";return {};
}
const auto checkpoint=league_family_checkpoint();
const uint64_t old_revision=revision;
try {
auto& family=*league_family_owner_;auto& table=*family.table;
const uint32_t word_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
if(!g_.memory.has(word_at+1))throw FormatError("league table: manager display word is unavailable");
uint16_t word=g_.memory.u16(word_at);
const int league=id.league,matchdays=bmh::league_matchdays(league);
const auto update_page=[&](std::optional<bmh::LeagueTable> engine={},bool forecast=false) {
table.display_word_override=word;
const auto context=source_table_context(table,word,std::move(engine),forecast);
table.page=ui::league_table_from_game(g_,id.manager,league,context);
};
switch(request.control_index) {
case 0: table.aggregation_flags=7;word=uint16_t((word&0x0ff0)|1);break;
case 1: table.aggregation_flags=1;word=uint16_t((word&0x0ff0)|2);break;
case 2: table.aggregation_flags=2;word=uint16_t((word&0x0ff0)|4);break;
case 3: {
if((word&8)==0) {
const int sort_extra=0x0e - int((word>>3)&0x0e);
std::array<uint8_t,10> gap{};
for(size_t i=0;i<gap.size();++i)gap[i]=exe_.u8(::bmh::layout::CareerSession_DispatchLeagueTableControl_RuntimeField+uint32_t(i));
const auto forecast=bmh::compute_league_table_forecast(g_,league,0,matchdays,
table.aggregation_flags,table.normal_mode,sort_extra,gap,game_);
table.forecast_game_after=forecast.game_after;
word=uint16_t((word|8)&0x0f7f);
table.display_word_override=uint16_t((word&0x0cf7)+0x0108);
table.forecast_present_pending=true;
table.phase=TableDispatchPhase::forecast_pending_present;
const auto context=source_table_context(table,table.display_word_override,forecast.table,true);
table.forecast_page=ui::league_table_from_game(g_,id.manager,league,context);
}
break;
}
case 4: case 5: case 6: {
const uint16_t bit=uint16_t(0x10u<<(request.control_index-4));word^=bit;
if((word&0x70)==0)word=uint16_t(word|0x70);
break;
}
case 7:
table.normal_mode^=1;
if(club_modal_runtime_.count(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField))club_modal_runtime_[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=uint8_t(table.normal_mode);
else if(g_.memory.has(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField))g_.memory.set8(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField,uint8_t(table.normal_mode));
break;
case 8:
table.first_round=0;table.end_round=matchdays;
word=uint16_t((word&0x0cff)|0x0100);break;
case 9: {
table.previous_start_round=table.first_round;table.previous_end_round=table.end_round;
table.pending_start_round=table.first_round;
table.runtime_font_id=exe_.u8(::bmh::layout::Advertising_Button_RuntimeField + 1);
if(g_.memory.has(::bmh::layout::CareerSession_DispatchLeagueTableControl_RuntimeField2))g_.memory.set8(::bmh::layout::CareerSession_DispatchLeagueTableControl_RuntimeField2,table.runtime_font_id);
else club_modal_runtime_[::bmh::layout::CareerSession_DispatchLeagueTableControl_RuntimeField2]=table.runtime_font_id;
table.phase=TableDispatchPhase::range_start;
break;
}
default: throw FormatError("league table: unsupported control");
}
if(request.control_index!=3&&request.control_index!=9) {
table.forecast_page.reset();table.forecast_game_after.reset();table.forecast_present_pending=false;
word=uint16_t(word&0x0f7f);
g_.memory.set16(word_at,word);
update_page();
}
if(request.control_index==3&&table.phase!=TableDispatchPhase::forecast_pending_present) {
word=uint16_t(word&0x0f7f);
g_.memory.set16(word_at,word);update_page();
}
auto next=id;next.revision=revision+1;next.family_sequence=id.family_sequence+1;
next.expected_settings_word=g_.memory.u16(::bmh::layout::ManagerSettings+uint32_t(id.manager)*2);
next.expected_family_word=g_.memory.u16(word_at);
family.identity=next;family.native=save_stream(g_);family.rand_seed=rand_.seed();
family.game_seed=game_.seed();family.rand_calls=rand_.calls();family.game_calls=game_.calls();
family.runtime=club_modal_runtime_;revision++;
auto result=current_league_table_dispatch(error);
if(!result)throw FormatError(error.empty()?"league table: dispatch projection failed":error);
return result;
} catch(const std::exception& e) {
restore_league_family_checkpoint(checkpoint);revision=old_revision;error=e.what();return {};
}
}
std::optional<CareerSession::LeagueTableDispatch> CareerSession::dispatch_league_table_range_reply(
const ui::LeagueFamilyRequest& request,uint64_t& revision,std::string& error) {
error.clear();const auto& id=request.identity;
if(league_family_teaminfo_active_||request.kind!=ui::LeagueFamilyRequestKind::table_range_result||
request.from_child!=1||request.target_child!=0||request.control_index!=9||
request.runtime_team!=-1||request.expected_club_identity!=-1||request.table_row_index!=-1||
request.league_id!=-1||id.revision!=revision||id.family_sequence==UINT64_MAX||revision==UINT64_MAX||
!source_table_identity_is_live(g_,id)||
!request.table_dialog_reply||!league_family_owner_||league_family_owner_->child!=1||
league_family_owner_->identity!=id||!league_family_owner_->table||
(league_family_owner_->table->phase!=TableDispatchPhase::range_start&&
league_family_owner_->table->phase!=TableDispatchPhase::range_end)||
save_stream(g_)!=league_family_owner_->native||rand_.seed()!=league_family_owner_->rand_seed||
rand_.calls()!=league_family_owner_->rand_calls||game_.seed()!=league_family_owner_->game_seed||
game_.calls()!=league_family_owner_->game_calls||club_modal_runtime_!=league_family_owner_->runtime) {
error="league table: stale or unavailable range reply";return {};
}
const auto checkpoint=league_family_checkpoint();
const uint64_t old_revision=revision;
try {
auto& family=*league_family_owner_;auto& table=*family.table;
const auto& reply=*request.table_dialog_reply;
const auto phase=table.phase;
const auto expected=phase==TableDispatchPhase::range_start?ui::TableDialogStage::start:ui::TableDialogStage::end;
if((reply.outcome!=ui::TableDialogOutcome::accept&&reply.outcome!=ui::TableDialogOutcome::cancel)||
reply.stage!=expected||reply.x<0||reply.x>207||reply.y<0||reply.y>104)
throw FormatError("league table: wrong dialog stage or Source position");
const int maximum=bmh::league_matchdays(id.league);
if(reply.outcome==ui::TableDialogOutcome::accept) {
const int minimum=phase==TableDispatchPhase::range_start?1:int(source_byte(table.pending_start_round))+1;
if(reply.value<minimum||reply.value>maximum)
throw FormatError("league table: accepted range value is outside Source bounds");
}
table.dialog_x=reply.x;table.dialog_y=reply.y;
uint16_t word=g_.memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2);
if(phase==TableDispatchPhase::range_start) {
if(reply.outcome==ui::TableDialogOutcome::accept) {
table.pending_start_round=reply.value-1;table.phase=TableDispatchPhase::range_end;
} else table.phase=TableDispatchPhase::ready;
} else {
if(reply.outcome==ui::TableDialogOutcome::accept) {
table.first_round=table.pending_start_round;table.end_round=reply.value;
} else {
table.first_round=table.previous_start_round;table.end_round=table.previous_end_round;
}
word=uint16_t((word&0x0cff)|0x0200);
source_table_apply_entry_flags(table,word);
source_table_normalize_range(table,g_,id.league,texts_);
table.phase=TableDispatchPhase::ready;
}
if(table.phase==TableDispatchPhase::ready) {
word=uint16_t(word&0x0f7f);
g_.memory.set16(::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2,word);
table.display_word_override=word;table.forecast_page.reset();table.forecast_game_after.reset();
table.page=ui::league_table_from_game(g_,id.manager,id.league,source_table_context(table,word));
}
auto next=id;next.revision=revision+1;next.family_sequence=id.family_sequence+1;
next.expected_settings_word=g_.memory.u16(::bmh::layout::ManagerSettings+uint32_t(id.manager)*2);
next.expected_family_word=g_.memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2);
family.identity=next;family.native=save_stream(g_);family.rand_seed=rand_.seed();
family.game_seed=game_.seed();family.rand_calls=rand_.calls();family.game_calls=game_.calls();
family.runtime=club_modal_runtime_;revision++;
auto result=current_league_table_dispatch(error);
if(!result)throw FormatError(error.empty()?"league table: range projection failed":error);
return result;
} catch(const std::exception& e) {restore_league_family_checkpoint(checkpoint);revision=old_revision;error=e.what();return {};}
}
std::optional<CareerSession::LeagueTableDispatch> CareerSession::acknowledge_league_forecast_present(
const ui::LeagueFamilyRequest& request,uint64_t& revision,std::string& error) {
error.clear();const auto& id=request.identity;
if(league_family_teaminfo_active_||request.kind!=ui::LeagueFamilyRequestKind::table_forecast_presented||
request.from_child!=1||request.target_child!=0||request.control_index!=3||
request.runtime_team!=-1||request.expected_club_identity!=-1||request.table_row_index!=-1||
request.league_id!=-1||request.table_dialog_reply||
id.revision!=revision||id.family_sequence==UINT64_MAX||revision==UINT64_MAX||
!source_table_identity_is_live(g_,id)||
!league_family_owner_||league_family_owner_->child!=1||league_family_owner_->identity!=id||
!league_family_owner_->table||league_family_owner_->table->phase!=TableDispatchPhase::forecast_pending_present||
!league_family_owner_->table->forecast_present_pending||!league_family_owner_->table->forecast_game_after||
save_stream(g_)!=league_family_owner_->native||rand_.seed()!=league_family_owner_->rand_seed||
rand_.calls()!=league_family_owner_->rand_calls||game_.seed()!=league_family_owner_->game_seed||
game_.calls()!=league_family_owner_->game_calls||club_modal_runtime_!=league_family_owner_->runtime) {
error="league table: stale or unavailable forecast-present acknowledgement";return {};
}
const auto checkpoint=league_family_checkpoint();
const uint64_t old_revision=revision;
try {
auto& family=*league_family_owner_;auto& table=*family.table;
game_=*table.forecast_game_after;
const uint32_t word_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
uint16_t word=uint16_t(table.display_word_override&0x0ff7);
g_.memory.set16(word_at,word);
table.display_word_override=word;table.forecast_present_pending=false;
table.forecast_game_after.reset();table.phase=TableDispatchPhase::ready;
const int sort_extra=0x0e - int((word>>3)&0x0e);
const auto normal=bmh::compute_league_table(g_,id.league,0,table.end_round,
table.aggregation_flags,table.normal_mode+sort_extra);
table.page=ui::league_table_from_game(g_,id.manager,id.league,
source_table_context(table,word,normal,false));
auto next=id;next.revision=revision+1;next.family_sequence=id.family_sequence+1;
next.expected_settings_word=g_.memory.u16(::bmh::layout::ManagerSettings+uint32_t(id.manager)*2);
next.expected_family_word=word;
family.identity=next;family.native=save_stream(g_);family.rand_seed=rand_.seed();
family.game_seed=game_.seed();family.rand_calls=rand_.calls();family.game_calls=game_.calls();
family.runtime=club_modal_runtime_;revision++;
auto result=current_league_table_dispatch(error);
if(!result)throw FormatError(error.empty()?"league table: forecast ACK projection failed":error);
return result;
} catch(const std::exception& e) {restore_league_family_checkpoint(checkpoint);revision=old_revision;error=e.what();return {};}
}
bool CareerSession::select_league_family_page(const ui::LeagueFamilyRequest& request,
uint64_t revision,std::string& error) {
error.clear();const auto& id=request.identity;
const bool map_select=request.kind==ui::LeagueFamilyRequestKind::select_league;
const bool toggle=request.kind==ui::LeagueFamilyRequestKind::toggle_league_group;
if(league_family_teaminfo_active_||(!map_select&&!toggle)||request.from_child!=1||
!canonical_table_envelope(request,-1,true)||id.revision!=revision||request.league_id<0||request.league_id>8||
!source_table_identity_is_live(g_,id)||strengths_owner_||league_pairings_draft_||
!league_family_owner_||league_family_owner_->child!=1||league_family_owner_->identity!=id||
!league_family_owner_->table||league_family_owner_->table->phase!=TableDispatchPhase::ready||
save_stream(g_)!=league_family_owner_->native||rand_.seed()!=league_family_owner_->rand_seed||
rand_.calls()!=league_family_owner_->rand_calls||game_.seed()!=league_family_owner_->game_seed||
game_.calls()!=league_family_owner_->game_calls||club_modal_runtime_!=league_family_owner_->runtime||
id.family_sequence==UINT64_MAX) {
error="league family: stale Table league selector";return false;
}
const uint8_t old_group=id.league_group;
const uint8_t next_group=toggle?uint8_t(old_group^1):old_group;
const size_t record=size_t(id.manager)*0xb0c;
const auto checkpoint=league_family_checkpoint();
try {
if(toggle) {
if(!g_.memory.has(::bmh::layout::CalendarState_FormatError_RuntimeField2)||g_.memory.u8(::bmh::layout::CalendarState_FormatError_RuntimeField2)!=0||
request.league_id!=(next_group?int(exe_.u8(::bmh::layout::CareerSession_FormatError_RuntimeField4)):int(g_.manager_records[record+0x210])))
throw FormatError("league family: group toggle target or Source availability is invalid");
} else {
bool listed=false;
for(int row=0;row<4;++row) {
const int count=exe_.u8(::bmh::layout::CalendarLeagueCounts+uint32_t(old_group*4+row));
const int first=old_group?int(exe_.u8(::bmh::layout::CareerSession_FormatError_RuntimeField4))+row:
int(exe_.u8(::bmh::layout::CalendarFirstLeague+uint32_t(row)));
if(first+count>int(bmh::kLeagueCount))
throw FormatError("league family: Source map row exceeds the league table");
for(int cell=0;cell<count;++cell)
if(first+cell==request.league_id)listed=true;
}
if(!listed)throw FormatError("league family: selected league is not in the bound Source map");
}
GameState next=g_;auto next_runtime=club_modal_runtime_;auto next_owner=*league_family_owner_;
const uint32_t word_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
if(!next.memory.has(word_at+1))throw FormatError("league family: missing manager mode word");
const bool league_changed=request.league_id!=id.league;
next_runtime[::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField]=next_group;
if(league_changed) {
next_runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2]=uint8_t(request.league_id);
next_runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(request.league_id));
}
uint16_t word=uint16_t(next.memory.u16(word_at)&0x0f7f);
if(next_runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]!=0)word=uint16_t(word|0x0080);
if(league_changed)word=uint16_t(word&0xff7f); // FriendlyMatchScreen outer redraw only.
next.memory.set16(word_at,word);
auto& identity=next_owner.identity;identity.league=request.league_id;
identity.league_group=next_group;
identity.expected_family_word=word;identity.family_sequence=id.family_sequence+1;
auto& table=*next_owner.table;
if(league_changed) {
table.normal_mode=next_runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]&1;
table.display_word_override=word;table.forecast_page.reset();table.forecast_game_after.reset();
table.forecast_present_pending=false;
table.page=ui::league_table_from_game(next,id.manager,request.league_id,
source_table_context(table,word));
}
// Same-league map/toggle stay inside FriendlyMatchScreen's event loop. Keep
// the current body, forecast, range locals and display override intact.
next_owner.native=save_stream(next);next_owner.runtime=next_runtime;
next_owner.rand_seed=rand_.seed();next_owner.rand_calls=rand_.calls();
next_owner.game_seed=game_.seed();next_owner.game_calls=game_.calls();
g_=std::move(next);club_modal_runtime_=std::move(next_runtime);
league_family_owner_=std::move(next_owner);
return true;
} catch(const std::exception& e) {
restore_league_family_checkpoint(checkpoint);error=e.what();return false;
}
}
std::optional<ui::StrengthsIdentity> CareerSession::dispatch_family_table_team_info(
const ui::LeagueFamilyRequest& request,uint64_t& revision,std::string& error,
const TransferOfferTeamInfoPresenter& presenter,
const std::optional<ClubPlayerDetailSelection>* poach_selection) {
error.clear();const auto& id=request.identity;
if((poach_selection&&!poach_table_selection_)||(league_family_owner_&&league_family_owner_->friendly_opponent)||league_family_teaminfo_active_||!presenter||request.kind!=ui::LeagueFamilyRequestKind::team_info||request.from_child!=1||
request.target_child!=0||request.control_index!=-1||request.league_id!=-1||request.table_dialog_reply||
id.revision!=revision||id.family_sequence==UINT64_MAX||!source_table_identity_is_live(g_,id)||
!league_family_owner_||league_family_owner_->child!=1||league_family_owner_->identity!=id||
!league_family_owner_->table||league_family_owner_->table->phase!=TableDispatchPhase::ready||
strengths_owner_||league_pairings_draft_||
save_stream(g_)!=league_family_owner_->native||rand_.seed()!=league_family_owner_->rand_seed||
game_.seed()!=league_family_owner_->game_seed||rand_.calls()!=league_family_owner_->rand_calls||
game_.calls()!=league_family_owner_->game_calls||club_modal_runtime_!=league_family_owner_->runtime||
revision==UINT64_MAX) {
error="league family: stale Table TeamInfo request";return {};
}
const auto checkpoint=league_family_checkpoint();
const uint64_t old_revision=revision;
try {
const auto& table_owner=*league_family_owner_->table;
const ui::LeagueTableState& visible=table_owner.forecast_page?*table_owner.forecast_page:table_owner.page;
if(request.table_row_index<0||size_t(request.table_row_index)>=visible.rows.size())
throw FormatError("league family: Table TeamInfo row index is outside the visible page");
const auto& visible_row=visible.rows[size_t(request.table_row_index)];
if(visible_row.runtime_team_id!=request.runtime_team||
visible_row.club_identity_key!=request.expected_club_identity||
request.runtime_team<0||size_t(request.runtime_team)>=g_.club_ids.size()||
int(g_.club_ids[size_t(request.runtime_team)])!=request.expected_club_identity)
throw FormatError("league family: Table TeamInfo visible row identity is stale");
if(size_t(request.table_row_index)>=table_owner.page.rows.size()||
table_owner.page.rows[size_t(request.table_row_index)].rank!=request.table_row_index+1)
throw FormatError("league family: normal working rank is unavailable for Table TeamInfo");
const auto& selected_row=table_owner.page.rows[size_t(request.table_row_index)];
const int selected_team=selected_row.runtime_team_id;
if(selected_team<0||size_t(selected_team)>=g_.club_ids.size()||
selected_row.club_identity_key!=int(g_.club_ids[size_t(selected_team)]))
throw FormatError("league family: normal working rank has a stale club identity");
const auto& before=checkpoint;
GameState next=g_;GameRandom next_game=game_;WatcomRandom next_rand=rand_;
auto next_runtime=club_modal_runtime_;
auto tables=ui::league_tables_from_game(g_,id.manager);
if(size_t(id.league)>=tables.size()||visible.manager_slot!=id.manager||visible.league_id!=id.league)
throw FormatError("league family: visible Table backdrop does not match the active owner");
tables[size_t(id.league)]=visible;
const Image backdrop=ui::LeagueTableScreen(data_directory_,tables,id.league,
ui::LeagueTableScreen::FamilyMode{id,uint8_t(poach_selection!=nullptr)}).render();
if(poach_selection) {
const uint32_t word_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
uint16_t word=uint16_t(next.memory.u16(word_at)&0x0f7f);
if(source_runtime_byte(next,next_runtime,exe_,::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField)!=0)word|=0x80;
next.memory.set16(word_at,word);
}
auto services=staged_club_modal_services(next,next_game,next_rand,next_runtime);
const auto enter=services.enter_club;int entry_calls=0;
services.enter_club=[enter,&entry_calls,selected=selected_team](int team) {
if(team!=selected)throw FormatError("league family: TeamInfo entered a different club");
++entry_calls;return enter(team);
};
league_family_teaminfo_active_=true;
struct Reset { bool& active;~Reset(){active=false;} } reset{league_family_teaminfo_active_};
const bool accepted=presenter(services,selected_team,backdrop);
const auto after=league_family_checkpoint();
const bool live_unchanged=same_strengths_runtime_state(before.state,after.state)&&
save_stream(before.state)==save_stream(after.state)&&before.runtime==after.runtime&&
before.game.seed()==after.game.seed()&&before.game.calls()==after.game.calls()&&
before.rand.seed()==after.rand.seed()&&before.rand.calls()==after.rand.calls()&&
before.family==after.family&&before.next_family_id==after.next_family_id&&
before.next_strengths_scope==after.next_strengths_scope&&
!before.strengths&&!after.strengths&&!before.pairings&&!after.pairings;
if(!live_unchanged||!accepted||(poach_selection?entry_calls<1:entry_calls!=1))
throw FormatError("league family: TeamInfo presenter changed owner or did not enter the selected club");
const size_t record=size_t(id.manager)*0xb0c;
if(next.date!=g_.date||next.manager_teams!=g_.manager_teams||
!next.memory.has(::bmh::layout::ActiveManager)||next.memory.u8(::bmh::layout::ActiveManager)!=id.manager||record+0x292>next.manager_records.size()||
(int(next.manager_records[record+0x290])|int(next.manager_records[record+0x291])<<8)!=id.runtime_club||
size_t(id.runtime_club)>=next.club_ids.size()||int(next.club_ids[size_t(id.runtime_club)])!=id.club_identity||
record+0x212>next.manager_records.size()||
int(next.manager_records[record+0x210])!=id.manager_default_league)
throw FormatError("league family: TeamInfo changed active manager or date");
auto refreshed=id;refreshed.revision=revision+1;refreshed.family_sequence=id.family_sequence+1;
refreshed.expected_settings_word=next.memory.u16(::bmh::layout::ManagerSettings+uint32_t(id.manager)*2);
const uint32_t family_word_at=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
if(poach_selection && *poach_selection) {
const auto chosen=club_player_detail_context(next,**poach_selection);
if(chosen.selection.runtime_team!=selected_team || chosen.source_slot<0 ||
chosen.source_slot>=0xb70 || chosen.human_loan)
throw FormatError("poach: card returned a different ordinary squad player");
refreshed.expected_family_word=next.memory.u16(family_word_at);
// A successful param1=1 selection leaves50775 here. Its common
// low80 write survives; there is no next outer Table redraw.
g_=std::move(next);game_=next_game;rand_=next_rand;club_modal_runtime_=std::move(next_runtime);
league_family_owner_->identity=refreshed;league_family_owner_->native=save_stream(g_);
league_family_owner_->rand_seed=rand_.seed();league_family_owner_->game_seed=game_.seed();
league_family_owner_->rand_calls=rand_.calls();league_family_owner_->game_calls=game_.calls();
league_family_owner_->runtime=club_modal_runtime_;++revision;return refreshed;
}
const uint16_t drawn_word=uint16_t(next.memory.u16(family_word_at)&0xff7f);
next.memory.set16(family_word_at,drawn_word);
refreshed.expected_family_word=drawn_word;
auto next_table_owner=*league_family_owner_->table;
source_table_apply_entry_flags(next_table_owner,next.memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2));
source_table_normalize_range(next_table_owner,next,refreshed.league,texts_);
next_table_owner.forecast_page.reset();next_table_owner.forecast_game_after.reset();
next_table_owner.forecast_present_pending=false;next_table_owner.phase=TableDispatchPhase::ready;
next_table_owner.display_word_override=refreshed.expected_family_word;
auto next_tables=ui::league_tables_from_game(next,id.manager);
next_tables[size_t(refreshed.league)]=ui::league_table_from_game(next,id.manager,refreshed.league,
source_table_context(next_table_owner,next_table_owner.display_word_override));
ui::LeagueTableScreen validate(data_directory_,std::move(next_tables),refreshed.league,
ui::LeagueTableScreen::FamilyMode{refreshed});
next_table_owner.page=validate.state();
auto preparation=preparation_projection(next,revision+1);
ui::validate_preparation_context(preparation);ui::DesktopScreen desk(data_directory_,preparation.desktop);
g_=std::move(next);game_=next_game;rand_=next_rand;club_modal_runtime_=std::move(next_runtime);
league_family_owner_->identity=refreshed;league_family_owner_->native=save_stream(g_);
league_family_owner_->table=std::move(next_table_owner);
league_family_owner_->rand_seed=rand_.seed();league_family_owner_->game_seed=game_.seed();
league_family_owner_->rand_calls=rand_.calls();league_family_owner_->game_calls=game_.calls();
league_family_owner_->runtime=club_modal_runtime_;++revision;return refreshed;
} catch(const std::exception& e) {restore_league_family_checkpoint(checkpoint);revision=old_revision;error=e.what();return {};}
}
bool CareerSession::refresh_family_after_child(const ui::StrengthsIdentity& prior,uint8_t child,
ui::StrengthsIdentity next,uint64_t revision,std::string& error) {
error.clear();
if(league_family_teaminfo_active_||child<1||child>3||!league_family_owner_||league_family_owner_->child!=child||
league_family_owner_->identity!=prior||prior.family_id==0||next.family_id!=prior.family_id||
next.family_sequence!=prior.family_sequence||next.revision!=revision||revision<prior.revision||
revision-prior.revision>1||
next.manager!=prior.manager||next.runtime_club!=prior.runtime_club||next.club_identity!=prior.club_identity||
next.day_counter!=prior.day_counter||next.source_param2!=prior.source_param2||
next.manager_default_league!=prior.manager_default_league||next.league<0||next.league>8||
!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=next.manager||g_.date!=next.day_counter||
size_t(next.manager)>=g_.manager_teams.size()||g_.manager_teams[size_t(next.manager)]!=next.runtime_club||
next.runtime_club<0||size_t(next.runtime_club)>=g_.club_ids.size()||
int(g_.club_ids[size_t(next.runtime_club)])!=next.club_identity) {
error="league family: child acknowledgement identity is stale";return false;
}
next.expected_settings_word=g_.memory.u16(::bmh::layout::ManagerSettings+uint32_t(next.manager)*2);
next.expected_family_word=g_.memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(next.manager)*2);
if(child==3&&(!strengths_owner_||strengths_owner_->page.identity!=next)) {
error="league family: Strengths child acknowledgement lost its owner";return false;
}
if(child==2&&(!league_pairings_draft_||league_pairings_draft_->identity.manager!=next.manager||
league_pairings_draft_->identity.runtime_club!=next.runtime_club||league_pairings_draft_->identity.league!=next.league)) {
error="league family: Pairings child acknowledgement lost its owner";return false;
}
league_family_owner_->identity=next;league_family_owner_->native=save_stream(g_);
league_family_owner_->rand_seed=rand_.seed();league_family_owner_->game_seed=game_.seed();
league_family_owner_->rand_calls=rand_.calls();league_family_owner_->game_calls=game_.calls();
league_family_owner_->runtime=club_modal_runtime_;return true;
}
std::optional<CareerSession::StrengthsDispatch> CareerSession::dispatch_strengths(
const ui::StrengthsRequest& request,uint64_t& revision,std::string& error,
const TransferOfferTeamInfoPresenter& team_info,bool family_transition) {
error.clear();const auto& id=request.identity;const bool opening=request.kind==ui::StrengthsAction::open;
if(league_family_teaminfo_active_||strengths_dispatch_active_||revision==UINT64_MAX||id.revision!=revision||id.sequence==UINT64_MAX||
id.manager<0||id.manager>3||!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=id.manager||
size_t(id.manager)>=g_.manager_teams.size()||id.runtime_club!=g_.manager_teams[size_t(id.manager)]||
id.runtime_club<0||size_t(id.runtime_club)>=g_.club_ids.size()||
id.club_identity!=int(g_.club_ids[size_t(id.runtime_club)])||id.day_counter!=g_.date||
id.league<0||id.league>8||career_complete()||
(turn_driver_.stage!=TurnDriver::Stage::MatchdayDesks&&turn_driver_.stage!=TurnDriver::Stage::SeasonEndDesk)||
pending_offer_dispatch_active_||market_dispatch_active_||calendar_advance_active_||league_pairings_draft_||
league_pairings_dispatch_active_||transfer_offer_editor_||manager_join_||contract_quote_||
stadium_.investment||stadium_.tip||stadium_.periphery_quote||top_scorers_owner_||top_scorers_dispatch_active_ || stadium_.block_expansion||other_games_owner_||other_games_dispatch_active_) {
error="strengths: stale or unavailable owner";return {};
}
const size_t rec=size_t(id.manager)*0xb0c;
const uint32_t setting=::bmh::layout::ManagerSettings+uint32_t(id.manager)*2,family=::bmh::layout::LeagueTableDisplayModes+uint32_t(id.manager)*2;
if(rec+0xb0c>g_.manager_records.size()||
(int(g_.manager_records[rec+0x290])|int(g_.manager_records[rec+0x291])<<8)!=id.runtime_club||
!g_.memory.has(setting+1)||!g_.memory.has(family+1)||
id.expected_settings_word!=g_.memory.u16(setting)||id.expected_family_word!=g_.memory.u16(family)) {
error="strengths: inconsistent manager or saved settings";return {};
}
if(opening) {
const int initial=id.runtime_club>356?0:team_league(id.runtime_club);
if(strengths_owner_||id.scope||id.sequence||(!family_transition&&id.league!=initial)||
(family_transition&&((id.source_param2!=0&&!live_source_identity(id))||id.league_group>1||id.manager_default_league<0||id.manager_default_league>8))||
next_strengths_scope_==UINT64_MAX||
request.value!=-1||request.control!=ui::StrengthsControl::condition) {
error="strengths: invalid entry";return {};
}
} else if(!strengths_owner_||id!=strengths_owner_->page.identity||
save_stream(g_)!=strengths_owner_->native||
rand_.seed()!=strengths_owner_->rand_seed||rand_.calls()!=strengths_owner_->rand_calls||
game_.seed()!=strengths_owner_->game_seed||game_.calls()!=strengths_owner_->game_calls) {
error="strengths: stale modal snapshot";return {};
}
// The process timer's automatic Source event8 belongs to an unported modal
// context. Ordinary desk entry initializes this runtime timer to zero.
const auto byte=[&](uint32_t at) {if(g_.memory.has(at))return g_.memory.u8(at);
const auto found=club_modal_runtime_.find(at);return found==club_modal_runtime_.end()?uint8_t(0):found->second;};
const uint32_t start=uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField2))|uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField3))<<8|
uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField4))<<16|uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField5))<<24;
if(opening&&start!=0&&byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField)<200) {
error="strengths: active process-timer context unsupported";return {};
}
if(request.kind==ui::StrengthsAction::pairings||request.kind==ui::StrengthsAction::table) {
error="strengths: navigation target not implemented";return {};
}
if(request.kind==ui::StrengthsAction::team_info&&!team_info) {
error="strengths: TeamInfo presenter unavailable";return {};
}
strengths_dispatch_active_=true;
struct Reset { bool& active; ~Reset(){active=false;} } reset{strengths_dispatch_active_};
try {
StrengthsDispatch result;
if(request.kind==ui::StrengthsAction::team_info) {
if(request.control!=ui::StrengthsControl::condition||request.value<0)
throw FormatError("strengths: malformed TeamInfo target");
// Keep an owned value copy across the external callback; callbacks
// can re-enter the public API and replace/reset modal ownership.
const auto current=strengths_owner_->page;
const auto target=std::find_if(current.projection.rows.begin(),current.projection.rows.end(),
[&](const auto& row){return row.runtime_team==request.value;});
if(target==current.projection.rows.end())
throw FormatError("strengths: TeamInfo target is not a visible team");
// Reset2 opens ClubInfoFromGame from the selected runtime row and
// resumes this same Strengths loop after the nested modal returns.
// Stage the presenter against the live page, then commit only if it
// did not re-enter or mutate the retained Strengths owner.
GameState next=g_;GameRandom next_game=game_;WatcomRandom next_rand=rand_;
auto next_runtime=club_modal_runtime_;
const auto live_before=strengths_checkpoint();const auto old_revision=revision;
const auto owner_identity=current.identity;
const auto same_strengths_checkpoint=[&](const StrengthsCheckpoint& before,
const StrengthsCheckpoint& after) {
const bool owner_matches=before.owner.has_value()==after.owner.has_value()&&
(!before.owner||(before.owner->page==after.owner->page&&
before.owner->native==after.owner->native&&
before.owner->rand_seed==after.owner->rand_seed&&
before.owner->game_seed==after.owner->game_seed&&
before.owner->rand_calls==after.owner->rand_calls&&
before.owner->game_calls==after.owner->game_calls));
return save_stream(before.state)==save_stream(after.state)&&
same_strengths_runtime_state(before.state,after.state)&&
before.game.seed()==after.game.seed()&&before.game.calls()==after.game.calls()&&
before.rand.seed()==after.rand.seed()&&before.rand.calls()==after.rand.calls()&&
before.runtime==after.runtime&&before.next_scope==after.next_scope&&owner_matches&&
before.family==after.family&&before.next_family_id==after.next_family_id;
};
const Image backdrop=ui::StrengthsScreen(data_directory_,current).render();
auto services=staged_club_modal_services(next,next_game,next_rand,next_runtime);
const bool accepted=team_info(services,request.value,backdrop);
const auto live_after=strengths_checkpoint();
if(revision!=old_revision||!same_strengths_checkpoint(live_before,live_after)||
!live_after.owner||live_after.owner->page.identity!=owner_identity)
throw FormatError("strengths: live owner changed during TeamInfo presenter");
if(!accepted)throw FormatError("strengths: TeamInfo presenter stopped");
if(next.date!=g_.date||next.manager_teams!=g_.manager_teams||
!next.memory.has(::bmh::layout::ActiveManager)||next.memory.u8(::bmh::layout::ActiveManager)!=id.manager||
next.memory.u16(setting)!=g_.memory.u16(setting)||next.memory.u16(family)!=g_.memory.u16(family)||
rec+0x292>next.manager_records.size()||
(int(next.manager_records[rec+0x290])|int(next.manager_records[rec+0x291])<<8)!=id.runtime_club)
throw FormatError("strengths: TeamInfo changed the retained desk or family owner");
// Reset2 retains local_68 across a nested ClubInfoFromGame and
// redraws the same league. The accepted club-entry injury cleanup
// can change lineup bits, so do not recompute this same-instance cache.
ui::StrengthsProjectionContext context;
context.cached_age=current.projection.age_scratch;
context.retain_validated_owner_age=true;
auto projection=ui::strengths_from_game(next,id.manager,id.league,context);
if(projection.rows.empty())throw FormatError("strengths: empty TeamInfo return projection");
if(current.projection.age_scratch.league!=id.league||
current.projection.age_scratch.tenths.size()!=projection.rows.size())
throw FormatError("strengths: retained TeamInfo age scratch does not match its owner");
next.memory.set16(setting,projection.words.post_draw_settings_word);
result.page=current;
result.page.identity.revision=revision+1;
result.page.identity.sequence=id.sequence+1;
result.page.identity.expected_settings_word=next.memory.u16(setting);
result.page.identity.expected_family_word=next.memory.u16(family);
result.page.projection=std::move(projection);
ui::StrengthsScreen validate(data_directory_,result.page);
result.preparation=preparation_projection(next,revision+1);
next_runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2]=uint8_t(id.league);
next_runtime[::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField]=uint8_t(current.league_group);
next_runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField]=1;next_runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2]=0;
next_runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(id.league));
const auto last=team_average(next,result.page.projection.rows.back().runtime_team,
result.page.projection.words.effective_average_flags);
next_runtime[::bmh::layout::CareerSession_FormatError_ExecutableField3]=uint8_t(last.best_half_sum);
next_runtime[::bmh::layout::CareerSession_FormatError_ExecutableField4]=uint8_t(last.best_half_sum>>8);
StrengthsOwner owner{result.page,save_stream(next),next_rand.seed(),next_game.seed(),
next_rand.calls(),next_game.calls(),next_runtime};
g_=std::move(next);game_=next_game;rand_=next_rand;
club_modal_runtime_=std::move(next_runtime);strengths_owner_=std::move(owner);
++revision;return result;
}
if(request.kind==ui::StrengthsAction::close) {
if(request.value!=-1||request.control!=ui::StrengthsControl::condition)
throw FormatError("strengths: malformed close");
result.closed=true;result.page=strengths_owner_->page;
++result.page.identity.revision;++result.page.identity.sequence;
result.preparation=preparation_projection(g_,revision+1);
strengths_owner_.reset();++revision;return result;
}
GameState next=g_;auto runtime=club_modal_runtime_;ui::StrengthsProjectionContext context;
int league=id.league,group=opening?(family_transition?id.league_group:0):strengths_owner_->page.league_group;
if(opening)next.memory.set16(family,ui::strengths_family_word_source(next.memory.u16(family),exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(league))));
else if(request.kind==ui::StrengthsAction::control) {
if(request.value!=-1)throw FormatError("strengths: malformed control");
const auto word=ui::strengths_control_word_source(id.expected_settings_word,request.control);
if(!word||*word==id.expected_settings_word)throw FormatError("strengths: unavailable or unchanged control");
next.memory.set16(setting,*word);
if(request.control==ui::StrengthsControl::lineup)context.recompute_age_as=ui::StrengthsAgeBasis::header_toggle_bit15;
else context.cached_age=strengths_owner_->page.projection.age_scratch;
} else if(request.kind==ui::StrengthsAction::select_league) {
if(request.control!=ui::StrengthsControl::condition||request.value<0||request.value>8||request.value==league)
throw FormatError("strengths: invalid league selection");
league=request.value;
} else if(request.kind==ui::StrengthsAction::toggle_group) {
if(request.value!=-1||request.control!=ui::StrengthsControl::condition||g_.memory.u8(::bmh::layout::CalendarState_FormatError_RuntimeField2)!=0)
throw FormatError("strengths: unavailable group selection");
group^=1;league=group?int(exe_.u8(::bmh::layout::CareerSession_FormatError_RuntimeField4)):int(g_.manager_records[rec+0x210]);
if(league<0||league>8)throw FormatError("strengths: invalid manager league");
if(league==id.league)context.cached_age=strengths_owner_->page.projection.age_scratch;
} else if(!opening)throw FormatError("strengths: unknown action");
auto projection=ui::strengths_from_game(next,id.manager,league,context);
next.memory.set16(setting,projection.words.post_draw_settings_word);
result.page.identity={id.manager,id.runtime_club,id.club_identity,league,id.day_counter,revision+1,
opening?next_strengths_scope_:id.scope,opening?0:id.sequence+1,
next.memory.u16(setting),next.memory.u16(family)};
result.page.identity.source_param2=id.source_param2;
result.page.identity.league_group=uint8_t(group);
result.page.identity.manager_default_league=id.manager_default_league;
result.page.identity.family_id=id.family_id;
result.page.identity.family_sequence=id.family_sequence;
result.page.projection=std::move(projection);result.page.league_group=group;
result.page.decorated=g_.memory.u8(::bmh::layout::PlainBackground)==0;result.page.original_panel=g_.memory.u8(::bmh::layout::SolidPanelBackground)==0;
result.page.gradient=g_.memory.u8(::bmh::layout::TextGradientDisabled)==0&&exe_.u8(::bmh::layout::TextGradientMode)==2;
result.page.secondary_leagues=g_.memory.u8(::bmh::layout::CalendarState_FormatError_RuntimeField2)==0;
result.page.title=message_text(next,::bmh::layout::CareerSession_FormatError_TextPointer5)+ui::utf8_to_original(result.page.projection.league_name);
const uint8_t raw_round=next.league_rounds.at(size_t(league));const int round=(raw_round&0x7f)+1;
result.page.subtitle=round>league_matchdays(league)?message_text(next,::bmh::layout::CareerSession_FormatError_TextPointer3):
message_text(next,::bmh::layout::CareerSession_FormatError_TextPointer2+uint32_t((raw_round&0x80)!=0)*4)+format_number(next,round,1)+
exe_.cstring(::bmh::layout::CareerSession_FormatError_TextPointer)+message_text(next,::bmh::layout::CareerSession_FormatError_TextPointer4);
ui::StrengthsScreen validate(data_directory_,result.page);
result.preparation=preparation_projection(next,revision+1);
// Runtime drawing scratch belongs to the session process, not the FBM.
runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2]=uint8_t(league);runtime[::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField]=uint8_t(group);runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField]=1;runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2]=0;
runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(league));
const auto last=team_average(next,result.page.projection.rows.back().runtime_team,result.page.projection.words.effective_average_flags);
runtime[::bmh::layout::CareerSession_FormatError_ExecutableField3]=uint8_t(last.best_half_sum);runtime[::bmh::layout::CareerSession_FormatError_ExecutableField4]=uint8_t(last.best_half_sum>>8);
StrengthsOwner owner{result.page,save_stream(next),rand_.seed(),game_.seed(),rand_.calls(),game_.calls(),runtime};
g_=std::move(next);club_modal_runtime_=std::move(runtime);strengths_owner_=std::move(owner);
if(opening)++next_strengths_scope_;
++revision;return result;
} catch(const std::exception& e) {error=e.what();return {};}
}
std::optional<ui::TopScorersState> CareerSession::open_top_scorers(
const ui::DeskRequest& request, uint64_t revision, const Image& underlay, std::string& error) {
error.clear();
if (top_scorers_dispatch_active_ || top_scorers_owner_ || revision == UINT64_MAX ||
next_top_scorers_scope_ == UINT64_MAX || request.kind != ui::DeskRequestKind::open_menu ||
request.menu_kind != 20 || request.revision != revision || request.manager_slot < 0 ||
request.manager_slot > 3 || !g_.memory.has(::bmh::layout::ActiveManager) ||
g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
size_t(request.manager_slot) >= g_.manager_teams.size() || career_complete() ||
(turn_driver_.stage != TurnDriver::Stage::MatchdayDesks &&
turn_driver_.stage != TurnDriver::Stage::SeasonEndDesk) ||
pending_offer_dispatch_active_ || market_dispatch_active_ || calendar_advance_active_ ||
league_pairings_draft_ || league_pairings_dispatch_active_ || strengths_owner_ ||
strengths_dispatch_active_ || balance_draft_ || balance_dispatch_active_ || transfer_offer_editor_ ||
manager_join_ || contract_quote_ || stadium_.investment || stadium_.tip || stadium_.periphery_quote || stadium_.block_expansion) {
error = "top scorers: stale or unavailable menu-20 owner";
return {};
}
const auto source_byte = [&](uint32_t address) {
if (g_.memory.has(address)) return g_.memory.u8(address);
const auto it = club_modal_runtime_.find(address);
return it == club_modal_runtime_.end() ? exe_.u8(address) : it->second;
};
const uint32_t timer_start=uint32_t(source_byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField2))|uint32_t(source_byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField3))<<8|
uint32_t(source_byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField4))<<16|uint32_t(source_byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField5))<<24;
const unsigned timer_duration=source_byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField);
if (timer_start != 0 && timer_duration < 200) {
error = "top scorers: active process-timer context unsupported";
return {};
}
try {
const int manager = request.manager_slot;
const int team = g_.manager_teams[size_t(manager)];
const size_t manager_record = size_t(manager) * 0xb0c;
if (manager_record + 0x292 > g_.manager_records.size() ||
uint16_t(g_.manager_records[manager_record + 0x290] |
uint16_t(g_.manager_records[manager_record + 0x291]) << 8) != uint16_t(team))
throw FormatError("top scorers: manager record does not own the active team");
int stable_team = team;
if (team == kNoTeam) {
// The live CupDraw_FormatError_RuntimeField3 owner is mirrored by the typed spare manager record 4.
const size_t backup = 4 * 0xb0c + 0x290;
if (manager != 0 || backup + 2 > g_.manager_records.size())
throw FormatError("top scorers: unsupported national-coach owner");
stable_team = int(uint16_t(g_.manager_records[backup] |
uint16_t(g_.manager_records[backup + 1]) << 8));
} else if (team < 0 || team >= 138) {
throw FormatError("top scorers: manager team is outside Source league scope");
}
if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= g_.club_ids.size())
throw FormatError("top scorers: missing stable club identity");
const int league = team > 0x164 ? 0 : team_league(team);
if (league < 0 || league > 8)
throw FormatError("top scorers: manager has no supported Source league");
ui::TopScorersIdentity identity;
identity.manager_slot = manager;
identity.runtime_team = team;
identity.club_identity = int(g_.club_ids[size_t(stable_team)]);
identity.league = league;
identity.day_counter = uint32_t(g_.date);
identity.revision = revision + 1;
identity.scope = next_top_scorers_scope_;
identity.sequence = 0;
auto page = ui::top_scorers_state_from_game(g_, identity,
ui::TopScorersMetric::goals, ui::TopScorersScope::league, underlay);
page.decorated_background = source_byte(::bmh::layout::PlainBackground) == 0;
page.gradient_text = source_byte(::bmh::layout::TextGradientDisabled) == 0 && source_byte(::bmh::layout::TextGradientMode) == 2;
page.cached_backdrop = source_byte(::bmh::layout::CareerSession_ApplyBalanceSourceStyle_ExecutableField) != 0 || source_byte(::bmh::layout::CareerSession_FormatError_ExecutableField5) != 0 ||
source_byte(::bmh::layout::CareerSession_FormatError_ExecutableField6) != 0 || source_byte(::bmh::layout::CareerSession_FormatError_ExecutableField7) != 0;
TopScorersOwner owner{page, save_stream(g_), rand_.seed(), game_.seed(), rand_.calls(), game_.calls()};
top_scorers_owner_ = std::move(owner);
++next_top_scorers_scope_;
++revision;
return page;
} catch (const std::exception& e) {
error = e.what();
return {};
}
}
std::optional<CareerSession::TopScorersDispatch> CareerSession::dispatch_top_scorers(
const ui::TopScorersRequest& request, uint64_t& revision, std::string& error) {
error.clear();
if (stadium_.block_expansion || top_scorers_dispatch_active_ || !top_scorers_owner_ || revision == UINT64_MAX ||
request.identity != top_scorers_owner_->page.identity || request.identity.revision != revision ||
request.identity.sequence == UINT64_MAX || request.identity.expected_settings_word != 0 ||
request.identity.expected_family_word != 0 || save_stream(g_) != top_scorers_owner_->native ||
rand_.seed() != top_scorers_owner_->rand_seed || rand_.calls() != top_scorers_owner_->rand_calls ||
game_.seed() != top_scorers_owner_->game_seed || game_.calls() != top_scorers_owner_->game_calls) {
error = "top scorers: stale, replayed or modified owner";
return {};
}
top_scorers_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{top_scorers_dispatch_active_};
try {
TopScorersDispatch result;
const auto& current = top_scorers_owner_->page;
const auto& identity = request.identity;
if (identity.manager_slot < 0 || identity.manager_slot > 3 ||
size_t(identity.manager_slot) >= g_.manager_teams.size() ||
g_.manager_teams[size_t(identity.manager_slot)] != identity.runtime_team ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager) != identity.manager_slot ||
uint32_t(g_.date) != identity.day_counter || identity.league != current.projection.league)
throw FormatError("top scorers: desk owner changed");
const size_t manager_record = size_t(identity.manager_slot) * 0xb0c;
if (manager_record + 0x292 > g_.manager_records.size() ||
uint16_t(g_.manager_records[manager_record + 0x290] |
uint16_t(g_.manager_records[manager_record + 0x291]) << 8) !=
uint16_t(identity.runtime_team))
throw FormatError("top scorers: manager record changed");
const size_t backup = 4 * 0xb0c + 0x290;
const int identity_team = identity.runtime_team == kNoTeam ?
(backup + 2 <= g_.manager_records.size() ?
int(uint16_t(g_.manager_records[backup] |
uint16_t(g_.manager_records[backup + 1]) << 8)) : -1) : identity.runtime_team;
if (identity_team < 0 || identity_team >= 138 ||
size_t(identity_team) >= g_.club_ids.size() ||
int(g_.club_ids[size_t(identity_team)]) != identity.club_identity)
throw FormatError("top scorers: stable club identity changed");
if (request.action == ui::TopScorersAction::open)
throw FormatError("top scorers: open is not a modal action");
if (request.action == ui::TopScorersAction::close) {
if (request.metric != current.metric || request.scope != current.scope)
throw FormatError("top scorers: malformed close request");
result.closed = true;
result.page = current;
} else {
ui::TopScorersMetric metric = current.metric;
ui::TopScorersScope scope = current.scope;
if (request.action == ui::TopScorersAction::set_metric) {
const auto next_metric = current.metric == ui::TopScorersMetric::goals ?
ui::TopScorersMetric::assists : current.metric == ui::TopScorersMetric::assists ?
ui::TopScorersMetric::scorer : ui::TopScorersMetric::goals;
if (request.scope != current.scope || request.metric != next_metric)
throw FormatError("top scorers: metric request is not the Source cycle successor");
metric = request.metric;
} else if (request.action == ui::TopScorersAction::toggle_scope) {
if (request.metric != current.metric || request.scope == current.scope)
throw FormatError("top scorers: invalid scope request");
scope = request.scope;
} else {
throw FormatError("top scorers: unknown action");
}
result.page = ui::top_scorers_state_from_game(g_, identity, metric, scope, current.underlay);
result.page.decorated_background = current.decorated_background;
result.page.gradient_text = current.gradient_text;
result.page.cached_backdrop = current.cached_backdrop;
}
result.page.identity.revision = revision + 1;
result.page.identity.sequence = identity.sequence + 1;
result.preparation = preparation_projection(g_, revision + 1);
if (result.closed) top_scorers_owner_.reset();
else {
top_scorers_owner_->page = result.page;
top_scorers_owner_->native = save_stream(g_);
top_scorers_owner_->rand_seed = rand_.seed();
top_scorers_owner_->game_seed = game_.seed();
top_scorers_owner_->rand_calls = rand_.calls();
top_scorers_owner_->game_calls = game_.calls();
}
++revision;
return result;
} catch (const std::exception& e) {
error = e.what();
return {};
}
}
bool CareerSession::apply_statistics_preference(const ui::DeskRequest& owner, int manager_slot,
uint8_t expected_flags, uint8_t target_flags,
uint64_t& revision, std::string& error) {
constexpr uint32_t flags_base = ::bmh::layout::Flags;
if (owner.kind != ui::DeskRequestKind::open_menu || owner.menu_kind != 23 ||
owner.manager_slot != manager_slot || manager_slot < 0 || manager_slot >= 4 ||
owner.revision != revision || !g_.memory.has(::bmh::layout::ActiveManager) ||
g_.memory.u8(::bmh::layout::ActiveManager) != manager_slot || size_t(manager_slot) >= g_.manager_teams.size() ||
career_complete() || opportunities_active() ||
(turn_driver_.stage != TurnDriver::Stage::MatchdayDesks &&
turn_driver_.stage != TurnDriver::Stage::SeasonEndDesk)) {
error = "statistics: stale menu owner";
return false;
}
const uint32_t address = flags_base + uint32_t(manager_slot) * 3;
if (!g_.memory.has(address) || g_.memory.u8(address) != expected_flags) {
error = "statistics: stale Source preference";
return false;
}
const uint8_t delta = uint8_t(expected_flags ^ target_flags);
const bool one_metric = delta != 0 && (delta & uint8_t(delta - 1)) == 0 && delta < 0x40;
const bool absolute_pair = delta == 0xc0;
if ((!one_metric && !absolute_pair) || target_flags != uint8_t(expected_flags ^ delta)) {
error = "statistics: invalid Source preference operation";
return false;
}
g_.memory.set8(address, target_flags);
error.clear();
return true;
}
std::optional<ui::OpportunitiesState> CareerSession::open_opportunities(
const ui::DeskRequest& request,uint64_t revision,const Image& underlay,std::string& error,
bool national_source_case,int stable_identity) {
error.clear();
if(opportunities_dispatch_active_||opportunities_owner_||revision==UINT64_MAX||next_opportunities_scope_==UINT64_MAX||
request.kind!=ui::DeskRequestKind::open_menu||request.menu_kind!=23||request.revision!=revision||
request.manager_slot<0||request.manager_slot>3||!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=request.manager_slot||
size_t(request.manager_slot)>=g_.manager_teams.size()||career_complete()||
(turn_driver_.stage!=TurnDriver::Stage::MatchdayDesks&&turn_driver_.stage!=TurnDriver::Stage::SeasonEndDesk)||
pending_offer_dispatch_active_||market_dispatch_active_||calendar_advance_active_||league_pairings_draft_||
league_pairings_dispatch_active_||strengths_owner_||strengths_dispatch_active_||top_scorers_owner_||
top_scorers_dispatch_active_||balance_draft_||balance_dispatch_active_||other_games_owner_||other_games_dispatch_active_||
transfer_offer_editor_||manager_join_||contract_quote_||stadium_.investment||stadium_.tip||stadium_.periphery_quote||
stadium_.block_expansion) { error="opportunities: stale or unavailable menu-23 owner"; return {}; }
try {
const int manager=request.manager_slot,team=g_.manager_teams[size_t(manager)];
const int league=national_source_case?0:team_league(team);
if(national_source_case) {
if(team!=0x165||league!=0)throw FormatError("opportunities: invalid national menu-6 owner");
if(stable_identity<0)throw FormatError("opportunities: missing national Desk identity");
} else if(team<0||team>=138||size_t(team)>=g_.club_ids.size()||league<0||league>=9)
throw FormatError("opportunities: unsupported team/league");
if(underlay.width!=320||underlay.height!=240)throw FormatError("opportunities: expected captured 320x240 desktop");
const uint32_t choice_at=::bmh::layout::CareerSession_FormatError_ExecutableField+uint32_t(manager)*2;
if(!g_.memory.has(choice_at+1))throw FormatError("opportunities: Source choice word missing");
uint16_t mode=g_.memory.u16(choice_at);if(mode==0){mode=1;g_.memory.set16(choice_at,mode);}
if(mode!=1&&mode!=2&&mode!=4&&mode!=8)throw FormatError("opportunities: invalid stored Source mode");
ui::OpportunitiesState page;page.identity={manager,team,national_source_case?stable_identity:int(g_.club_ids[size_t(team)]),uint32_t(g_.date),revision+1,next_opportunities_scope_,0};
page.mode=mode;page.league_size=kLeagueSizes[league];page.underlay=underlay;
page.gradient_text=g_.memory.has(::bmh::layout::TextGradientDisabled)&&g_.memory.u8(::bmh::layout::TextGradientDisabled)==0&&g_.memory.has(::bmh::layout::TextGradientMode)&&g_.memory.u8(::bmh::layout::TextGradientMode)==2;
page.current_rank=national_source_case?national_opportunities_rank(g_,team,page.ranks):table_prediction(g_,team,mode,page.ranks,nullptr);
opportunities_owner_=OpportunitiesOwner{page,save_stream(g_),game_,rand_,national_source_case};++next_opportunities_scope_;
return page;
} catch(const std::exception& e){error=e.what();return {};}
}
std::optional<CareerSession::OpportunitiesDispatch> CareerSession::dispatch_opportunities(
const ui::OpportunitiesRequest& request,uint64_t& revision,std::string& error) {
error.clear();
if(opportunities_dispatch_active_||!opportunities_owner_||revision==UINT64_MAX||
request.identity!=opportunities_owner_->page.identity||request.identity.revision!=revision||
request.identity.sequence==UINT64_MAX||save_stream(g_)!=opportunities_owner_->native||
game_.seed()!=opportunities_owner_->game.seed()||game_.calls()!=opportunities_owner_->game.calls()||
rand_.seed()!=opportunities_owner_->rand.seed()||rand_.calls()!=opportunities_owner_->rand.calls()) {
error="opportunities: stale, replayed or modified owner";return {};
}
opportunities_dispatch_active_=true;struct Reset{bool& active;~Reset(){active=false;}} reset{opportunities_dispatch_active_};
try {
const auto current=opportunities_owner_->page; // Value snapshot across all validation.
const bool national_source_case=opportunities_owner_->national_source_case;
if(current.identity.manager_slot<0||current.identity.manager_slot>3||
size_t(current.identity.manager_slot)>=g_.manager_teams.size()||
g_.manager_teams[size_t(current.identity.manager_slot)]!=current.identity.runtime_team||
!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=current.identity.manager_slot||
uint32_t(g_.date)!=current.identity.day_counter||
size_t(current.identity.runtime_team)>=g_.club_ids.size()||
(!national_source_case&&int(g_.club_ids[size_t(current.identity.runtime_team)])!=current.identity.stable_club_identity)||
(national_source_case&&(current.identity.runtime_team!=0x165||
current.identity.stable_club_identity<0)))
throw FormatError("opportunities: desk owner changed");
OpportunitiesDispatch result;result.page=current;
if(request.action==ui::OpportunitiesAction::close){
if(request.mode!=current.mode)throw FormatError("opportunities: malformed close");
result.closed=true;
} else if(request.action==ui::OpportunitiesAction::select_mode){
if(request.mode!=1&&request.mode!=2&&request.mode!=4&&request.mode!=8)
throw FormatError("opportunities: unsupported Source mode");
const uint32_t choice_at=::bmh::layout::CareerSession_FormatError_ExecutableField+uint32_t(current.identity.manager_slot)*2;
if(!g_.memory.has(choice_at+1))throw FormatError("opportunities: Source choice word missing");
g_.memory.set16(choice_at,uint16_t(request.mode));
result.page.mode=request.mode;
result.page.current_rank=national_source_case?
national_opportunities_rank(g_,current.identity.runtime_team,result.page.ranks):
table_prediction(g_,current.identity.runtime_team,request.mode,result.page.ranks,nullptr);
} else throw FormatError("opportunities: unknown action");
result.page.identity.revision=revision+1;result.page.identity.sequence=request.identity.sequence+1;
result.preparation=preparation_projection(g_,revision+1);
if(result.closed)opportunities_owner_.reset();
else opportunities_owner_=OpportunitiesOwner{result.page,save_stream(g_),game_,rand_,national_source_case};
++revision;return result;
} catch(const std::exception& e){error=e.what();return {};}
}
std::optional<ui::OtherGamesState> CareerSession::open_other_games(
const ui::DeskRequest& request, uint64_t& revision, const Image& underlay, std::string& error) {
error.clear();
if (other_games_dispatch_active_ || other_games_owner_ || revision == UINT64_MAX ||
next_other_games_scope_ == UINT64_MAX || request.kind != ui::DeskRequestKind::open_menu ||
request.menu_kind != 5 || request.revision != revision || request.manager_slot < 0 ||
request.manager_slot > 3 || !g_.memory.has(::bmh::layout::ActiveManager) ||
g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
size_t(request.manager_slot) >= g_.manager_teams.size() || career_complete() ||
(turn_driver_.stage != TurnDriver::Stage::MatchdayDesks &&
turn_driver_.stage != TurnDriver::Stage::SeasonEndDesk) ||
pending_offer_dispatch_active_ || market_dispatch_active_ || calendar_advance_active_ ||
league_pairings_draft_ || league_pairings_dispatch_active_ || strengths_owner_ ||
strengths_dispatch_active_ || top_scorers_owner_ || top_scorers_dispatch_active_ || other_games_owner_ || other_games_dispatch_active_ ||
balance_draft_ || balance_dispatch_active_ || transfer_offer_editor_ || manager_join_ ||
contract_quote_ || stadium_.investment || stadium_.tip || stadium_.periphery_quote || stadium_.block_expansion) {
error = "other games: stale or unavailable menu-5 owner";
return {};
}
try {
if (!g_.memory.has(::bmh::layout::ActiveSelectors + 7) || !g_.memory.has(::bmh::layout::ActiveManager) ||
!g_.memory.has(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField + uint32_t(request.manager_slot)) || !g_.memory.has(::bmh::layout::FriendlyPlanCount))
throw FormatError("other games: missing Source overview state");
GameState next = g_;
// CupGroupOverviewEffects's exact entry transaction. CareerSession_FormatError_RuntimeField3 aliases selector slot four, so its
// season write precedes the first-hit selector-12 insertion/removal.
next.memory.set8(::bmh::layout::CareerSession_FormatError_RuntimeField3, uint8_t(7 - (uint16_t(next.season) % 4)));
int active = next.memory.u8(::bmh::layout::ActiveManager);
if (active > 3) {
active = 0;
next.memory.set8(::bmh::layout::ActiveManager, 0);
}
next.memory.set8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField + uint32_t(active), 0x80);
if (next.memory.u8(::bmh::layout::FriendlyPlanCount) == 0) {
end_competition(next.memory, 12);
} else {
for (uint32_t i = 0; i < 8; ++i) {
const uint8_t id = next.memory.u8(::bmh::layout::ActiveSelectors + i);
if (id == 12) break;
if (id == 0x14) { next.memory.set8(::bmh::layout::ActiveSelectors + i, 12); break; }
}
}
const int manager = active;
if (size_t(manager) >= next.manager_teams.size())
throw FormatError("other games: active manager slot is outside typed manager list");
const int team = next.manager_teams[size_t(manager)];
const size_t record = size_t(manager) * 0xb0c;
if (record + 0x292 > next.manager_records.size() || team < 0 || team >= 0x190 ||
uint16_t(next.manager_records[record + 0x290] |
uint16_t(next.manager_records[record + 0x291]) << 8) != uint16_t(team))
throw FormatError("other games: manager record does not own the active team");
int stable_team = team;
if (team > 0x164) {
const size_t backup = 4 * 0xb0c + 0x290;
if (manager != 0 || backup + 2 > next.manager_records.size())
throw FormatError("other games: unsupported national-coach owner");
stable_team = int(uint16_t(next.manager_records[backup] |
uint16_t(next.manager_records[backup + 1]) << 8));
}
if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= next.club_ids.size())
throw FormatError("other games: missing stable manager club identity");
const uint8_t source_view = next.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField + uint32_t(manager));
const OtherGamesDisplayMode mode = (source_view & 0x80)
? OtherGamesDisplayMode::detail : OtherGamesDisplayMode::compact;
const int local_cursor = source_view & 0x7f;
if (local_cursor % 16 != 0)
throw FormatError("other games: malformed Source local page cursor");
ui::OtherGamesIdentity identity;
identity.manager_slot = manager;
identity.runtime_team = team;
identity.club_identity = int(next.club_ids[size_t(stable_team)]);
identity.day_counter = uint32_t(next.date);
identity.revision = revision + 1;
identity.scope = next_other_games_scope_;
identity.sequence = 0;
identity.expected_view_byte = source_view;
auto page = ui::other_games_state_from_game(next,identity,texts_,exe_,
other_games_selection_.competition,other_games_selection_.linked_page,-1,mode,
local_cursor,true,underlay,club_modal_runtime_);
if (page.projection.display_mode != mode) {
// Source forces local20=detail on redraw if this round cannot use the toggle.
if (page.projection.source_participant_count <= 16 && mode != OtherGamesDisplayMode::detail) {
next.memory.set8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField + uint32_t(manager),uint8_t(source_view | 0x80));
identity.expected_view_byte = uint8_t(source_view | 0x80);
page.identity = identity;
} else {
throw FormatError("other games: malformed Source local page cursor");
}
}
page.source_participant_offset = local_cursor;
OtherGamesOwner owner;
owner.page = page;
owner.desk_owner = request;
owner.round = page.projection.round;
owner.participant_offset = local_cursor;
owner.display_mode = page.projection.display_mode;
owner.native = save_stream(next);
owner.runtime = club_modal_runtime_;
owner.rand_seed = rand_.seed(); owner.game_seed = game_.seed();
owner.rand_calls = rand_.calls(); owner.game_calls = game_.calls();
g_ = std::move(next);
other_games_owner_ = std::move(owner);
++next_other_games_scope_;
++revision;
return page;
} catch (const std::exception& e) {
error = e.what();
return {};
}
}
std::optional<CareerSession::OtherGamesDispatch> CareerSession::dispatch_other_games(
const ui::OtherGamesRequest& request, uint64_t& revision, std::string& error,
const TransferOfferTeamInfoPresenter& team_info) {
error.clear();
if (stadium_.block_expansion || other_games_dispatch_active_ || !other_games_owner_ || revision == UINT64_MAX ||
request.identity != other_games_owner_->page.identity || request.identity.revision != revision ||
request.identity.sequence == UINT64_MAX || save_stream(g_) != other_games_owner_->native ||
club_modal_runtime_ != other_games_owner_->runtime || rand_.seed() != other_games_owner_->rand_seed ||
rand_.calls() != other_games_owner_->rand_calls || game_.seed() != other_games_owner_->game_seed ||
game_.calls() != other_games_owner_->game_calls) {
error = "other games: stale, replayed or modified owner";
return {};
}
other_games_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{other_games_dispatch_active_};
try {
// Keep value snapshots across any external presenter call. The presenter
// may capture this CareerSession and invoke another public action while
// the modal dispatch is active.
const auto current = other_games_owner_->page;
const auto id = request.identity;
const auto desk = other_games_owner_->desk_owner;
const int owned_round=other_games_owner_->round;
const int owned_participant_offset=other_games_owner_->participant_offset;
const auto owned_display_mode=other_games_owner_->display_mode;
if (id.manager_slot != desk.manager_slot || id.manager_slot < 0 || id.manager_slot > 3 ||
size_t(id.manager_slot) >= g_.manager_teams.size() ||
g_.manager_teams[size_t(id.manager_slot)] != id.runtime_team ||
g_.memory.u8(::bmh::layout::ActiveManager) != id.manager_slot || uint32_t(g_.date) != id.day_counter ||
g_.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField + uint32_t(id.manager_slot)) != id.expected_view_byte)
throw FormatError("other games: desk owner or view byte changed");
const size_t rec = size_t(id.manager_slot) * 0xb0c;
if (rec + 0x292 > g_.manager_records.size() ||
uint16_t(g_.manager_records[rec + 0x290] | uint16_t(g_.manager_records[rec + 0x291]) << 8) !=
uint16_t(id.runtime_team))
throw FormatError("other games: manager record changed");
int stable_team = id.runtime_team;
if (id.runtime_team > 0x164) {
const size_t backup = 4 * 0xb0c + 0x290;
if (id.manager_slot != 0 || backup + 2 > g_.manager_records.size())
throw FormatError("other games: unsupported national owner");
stable_team = int(uint16_t(g_.manager_records[backup] | uint16_t(g_.manager_records[backup + 1]) << 8));
}
if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= g_.club_ids.size() ||
int(g_.club_ids[size_t(stable_team)]) != id.club_identity)
throw FormatError("other games: stable club identity changed");
if (request.action == ui::OtherGamesAction::team_info) {
if (request.value < 0 || current.projection.unfinished_predecessor ||
!current.projection.fixtures_available)
throw FormatError("other games: invalid team-information target");
bool target_visible = false;
for (const auto& row:current.projection.rows) {
target_visible |= row.home_team==request.value||row.away_team==request.value;
}
if (!target_visible) throw FormatError("other games: team-information target is not visible");
if (!team_info) throw FormatError("other games: TeamInfo presenter unavailable");
GameState next=g_;
GameRandom next_game=game_;
WatcomRandom next_rand=rand_;
auto next_runtime=club_modal_runtime_;
// Source CupGroupOverviewEffects passes the accepted Other Games drawing as the
// immediate parent's backdrop. The presenter's mutations are staged
// with the same Native, W and process-runtime owners.
const Image backdrop=ui::OtherGamesScreen(data_directory_,current).render();
auto services=staged_club_modal_services(next,next_game,next_rand,next_runtime);
const auto live_baseline=other_games_checkpoint();
const auto revision_baseline=revision;
const bool presenter_accepted=team_info(services,request.value,backdrop);
// Validate the live session before consulting the owner again or
// committing staged presenter changes. A captured callback that
// mutated Native, either RNG, runtime, selection, scope or owner is
// rejected; Controller restores its pre-dispatch checkpoint.
if(revision!=revision_baseline||
!same_other_games_live_baseline(live_baseline,other_games_checkpoint()))
throw FormatError("other games: live session changed during TeamInfo presenter");
if(!presenter_accepted)
throw FormatError("other games: TeamInfo presenter stopped");
if(!other_games_owner_||other_games_owner_->page.identity!=id||
ui::OtherGamesScreen(data_directory_,other_games_owner_->page).render().pixels!=backdrop.pixels)
throw FormatError("other games: live page changed during TeamInfo presenter");
if(next.date!=g_.date||next.manager_teams!=g_.manager_teams||
next.memory.u8(::bmh::layout::ActiveManager)!=id.manager_slot||
next.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(id.manager_slot))!=id.expected_view_byte)
throw FormatError("other games: TeamInfo changed its outer desk or saved page owner");
const size_t active_record=size_t(id.manager_slot)*0xb0c;
if(active_record+0x292>next.manager_records.size()||
uint16_t(next.manager_records[active_record+0x290]|
uint16_t(next.manager_records[active_record+0x291])<<8)!=uint16_t(id.runtime_team))
throw FormatError("other games: TeamInfo changed the active manager record");
const int retained_team=id.runtime_team>0x164
? int(uint16_t(next.manager_records[4*0xb0c+0x290]|
uint16_t(next.manager_records[4*0xb0c+0x291])<<8)) : id.runtime_team;
if(retained_team<0||retained_team>=138||size_t(retained_team)>=next.club_ids.size()||
int(next.club_ids[size_t(retained_team)])!=id.club_identity)
throw FormatError("other games: TeamInfo changed the stable desk club identity");
// LAB_000226dc clears the input event, then local_50 skips the
// entry-only stage/cursor/round setup and redraws the retained view.
const auto put_runtime=[&](uint32_t address,uint8_t value) {
if(next.memory.has(address))next.memory.set8(address,value);
else next_runtime[address]=value;
};
put_runtime(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2,0);
ui::OtherGamesIdentity returned_id=id;
returned_id.revision=revision+1;
returned_id.sequence=id.sequence+1;
auto page=ui::other_games_state_from_game(next,returned_id,texts_,exe_,
current.projection.competition,current.projection.linked_page,
owned_round,owned_display_mode,
owned_participant_offset,false,current.underlay,next_runtime);
if(page.projection.competition!=current.projection.competition||
page.projection.entry_index!=current.projection.entry_index||
page.projection.descriptor_competition!=current.projection.descriptor_competition||
page.projection.linked_page!=current.projection.linked_page||
page.projection.round!=current.projection.round)
throw FormatError("other games: TeamInfo return changed the retained Source selection");
if(page.projection.source_participant_count<=16) {
const uint32_t view_at=::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(id.manager_slot);
const uint8_t before_view=next.memory.has(view_at)
?next.memory.u8(view_at):id.expected_view_byte;
const uint8_t forced=uint8_t(before_view|0x80);
put_runtime(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField+uint32_t(id.manager_slot),forced);
returned_id.expected_view_byte=forced;
page=ui::other_games_state_from_game(next,returned_id,texts_,exe_,
current.projection.competition,current.projection.linked_page,
owned_round,OtherGamesDisplayMode::detail,
owned_participant_offset,false,current.underlay,next_runtime);
}
page.source_participant_offset=owned_participant_offset;
other_games_source_redraw_effects(next,next_rand,next_runtime,page.projection,exe_);
OtherGamesDispatch result;
result.page=std::move(page);
result.preparation=preparation_projection(next,revision+1);
ui::OtherGamesScreen validate_page(data_directory_,result.page);
ui::DesktopScreen validate_desktop(data_directory_,result.preparation.desktop);
// Commit only after the nested presenter and both return projections
// have succeeded. The modal scope stays owned; only its action token
// advances, matching StartupFlow's full-identity ACK.
g_=std::move(next);game_=next_game;rand_=next_rand;
club_modal_runtime_=std::move(next_runtime);
other_games_owner_->page=result.page;
other_games_owner_->round=result.page.projection.round;
other_games_owner_->participant_offset=result.page.source_participant_offset;
other_games_owner_->display_mode=result.page.projection.display_mode;
other_games_owner_->native=save_stream(g_);
other_games_owner_->runtime=club_modal_runtime_;
other_games_owner_->rand_seed=rand_.seed();other_games_owner_->game_seed=game_.seed();
other_games_owner_->rand_calls=rand_.calls();other_games_owner_->game_calls=game_.calls();
++revision;
return result;
}
OtherGamesDispatch result;
if (request.action == ui::OtherGamesAction::close) {
if (request.value != -1) throw FormatError("other games: malformed close request");
result.closed = true;
result.page = current;
} else {
GameState next = g_;
const int manager = id.manager_slot;
const uint32_t view_at = ::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField + uint32_t(manager);
uint8_t view = next.memory.u8(view_at);
int competition = other_games_selection_.competition;
int linked_page = other_games_selection_.linked_page;
int round = other_games_owner_->round;
int local_cursor = other_games_owner_->participant_offset;
auto mode = other_games_owner_->display_mode;
bool source_new_selection = false;
switch (request.action) {
case ui::OtherGamesAction::select_competition: {
if (current.projection.display_mode != OtherGamesDisplayMode::detail || request.value < 0 ||
request.value >= int(current.projection.selectors.size()))
throw FormatError("other games: invalid selector slot");
const auto& selector = current.projection.selectors[size_t(request.value)];
if (!selector.active) throw FormatError("other games: inactive selector slot");
const int old_competition=competition;
if (old_competition == selector.competition &&
current.projection.source_participant_count > 16) {
local_cursor += 16;
if (local_cursor >= current.projection.source_participant_count) local_cursor = 0;
const uint8_t updated = uint8_t((view & 0x80) | (local_cursor & 0x7f));
next.memory.set8(view_at,updated);
view = updated;
} else {
// CupGroupOverviewEffects compares the selected ID with the clicked SLOT before it
// stores the selector ID. These are intentionally different values.
if (old_competition != request.value) {
local_cursor = 0;
linked_page = 0;
const uint8_t updated = uint8_t(view & 0x80);
next.memory.set8(view_at,updated);
view = updated;
}
competition = selector.competition;
local_cursor = int(view & 0x7f);
round = -1;
source_new_selection = old_competition != competition;
}
break;
}
case ui::OtherGamesAction::select_linked_page:
if (current.projection.display_mode != OtherGamesDisplayMode::detail || request.value < 0 ||
request.value >= int(current.projection.linked_pages.size()) ||
current.projection.linked_pages[size_t(request.value)].ordinal != request.value)
throw FormatError("other games: invalid linked-page ordinal");
linked_page = request.value;
round = -1;
local_cursor = int(view & 0x7f);
break;
case ui::OtherGamesAction::previous_round:
case ui::OtherGamesAction::next_round:
if (request.value != -1 || !current.projection.round_arrows_visible)
throw FormatError("other games: invalid round action");
round = request.action == ui::OtherGamesAction::previous_round
? (round + current.projection.rounds - 1) % current.projection.rounds
: (round + 1) % current.projection.rounds;
local_cursor = 0;
break;
case ui::OtherGamesAction::toggle_display_mode:
if (request.value != -1 || !current.projection.display_mode_toggle_available ||
current.projection.unfinished_predecessor || !current.projection.fixtures_available)
throw FormatError("other games: display toggle is unavailable");
view ^= 0x80;
next.memory.set8(view_at,view);
mode = (view & 0x80) ? OtherGamesDisplayMode::detail : OtherGamesDisplayMode::compact;
break;
case ui::OtherGamesAction::team_info:
case ui::OtherGamesAction::close:
throw FormatError("other games: malformed action");
default:
throw FormatError("other games: unknown action");
}
if (current.projection.source_participant_count <= 16) {
const uint8_t updated = uint8_t(view | 0x80);
if (updated != view) next.memory.set8(view_at,updated);
view = updated; mode = OtherGamesDisplayMode::detail;
}
ui::OtherGamesIdentity next_id = id;
next_id.revision = revision + 1;
next_id.sequence = id.sequence + 1;
next_id.expected_view_byte = view;
auto page = ui::other_games_state_from_game(next,next_id,texts_,exe_,competition,linked_page,
round,mode,local_cursor,source_new_selection,current.underlay,club_modal_runtime_);
if (page.projection.source_participant_count <= 16 && mode != OtherGamesDisplayMode::detail) {
const uint8_t updated = uint8_t(view | 0x80);
next.memory.set8(view_at,updated);
next_id.expected_view_byte = updated;
page.identity = next_id;
mode = OtherGamesDisplayMode::detail;
}
page.source_participant_offset = local_cursor;
result.page = std::move(page);
result.preparation = preparation_projection(next,revision+1);
g_ = std::move(next);
other_games_selection_ = {competition,linked_page};
other_games_owner_->page = result.page;
other_games_owner_->round = result.page.projection.round;
other_games_owner_->participant_offset = local_cursor;
other_games_owner_->display_mode = mode;
other_games_owner_->native = save_stream(g_);
other_games_owner_->runtime = club_modal_runtime_;
other_games_owner_->rand_seed = rand_.seed(); other_games_owner_->game_seed = game_.seed();
other_games_owner_->rand_calls = rand_.calls(); other_games_owner_->game_calls = game_.calls();
}
if (result.closed) {
result.page.identity.revision = revision + 1;
result.page.identity.sequence = id.sequence + 1;
result.preparation = preparation_projection(g_,revision+1);
other_games_owner_.reset();
}
++revision;
return result;
} catch (const std::exception& e) {
error = e.what();
return {};
}
}
std::optional<ui::BalanceState> CareerSession::open_balance_plan(
const ui::DeskRequest& request,uint64_t revision,const Image& underlay,std::string& error) {
error.clear();
if(request.kind!=ui::DeskRequestKind::open_menu||request.menu_kind!=28||request.revision!=revision||
revision==UINT64_MAX||balance_draft_||balance_dispatch_active_||strengths_owner_||strengths_dispatch_active_||
top_scorers_owner_||top_scorers_dispatch_active_ || stadium_.block_expansion||other_games_owner_||other_games_dispatch_active_||
league_pairings_draft_||league_pairings_dispatch_active_||market_dispatch_active_||pending_offer_dispatch_active_||
calendar_advance_active_||transfer_offer_editor_||manager_join_||request.manager_slot<0||request.manager_slot>=4||
size_t(request.manager_slot)>=g_.manager_teams.size()||!g_.memory.has(::bmh::layout::ActiveManager)||
g_.memory.u8(::bmh::layout::ActiveManager)!=request.manager_slot) {
error="balance: stale, nested or unsupported opening";return {};
}
try {
const int slot=request.manager_slot, runtime_club=g_.manager_teams[size_t(slot)];
if(runtime_club<0||size_t(runtime_club)>=g_.club_ids.size()||g_.date>UINT32_MAX||next_balance_scope_==UINT64_MAX)
throw FormatError("balance: invalid manager identity");
BalanceDraft next{g_,game_,rand_,club_modal_runtime_,club_modal_runtime_,{},save_stream(g_),
rand_.seed(),game_.seed(),rand_.calls(),game_.calls(),false};
next.notice_gate={source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::CompactDialogFrame),
source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField2),
source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField)};
GameState opening=g_;
if(!opening.memory.has(::bmh::layout::PlanTicketPrice))opening.memory.add_block(::bmh::layout::PlanTicketPrice,4);
for(int i=0;i<4;++i)opening.memory.set8(::bmh::layout::PlanTicketPrice+uint32_t(i),
source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::PlanTicketPrice+uint32_t(i)));
auto draft=bmh::open_balance_plan(opening,slot);
if(!g_.memory.has(::bmh::layout::PlanTicketPrice+uint32_t(slot)))
next.runtime[::bmh::layout::PlanTicketPrice+uint32_t(slot)]=uint8_t(draft.rows[kBalanceTicketPrice]);
ui::BalanceIdentity id{slot,runtime_club,int(g_.club_ids[size_t(runtime_club)]),uint32_t(g_.date),revision,next_balance_scope_,0};
next.page=ui::balance_from_game(g_,draft,exe_,id,underlay);
apply_balance_source_style(next.page,g_,club_modal_runtime_,exe_);
next.page.read_only_notice_enabled=next.notice_gate.enabled();
next.page.read_only_notice.compact_dialog_frame=next.notice_gate.compact_dialog_frame!=0;
next.page.close_notice.compact_dialog_frame=next.notice_gate.compact_dialog_frame!=0;
ui::BalanceScreen validate(data_directory_,next.page);
auto accepted_page=next.page;
auto accepted_runtime=next.runtime;
next.original_runtime=accepted_runtime;
balance_draft_=std::move(next);
club_modal_runtime_=std::move(accepted_runtime);
++next_balance_scope_;
return accepted_page;
} catch(const std::exception& e) {error=e.what();return {};}
}
std::optional<CareerSession::BalanceDispatch> CareerSession::dispatch_balance_plan(
const ui::BalanceRequest& request,uint64_t& revision,std::string& error) {
error.clear();
if(stadium_.block_expansion||balance_dispatch_active_||!balance_draft_||request.identity!=balance_draft_->page.identity||
request.identity.revision!=revision||request.identity.sequence==UINT64_MAX||revision==UINT64_MAX||
save_stream(g_)!=balance_draft_->original_stream||rand_.seed()!=balance_draft_->original_rand_seed||
game_.seed()!=balance_draft_->original_game_seed||rand_.calls()!=balance_draft_->original_rand_calls||
game_.calls()!=balance_draft_->original_game_calls||club_modal_runtime_!=balance_draft_->original_runtime) {
error="balance: stale or nested owner action";return {};
}
auto next=*balance_draft_;
balance_dispatch_active_=true;struct Reset {bool& x;~Reset(){x=false;}} reset{balance_dispatch_active_};
try {
auto& identity=next.page.identity;
const int manager=identity.manager_slot;
if(manager<0||manager>=4||size_t(manager)>=g_.manager_teams.size()||
g_.manager_teams[size_t(manager)]!=identity.runtime_club||
int(g_.club_ids[size_t(identity.runtime_club)])!=identity.club_identity||g_.date!=identity.day_counter||
!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=manager)
throw FormatError("balance: manager identity changed");
BalanceDispatch result;
if(request.kind==ui::BalanceAction::confirm_close) {
if(!next.page.pending_close||!next.warning)throw FormatError("balance: no staged warning close");
if(request.row!=-1||request.value)throw FormatError("balance: malformed confirmation");
const auto before=identity;identity.revision=revision+1;identity.sequence=before.sequence+1;
next.page.pending_close=false;next.page.close_notice={};
result.closed=true;result.page=next.page;
result.preparation=preparation_projection(next.state,revision+1);
ui::validate_preparation_context(result.preparation);
ui::DesktopScreen validate(data_directory_,result.preparation.desktop);
g_=std::move(next.state);game_=next.game;rand_=next.rand;club_modal_runtime_=std::move(next.runtime);
balance_draft_.reset();++revision;
return result;
}
if(next.page.pending_close)throw FormatError("balance: warning confirmation is pending");
auto draft=next.page.draft;
switch(request.kind) {
case ui::BalanceAction::edit_row: {
if(request.row<0||request.row>=kBalanceRows)throw FormatError("balance: invalid row");
const auto status=edit_balance_plan(next.state,draft,request.row,request.value);
if(status!=BalanceEditStatus::changed)throw FormatError("balance: edit rejected");
break;
}
case ui::BalanceAction::cycle_view:
if(request.row!=-1||request.value)throw FormatError("balance: malformed view action");
cycle_balance_view(next.state,draft);break;
case ui::BalanceAction::take_actuals:
if(request.row!=-1||request.value)throw FormatError("balance: malformed reset action");
reset_balance_plan(next.state,draft);break;
case ui::BalanceAction::close: {
if(request.row!=-1||request.value)throw FormatError("balance: malformed close action");
const auto original_identity=identity;
GameState closing=next.state;
if(!closing.memory.has(::bmh::layout::PlanTicketPrice))closing.memory.add_block(::bmh::layout::PlanTicketPrice,4);
for(int i=0;i<4;++i)closing.memory.set8(::bmh::layout::PlanTicketPrice+uint32_t(i),
source_runtime_byte(next.state,next.runtime,exe_,::bmh::layout::PlanTicketPrice+uint32_t(i)));
const bool dfb_warning=bmh::close_balance_plan(closing,draft);
next.state.manager_records=std::move(closing.manager_records);
const uint32_t ticket_address=::bmh::layout::PlanTicketPrice+uint32_t(manager);
if(next.state.memory.has(ticket_address))next.state.memory.set8(ticket_address,closing.memory.u8(ticket_address));
else next.runtime[ticket_address]=closing.memory.u8(ticket_address);
next.notice_gate={source_runtime_byte(next.state,next.runtime,exe_,::bmh::layout::CompactDialogFrame),
source_runtime_byte(next.state,next.runtime,exe_,::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField2),
source_runtime_byte(next.state,next.runtime,exe_,::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField)};
next.warning=dfb_warning&&next.notice_gate.enabled();
next.page.pending_close=next.warning;
next.page.close_notice=next.warning?next.page.close_notice:ui::TaxDialogProjection{};
next.page.draft=draft;
next.page.identity.sequence=original_identity.sequence+1;
if(next.warning) {
auto& notice=next.page.close_notice;
notice.kind=ui::TaxDialogKind::acknowledgement;
notice.source_manager_flags=uint8_t(manager)|0x40;
notice.compact_dialog_frame=next.notice_gate.compact_dialog_frame!=0;
notice.body=message_text(next.state,::bmh::layout::BalancePlan_BalanceFromGame_TextPointer2);
const size_t record=size_t(manager)*0xb0c;
if(record+0x223>next.state.manager_records.size())throw FormatError("balance: missing manager display identity");
const size_t name_at=record+0xa8;size_t name_end=name_at;
while(name_end<name_at+30&&next.state.manager_records[name_end])++name_end;
notice.manager_name.assign(reinterpret_cast<const char*>(next.state.manager_records.data()+name_at),name_end-name_at);
notice.portrait=next.state.manager_records[record+0x221];
const int club=next.state.manager_teams[size_t(manager)];
notice.badge_fallback=original_badge_fallback(club,&exe_);
if(!notice.badge_fallback&&club>=0&&size_t(club)*2+2<=next.state.club_heap_78.size())
notice.badge_sprite=(int(next.state.club_heap_78[size_t(club)*2])|
int(next.state.club_heap_78[size_t(club)*2+1])<<8)&0x1ff;
else notice.badge_fallback=true;
result.warning=true;result.page=next.page;balance_draft_=std::move(next);return result;
}
next.page.pending_close=false;
next.page.identity.revision=revision+1;
next.page.identity.sequence=original_identity.sequence+1;
result.closed=true;result.page=next.page;
result.preparation=preparation_projection(next.state,revision+1);
ui::validate_preparation_context(result.preparation);
ui::DesktopScreen validate(data_directory_,result.preparation.desktop);
g_=std::move(next.state);game_=next.game;rand_=next.rand;club_modal_runtime_=std::move(next.runtime);
balance_draft_.reset();++revision;return result;
}
default: throw FormatError("balance: unsupported action");
}
const int calculator_x=next.page.calculator_x,calculator_y=next.page.calculator_y;
next.page.draft=draft;next.page.identity.sequence=identity.sequence+1;
next.page=ui::balance_from_game(next.state,draft,exe_,next.page.identity,next.page.underlay);
next.page.calculator_x=calculator_x;next.page.calculator_y=calculator_y;
apply_balance_source_style(next.page,next.state,next.runtime,exe_);
next.notice_gate={source_runtime_byte(next.state,next.runtime,exe_,::bmh::layout::CompactDialogFrame),
source_runtime_byte(next.state,next.runtime,exe_,::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField2),
source_runtime_byte(next.state,next.runtime,exe_,::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField)};
next.page.read_only_notice_enabled=next.notice_gate.enabled();
next.page.read_only_notice.compact_dialog_frame=next.notice_gate.compact_dialog_frame!=0;
next.page.close_notice.compact_dialog_frame=next.notice_gate.compact_dialog_frame!=0;
ui::BalanceScreen validate(data_directory_,next.page);
result.page=next.page;balance_draft_=std::move(next);return result;
} catch(const std::exception& e) {error=e.what();return {};}
}
std::optional<ui::LeaguePairingsState> CareerSession::open_league_pairings(
const ui::DeskRequest& request,uint64_t revision,std::string& error) {
error.clear();
if(league_family_teaminfo_active_||request.kind!=ui::DeskRequestKind::open_menu||request.menu_kind!=1||request.revision!=revision||
revision==std::numeric_limits<uint64_t>::max()||strengths_owner_||strengths_dispatch_active_||balance_draft_||balance_dispatch_active_||
top_scorers_owner_||top_scorers_dispatch_active_ || stadium_.block_expansion||other_games_owner_||other_games_dispatch_active_||league_pairings_draft_||league_pairings_dispatch_active_||
market_dispatch_active_||pending_offer_dispatch_active_||calendar_advance_active_||transfer_offer_editor_||
manager_join_||request.manager_slot<0||request.manager_slot>=4) {
error="pairings: stale, nested or unsupported opening";return std::nullopt;
}
try {
LeaguePairingsDraft next{g_,game_,rand_,club_modal_runtime_,club_modal_runtime_,{}, {},
save_stream(g_),rand_.seed(),game_.seed(),rand_.calls(),game_.calls()};
for(const auto& group:turn_driver_.groups)
next.original_active_groups.emplace_back(group.desc,group.fixtures);
next.original_referee_profiles=turn_driver_.referees;
next.owner=open_league_pairings_source(next.state,request.manager_slot,ui::league_pairings_constants(exe_));
next.active_packet=validate_normal_pairings_group(next.state,next.owner,next.runtime);
const uint64_t scope=++league_pairings_scope_;
auto page=ui::league_pairings_from_game(next.state,next.owner,exe_,revision,scope,0,next.active_packet);
ui::LeaguePairingsScreen validate(data_directory_,page);
next.identity=page.identity;
next.runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(next.owner.league));
pairings_runtime_draw(next.state,next.runtime,page,exe_);
league_pairings_draft_=std::move(next);return page;
} catch(const std::exception& e) {error=e.what();return std::nullopt;}
}
std::optional<LeaguePairingsActivePacket> CareerSession::validate_normal_pairings_group(
const GameState& state,LeaguePairingsOwner& owner,
const std::map<uint32_t,uint8_t>& runtime) const {
//Sample synthesizes event8 only for a running process timer. These globals
//are not serialized Native pointers. The normal port starts them at zero.
const auto byte=[&](uint32_t address) {if(state.memory.has(address))return state.memory.u8(address);
const auto at=runtime.find(address);return at==runtime.end()?uint8_t(0):at->second;};
const unsigned duration=byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField);
const uint32_t started=uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField2))|(uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField3))<<8)|
(uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField4))<<16)|(uint32_t(byte(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField5))<<24);
if(duration<200&&started!=0)
throw FormatError("pairings: active process timer presentation is not implemented");
auto packet=league_pairings_active_packet_source(state,owner,turn_driver_.groups,turn_driver_.referees);
owner.active_group=packet?packet->group_index:-1;
if(!packet)owner.active_phase=false;
if(packet)validate_league_pairings_active_packet_source(state,owner,*packet);
return packet;
}
std::optional<CareerSession::LeaguePairingsDispatch> CareerSession::dispatch_league_pairings(
const ui::LeaguePairingsRequest& request,uint64_t& revision,std::string& error,
const TransferOfferTeamInfoPresenter& team_info) {
if (league_family_teaminfo_active_ || balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
const auto live_matches=[&] {
if(!league_pairings_draft_)return false;
const auto& d=*league_pairings_draft_;
if(d.original_active_groups.size()!=turn_driver_.groups.size()||
d.original_referee_profiles!=turn_driver_.referees)return false;
for(size_t n=0;n<turn_driver_.groups.size();++n)
if(d.original_active_groups[n].first!=turn_driver_.groups[n].desc||
d.original_active_groups[n].second!=turn_driver_.groups[n].fixtures)return false;
return revision==d.identity.revision&&save_stream(g_)==d.original_stream&&
rand_.seed()==d.original_rand_seed&&game_.seed()==d.original_game_seed&&
rand_.calls()==d.original_rand_calls&&game_.calls()==d.original_game_calls&&
club_modal_runtime_==d.original_runtime;
};
if(balance_draft_||balance_dispatch_active_||!league_pairings_draft_||league_pairings_dispatch_active_||top_scorers_owner_||top_scorers_dispatch_active_||other_games_owner_||other_games_dispatch_active_||market_dispatch_active_||
pending_offer_dispatch_active_||calendar_advance_active_||
request.identity!=league_pairings_draft_->identity||!live_matches()||
request.identity.sequence==std::numeric_limits<uint64_t>::max()||
revision==std::numeric_limits<uint64_t>::max()) {
error="pairings: stale or nested family action";return std::nullopt;
}
if(request.event.kind==LeaguePairingsAction::team_info&&!team_info) {
error="pairings: TeamInfo presenter unavailable";return std::nullopt;
}
auto next=*league_pairings_draft_;
league_pairings_dispatch_active_=true;
struct Reset {bool& value;~Reset(){value=false;}} reset{league_pairings_dispatch_active_};
try {
auto bound_owner=next.owner;
const auto bound_packet=validate_normal_pairings_group(next.state,bound_owner,next.runtime);
if(bound_packet!=next.active_packet||bound_owner.active_phase!=next.owner.active_phase||
bound_owner.active_group!=next.owner.active_group)
throw FormatError("pairings: stale staged active presentation packet");
next.owner=edit_league_pairings_source(next.state,next.owner,request.event,
ui::league_pairings_constants(exe_),next.game,next.rand);
if(request.event.kind==LeaguePairingsAction::computer_tip) {
const auto put_scratch=[&](uint32_t address,uint8_t value) {
if(next.state.memory.has(address))next.state.memory.set8(address,value);
else next.runtime[address]=value;
};
// ComputeLeagueTableForecast's final 17295(0x3fc) clears the strength scratch before
// the ordinary list redraw repopulates it from visible away rows.
put_scratch(::bmh::layout::CareerSession_FormatError_ExecutableField3,0);put_scratch(::bmh::layout::CareerSession_FormatError_ExecutableField4,0);
}
if(!next.owner.closed)next.active_packet=validate_normal_pairings_group(next.state,next.owner,next.runtime);
if(request.event.kind==LeaguePairingsAction::team_info) {
const auto parent=ui::league_pairings_from_game(next.state,next.owner,exe_,revision,
next.identity.scope,next.identity.sequence,next.active_packet);
auto services=staged_club_modal_services(next.state,next.game,next.rand,next.runtime);
if(!team_info(services,request.event.value,ui::LeaguePairingsScreen(data_directory_,parent).render())) {
error="pairings: TeamInfo presenter stopped";return std::nullopt;
}
const auto returned_packet=validate_normal_pairings_group(next.state,next.owner,next.runtime);
if(returned_packet!=next.active_packet)
throw FormatError("pairings: active presentation packet changed during TeamInfo");
}
if(!live_matches()) {error="pairings: live state changed during modal";return std::nullopt;}
LeaguePairingsDispatch result;result.closed=next.owner.closed;
if(result.closed) {
result.preparation=preparation_projection(next.state,revision+1);
ui::validate_preparation_context(result.preparation);
ui::DesktopScreen validate(data_directory_,result.preparation.desktop);
// Move returns with event8;53435 stirs once and leaves.
next.runtime[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2]=8;
g_=std::move(next.state);game_=next.game;rand_=next.rand;club_modal_runtime_=std::move(next.runtime);
league_pairings_draft_.reset();++revision;
} else {
result.page=ui::league_pairings_from_game(next.state,next.owner,exe_,revision,
next.identity.scope,next.identity.sequence+1,next.active_packet);
ui::LeaguePairingsScreen validate(data_directory_,result.page);
pairings_runtime_draw(next.state,next.runtime,result.page,exe_);
next.identity=result.page.identity;league_pairings_draft_=std::move(next);
}
return result;
} catch(const std::exception& e) {error=e.what();return std::nullopt;}
}
namespace {
ui::OutgoingTransferEditorState transfer_offer_projection(const GameState& game,
const TransferOfferEditorState& owner, uint64_t revision, bool gradient) {
ui::OutgoingTransferEditorState out;
const auto& request = owner.request;
out.manager_slot = request.manager; out.runtime_club = request.runtime_club;
out.revision = revision; out.list_entry = request.list_entry; out.source_slot = request.source_slot;
out.player = request.expected_player;
out.seller = request.expected_seller_word == 0xffff ? 0x0fff : request.expected_seller_word & 0x7fff;
out.bid_slot = owner.bid_slot; out.source_mode = owner.mode;
out.editable = owner.editable; out.closed = owner.closed; out.quote_loan = owner.quote_loan;
out.initial_action_loan = request.loan;
out.gradient_text = gradient;
out.fee = owner.fee; out.monthly_salary = owner.salary; out.duration_years = owner.years;
out.bonuses = owner.bonuses;
const auto copy_profile = [](const TransferOfferInputProfile& p) {
return ui::OutgoingTransferCalculatorProfile{p.supported, p.currency, p.minimum, p.maximum,
p.initial, p.source_text_address, p.presets};
};
for (size_t n = 0; n < 2; ++n) out.money_calculators[n] = copy_profile(owner.money_profiles[n]);
for (size_t n = 0; n < 8; ++n) out.mode3_calculators[n] = copy_profile(owner.mode3_profiles[n]);
if (owner.closed) return out; // No modal is constructed after Source cleanup.
ui::IncomingTransferDecisionView view;
view.source_outgoing_editor_context = true;
view.valid = true; view.list_entry = request.list_entry; view.player = out.player;
view.seller = out.seller; view.seller_manager = out.seller == 0x0fff ? -1 : game.manager_of(out.seller);
view.viewer_manager = request.manager;
view.asking_fee = owner.asking_fee; view.asking_monthly_salary = owner.asking_salary;
view.quoted_fee = owner.quoted_fee; view.quoted_monthly_salary = owner.quoted_salary;
view.quoted_years = owner.years;
const uint32_t list = ::bmh::layout::EditorList + uint32_t(request.list_entry) * 0x58;
for (uint32_t n = 0; n < 4; ++n) {
auto& row = view.offers[n];
const auto buyer = game.memory.u16(list + n * 2);
row.bid_index = int(n); row.present = buyer != 0xffff;
row.buyer = row.present ? int(buyer) : -1;
row.buyer_manager = row.present ? game.manager_of(row.buyer) : -1;
row.fee = game.memory.u32(list + 0x1c + n * 4);
row.monthly_salary = game.memory.u32(list + 0x0c + n * 4);
const auto raw_term = game.memory.u8(list + 0x34 + n);
row.loan = (raw_term & 0x80) != 0; row.contract_months = raw_term & 0x7f;
row.eligible = row.present;
for (uint32_t k = 0; k < 7; ++k) row.bonuses[k] = game.memory.u8(list + 0x38 + n * 7 + k);
}
out.panel = ui::incoming_transfer_decision_from_game(game, view);
return out;
}
}
ui::OutgoingTransferEditorState loan_return_offer_editor_projection(
const GameState& game, const TransferOfferEditorState& owner, uint64_t revision, bool gradient) {
return transfer_offer_projection(game, owner, revision, gradient);
}
TransferOfferEditorState edit_transfer_offer_from_ui(GameState& game,
const TransferOfferEditorState& owner, const ui::OutgoingTransferRequest& request,
GameRandom& game_random, WatcomRandom& watcom_random) {
return edit_transfer_offer_editor_source(game, owner,
{TransferOfferEditorField(uint8_t(request.field)), request.value, request.accepted},
game_random, watcom_random);
}
std::optional<CareerSession::TransferOfferEditorDispatch> CareerSession::open_transfer_offer(
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (request.kind != ui::TransferMarketRequestKind::open_offer || transfer_offer_editor_ ||
market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.manager_slot < 0 || request.manager_slot >= 4 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] ||
request.bid.manager != request.manager_slot || request.bid.list_entry < 0 || request.bid.list_entry >= 40 ||
request.bid.source_slot != 2928 + request.bid.list_entry || request.selected_players.size() > 1) {
error = "transfer offer: stale, nested or unsupported marked opening";
return std::nullopt;
}
const uint32_t list = ::bmh::layout::EditorList + uint32_t(request.bid.list_entry) * 0x58;
if (!g_.memory.has(list + 0x57)) { error = "transfer offer: missing Native list row"; return std::nullopt; }
const uint16_t seller_word = g_.memory.u16(list + 8);
if (!request.selected_players.empty()) {
const auto& selected = request.selected_players.front();
const int seller = seller_word == 0xffff ? -1 : int(seller_word & 0x7fff);
if (selected.squad_row != -1 || selected.source_slot != request.bid.source_slot ||
selected.list_entry != request.bid.list_entry || selected.player != request.bid.player ||
selected.seller != seller) {
error = "transfer offer: selected row does not match the Native market identity";
return std::nullopt;
}
}
int bid_slot = -1;
for (int n = 0; n < 4; ++n) {
const auto buyer = g_.memory.u16(list + uint32_t(n) * 2);
if (buyer == 0xffff || buyer == request.runtime_club) { bid_slot = n; break; }
}
const TransferOfferEditorRequest input{request.manager_slot, request.runtime_club, request.bid.list_entry,
request.bid.source_slot, request.bid.player, seller_word, bid_slot, request.offer_is_loan};
auto next_state = g_; auto next_game = game_; auto next_rand = rand_;
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
auto owner = open_transfer_offer_editor_source(next_state, input, next_game, next_rand);
if (!owner.supported) { error = owner.reason; return std::nullopt; }
// Opening has Source G-seeding/G92..108 even for a full read-only list.
const auto next_revision = revision + 1;
TransferOfferEditorDispatch result;
result.preparation = preparation_projection(next_state, next_revision);
result.editor = transfer_offer_projection(next_state, owner, next_revision, result.preparation.desktop.gradient_text);
ui::OutgoingTransferScreen validate(data_directory_, result.editor);
g_ = std::move(next_state); game_ = next_game; rand_ = next_rand;
transfer_offer_editor_ = std::move(owner); transfer_offer_revision_ = next_revision; revision = next_revision;
return result;
} catch (const std::exception& e) { error = e.what(); return std::nullopt; }
}
std::optional<CareerSession::PoachDispatch> CareerSession::open_poach(
int manager_slot, int squad_slot, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
revision == std::numeric_limits<uint64_t>::max() || manager_slot < 0 || manager_slot >= 4 ||
size_t(manager_slot) >= g_.manager_teams.size() || !g_.memory.has(::bmh::layout::ActiveManager) ||
g_.memory.u8(::bmh::layout::ActiveManager) != manager_slot) {
error = "poach: stale, nested or unsupported opening";
return std::nullopt;
}
auto next_state = g_; auto next_game = game_; auto next_rand = rand_;
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
PoachDispatch result;
result.start = start_poach(next_state, manager_slot, squad_slot, next_rand);
if (result.start.status == PoachStatus::ready) {
const int row = 0x28 + result.start.offer_row;
const TransferOfferEditorRequest input{manager_slot, g_.manager_teams[size_t(manager_slot)], row, 2928 + row,
result.start.player, next_state.memory.u16(::bmh::layout::EditorList + uint32_t(row) * 0x58 + 8), 0, false, true};
auto owner = open_transfer_offer_editor_source(next_state, input, next_game, next_rand);
if (!owner.supported) { error = owner.reason; return std::nullopt; }
const auto next_revision = revision + 1;
TransferOfferEditorDispatch editor;
editor.preparation = preparation_projection(next_state, next_revision);
editor.editor = transfer_offer_projection(next_state, owner, next_revision, editor.preparation.desktop.gradient_text);
result.editor = std::move(editor);
transfer_offer_editor_ = std::move(owner);
transfer_offer_revision_ = next_revision;
poach_ = result.start;
revision = next_revision;
} else if (result.start.status != PoachStatus::invalid) {
++revision; // draws, and "Transfermarkt überlastet" counts the attempt
}
g_ = std::move(next_state); game_ = next_game; rand_ = next_rand;
return result;
} catch (const std::exception& e) { error = e.what(); return std::nullopt; }
}
bool CareerSession::close_poach_table_selection(const ui::LeagueFamilyRequest& request,std::string& error) {
error.clear();
if(!poach_table_selection_ || request.kind!=ui::LeagueFamilyRequestKind::close || request.from_child!=1 ||
!canonical_table_envelope(request) || !league_family_owner_ || league_family_owner_->child!=1 ||
league_family_owner_->identity!=request.identity || !league_family_owner_->table ||
league_family_owner_->table->phase!=TableDispatchPhase::ready ||
save_stream(g_)!=league_family_owner_->native || club_modal_runtime_!=league_family_owner_->runtime ||
game_.seed()!=league_family_owner_->game_seed || game_.calls()!=league_family_owner_->game_calls ||
rand_.seed()!=league_family_owner_->rand_seed || rand_.calls()!=league_family_owner_->rand_calls) {
error="poach: stale Table selection close";return false;
}
const uint32_t at=::bmh::layout::LeagueTableDisplayModes+uint32_t(request.identity.manager)*2;
uint16_t word=uint16_t(g_.memory.u16(at)&0x0f7f);
if(source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField)!=0)word|=0x80;
g_.memory.set16(at,word);
if(g_.memory.has(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2))g_.memory.set8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2,0);else club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2]=0;
// FriendlyMatchScreen returns directly to19c1c. No21213 family close.
league_family_owner_.reset();return true;
}
bool CareerSession::dispatch_poach_ui(const ui::TransferMarketRequest& request,
const Image& backdrop, const PoachPlayerSelector& select, const PoachUiAccept& accept,
uint64_t& revision, std::string& error) {
error.clear();
if (!accept || request.kind!=ui::TransferMarketRequestKind::open_poach ||
!g_.memory.has(::bmh::layout::GameMode) || g_.memory.u8(::bmh::layout::GameMode)!=3 ||
request.revision!=revision || revision==UINT64_MAX || request.manager_slot<0 || request.manager_slot>3 ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager)!=request.manager_slot ||
size_t(request.manager_slot)>=g_.manager_teams.size() ||
request.runtime_club!=g_.manager_teams[size_t(request.manager_slot)] ||
request.bid.manager!=request.manager_slot || request.bid.list_entry!=-1 || request.bid.player!=-1 ||
request.bid.source_slot!=-1 || request.bid.fee!=0 || request.bid.annual_salary!=0 ||
request.bid.contract_years!=1 || request.bid.poach || std::any_of(request.bid.bonuses.begin(),request.bid.bonuses.end(),
[](uint32_t n){return n!=0;}) || request.squad_row!=-1 || request.expected_player!=-1 ||
request.preview_source_slot!=-1 || request.preview_seller!=-1 || request.preview_is_purchase ||
request.preview_is_loan || !request.selected_players.empty() ||
backdrop.width!=320 || backdrop.height!=240 || advertising_renewal_dispatch_active_ || pending_offer_dispatch_active_ || market_dispatch_active_ ||
calendar_advance_active_ || transfer_offer_editor_ || poach_ || manager_join_ || contract_quote_ ||
league_family_owner_ || league_pairings_draft_ || strengths_owner_ || top_scorers_owner_ ||
other_games_owner_ || balance_draft_ || stadium_.opened ||
(turn_driver_.stage!=TurnDriver::Stage::MatchdayDesks && turn_driver_.stage!=TurnDriver::Stage::SeasonEndDesk)) {
error="poach: stale or competing selection";return false;
}
const auto checkpoint=advertising_session_checkpoint(revision);
try {
const int manager=request.manager_slot;
const size_t record=size_t(manager)*0xb0c;
PoachDispatch result;
result.start.manager=manager;
// These three notices precede the Table modal in Reset.
if (record+0x8c0>g_.manager_records.size()) throw FormatError("poach: missing manager record");
const bool attempts_used=(g_.manager_records[record+0x8be] |
uint16_t(g_.manager_records[record+0x8bf])<<8)!=0xffff;
if(attempts_used) {
result.start.status=PoachStatus::attempts_used;
result.start.messages.push_back(message_text(g_,::bmh::layout::CareerSession_DispatchPoachUi_TextPointer2));
} else if(g_.manager_records[record+0x220]>>5==1) {
result.start.status=PoachStatus::transfer_ban;
result.start.messages.push_back(message_text(g_,::bmh::layout::CareerSession_DispatchPoachUi_TextPointer));
} else if(request.offer_is_loan) {
auto services=staged_club_modal_services(g_,game_,rand_,club_modal_runtime_);
services.set_runtime_byte(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField,0);
services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2,g_.manager_records[record+0x210]);
services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField,2);
result.start.messages.push_back(message_text(g_,::bmh::layout::CareerSession_DispatchPoachUi_TextPointer3));
} else {
if(!select) throw FormatError("poach: Source player selection presenter unavailable");
// The cloned Session owns the existing50775 controls implementation.
// begin_league_family(child1) itself does not call53435; only the
// host Table owner is reused, never prepare/close-family effects.
CareerSession staged=*this;
staged.poach_table_selection_=true;
uint64_t selection_revision=revision;
auto services=staged.staged_club_modal_services(staged.g_,staged.game_,staged.rand_,staged.club_modal_runtime_);
services.set_runtime_byte(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField,0);
services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2,g_.manager_records[record+0x210]);
services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField,2);
services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField,0);services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2,0);
//50775 control7 toggles this existing BSS byte. Materialize its
// actual current value in the staged runtime, including when it
// was read from the executable rather than persisted in Native.
services.set_runtime_byte(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField,services.runtime_byte(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField));
auto entry=staged.strengths_open_request(selection_revision);
if(!entry)throw FormatError("poach: missing Table selection identity");
entry->identity.league=g_.manager_records[record+0x210];entry->identity.league_group=0;
if(!staged.begin_league_family(entry->identity,1,selection_revision,error))throw FormatError(error);
market_dispatch_active_=true;
const auto live_baseline=advertising_session_checkpoint(revision);
const auto selection=select(staged,services,manager,selection_revision,backdrop);
if(!advertising_session_unchanged(live_baseline,revision))
throw FormatError("poach: selection changed the live session");
auto& next=staged.g_;
if(next.date!=g_.date || next.manager_teams!=g_.manager_teams ||
!next.memory.has(::bmh::layout::ActiveManager) || next.memory.u8(::bmh::layout::ActiveManager)!=manager)
throw FormatError("poach: selection changed its manager/calendar context");
market_dispatch_active_=false;
int slot=-1;
if(selection) {
if(selection->origin!=ClubPlayerDetailOrigin::squad || selection->human_loan_index!=-1)
throw FormatError("poach: selection is not an ordinary squad row");
const auto player=club_player_detail_context(next,*selection);
slot=player.source_slot;
if(slot<0 || slot>=0xb70 || slot_team(slot)!=selection->runtime_team ||
(next.squad_slots.at(size_t(slot))&0xfff)!=selection->player_id)
throw FormatError("poach: stale player selection");
}
// Preserve actual Table/ClubInfo/card effects, including a cancelled
// selection. No LeagueScreenShown entry and no family-close RNG stir.
g_=std::move(next);game_=staged.game_;rand_=staged.rand_;club_modal_runtime_=std::move(staged.club_modal_runtime_);
if(selection) {
auto opened=open_poach(manager,slot,revision,error);
if(!opened) throw FormatError(error);
result=std::move(*opened);
}
if(revision==checkpoint.revision) ++revision;
}
const auto accepted_baseline=advertising_session_checkpoint(revision);
accept(result,preparation_projection(revision));
if(!advertising_session_unchanged(accepted_baseline,revision))
throw FormatError("poach: UI acknowledgement changed the session");
return true;
} catch(const std::exception& e) {
restore_advertising_session_checkpoint(checkpoint);revision=checkpoint.revision;
error=e.what();return false;
}
}
std::optional<CareerSession::TransferOfferEditorDispatch> CareerSession::dispatch_transfer_offer(
const ui::OutgoingTransferRequest& request, const HumanBuyerSaleHooks& presenters,
uint64_t& revision, std::string& error,
const TransferOfferTeamInfoPresenter& team_info,
const TransferOfferPlayerInfoPresenter& player_info) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (!transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.identity.revision != revision || transfer_offer_revision_ != revision ||
revision == std::numeric_limits<uint64_t>::max()) {
error = "transfer offer: stale or nested editor event"; return std::nullopt;
}
const auto& current = *transfer_offer_editor_;
const auto& id = request.identity;
const int seller = current.request.expected_seller_word == 0xffff ? 0x0fff : current.request.expected_seller_word & 0x7fff;
if (id.manager_slot != current.request.manager || id.runtime_club != current.request.runtime_club ||
id.list_entry != current.request.list_entry || id.source_slot != current.request.source_slot ||
id.player != current.request.expected_player || id.seller != seller || id.bid_slot != current.bid_slot ||
request.quoted_fee != current.quoted_fee || request.quoted_monthly_salary != current.quoted_salary ||
request.quoted_years != current.years) {
error = "transfer offer: mismatched editor identity or quote"; return std::nullopt;
}
uint32_t fee = current.fee, salary = current.salary;
uint8_t years = current.years; auto bonuses = current.bonuses;
bool quote_loan = current.quote_loan;
const unsigned field = unsigned(request.field);
if (request.kind == ui::OutgoingTransferRequestKind::quote_change) {
if (field > unsigned(ui::OutgoingTransferField::quote_loan)) {
error = "transfer offer: invalid editor field"; return std::nullopt;
}
if (request.accepted) {
if (field == 0) fee = request.value;
else if (field == 1) salary = request.value;
else if (field == 2) years = uint8_t(request.value);
else if (field < 10) bonuses[field - 3] = uint8_t(field < 6 ? request.value : request.value / 5);
else quote_loan = !quote_loan;
}
} else if (request.kind != ui::OutgoingTransferRequestKind::submit && request.kind != ui::OutgoingTransferRequestKind::cancel &&
request.kind != ui::OutgoingTransferRequestKind::team_info &&
request.kind != ui::OutgoingTransferRequestKind::player_info) {
error = "transfer offer: unsupported editor event"; return std::nullopt;
}
if (request.fee != fee || request.monthly_salary != salary || request.duration_years != years ||
request.bonuses != bonuses || request.quote_loan != quote_loan) {
error = "transfer offer: posted row differs from the single Source field event"; return std::nullopt;
}
if(request.kind==ui::OutgoingTransferRequestKind::team_info&&!team_info) {
error="transfer offer: TeamInfo presenter unavailable"; return std::nullopt;
}
if(request.kind==ui::OutgoingTransferRequestKind::player_info&&!player_info) {
error="transfer offer: PlayerInfo presenter unavailable"; return std::nullopt;
}
auto next_state = g_; auto next_game = game_; auto next_rand = rand_;
auto next_runtime=club_modal_runtime_;
auto owner = current; TransferActionResult action;
auto hooks = presenters;
switch (turn_driver_.transfer_allocator_context) {
case PendingOfferAllocatorGate::zero: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::zero; break;
case PendingOfferAllocatorGate::blocked: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::blocked; break;
default: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::unsupported; break;
}
hooks.direct_mode = HumanBuyerSaleDirectMode::ordinary_ai_purchase;
hooks.before_accounts = {}; hooks.after_paid_accounts = {};
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
if (request.kind == ui::OutgoingTransferRequestKind::quote_change) {
owner = edit_transfer_offer_from_ui(next_state, current, request, next_game, next_rand);
} else if (request.kind == ui::OutgoingTransferRequestKind::cancel) {
owner = cancel_transfer_offer_editor_source(next_state, current);
} else if(request.kind==ui::OutgoingTransferRequestKind::team_info) {
// Validate the complete old Native row before any modal effect.
const auto validation=cancel_transfer_offer_editor_source(next_state,current);
if(!validation.supported) {error=validation.reason;return std::nullopt;}
auto services=staged_club_modal_services(next_state,next_game,next_rand,next_runtime);
const auto parent=transfer_offer_projection(next_state,current,revision,
next_state.memory.u8(::bmh::layout::TextGradientDisabled)==0);
const Image backdrop=ui::OutgoingTransferScreen(data_directory_,parent).render();
if(!team_info(services,current.request.runtime_club,backdrop)) {
error="transfer offer: TeamInfo presenter stopped";return std::nullopt;
}
owner=resume_transfer_offer_team_info_source(next_state,current,next_rand);
} else if(request.kind==ui::OutgoingTransferRequestKind::player_info) {
const auto selection=transfer_offer_player_info_selection_source(next_state,current);
auto services=staged_club_modal_services(next_state,next_game,next_rand,next_runtime);
const auto parent=transfer_offer_projection(next_state,current,revision,
next_state.memory.u8(::bmh::layout::TextGradientDisabled)==0);
const Image backdrop=ui::OutgoingTransferScreen(data_directory_,parent).render();
services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField,1); // Source direct entry persists, unlike4f548.
if(!player_info(services,selection,backdrop)) {
error="transfer offer: PlayerInfo presenter stopped";return std::nullopt;
}
owner=resume_transfer_offer_player_info_source(next_state,current,
services.runtime_byte(::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField),services.runtime_byte(::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField2),next_rand);
} else {
MinuteReport report;
auto submitted = submit_transfer_offer_editor_source(next_state, current, next_rand, hooks, report);
owner = std::move(submitted.editor); action = submitted.action;
if (report.unsupported) { error = report.reason; return std::nullopt; }
}
if (!owner.supported) { error = owner.reason; return std::nullopt; }
// a poaching editor that closes frees its special row and counts the attempt (Reset)
if (owner.closed && poach_) finish_poach(next_state, *poach_);
const bool changed = save_stream(next_state) != save_stream(g_) || next_runtime != club_modal_runtime_ ||
next_game.seed() != game_.seed() || next_game.calls() != game_.calls() ||
next_rand.seed() != rand_.seed() || next_rand.calls() != rand_.calls();
const auto next_revision = revision + uint64_t(changed);
TransferOfferEditorDispatch result;
result.preparation = preparation_projection(next_state, next_revision);
result.editor = transfer_offer_projection(next_state, owner, next_revision, result.preparation.desktop.gradient_text);
result.action = action;
if (!owner.closed) { ui::OutgoingTransferScreen validate(data_directory_, result.editor); }
g_ = std::move(next_state); game_ = next_game; rand_ = next_rand;
club_modal_runtime_=std::move(next_runtime);
if (owner.closed) { transfer_offer_editor_.reset(); poach_.reset(); } else transfer_offer_editor_ = std::move(owner);
transfer_offer_revision_ = next_revision; revision = next_revision;
return result;
} catch (const std::exception& e) { error = e.what(); return std::nullopt; }
}
std::optional<CareerSession::TransferMarketPreviewDispatch> CareerSession::preview_transfer_market(
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (request.kind != ui::TransferMarketRequestKind::preview_quote ||
transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.manager_slot < 0 || request.manager_slot >= 4 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)]) {
error = "transfer market: stale or nested preview";
return std::nullopt;
}
if (request.preview_is_purchase) {
if (request.preview_snapshot_index != -1 || request.squad_row != -1 || request.bid.manager != request.manager_slot ||
request.bid.list_entry < 0 || request.bid.list_entry >= 40 ||
request.bid.source_slot != request.preview_source_slot ||
request.preview_source_slot != 0xb70 + request.bid.list_entry ||
request.bid.player != request.expected_player) {
error = "transfer market: mismatched preview listing identity";
return std::nullopt;
}
} else if (request.preview_snapshot_index >= 0) {
const auto identity = transfer_market_snapshot_preview(g_, request.manager_slot,
request.runtime_club, request.preview_snapshot_index);
if (!identity || identity->displayed_row != request.squad_row || identity->player != request.expected_player ||
identity->source_slot != request.preview_source_slot || request.preview_seller != request.runtime_club) {
error = "transfer market: mismatched lender snapshot identity";
return std::nullopt;
}
} else {
const auto range = squad_range(request.runtime_club);
if (request.preview_snapshot_index != -1 || request.squad_row < 0 || size_t(request.squad_row) >= range.count ||
request.preview_source_slot != int(range.first + size_t(request.squad_row)) ||
request.preview_seller != request.runtime_club) {
error = "transfer market: mismatched preview roster identity";
return std::nullopt;
}
}
auto next_rand = rand_;
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
const TransferMarketPreviewRequest input{request.manager_slot, request.runtime_club,
request.preview_source_slot, request.expected_player, request.preview_seller,
request.preview_is_purchase, request.preview_is_loan, request.preview_snapshot_index};
const auto result = quote_transfer_market_preview_source(g_, input, next_rand);
if (!result.supported) {
error = result.reason.empty() ? "transfer market: unsupported Source preview" : result.reason;
return std::nullopt;
}
const bool changed = next_rand.seed() != rand_.seed() || next_rand.calls() != rand_.calls();
const auto next_revision = revision + uint64_t(changed);
TransferMarketPreviewDispatch dispatch;
dispatch.preparation = preparation_projection(next_revision);
if (!dispatch.preparation.transfer_market)
throw FormatError("transfer market: preview has no ordinary projection");
dispatch.quote = {request.manager_slot, request.runtime_club, request.preview_source_slot,
request.expected_player, request.preview_seller, next_revision,
result.delta, result.projected_balance, request.preview_is_purchase, request.preview_is_loan, request.preview_snapshot_index};
// Projection construction can throw. Keep the live W stream and revision
// unchanged until both the Source result and the projection are valid.
rand_ = next_rand;
revision = next_revision;
return dispatch;
} catch (const std::exception& e) {
error = e.what();
return std::nullopt;
}
}
std::optional<TransferActionResult> CareerSession::dispatch_transfer_market(
const ui::TransferMarketRequest& request, const HumanBuyerSaleHooks& presenters,
uint64_t& revision, std::string& error,
const std::function<int(const GameState&, const TransferOfferListView&)>& review) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.manager_slot < 0 || request.manager_slot >= 4 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)]) {
error = "transfer market: stale or nested request";
return std::nullopt;
}
if (request.kind == ui::TransferMarketRequestKind::review_offers) {
if (!review || request.bid.manager != request.manager_slot || request.bid.list_entry < 0 ||
request.bid.list_entry >= 40 || request.bid.source_slot != 0xb70 + request.bid.list_entry ||
request.squad_row != -1 || !request.selected_players.empty()) {
error = "transfer market: invalid offer review"; return std::nullopt;
}
const auto view = project_transfer_offer_list(g_, request.bid.list_entry);
if (!view.valid || view.player != request.bid.player || view.seller != request.runtime_club ||
view.seller_manager != request.manager_slot) {
error = "transfer market: stale seller listing"; return std::nullopt;
}
} else if (request.kind == ui::TransferMarketRequestKind::submit_bid) {
if (request.bid.manager != request.manager_slot || request.squad_row != -1 ||
request.expected_player != -1 ||
std::any_of(request.bid.bonuses.begin(), request.bid.bonuses.end(),
[](uint32_t value) { return value > 255; })) {
error = "transfer market: invalid buyer request";
return std::nullopt;
}
} else if (request.kind == ui::TransferMarketRequestKind::list_player) {
const auto range = squad_range(request.runtime_club);
if (request.squad_row < 0 || size_t(request.squad_row) >= range.count ||
range.first + size_t(request.squad_row) >= g_.squad_slots.size() ||
request.expected_player < 0 || request.expected_player >= 0xfff ||
(g_.squad_slots[range.first + size_t(request.squad_row)] & 0xfff) != request.expected_player) {
error = "transfer market: stale seller row";
return std::nullopt;
}
} else {
error = "transfer market: unsupported action";
return std::nullopt;
}
// Reset sends an owned marked player through the same Size2
// listing for both VER-KAUFEN and VER-LEIHEN. Only a buyer's OpenTransferEditor
// offer owns the actual loan term; listing does not create a loan record.
if ((request.offer_is_loan && request.kind != ui::TransferMarketRequestKind::list_player) ||
request.selected_players.size() > 1) {
error = "transfer market: this caller does not own buyer loan or marked batch processing";
return std::nullopt;
}
if (!request.selected_players.empty()) {
const auto& selected = request.selected_players.front();
const bool matches = request.kind == ui::TransferMarketRequestKind::list_player
? selected.squad_row == request.squad_row && selected.player == request.expected_player &&
selected.seller == request.runtime_club &&
selected.source_slot == int(squad_range(request.runtime_club).first + size_t(request.squad_row))
: selected.list_entry == request.bid.list_entry && selected.source_slot == request.bid.source_slot &&
selected.player == request.bid.player && selected.squad_row == -1;
if (!matches) {
error = "transfer market: mismatched marked selection";
return std::nullopt;
}
}
auto next_state = g_;
auto next_game = game_;
auto next_rand = rand_;
auto hooks = presenters;
// A presenter cannot supply the allocator gate or insert the special
// pending caller's severance/ACK/news sequence into a direct purchase.
switch (turn_driver_.transfer_allocator_context) {
case PendingOfferAllocatorGate::zero: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::zero; break;
case PendingOfferAllocatorGate::blocked: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::blocked; break;
default: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::unsupported; break;
}
// Reset -> OpenTransferEditor establishes DeskActions_EditorFail_RuntimeField2=0 at LAB1b67e before
// resolving the AI seller. This explicitly selected App entry supplies
// that transient ownership; a missing FBM byte is never the observation.
hooks.direct_mode = HumanBuyerSaleDirectMode::ordinary_ai_purchase;
hooks.before_accounts = {};
hooks.after_paid_accounts = {};
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
MinuteReport report;
try {
const auto before = save_stream(g_);
TransferActionResult result;
if (request.kind == ui::TransferMarketRequestKind::review_offers) {
const auto view = project_transfer_offer_list(next_state, request.bid.list_entry);
const int selected = view.offer_count ? review(next_state, view) : -1;
result.player = view.player; result.list_entry = view.list_entry;
result.status = TransferActionStatus::pending;
if (selected != -1) {
auto allocator = TransferAllocatorContext::unsupported;
if (turn_driver_.transfer_allocator_context == PendingOfferAllocatorGate::zero)
allocator = TransferAllocatorContext::zero;
else if (turn_driver_.transfer_allocator_context == PendingOfferAllocatorGate::blocked)
allocator = TransferAllocatorContext::blocked;
result = accept_manager_transfer_offer(next_state, request.manager_slot,
view.list_entry, view.player, selected, next_rand, report, allocator);
}
} else if (request.kind == ui::TransferMarketRequestKind::list_player)
result = list_manager_player(next_state, request.manager_slot, request.squad_row, next_rand, report);
else
result = submit_transfer_bid_source_human_buyer(next_state, request.bid, next_rand, hooks, report);
if (report.unsupported || result.status == TransferActionStatus::unsupported) {
error = report.reason.empty() ? "transfer market: unsupported Source sale" : report.reason;
return std::nullopt;
}
const bool changed = save_stream(next_state) != before ||
next_rand.seed() != rand_.seed() || next_rand.calls() != rand_.calls() ||
next_game.seed() != game_.seed() || next_game.calls() != game_.calls();
if (changed) {
// Pure projections reject inconsistent squad/board/training state
// before any staged notice effects become live.
(void)ui::preparation_from_game(next_state, exe_, revision + 1);
g_ = std::move(next_state);
game_ = next_game;
rand_ = next_rand;
++revision;
}
return result;
} catch (const std::exception& e) {
error = e.what();
return std::nullopt;
}
}
bool CareerSession::finish(ui::CareerInitializationResult& result, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const bool previous_advance = calendar_advance_active_;
calendar_advance_active_ = true;
struct AdvanceReset { bool& active; bool previous; ~AdvanceReset() { active = previous; } }
advance_reset{calendar_advance_active_, previous_advance};
MinuteReport report;
career_managers_end(g_, false);
const auto season_pause = [this](const char* checkpoint) {
if (turn_driver_.season_pause) turn_driver_.season_pause(checkpoint, g_);
};
if (!career_season_setup(g_, game_, rand_, report, season_pause, turn_driver_.season_cup_draw) ||
!career_first_steps(g_, game_, rand_, report)) {
error = report.reason;
return false;
}
// DailyInterest's loop: the event of season day 0 (AdvanceTurn) and the first desk
std::vector<uint8_t> referees = db_.raw_referee_properties;
MatchdayContext ctx;
ctx.month = month_code(g_.date);
ctx.season_day = g_.season_day();
ctx.weekday = weekday_code(g_.date);
ctx.referees = &referees;
const uint16_t entry = g_.memory.u16(::bmh::layout::CompetitionCalendar + uint32_t(g_.season_day()) * 2);
std::vector<MatchGroup> groups = prepare_event(g_, entry, ctx, game_, rand_, report);
enter_event_desk(g_, 0, groups, game_, rand_, report, true, turn_driver_.desk_autosave);
if (report.unsupported) {
error = report.reason;
return false;
}
if (!begin_turn_driver(turn_driver_, g_, std::move(groups), entry, db_.raw_referee_properties,
session_id_, 1, error))
return false;
capture_source_desk_callargs();
// Both UI projections must reflect the freshly initialized driver cursor.
// Reuse its prepared groups; these projections do not prepare an event or draw RNG.
result.desktop = desktop_projection(1);
result.preparation = preparation_projection(1);
for (size_t m = 0; m < managers_.size(); ++m)
managers_[m].runtime_club = g_.manager_teams.at(m);
result.managers = managers_;
return true;
}
TurnAdvanceResult CareerSession::dispatch_kickoff(const ui::DeskRequest& request, uint64_t& revision,
std::string& error) {
error.clear();
if (strengths_owner_ || strengths_dispatch_active_ || balance_draft_ || balance_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_ || league_pairings_draft_ || league_pairings_dispatch_active_ || transfer_offer_editor_ || pending_offer_dispatch_active_ || market_dispatch_active_) {
error = "pending_offer_decision_active";
TurnAdvanceResult result;
result.kind = TurnDeskKind::Failed;
result.manager_slot = int(g_.memory.u8(::bmh::layout::ActiveManager));
result.date = g_.date;
result.revision = revision;
result.reason = error;
return result;
}
if (career_complete()) {
error = "career_complete";
TurnAdvanceResult result;
result.kind = TurnDeskKind::Failed;
result.manager_slot = -1;
result.date = g_.date;
result.revision = revision;
result.reason = error;
return result;
}
if (!saved_turn_error_.empty()) {
error = saved_turn_error_;
TurnAdvanceResult result;
result.kind = TurnDeskKind::Failed;
result.manager_slot = int(g_.memory.u8(::bmh::layout::ActiveManager));
result.date = g_.date;
result.revision = revision;
result.reason = error;
return result;
}
if (request.kind != ui::DeskRequestKind::advance_turn || request.revision != revision) {
error = "stale_manager_or_revision";
TurnAdvanceResult result;
result.kind = TurnDeskKind::Failed;
result.manager_slot = int(g_.memory.u8(::bmh::layout::ActiveManager));
result.date = g_.date;
result.revision = revision;
result.reason = error;
return result;
}
if (request.manager_slot != int(g_.memory.u8(::bmh::layout::ActiveManager))) {
error = "stale_manager_or_revision";
TurnAdvanceResult result;
result.kind = TurnDeskKind::Failed;
result.manager_slot = int(g_.memory.u8(::bmh::layout::ActiveManager));
result.date = g_.date;
result.revision = revision;
result.reason = error;
return result;
}
const auto remain_at_desk = [&](TurnDeskKind kind, std::string reason) {
if (reason.empty()) reason = "post-desk pending presenter stopped";
error = std::move(reason);
TurnAdvanceResult out;
out.kind = kind;
out.manager_slot = request.manager_slot;
out.date = g_.date;
out.revision = revision;
out.reason = error;
return out;
};
if (revision == std::numeric_limits<uint64_t>::max() ||
(turn_driver_.stage != TurnDriver::Stage::MatchdayDesks &&
turn_driver_.stage != TurnDriver::Stage::SeasonEndDesk))
return remain_at_desk(TurnDeskKind::Failed, "stale_or_exhausted_turn_cursor");
// Pending decisions and their cursor checks must complete together or
// restore the previous desk. Once simulation starts, its terminal failure
// cursor must stay claimed: external presentation cannot be rolled back.
struct KickoffTransaction {
CareerSession& session;
uint64_t& revision;
std::optional<AdvertisingSessionCheckpoint> before;
void restore() {
if (!before) return;
auto checkpoint = std::move(*before);
before.reset();
revision = checkpoint.revision;
session.restore_advertising_session_checkpoint(std::move(checkpoint));
}
~KickoffTransaction() { restore(); }
} transaction{*this, revision, advertising_session_checkpoint(revision)};
const auto stop_at_desk = [&](TurnDeskKind kind, std::string reason) {
transaction.restore();
return remain_at_desk(kind, std::move(reason));
};
const bool previous_advance = calendar_advance_active_;
calendar_advance_active_ = true;
struct AdvanceReset { bool& active; bool previous; ~AdvanceReset() { active = previous; } }
advance_reset{calendar_advance_active_, previous_advance};
if ((turn_driver_.stage == TurnDriver::Stage::MatchdayDesks ||
turn_driver_.stage == TurnDriver::Stage::SeasonEndDesk) &&
pending_offer_entry_policy_ == PendingOfferEntryPolicy::normal_interactive) {
// AdvanceTurn resolves this manager before the next desk or simulation.
// An unsupported decision must leave the driver unclaimed and retryable.
pending_offer_dispatch_active_ = true;
struct PendingReset { bool& active; ~PendingReset() { active = false; } }
pending_reset{pending_offer_dispatch_active_};
try {
const auto modal_baseline = advertising_session_checkpoint(revision);
auto next_state = g_;
auto next_game = game_;
auto next_rand = rand_;
const auto hooks = pending_hooks_for_dispatch(pending_offer_hooks_);
MinuteReport pending_report;
// Explicit supported interactive runtime policy, not reconstructed
// Original transient bytes or an answer inferred from missing data.
const PendingOfferDeskRequest pending_request{
PendingOfferDeskRuntimeMode::normal_interactive,
int(g_.manager_teams.size()), turn_driver_.manager_position};
// A nomination desk has one temporary national manager but retains
// the original order prefix. Its Source post-return owner can differ
// from the runtime desk owner, so ordinary permutation checks do not apply.
const auto pending = turn_driver_.national_nomination_desk
? process_national_nomination_pending_after_desk(
next_state, pending_request, next_game, next_rand, hooks, pending_report)
: process_natural_pending_offers_after_desk(
next_state, pending_request, next_game, next_rand, hooks, pending_report);
// This existing fingerprint covers Native and its qualified
// runtime/owners, RNG and revision, not arbitrary memory writes.
if (!advertising_session_unchanged(modal_baseline, revision) ||
turn_driver_.manager_position != modal_baseline.driver.manager_position ||
turn_driver_.revision != modal_baseline.driver.revision ||
turn_driver_.calendar_entry != modal_baseline.driver.calendar_entry)
return stop_at_desk(TurnDeskKind::Failed, "pending_offer_reentrant_state");
if (pending_report.unsupported || !pending.completed)
return stop_at_desk(TurnDeskKind::WaitingAtDesk,
pending_report.reason.empty() ? "post-desk pending decision incomplete" : pending_report.reason);
// Even a batch without owned offers performs Source's last-manager
// cleanup and completed-loop cursor write. No intermediate revision.
g_ = std::move(next_state);
game_ = next_game;
rand_ = next_rand;
} catch (const std::exception& e) {
return stop_at_desk(TurnDeskKind::WaitingAtDesk, e.what());
}
}
// Resolve names before advancing: next_event can reorder clubs at a season
// transition. The result view must keep the identities of the played event.
std::vector<std::string> names;
names.reserve(g_.club_ids.size());
for (size_t team = 0; team < g_.club_ids.size(); ++team)
names.push_back(ui::original_to_utf8(g_.club_name(int(team))));
const bool had_results = turn_driver_.last_results.valid;
const uint32_t previous_result_date = turn_driver_.last_results.date;
const uint32_t previous_day = g_.date;
const uint16_t previous_calendar_entry = turn_driver_.calendar_entry;
// Desk actions legitimately advance the app's projection revision between turns.
// Adopt that already-validated current revision before handing off the kickoff.
// AdvanceTurn(param1=1) skips only later pre-match offer generation in this
// already prepared loop. Legacy/headless callers retain their explicit path.
// Select it after a complete staged batch so Waiting cannot alter the cursor.
turn_driver_.suppress_remaining_pre_match_offers =
pending_offer_entry_policy_ == PendingOfferEntryPolicy::normal_interactive &&
turn_driver_.loaded_matchday_resume;
// Select the complete nomination-desk lifecycle only for the interactive
// controller, after the staged outgoing batch has completed successfully.
turn_driver_.enable_national_nomination_desks =
pending_offer_entry_policy_ == PendingOfferEntryPolicy::normal_interactive;
turn_driver_.revision = revision;
MinuteReport report;
// Contract expiry can also be reached by a headless/unpresented session.
// Keep the checkpoint from before the complete pending decision batch so a
// missing decision owner cannot commit its Native cursor cleanup or leave
// an expired player partially advanced.
std::optional<AdvertisingSessionCheckpoint> contract_expiry_checkpoint = transaction.before;
transaction.before.reset(); // claim the completed decision batch before simulation callbacks
turn_driver_.reality_rules = &exe_;
turn_driver_.sportschau_source = sportschau_source_options();
TurnAdvanceResult result = advance_to_next_desk(turn_driver_, g_,
TurnAdvanceRequest{request.manager_slot, request.revision}, game_, rand_, report);
if (result.kind == TurnDeskKind::Failed || result.kind == TurnDeskKind::WaitingAtDesk) {
if (contract_expiry_checkpoint && (result.reason.find("month change: a contract ends") != std::string::npos ||
result.reason.find("month change: human-owner loan record is incomplete") != std::string::npos ||
result.reason.find("month change: human-owner loan cannot be restored safely") != std::string::npos ||
result.reason.find("month change: expiring human-borrower loan") != std::string::npos ||
result.reason.find("month change: human-borrower loan return dialog") != std::string::npos ||
result.reason.find("month change: OpenTransferEditor return-offer editor") != std::string::npos)) {
const uint64_t checkpoint_revision = contract_expiry_checkpoint->revision;
restore_advertising_session_checkpoint(std::move(*contract_expiry_checkpoint));
revision = checkpoint_revision;
return remain_at_desk(result.kind, result.reason);
}
return stop_at_desk(result.kind, result.reason);
}
revision = result.revision;
if (g_.date != previous_day || turn_driver_.calendar_entry != previous_calendar_entry)
capture_source_desk_callargs();
lineup_entry_manager_ = -1;
lineup_entry_club_ = -1;
completed_results_.reset();
const auto& snapshot = turn_driver_.last_results;
if (snapshot.valid && !snapshot.groups.empty() &&
(!had_results || snapshot.date != previous_result_date)) {
completed_results_ = ui::matchday_results_from_snapshot(snapshot, [&](int team) {
const size_t id = size_t(team & 0x0fff);
return id < names.size() ? names[id] : std::string();
}, exe_, g_);
}
return result;
}
bool CareerSession::dispatch_mailbox(const ui::MailboxActionRequest& request, uint64_t& revision,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (active < 0 || active > 3 || size_t(active) >= g_.manager_teams.size() ||
request.manager_slot != active || request.revision != revision ||
revision == std::numeric_limits<uint64_t>::max()) {
error = "Diese Nachricht gehört zu einem veralteten Postfach.";
return false;
}
constexpr size_t entry_size = 0xa0, entries = 40;
if (request.entry_index < 0 || size_t(request.entry_index) >= entries ||
g_.mailbox.size() < entries * entry_size) {
error = "Diese Nachricht ist nicht mehr vorhanden.";
return false;
}
const size_t at = size_t(request.entry_index) * entry_size;
if (!std::equal(request.expected_entry.begin(), request.expected_entry.end(), g_.mailbox.begin() + at)) {
error = "Diese Nachricht wurde inzwischen geändert.";
return false;
}
const auto word = [&](size_t p) {
return uint32_t(g_.mailbox[p]) | uint32_t(g_.mailbox[p + 1]) << 8 |
uint32_t(g_.mailbox[p + 2]) << 16 | uint32_t(g_.mailbox[p + 3]) << 24;
};
const uint32_t bit = uint32_t(1) << active;
const uint32_t recipients = word(at), kept = word(at + 4);
if (!(recipients & bit)) {
error = "Diese Nachricht ist nicht an diesen Manager gerichtet.";
return false;
}
size_t target = at;
uint32_t value = recipients;
if (request.kind == ui::MailboxActionKind::toggle_keep) {
int count = 0;
for (size_t i = 0; i < entries; ++i)
if ((word(i * entry_size) & bit) && (word(i * entry_size + 4) & bit)) ++count;
// MailboxStateFromGame tests (recipient word + 1), NOT the kept word. Preserve
// its manager-specific five-entry exception, including blocked unkeep.
if (!((recipients + 1u) & bit) && count >= 5) {
error = "Die Originalgrenze für gemerkte Nachrichten ist erreicht.";
return false;
}
target += 4; value = kept ^ bit;
} else if (request.kind == ui::MailboxActionKind::delete_for_manager) {
if (kept & bit) {
error = "Diese Nachricht ist noch gemerkt.";
return false;
}
value = recipients ^ bit;
if (value == 0x80000000u) value = 0;
} else {
error = "Unbekannte Postfachaktion.";
return false;
}
for (size_t i = 0; i < 4; ++i) g_.mailbox[target + i] = uint8_t(value >> (8 * i));
++revision;
return true;
}
std::optional<ui::MailboxState> CareerSession::pending_mailbox_notification(uint64_t revision) const {
if (!g_.memory.has(::bmh::layout::ActiveManager)) return std::nullopt;
const int manager = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (manager < 0 || manager >= 4 || size_t(manager) >= g_.manager_teams.size() ||
g_.manager_teams[size_t(manager)] == kNoTeam || !g_.memory.has(::bmh::layout::MailboxRecipientMask) ||
(g_.memory.u32(::bmh::layout::MailboxRecipientMask) & (uint32_t(1) << manager)) == 0)
return std::nullopt;
return ui::mailbox_state_from_game(g_, manager, revision);
}
bool CareerSession::acknowledge_mailbox_close(const ui::MailboxCloseRequest& request,
uint64_t revision, std::string& error) {
if (!g_.memory.has(::bmh::layout::ActiveManager) || request.manager_slot < 0 || request.manager_slot >= 4 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.manager_slot != int(g_.memory.u8(::bmh::layout::ActiveManager)) || request.revision != revision) {
error = "Diese Nachrichtenansicht gehört zu einem veralteten Manager oder Spielstand.";
return false;
}
// MailboxStateFromGame clears only this manager's MailboxRecipientMask bit on normal exit.
// The latch lives outside the FBM data blocks and does not advance game revision.
if (g_.memory.has(::bmh::layout::MailboxRecipientMask)) {
const uint32_t notifications = g_.memory.u32(::bmh::layout::MailboxRecipientMask);
const uint32_t bit = uint32_t(1) << request.manager_slot;
if (notifications & bit) g_.memory.set32(::bmh::layout::MailboxRecipientMask, notifications & ~bit);
}
error.clear();
return true;
}
bool CareerSession::dispatch_settings(const ui::SettingsWriteRequest& request, uint64_t& revision,
std::string& error) {
if ((live_settings_owner_ && !live_settings_dispatch_active_) ||
(desk_settings_owner_ && !desk_settings_dispatch_active_)) {
error = "Diese Einstellung gehört zum geöffneten Einstellungsmenü.";
return false;
}
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
auto& mem = g_.memory;
if (request.manager_slot < 0 || request.manager_slot > 3 ||
size_t(request.manager_slot) >= g_.manager_teams.size() || !mem.has(::bmh::layout::ActiveManager) ||
int(mem.u8(::bmh::layout::ActiveManager)) != request.manager_slot || request.revision != revision ||
revision == std::numeric_limits<uint64_t>::max()) {
error = "Diese Einstellungsaktion gehört zu einem veralteten Manager oder Stand.";
return false;
}
if (request.row >= 20 || request.column >= 9 || !mem.has(::bmh::layout::LeaguePresentationOptions + 179) ||
!mem.has(::bmh::layout::GameMode) || !mem.has(::bmh::layout::CompetitionSelection)) {
error = "Der Einstellungszustand ist unvollständig.";
return false;
}
std::array<uint8_t, 180> raw{};
for (size_t i = 0; i < raw.size(); ++i) {
const uint32_t address = ::bmh::layout::LeaguePresentationOptions + uint32_t(i);
if (!mem.has(address)) { error = "Der Einstellungszustand ist unvollständig."; return false; }
raw[i] = mem.u8(address);
}
if (raw != request.expected_raw) {
error = "Die Einstellungen wurden inzwischen geändert.";
return false;
}
const size_t index = size_t(request.row) * 9 + request.column;
const uint32_t address = ::bmh::layout::LeaguePresentationOptions + uint32_t(index);
ui::SettingsAvailabilityInputs inputs{mem.u8(::bmh::layout::GameMode), mem.u32(::bmh::layout::CompetitionSelection),
uint8_t(sound_capabilities_ && !sound_capabilities_->music),
uint8_t(sound_capabilities_ && !sound_capabilities_->effects)};
auto availability = ui::project_settings_availability(raw, inputs, exe_);
// The host supplies the portable sound driver's capabilities. Headless
// callers without that provider retain the unknown Source latch boundary.
if (!sound_capabilities_) { availability[5] = raw[5]; availability[6] = raw[6]; }
const bool sound_cell = request.row == 0 && (request.column == 5 || request.column == 6);
if (sound_cell && !sound_capabilities_) {
error = "Diese Einstellung ist noch nicht verfügbar.";
return false;
}
const bool scoped_settings = (live_settings_owner_.has_value() && live_settings_dispatch_active_) ||
(desk_settings_owner_.has_value() && desk_settings_dispatch_active_);
if (((request.row == 8 && request.column == 7) && !scoped_settings) ||
(request.column == 7 && request.row >= 14 && request.row <= 19)) {
error = "Diese Einstellung ist noch nicht verfügbar.";
return false;
}
if ((request.operation != ui::SettingsEdit::toggle_binary &&
request.operation != ui::SettingsEdit::decrement && request.operation != ui::SettingsEdit::increment) ||
(request.column < 7 && request.operation != ui::SettingsEdit::toggle_binary) ||
(request.column >= 7 && request.operation == ui::SettingsEdit::toggle_binary)) {
error = "Die Aktion passt nicht zum Einstellungsfeld.";
return false;
}
const uint8_t shown = availability[index];
const uint8_t raw_value = sound_cell && sound_capabilities_ ? uint8_t(raw[index] & 0x7f) : raw[index];
if (request.column < 7 && ((shown & 0x80) || raw_value >= 2)) {
error = "Dieses Einstellungsfeld ist im aktuellen Modus gesperrt.";
return false;
}
const uint8_t old = raw_value;
uint8_t next = old;
if (request.operation == ui::SettingsEdit::toggle_binary) {
// Inventory of actual current consumers: direct match-engine buttons,
// matchday/season flags and the live-scene switch. Other cells are not
// made writable merely because the Original UI displayed a cell.
// Tie the write whitelist to the concrete consumer ranges. League
// remapping reads rows 0..4, columns 0..3; matchday display kinds 1/2
// map to columns 0..2 and rows 0..4 or 17..19.
const bool consumed = (sound_cell && sound_capabilities_.has_value()) ||
(request.row == 0 && request.column == 4) || // A5: match/Sportschau sound
((request.row <= 4 && request.column <= 3) ||
((request.row <= 4 || request.row >= 17) && request.column <= 2)) ||
((request.row == 5 || (request.row >= 9 && request.row <= 12)) && request.column == 0) ||
(request.row == 1 && request.column == 4) || // B5 live-scene option
(request.row == 2 && request.column == 4) || // C5: Reality player numbers (RealityMatch_FormatError_ExecutableField)
(request.row == 5 && request.column == 5) || // F6: Source manager-match desk gate (MatchdaySetup_MatchdayNeedsManagerDesks_RuntimeField)
(request.row == 6 && request.column == 5) || // G6: transfer confirmation wait (OutcomeDelayDisabled)
(request.row == 16 && request.column == 6) || // Q7: own-club Sportschau preference (MatchdaySetup_ConsiderSportschauFixture_RuntimeField)
(request.row == 13 && request.column == 6) || // N7: Source kickoff competition list (SportschauAwards_MatchdayIntroView_RuntimeField)
(request.row == 1 && request.column == 6) || // B7: SportschauIntro intro gate (Controller_FormatError_RuntimeField)
(request.row == 2 && request.column == 6) || // C7: SportschauIntro intro-animation gate (Controller_FormatError_RuntimeField2)
(request.row == 3 && request.column == 6) || // D7: selected report progression (ReplayProgressionMode)
(request.row == 4 && request.column == 6) || // E7: Source-owned Sportschau scenes (ReplayChanceMode)
(request.row == 5 && request.column == 6) || // F7: SportschauIntro fixture-report gate (Controller_FormatError_RuntimeField3)
(request.row == 6 && request.column == 6) || // G7: MatchdayIntro player/award rating (SportschauAwards_FinishSportschauAwards_RuntimeField)
(request.row == 7 && request.column == 6) || // H7: SportschauTeamInfo competition totals (SportschauAwards_SportschauTeamInfoView_RuntimeField)
(request.row == 2 && request.column == 5) || // C6 drawer-handle behavior (CareerSession_DispatchDesktopLayout_RuntimeField)
(request.row == 3 && request.column == 5) || // D6 native desktop drag raster (CareerSession_DispatchDesktopLayout_RuntimeField2)
(request.row == 4 && request.column == 5) || // E6 always-visible shortcut bar (DeskState_FormatError_RuntimeField3)
(request.row == 7 && request.column == 5) || // H6 transfer option
(request.row == 8 && (request.column == 5 || request.column == 6)) || // I6/I7
(request.row >= 10 && request.row <= 13 && request.column == 4) || // K5:N5 match buttons
(request.row >= 10 && request.row <= 12 && request.column == 6) || // K7:M7 presentation
(request.row == 9 && request.column == 6) || // J7 season-entrant visibility (SeasonEntrants_SeasonEntrantsFromGame_TextPointer)
(request.row == 15 && request.column == 4) || // P5
(request.row == 16 && request.column == 4) || // Q5
(request.row == 17 && request.column == 4); // R5: secondary leagues (CalendarState_FormatError_RuntimeField2)
if (!consumed || (old != 0 && old != 1)) {
error = "Diese Einstellung ist noch nicht verfügbar.";
return false;
}
if (request.row == 16 && request.column == 4 &&
g_.season_day() >= 110 && g_.season_day() <= 230) {
error = ui::original_to_utf8(message_text(g_, ::bmh::layout::CareerSession_DispatchSettings_TextPointer));
return false;
}
// SettingsSourceRefusal only permits re-enabling R5 while CareerSessionRuntimeField4 is zero.
// LeagueRoundCounters is the saved league_rounds block; CareerSessionRuntimeField4 is its sixth byte.
// Turning the leagues off remains possible after they have started.
if (request.row == 17 && request.column == 4 && old != 0 &&
(g_.league_rounds.size() <= 5 || g_.league_rounds[5] != 0)) {
error = ui::original_to_utf8(message_text(g_, ::bmh::layout::CareerSession_DispatchSettings_TextPointer2));
return false;
}
next = old ^ 1;
} else {
// Column8: existing presentation speeds B8:F8, H8 process budget,
// J8 postponed limit and K8 autosave. Column9 only exposes values
// already read by Main's Source live presenters or CupDrawScreen.
const bool consumed = (request.column == 7 &&
((request.row <= 6) || request.row == 7 || request.row == 9 || request.row == 10 ||
(scoped_settings && request.row == 8))) ||
// A9 match minutes; B9:C9 chance result; D9:E9 bookings; F9:G9 rolling ball;
// I9 cup draw; K9 Reality report; M9 preview/shootout; P9 shot.
(request.column == 8 && ((request.row >= 0 && request.row <= 6) ||
request.row == 7 || request.row == 8 || request.row == 10 || request.row == 12 || request.row == 15));
if (!consumed || old >= 200) {
error = "Diese Einstellung ist noch nicht verfügbar.";
return false;
}
if (request.column == 8) {
// SettingsSourceRefusal's ninth column is stored doubled for display. Its
// Source edit step is two raw units; decrement is enabled only
// above 1 and increment only below 0xc6 (198). Preserve odd raw
// values exactly, as the original does.
if (request.operation == ui::SettingsEdit::decrement) {
if (old <= 1) { error = "Der Zahlenwert ist bereits am Originalminimum."; return false; }
next = uint8_t(old - 2);
} else {
if (old >= 198) { error = "Der Zahlenwert ist bereits am Originalmaximum."; return false; }
next = uint8_t(old + 2);
}
} else if (request.column == 7) {
if (request.operation == ui::SettingsEdit::decrement) {
if (old == 0) { error = "Der Zahlenwert ist bereits am Originalminimum."; return false; }
next = uint8_t(old - 1);
} else {
const uint8_t limit = exe_.u8(::bmh::layout::CareerSession_DispatchSettings_RuntimeField + request.row);
if (old >= limit) { error = "Der Zahlenwert ist bereits am Originalmaximum."; return false; }
next = uint8_t(old + 1);
}
}
}
if (next == old) { error = "Die Einstellung hat sich nicht geändert."; return false; }
mem.set8(address, next);
++revision;
return true;
}
std::optional<CareerSession::LiveSettingsProjection> CareerSession::open_live_settings(
const LiveSettingsRequest& request,MatchEngine& engine,uint64_t& revision,std::string& error) {
error.clear();
if(!calendar_advance_active_||live_settings_owner_||request.minute<0||request.minute>255||
request.manager_slot<0||request.manager_slot>=int(g_.manager_teams.size())||
request.revision!=revision||revision==UINT64_MAX||next_live_settings_scope_==UINT64_MAX||
&engine.state!=&g_||&engine.game!=&game_||&engine.rand!=&rand_||
engine.groups.empty()||engine.groups.size()!=turn_driver_.groups.size()||
!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=request.manager_slot||
size_t(request.manager_slot)>=g_.manager_teams.size()||
g_.manager_teams[size_t(request.manager_slot)]!=request.runtime_team||
request.runtime_team<0||size_t(request.runtime_team)>=g_.team_flags.size()||
live_overview_owner_||live_intervention_||balance_draft_||balance_dispatch_active_||
strengths_owner_||strengths_dispatch_active_||league_family_owner_||league_pairings_draft_||
league_pairings_dispatch_active_||other_games_owner_||other_games_dispatch_active_||
top_scorers_owner_||top_scorers_dispatch_active_||pending_offer_dispatch_active_||market_dispatch_active_||
transfer_offer_editor_||manager_join_||contract_quote_||stadium_.investment||stadium_.tip||
stadium_.periphery_quote||stadium_.block_expansion) {
error="live settings: stale, nested or unauthenticated Source S request";return {};
}
for(size_t i=0;i<engine.groups.size();++i)
if(engine.groups[i].desc!=turn_driver_.groups[i].desc||engine.groups[i].fixtures!=turn_driver_.groups[i].fixtures) {
error="live settings: match descriptors changed outside the observer";return {};
}
if(!g_.memory.has(::bmh::layout::LeaguePresentationOptions+179)||!g_.memory.has(::bmh::layout::GameMode)||!g_.memory.has(::bmh::layout::CompetitionSelection)) {
error="live settings: Source switch block is incomplete";return {};
}
GameState staged=g_;
auto runtime=club_modal_runtime_;
try {
std::array<uint8_t,180> raw{};
for(size_t i=0;i<raw.size();++i) {
const uint32_t address=::bmh::layout::LeaguePresentationOptions+uint32_t(i);
if(!staged.memory.has(address))throw FormatError("live settings: Source switch block is incomplete");
raw[i]=staged.memory.u8(address);
}
const auto entry=ui::project_settings_availability(raw,
{staged.memory.u8(::bmh::layout::GameMode),staged.memory.u32(::bmh::layout::CompetitionSelection),0,0},exe_);
for(size_t i=0;i<entry.size();++i) {
// A6/A7 availability is projected from the host's runtime capability.
// Keep their saved switches intact until an explicit user write.
const uint8_t value=(i==5||i==6)?raw[i]:entry[i];
staged.memory.set8(::bmh::layout::LeaguePresentationOptions+uint32_t(i),value);
}
source_runtime_set_byte(staged,runtime,::bmh::layout::CareerSession_LiveBoundaryFamilyScope_ExecutableField,0); // SavePathInDirectory, before SettingsSourceRefusal.
auto state=ui::settings_from_game(staged,request.manager_slot,revision+1,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
std::vector<uint8_t> buttons(180);
for(size_t i=0;i<buttons.size();++i)buttons[i]=staged.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
const bool live_desk_disabled=source_runtime_byte(staged,runtime,exe_,::bmh::layout::LiveDeskDisabled)!=0;
LiveSettingsRequest owner=request;owner.sequence=next_live_settings_scope_;owner.revision=revision+1;
LiveSettingsOwner next;next.request=owner;next.native=save_stream(staged);
next.expected_buttons=buttons;next.expected_live_desk_disabled=live_desk_disabled;next.expected_live_scene_visible=engine.live_scene_visible;
next.expected_runtime=runtime;
next.rand_seed=rand_.seed();next.game_seed=game_.seed();next.rand_calls=rand_.calls();next.game_calls=game_.calls();
for(const auto& group:engine.groups)next.active_groups.emplace_back(group.desc,group.fixtures);
next.referees=engine.referees;
LiveSettingsProjection projection{owner,std::move(state)};
g_=std::move(staged);club_modal_runtime_=std::move(runtime);
engine.buttons=std::move(buttons);engine.live_desk_disabled=live_desk_disabled;
live_settings_owner_=std::move(next);++next_live_settings_scope_;revision=owner.revision;
return projection;
} catch(const std::exception& e) {
error=e.what();return {};
}
}
std::optional<CareerSession::LiveSettingsDispatch> CareerSession::dispatch_live_settings(
const LiveSettingsAction& action,MatchEngine& engine,uint64_t& revision,std::string& error) {
error.clear();
if(!calendar_advance_active_||!live_settings_owner_||revision==UINT64_MAX||
live_settings_owner_->request.revision!=revision||&engine.state!=&g_||
&engine.game!=&game_||&engine.rand!=&rand_||engine.groups.size()!=live_settings_owner_->active_groups.size()||
engine.referees!=live_settings_owner_->referees||save_stream(g_)!=live_settings_owner_->native||
engine.buttons!=live_settings_owner_->expected_buttons||engine.live_desk_disabled!=live_settings_owner_->expected_live_desk_disabled||
engine.live_scene_visible!=live_settings_owner_->expected_live_scene_visible||club_modal_runtime_!=live_settings_owner_->expected_runtime||
rand_.seed()!=live_settings_owner_->rand_seed||rand_.calls()!=live_settings_owner_->rand_calls||
game_.seed()!=live_settings_owner_->game_seed||game_.calls()!=live_settings_owner_->game_calls||
!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=live_settings_owner_->request.manager_slot||
size_t(live_settings_owner_->request.manager_slot)>=g_.manager_teams.size()||
g_.manager_teams[size_t(live_settings_owner_->request.manager_slot)]!=live_settings_owner_->request.runtime_team) {
error="live settings: stale owner or no longer at the Source observer";return {};
}
for(size_t i=0;i<engine.groups.size();++i)
if(engine.groups[i].desc!=live_settings_owner_->active_groups[i].first||
engine.groups[i].fixtures!=live_settings_owner_->active_groups[i].second||
engine.groups[i].desc!=turn_driver_.groups[i].desc||engine.groups[i].fixtures!=turn_driver_.groups[i].fixtures) {
error="live settings: active Source match list changed";return {};
}
const auto current=*live_settings_owner_;
struct LiveSettingsBoundaryScope {
bool& active;bool previous;
explicit LiveSettingsBoundaryScope(bool& value):active(value),previous(value){active=false;}
~LiveSettingsBoundaryScope(){active=previous;}
} boundary(calendar_advance_active_);
std::optional<GameState> write_rollback;
const uint64_t revision_before_action=revision;
try {
if(const auto* write=std::get_if<LiveSettingsWrite>(&action)) {
if(write->owner_sequence!=current.request.sequence||write->write.manager_slot!=current.request.manager_slot||
write->write.revision!=revision)
throw FormatError("live settings: write belongs to another Source owner");
write_rollback=g_;
live_settings_dispatch_active_=true;
struct Reset { bool& active;~Reset(){active=false;} } reset{live_settings_dispatch_active_};
uint64_t staged_revision=revision;
if(!dispatch_settings(write->write,staged_revision,error))
throw FormatError(error.empty()?"live settings: Source cell write rejected":error);
GameState staged=std::move(g_);
g_=*write_rollback;
std::array<uint8_t,180> raw{};
for(size_t i=0;i<raw.size();++i)raw[i]=staged.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
const auto projected=ui::project_settings_availability(raw,
{staged.memory.u8(::bmh::layout::GameMode),staged.memory.u32(::bmh::layout::CompetitionSelection),0,0},exe_);
for(size_t i=0;i<projected.size();++i)
if(i!=5&&i!=6)staged.memory.set8(::bmh::layout::LeaguePresentationOptions+uint32_t(i),projected[i]);
std::vector<uint8_t> buttons(180);
for(size_t i=0;i<buttons.size();++i)buttons[i]=staged.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
const bool live_desk_disabled=source_runtime_byte(staged,club_modal_runtime_,exe_,::bmh::layout::LiveDeskDisabled)!=0;
auto state=ui::settings_from_game(staged,current.request.manager_slot,staged_revision,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
LiveSettingsOwner updated=current;
updated.request.revision=staged_revision;updated.native=save_stream(staged);
updated.expected_buttons=buttons;updated.expected_live_desk_disabled=live_desk_disabled;
updated.expected_live_scene_visible=engine.live_scene_visible;updated.expected_runtime=club_modal_runtime_;
updated.rand_seed=rand_.seed();updated.game_seed=game_.seed();
updated.rand_calls=rand_.calls();updated.game_calls=game_.calls();
LiveSettingsDispatch result{updated.request,false,std::move(state)};
g_=std::move(staged);revision=staged_revision;
engine.buttons=std::move(buttons);engine.live_desk_disabled=live_desk_disabled;
live_settings_owner_=std::move(updated);
write_rollback.reset();
return result;
}
if(const auto* file=std::get_if<LiveSettingsFile>(&action)) {
if(file->owner_sequence!=current.request.sequence||file->request.manager_slot!=current.request.manager_slot||
file->request.origin_item_id!=-1||file->request.revision!=revision||revision==UINT64_MAX)
throw FormatError("live settings: file request belongs to another owner");
GameState staged=g_;bool loaded=false;
if(!apply_settings_file(file->request,current.request.manager_slot,-1,staged,loaded,error))
throw FormatError(error.empty()?"live settings: .EIN request rejected":error);
auto state=ui::settings_from_game(staged,current.request.manager_slot,revision+1,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
std::vector<uint8_t> buttons(180);
for(size_t i=0;i<buttons.size();++i)buttons[i]=staged.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
const bool live_desk_disabled=source_runtime_byte(staged,club_modal_runtime_,exe_,::bmh::layout::LiveDeskDisabled)!=0;
LiveSettingsOwner updated=current;updated.request.revision=revision+1;
updated.native=save_stream(staged);updated.expected_buttons=buttons;
updated.expected_live_desk_disabled=live_desk_disabled;updated.expected_live_scene_visible=engine.live_scene_visible;
updated.expected_runtime=club_modal_runtime_;
LiveSettingsDispatch result{updated.request,false,std::move(state)};
g_=std::move(staged);engine.buttons=std::move(buttons);engine.live_desk_disabled=live_desk_disabled;
live_settings_owner_=std::move(updated);++revision;
return result;
}
const auto& close=std::get<LiveSettingsCloseRequest>(action);
if(close.owner!=current.request||close.owner.sequence!=current.request.sequence||close.owner.revision!=revision)
throw FormatError("live settings: stale or mismatched Source close");
if(revision==UINT64_MAX)throw FormatError("live settings: revision exhausted");
GameState next=g_;auto runtime=club_modal_runtime_;
std::array<uint8_t,180> raw{};
for(size_t i=0;i<raw.size();++i)raw[i]=next.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
next.live_scene=uint8_t(1-(raw[13]&1))!=0; // SettingsSourceRefusal: LiveSceneVisible=1-(CareerSession_DispatchLiveTactic_RuntimeField3&1).
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_DispatchLiveSubstitution_ExecutableField,next.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField2)); // Source max-substitution latch.
uint32_t code=0;
for(uint32_t i=0;i<6;++i)code=code*10+next.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField + (i+14)*9);
for(uint32_t i=0;i<4;++i)source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_RuntimeField9+i,uint8_t(code>>(8*i)));
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_ExecutableField8,1); // EndPhase requests its normal redraw on return.
auto state=ui::settings_from_game(next,current.request.manager_slot,revision+1,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
std::vector<uint8_t> buttons(180);
for(size_t i=0;i<buttons.size();++i)buttons[i]=next.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
const bool live_desk_disabled=source_runtime_byte(next,runtime,exe_,::bmh::layout::LiveDeskDisabled)!=0;
LiveSettingsDispatch result;result.owner=current.request;result.owner.revision=revision+1;
result.closed=true;result.state=std::move(state);
g_=std::move(next);club_modal_runtime_=std::move(runtime);
engine.buttons=std::move(buttons);engine.live_desk_disabled=live_desk_disabled;engine.live_scene_visible=g_.live_scene;
live_settings_owner_.reset();++revision;return result;
} catch(const std::exception& e) {
if(write_rollback) {
g_=std::move(*write_rollback);revision=revision_before_action;
live_settings_owner_=current;
}
error=e.what();return {};
}
}
CareerSession::DeskSettingsCheckpoint CareerSession::desk_settings_checkpoint(uint64_t revision) const {
return {g_,club_modal_runtime_,desk_settings_owner_ ?
std::optional<DeskSettingsOwner>(desk_settings_owner_->owner) : std::nullopt,
desk_settings_owner_ ? desk_settings_owner_->initial_h8 : uint8_t(0),
next_desk_settings_scope_,revision};
}
bool CareerSession::apply_settings_file(const ui::SaveLoadRequest& request,int manager_slot,int origin_item_id,
GameState& staged,bool& loaded,std::string& error) const {
constexpr size_t kBytes=180;
loaded=false;
if(request.file_kind!=ui::SaveLoadFileKind::settings||request.manager_slot!=manager_slot||
request.origin_item_id!=origin_item_id||request.path.filename().empty()) {
error="invalid_settings_file_owner";return false;
}
std::string extension=request.path.extension().string();
std::transform(extension.begin(),extension.end(),extension.begin(),
[](unsigned char c){return char(std::tolower(c));});
if(extension!=".ein") {error="invalid_settings_file_extension";return false;}
const uint32_t base=::bmh::layout::LeaguePresentationOptions;
if(!staged.memory.has(base+uint32_t(kBytes-1))) {error="settings_file_memory_unavailable";return false;}
std::error_code ec;
const auto status=std::filesystem::symlink_status(request.path,ec);
if(!ec&&std::filesystem::is_symlink(status)) {error="settings_file_target_is_symlink";return false;}
if(request.action==ui::SaveLoadAction::load) {
Bytes bytes;
try {bytes=read_file(request.path);}catch(const std::exception&) {error="settings_file_read_failed";return false;}
if(bytes.size()!=kBytes) {error="settings_file_wrong_size";return false;}
for(size_t i=0;i<kBytes;++i)staged.memory.set8(base+uint32_t(i),bytes[i]);
std::array<uint8_t,kBytes> raw{};
for(size_t i=0;i<kBytes;++i)raw[i]=bytes[i];
const auto availability=ui::project_settings_availability(raw,
{staged.memory.u8(::bmh::layout::GameMode),staged.memory.u32(::bmh::layout::CompetitionSelection),0,0},exe_);
for(size_t i=0;i<kBytes;++i)
if(i!=5&&i!=6)staged.memory.set8(base+uint32_t(i),availability[i]);
loaded=true;error.clear();return true;
}
if(request.action!=ui::SaveLoadAction::save) {error="invalid_settings_file_action";return false;}
if(!std::filesystem::is_directory(request.path.parent_path(),ec)||ec) {
error="settings_file_directory_unavailable";return false;
}
ec.clear();const bool exists=std::filesystem::exists(request.path,ec);
if(ec||(exists&&!request.overwrite)) {
error=exists?"settings_file_overwrite_confirmation_required":"settings_file_target_unavailable";
return false;
}
Bytes bytes(kBytes);
for(size_t i=0;i<kBytes;++i)bytes[i]=staged.memory.u8(base+uint32_t(i));
try {
std::ofstream file(request.path,std::ios::binary|std::ios::trunc);
if(!file) {error="settings_file_write_failed";return false;}
file.write(reinterpret_cast<const char*>(bytes.data()),std::streamsize(bytes.size()));file.flush();
if(!file) {error="settings_file_write_failed";return false;}
} catch(const std::exception&) {error="settings_file_write_failed";return false;}
error.clear();return true;
}
void CareerSession::restore_desk_settings_checkpoint(DeskSettingsCheckpoint checkpoint,uint64_t& revision) {
g_=std::move(checkpoint.state);club_modal_runtime_=std::move(checkpoint.runtime);
desk_settings_owner_.reset();
if(checkpoint.owner) {
DeskSettingsOwnerState restored;restored.owner=*checkpoint.owner;
restored.initial_h8=checkpoint.initial_h8;restored.native=save_stream(g_);
restored.expected_runtime=club_modal_runtime_;restored.rand_seed=rand_.seed();
restored.game_seed=game_.seed();restored.rand_calls=rand_.calls();restored.game_calls=game_.calls();
desk_settings_owner_=std::move(restored);
}
next_desk_settings_scope_=checkpoint.next_scope;revision=checkpoint.revision;
}
std::optional<CareerSession::DeskSettingsProjection> CareerSession::open_desk_settings(
const ui::DeskRequest& request,uint64_t& revision,std::string& error) {
error.clear();
if(request.kind!=ui::DeskRequestKind::open_menu||request.menu_kind!=19||request.value!=-1||
request.item_id<0||request.item_id>=54||request.revision!=revision||revision==UINT64_MAX||
next_desk_settings_scope_==UINT64_MAX||request.manager_slot<0||request.manager_slot>3||
!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=request.manager_slot||
size_t(request.manager_slot)>=g_.manager_teams.size()||
live_settings_owner_||desk_settings_owner_||live_overview_owner_||live_intervention_||
balance_draft_||balance_dispatch_active_||strengths_owner_||strengths_dispatch_active_||
league_family_owner_||league_family_teaminfo_active_||league_pairings_draft_||
league_pairings_dispatch_active_||other_games_owner_||other_games_dispatch_active_||
top_scorers_owner_||top_scorers_dispatch_active_||opportunities_owner_||opportunities_dispatch_active_||
pending_offer_dispatch_active_||market_dispatch_active_||transfer_offer_editor_||manager_join_||
contract_quote_||advertising_renewal_dispatch_active_||stadium_.investment||stadium_.tip||
stadium_.periphery_quote||stadium_.block_expansion||
calendar_advance_active_||career_complete()) {
error="desk settings: stale, nested or unauthenticated menu-19 request";return {};
}
try {
const auto desk=desktop_projection(revision);
const auto source=std::find_if(desk.items.begin(),desk.items.end(),[&](const ui::DeskItem& item) {
return item.id==request.item_id;
});
if(source==desk.items.end()||source->kind!=19||source->disabled||desk.manager_slot!=request.manager_slot) {
error="desk settings: menu-19 source item is not currently enabled";return {};
}
if(!g_.memory.has(::bmh::layout::LeaguePresentationOptions+179)||!g_.memory.has(::bmh::layout::GameMode)||!g_.memory.has(::bmh::layout::CompetitionSelection)) {
error="desk settings: Source settings block is incomplete";return {};
}
GameState staged=g_;auto runtime=club_modal_runtime_;
std::array<uint8_t,180> raw{};
for(size_t i=0;i<raw.size();++i) {
const uint32_t address=::bmh::layout::LeaguePresentationOptions+uint32_t(i);
if(!staged.memory.has(address))throw FormatError("desk settings: Source settings block is incomplete");
raw[i]=staged.memory.u8(address);
}
const auto projected=ui::project_settings_availability(raw,
{staged.memory.u8(::bmh::layout::GameMode),staged.memory.u32(::bmh::layout::CompetitionSelection),0,0},exe_);
for(size_t i=0;i<projected.size();++i)
staged.memory.set8(::bmh::layout::LeaguePresentationOptions+uint32_t(i),(i==5||i==6)?raw[i]:projected[i]);
auto state=ui::settings_from_game(staged,request.manager_slot,revision+1,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
DeskSettingsOwner owner{next_desk_settings_scope_,revision+1,request.manager_slot,request.item_id};
DeskSettingsOwnerState next;next.owner=owner;next.initial_h8=raw[7*9+7];next.native=save_stream(staged);
next.expected_runtime=runtime;next.rand_seed=rand_.seed();next.game_seed=game_.seed();
next.rand_calls=rand_.calls();next.game_calls=game_.calls();
DeskSettingsProjection result{owner,std::move(state)};
g_=std::move(staged);club_modal_runtime_=std::move(runtime);
desk_settings_owner_=std::move(next);++next_desk_settings_scope_;++revision;
return result;
} catch(const std::exception& e) {error=e.what();return {};}
}
std::optional<CareerSession::DeskSettingsDispatch> CareerSession::dispatch_desk_settings(
const DeskSettingsAction& action,uint64_t& revision,std::string& error) {
error.clear();
if(!desk_settings_owner_||revision==UINT64_MAX||desk_settings_owner_->owner.revision!=revision||
save_stream(g_)!=desk_settings_owner_->native||club_modal_runtime_!=desk_settings_owner_->expected_runtime||
rand_.seed()!=desk_settings_owner_->rand_seed||rand_.calls()!=desk_settings_owner_->rand_calls||
game_.seed()!=desk_settings_owner_->game_seed||game_.calls()!=desk_settings_owner_->game_calls||
!g_.memory.has(::bmh::layout::ActiveManager)||g_.memory.u8(::bmh::layout::ActiveManager)!=desk_settings_owner_->owner.manager_slot) {
error="desk settings: stale owner or changed session";return {};
}
const auto current=*desk_settings_owner_;
const uint64_t revision_before=revision;
std::optional<GameState> rollback;
try {
if(const auto* write=std::get_if<DeskSettingsWrite>(&action)) {
if(write->owner_sequence!=current.owner.sequence||write->write.manager_slot!=current.owner.manager_slot||
write->write.revision!=revision)throw FormatError("desk settings: write belongs to another owner");
rollback=g_;desk_settings_dispatch_active_=true;
struct Reset { bool& active;~Reset(){active=false;} } reset{desk_settings_dispatch_active_};
uint64_t staged_revision=revision;
if(!dispatch_settings(write->write,staged_revision,error))
throw FormatError(error.empty()?"desk settings: Source write rejected":error);
GameState staged=std::move(g_);g_=*rollback;
std::array<uint8_t,180> raw{};
for(size_t i=0;i<raw.size();++i)raw[i]=staged.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
const auto projected=ui::project_settings_availability(raw,
{staged.memory.u8(::bmh::layout::GameMode),staged.memory.u32(::bmh::layout::CompetitionSelection),0,0},exe_);
for(size_t i=0;i<projected.size();++i)
if(i!=5&&i!=6)staged.memory.set8(::bmh::layout::LeaguePresentationOptions+uint32_t(i),projected[i]);
auto state=ui::settings_from_game(staged,current.owner.manager_slot,staged_revision,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
DeskSettingsOwnerState updated=current;updated.owner.revision=staged_revision;
updated.native=save_stream(staged);updated.expected_runtime=club_modal_runtime_;
updated.rand_seed=rand_.seed();updated.game_seed=game_.seed();
updated.rand_calls=rand_.calls();updated.game_calls=game_.calls();
DeskSettingsDispatch result{updated.owner,false,std::move(state)};
g_=std::move(staged);revision=staged_revision;desk_settings_owner_=std::move(updated);
rollback.reset();return result;
}
if(const auto* file=std::get_if<DeskSettingsFile>(&action)) {
if(file->owner_sequence!=current.owner.sequence||file->request.manager_slot!=current.owner.manager_slot||
file->request.revision!=revision||file->request.origin_item_id!=current.owner.source_item_id||
revision==UINT64_MAX)
throw FormatError("desk settings: file request belongs to another owner");
GameState staged=g_;bool loaded=false;
if(!apply_settings_file(file->request,current.owner.manager_slot,current.owner.source_item_id,
staged,loaded,error))
throw FormatError(error.empty()?"desk settings: .EIN request rejected":error);
auto state=ui::settings_from_game(staged,current.owner.manager_slot,revision+1,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
DeskSettingsOwnerState updated=current;updated.owner.revision=revision+1;
updated.native=save_stream(staged);updated.expected_runtime=club_modal_runtime_;
updated.rand_seed=rand_.seed();updated.game_seed=game_.seed();
updated.rand_calls=rand_.calls();updated.game_calls=game_.calls();
DeskSettingsDispatch result{updated.owner,false,std::move(state)};
g_=std::move(staged);desk_settings_owner_=std::move(updated);++revision;
return result;
}
const auto& close=std::get<DeskSettingsClose>(action);
if(close.owner!=current.owner||close.owner.revision!=revision)
throw FormatError("desk settings: stale close request");
GameState next=g_;auto runtime=club_modal_runtime_;
std::array<uint8_t,180> raw{};
for(size_t i=0;i<raw.size();++i)raw[i]=next.memory.u8(::bmh::layout::LeaguePresentationOptions+uint32_t(i));
const uint8_t new_h8=raw[7*9+7];
if(new_h8==0) {
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_ExecutableField2,1);
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_ExecutableField2+1,0);
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_ExecutableField2+2,0);
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_ExecutableField2+3,0);
} else if(current.initial_h8!=0) {
const int16_t delta=static_cast<int16_t>(int(new_h8)-int(current.initial_h8));
const uint32_t remaining=source_runtime_u32(next,runtime,exe_,::bmh::layout::CareerSession_FormatError_ExecutableField2);
const uint32_t adjusted=remaining+uint32_t(int32_t(delta)*60);
for(uint32_t i=0;i<4;++i)
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_ExecutableField2+i,uint8_t(adjusted>>(8*i)));
}
next.live_scene=uint8_t(1-(raw[13]&1))!=0;
source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_DispatchLiveSubstitution_ExecutableField,next.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField2));
uint32_t code=0;
for(uint32_t i=0;i<6;++i)code=code*10+next.memory.u8(::bmh::layout::CareerSession_FormatError_RuntimeField + (i+14)*9);
for(uint32_t i=0;i<4;++i)source_runtime_set_byte(next,runtime,::bmh::layout::CareerSession_FormatError_RuntimeField9+i,uint8_t(code>>(8*i)));
auto state=ui::settings_from_game(next,current.owner.manager_slot,revision+1,exe_,sound_capabilities_);
ui::SettingsScreen validate(data_directory_,state);
DeskSettingsDispatch result{current.owner,true,std::move(state)};result.owner.revision=revision+1;
g_=std::move(next);club_modal_runtime_=std::move(runtime);desk_settings_owner_.reset();++revision;
return result;
} catch(const std::exception& e) {
if(rollback) {g_=std::move(*rollback);revision=revision_before;desk_settings_owner_=current;}
error=e.what();return {};
}
}
std::optional<AdvertisingRenewal> CareerSession::check_advertising_renewal(int manager_slot, int display_slot,
uint64_t& revision, std::string& error) {
error.clear();
if (advertising_renewal_dispatch_active_) {
error = "advertising_renewal_active";
return std::nullopt;
}
if (!g_.memory.has(::bmh::layout::ActiveManager) || manager_slot < 0 || size_t(manager_slot) >= g_.manager_teams.size() ||
int(g_.memory.u8(::bmh::layout::ActiveManager)) != manager_slot || revision == std::numeric_limits<uint64_t>::max()) {
error = "Diese Werbeaktion ist nicht mehr aktuell.";
return std::nullopt;
}
AdvertisingRenewal renewal = bmh::check_advertising_renewal(g_, manager_slot, display_slot, rand_);
if (renewal.status == AdvertisingRenewal::Status::invalid) {
error = "Diese Werbefläche gibt es nicht.";
return std::nullopt;
}
if (renewal.status != AdvertisingRenewal::Status::not_expired) ++revision;
return renewal;
}
bool CareerSession::answer_advertising_renewal(int manager_slot, int contract_slot, bool renew, uint64_t& revision,
std::string& error) {
error.clear();
if (advertising_renewal_dispatch_active_) {
error = "advertising_renewal_active";
return false;
}
if (!g_.memory.has(::bmh::layout::ActiveManager) || manager_slot < 0 || size_t(manager_slot) >= g_.manager_teams.size() ||
int(g_.memory.u8(::bmh::layout::ActiveManager)) != manager_slot || revision == std::numeric_limits<uint64_t>::max() ||
!bmh::answer_advertising_renewal(g_, manager_slot, contract_slot, renew)) {
error = "Diese Vertragsverlängerung ist nicht mehr aktuell.";
return false;
}
++revision;
return true;
}
CareerSession::AdvertisingSessionCheckpoint CareerSession::advertising_session_checkpoint(uint64_t revision) const {
AdvertisingSessionCheckpoint c;
c.state=g_; c.game=game_; c.rand=rand_; c.driver=turn_driver_;
c.desk_callargs=source_desk_callargs_; c.saved_turn_error=saved_turn_error_;
c.completed_results=completed_results_; c.lineup_manager=lineup_entry_manager_;
c.lineup_club=lineup_entry_club_; c.managers=managers_; c.stock_tip=last_stock_tip_;
c.property_notice=last_property_notice_; c.credit_notice=last_credit_notice_;
c.stadium=stadium_; c.next_stadium_scope=next_stadium_scope_;
c.contract_quote=contract_quote_; c.next_contract_quote_id=next_contract_quote_id_;
c.last_contract_request_id=last_contract_request_id_; c.options_applied=options_applied_;
c.pending_offer_active=pending_offer_dispatch_active_; c.market_active=market_dispatch_active_;
c.pairings_active=league_pairings_dispatch_active_; c.family_teaminfo_active=league_family_teaminfo_active_;
c.strengths_active=strengths_dispatch_active_; c.top_scorers_active=top_scorers_dispatch_active_;
c.other_games_active=other_games_dispatch_active_; c.balance_active=balance_dispatch_active_;
c.calendar_active=calendar_advance_active_; c.next_other_games_scope=next_other_games_scope_;
c.other_games_owner=other_games_owner_; c.other_games_selection=other_games_selection_;
c.next_balance_scope=next_balance_scope_; c.balance=balance_draft_;
c.next_strengths_scope=next_strengths_scope_; c.strengths=strengths_owner_;
c.family=league_family_owner_; c.next_family_id=next_league_family_id_;
c.next_top_scorers_scope=next_top_scorers_scope_; c.top_scorers=top_scorers_owner_;
c.pairings_scope=league_pairings_scope_; c.pairings=league_pairings_draft_;
c.transfer_editor=transfer_offer_editor_; c.poach=poach_;
c.transfer_offer_revision=transfer_offer_revision_; c.pending_hooks=pending_offer_hooks_;
c.pending_policy=pending_offer_entry_policy_; c.runtime=club_modal_runtime_;
c.last_request_id=last_advertising_request_id_; c.manager_join=manager_join_;
c.revision=revision; c.session_id=session_id_;
return c;
}
void CareerSession::restore_advertising_session_checkpoint(AdvertisingSessionCheckpoint c) {
g_=std::move(c.state); game_=c.game; rand_=c.rand; turn_driver_=std::move(c.driver);
source_desk_callargs_=std::move(c.desk_callargs); saved_turn_error_=std::move(c.saved_turn_error);
completed_results_=std::move(c.completed_results); lineup_entry_manager_=c.lineup_manager;
lineup_entry_club_=c.lineup_club; managers_=std::move(c.managers); last_stock_tip_=c.stock_tip;
last_property_notice_=std::move(c.property_notice); last_credit_notice_=std::move(c.credit_notice);
stadium_=std::move(c.stadium); next_stadium_scope_=c.next_stadium_scope;
contract_quote_=std::move(c.contract_quote); next_contract_quote_id_=c.next_contract_quote_id;
last_contract_request_id_=c.last_contract_request_id; options_applied_=c.options_applied;
pending_offer_dispatch_active_=c.pending_offer_active; market_dispatch_active_=c.market_active;
league_pairings_dispatch_active_=c.pairings_active; league_family_teaminfo_active_=c.family_teaminfo_active;
strengths_dispatch_active_=c.strengths_active; top_scorers_dispatch_active_=c.top_scorers_active;
other_games_dispatch_active_=c.other_games_active; balance_dispatch_active_=c.balance_active;
calendar_advance_active_=c.calendar_active; next_other_games_scope_=c.next_other_games_scope;
other_games_owner_=std::move(c.other_games_owner); other_games_selection_=c.other_games_selection;
next_balance_scope_=c.next_balance_scope; balance_draft_=std::move(c.balance);
next_strengths_scope_=c.next_strengths_scope; strengths_owner_=std::move(c.strengths);
league_family_owner_=std::move(c.family); next_league_family_id_=c.next_family_id;
next_top_scorers_scope_=c.next_top_scorers_scope; top_scorers_owner_=std::move(c.top_scorers);
league_pairings_scope_=c.pairings_scope; league_pairings_draft_=std::move(c.pairings);
transfer_offer_editor_=std::move(c.transfer_editor); poach_=std::move(c.poach);
transfer_offer_revision_=c.transfer_offer_revision; pending_offer_hooks_=std::move(c.pending_hooks);
pending_offer_entry_policy_=c.pending_policy; club_modal_runtime_=std::move(c.runtime);
last_advertising_request_id_=c.last_request_id; manager_join_=std::move(c.manager_join);
}
bool CareerSession::advertising_session_unchanged(const AdvertisingSessionCheckpoint& c,
uint64_t revision) const {
const auto byte_same=[&](uint32_t at) {
const bool live_has=g_.memory.has(at), saved_has=c.state.memory.has(at);
return live_has==saved_has && (!live_has || g_.memory.u8(at)==c.state.memory.u8(at));
};
const bool manager_ids_same = managers_.size()==c.managers.size() &&
std::equal(managers_.begin(),managers_.end(),c.managers.begin(),[](const auto& a,const auto& b) {
return a.slot==b.slot && a.master_club==b.master_club && a.runtime_club==b.runtime_club;
});
return save_stream(g_)==save_stream(c.state) && same_strengths_runtime_state(g_,c.state) &&
g_.manager_teams==c.state.manager_teams && byte_same(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField) && byte_same(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField) &&
rand_.seed()==c.rand.seed() && rand_.calls()==c.rand.calls() &&
game_.seed()==c.game.seed() && game_.calls()==c.game.calls() &&
turn_driver_.stage==c.driver.stage && source_desk_callargs_==c.desk_callargs &&
lineup_entry_manager_==c.lineup_manager && lineup_entry_club_==c.lineup_club && manager_ids_same &&
session_id_==c.session_id && last_advertising_request_id_==c.last_request_id && revision==c.revision &&
club_modal_runtime_==c.runtime &&
pending_offer_dispatch_active_==c.pending_offer_active && market_dispatch_active_==c.market_active &&
league_pairings_dispatch_active_==c.pairings_active && league_family_teaminfo_active_==c.family_teaminfo_active &&
strengths_dispatch_active_==c.strengths_active && top_scorers_dispatch_active_==c.top_scorers_active &&
other_games_dispatch_active_==c.other_games_active && balance_dispatch_active_==c.balance_active &&
calendar_advance_active_==c.calendar_active &&
bool(other_games_owner_)==bool(c.other_games_owner) && bool(balance_draft_)==bool(c.balance) &&
bool(strengths_owner_)==bool(c.strengths) && bool(league_family_owner_)==bool(c.family) &&
bool(top_scorers_owner_)==bool(c.top_scorers) && bool(league_pairings_draft_)==bool(c.pairings) &&
bool(transfer_offer_editor_)==bool(c.transfer_editor) && bool(poach_)==bool(c.poach) &&
bool(manager_join_)==bool(c.manager_join) && bool(stadium_.opened)==bool(c.stadium.opened) &&
bool(contract_quote_)==bool(c.contract_quote) &&
next_other_games_scope_==c.next_other_games_scope && next_balance_scope_==c.next_balance_scope &&
next_strengths_scope_==c.next_strengths_scope && next_league_family_id_==c.next_family_id &&
next_top_scorers_scope_==c.next_top_scorers_scope && league_pairings_scope_==c.pairings_scope &&
next_stadium_scope_==c.next_stadium_scope && next_contract_quote_id_==c.next_contract_quote_id &&
last_contract_request_id_==c.last_contract_request_id && transfer_offer_revision_==c.transfer_offer_revision;
}
std::optional<AdvertisingRenewal> CareerSession::dispatch_advertising_renewal(
const ui::AdvertisingRequest& request, uint64_t& revision, std::string& error,
const AdvertisingRenewalPresenter& presenter) {
error.clear();
const auto competing_owner = [&] {
return pending_offer_dispatch_active_ || market_dispatch_active_ || league_pairings_dispatch_active_ ||
league_family_teaminfo_active_ || strengths_dispatch_active_ || top_scorers_dispatch_active_ ||
other_games_dispatch_active_ || balance_dispatch_active_ || calendar_advance_active_ ||
balance_draft_.has_value() || strengths_owner_.has_value() || top_scorers_owner_.has_value() ||
other_games_owner_.has_value() || league_family_owner_.has_value() || league_pairings_draft_.has_value() ||
manager_join_.has_value() || transfer_offer_editor_.has_value() || poach_.has_value() ||
stadium_.opened || stadium_.investment.has_value() || stadium_.tip.has_value() ||
stadium_.periphery_quote.has_value() || stadium_.selection_status.has_value() ||
stadium_.block_expansion.has_value() || contract_quote_.has_value() ||
(turn_driver_.stage!=TurnDriver::Stage::MatchdayDesks &&
turn_driver_.stage!=TurnDriver::Stage::SeasonEndDesk);
};
if (advertising_renewal_dispatch_active_ || competing_owner()) {
error = "Eine andere Session-Aktion oder ein konkurrierender Screen ist aktiv.";
return std::nullopt;
}
if (!presenter || request.kind != ui::AdvertisingActionKind::check_renewal ||
request.request_id == 0 || request.request_id <= last_advertising_request_id_ ||
request.manager_slot < 0 || request.manager_slot > 3 ||
!g_.memory.has(::bmh::layout::ActiveManager) || int(g_.memory.u8(::bmh::layout::ActiveManager)) != request.manager_slot ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.renewal_display_slot < 0 || request.renewal_display_slot > 15 ||
request.renewal_contract_slot < 0 || request.renewal_contract_slot > 15 ||
request.offer != AdvertisingOfferRequest{} || request.spending != AdvertisingSpendingRequest{}) {
error = "Diese Werbeaktion ist nicht mehr aktuell.";
return std::nullopt;
}
const size_t record = size_t(request.manager_slot) * 0xb0c + 0xa34 +
size_t(request.renewal_contract_slot) * 0x0c;
if (record + 12 > g_.manager_records.size() ||
!std::equal(request.renewal_expected_contract.begin(), request.renewal_expected_contract.end(),
g_.manager_records.begin() + std::ptrdiff_t(record)) ||
(request.renewal_expected_contract[6] & 0x7f) == 0 || request.renewal_expected_contract[5] != 0) {
error = "Diese Vertragsverlängerung ist nicht mehr aktuell.";
return std::nullopt;
}
const auto checkpoint = advertising_session_checkpoint(revision);
const auto restore = [&] {
restore_advertising_session_checkpoint(checkpoint);
revision = checkpoint.revision;
};
advertising_renewal_dispatch_active_ = true;
struct ActiveReset { bool& active; ~ActiveReset() { active = false; } } active_reset{advertising_renewal_dispatch_active_};
try {
GameState staged = g_;
WatcomRandom staged_rand = rand_;
auto renewal = bmh::check_advertising_renewal(staged, request.manager_slot,
request.renewal_display_slot, staged_rand);
if (renewal.status == AdvertisingRenewal::Status::invalid ||
renewal.contract_slot != request.renewal_contract_slot ||
renewal.status == AdvertisingRenewal::Status::not_expired) {
restore(); error = "Diese Vertragsverlängerung ist nicht mehr aktuell."; return std::nullopt;
}
const auto presentation = presenter(staged, renewal);
if (!advertising_session_unchanged(checkpoint, revision)) {
restore(); error = "Die Session wurde während des Werbedialogs verändert."; return std::nullopt;
}
// Always restore the snapshot after presentation. This makes the rollback
// unconditional, including hidden owners, IDs and runtime maps; only the
// staged Source result below is allowed to become live.
restore();
if (renewal.status == AdvertisingRenewal::Status::offered) {
if (presentation != AdvertisingRenewalPresentation::renew &&
presentation != AdvertisingRenewalPresentation::decline) {
error = "Die Vertragsverlängerung wurde nicht bestätigt."; return std::nullopt;
}
const bool renew = presentation == AdvertisingRenewalPresentation::renew;
if (!bmh::answer_advertising_renewal(staged, request.manager_slot,
request.renewal_contract_slot, renew)) {
error = "Diese Vertragsverlängerung ist nicht mehr aktuell."; return std::nullopt;
}
} else if (renewal.status == AdvertisingRenewal::Status::declined_by_sponsor) {
if (presentation != AdvertisingRenewalPresentation::acknowledged) {
error = "Die Sponsorabsage wurde nicht bestätigt."; return std::nullopt;
}
} else {
error = "Unbekannter Source-Verlängerungsstatus."; return std::nullopt;
}
g_ = std::move(staged);
rand_ = staged_rand;
last_advertising_request_id_ = request.request_id;
++revision;
error.clear();
return renewal;
} catch (const std::exception&) {
restore(); error = "Die Vertragsverlängerung konnte nicht bestätigt werden."; return std::nullopt;
} catch (...) {
restore(); error = "Die Vertragsverlängerung konnte nicht bestätigt werden."; return std::nullopt;
}
}
bool CareerSession::apply_advertising(const ui::AdvertisingRequest& request, uint64_t& revision,
std::string& error, const AdvertisingAcknowledge& acknowledge,
const AdvertisingRenewalPresenter& presenter) {
auto before = advertising_checkpoint();
const auto old_revision = revision;
const auto restore = [&] {
restore_advertising_checkpoint(std::move(before));
revision = old_revision;
};
try {
AdvertisingActionResult result;
if (request.kind == ui::AdvertisingActionKind::check_renewal) {
if (!presenter) {
error = "Die Original-Verlängerungsfrage ist nicht verfügbar.";
restore(); return false;
}
result.renewal = dispatch_advertising_renewal(request, revision, error, presenter);
if (!result.renewal) { restore(); return false; }
} else if (!dispatch_advertising(request, revision, error, &result.spending)) {
restore(); return false;
}
if (acknowledge) acknowledge(result);
return true;
} catch (...) {
restore();
throw;
}
}
bool CareerSession::accept_advertising_selection(const ui::AdvertisingState& observed,
int display_slot, int raw_offer, uint64_t request_id, uint64_t& revision, std::string& error) {
if (display_slot < 0 || display_slot >= int(observed.offers.size())) {
error = "Dieses Werbeangebot kann nicht übernommen werden."; return false;
}
const auto& view = observed.offers[size_t(display_slot)];
const auto candidate = std::find_if(view.offers.begin(), view.offers.end(),
[&](const auto& offer) { return offer.raw_slot == raw_offer; });
if (candidate == view.offers.end()) {
error = "Dieses Werbeangebot kann nicht übernommen werden."; return false;
}
ui::AdvertisingRequest request;
request.request_id = request_id;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_team_id;
request.revision = observed.revision;
request.kind = ui::AdvertisingActionKind::accept_offer;
request.offer.manager = observed.manager_slot;
request.offer.display_slot = display_slot;
request.offer.contract_slot = view.contract_slot;
request.offer.expected_contract = view.contract_bytes;
request.offer.raw_slot = candidate->raw_slot;
request.offer.expected_offer = candidate->bytes;
return apply_advertising(request, revision, error);
}
bool CareerSession::set_advertising_budget(const ui::AdvertisingState& observed, int target_slot,
uint32_t amount, uint64_t request_id, uint64_t& revision, std::string& error,
AdvertisingSpendingResult& result) {
if (target_slot < 16 || target_slot > 18) {
error = "Dieser Werbeausgabenauftrag ist nicht mehr gültig."; return false;
}
const auto& view = observed.spending[size_t(target_slot - 16)];
ui::AdvertisingRequest request;
request.request_id = request_id;
request.manager_slot = observed.manager_slot;
request.runtime_club = observed.runtime_team_id;
request.revision = observed.revision;
request.kind = ui::AdvertisingActionKind::set_spending;
request.spending.manager = observed.manager_slot;
request.spending.target_slot = target_slot;
request.spending.amount = amount;
request.spending.expected_amount = view.current_amount;
request.spending.expected_delivery_weeks = view.delivery_weeks;
return apply_advertising(request, revision, error,
[&](const AdvertisingActionResult& applied) { result = applied.spending; });
}
bool CareerSession::dispatch_advertising(const ui::AdvertisingRequest& request, uint64_t& revision,
std::string& error, AdvertisingSpendingResult* spending_result) {
if (advertising_renewal_dispatch_active_) { error = "advertising_renewal_active"; return false; }
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
error.clear();
if (spending_result) *spending_result = {};
const int manager = request.manager_slot;
if (!g_.memory.has(::bmh::layout::ActiveManager) || manager < 0 || manager > 3 ||
size_t(manager) >= g_.manager_teams.size() || int(g_.memory.u8(::bmh::layout::ActiveManager)) != manager ||
request.runtime_club != g_.manager_teams[size_t(manager)] ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.request_id == 0 || request.request_id <= last_advertising_request_id_ ||
request.kind == ui::AdvertisingActionKind::check_renewal ||
request.renewal_display_slot != -1 || request.renewal_contract_slot != -1 ||
request.renewal_expected_contract != std::array<uint8_t, 12>{}) {
error = "Diese Werbeaktion ist nicht mehr aktuell.";
return false;
}
if (request.kind == ui::AdvertisingActionKind::accept_offer) {
if (request.offer.manager != manager || request.spending != AdvertisingSpendingRequest{}) {
error = "Das Werbeangebot enthält fremde Ausgabedaten.";
return false;
}
const auto result = accept_advertising_offer(g_, request.offer);
if (result.status != AdvertisingOfferStatus::accepted) {
error = result.status == AdvertisingOfferStatus::unsupported_extension
? "Diese Vertragsverlängerung ist noch nicht verfügbar."
: "Dieses Werbeangebot kann nicht übernommen werden.";
return false;
}
} else if (request.kind == ui::AdvertisingActionKind::set_spending) {
if (request.spending.manager != manager || request.offer != AdvertisingOfferRequest{}) {
error = "Der Ausgabenauftrag enthält fremde Vertragsdaten.";
return false;
}
const auto result = set_advertising_spending(g_, request.spending, rand_);
if (spending_result) *spending_result = result;
if (result.status != AdvertisingSpendingStatus::accepted &&
result.status != AdvertisingSpendingStatus::no_change &&
result.status != AdvertisingSpendingStatus::insufficient_funds) {
error = "Dieser Werbeausgabenauftrag ist nicht mehr gültig.";
return false;
}
// Insufficient funds is an Original handled response: it clears the old
// merchandise amount, but neither books cash nor draws a delivery delay.
} else {
error = "Unbekannte Werbeaktion.";
return false;
}
last_advertising_request_id_ = request.request_id;
++revision;
return true;
}
bool CareerSession::dispatch_contract(const ui::ContractRequest& request, uint64_t& revision,
ui::ContractActionResult& result, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const auto reject = [&](std::string message) { error = std::move(message); return false; };
const auto original_text = [&](uint32_t address) {
return ui::original_to_utf8(texts_[(address - ::bmh::layout::TextPointerTable) / 4]);
};
const int active = g_.memory.has(::bmh::layout::ActiveManager) ? int(g_.memory.u8(::bmh::layout::ActiveManager)) : -1;
if (request.request_id == 0 || request.request_id <= last_contract_request_id_ ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.manager_slot != active || active < 0 || active > 3 ||
size_t(active) >= g_.manager_teams.size() || request.runtime_club != g_.manager_teams[size_t(active)] ||
request.runtime_club == kNoTeam)
return reject("Der Vertragsauftrag gehört zu einem veralteten Manager oder Stand.");
const bool team_bonuses = request.kind == ui::ContractActionKind::submit_bonuses && request.row == -1;
const SquadRange range = squad_range(request.runtime_club);
int player = -1;
size_t board = 0;
if (team_bonuses) {
if (request.player_id != -1 || request.quote_id != 0)
return reject("Der Teamprämienauftrag enthält eine fremde Spieleridentität.");
} else {
if (request.row < 0 || size_t(request.row) >= range.count || request.row >= 24 ||
range.first + size_t(request.row) >= g_.squad_slots.size())
return reject("Der ausgewählte Kaderplatz ist nicht mehr gültig.");
player = g_.squad_slots[range.first + size_t(request.row)] & 0x0fff;
if (player == 0x0fff || player != request.player_id || size_t(player) >= g_.players.size())
return reject("Der Spieler gehört nicht mehr zu diesem Kaderplatz.");
board = size_t(active) * 0x840 + size_t(request.row) * 0x58;
if (board + 0x58 > g_.tactics.size()) return reject("Der Vertragsdatensatz ist unvollständig.");
}
if (request.kind == ui::ContractActionKind::request_demands) {
if (request.quote_id != 0 || request.term_column != 0 || request.demand != 0 || request.monthly_salary != 0 ||
request.insurance_months != 0 || std::any_of(request.proposed_bonuses.begin(),
request.proposed_bonuses.end(), [](uint8_t b) { return b != 0; }))
return reject("Der Forderungsauftrag enthält ungültige Angebotsdaten.");
GameState staged_game = g_;
WatcomRandom staged_rand = rand_;
std::array<uint32_t, 4> demands{};
try { demands = contract_demands(staged_game, active, request.row, true, staged_rand); }
catch (const std::exception&) { return reject("Die Gehaltsforderungen konnten nicht ermittelt werden."); }
if (save_stream(staged_game) != save_stream(g_))
return reject("Die Forderungsabfrage hat unerwartet den Spielstand verändert.");
rand_ = staged_rand;
++revision;
ContractQuoteRecord quote;
quote.quote_id = next_contract_quote_id_++;
quote.request_id = request.request_id;
quote.revision = revision;
quote.manager_slot = active;
quote.runtime_club = request.runtime_club;
quote.row = request.row;
quote.player_id = player;
quote.demands = demands;
contract_quote_ = quote;
last_contract_request_id_ = request.request_id;
result.success = true;
result.quote_id = quote.quote_id;
result.demands = demands;
return true;
}
if (!team_bonuses && (!contract_quote_ || request.quote_id != contract_quote_->quote_id ||
request.request_id <= contract_quote_->request_id || request.revision != contract_quote_->revision ||
request.manager_slot != contract_quote_->manager_slot || request.runtime_club != contract_quote_->runtime_club ||
request.row != contract_quote_->row || player != contract_quote_->player_id))
return reject("Dieser Auftrag ist nicht mehr an die aktuelle Verhandlung gebunden.");
const bool full_mode = g_.memory.u8(::bmh::layout::GameMode) == 3;
if (request.kind == ui::ContractActionKind::insure_player) {
if (!full_mode || request.term_column >= 4 || request.insurance_months < 1 || request.insurance_months > 60 ||
request.demand != 0 || request.monthly_salary != 0 ||
std::any_of(request.proposed_bonuses.begin(), request.proposed_bonuses.end(), [](uint8_t b) { return b != 0; }))
return reject("Der Versicherungsauftrag enthält ungültige Daten.");
// ContractBonuses checks these in this order and uses the corresponding Original dialog.
if (g_.tactics[board + 0x0b] & 0x20) return reject(original_text(::bmh::layout::CareerSession_Reject_TextPointer));
if (g_.tactics[board + 0x0b] & 0x40) return reject(original_text(::bmh::layout::CareerSession_Reject_TextPointer2));
if (g_.tactics[board + 0x43] != 0) return reject(original_text(::bmh::layout::CareerSession_Reject_TextPointer3));
if (g_.players[size_t(player)].w35c >> 27) return reject(original_text(::bmh::layout::CareerSession_Reject_TextPointer4));
GameState staged_game = g_;
if (!contract_insurance(staged_game, active, request.row, request.term_column, request.insurance_months).accepted)
return reject("Die Versicherung konnte nicht bestätigt werden.");
g_ = std::move(staged_game);
++revision;
last_contract_request_id_ = request.request_id;
contract_quote_->revision = revision;
result.success = result.accepted = true;
result.quote_id = contract_quote_->quote_id;
result.demands = contract_quote_->demands;
return true;
}
for (size_t i = 0; i < request.proposed_bonuses.size(); ++i)
if (request.proposed_bonuses[i] > (i < 3 ? 20 : 200))
return reject("Die Prämie liegt über dem Originalmaximum.");
if (request.kind == ui::ContractActionKind::submit_bonuses) {
if (!full_mode || request.term_column != 0 || request.demand != 0 || request.monthly_salary != 0 ||
request.insurance_months != 0) return reject("Der Prämienauftrag enthält ungültige Daten.");
GameState staged_game = g_;
const bool accepted = contract_bonuses(staged_game, active, request.row, request.proposed_bonuses);
g_ = std::move(staged_game);
++revision;
last_contract_request_id_ = request.request_id;
contract_quote_.reset();
result.success = true;
result.accepted = accepted;
result.feedback = accepted ? original_text(team_bonuses ? ::bmh::layout::CareerSession_Reject_TextPointer8 : ::bmh::layout::CareerSession_Reject_TextPointer9) :
team_bonuses ? original_text(::bmh::layout::CareerSession_Reject_TextPointer7) : std::string{};
return true;
}
if (request.kind != ui::ContractActionKind::submit_offer || request.term_column >= 4 || request.insurance_months != 0 ||
request.demand != contract_quote_->demands[request.term_column] || request.demand == 0 ||
request.demand == std::numeric_limits<uint32_t>::max() || request.monthly_salary > 200000 ||
(g_.tactics[board + 0x4f] & 0x80) || (g_.tactics[board + 0x0b] & 0x60))
return reject("Dieses Angebot ist im Original nicht mehr verhandelbar.");
if (!full_mode && !std::equal(request.proposed_bonuses.begin(), request.proposed_bonuses.end(),
g_.tactics.begin() + long(board + 0x12)))
return reject("Prämienänderungen sind nur in Spielmodus III verfügbar.");
GameState staged_game = g_;
WatcomRandom staged_rand = rand_;
bool accepted = false;
try {
accepted = contract_offer(staged_game, active, request.row, request.term_column,
request.monthly_salary, request.demand, false, false, staged_rand,
&request.proposed_bonuses);
} catch (const std::exception&) { return reject("Der Vertrag konnte nicht verhandelt werden."); }
g_ = std::move(staged_game);
rand_ = staged_rand;
++revision;
last_contract_request_id_ = request.request_id;
contract_quote_.reset();
result.success = true;
result.accepted = accepted;
result.feedback = original_text(accepted ? ::bmh::layout::CareerSession_Reject_TextPointer5 : ::bmh::layout::CareerSession_Reject_TextPointer6);
return true;
}
bool CareerSession::validate_desk_setting_owner(const DeskSettingIdentity& identity, uint64_t revision,
std::string& error, bool require_desk_phase) const {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
if (balance_draft_ || balance_dispatch_active_ || league_pairings_draft_ || league_pairings_dispatch_active_) {
error = "league_pairings_active"; return false;
}
if (career_complete()) { error = "career_complete"; return false; }
if (require_desk_phase && ((turn_driver_.stage != TurnDriver::Stage::MatchdayDesks &&
turn_driver_.stage != TurnDriver::Stage::SeasonEndDesk) ||
pending_offer_dispatch_active_ || market_dispatch_active_ || calendar_advance_active_ ||
transfer_offer_editor_ || manager_join_ || contract_quote_ || stadium_.investment ||
stadium_.tip || stadium_.periphery_quote)) {
error = "desk_setting_unavailable"; return false;
}
const int active = g_.memory.has(::bmh::layout::ActiveManager) ? int(g_.memory.u8(::bmh::layout::ActiveManager)) : -1;
if (identity.manager_slot != active || active < 0 || active > 3 ||
size_t(active) >= g_.manager_teams.size() || identity.revision != revision || revision == UINT64_MAX) {
error = "stale_manager_or_revision"; return false;
}
const int club = g_.manager_teams[size_t(active)];
const size_t rec = size_t(active) * 0xb0c;
if (identity.runtime_club != club || club < 0 || club > kNoTeam || size_t(club) >= g_.club_ids.size() ||
identity.stable_club_identity != std::optional<int>(int(g_.club_ids[size_t(club)])) ||
rec + 0xb0c > g_.manager_records.size() || size_t(active + 1) * 5 > g_.manager_options.size() ||
(int(g_.manager_records[rec + 0x290]) | int(g_.manager_records[rec + 0x291]) << 8) != club) {
error = "invalid_desk_setting_owner"; return false;
}
return true;
}
bool CareerSession::apply_desk_setting(int manager, bool price, int index, int value, std::string& error) {
const size_t rec = size_t(manager) * 0xb0c;
const bool national = g_.manager_teams[size_t(manager)] == kNoTeam;
if (price) {
// Uint8T4: local offsets35..86 map to admission values8..25.
if (national || value < 8 || value > 25) { error = "invalid_ticket_price"; return false; }
g_.manager_records[rec + 0x26e] = uint8_t(value);
} else {
if (index < 0 || index > 4) { error = "invalid_automation_index"; return false; }
const size_t at = size_t(manager) * 5 + size_t(index);
if (index == 0) {
if (g_.manager_options[at] > 8 || value < 0 || value > 8) {
error = "invalid_saved_formation_automation"; return false;
}
// SizeT6 uses the saved outdoor/indoor formation availability.
const uint8_t mask = g_.manager_records[rec + 0x218 + size_t(g_.indoor)];
if (value != 0 && !(mask & (1u << (value - 1)))) {
error = "unavailable_saved_formation"; return false;
}
g_.manager_options[at] = uint8_t(value);
} else {
if (index == 4 && national) { error = "national_team_training_unavailable"; return false; }
if (value != 0 && value != 1) { error = "invalid_automation_value"; return false; }
// Explicit bool setters and SDL toggles preserve every other bit.
g_.manager_options[at] = uint8_t((g_.manager_options[at] & ~uint8_t(1)) | uint8_t(value));
}
}
error.clear();
return true;
}
bool CareerSession::dispatch_ticket_price(const TicketPriceRequest& request, uint64_t& revision,
std::string& error) {
if (!validate_desk_setting_owner(request.identity, revision, error)) return false;
if (request.price < 8 || request.price > 25) { error = "invalid_ticket_price"; return false; }
if (!apply_desk_setting(request.identity.manager_slot, true, -1, request.price, error)) return false;
++revision;
return true;
}
bool CareerSession::dispatch_automation(const AutomationRequest& request, uint64_t& revision,
std::string& error) {
if (!validate_desk_setting_owner(request.identity, revision, error)) return false;
const int index = int(request.automation);
if (index < 0 || index > 4) { error = "invalid_automation_index"; return false; }
int value = int(request.enabled);
if (index == 0) {
if (request.enabled != request.formation.has_value() ||
(request.formation && (*request.formation < 1 || *request.formation > 8))) {
error = "invalid_saved_formation_automation"; return false;
}
value = request.formation.value_or(0);
} else if (request.formation) { error = "unexpected_formation_selection"; return false; }
if (!apply_desk_setting(request.identity.manager_slot, false, index, value, error)) return false;
++revision;
return true;
}
bool CareerSession::dispatch_desk_widget(const ui::DeskRequest& request, uint64_t& revision,
std::string& error) {
const int active = g_.memory.has(::bmh::layout::ActiveManager) ? int(g_.memory.u8(::bmh::layout::ActiveManager)) : -1;
DeskSettingIdentity identity{request.manager_slot, -1, std::nullopt, request.revision};
if (active >= 0 && size_t(active) < g_.manager_teams.size()) {
identity.runtime_club = g_.manager_teams[size_t(active)];
if (identity.runtime_club >= 0 && size_t(identity.runtime_club) < g_.club_ids.size())
identity.stable_club_identity = int(g_.club_ids[size_t(identity.runtime_club)]);
}
if (!validate_desk_setting_owner(identity, revision, error, false)) return false;
// Refuse malformed saved formation state before projecting widget ownership.
// The desktop renderer cannot project indices outside the stored 0..8 range.
if (g_.manager_options[size_t(active) * 5] > 8) {
error = "invalid_saved_formation_automation"; return false;
}
const bool price = request.kind == ui::DeskRequestKind::change_ticket_price;
if (!price && request.kind != ui::DeskRequestKind::change_option) {
error = "unsupported_desk_widget"; return false;
}
// Keep SDL requests bound to a visible and enabled MEN drawer/item; the frame bit is optional.
const auto desk = desktop_projection(revision);
const int expected_kind = price ? 55 : 64;
const auto item = std::find_if(desk.items.begin(), desk.items.end(), [&](const ui::DeskItem& item) {
return item.id == request.item_id && item.kind == expected_kind && !item.disabled;
});
if (request.menu_kind != expected_kind || item == desk.items.end()) {
error = "stale_or_closed_desk_widget"; return false;
}
int value = request.value;
if (!price) {
if (request.value < 0 || request.value > 4) { error = "invalid_automation_index"; return false; }
const size_t at = size_t(active) * 5 + size_t(request.value);
if (request.value == 0) {
if (g_.manager_options[at] > 8) { error = "invalid_saved_formation_automation"; return false; }
value = g_.manager_options[at];
const uint8_t mask = g_.manager_records[size_t(active) * 0xb0c + 0x218 + size_t(g_.indoor)];
do { value = (value + 1) % 9; } while (value != 0 && !(mask & (1u << (value - 1))));
} else value = (g_.manager_options[at] ^ 1) & 1;
}
if (!apply_desk_setting(active, price, request.value, value, error)) return false;
++revision;
return true;
}
bool CareerSession::dispatch_desktop_layout(const ui::DeskRequest& request, uint64_t& revision,
std::string& error) {
constexpr size_t kItems=54, kStride=16, kBytes=kItems*kStride;
if (request.kind != ui::DeskRequestKind::change_layout || request.revision != revision ||
request.manager_slot < 0 || size_t(request.manager_slot) >= g_.manager_teams.size() ||
!g_.memory.has(::bmh::layout::ActiveManager) || int(g_.memory.u8(::bmh::layout::ActiveManager)) != request.manager_slot ||
turn_driver_.stage==TurnDriver::Stage::Failed || turn_driver_.stage==TurnDriver::Stage::CareerComplete ||
career_complete()) {
error="stale_or_invalid_desk_layout_owner"; return false;
}
if (transfer_offer_editor_ || pending_offer_dispatch_active_ || market_dispatch_active_ ||
balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || other_games_owner_ || other_games_dispatch_active_ ||
stadium_.block_expansion || advertising_renewal_dispatch_active_) {
error="desk_layout_blocked_during_active_flow"; return false;
}
if (request.item_id < 1 || request.item_id >= int(kItems)) { error="invalid_desk_layout_item"; return false; }
const uint32_t base=::bmh::layout::DesktopsUnsigned+uint32_t(request.manager_slot)*0x360u;
if (!g_.memory.has(base+kBytes-1)) { error="desk_layout_memory_unavailable"; return false; }
std::array<uint8_t,kBytes> actual{};
for(size_t i=0;i<kBytes;++i) actual[i]=g_.memory.u8(base+uint32_t(i));
if(actual!=request.layout_before) { error="stale_desk_layout_before_state"; return false; }
auto expected=request.layout_before;
const size_t at=size_t(request.item_id)*kStride;
auto read16=[](const auto& bytes,size_t offset){return uint16_t(bytes[offset])|(uint16_t(bytes[offset+1])<<8);};
auto write16=[](auto& bytes,size_t offset,uint16_t value){bytes[offset]=uint8_t(value);bytes[offset+1]=uint8_t(value>>8);};
const auto moved_x=read16(request.layout_after,at);
const uint8_t moved_y=request.layout_after[at+2];
if(request.menu_kind!=expected[at+12]) { error="desk_layout_item_kind_mismatch"; return false; }
const bool source_drag_enabled=g_.memory.has(::bmh::layout::CareerSession_DispatchDesktopLayout_RuntimeField)&&g_.memory.u8(::bmh::layout::CareerSession_DispatchDesktopLayout_RuntimeField)==0;
if((request.layout_operation==ui::DeskLayoutOperation::move_item||
request.layout_operation==ui::DeskLayoutOperation::set_folder||
request.layout_operation==ui::DeskLayoutOperation::return_folder_child||
request.layout_operation==ui::DeskLayoutOperation::send_to_folder||
request.layout_operation==ui::DeskLayoutOperation::restore_folder_child)&&!source_drag_enabled) {
error="source_desk_drag_disabled";return false;
}
switch(request.layout_operation) {
case ui::DeskLayoutOperation::move_item: {
if(request.layout_target_item!=-1 || expected[at+12]==72) { error="invalid_desk_layout_move_target"; return false; }
for(size_t i=0;i<kBytes;++i) if(i!=at&&i!=at+1&&i!=at+2&&request.layout_after[i]!=expected[i]) {
error="desk_layout_move_changed_unowned_bytes"; return false;
}
const int source_x=int(moved_x&0xefff), max_x=std::max(1,319-int(expected[at+3]));
const int max_y=std::max(1,239-int(expected[at+4]));
const bool snap=g_.memory.has(::bmh::layout::CareerSession_DispatchDesktopLayout_RuntimeField2) && g_.memory.u8(::bmh::layout::CareerSession_DispatchDesktopLayout_RuntimeField2)==0;
if((moved_x&0x1000)!=(read16(expected,at)&0x1000) || source_x<1 || source_x>max_x ||
moved_y<1 || moved_y>max_y ||
(snap && ((source_x%5)!=0 && source_x!=max_x || (moved_y%5)!=0 && moved_y!=max_y))) {
error="desk_layout_move_outside_source_bounds"; return false;
}
write16(expected,at,moved_x); expected[at+2]=moved_y;
break;
}
case ui::DeskLayoutOperation::toggle_quickbar_drawer: {
const int id=request.item_id;
const int kind=expected[at+12];
if(request.layout_target_item!=id || id<1 || id>=54 || kind<50 || kind>71 ||
kind!=request.menu_kind || (request.value!=2 && request.value!=8)) {
error="invalid_desk_quickbar_drawer"; return false;
}
if(expected[at+5]==0xff) {
int tail=0;
size_t guard=0;
while(expected[size_t(tail)*kStride+5]!=0) {
if(++guard>=kItems) { error="invalid_desk_layout_chain"; return false; }
tail=expected[size_t(tail)*kStride+5];
if(tail<0 || tail>=int(kItems)) { error="invalid_desk_layout_links"; return false; }
}
expected[at+5]=0; expected[at+6]=uint8_t(tail);
expected[size_t(tail)*kStride+5]=uint8_t(id);
const bool opened=!(request.value==8 && id>2);
expected[at+13]=uint8_t((expected[at+13]&0x7f)|(opened?0x80:0));
} else {
const uint8_t previous=expected[at+6],next=expected[at+5];
if(previous>=kItems || (next!=0 && next>=kItems)) { error="invalid_desk_layout_links"; return false; }
expected[size_t(previous)*kStride+5]=next;
if(next!=0) expected[size_t(next)*kStride+6]=previous;
expected[at+5]=expected[at+6]=0xff;
}
break;
}
case ui::DeskLayoutOperation::return_folder_child: {
const int folder=request.layout_target_item;
if(request.item_id<1||request.item_id>30||folder<0||folder>=3||
expected[at+5]!=0xff||expected[at+6]!=0xff||(expected[at+1]&0x10)!=0||
(expected[at+13]&0x7f)!=folder||expected[at+12]>=50) {
error="invalid_desk_folder_child_return"; return false;
}
bool owner_visible=false;
for(size_t item=1;item<kItems;++item) {
// The frame bit does not hide folder contents; require a visible linked owner.
if(expected[item*kStride+12]!=50+folder||(expected[item*kStride+1]&0x10)!=0) continue;
int cursor=0;size_t visited=0;
while(++visited<kItems) {
const int next=expected[size_t(cursor)*kStride+5];
if(next==int(item)) { owner_visible=true;break; }
if(next<=0||next>=int(kItems)) break;
cursor=next;
}
if(owner_visible) break;
}
if(!owner_visible) { error="desk_folder_child_owner_hidden"; return false; }
const int max_x=std::max(1,319-int(expected[at+3])),max_y=std::max(1,239-int(expected[at+4]));
const int source_x=int(moved_x&0xefff);
const bool snap=g_.memory.has(::bmh::layout::CareerSession_DispatchDesktopLayout_RuntimeField2)&&g_.memory.u8(::bmh::layout::CareerSession_DispatchDesktopLayout_RuntimeField2)==0;
if((moved_x&0x1000)!=(read16(expected,at)&0x1000)||source_x<1||source_x>max_x||moved_y<1||moved_y>max_y||
(snap&&(((source_x%5)!=0&&source_x!=max_x)||((moved_y%5)!=0&&moved_y!=max_y)))) {
error="desk_folder_child_return_outside_source_bounds";return false;
}
int tail=0;size_t guard=0;
while(expected[size_t(tail)*kStride+5]!=0) {
if(++guard>=kItems) { error="invalid_desk_layout_chain";return false; }
tail=expected[size_t(tail)*kStride+5];
if(tail<0||tail>=int(kItems)) { error="invalid_desk_layout_links";return false; }
}
expected[at]=request.layout_after[at];expected[at+1]=request.layout_after[at+1];expected[at+2]=moved_y;
expected[at+5]=0;expected[at+6]=uint8_t(tail);
expected[size_t(tail)*kStride+5]=uint8_t(request.item_id);
break;
}
case ui::DeskLayoutOperation::send_to_folder: {
const int folder=request.layout_target_item;
const uint8_t previous=expected[at+6],next=expected[at+5];
if(request.item_id<1||request.item_id>30||folder<0||folder>=3||
expected[at+5]==0xff||expected[at+12]>=50||expected[at+12]==12||
(expected[at+13]&0x7f)!=folder||previous>=kItems||(next!=0&&next>=kItems)||
expected[size_t(previous)*kStride+5]!=request.item_id||
(next!=0&&expected[size_t(next)*kStride+6]!=request.item_id)) {
error="invalid_desk_bin_send";return false;
}
expected[size_t(previous)*kStride+5]=next;
if(next!=0)expected[size_t(next)*kStride+6]=previous;
expected[at+5]=expected[at+6]=0xff;
break;
}
case ui::DeskLayoutOperation::restore_folder_child: {
const int folder=request.layout_target_item;
if(request.item_id<1||request.item_id>30||folder<0||folder>=3||
expected[at+5]!=0xff||expected[at+6]!=0xff||(expected[at+1]&0x10)!=0||
(expected[at+13]&0x7f)!=folder||expected[at+12]>=50) {
error="invalid_desk_bin_restore";return false;
}
bool owner_visible=false;
for(size_t item=1;item<kItems;++item) {
// The frame bit does not hide folder contents; require a visible linked owner.
if(expected[item*kStride+12]!=50+folder||(expected[item*kStride+1]&0x10)!=0) continue;
int cursor=0;size_t visited=0;
while(++visited<kItems) {
const int next=expected[size_t(cursor)*kStride+5];
if(next==int(item)) { owner_visible=true;break; }
if(next<=0||next>=int(kItems)) break;
cursor=next;
}
if(owner_visible)break;
}
if(!owner_visible) { error="desk_bin_restore_folder_hidden";return false; }
int tail=0;size_t guard=0;
while(expected[size_t(tail)*kStride+5]!=0) {
if(++guard>=kItems) { error="invalid_desk_layout_chain";return false; }
tail=expected[size_t(tail)*kStride+5];
if(tail<0||tail>=int(kItems)) { error="invalid_desk_layout_links";return false; }
}
expected[at+5]=0;expected[at+6]=uint8_t(tail);
expected[size_t(tail)*kStride+5]=uint8_t(request.item_id);
break;
}
case ui::DeskLayoutOperation::set_folder: {
const int target=request.layout_target_item;
const int kind=expected[at+12];
if(kind>=50 || request.item_id>30 || (expected[at+1]&0x10)!=0 || target<1 || target>=int(kItems) || expected[size_t(target)*kStride+12]<50 ||
expected[size_t(target)*kStride+12]>52) { error="invalid_desk_folder_drop"; return false; }
const size_t target_at=size_t(target)*kStride;
const uint8_t folder=uint8_t(expected[target_at+12]-50);
int folder_count=0;
for(int child=1;child<=30;++child) {
const size_t child_at=size_t(child)*kStride;
if(expected[child_at+5]==0xff && (expected[child_at+1]&0x10)==0 &&
(expected[child_at+13]&0x7f)==folder) ++folder_count;
}
const bool already_in_folder=expected[at+5]==0xff&&(expected[at+13]&0x7f)==folder;
if(folder_count-(already_in_folder?1:0)>=12) { error="desk_folder_source_capacity"; return false; }
const int previous=expected[at+6], next=expected[at+5];
if((previous!=0xff && previous>=int(kItems)) || (next!=0xff && next>=kItems)) { error="invalid_desk_layout_links"; return false; }
if(previous!=0xff) expected[size_t(previous)*kStride+5]=uint8_t(next);
if(next>0 && next<0xff) expected[size_t(next)*kStride+6]=uint8_t(previous);
expected[at+13]=uint8_t((expected[at+13]&0x80)|folder);
expected[at+5]=expected[at+6]=0xff;
write16(expected,at,moved_x); expected[at+2]=moved_y;
break;
}
case ui::DeskLayoutOperation::none:
error="unsupported_desk_layout_operation"; return false;
}
if(expected!=request.layout_after) { error="desk_layout_after_state_not_source_derived"; return false; }
GameState staged=g_;
for(size_t i=0;i<kBytes;++i) staged.memory.set8(base+uint32_t(i),expected[i]);
try {
const auto projected=desktop_projection(staged,revision+1);
if(projected.manager_slot!=request.manager_slot) { error="desk_layout_projection_mismatch"; return false; }
for(size_t item=0;item<kItems;++item)
if(!std::equal(projected.layout_records[item].begin(),projected.layout_records[item].end(),expected.begin()+item*kStride)) {
error="desk_layout_projection_mismatch"; return false;
}
} catch(const std::exception&) { error="desk_layout_projection_invalid"; return false; }
g_=std::move(staged); ++revision; error.clear(); return true;
}
bool CareerSession::dispatch_tactics(const ui::TacticsRequest& request, uint64_t& revision,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
error.clear();
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (request.manager_slot != active || request.manager_slot < 0 || request.manager_slot > 3 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] ||
request.revision != revision) {
error = "Die Taktikanfrage ist veraltet."; return false;
}
if (request.kind != ui::TacticsRequestKind::set_tactic || request.index < 0 || request.index >= 8 ||
request.desired_value < 0 || request.desired_value > exe_.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField + request.index)) {
error = "Ungültige Taktikeinstellung."; return false;
}
const bool live_option = (g_.memory.has(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField3) ? g_.memory.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField3) : exe_.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField3)) != 0;
if (live_option && exe_.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField2 + request.index) == 0) {
error = "Diese Taktikeinstellung ist nicht verfügbar."; return false;
}
if ((request.index == 0 && request.desired_assistant_attitude != std::optional<uint8_t>(0)) ||
(request.index != 0 && request.desired_assistant_attitude)) {
error = "Ungültige Assistenteneinstellung."; return false;
}
// RerateTeam: only +d2..+d9 and (index 0) option byte +2.
// The tactic board, player order and both RNG streams stay untouched.
const size_t rec = size_t(request.manager_slot) * 0xb0c;
const size_t option = size_t(request.manager_slot) * 5 + 2;
if (g_.manager_records.size() < rec + 0xb0c || g_.manager_options.size() <= option) {
error = "Die Taktikdaten sind unvollständig."; return false;
}
g_.manager_records[rec + 0xd2 + size_t(request.index)] = uint8_t(request.desired_value);
if (request.index == 0) g_.manager_options[option] = 0;
++revision;
return true;
}
bool CareerSession::dispatch_lineup(const ui::LineupRequest& request, uint64_t& revision,
std::string& error) {
if (calendar_advance_active_ || pending_offer_dispatch_active_) {
error = "lineup_unavailable_during_calendar_advance";
return false;
}
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
error.clear();
const int active = g_.memory.has(::bmh::layout::ActiveManager) ? int(g_.memory.u8(::bmh::layout::ActiveManager)) : -1;
if (request.manager_slot != active || active < 0 || active > 3 ||
size_t(active) >= g_.manager_teams.size() || request.runtime_club != g_.manager_teams[size_t(active)] ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.runtime_club < 0 || request.runtime_club >= int(g_.team_flags.size())) {
error = "Die Aufstellungsaktion ist veraltet.";
return false;
}
const SquadRange range = squad_range(request.runtime_club);
if (range.count < 11 || range.first + range.count > g_.squad_slots.size() ||
g_.tactics.size() < size_t(active + 1) * 0x840 ||
g_.manager_options.size() <= size_t(active) * 5 || g_.player_cards.size() != g_.players.size()) {
error = "Der Aufstellungszustand ist unvollständig.";
return false;
}
if (request.kind == ui::LineupRequestKind::prepare_lineup) {
GameState staged = g_;
try {
// PitchScreen opens through the human Int2 path first.
// Existing assistant scoring retains its documented port limitations.
auto_lineup(staged, request.runtime_club, 0xe4);
prepare_lineup_entry(staged, request.runtime_club); // PrepareLineupEntry.
open_lineup_screen(staged, active); // OpenBMH deviates from the original: supports designated set-piece record initialization and validation.
// supported rule profile NormalizePitchSetPieceSource entry initialization.
if (!initialize_pitch_set_piece_source(staged, active, request.runtime_club))
throw std::runtime_error("set-piece set-piece record did not validate");
const uint32_t display=uint32_t(::bmh::layout::CareerSession_AnyOf_ExecutableField+active*2);
if(staged.memory.has(display)&&(staged.memory.u16(display)&0x80)&&
!normalize_pitch_set_piece_source(staged,active,request.runtime_club))
throw std::runtime_error("set-piece reentry redraw did not validate");
} catch (const std::exception& e) {
error = std::string("Diese Aufstellung kann im aktuellen Spielmodus noch nicht vorbereitet werden. (") + e.what() + ")";
return false;
}
// Accept only the valid authoritative eleven produced by the human path.
std::array<bool, 0x1000> seen{};
for (int row = 0; row < 11; ++row) {
const uint16_t slot = staged.squad_slots.at(range.first + size_t(row));
const int id = slot & 0x0fff;
const auto* board = staged.tactics.data() + size_t(active) * 0x840 + size_t(row) * 0x58;
if (id == 0x0fff || size_t(id) >= g_.players.size() || seen[size_t(id)] ||
!(slot & 0x8000) || (slot & 0x4000) || int8_t(board[0x41]) < 0 ||
int8_t(board[0x41]) > 19 || int8_t(board[0x42]) < 0 || int8_t(board[0x42]) > 8) {
error = "Die Aufstellung ist noch nicht für den Anstoß vorbereitet.";
return false;
}
seen[size_t(id)] = true;
}
g_ = std::move(staged);
lineup_entry_manager_ = active;
lineup_entry_club_ = request.runtime_club;
++revision;
return true;
}
if (request.kind != ui::LineupRequestKind::swap_players ||
lineup_entry_manager_ != active || lineup_entry_club_ != request.runtime_club ||
request.first_row < 0 || request.second_row < 0 || request.first_row == request.second_row ||
size_t(request.first_row) >= range.count || size_t(request.second_row) >= range.count) {
error = "Der Spielerwechsel ist nicht freigegeben.";
return false;
}
const size_t first = range.first + size_t(request.first_row);
const size_t second = range.first + size_t(request.second_row);
const uint16_t first_slot = g_.squad_slots.at(first), second_slot = g_.squad_slots.at(second);
const int first_id = (first_slot & 0x0fff) == 0x0fff ? -1 : first_slot & 0x0fff;
const int second_id = (second_slot & 0x0fff) == 0x0fff ? -1 : second_slot & 0x0fff;
if (first_slot != request.first_slot || second_slot != request.second_slot ||
first_id != request.first_player || second_id != request.second_player ||
first_id < 0 || second_id < 0 || size_t(first_id) >= g_.players.size() || size_t(second_id) >= g_.players.size()) {
error = "Die Kaderzeilen wurden inzwischen geändert.";
return false;
}
// SizeT3 requires injury/foreign-rule confirmations for special
// swaps. Until those dialogs exist, reject that path before any writes.
if (((g_.players[size_t(first_id)].w364 >> 16) & 0x1f) != 0 ||
((g_.players[size_t(second_id)].w364 >> 16) & 0x1f) != 0) {
error = "Ein verletzter Spieler kann hier noch nicht eingewechselt werden.";
return false;
}
if ((request.first_row < 11) != (request.second_row < 11) && exe_.u8(::bmh::layout::ForeignPlayerLimitEnabled) != 0) {
error = "Dieser Wechsel benötigt eine Bestätigung der Ausländerregel.";
return false;
}
const size_t board_base = size_t(active) * 0x840;
auto* a = g_.tactics.data() + board_base + size_t(request.first_row) * 0x58;
auto* b = g_.tactics.data() + board_base + size_t(request.second_row) * 0x58;
const uint8_t ax = a[0x41], ay = a[0x42], bx = b[0x41], by = b[0x42];
// Original SquadSlotsBoardEntriesChangePlaces moves the player/tactics entry, then restores
// the 0xc000 role bits to their roster rows. Preserve bit 12 and the
// player id with the entry; keep the starter/bench flags with the slot.
g_.squad_slots[first] = uint16_t((second_slot & 0x1fff) | (first_slot & 0xc000));
g_.squad_slots[second] = uint16_t((first_slot & 0x1fff) | (second_slot & 0xc000));
std::swap_ranges(a, a + 0x58, b);
a[0x41] = ax; a[0x42] = ay; b[0x41] = bx; b[0x42] = by;
// GatedByParamLive is applied to every marked row, not just the two swapped
// players. Keep card-side row identity synchronized with the roster.
for (size_t row = 0; row < range.count; ++row) {
const uint16_t slot = g_.squad_slots[range.first + row];
if ((slot & 0xc000) == 0) continue;
const size_t id = slot & 0x0fff;
if (id >= g_.players.size()) continue;
g_.player_cards[id] = uint16_t((g_.player_cards[id] & 0xffe0) | uint16_t(row));
}
g_.manager_options.at(size_t(active) * 5) = 0; // source manual mode selects DispatchLiveOverview
++revision;
return true;
}
std::optional<CareerSession::LiveOverviewDispatch> CareerSession::dispatch_live_overview(
const LiveOverviewAction& action, MatchEngine& engine, uint64_t& revision, std::string& error,
const TransferOfferTeamInfoPresenter& team_info) {
error.clear();
if (!calendar_advance_active_ || !live_overview_owner_ || revision==UINT64_MAX || live_overview_owner_->request.revision!=revision ||
&engine.state!=&g_ || &engine.game!=&game_ || &engine.rand!=&rand_ ||
(live_overview_owner_->phase_result
? (!phase_result_request_ || live_overview_owner_->request.group_index!=int(phase_result_request_->group_index))
: live_overview_owner_->request.group_index!=0) || engine.groups.empty() ||
engine.groups.size()!=live_overview_owner_->active_groups.size() ||
engine.groups.size()!=turn_driver_.groups.size() ||
engine.groups.front().desc!=turn_driver_.groups.front().desc ||
engine.groups.front().fixtures!=turn_driver_.groups.front().fixtures ||
engine.referees!=live_overview_owner_->referees) {
error="live overview: stale owner or no longer at the Source minute boundary";
return {};
}
for(size_t i=0;i<engine.groups.size();++i)
if(engine.groups[i].desc!=live_overview_owner_->active_groups[i].first ||
engine.groups[i].fixtures!=live_overview_owner_->active_groups[i].second) {
error="live overview: active Source match group changed";return {};
}
const auto live= *live_overview_owner_;
struct LiveBoundaryFamilyScope {
bool& active; bool previous;
explicit LiveBoundaryFamilyScope(bool& value) : active(value), previous(value) { active=false; }
~LiveBoundaryFamilyScope() { active=previous; }
} family_scope(calendar_advance_active_);
LiveOverviewDispatch result;result.kind=live.kind;
try {
if(const auto* family=std::get_if<ui::LeagueFamilyRequest>(&action)) {
if((live.kind!=LiveOverviewKind::league_table&&live.kind!=LiveOverviewKind::league_pairings&&
live.kind!=LiveOverviewKind::league_strengths) ||
family->identity!=live.family_identity || family->identity.revision!=revision ||
!league_family_owner_ || league_family_owner_->identity!=family->identity ||
family->from_child!=league_family_owner_->child)
throw FormatError("live overview: mismatched League family owner");
if(family->kind==ui::LeagueFamilyRequestKind::close) {
auto preparation=close_league_family(*family,revision,error);
if(!preparation)throw FormatError(error.empty()?"live overview: Source family close rejected":error);
result.closed=true;result.preparation=std::move(*preparation);live_overview_owner_.reset();return result;
}
if(family->kind==ui::LeagueFamilyRequestKind::control && family->from_child==1) {
auto page=dispatch_league_table_control(*family,revision,error);
if(!page)throw FormatError(error.empty()?"live overview: Source Table control rejected":error);
result.table=page->page;result.family_identity=page->identity;
result.table_phase=page->phase;result.table_dialog=page->dialog;
} else if(family->kind==ui::LeagueFamilyRequestKind::table_range_result && family->from_child==1) {
auto page=dispatch_league_table_range_reply(*family,revision,error);
if(!page)throw FormatError(error.empty()?"live overview: Source Table range reply rejected":error);
result.table=page->page;result.family_identity=page->identity;
result.table_phase=page->phase;result.table_dialog=page->dialog;
} else if(family->kind==ui::LeagueFamilyRequestKind::table_forecast_presented && family->from_child==1) {
auto page=acknowledge_league_forecast_present(*family,revision,error);
if(!page)throw FormatError(error.empty()?"live overview: Source Table forecast ACK rejected":error);
result.table=page->page;result.family_identity=page->identity;
result.table_phase=page->phase;result.table_dialog=page->dialog;
} else if(family->kind==ui::LeagueFamilyRequestKind::team_info && family->from_child==1) {
auto identity=dispatch_family_table_team_info(*family,revision,error,team_info);
if(!identity)throw FormatError(error.empty()?"live overview: Source Table TeamInfo rejected":error);
auto page=current_league_table_dispatch(error);
if(!page)throw FormatError(error.empty()?"live overview: Source Table return is unavailable":error);
result.table=page->page;result.family_identity=page->identity;
result.table_phase=page->phase;result.table_dialog=page->dialog;
} else if((family->kind==ui::LeagueFamilyRequestKind::select_league ||
family->kind==ui::LeagueFamilyRequestKind::toggle_league_group) && family->from_child==1) {
if(!select_league_family_page(*family,revision,error))
throw FormatError(error.empty()?"live overview: Source Table selector rejected":error);
auto page=current_league_table_dispatch(error);
if(!page)throw FormatError(error.empty()?"live overview: Source Table selector projection missing":error);
result.table=page->page;result.family_identity=page->identity;
result.table_phase=page->phase;result.table_dialog=page->dialog;
} else if(family->kind==ui::LeagueFamilyRequestKind::navigate &&
family->target_child>=1 && family->target_child<=3) {
if(family->from_child==3) {
if(!suspend_strengths_for_family(*family,revision,error))
throw FormatError(error.empty()?"live overview: Source Strengths child return rejected":error);
} else if(family->from_child==2) {
if(!suspend_pairings_for_family(*family,revision,error))
throw FormatError(error.empty()?"live overview: Source Pairings child return rejected":error);
}
auto fresh=strengths_open_request(revision);
if(!fresh)throw FormatError("live overview: Source family has no active manager projection");
auto identity=fresh->identity;
identity.family_id=family->identity.family_id;
identity.family_sequence=family->identity.family_sequence+1;
identity.league=family->identity.league;
identity.league_group=family->identity.league_group;
identity.manager_default_league=family->identity.manager_default_league;
identity.source_param2=family->identity.source_param2;
if(!prepare_league_family_child(identity,family->target_child,revision,error))
throw FormatError(error.empty()?"live overview: Source family child preparation rejected":error);
identity.expected_family_word=g_.memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(identity.manager)*2);
if(family->target_child==1) {
if(!advance_league_family(*family,identity,1,revision,error))
throw FormatError(error.empty()?"live overview: Source Table handoff rejected":error);
auto page=current_league_table_dispatch(error);
if(!page)throw FormatError(error.empty()?"live overview: Source Table handoff projection missing":error);
result.kind=LiveOverviewKind::league_table;
result.table=page->page;result.family_identity=page->identity;
result.table_phase=page->phase;result.table_dialog=page->dialog;
} else if(family->target_child==2) {
LeaguePairingsDraft draft{g_,game_,rand_,club_modal_runtime_,club_modal_runtime_,{}, {},
save_stream(g_),rand_.seed(),game_.seed(),rand_.calls(),game_.calls()};
for(const auto& group:engine.groups)draft.original_active_groups.emplace_back(group.desc,group.fixtures);
draft.original_referee_profiles=engine.referees;
draft.owner=open_league_pairings_source(draft.state,identity.manager,ui::league_pairings_constants(exe_));
if(draft.owner.league!=identity.league) {
// Source Move chooses the family league before its first visible page.
draft.owner.league=identity.league;
draft.owner.round=std::min<int>(draft.state.league_rounds.at(size_t(identity.league)),
league_matchdays(identity.league)-1);
draft.owner.title_round=draft.state.league_rounds.at(size_t(identity.league));
if(draft.owner.round>=league_matchdays(identity.league))
throw FormatError("live overview: selected Source Pairings league round is outside its schedule");
}
draft.active_packet=validate_normal_pairings_group(draft.state,draft.owner,draft.runtime);
const uint64_t child_scope=++league_pairings_scope_;
auto page=ui::league_pairings_from_game(draft.state,draft.owner,exe_,revision,
child_scope,family->identity.family_sequence+1,draft.active_packet);
draft.identity=page.identity;
draft.runtime[::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField]=exe_.u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+uint32_t(draft.owner.league));
pairings_runtime_draw(draft.state,draft.runtime,page,exe_);
league_pairings_draft_=std::move(draft);
if(!advance_league_family(*family,identity,2,revision,error))
throw FormatError(error.empty()?"live overview: Source Pairings handoff rejected":error);
result.kind=LiveOverviewKind::league_pairings;
result.pairings=std::move(page);
result.family_identity=league_family_owner_->identity;
} else {
ui::StrengthsRequest open=*fresh;open.identity=identity;open.kind=ui::StrengthsAction::open;
auto page=dispatch_strengths(open,revision,error,{},true);
if(!page||page->closed)throw FormatError(error.empty()?"live overview: Source Strengths entry rejected":error);
if(!advance_league_family(*family,page->page.identity,3,revision,error))
throw FormatError(error.empty()?"live overview: Source Strengths handoff rejected":error);
result.kind=LiveOverviewKind::league_strengths;
result.strengths=page->page;result.family_identity=page->page.identity;
}
} else {
throw FormatError("live overview: unsupported Source family transition");
}
if(league_family_owner_) {
result.family_identity=league_family_owner_->identity;
live_overview_owner_->kind=result.kind;
live_overview_owner_->family_identity=result.family_identity;
}
live_overview_owner_->request.revision=revision;
return result;
}
if(const auto* strengths=std::get_if<ui::StrengthsRequest>(&action)) {
if(live.kind!=LiveOverviewKind::league_strengths || !strengths_owner_ ||
strengths->identity!=strengths_owner_->page.identity ||
strengths->identity.revision!=revision || strengths->identity!=live.family_identity)
throw FormatError("live overview: mismatched Source Strengths owner");
if(strengths->kind==ui::StrengthsAction::table || strengths->kind==ui::StrengthsAction::pairings) {
ui::LeagueFamilyRequest navigation;
navigation.identity=live.family_identity;
navigation.kind=ui::LeagueFamilyRequestKind::navigate;
navigation.from_child=3;
navigation.target_child=strengths->kind==ui::StrengthsAction::table?1:2;
struct RestoreObserverScope { bool& flag; bool previous; explicit RestoreObserverScope(bool& f):flag(f),previous(f){flag=true;} ~RestoreObserverScope(){flag=previous;} } observer_scope(calendar_advance_active_);
return dispatch_live_overview(LiveOverviewAction{navigation},engine,revision,error,team_info);
}
if(strengths->kind==ui::StrengthsAction::close) {
ui::LeagueFamilyRequest close;close.identity=live.family_identity;
close.kind=ui::LeagueFamilyRequestKind::close;close.from_child=3;close.target_child=0;
auto preparation=close_league_family(close,revision,error);
if(!preparation)throw FormatError(error.empty()?"live overview: Source Strengths close rejected":error);
result.closed=true;result.preparation=std::move(*preparation);live_overview_owner_.reset();return result;
}
const auto prior=live.family_identity;
auto page=dispatch_strengths(*strengths,revision,error,team_info,false);
if(!page || page->closed)throw FormatError(error.empty()?"live overview: Source Strengths action rejected":error);
if(!refresh_family_after_child(prior,3,page->page.identity,revision,error))
throw FormatError(error.empty()?"live overview: Source Strengths ACK rejected":error);
result.strengths=page->page;result.preparation=page->preparation;
result.family_identity=page->page.identity;
live_overview_owner_->family_identity=result.family_identity;
live_overview_owner_->request.revision=revision;
return result;
}
if(const auto* pairings=std::get_if<ui::LeaguePairingsRequest>(&action)) {
if(live.kind!=LiveOverviewKind::league_pairings || !league_pairings_draft_ ||
pairings->identity!=league_pairings_draft_->identity || pairings->identity.revision!=revision)
throw FormatError("live overview: mismatched Source Pairings owner");
if(pairings->event.kind==LeaguePairingsAction::close) {
ui::LeagueFamilyRequest close;close.identity=live.family_identity;
close.kind=ui::LeagueFamilyRequestKind::close;close.from_child=2;close.target_child=0;
auto preparation=close_league_family(close,revision,error);
if(!preparation)throw FormatError(error.empty()?"live overview: Source Pairings close rejected":error);
result.closed=true;result.preparation=std::move(*preparation);live_overview_owner_.reset();return result;
}
auto page=dispatch_league_pairings(*pairings,revision,error,team_info);
if(!page)throw FormatError(error.empty()?"live overview: Source Pairings action rejected":error);
result.closed=page->closed;result.pairings=page->page;result.preparation=page->preparation;
if(result.closed) {
// The Source Move return is completed by the outer G/T wrapper.
live_overview_owner_.reset();league_family_owner_.reset();
} else {
live_overview_owner_->request.revision=revision;
if(league_family_owner_) {
live_overview_owner_->family_identity=league_family_owner_->identity;
result.family_identity=league_family_owner_->identity;
}
}
return result;
}
const auto* cup=std::get_if<ui::OtherGamesRequest>(&action);
if(!cup || live.kind!=LiveOverviewKind::cup_other_games || !other_games_owner_ ||
cup->identity!=other_games_owner_->page.identity || cup->identity.revision!=revision)
throw FormatError("live overview: mismatched Source cup overview owner");
auto page=dispatch_other_games(*cup,revision,error,team_info);
if(!page)throw FormatError(error.empty()?"live overview: Source cup overview action rejected":error);
result.closed=page->closed;result.cup=page->page;result.preparation=page->preparation;
if(result.closed)live_overview_owner_.reset();
else live_overview_owner_->request.revision=revision;
return result;
} catch(const std::exception& e) {
error=e.what();return {};
}
}
bool CareerSession::begin_live_intervention(int minute, int source_mode, int manager, int team,
MatchEngine& engine, uint64_t& revision, std::string& error) {
error.clear();
if (live_intervention_ || minute <= 2 || (source_mode != 2 && source_mode != 8) ||
revision == std::numeric_limits<uint64_t>::max() || manager < 0 || manager >= int(g_.manager_teams.size()) ||
team < 0 || team >= int(g_.team_flags.size()) || g_.manager_teams[size_t(manager)] != team ||
g_.manager_of(team) != manager || &engine.state != &g_ || &engine.game != &game_ || &engine.rand != &rand_) {
error = "Der Live-Eingriff kann für diesen Manager oder Modus nicht geöffnet werden.";
return false;
}
bool current_match = false;
for (const MatchGroup& group : engine.groups) for (int match = 0; match < group.matches(); ++match) {
const uint32_t bit = uint32_t(1) << match;
if ((group.kickoff_void_mask & bit) || (group.void_mask() & bit)) continue;
const int home = group.fixtures.at(size_t(match) * 2);
const int away = group.fixtures.at(size_t(match) * 2 + 1);
if (std::find(g_.live_matches.begin(), g_.live_matches.end(), home) != g_.live_matches.end() &&
(team == home || team == away)) current_match = true;
}
if (!current_match) {
error = "Die Mannschaft spielt in der aktuellen Partie nicht.";
return false;
}
LiveInterventionCheckpoint checkpoint;
checkpoint.state = g_;
checkpoint.groups = engine.groups;
checkpoint.game = engine.game;
checkpoint.rand = engine.rand;
checkpoint.minute = minute; checkpoint.source_mode = source_mode;
checkpoint.manager = manager; checkpoint.team = team;
checkpoint.initial_revision = revision; checkpoint.current_revision = revision;
live_intervention_ = std::move(checkpoint);
if (source_mode == 2) {
try {
GameState entered = g_;
prepare_lineup_entry(entered, team); // PitchScreen's unconditional PrepareLineupEntry entry pass.
g_ = std::move(entered);
} catch (const std::exception& e) {
live_intervention_.reset();
error = std::string("Die Live-Aufstellung kann nicht geöffnet werden: ") + e.what();
return false;
}
}
if (g_.memory.has(::bmh::layout::ActiveManager)) g_.memory.set8(::bmh::layout::ActiveManager, uint8_t(manager));
return true;
}
bool CareerSession::begin_live_event_intervention(const LiveMatchEvent& event, MatchEngine& engine,
uint64_t& revision, std::string& error) {
error.clear();
const int manager = event.manager_slot, team = event.team;
if (live_intervention_ || event.minute < 1 || (event.kind != 1 && event.kind != 2) ||
event.group_index >= engine.groups.size() || event.match_index < 0 || event.side < 0 || event.side > 1 ||
manager < 0 || manager >= int(g_.manager_teams.size()) || team < 0 ||
team >= int(g_.team_flags.size()) || event.player < 0 || event.player >= int(g_.players.size()) ||
g_.manager_teams[size_t(manager)] != team || g_.manager_of(team) != manager ||
g_.manager_option(manager, 1) || engine.live_desk_disabled || !(g_.team_morale.at(size_t(team)) & 0x80) ||
&engine.state != &g_ || &engine.game != &game_ || &engine.rand != &rand_ ||
revision == std::numeric_limits<uint64_t>::max()) {
error = "Der automatische Live-Eingriff gehört nicht zu einem aktuellen Source-Ereignis.";
return false;
}
const MatchGroup& group = engine.groups[event.group_index];
if (event.match_index >= group.matches() ||
group.fixtures.at(size_t(event.match_index) * 2 + size_t(event.side)) != team ||
group.fixtures.at(size_t(event.match_index) * 2 + size_t(1 - event.side)) != event.opponent ||
(group.kickoff_void_mask >> event.match_index & 1) || (group.void_mask() >> event.match_index & 1) ||
std::find(g_.live_matches.begin(), g_.live_matches.end(), group.fixtures.at(size_t(event.match_index) * 2)) ==
g_.live_matches.end()) {
error = "Das Source-Ereignis gehört nicht zur aktuell gezeigten Partie.";
return false;
}
// The Source event already changed this exact player/slot before opening PitchScreen.
bool event_player_found = false;
const auto range = squad_range(team);
for (size_t offset = 0; offset < range.count; ++offset) {
const size_t slot = size_t(range.first) + offset;
const uint16_t entry = g_.squad_slots.at(slot);
if ((entry & 0x0fff) != event.player) continue;
if (event.kind == 2 && (g_.players.at(size_t(event.player)).w35c >> 27) != 0 && !(entry & 0x8000))
event_player_found = true;
if (event.kind == 1 && (g_.players.at(size_t(event.player)).w368 & 0x07000000u) != 0 && !(entry & 0x8000))
event_player_found = true;
}
if (!event_player_found) {
error = "Der Source-Spielerstatus passt nicht mehr zum automatischen Eingriff.";
return false;
}
LiveInterventionCheckpoint checkpoint;
checkpoint.state = g_; checkpoint.groups = engine.groups;
checkpoint.game = engine.game; checkpoint.rand = engine.rand;
checkpoint.minute = event.minute; checkpoint.source_mode = 2;
checkpoint.manager = manager; checkpoint.team = team; checkpoint.source_event = true;
checkpoint.event = event; checkpoint.initial_revision = revision; checkpoint.current_revision = revision;
live_intervention_ = std::move(checkpoint);
try {
GameState entered = g_;
prepare_lineup_entry(entered, team);
g_ = std::move(entered);
} catch (const std::exception& e) {
live_intervention_.reset();
error = std::string("Die automatische Live-Aufstellung kann nicht geöffnet werden: ") + e.what();
return false;
}
if (g_.memory.has(::bmh::layout::ActiveManager)) g_.memory.set8(::bmh::layout::ActiveManager, uint8_t(manager));
return true;
}
bool CareerSession::finish_live_event_intervention(const LiveMatchEvent& event, MatchEngine& engine,
uint64_t& revision, std::string& error) {
error.clear();
if (!live_intervention_ || !live_intervention_->source_event ||
live_intervention_->event.group_index != event.group_index ||
live_intervention_->event.match_index != event.match_index ||
live_intervention_->event.side != event.side || live_intervention_->event.team != event.team ||
live_intervention_->event.opponent != event.opponent ||
live_intervention_->event.player != event.player || live_intervention_->event.kind != event.kind ||
live_intervention_->minute != event.minute || live_intervention_->manager != event.manager_slot ||
live_intervention_->current_revision != revision || &engine.state != &g_ ||
&engine.game != &game_ || &engine.rand != &rand_ || revision == std::numeric_limits<uint64_t>::max()) {
error = "Der automatische Live-Menüabschluss ist veraltet oder gehört zu einem anderen Ereignis.";
return false;
}
if (event.group_index >= engine.groups.size() || event.match_index < 0 || event.side < 0 || event.side > 1) {
error = "Das Source-Ereignis gehört nicht mehr zur aktiven Partie.";
return false;
}
const MatchGroup& group = engine.groups[event.group_index];
if (event.match_index >= group.matches() ||
group.fixtures.at(size_t(event.match_index) * 2 + size_t(event.side)) != event.team ||
group.fixtures.at(size_t(event.match_index) * 2 + size_t(1 - event.side)) != event.opponent ||
(group.kickoff_void_mask >> event.match_index & 1) || (group.void_mask() >> event.match_index & 1)) {
error = "Die aktive Partie hat sich während der automatischen Aufstellung geändert.";
return false;
}
if (engine.groups.size() != live_intervention_->groups.size() ||
group.desc != live_intervention_->groups[event.group_index].desc ||
group.fixtures != live_intervention_->groups[event.group_index].fixtures) {
error = "Die Matchgruppenstruktur hat sich während der Source-Aufstellung geändert.";
return false;
}
// PitchScreen returns to EventImpl; its single Source rerate remains at the event's
// existing tail, so this boundary only consumes the authenticated modal owner.
++revision;
live_intervention_.reset();
return true;
}
bool CareerSession::finish_live_intervention(int minute, int source_mode, int manager, int team,
MatchEngine& engine, uint64_t& revision, std::string& error) {
error.clear();
if (!live_intervention_ || live_intervention_->minute != minute ||
live_intervention_->source_mode != source_mode || live_intervention_->manager != manager ||
live_intervention_->team != team || live_intervention_->current_revision != revision ||
&engine.state != &g_ || &engine.game != &game_ || &engine.rand != &rand_) {
error = "Der Live-Menüabschluss ist veraltet oder gehört zu einem anderen Eingriff.";
return false;
}
const LiveInterventionCheckpoint& checkpoint = *live_intervention_;
GameState staged_state = g_;
std::vector<MatchGroup> staged_groups = engine.groups;
GameRandom staged_game = engine.game;
WatcomRandom staged_rand = engine.rand;
MatchEngine staged_engine(staged_state, staged_groups, staged_game, staged_rand, engine.referees);
staged_engine.indoor = engine.indoor;
staged_engine.alternate_event_roll = engine.alternate_event_roll;
staged_engine.match_events_disabled = engine.match_events_disabled;
staged_engine.live_scene_visible = engine.live_scene_visible;
staged_engine.live_desk_disabled = engine.live_desk_disabled;
staged_engine.month = engine.month;
staged_engine.trace = engine.trace;
staged_engine.show = engine.show;
staged_engine.leave_screens = engine.leave_screens;
staged_engine.buttons = engine.buttons;
MinuteReport report;
staged_engine.rerate_team(team, report);
if (report.unsupported) {
g_ = checkpoint.state;
engine.groups = checkpoint.groups;
engine.game = checkpoint.game;
engine.rand = checkpoint.rand;
revision = checkpoint.initial_revision;
live_intervention_.reset();
error = "Die Mannschaft kann nach dem Live-Eingriff nicht neu bewertet werden: " + report.reason;
return false;
}
g_ = std::move(staged_state);
engine.groups = std::move(staged_groups);
engine.game = staged_game;
engine.rand = staged_rand;
if (revision == std::numeric_limits<uint64_t>::max()) {
g_ = checkpoint.state;
engine.groups = checkpoint.groups;
engine.game = checkpoint.game;
engine.rand = checkpoint.rand;
revision = checkpoint.initial_revision;
live_intervention_.reset();
error = "Die Live-Menürevisionsnummer ist erschöpft.";
return false;
}
++revision;
live_intervention_.reset();
return true;
}
void CareerSession::abort_live_intervention(int minute, int source_mode, int manager, int team,
MatchEngine& engine, uint64_t& revision) {
if (!live_intervention_ || live_intervention_->minute != minute ||
live_intervention_->source_mode != source_mode || live_intervention_->manager != manager ||
live_intervention_->team != team || &engine.state != &g_ ||
&engine.game != &game_ || &engine.rand != &rand_) return;
g_ = std::move(live_intervention_->state);
if (live_intervention_->source_event && engine.groups.size() == live_intervention_->groups.size()) {
// Preserve MatchGroup element addresses held by MatchEngine::event/side;
// side reacquires its record byte pointers immediately after this callback.
for (size_t i = 0; i < engine.groups.size(); ++i)
engine.groups[i] = std::move(live_intervention_->groups[i]);
} else {
engine.groups = std::move(live_intervention_->groups);
}
engine.game = live_intervention_->game;
engine.rand = live_intervention_->rand;
revision = live_intervention_->initial_revision;
live_intervention_.reset();
}
bool CareerSession::dispatch_live_substitution(const ui::LineupRequest& request, int minute,
int source_mode, MatchEngine& engine, uint64_t& revision, std::string& error) {
error.clear();
// PitchScreen stays open for repeated actions; EndPhase rerates once after
// event 8 closes either live menu.
if (source_mode != 2 || request.kind != ui::LineupRequestKind::swap_players ||
(minute <= 2 && (!live_intervention_ || !live_intervention_->source_event))) {
error = "Der Eingriff ist in dieser Spielminute nicht verfügbar.";
return false;
}
const int active = request.manager_slot;
const int team = request.runtime_club;
if (!live_intervention_ || live_intervention_->minute != minute ||
live_intervention_->source_mode != source_mode || live_intervention_->manager != active ||
live_intervention_->team != team || live_intervention_->current_revision != revision ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
active < 0 || active > 3 || request.manager_slot != active || team < 0 ||
size_t(active) >= g_.manager_teams.size() || g_.manager_teams[size_t(active)] != team ||
g_.manager_of(team) != active || team >= int(g_.team_flags.size()) ||
&engine.state != &g_ || &engine.game != &game_ || &engine.rand != &rand_) {
error = "Der Eingriff ist veraltet oder gehört nicht zum aktiven Manager.";
return false;
}
const bool current_match = std::any_of(engine.groups.begin(), engine.groups.end(), [this, team](const MatchGroup& group) {
for (int match = 0; match < group.matches(); ++match) {
const uint32_t bit = uint32_t(1) << match;
if ((group.kickoff_void_mask & bit) || (group.void_mask() & bit)) continue;
const int home = group.fixtures.at(size_t(match) * 2);
const int away = group.fixtures.at(size_t(match) * 2 + 1);
if (std::find(g_.live_matches.begin(), g_.live_matches.end(), home) != g_.live_matches.end() &&
(team == home || team == away)) return true;
}
return false;
});
if (!current_match) {
error = "Die Mannschaft spielt in der aktuellen Partie nicht.";
return false;
}
const auto range = squad_range(team);
const bool first_field = request.first_row >= 0 && request.first_row < 11;
const bool second_field = request.second_row >= 0 && request.second_row < 11;
const bool same_zone_exchange = first_field == second_field;
if (request.first_row < 0 || request.second_row < 0 ||
size_t(request.first_row) >= range.count || size_t(request.second_row) >= range.count ||
request.first_row == request.second_row ||
range.first + range.count > g_.squad_slots.size()) {
error = "Die Spielerzeilen sind für den Live-Tausch ungültig.";
return false;
}
const uint16_t outgoing = g_.squad_slots[range.first + size_t(request.first_row)];
const uint16_t incoming = g_.squad_slots[range.first + size_t(request.second_row)];
const uint16_t same_zone_role = first_field ? 0x8000 : 0x4000;
if (outgoing != request.first_slot || incoming != request.second_slot ||
(outgoing & 0x0fff) != request.first_player ||
(incoming & 0x0fff) != request.second_player ||
(same_zone_exchange ? ((outgoing & 0xc000) != same_zone_role || (incoming & 0xc000) != same_zone_role) :
(first_field ? (!(outgoing & 0x8000) || !(incoming & 0x4000)) :
(!(incoming & 0x8000) || !(outgoing & 0x4000)))) ||
request.first_player < 0 || request.second_player < 0) {
error = "Die Kaderauswahl hat sich inzwischen geändert.";
return false;
}
if (size_t(request.first_player) >= g_.players.size() || size_t(request.second_player) >= g_.players.size()) {
error = "Die Spielerkennung liegt außerhalb des Kaders.";
return false;
}
const Player& first_player = g_.players.at(size_t(request.first_player));
const Player& second_player = g_.players.at(size_t(request.second_player));
const auto injury_status = [](const Player& p) { return int(p.w364 >> 16 & 0x1f); };
// PitchScreen checks both selected players before it distinguishes same-zone
// tactical exchanges from field/bench substitutions.
if (((first_player.w35c >> 27) == 0 && injury_status(first_player) != 0) ||
((second_player.w35c >> 27) == 0 && injury_status(second_player) != 0)) {
error = "source_notice:0xaf13c";
return false;
}
if (!same_zone_exchange) {
const int field_row = first_field ? request.first_row : request.second_row;
const int bench_row = first_field ? request.second_row : request.first_row;
const int field_player = first_field ? request.first_player : request.second_player;
const int bench_player = first_field ? request.second_player : request.first_player;
const Player& field = g_.players.at(size_t(field_player));
const Player& bench = g_.players.at(size_t(bench_player));
const int field_status = int(field.w364 >> 16 & 0x1f);
const int bench_status = int(bench.w364 >> 16 & 0x1f);
if (field_status != 0 && (field.w35c >> 27) == 0) {
error = "source_notice:0xaf140";
return false;
}
if (bench_status != 0) {
error = "source_notice:0xaf144";
return false;
}
const int used = int(g_.team_flags.at(size_t(team)) >> 5 & 7);
const int max_substitutions = source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::CareerSession_DispatchLiveSubstitution_ExecutableField);
if (used >= max_substitutions) {
error = "source_notice:0xaf150";
return false;
}
const bool foreign_limit = g_.memory.has(::bmh::layout::ForeignPlayerLimitEnabled) ? g_.memory.u8(::bmh::layout::ForeignPlayerLimitEnabled) != 0 : exe_.u8(::bmh::layout::ForeignPlayerLimitEnabled) != 0;
if (foreign_limit) {
int foreign_on_field = 0;
for (size_t row = 0; row < range.count; ++row) {
const uint16_t slot = g_.squad_slots.at(range.first + row);
if (!(slot & 0x8000) || (slot & 0x0fff) == 0x0fff) continue;
if (nationality(g_, slot & 0x0fff) != 0) ++foreign_on_field;
}
foreign_on_field -= nationality(g_, field_player) != 0;
foreign_on_field += nationality(g_, bench_player) != 0;
if (foreign_on_field >= 4) {
error = "source_notice:0xaf148";
return false;
}
}
if (bench.w364 & 0x1000) {
error = "source_notice:0xaf14c";
return false;
}
}
// Source updates the squad before leaving the child menu; BuildSideRecords3 belongs
// to the single parent-menu completion callback.
GameState staged_state = g_;
if (same_zone_exchange) {
const size_t first = range.first + size_t(request.first_row);
const size_t second = range.first + size_t(request.second_row);
const size_t board = size_t(active) * 0x840;
if (board + (size_t(std::max(request.first_row, request.second_row)) + 1) * 0x58 >
staged_state.tactics.size()) {
error = "Die taktischen Spielerdaten sind unvollständig.";
return false;
}
auto* a = staged_state.tactics.data() + board + size_t(request.first_row) * 0x58;
auto* b = staged_state.tactics.data() + board + size_t(request.second_row) * 0x58;
const uint8_t ax = a[0x41], ay = a[0x42], bx = b[0x41], by = b[0x42];
staged_state.squad_slots[first] = uint16_t((incoming & 0x1fff) | (outgoing & 0xc000));
staged_state.squad_slots[second] = uint16_t((outgoing & 0x1fff) | (incoming & 0xc000));
std::swap_ranges(a, a + 0x58, b);
a[0x41] = ax; a[0x42] = ay; b[0x41] = bx; b[0x42] = by;
// GatedByParamLive (the desk-card remap) is gated by param_2==0; a live
// marked exchange changes the selected rows but leaves player_cards alone.
} else {
const int field_row = first_field ? request.first_row : request.second_row;
const int bench_row = first_field ? request.second_row : request.first_row;
const auto staged_range = squad_range(team);
const size_t field_at = staged_range.first + size_t(field_row);
const size_t bench_at = staged_range.first + size_t(bench_row);
const uint16_t field_slot = staged_state.squad_slots.at(field_at);
const uint16_t bench_slot = staged_state.squad_slots.at(bench_at);
const int used = int(staged_state.team_flags.at(size_t(team)) >> 5 & 7);
if (!(field_slot & 0x8000) || !(bench_slot & 0x4000) ||
(bench_slot & 0x0fff) == 0x0fff || used >= source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::CareerSession_DispatchLiveSubstitution_ExecutableField) ||
(staged_state.players.at(bench_slot & 0x0fff).w364 & 0x1000)) {
error = "Die Auswechslung erfüllt die Source-Bedingungen nicht.";
return false;
}
const size_t first = std::min(field_at, bench_at), second = std::max(field_at, bench_at);
const size_t board = size_t(active) * 0x840;
if (board + (size_t(bench_row) + 1) * 0x58 > staged_state.tactics.size()) {
error = "Die taktischen Spielerdaten sind unvollständig.";
return false;
}
auto* a = staged_state.tactics.data() + board + size_t(field_row) * 0x58;
auto* b = staged_state.tactics.data() + board + size_t(bench_row) * 0x58;
const uint8_t fx = a[0x41], fy = a[0x42], bx = b[0x41], by = b[0x42];
b[0] = uint8_t(minute); // EndPhase passes minute + 1 as PitchScreen param_2; source stores param_2 - 1.
staged_state.squad_slots[first] = bench_slot;
staged_state.squad_slots[second] = field_slot;
std::swap_ranges(a, a + 0x58, b);
a[0x41] = fx; a[0x42] = fy; b[0x41] = bx; b[0x42] = by;
staged_state.squad_slots[bench_at] &= 0x1fff;
staged_state.squad_slots[field_at] &= 0x1fff;
staged_state.players.at(bench_slot & 0x0fff).w364 |= 0x1000;
staged_state.squad_slots[field_at] |= 0x8000;
staged_state.squad_slots[bench_at] |= 0x4000;
staged_state.team_flags.at(size_t(team)) = uint16_t(
(staged_state.team_flags.at(size_t(team)) & 0xff1f) | uint16_t(used + 1) << 5);
}
g_ = std::move(staged_state);
++revision;
live_intervention_->current_revision = revision;
return true;
}
LiveSubstitutionResult CareerSession::dispatch_live_substitution_result(
const ui::LineupRequest& request, int minute, int source_mode,
MatchEngine& engine, uint64_t& revision) {
std::string error;
if (dispatch_live_substitution(request, minute, source_mode, engine, revision, error))
return {LiveSubstitutionStatus::applied, 0, request.manager_slot, {}};
constexpr std::string_view prefix = "source_notice:";
if (error.compare(0, prefix.size(), prefix) == 0) {
uint32_t address = 0;
try { address = uint32_t(std::stoul(error.substr(prefix.size()), nullptr, 16)); }
catch (...) { return {LiveSubstitutionStatus::rejected, 0, request.manager_slot,
"Invalid internal Source notice address."}; }
return {LiveSubstitutionStatus::source_notice, address, request.manager_slot, {}};
}
return {LiveSubstitutionStatus::rejected, 0, request.manager_slot, std::move(error)};
}
bool CareerSession::dispatch_live_tactic(const ui::TacticsRequest& request, int minute,
int source_mode, MatchEngine& engine, uint64_t& revision, std::string& error) {
error.clear();
if (minute <= 2 || source_mode != 8 || request.kind != ui::TacticsRequestKind::set_tactic) {
error = "Die Taktikänderung ist in dieser Spielminute nicht verfügbar.";
return false;
}
const int manager = request.manager_slot;
const int team = request.runtime_club;
if (!live_intervention_ || live_intervention_->minute != minute ||
live_intervention_->source_mode != source_mode || live_intervention_->manager != manager ||
live_intervention_->team != team || live_intervention_->current_revision != revision ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
manager < 0 || manager >= int(g_.manager_teams.size()) || team < 0 ||
team >= int(g_.team_flags.size()) || team != g_.manager_teams[size_t(manager)] ||
g_.manager_of(team) != manager || &engine.state != &g_ || &engine.game != &game_ || &engine.rand != &rand_) {
error = "Die Taktikanfrage ist veraltet oder gehört nicht zum aktiven Manager.";
return false;
}
bool selected_match = false;
for (const MatchGroup& group : engine.groups) {
for (int match = 0; match < group.matches(); ++match) {
const uint32_t bit = uint32_t(1) << match;
if ((group.kickoff_void_mask & bit) || (group.void_mask() & bit)) continue;
const int home = group.fixtures.at(size_t(match) * 2);
const int away = group.fixtures.at(size_t(match) * 2 + 1);
if (std::find(g_.live_matches.begin(), g_.live_matches.end(), home) != g_.live_matches.end() &&
(team == home || team == away)) selected_match = true;
}
}
if (!selected_match) {
error = "Die Mannschaft spielt nicht in der aktuell ausgewählten Partie.";
return false;
}
if (request.index < 0 || request.index >= 8 || request.desired_value < 0 ||
request.desired_value > exe_.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField + request.index)) {
error = "Ungültige Taktikeinstellung.";
return false;
}
const bool live_option = (g_.memory.has(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField3) ? g_.memory.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField3) : exe_.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField3)) != 0;
if (live_option && exe_.u8(::bmh::layout::CareerSession_DispatchLiveTactic_RuntimeField2 + request.index) == 0) {
error = "Diese Taktikeinstellung ist nicht verfügbar.";
return false;
}
if ((request.index == 0 && request.desired_assistant_attitude != std::optional<uint8_t>(0)) ||
(request.index != 0 && request.desired_assistant_attitude)) {
error = "Ungültige Assistenteneinstellung.";
return false;
}
const size_t record = size_t(manager) * 0xb0c;
const size_t option = size_t(manager) * 5 + 2;
if (g_.manager_records.size() < record + 0xb0c || g_.manager_options.size() <= option) {
error = "Die Taktikdaten sind unvollständig.";
return false;
}
// RerateTeam commits each click to the manager record while the menu stays
// open; EndPhase invokes BuildSideRecords3 exactly once after menu exit.
g_.manager_records[record + 0xd2 + size_t(request.index)] = uint8_t(request.desired_value);
if (request.index == 0) g_.manager_options[option] = 0;
++revision;
live_intervention_->current_revision = revision;
return true;
}
bool CareerSession::dispatch_pitch(const ui::PitchRequest& request, uint64_t& revision,
std::string& error) {
if (request.kind == ui::PitchRequestKind::swap_players) {
if (request.runtime_club < 0 || request.runtime_club >= int(g_.team_flags.size()) ||
size_t(request.runtime_club + 1) * 2 > g_.club_heap_78.size() ||
request.indoor != g_.indoor) {
error = "Der Hallen-/Außenmodus der Spielfeldanfrage ist veraltet.";
return false;
}
ui::LineupRequest lineup;
lineup.kind = ui::LineupRequestKind::swap_players;
lineup.manager_slot = request.manager_slot; lineup.runtime_club = request.runtime_club;
lineup.revision = request.revision;
lineup.first_row = request.row; lineup.first_player = request.player_id; lineup.first_slot = request.slot;
lineup.second_row = request.second_row; lineup.second_player = request.second_player;
lineup.second_slot = request.second_slot;
return dispatch_lineup(lineup, revision, error);
}
if (request.kind != ui::PitchRequestKind::move_player &&
request.kind != ui::PitchRequestKind::set_automatic_weight &&
request.kind != ui::PitchRequestKind::apply_formation &&
request.kind != ui::PitchRequestKind::save_formation &&
request.kind != ui::PitchRequestKind::open_set_piece_editor &&
request.kind != ui::PitchRequestKind::close_set_piece_editor &&
request.kind != ui::PitchRequestKind::set_piece_taker &&
request.kind != ui::PitchRequestKind::auto_set_piece_takers &&
request.kind != ui::PitchRequestKind::set_player_order &&
request.kind != ui::PitchRequestKind::select_pitch_page &&
request.kind != ui::PitchRequestKind::set_player_marking) {
error = "Diese Spielfeldaktion ist noch nicht verfügbar.";
return false;
}
// PitchRequest has runtime ownership and a revision, not a caller-supplied
// stable-club token. Cross-check the live mapping and record just as for the
// semantic desk setters, including their tracked phase/modal exclusions.
const int count = g_.memory.has(::bmh::layout::ManagerCount) ? int(g_.memory.u8(::bmh::layout::ManagerCount)) : -1;
if (count < 1 || count > 4 || g_.manager_teams.size() != size_t(count) ||
request.manager_slot < 0 || request.manager_slot >= count) {
error = "Die Managerdaten der Spielfeldaktion sind unvollständig.";
return false;
}
DeskSettingIdentity identity{request.manager_slot, request.runtime_club, std::nullopt, request.revision};
if (request.runtime_club >= 0 && size_t(request.runtime_club) < g_.club_ids.size())
identity.stable_club_identity = int(g_.club_ids[size_t(request.runtime_club)]);
// PitchScreen exposes the prepared Pitch view during initial setup as well as
// during manager desks. A verified line-up owner in the still-empty turn loop
// is sufficient authority there; ordinary automation/ticket settings remain
// desk-only. Keep all nested desk mutations blocked while allowing this Source
// line-up window before the first desk has been created.
const bool live_context = live_intervention_ && live_intervention_->source_mode == 2 &&
request.manager_slot == live_intervention_->manager &&
request.runtime_club == live_intervention_->team &&
request.revision == live_intervention_->current_revision && request.revision == revision;
const bool desk_phase = turn_driver_.stage == TurnDriver::Stage::MatchdayDesks ||
turn_driver_.stage == TurnDriver::Stage::SeasonEndDesk;
const bool initial_lineup_phase = turn_driver_.stage == TurnDriver::Stage::Empty &&
lineup_entry_manager_ == request.manager_slot && lineup_entry_club_ == request.runtime_club;
if (!desk_phase && !initial_lineup_phase && !live_context) { error = "desk_setting_unavailable"; return false; }
if (!live_context && (pending_offer_dispatch_active_ || market_dispatch_active_ || calendar_advance_active_ ||
transfer_offer_editor_ || manager_join_ || contract_quote_ || stadium_.investment ||
stadium_.tip || stadium_.periphery_quote)) {
error = "desk_setting_unavailable"; return false;
}
if (live_context) {
const int manager = live_intervention_->manager;
const int team = live_intervention_->team;
const size_t rec = size_t(manager) * 0xb0c;
if (request.indoor != g_.indoor || manager < 0 || manager >= int(g_.manager_teams.size()) ||
g_.manager_teams[size_t(manager)] != team || g_.manager_of(team) != manager ||
size_t(team) >= g_.club_ids.size() || rec + 0xb0c > g_.manager_records.size() ||
(int(g_.manager_records[rec + 0x290]) | int(g_.manager_records[rec + 0x291]) << 8) != team) {
error = "Die Spielfeldaktion gehört nicht zum aktiven Live-Manager."; return false;
}
} else if (!validate_desk_setting_owner(identity, revision, error, false)) return false;
const size_t badge = size_t(request.runtime_club) * 2;
const int mode = g_.memory.has(::bmh::layout::GameMode) ? int(g_.memory.u8(::bmh::layout::GameMode)) : int(exe_.u8(::bmh::layout::GameMode));
if (request.runtime_club >= int(exe_.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField)) || g_.lineups_frozen ||
mode < 1 || mode > 3 || g_.manager_options[size_t(request.manager_slot) * 5] > 8 ||
request.indoor != g_.indoor ||
(!live_context && (lineup_entry_manager_ != request.manager_slot ||
lineup_entry_club_ != request.runtime_club)) || badge + 1 >= g_.club_heap_78.size()) {
error = "Diese Spielfeldaktion ist nicht für die vorbereitete Aufstellung freigegeben.";
return false;
}
if ((request.kind == ui::PitchRequestKind::apply_formation ||
request.kind == ui::PitchRequestKind::save_formation) && request.new_weights != request.old_weights) {
error = "Die Gewichtung der Aufstellungsanfrage wurde geändert.";
return false;
}
const auto selected_live_opponent = [&](int opponent) {
if (!live_context || opponent < 0 || opponent >= int(exe_.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField))) return false;
return std::any_of(live_intervention_->groups.begin(), live_intervention_->groups.end(),
[&](const MatchGroup& group) {
for (int match = 0; match < group.matches(); ++match) {
const uint32_t bit = uint32_t(1) << match;
if ((group.kickoff_void_mask & bit) || (group.void_mask() & bit)) continue;
const int home = group.fixtures.at(size_t(match) * 2);
const int away = group.fixtures.at(size_t(match) * 2 + 1);
if (std::find(g_.live_matches.begin(), g_.live_matches.end(), home) != g_.live_matches.end() &&
((home == request.runtime_club && away == opponent) ||
(away == request.runtime_club && home == opponent))) return true;
}
return false;
});
};
const auto selected_source_opponent = [&](int opponent) {
if (live_context) return selected_live_opponent(opponent);
const auto prepared = prepared_lineup_opponent(request.manager_slot,
request.runtime_club, request.revision);
return prepared && *prepared == opponent;
};
if (request.kind == ui::PitchRequestKind::select_pitch_page && request.page_control == 4 &&
(request.indoor || g_.indoor || !selected_source_opponent(request.opponent_team))) {
error = "Die Manndeckungsseite ist für diese Partie nicht verfügbar.";
return false;
}
if (request.kind == ui::PitchRequestKind::set_player_marking &&
(request.indoor || g_.indoor || !selected_source_opponent(request.opponent_team))) {
error = "Die Manndeckung gehört nicht zur aktuellen Außenspielpartie.";
return false;
}
try {
GameState staged = g_;
bool accepted = false;
const size_t manager_rec = size_t(request.manager_slot) * 0xb0c;
static constexpr size_t set_piece_offsets[] = {0xafc,0xafe,0xb08};
std::array<uint16_t,3> current_set_piece{};
for(size_t i=0;i<3;++i){const size_t at=manager_rec+set_piece_offsets[i];
current_set_piece[i]=uint16_t(staged.manager_records.at(at)|uint16_t(staged.manager_records.at(at+1))<<8);}
const uint32_t display_at=uint32_t(::bmh::layout::CareerSession_AnyOf_ExecutableField+request.manager_slot*2);
const bool editor_action=request.kind==ui::PitchRequestKind::open_set_piece_editor||
request.kind==ui::PitchRequestKind::close_set_piece_editor||
request.kind==ui::PitchRequestKind::set_piece_taker||
request.kind==ui::PitchRequestKind::auto_set_piece_takers;
if(request.kind==ui::PitchRequestKind::select_pitch_page&&
(!staged.memory.has(display_at)||request.expected_display_word!=staged.memory.u16(display_at)||
request.expected_set_piece_values!=current_set_piece||
request.expected_set_piece_signature!=uint16_t(staged.manager_records.at(manager_rec+0xb0a)|uint16_t(staged.manager_records.at(manager_rec+0xb0b))<<8)||
request.expected_mode!=mode||request.indoor!=staged.indoor||request.page_control<0||request.page_control>4)){
error="Der Seitenwechsel am Spielfeld ist veraltet oder ungültig.";return false;
}
if (request.kind == ui::PitchRequestKind::set_player_marking) {
if (!staged.memory.has(display_at) ||
request.expected_display_word != staged.memory.u16(display_at) ||
(request.expected_display_word & 0x0040) == 0 || staged.indoor ||
request.opponent_team < 0 || !selected_source_opponent(request.opponent_team) ||
size_t(request.opponent_team) >= staged.team_flags.size()) {
error = "Die Manndeckungsanfrage ist veraltet oder nicht auf der Source-Seite aktiv.";
return false;
}
const SquadRange own = squad_range(request.runtime_club);
const SquadRange opponent = squad_range(request.opponent_team);
const size_t own_board = size_t(request.manager_slot) * 0x840;
if (own.count < 11 || opponent.count < 11 || own.first + 11 > staged.squad_slots.size() ||
opponent.first + 11 > staged.squad_slots.size() || own_board + 11 * 0x58 > staged.tactics.size()) {
error = "Die Mannschaftstaktik enthält keine vollständigen Spielerzeilen.";
return false;
}
if (request.opponent_row < 1 || request.opponent_row >= 11 ||
staged.squad_slots.at(opponent.first + size_t(request.opponent_row)) != request.opponent_slot ||
(request.opponent_slot & 0xc000) != 0x8000 ||
(request.opponent_slot & 0x0fff) != request.opponent_player ||
request.opponent_player < 0 || size_t(request.opponent_player) >= staged.players.size()) {
error = "Der ausgewählte Gegenspieler gehört nicht mehr zur gegnerischen Feldaufstellung.";
return false;
}
bool clear = request.row == -1 && request.player_id == -1;
if (clear) {
if (request.expected_marking_player_id != uint16_t(request.opponent_player)) {
error = "Die zu löschende Manndeckung ist veraltet.";
return false;
}
} else {
if (request.row < 0 || request.row >= 11 ||
staged.squad_slots.at(own.first + size_t(request.row)) != request.slot ||
(request.slot & 0xc000) != 0x8000 || (request.slot & 0x0fff) != request.player_id ||
request.player_id < 0 || size_t(request.player_id) >= staged.players.size()) {
error = "Der ausgewählte eigene Feldspieler gehört nicht mehr zur Aufstellung.";
return false;
}
const size_t own_row_at = own_board + size_t(request.row) * 0x58;
const uint16_t current = uint16_t(staged.tactics.at(own_row_at + 0x44) |
uint16_t(staged.tactics.at(own_row_at + 0x45)) << 8);
if (current != request.expected_marking_player_id) {
error = "Die bestehende Manndeckung wurde inzwischen geändert.";
return false;
}
}
}
if(editor_action && (!staged.memory.has(display_at)||request.expected_set_piece_values!=current_set_piece||
request.expected_display_word!=staged.memory.u16(display_at)||request.expected_mode!=mode||request.indoor!=staged.indoor||
request.expected_set_piece_signature!=uint16_t(staged.manager_records.at(manager_rec+0xb0a)|uint16_t(staged.manager_records.at(manager_rec+0xb0b))<<8)||
uint16_t(staged.manager_records.at(manager_rec+0xb0a)|uint16_t(staged.manager_records.at(manager_rec+0xb0b))<<8)!=0x3253)){
error="Der Schützenauftrag ist veraltet oder unvollständig.";return false;
}
const bool editor_open=staged.memory.has(display_at)&&(staged.memory.u16(display_at)&0x80)!=0;
// The low-80 native bit survives Padded when the whole Pitch view
// returns. Screen-local editor runtime is reset on each new view, so a
// Source Schütze entry is valid even when the retained word already has
// bit80; mutations and editor-page exits still require that active bit.
if((request.kind==ui::PitchRequestKind::close_set_piece_editor||
request.kind==ui::PitchRequestKind::set_piece_taker||
request.kind==ui::PitchRequestKind::auto_set_piece_takers)&&!editor_open){
error="Der Schützenauftrag passt nicht zum aktuellen Anzeigestatus.";return false;
}
if(request.kind==ui::PitchRequestKind::set_player_order){
if(request.expected_mode!=mode||request.expected_display_word!=staged.memory.u16(display_at)||
request.expected_set_piece_values!=current_set_piece||
request.expected_set_piece_signature!=uint16_t(staged.manager_records.at(manager_rec+0xb0a)|uint16_t(staged.manager_records.at(manager_rec+0xb0b))<<8)||
request.row<0||request.row>=11||request.order_aspect<0||request.order_aspect>3||
mode==1||!staged.memory.has(display_at)||(staged.memory.u16(display_at)&0x0070)!=0x0020||
request.new_order_value<2||request.new_order_value>40||
request.new_order_value==request.expected_order_value){
error="Der Anweisungsauftrag ist ungültig.";return false;
}
const size_t row_at=size_t(request.manager_slot)*0x840+size_t(request.row)*0x58;
if(row_at+6>staged.tactics.size()||
(staged.squad_slots.at(squad_range(request.runtime_club).first+size_t(request.row))!=request.slot)||
(request.slot&0x0fff)!=request.player_id||
staged.tactics[row_at+2+size_t(request.order_aspect)]!=request.expected_order_value){
error="Die Anweisungszeile wurde inzwischen geändert.";return false;
}
}
switch (request.kind) {
case ui::PitchRequestKind::set_automatic_weight:
accepted = set_pitch_automatic_weight_source(staged, request.manager_slot, request.runtime_club,
request.weight_index, request.old_weights, request.new_weights);
break;
case ui::PitchRequestKind::move_player:
accepted = move_pitch_player_source(staged, request.manager_slot, request.runtime_club,
request.row, request.player_id, request.slot, request.old_depth, request.old_lane,
request.new_depth, request.new_lane);
break;
case ui::PitchRequestKind::apply_formation:
accepted = apply_pitch_formation_source(staged, request.manager_slot, request.runtime_club,
request.formation, request.old_weights);
break;
case ui::PitchRequestKind::save_formation:
accepted = save_pitch_formation_source(staged, request.manager_slot, request.runtime_club,
request.formation, request.old_weights, request.formation_positions);
break;
case ui::PitchRequestKind::open_set_piece_editor: {
const uint16_t expected=uint16_t((request.expected_display_word&0xff00)|
((request.expected_display_word&0x008f)|0x0080));
accepted=request.new_display_word==expected&&
normalize_pitch_set_piece_source(staged,request.manager_slot,request.runtime_club);
if(accepted)staged.memory.set16(display_at,expected);
break;
}
case ui::PitchRequestKind::close_set_piece_editor: {
const uint16_t expected=uint16_t(request.expected_display_word&~uint16_t(0x80));
accepted=(request.expected_display_word&0x80)!=0&&request.new_display_word==expected;
if(accepted)staged.memory.set16(display_at,expected);
break;
}
case ui::PitchRequestKind::set_piece_taker:
accepted=request.set_piece_selector>=2&&request.set_piece_selector<=4&&
request.expected_set_piece_value==current_set_piece[size_t(request.set_piece_selector-2)]&&
set_pitch_set_piece_taker_source(staged,request.manager_slot,request.runtime_club,
request.set_piece_selector,request.row,request.player_id,request.slot,request.expected_set_piece_value);
break;
case ui::PitchRequestKind::auto_set_piece_takers:
accepted=auto_pitch_set_piece_takers_source(staged,request.manager_slot,request.runtime_club,
request.expected_set_piece_values);
break;
case ui::PitchRequestKind::set_player_order:
accepted=set_player_order_source(staged,request.manager_slot,request.runtime_club,request.row,
request.player_id,request.order_aspect,request.new_order_value);
break;
case ui::PitchRequestKind::set_player_marking: {
const size_t board = size_t(request.manager_slot) * 0x840;
for (size_t row = 0; row < 11; ++row) {
const size_t at = board + row * 0x58 + 0x44;
const uint16_t marker = uint16_t(staged.tactics.at(at) | uint16_t(staged.tactics.at(at + 1)) << 8);
if (marker == uint16_t(request.opponent_player)) {
staged.tactics[at] = 0xff;
staged.tactics[at + 1] = 0x0f;
}
}
if (request.row >= 0) {
const size_t at = board + size_t(request.row) * 0x58 + 0x44;
staged.tactics[at] = uint8_t(request.opponent_player);
staged.tactics[at + 1] = uint8_t(uint16_t(request.opponent_player) >> 8);
}
accepted = true;
break;
}
case ui::PitchRequestKind::select_pitch_page: {
const uint16_t old=request.expected_display_word;
uint16_t next=old;
switch(request.page_control){
case 0: next=uint16_t((old&~uint16_t(0x80))^0x0003); break; // Data toggles its source word.
case 1: next=uint16_t(old^0x000c); break; // Team is the original inner-loop toggle.
case 2: next=uint16_t(((old&~uint16_t(0x0080))&0x008f)|0x0010); break;
case 3: next=uint16_t(((old&~uint16_t(0x0080))&0x008f)|0x0020); break;
case 4: next=uint16_t(((old&~uint16_t(0x0080))&0x008f)|0x0040); break;
default: break;
}
accepted=staged.memory.has(display_at)&&request.new_display_word==next&&
!((request.page_control==3)&&mode==1);
if(accepted)staged.memory.set16(display_at,next);
break;
}
default: break;
}
if (!accepted) {
error = "Die Spielfeldaktion ist veraltet oder in dieser Aufstellung nicht verfügbar.";
return false;
}
g_ = std::move(staged);
} catch (const std::exception&) {
// Keep pitch requests transactional if a malformed native projection throws.
error = "Diese Aufstellung kann im aktuellen Spielmodus noch nicht übernommen werden.";
return false;
}
++revision;
if (live_context) live_intervention_->current_revision = revision;
error.clear();
return true;
}
bool CareerSession::dispatch_live_pitch(const ui::PitchRequest& request, int minute, int source_mode,
MatchEngine& engine, uint64_t& revision, std::string& error) {
if (!live_intervention_ || live_intervention_->minute != minute ||
live_intervention_->source_mode != source_mode || source_mode != 2 ||
live_intervention_->manager != request.manager_slot ||
live_intervention_->team != request.runtime_club ||
live_intervention_->current_revision != revision || request.revision != revision ||
&engine.state != &g_ || &engine.game != &game_ || &engine.rand != &rand_) {
error = "Die Spielfeldaktion gehört zu keinem aktiven Live-Menü.";
return false;
}
if (request.kind == ui::PitchRequestKind::swap_players) {
ui::LineupRequest swap;
swap.kind = ui::LineupRequestKind::swap_players;
swap.manager_slot = request.manager_slot; swap.runtime_club = request.runtime_club;
swap.revision = request.revision;
swap.first_row = request.row; swap.first_player = request.player_id; swap.first_slot = request.slot;
swap.second_row = request.second_row; swap.second_player = request.second_player;
swap.second_slot = request.second_slot;
return dispatch_live_substitution(swap, minute, source_mode, engine, revision, error);
}
// PitchScreen's live param_2 is nonzero: these formation and weight controls
// exist only in its param_2==0 initial-preparation path.
if (request.kind == ui::PitchRequestKind::set_automatic_weight ||
request.kind == ui::PitchRequestKind::apply_formation ||
request.kind == ui::PitchRequestKind::save_formation) {
error = "Diese Aufstellungsoption ist außerhalb der Vorbereitungsphase nicht verfügbar.";
return false;
}
return dispatch_pitch(request, revision, error);
}
LiveSubstitutionResult CareerSession::dispatch_live_pitch_result(const ui::PitchRequest& request,
int minute, int source_mode, MatchEngine& engine, uint64_t& revision) {
if (request.kind == ui::PitchRequestKind::swap_players) {
ui::LineupRequest swap;
swap.kind = ui::LineupRequestKind::swap_players;
swap.manager_slot = request.manager_slot; swap.runtime_club = request.runtime_club;
swap.revision = request.revision;
swap.first_row = request.row; swap.first_player = request.player_id; swap.first_slot = request.slot;
swap.second_row = request.second_row; swap.second_player = request.second_player;
swap.second_slot = request.second_slot;
return dispatch_live_substitution_result(swap, minute, source_mode, engine, revision);
}
std::string error;
const bool applied = dispatch_live_pitch(request, minute, source_mode, engine, revision, error);
return {applied ? LiveSubstitutionStatus::applied : LiveSubstitutionStatus::rejected,
0, request.manager_slot, std::move(error)};
}
bool CareerSession::dispatch_pitch_swap(const ui::PitchRequest& request, uint64_t& revision,
std::string& error) {
if (request.kind != ui::PitchRequestKind::swap_players) {
error = "Diese Spielfeldaktion ist kein Spielerwechsel.";
return false;
}
return dispatch_pitch(request, revision, error);
}
ui::PreparationState CareerSession::preparation_projection(uint64_t revision) const {
return preparation_projection(g_, revision);
}
std::optional<int> CareerSession::prepared_lineup_opponent(int manager_slot, int runtime_club,
uint64_t revision) const {
if (turn_driver_.stage != TurnDriver::Stage::MatchdayDesks || g_.indoor ||
manager_slot < 0 || manager_slot >= int(g_.manager_teams.size()) ||
manager_slot != lineup_entry_manager_ || runtime_club != lineup_entry_club_ ||
!g_.memory.has(::bmh::layout::ActiveManager) ||
int(g_.memory.u8(::bmh::layout::ActiveManager)) != manager_slot ||
g_.manager_teams[size_t(manager_slot)] != runtime_club ||
runtime_club == kNoTeam || runtime_club < 0 ||
runtime_club >= int(exe_.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField)) || g_.manager_of(runtime_club) != manager_slot ||
size_t(manager_slot) >= source_desk_callargs_.size())
return std::nullopt;
const ui::DeskMatchCallargs& source = source_desk_callargs_[size_t(manager_slot)];
const int opponent = source.opponent;
if (opponent < 0 || opponent == runtime_club || opponent >= int(exe_.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField)) ||
source.competition == 32 || source.competition == 33 || source.competition == 34)
return std::nullopt;
uint32_t competitions = day_competitions(g_, turn_driver_.calendar_entry);
if (competitions == 0x800000) competitions = 0;
const int default_competition = competitions != 0 ? 34 : 33;
GameState manager_view = g_;
manager_view.memory.set8(::bmh::layout::ActiveManager, uint8_t(manager_slot));
const ui::DeskState projected = ui::desk_from_game(manager_view, exe_, revision,
&turn_driver_.groups, default_competition);
if (projected.manager_slot != manager_slot || projected.runtime_club != runtime_club ||
!projected.next_opponent || *projected.next_opponent != opponent ||
!projected.next_competition || *projected.next_competition != source.competition)
return std::nullopt;
const SquadRange rival_roster = squad_range(opponent);
if (rival_roster.count < 11 || rival_roster.first + rival_roster.count > g_.squad_slots.size())
return std::nullopt;
// The captured DayCompetitions2 callargs already encode Source's group order and
// overwrite rules. Confirm that exact pair still exists in this Matchday;
// never substitute another fixture if it has become void or unsupported.
bool current_pair = false;
for (const MatchGroup& group : turn_driver_.groups) {
if (group.fixtures.size() < size_t(group.matches()) * 2) continue;
const int type = group.desc.empty() ? -1 : group.desc.at(0);
int mapped_competition = -1, league = -1;
if (type == 0) {
if (group.desc.size() < 0xd0) continue;
league = int(le32(group.desc, 0xcc));
if (league >= 0 && league < 9)
mapped_competition = int(exe_.u8(::bmh::layout::LeagueCalendarBits + uint32_t(league)));
} else if (type > 0) {
mapped_competition = type + 4;
}
for (int match = 0; match < group.matches(); ++match) {
const int home = group.fixtures.at(size_t(match) * 2);
const int away = group.fixtures.at(size_t(match) * 2 + 1);
if (!((home == runtime_club && away == opponent) ||
(away == runtime_club && home == opponent))) continue;
bool valid = mapped_competition == source.competition;
const uint32_t bit = uint32_t(1) << match;
valid = valid && !(group.kickoff_void_mask & bit) && !(group.void_mask() & bit);
if (valid && type == 0) {
bool has_result = false;
uint8_t raw_result = 0xcc;
if (size_t(match) < group.results.size()) {
has_result = true;
raw_result = group.results[size_t(match)];
} else if (league >= 0 && league < int(g_.league_rounds.size())) {
const int round = int(g_.league_rounds[size_t(league)]);
const size_t result_at = size_t(league) * 0x17c + size_t(round) * 10 + size_t(match);
if (round >= 0 && result_at < g_.results.size()) {
has_result = true;
raw_result = g_.results[result_at];
}
}
if (has_result && raw_result != 0xcc) valid = false;
}
// MatchdayNeedsManagerDesks overwrites the per-manager callargs in group order.
// The last matching pair therefore decides whether this exact
// callarg is still a supported, unplayed fixture.
current_pair = valid;
}
}
return current_pair ? std::optional<int>(opponent) : std::nullopt;
}
ui::PreparationState CareerSession::preparation_projection(const GameState& state, uint64_t revision) const {
auto result = ui::preparation_from_game(state, exe_, revision);
result.desktop = desktop_projection(state, revision);
if (lineup_entry_manager_ == result.lineup.manager_slot &&
lineup_entry_club_ == result.lineup.runtime_club) {
result.lineup.entry_prepared = true;
if (result.pitch) {
const auto opponent = prepared_lineup_opponent(result.lineup.manager_slot,
result.lineup.runtime_club, revision);
if (opponent)
result.pitch = ui::pitch_extras_from_game(state, exe_, revision, *opponent);
}
}
if (result.bank) {
result.bank->last_tip = last_stock_tip_;
result.bank->property_notice = last_property_notice_;
result.bank->credit_notice = last_credit_notice_;
}
if (result.stadium) {
const int team = result.stadium->runtime_club;
const int stable = int(state.club_ids.at(size_t(team)));
const bool owned = stadium_.manager == result.stadium->manager_slot &&
stadium_.club == team && stadium_.stable_club == stable && stadium_.revision == revision;
*result.stadium = ui::stadium_from_game(state, exe_, revision, owned ? stadium_.price_percent : 100);
auto& stadium = *result.stadium;
stadium.source = result.desktop.source;
stadium.club_name = result.desktop.club_name;
stadium.stable_club_identity = stable;
stadium.plain_background = source_runtime_byte(state, club_modal_runtime_, exe_, ::bmh::layout::PlainBackground) != 0;
stadium.decorated_stadium_header = !stadium.plain_background;
stadium.compact_dialog_frame = source_runtime_byte(state, club_modal_runtime_, exe_, ::bmh::layout::CompactDialogFrame) != 0;
stadium.solid_panel_background = source_runtime_byte(state, club_modal_runtime_, exe_, ::bmh::layout::SolidPanelBackground) != 0;
stadium.gradient_text = source_runtime_byte(state, club_modal_runtime_, exe_, ::bmh::layout::TextGradientDisabled) == 0 &&
source_runtime_byte(state, club_modal_runtime_, exe_, ::bmh::layout::TextGradientMode) == 2;
stadium.source_level = state.level;
stadium.season_tickets = uint16_t(state.manager_records.at(size_t(stadium.manager_slot) * 0xb0c + 0x2ac)) |
uint16_t(state.manager_records.at(size_t(stadium.manager_slot) * 0xb0c + 0x2ad)) << 8;
const int source_team = int16_t(uint16_t(state.manager_records.at(size_t(stadium.manager_slot) * 0xb0c + 0x290)) |
uint16_t(state.manager_records.at(size_t(stadium.manager_slot) * 0xb0c + 0x291)) << 8);
const int source_league = source_team > 0x164 ? 0 : team_league(source_team);
if (source_league < 0 || size_t(source_league) >= state.league_rounds.size())
throw FormatError("stadium source league is outside the live league table");
stadium.live_league_round = state.league_rounds.at(size_t(source_league));
stadium.ticket_refund_rate = std::bit_cast<int32_t>(exe_.u32(::bmh::layout::CareerSession_FormatError_RuntimeField5 + uint32_t(source_league) * 4));
stadium.investments_enabled = state.memory.u8(::bmh::layout::GameMode) != 1;
for (size_t i = 0; i < stadium.investments.size(); ++i) {
stadium.investments[i].original_label = texts_[734 + i];
if (!stadium.investments_enabled) stadium.investments[i].available = false;
}
if (owned) {
stadium.opened = stadium_.opened;
stadium.scope = stadium_.scope; stadium.sequence = stadium_.sequence;
if (stadium_.data_open)
stadium.data = ui::stadium_data_from_game(state, exe_, stadium.manager_slot, stadium_.data_flags);
stadium.selected_investment = stadium_.investment;
if (stadium_.option_index >= 0) stadium.selected_option = stadium_.option_index;
stadium.investment_text_variant = stadium_.text_variant;
stadium.action_feedback = stadium_.feedback;
if (stadium_.tip) {
PendingOfferQuestion question;
question.manager = stadium_.manager; question.source_flags = 0x204;
question.original_message = message_text(state, ::bmh::layout::CareerSession_FormatError_TextPointer8) +
format_number(state, stadium_.tip->percent, 1) + message_text(state, ::bmh::layout::CareerSession_FormatError_TextPointer9);
stadium.construction_tip_dialog = ui::pending_offer_question_dialog(state, question);
stadium.construction_tip_price = stadium_.tip->offered_price;
}
if (stadium_.periphery_quote) {
stadium.quoted_object = stadium_.periphery_quote->first;
stadium.quoted_price = stadium_.periphery_quote->second;
PendingOfferQuestion question;
question.manager = stadium_.manager;
question.source_flags = 1; // ConstructionPricePercent -> PresentManagerDialog: ordinary JA/NEIN question.
question.original_message = message_text(state, ::bmh::layout::CareerSession_FormatError_TextPointer6) +
format_number(state, stadium.quoted_price, 0x106) + message_text(state, ::bmh::layout::CareerSession_FormatError_TextPointer7);
stadium.periphery_quote_dialog = ui::pending_offer_question_dialog(state, question);
stadium.periphery_quote_dialog->compact_dialog_frame = stadium.compact_dialog_frame;
}
if (stadium_.block_expansion) {
const auto& draft = *stadium_.block_expansion;
ui::StadiumBlockExpansionEditor editor;
editor.quote = draft.quote;
editor.total_target_places = draft.total_target_places;
editor.desired_features = draft.desired_features;
editor.header_text_variant = draft.header_text_variant;
editor.offer = draft.tip;
const uint32_t current = uint32_t(draft.quote.current_capacity_thousands) * 1000;
const uint32_t added = draft.total_target_places - current;
editor.current_places_text = format_number(state, int32_t(current), 5);
editor.new_places_text = format_number(state, int32_t(added), 5);
editor.target_places_text = format_number(state, int32_t(draft.total_target_places), 5);
const auto cost_text = [&](uint32_t amount) {
return format_number(state, int32_t(amount), 0x181) + exe_.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField);
};
editor.per_thousand_cost_text = format_number(state, int32_t(draft.quote.price_per_1000), 0x181);
editor.new_places_cost_text = cost_text(draft.quote.new_places_cost);
editor.seats_cost_text = cost_text(draft.quote.seats_cost);
editor.roof_cost_text = cost_text(draft.quote.roof_cost);
editor.total_cost_text = cost_text(draft.quote.base_price);
editor.discount_text = exe_.cstring(::bmh::layout::CareerSession_FormatNumber_TextPointer) +
format_number(state, 100 - stadium_.price_percent, 1) + exe_.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField2);
stadium.block_expansion = std::move(editor);
}
if (stadium_.block_expansion && stadium_.block_expansion->tip) {
PendingOfferQuestion question;
question.manager = stadium_.manager;
question.source_flags = 0x204;
question.original_message = message_text(state, ::bmh::layout::CareerSession_FormatError_TextPointer8) +
format_number(state, stadium_.block_expansion->tip->percent, 1) +
message_text(state, ::bmh::layout::CareerSession_FormatError_TextPointer9);
stadium.construction_tip_dialog = ui::pending_offer_question_dialog(state, question);
stadium.construction_tip_dialog->compact_dialog_frame = stadium.compact_dialog_frame;
stadium.construction_tip_price = stadium_.block_expansion->tip->offered_price;
}
}
}
return result;
}
bool CareerSession::dispatch_training(const ui::TrainingRequest& request, uint64_t& revision,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (request.manager_slot != active || request.manager_slot < 0 || request.manager_slot > 3 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision";
return false;
}
try {
const ui::TrainingState current = ui::training_from_game(g_, exe_, revision);
if (current.manager_slot != request.manager_slot || current.runtime_club != request.runtime_club) {
error = "stale_manager_or_revision";
return false;
}
const size_t slot = size_t(request.manager_slot);
const size_t rec = slot * 0xb0c;
const size_t option_at = slot * 5 + 4;
if (g_.manager_records.size() < rec + 0xb0c || g_.manager_options.size() <= option_at) {
error = "invalid_training_state";
return false;
}
auto valid_plan = [](const std::array<uint8_t, 4>& types, const std::array<uint8_t, 9>& areas) {
int type_sum = 0, fitness = 0, skills = 0;
for (uint8_t value : types) { if (value < 1 || value > 3) return false; type_sum += value; }
for (size_t i = 0; i < areas.size(); ++i) {
const uint8_t value = areas[i];
if (value < 1 || value > 3) return false;
if (i < 2) fitness += value; else skills += value;
}
return type_sum <= 8 && fitness <= 4 && skills <= 18;
};
if (!valid_plan(request.desired_types, request.desired_areas)) {
error = "invalid_training_plan";
return false;
}
ui::TrainingRequestKind kind = request.kind;
auto types = current.types;
auto areas = current.areas;
uint8_t automation = current.automation;
bool run_automatic = false;
// NeedsInitialization initializes an uninitialized screen via Initialize;
// the four subordinate toggles exist only while the global flag is on.
// NeedsInitialization2 calls that same deterministic routine after an enabled
// automation toggle. Manual field edits only write their field and clear
// the matching assistant flag; they do not run training or draw RNG.
switch (kind) {
case ui::TrainingRequestKind::initialize:
if (!current.needs_initialization() || request.index != -1 || request.value != -1 ||
request.player_id != -1 || request.desired_types != types || request.desired_areas != areas ||
request.desired_automation != 0x9f) {
error = "invalid_training_initialization";
return false;
}
automation = 0x9f;
run_automatic = true;
break;
case ui::TrainingRequestKind::set_type:
if (current.needs_initialization() || request.index < 0 || request.index >= int(types.size()) ||
request.value < 1 || request.value > 3 || request.player_id != -1 ||
request.value == types[size_t(request.index)]) {
error = "invalid_training_type";
return false;
}
types[size_t(request.index)] = uint8_t(request.value);
automation = uint8_t(automation & ~uint8_t(1u << 1));
break;
case ui::TrainingRequestKind::set_area:
if (current.needs_initialization() || request.index < 0 || request.index >= int(areas.size()) ||
request.value < 1 || request.value > 3 || request.player_id != -1 ||
request.value == areas[size_t(request.index)]) {
error = "invalid_training_area";
return false;
}
areas[size_t(request.index)] = uint8_t(request.value);
automation = uint8_t(automation & ~uint8_t(1u << 2));
break;
case ui::TrainingRequestKind::set_player_intensity:
case ui::TrainingRequestKind::set_player_focus: {
if (current.needs_initialization() || request.index < 0 || request.index >= current.squad_capacity ||
request.player_id < 0 || request.player_id > 0x0ffe) {
error = "invalid_training_player";
return false;
}
const auto player = std::find_if(current.players.begin(), current.players.end(), [&](const auto& p) {
return p.row == request.index && p.player_id == request.player_id;
});
const SquadRange squad = squad_range(request.runtime_club);
if (player == current.players.end() || squad.count != size_t(current.squad_capacity) ||
squad.first + size_t(request.index) >= g_.squad_slots.size() ||
(g_.squad_slots[squad.first + size_t(request.index)] & 0x0fff) != request.player_id) {
error = "stale_training_player";
return false;
}
if (kind == ui::TrainingRequestKind::set_player_intensity) {
if (request.value < 1 || request.value > 3 || request.value == player->intensity) {
error = "invalid_training_intensity";
return false;
}
automation = uint8_t(automation & ~uint8_t(1u << 3));
} else if (request.value < 0 || request.value > 7 || request.value != (player->focus + 1) % 8) {
error = "invalid_training_focus";
return false;
}
break;
}
case ui::TrainingRequestKind::set_automation: {
if (current.needs_initialization() || request.index < 0 || request.index > 4 ||
(request.value != 0 && request.value != 1) || request.player_id != -1) {
error = "invalid_training_automation";
return false;
}
if (request.index != 0 && !(current.automation & 1)) {
error = "training_automation_group_hidden";
return false;
}
const uint8_t mask = uint8_t(1u << request.index);
automation = uint8_t(automation ^ mask);
if (((automation & mask) != 0) != (request.value != 0)) {
error = "stale_training_automation";
return false;
}
run_automatic = (automation & 1) != 0;
break;
}
case ui::TrainingRequestKind::none:
default:
error = "unsupported_training_request";
return false;
}
if (request.desired_types != types || request.desired_areas != areas ||
request.desired_automation != automation) {
error = "stale_training_projection";
return false;
}
GameState staged = g_;
std::copy(types.begin(), types.end(), staged.manager_records.begin() + rec + 0xc5);
std::copy(areas.begin(), areas.end(), staged.manager_records.begin() + rec + 0xc9);
staged.manager_options[option_at] = automation;
if (kind == ui::TrainingRequestKind::set_player_intensity ||
kind == ui::TrainingRequestKind::set_player_focus) {
const size_t board = slot * 0x840 + size_t(request.index) * 0x58 + 0x0a;
if (board >= staged.tactics.size()) {
error = "invalid_training_board";
return false;
}
if (kind == ui::TrainingRequestKind::set_player_intensity)
staged.tactics[board] = uint8_t((staged.tactics[board] & 0xfc) | request.value);
else
staged.tactics[board] = uint8_t((staged.tactics[board] & 0x03) | (request.value << 2));
}
if (run_automatic) auto_training(staged, request.manager_slot);
g_ = std::move(staged);
++revision;
error.clear();
return true;
} catch (const std::exception&) {
error = "invalid_training_state";
return false;
}
}
void CareerSession::capture_source_desk_callargs() {
source_desk_callargs_.clear();
const auto stage = turn_driver_.stage;
if (stage != TurnDriver::Stage::MatchdayDesks &&
stage != TurnDriver::Stage::SeasonEndDesk)
return;
uint32_t competitions = 0;
int default_competition = 32;
const std::vector<MatchGroup>* groups = nullptr;
if (stage == TurnDriver::Stage::MatchdayDesks) {
competitions = day_competitions(g_, turn_driver_.calendar_entry);
if (competitions == 0x800000) competitions = 0;
default_competition = competitions != 0 ? 34 : 33;
groups = &turn_driver_.groups;
}
// DayCompetitions2 initializes the full four-slot callarg arrays before joining
// any manager desk: FF opponents, competition 33/34 (or 32 at season end).
source_desk_callargs_.assign(4, ui::DeskMatchCallargs{default_competition, -1});
for (size_t slot = 0; slot < g_.manager_teams.size(); ++slot) {
if (slot >= source_desk_callargs_.size())
throw FormatError("desk: too many manager slots while capturing Source callargs");
if (!groups) continue;
GameState manager_view = g_;
if (!manager_view.memory.has(::bmh::layout::ActiveManager))
throw FormatError("desk: active manager field is missing while capturing Source callargs");
manager_view.memory.set8(::bmh::layout::ActiveManager, uint8_t(slot));
const ui::DeskState source = ui::desk_from_game(
manager_view, exe_, turn_driver_.revision, groups, default_competition);
source_desk_callargs_[slot] = {source.next_competition.value_or(default_competition),
source.next_opponent.value_or(-1)};
}
}
ui::DeskState CareerSession::desktop_projection(uint64_t revision) const {
return desktop_projection(g_, revision);
}
ui::DeskState CareerSession::desktop_projection(const GameState& state, uint64_t revision) const {
std::optional<int> source_default;
if (turn_driver_.stage == TurnDriver::Stage::SeasonEndDesk) {
source_default = 32;
} else if (turn_driver_.stage == TurnDriver::Stage::MatchdayDesks) {
uint32_t competitions = day_competitions(state, turn_driver_.calendar_entry);
if (competitions == 0x800000) competitions = 0;
source_default = competitions != 0 ? 34 : 33;
} else {
// An unsupported/empty saved cursor is not evidence that the Source
// dispatcher produced its no-fixture default. Keep those fields unknown.
return ui::desk_from_game(state, exe_, revision);
}
const int slot = int(state.memory.u8(::bmh::layout::ActiveManager));
const ui::DeskMatchCallargs defaults{source_default.value_or(34), -1};
const ui::DeskMatchCallargs* callargs = &defaults;
if (slot >= 0 && size_t(slot) < source_desk_callargs_.size())
callargs = &source_desk_callargs_[size_t(slot)];
return ui::desk_from_game(state, exe_, revision, &turn_driver_.groups, source_default, callargs);
}
void CareerSession::configure_autosave_directory(const std::filesystem::path& directory) {
if (autosave_directory_ && *autosave_directory_ == directory) return;
if (calendar_advance_active_) throw FormatError("autosave directory change during active turn");
autosave_directory_ = directory;
turn_driver_.desk_autosave = [this](const GameState& state, WatcomRandom& random) {
write_desk_autosave(state, random);
};
}
std::string CareerSession::take_autosave_error() {
return std::exchange(autosave_error_, {});
}
void CareerSession::write_desk_autosave(const GameState& state, WatcomRandom& random) {
std::filesystem::path temporary;
try {
if (!autosave_directory_ || !std::filesystem::is_directory(*autosave_directory_))
throw FormatError("autosave directory unavailable");
// CareerSession_Name_TextPointer is the Original TEXTD filename, not the manual browser name.
const std::filesystem::path name(texts_.strings.at((::bmh::layout::CareerSession_Name_TextPointer - ::bmh::layout::TextPointerTable) / 4));
if (name.empty() || name != name.filename() || name.extension() != ".FBM")
throw FormatError("invalid Original autosave filename");
const auto target = *autosave_directory_ / name;
if (std::filesystem::is_symlink(std::filesystem::symlink_status(target)) ||
std::filesystem::is_directory(target)) throw FormatError("autosave target unavailable");
WatcomRandom staged = random;
const auto saved = make_savegame(state, staged);
temporary = target;
temporary += ".tmp-" + std::to_string(saved.id2);
if (std::filesystem::exists(std::filesystem::symlink_status(temporary))) {
temporary.clear();
throw FormatError("autosave temporary target already exists");
}
write_savegame(temporary, saved);
if (std::filesystem::is_symlink(std::filesystem::symlink_status(target)) ||
std::filesystem::is_directory(target)) throw FormatError("autosave target changed");
std::filesystem::rename(temporary, target);
temporary.clear();
random = staged;
} catch (const std::exception& e) {
autosave_error_ = e.what();
if (!temporary.empty()) {
std::error_code ignored;
std::filesystem::remove(temporary, ignored);
}
}
}
bool CareerSession::save_game(const std::filesystem::path& path, int manager_slot, bool overwrite, std::string& error) {
if (advertising_renewal_dispatch_active_) { error="save_blocked_during_advertising_renewal"; return false; }
if(balance_draft_||balance_dispatch_active_||strengths_owner_||strengths_dispatch_active_||
top_scorers_owner_||top_scorers_dispatch_active_ || stadium_.block_expansion||other_games_owner_||other_games_dispatch_active_){error="strengths_active";return false;}
if(balance_draft_||balance_dispatch_active_||league_pairings_draft_||league_pairings_dispatch_active_){error="league_pairings_active";return false;}
if (transfer_offer_editor_) { error = "transfer_offer_editor_active"; return false; }
if (pending_offer_dispatch_active_) { error = "pending_offer_decision_active"; return false; }
if (market_dispatch_active_) { error = "transfer_market_decision_active"; return false; }
if (career_complete()) { error = "career_complete"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
std::string extension = path.extension().string();
std::transform(extension.begin(), extension.end(), extension.begin(), [](unsigned char c) { return char(std::tolower(c)); });
if (manager_slot != active || manager_slot < 0 || size_t(manager_slot) >= g_.manager_teams.size() ||
extension != ".fbm" || path.filename().empty()) {
error = "invalid_save_request"; return false;
}
std::error_code ec;
if (!std::filesystem::is_directory(path.parent_path(), ec) || ec) {
error = "save_directory_unavailable"; return false;
}
const auto status = std::filesystem::symlink_status(path, ec);
if (!ec && std::filesystem::is_symlink(status)) { error = "save_target_is_symlink"; return false; }
ec.clear();
const bool exists = std::filesystem::exists(path, ec);
if (ec || (exists && !overwrite)) { error = exists ? "overwrite_confirmation_required" : "save_target_unavailable"; return false; }
try {
WatcomRandom staged_rand = rand_;
const Savegame save = make_savegame(g_, staged_rand);
write_savegame(path, save);
rand_ = staged_rand;
return true;
} catch (const std::exception&) {
error = "save_write_failed"; return false;
}
}
bool CareerSession::dispatch_menu_layout(const ui::SaveLoadRequest& request, uint64_t& revision,
std::string& error) {
constexpr uint32_t kLayouts = ::bmh::layout::Desktops;
constexpr size_t kLayoutBytes = 0x360;
constexpr int kDeskItemCount = 54;
if (request.file_kind != ui::SaveLoadFileKind::menu_layout ||
request.origin_item_id < 0 || request.origin_item_id >= kDeskItemCount) {
error = "invalid_menu_layout_origin"; return false;
}
if (request.revision != revision || revision == UINT64_MAX || request.path.filename().empty() ||
request.manager_slot < 0 || request.manager_slot > 3 ||
!g_.memory.has(::bmh::layout::ActiveManager) || int(g_.memory.u8(::bmh::layout::ActiveManager)) != request.manager_slot) {
error = "stale_menu_layout_owner"; return false;
}
if (calendar_advance_active_ || live_intervention_ || career_complete() ||
(turn_driver_.stage != TurnDriver::Stage::Empty &&
turn_driver_.stage != TurnDriver::Stage::MatchdayDesks &&
turn_driver_.stage != TurnDriver::Stage::SeasonEndDesk) ||
pending_offer_dispatch_active_ || market_dispatch_active_ || transfer_offer_editor_ ||
manager_join_ || contract_quote_ || advertising_renewal_dispatch_active_ ||
balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || opportunities_owner_ ||
opportunities_dispatch_active_ || league_pairings_draft_ || league_pairings_dispatch_active_ ||
league_family_owner_ || league_family_teaminfo_active_ || other_games_owner_ ||
other_games_dispatch_active_ || stadium_.block_expansion || stadium_.investment ||
stadium_.tip || stadium_.periphery_quote) {
error = "menu_layout_unavailable_during_active_flow"; return false;
}
std::string extension = request.path.extension().string();
std::transform(extension.begin(), extension.end(), extension.begin(),
[](unsigned char c) { return char(std::tolower(c)); });
if (extension != ".men") { error = "invalid_menu_layout_extension"; return false; }
const size_t active_base = size_t(request.manager_slot) * 0xb0c;
if (active_base + 0xb0c > g_.manager_records.size() ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
(int(g_.manager_records[active_base + 0x290]) |
int(g_.manager_records[active_base + 0x291]) << 8) != g_.manager_teams[size_t(request.manager_slot)]) {
error = "menu_layout_manager_record_mismatch"; return false;
}
if (!g_.memory.has(kLayouts + uint32_t(request.manager_slot) * uint32_t(kLayoutBytes) +
uint32_t(kLayoutBytes - 1))) {
error = "menu_layout_memory_unavailable"; return false;
}
// CopyN returns the matching record index. In the native MEN file,
// the final bar cell (source value 72) resolves to record 53; DeskDate
// dispatches that index to the menu-layout chooser.
const uint32_t base = kLayouts + uint32_t(request.manager_slot) * uint32_t(kLayoutBytes);
const int source_item = g_.memory.u8(base + 53u * 16u + 12u) == 72 ? 53 : -1;
if (source_item != request.origin_item_id) { error = "menu_layout_source_handle_unavailable"; return false; }
const auto validate_payload = [&](const Bytes& bytes) -> bool {
if (bytes.size() != kLayoutBytes) { error = "menu_layout_wrong_size"; return false; }
// Bound the forward traversal before asking the desk projector to
// validate geometry, kinds, and remaining source fields. Native layouts
// may contain valid custom back-links; Source load does not normalize them.
std::array<bool, kDeskItemCount> seen{};
const int head = bytes[5];
// CopyN permits an empty linked drawer (head == 0).
if (head == 0) return true;
if (head < 1 || head >= kDeskItemCount) { error = "menu_layout_invalid_head"; return false; }
int item = head;
for (int steps = 0; steps < kDeskItemCount; ++steps) {
if (item <= 0 || item >= kDeskItemCount || seen[size_t(item)]) {
error = "menu_layout_invalid_chain"; return false;
}
seen[size_t(item)] = true;
const size_t at = size_t(item) * 16;
item = bytes[at + 5];
if (item == 0) return true;
if (item == 0xff) { error = "menu_layout_invalid_chain_terminator"; return false; }
}
error = "menu_layout_chain_cycle"; return false;
};
if (request.action == ui::SaveLoadAction::load) {
Bytes payload;
try { payload = read_file(request.path); }
catch (const std::exception&) { error = "menu_layout_read_failed"; return false; }
if (!validate_payload(payload)) return false;
GameState staged = g_;
for (size_t i = 0; i < kLayoutBytes; ++i)
staged.memory.set8(base + uint32_t(i), payload[i]);
try {
(void)desktop_projection(staged, revision + 1);
} catch (const std::exception&) { error = "menu_layout_projection_invalid"; return false; }
g_ = std::move(staged);
++revision;
error.clear();
return true;
}
if (request.action != ui::SaveLoadAction::save) {
error = "invalid_menu_layout_action";
return false;
}
std::error_code ec;
if (!std::filesystem::is_directory(request.path.parent_path(), ec) || ec) {
error = "menu_layout_directory_unavailable"; return false;
}
ec.clear();
const auto status = std::filesystem::symlink_status(request.path, ec);
if (!ec && std::filesystem::is_symlink(status)) { error = "menu_layout_target_is_symlink"; return false; }
ec.clear();
const bool exists = std::filesystem::exists(request.path, ec);
if (ec || (exists && !request.overwrite)) {
error = exists ? "menu_layout_overwrite_confirmation_required" : "menu_layout_target_unavailable";
return false;
}
Bytes payload(kLayoutBytes);
for (size_t i = 0; i < kLayoutBytes; ++i) payload[i] = g_.memory.u8(base + uint32_t(i));
if (!validate_payload(payload)) return false;
try {
std::ofstream file(request.path, std::ios::binary | std::ios::trunc);
if (!file) { error = "menu_layout_write_failed"; return false; }
file.write(reinterpret_cast<const char*>(payload.data()), std::streamsize(payload.size()));
file.flush();
if (!file) { error = "menu_layout_write_failed"; return false; }
} catch (const std::exception&) { error = "menu_layout_write_failed"; return false; }
++revision;
error.clear();
return true;
}
bool CareerSession::dispatch_training_camp(const ui::TrainingCampRequest& request, uint64_t& revision,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
if (request.manager_slot < 0 || size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.manager_slot != int(g_.memory.u8(::bmh::layout::ActiveManager)) ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision";
return false;
}
const size_t rec = size_t(request.manager_slot) * 0xb0c;
if (request.kind == ui::TrainingCampRequestKind::set_focus) {
const std::array<uint8_t, 4> current{
g_.manager_records.at(rec + 0xc1), g_.manager_records.at(rec + 0xc2),
g_.manager_records.at(rec + 0xc3), g_.manager_records.at(rec + 0xc4)};
if (request.focus == current) {
error = "focus_unchanged";
return false;
}
if (!set_training_camp_focus(g_, request.manager_slot, request.focus)) {
error = "invalid_focus_request";
return false;
}
++revision;
return true;
}
if (request.kind == ui::TrainingCampRequestKind::book) {
if (request.resort < 0 || request.resort >= kTrainingCampResorts) {
error = "invalid_resort";
return false;
}
const std::array<uint8_t, 4> current{
g_.manager_records.at(rec + 0xc1), g_.manager_records.at(rec + 0xc2),
g_.manager_records.at(rec + 0xc3), g_.manager_records.at(rec + 0xc4)};
if (request.focus != current) {
error = "stale_focus";
return false;
}
switch (training_camp_booking_block(g_, request.manager_slot)) {
case TrainingCampBookingBlock::booked_this_week: error = "booked_this_week"; return false;
case TrainingCampBookingBlock::visit_limit: error = "visit_limit"; return false;
case TrainingCampBookingBlock::invalid_request: error = "invalid_request"; return false;
case TrainingCampBookingBlock::none: break;
}
if (!book_training_camp(g_, request.manager_slot, request.resort, rand_)) {
error = "insufficient_funds";
return false;
}
++revision;
return true;
}
error = "unsupported_training_camp_request";
return false;
}
bool CareerSession::dispatch_bank(const ui::BankRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
error.clear();
if (revision == std::numeric_limits<uint64_t>::max()) {
error = "revision_exhausted"; return false;
}
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (request.manager_slot != active ||
request.manager_slot < 0 || size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision"; return false;
}
const size_t rec = size_t(request.manager_slot) * 0xb0c;
std::optional<ui::BankState::PropertyNotice> property_notice;
std::optional<ui::BankState::CreditNotice> credit_notice;
const auto read_signed = [&](size_t offset) {
const uint32_t v = uint32_t(g_.manager_records.at(rec + offset)) |
uint32_t(g_.manager_records.at(rec + offset + 1)) << 8 |
uint32_t(g_.manager_records.at(rec + offset + 2)) << 16 |
uint32_t(g_.manager_records.at(rec + offset + 3)) << 24;
return int32_t(v);
};
if (request.kind == ui::BankRequestKind::move_to_deposit) {
if (!request.amount || request.asset_index != -1 || request.count != 0 ||
int64_t(request.amount > 0 ? request.amount : -int64_t(request.amount)) > 99999999) {
error = "invalid_amount"; return false;
}
const int64_t available = request.amount > 0 ? read_signed(0x314) : read_signed(0x318);
if (available < 0 || int64_t(request.amount > 0 ? request.amount : -int64_t(request.amount)) > available) {
error = "amount_unavailable"; return false;
}
move_to_deposit(g_, request.manager_slot, request.amount);
} else if (request.kind == ui::BankRequestKind::buy_shares || request.kind == ui::BankRequestKind::sell_shares ||
request.kind == ui::BankRequestKind::stock_tip) {
if (request.asset_index < 0 || request.asset_index >= kStocks ||
g_.stocks.size() < size_t(kStocks) * 0x5c) { error = "invalid_stock"; return false; }
const size_t at = size_t(request.asset_index) * 0x5c;
const int price = int(uint16_t(g_.stocks.at(at + 0x4e) | uint16_t(g_.stocks.at(at + 0x4f)) << 8));
if (request.kind == ui::BankRequestKind::buy_shares) {
if (request.count <= 0 || request.count > 9999 || price <= 0 ||
request.count > max_shares_to_buy(g_, request.manager_slot, request.asset_index)) {
error = "invalid_share_count"; return false;
}
const int64_t raw = int64_t(price) * request.count;
const int64_t total = raw + raw * 15 / 1000;
if (total > int64_t(read_signed(0x314)) + read_signed(0x31c)) {
error = "insufficient_funds"; return false;
}
if (!buy_shares(g_, request.manager_slot, request.asset_index, request.count)) {
error = "investment_limit"; return false;
}
} else if (request.kind == ui::BankRequestKind::sell_shares) {
const size_t held_at = at + 0x50 + size_t(request.manager_slot) * 2;
const int held = int(uint16_t(g_.stocks.at(held_at) | uint16_t(g_.stocks.at(held_at + 1)) << 8));
if (request.count <= 0 || request.count > held) { error = "invalid_share_count"; return false; }
sell_shares(g_, request.manager_slot, request.asset_index, request.count);
} else {
if (request.count != 0 || request.amount != 0) { error = "invalid_tip_request"; return false; }
last_stock_tip_ = stock_tip(g_, request.manager_slot, request.asset_index, rand_);
}
} else if (request.kind == ui::BankRequestKind::buy_fund || request.kind == ui::BankRequestKind::sell_fund) {
if (request.amount != 0 || request.asset_index < 0 || request.asset_index >= kFunds || request.count <= 0 || request.count > 10 ||
g_.memory.u32(::bmh::layout::FundBlock + uint32_t(request.asset_index) * 0x1c) == 0) {
error = "invalid_fund_request"; return false;
}
const uint32_t fund_at = ::bmh::layout::FundBlock + uint32_t(request.asset_index) * 0x1c;
const uint16_t held = g_.memory.u16(fund_at + 0x14 + uint32_t(request.manager_slot) * 2);
if (request.kind == ui::BankRequestKind::buy_fund) {
if (request.count > max_fund_units(g_, request.manager_slot, request.asset_index)) {
error = "invalid_fund_count"; return false;
}
const int32_t additional_cost = buy_fund_units(g_, request.manager_slot, request.asset_index, request.count, game_);
if (request.asset_index != 0) {
const std::string text = message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer2) + format_number(g_, additional_cost, 0x101) +
message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer);
property_notice = ui::BankState::PropertyNotice{request.asset_index, additional_cost, ui::original_to_utf8(text)};
}
} else {
if (request.count > held) { error = "invalid_fund_count"; return false; }
sell_fund_units(g_, request.manager_slot, request.asset_index, request.count);
}
} else if (request.kind == ui::BankRequestKind::bank_credit) {
if (request.amount != 0 || request.asset_index != -1 || request.count != 0 || request.credit_edits.empty()) {
error = "invalid_credit_request"; return false;
}
if (request.credit_counterparty != 0) {
// Source case 5 scans configured human managers, excluding the borrower.
// A runtime national-manager entry is not an additional human lender.
const int configured = int(g_.memory.u8(::bmh::layout::ManagerCount));
if (request.credit_counterparty < 1 || request.credit_counterparty > 4) {
error = "invalid_credit_request"; return false;
}
const int lender = request.credit_counterparty - 1;
if (configured < 1 || configured > 4 || request.manager_slot >= configured ||
lender < 0 || lender >= configured || lender == request.manager_slot) {
error = "invalid_credit_request"; return false;
}
}
const auto result = commit_bank_credit(g_, exe_, request.manager_slot,
request.expected_credit, request.credit_edits, request.accept_credit_fees, request.credit_counterparty);
if (result.status != BankCreditStatus::accepted) {
error = result.status == BankCreditStatus::no_change ? "credit_no_change" :
result.status == BankCreditStatus::stale_request ? "stale_credit_request" :
result.status == BankCreditStatus::confirmation_required ? "credit_confirmation_required" :
"invalid_credit_request";
return false;
}
if (result.refund != 0) {
// "Die Bank" (CareerSession_Int32T_TextPointer3) or, in case 5, the lender's name (record +0xa8)
const int lender = request.credit_counterparty - 1;
std::string who = message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer3);
if (lender >= 0) {
who.clear();
for (size_t i = 0; i < 26; ++i) {
const uint8_t ch = g_.manager_records.at(size_t(lender) * 0xb0c + 0xa8 + i);
if (!ch) break;
who += char(ch);
}
}
const std::string text = who + message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer4) +
format_number(g_, result.refund, 0x101) + message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer5);
credit_notice = ui::BankState::CreditNotice{result.refund, ui::original_to_utf8(text)};
}
} else {
error = "unsupported_bank_request"; return false;
}
last_property_notice_ = std::move(property_notice);
last_credit_notice_ = std::move(credit_notice);
++revision;
return true;
}
bool CareerSession::stadium_tip_deadline_expired() const {
if (!stadium_.opened || (!stadium_.tip &&
(!stadium_.block_expansion || !stadium_.block_expansion->tip))) return false;
const auto byte = [this](uint32_t address) {
if (g_.memory.has(address)) return g_.memory.u8(address);
const auto found = club_modal_runtime_.find(address);
return found == club_modal_runtime_.end() ? exe_.u8(address) : found->second;
};
const auto word = [&byte](uint32_t address) {
uint32_t value = 0;
for (unsigned i = 0; i < 4; ++i) value |= uint32_t(byte(address + i)) << (8 * i);
return value;
};
return word(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField2) != 0 && int32_t(word(::bmh::layout::CareerSession_FormatError_ExecutableField2)) < 1;
}
bool CareerSession::dispatch_stadium(const ui::StadiumRequest& supplied_request, uint64_t& revision, std::string& error,
const ConstructionNoticeHook& notice_presenter,
const SeasonTicketCompensationNoticeHook& compensation_presenter) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
auto request = supplied_request;
// Existing CLI periphery callers predate the UI scope envelope. Restrict
// this compatibility adapter to their four original operations and an
// entirely absent envelope; investments and close remain strictly owned.
const bool legacy_periphery = !request.stable_club_identity && request.scope == 0 && request.sequence == 0 &&
(request.kind == ui::StadiumRequestKind::open || request.kind == ui::StadiumRequestKind::quote_periphery ||
request.kind == ui::StadiumRequestKind::decline_periphery || request.kind == ui::StadiumRequestKind::build_periphery);
if (legacy_periphery && active >= 0 && active <= 3 && size_t(active) < g_.manager_teams.size() &&
request.runtime_club >= 0 && size_t(request.runtime_club) < g_.club_ids.size()) {
request.stable_club_identity = int(g_.club_ids[size_t(request.runtime_club)]);
if (request.kind != ui::StadiumRequestKind::open) {
request.scope = stadium_.scope; request.sequence = stadium_.sequence;
}
}
const bool block_action = is_block_expansion_action(request.kind);
if (!block_action && (request.block_slot != -1 || request.block_total_places != 0 ||
request.block_features != 0 || request.expected_block_quote)) {
error = "unexpected_block_expansion_fields"; return false;
}
if (request.manager_slot != active || active < 0 || active > 3 ||
size_t(active) >= g_.manager_teams.size() || request.runtime_club != g_.manager_teams[size_t(active)] ||
request.runtime_club < 0 || request.runtime_club >= 357 ||
size_t(request.runtime_club) >= g_.club_ids.size() ||
request.stable_club_identity != std::optional<int>(int(g_.club_ids[size_t(request.runtime_club)])) ||
request.revision != revision || revision == UINT64_MAX || !g_.memory.has(::bmh::layout::GameMode)) {
error = "stale_manager_or_revision"; return false;
}
const size_t record = size_t(active) * 0xb0c;
if (record + 0xb0c > g_.manager_records.size() ||
(int(g_.manager_records[record + 0x290]) | int(g_.manager_records[record + 0x291]) << 8) != request.runtime_club) {
error = "invalid_stadium_owner"; return false;
}
const int mode = g_.memory.u8(::bmh::layout::GameMode);
if (mode < 1 || mode > 3) { error = "invalid_stadium_mode"; return false; }
if (request.kind == ui::StadiumRequestKind::open) {
const bool legacy_reentry = legacy_periphery && !stadium_.data_open && !stadium_.investment && !stadium_.tip &&
!stadium_.block_expansion;
if ((stadium_.opened && !legacy_reentry) || request.scope != 0 || request.sequence != 0 || request.object != -1 ||
request.option != -1 || request.price != 0 || request.accept_tip || next_stadium_scope_ == UINT64_MAX) {
error = "invalid_stadium_open"; return false;
}
} else if (!stadium_.opened || stadium_.manager != active || stadium_.club != request.runtime_club ||
stadium_.stable_club != *request.stable_club_identity || stadium_.mode != mode ||
stadium_.revision != revision || request.scope != stadium_.scope ||
request.sequence != stadium_.sequence || stadium_.sequence == UINT64_MAX) {
error = "stale_stadium_scope"; return false;
}
auto before = stadium_checkpoint();
const uint64_t before_revision = revision;
try {
const auto apply = [&]() -> bool {
const auto invalid = [&error](const char* reason) { error = reason; return false; };
const auto plain = [&request](int object = -1) {
return request.object == object && request.option == -1 && request.price == 0 && !request.accept_tip;
};
const auto clear_investment = [this] {
stadium_.investment.reset(); stadium_.selection_status.reset(); stadium_.option.reset(); stadium_.tip.reset();
stadium_.option_index = -1; stadium_.text_variant = -1;
};
StadiumInvestmentConstants constants;
for (unsigned i = 0; i < 8; ++i) {
constants.price[i] = exe_.u32(::bmh::layout::CareerSession_DispatchStadium_RuntimeField + i * 4);
constants.weeks[i] = exe_.u8(::bmh::layout::CareerSession_DispatchStadium_RuntimeField2 + (14 + i) * 5);
}
const auto options = [&](StadiumInvestment investment) {
return stadium_investment_options_source(g_, active, investment, stadium_.price_percent, constants);
};
const auto selected_valid = [&]() {
if (!stadium_.investment || !stadium_.option || stadium_.option_index < 0) return false;
const auto current = options(*stadium_.investment);
return size_t(stadium_.option_index) < current.size() &&
current[size_t(stadium_.option_index)] == *stadium_.option;
};
if (request.kind == ui::StadiumRequestKind::open) {
StadiumRuntime opened;
opened.opened = true; opened.manager = active; opened.club = request.runtime_club;
opened.stable_club = *request.stable_club_identity; opened.mode = mode;
opened.scope = next_stadium_scope_++;
opened.price_percent = construction_price_percent(g_, active, game_);
if (opened.price_percent < 1 || opened.price_percent > 427) return invalid("invalid_stadium_discount");
stadium_ = std::move(opened);
return true;
}
if (request.kind == ui::StadiumRequestKind::close) {
if (stadium_.data_open || !plain() || stadium_.investment || stadium_.periphery_quote || stadium_.tip ||
stadium_.block_expansion)
return invalid("invalid_stadium_close");
stadium_.opened = false; stadium_.periphery_quote.reset(); clear_investment();
stadium_.feedback.clear(); return true;
}
const bool data_action = request.kind == ui::StadiumRequestKind::open_data ||
request.kind == ui::StadiumRequestKind::toggle_data_curve ||
request.kind == ui::StadiumRequestKind::toggle_data_scale ||
request.kind == ui::StadiumRequestKind::set_data_ticket_price ||
request.kind == ui::StadiumRequestKind::close_data;
if (data_action) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.tip || stadium_.block_expansion ||
request.option != -1 || request.price != 0 || request.accept_tip)
return invalid("invalid_stadium_data_context");
if (request.kind == ui::StadiumRequestKind::open_data) {
if (stadium_.data_open || request.object != -1) return invalid("invalid_stadium_data_open");
const uint32_t flags_at = ::bmh::layout::Flags + uint32_t(active) * 3 + 1;
if (!g_.memory.has(flags_at)) return invalid("missing_stadium_data_flags");
stadium_.data_flags = g_.memory.u8(flags_at);
// Build the pure projection before accepting modal ownership.
(void)ui::stadium_data_from_game(g_, exe_, active, stadium_.data_flags);
stadium_.data_open = true;
} else {
if (!stadium_.data_open) return invalid("stadium_data_not_open");
if (request.kind == ui::StadiumRequestKind::toggle_data_curve) {
if (request.object < 0 || request.object > 5) return invalid("invalid_stadium_data_curve");
stadium_.data_flags ^= uint8_t(1u << request.object);
} else if (request.kind == ui::StadiumRequestKind::toggle_data_scale) {
if (request.object < 0 || request.object > 1) return invalid("invalid_stadium_data_scale");
stadium_.data_flags ^= 0xc0; // Either ABS or REL button toggles both Source bits.
} else if (request.kind == ui::StadiumRequestKind::set_data_ticket_price) {
if (request.object < 10 || request.object > 25) return invalid("invalid_stadium_data_ticket");
g_.manager_records[record + 0x26e] = uint8_t(request.object);
(void)ui::stadium_data_from_game(g_, exe_, active, stadium_.data_flags);
} else {
if (request.object != -1) return invalid("invalid_stadium_data_close");
g_.memory.set8(::bmh::layout::Flags + uint32_t(active) * 3 + 1, stadium_.data_flags);
stadium_.data_open = false;
}
}
stadium_.feedback.clear();
return true;
}
if (stadium_.data_open) return invalid("stadium_data_active");
if (mode == 1 && !legacy_periphery &&
(request.kind == ui::StadiumRequestKind::quote_periphery ||
request.kind == ui::StadiumRequestKind::build_periphery ||
request.kind == ui::StadiumRequestKind::decline_periphery))
return invalid("stadium_periphery_disabled");
if (request.kind == ui::StadiumRequestKind::quote_periphery) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.block_expansion || request.object < 0 ||
request.object >= 14 || !plain(request.object)) return invalid("invalid_periphery_offer");
const size_t object = size_t(request.object);
const uint8_t level = g_.manager_records[record + object];
if (g_.manager_records[record + 0x1e + object] != 0 || (object == 0 ? level >= 0xab : level != 0))
return invalid("periphery_unavailable");
const int32_t price = periphery_offer(g_, request.object, game_);
if (price <= 0) return invalid("invalid_periphery_price");
stadium_.periphery_quote = std::make_pair(request.object, price);
stadium_.feedback.clear(); return true;
}
if (request.kind == ui::StadiumRequestKind::decline_periphery ||
request.kind == ui::StadiumRequestKind::build_periphery) {
if (stadium_.investment || stadium_.block_expansion || !stadium_.periphery_quote ||
request.option != -1 || request.accept_tip ||
request.object != stadium_.periphery_quote->first || request.price != stadium_.periphery_quote->second)
return invalid("stale_periphery_offer");
if (request.kind == ui::StadiumRequestKind::build_periphery) {
const size_t object = size_t(request.object);
const uint8_t level = g_.manager_records[record + object];
if (g_.manager_records[record + 0x1e + object] != 0 || (object == 0 ? level >= 0xab : level != 0))
return invalid("periphery_unavailable");
// ConstructionPricePercent consumes this genuine JA even when PayConstruction's
// payment fails. The Source presenter runs before the quote
// is cleared; payment/sponsor effects are not rolled back.
const bool built = build_periphery(g_, active, request.object,
uint32_t(request.price), rand_, notice_presenter);
stadium_.feedback = built || notice_presenter ? std::string{} : message_text(g_, ::bmh::layout::Advertising_FormatError_TextPointer18);
}
stadium_.periphery_quote.reset();
if (request.kind == ui::StadiumRequestKind::decline_periphery) stadium_.feedback.clear();
return true;
}
// A–H uses its own quote/commit domain and remains available in
// Source mode 1, where facilities are disabled. All request fields
// outside the typed block envelope must stay neutral.
if (block_action) {
if (request.object != -1 || request.option != -1 || request.price != 0 ||
(request.kind != ui::StadiumRequestKind::expansion_answer_tip && request.accept_tip))
return invalid("invalid_block_expansion_envelope");
const auto block_constants=stadium_block_expansion_constants(exe_);
const auto quote_block = [&](StadiumBlockSlot slot, uint32_t total, uint8_t features) {
return quote_stadium_block_expansion(g_, active, slot, total, features,
stadium_.price_percent, block_constants);
};
if (request.kind == ui::StadiumRequestKind::expansion_select) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.block_expansion ||
request.block_slot < 0 || request.block_slot >= 8 || request.block_total_places != 0 ||
request.block_features != 0 || request.expected_block_quote)
return invalid("invalid_block_expansion_selection");
const auto slot = static_cast<StadiumBlockSlot>(request.block_slot);
const uint8_t raw = g_.manager_records.at(record + 0x44 + size_t(request.block_slot));
const uint32_t current = uint32_t(g_.manager_records.at(record + 0x4c + size_t(request.block_slot))) * 1000;
auto quote = quote_block(slot, current, uint8_t(raw & kBlockFeatures));
if (!quote) return invalid("block_expansion_unavailable");
StadiumRuntime::BlockExpansion draft;
draft.quote = *quote;
draft.total_target_places = current;
draft.desired_features = uint8_t(raw & kBlockFeatures);
game_.set_seed(int32_t(g_.memory.u32(::bmh::layout::CareerSession_Invalid_RuntimeField2)));
draft.header_text_variant = game_.range(3, 10); // Front, once on editor entry.
stadium_.block_expansion = std::move(draft);
stadium_.feedback.clear();
return true;
}
if (!stadium_.block_expansion || stadium_.investment || stadium_.periphery_quote ||
request.block_slot < 0 || request.block_slot >= 8 ||
request.block_slot != int(stadium_.block_expansion->quote.slot) ||
!request.expected_block_quote || *request.expected_block_quote != stadium_.block_expansion->quote)
return invalid("stale_block_expansion_quote");
auto& draft = *stadium_.block_expansion;
if (draft.tip) {
const auto& tip = *draft.tip;
const bool valid_tip = tip.decision == StandBlockOfferDecision::Pending &&
tip.base_price == draft.quote.base_price && tip.base_days == draft.quote.base_weeks &&
tip.price == tip.base_price && tip.percent >= 6 && tip.percent <= 14 &&
tip.offered_price == uint32_t(uint64_t(tip.base_price) * uint32_t(100 + tip.percent) / 100);
if (!valid_tip) return invalid("stale_block_expansion_tip");
}
auto fresh = quote_block(draft.quote.slot, draft.total_target_places, draft.desired_features);
if (!fresh || *fresh != draft.quote)
return invalid("block_expansion_source_changed");
const auto matches_draft = [&] {
return request.block_total_places == draft.total_target_places &&
request.block_features == draft.desired_features;
};
switch (request.kind) {
case ui::StadiumRequestKind::expansion_set_total: {
if (draft.tip || request.block_features != draft.desired_features)
return invalid("stale_block_expansion_draft");
auto next_quote = quote_block(draft.quote.slot, request.block_total_places, draft.desired_features);
if (!next_quote) return invalid("invalid_block_expansion_total");
draft.total_target_places = request.block_total_places;
draft.quote = *next_quote;
stadium_.feedback.clear();
return true;
}
case ui::StadiumRequestKind::expansion_toggle_feature: {
const uint8_t changed = uint8_t(request.block_features ^ draft.desired_features);
if (draft.tip || request.block_total_places != draft.total_target_places ||
(request.block_features & uint8_t(~kBlockFeatures)) != 0 ||
(changed != kBlockSeat && changed != kBlockRoof) ||
(request.block_features & uint8_t(draft.quote.current_raw_flags & kBlockFeatures)) !=
uint8_t(draft.quote.current_raw_flags & kBlockFeatures))
return invalid("invalid_block_expansion_feature");
auto next_quote = quote_block(draft.quote.slot, draft.total_target_places, request.block_features);
if (!next_quote) return invalid("invalid_block_expansion_feature");
draft.desired_features = request.block_features;
draft.quote = *next_quote;
stadium_.feedback.clear();
return true;
}
case ui::StadiumRequestKind::expansion_cancel:
if (draft.tip || !matches_draft()) return invalid("stale_block_expansion_cancel");
stadium_.block_expansion.reset();
stadium_.feedback.clear();
return true;
case ui::StadiumRequestKind::expansion_confirm: {
if (draft.tip || !matches_draft()) return invalid("stale_block_expansion_confirm");
if (draft.quote.base_price == 0) {
stadium_.block_expansion.reset();
stadium_.feedback.clear();
return true;
}
auto tip = prepare_stand_block_offer(draft.quote.base_price, draft.quote.base_weeks, rand_);
if (tip.offered_price > uint32_t(INT32_MAX))
return invalid("block_expansion_tip_price_overflow");
draft.tip = tip;
stadium_.feedback.clear();
return true;
}
case ui::StadiumRequestKind::expansion_answer_tip: {
if (!draft.tip || !matches_draft() || request.accept_tip &&
uint64_t(draft.tip->base_price) * uint32_t(100 + draft.tip->percent) >
uint64_t(INT32_MAX))
return invalid("invalid_block_expansion_tip_answer");
StandBlockOffer resolved = *draft.tip;
resolve_stand_block_offer(resolved, request.accept_tip, rand_);
const bool built = build_stadium_block_expansion(g_, active, draft.quote.slot,
block_constants, draft.quote, resolved, rand_, notice_presenter, compensation_presenter);
stadium_.block_expansion.reset();
stadium_.feedback = built || notice_presenter ? std::string{} : message_text(g_, ::bmh::layout::Advertising_FormatError_TextPointer18);
return true;
}
default:
return invalid("unsupported_block_expansion_request");
}
}
if (mode == 1) return invalid("stadium_investments_disabled");
if (request.kind == ui::StadiumRequestKind::select_investment) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.block_expansion || request.object < 0 ||
request.object >= 8 || !plain(request.object)) return invalid("invalid_investment_selection");
const auto investment = static_cast<StadiumInvestment>(request.object);
const auto current = options(investment);
if (current.empty()) return invalid("investment_unavailable");
game_.set_seed(int32_t(g_.memory.u32(::bmh::layout::CareerSession_Invalid_RuntimeField2)));
stadium_.text_variant = game_.range(3, 10); // Front: exactly once at dialog entry.
stadium_.investment = investment; stadium_.selection_status = current.front().current_status;
stadium_.option_index = -1; stadium_.option.reset(); // Source iVar5=-1 until an explicit tier click.
stadium_.feedback.clear(); return true;
}
if (request.kind == ui::StadiumRequestKind::cancel_investment) {
if (!stadium_.investment || stadium_.tip || !plain(int(*stadium_.investment)))
return invalid("stale_investment_selection");
clear_investment(); stadium_.feedback.clear(); return true; // Initial Abbruch precedes W(6,14).
}
if (request.kind == ui::StadiumRequestKind::select_investment_option) {
if (!stadium_.investment || stadium_.tip || request.object != int(*stadium_.investment) ||
request.option < 0 || request.accept_tip || !stadium_.selection_status ||
g_.manager_records[record + 0x3c + size_t(*stadium_.investment)] != *stadium_.selection_status)
return invalid("stale_investment_selection");
const auto current = options(*stadium_.investment);
if (size_t(request.option) >= current.size() || request.price != int32_t(current[size_t(request.option)].base_price))
return invalid("stale_investment_price");
stadium_.option_index = request.option; stadium_.option = current[size_t(request.option)];
return true; // Pure tier choice: neither Source generator advances.
}
if (request.kind == ui::StadiumRequestKind::confirm_investment) {
if (stadium_.tip || !selected_valid() || request.object != int(*stadium_.investment) ||
request.option != stadium_.option_index || request.accept_tip ||
request.price != int32_t(stadium_.option->base_price)) return invalid("stale_investment_selection");
stadium_.tip = prepare_stand_block_offer(stadium_.option->base_price, stadium_.option->base_weeks, rand_);
if (stadium_.tip->offered_price > uint32_t(INT32_MAX)) return invalid("invalid_investment_tip_price");
return true;
}
if (request.kind == ui::StadiumRequestKind::answer_construction_tip) {
if (!stadium_.tip || !selected_valid() || request.object != int(*stadium_.investment) ||
request.option != stadium_.option_index || request.price != int32_t(request.accept_tip ?
stadium_.tip->offered_price : stadium_.tip->base_price)) return invalid("stale_construction_tip");
auto resolved = *stadium_.tip;
resolve_stand_block_offer(resolved, request.accept_tip, rand_);
const bool built = build_stadium_investment_source(g_, active, *stadium_.investment,
stadium_.price_percent, constants, *stadium_.option, resolved, rand_, notice_presenter);
// A genuine PayConstruction/BookMoney2 refusal consumes the answer and
// retains the sponsor share clearing and Source W draws.
// Interactive callers have already shown Source's timed funds
// notice; headless legacy callers retain their text feedback.
clear_investment();
stadium_.feedback = built || notice_presenter ? std::string{} : message_text(g_, ::bmh::layout::Advertising_FormatError_TextPointer18);
return true;
}
return invalid("unsupported_stadium_request");
};
if (!apply()) { restore_stadium_checkpoint(std::move(before)); return false; }
++revision; ++stadium_.sequence; stadium_.revision = revision;
error.clear(); return true;
} catch (...) {
restore_stadium_checkpoint(std::move(before)); revision = before_revision; throw;
}
}
bool CareerSession::dispatch_toto(const ui::TotoRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (request.kind != ui::TotoRequestKind::submit || request.manager_slot != active || request.manager_slot < 0 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision"; return false;
}
if (g_.memory.u8(::bmh::layout::CareerSession_DispatchToto_RuntimeField) != 11) { error = "toto_coupon_requires_eleven_matches"; return false; }
if (!submit_pools_coupon(g_, request.manager_slot, request.stake, request.tips)) {
error = "invalid_toto_coupon"; return false;
}
++revision;
return true;
}
} // namespace bmh::app
namespace bmh::app {
PendingOfferHooks CareerSession::pending_hooks_for_dispatch(PendingOfferHooks hooks) const {
// Presenters own answers and notice delivery, never allocator provenance.
hooks.human_buyer_allocator_gate = turn_driver_.transfer_allocator_context;
return hooks;
}
void CareerSession::install_default_hooks() {
// InstallDefaultHooks pauses at the Original contracts screen when a term expires.
// Never synthesize a two-year renewal here: callers must install the real
// interactive ContractExpiryPresenter or month_change stops without a decision.
g_.contract_screen = {};
g_.loan_return_screen = {};
g_.loan_return_offer_screen = {};
}
void CareerSession::set_contract_expiry_presenter(ContractExpiryPresenter presenter) {
// Clear any previously installed presenter before replacing it. The only
// fallback is an explicit unsupported expiry, never a synthesized decision.
auto loan_return_hook = std::move(g_.loan_return_screen);
auto loan_offer_hook = std::move(g_.loan_return_offer_screen);
install_default_hooks();
g_.loan_return_screen = std::move(loan_return_hook);
g_.loan_return_offer_screen = std::move(loan_offer_hook);
contract_expiry_presenter_installed_ = bool(presenter);
if (!presenter) return;
g_.contract_screen = [this, presenter = std::move(presenter)](GameState& g, int manager, int row) {
return presenter(g, rand_, manager, row);
};
}
void CareerSession::set_loan_return_presenter(LoanReturnPresenter presenter) {
auto contract_hook = std::move(g_.contract_screen);
auto loan_offer_hook = std::move(g_.loan_return_offer_screen);
install_default_hooks();
g_.contract_screen = std::move(contract_hook);
g_.loan_return_offer_screen = std::move(loan_offer_hook);
loan_return_presenter_installed_ = bool(presenter);
if (!presenter) return;
g_.loan_return_screen = [this, presenter = std::move(presenter)](
GameState& g, int manager, const std::string& question) {
return presenter(g, rand_, manager, question);
};
}
void CareerSession::set_loan_return_offer_presenter(LoanReturnOfferPresenter presenter,
HumanBuyerSaleHooks sale_hooks) {
auto contract_hook = std::move(g_.contract_screen);
auto loan_question_hook = std::move(g_.loan_return_screen);
install_default_hooks();
g_.contract_screen = std::move(contract_hook);
g_.loan_return_screen = std::move(loan_question_hook);
loan_return_offer_presenter_installed_ = bool(presenter);
if (!presenter) return;
g_.loan_return_offer_screen = [this, presenter = std::move(presenter),
sale_hooks = std::move(sale_hooks)](
GameState& g, GameRandom& game, WatcomRandom& rand, int manager,
int source_slot, int list_entry, const HumanBuyerSaleHooks&) mutable {
auto staged_runtime = club_modal_runtime_;
auto services = staged_club_modal_services(g, game, rand, staged_runtime);
auto hooks = sale_hooks;
switch (turn_driver_.transfer_allocator_context) {
case PendingOfferAllocatorGate::zero: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::zero; break;
case PendingOfferAllocatorGate::blocked: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::blocked; break;
default: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::unsupported; break;
}
hooks.direct_mode = HumanBuyerSaleDirectMode::ordinary_ai_purchase;
const int result = presenter(g, game, rand, services, manager, source_slot, list_entry, hooks);
if (result >= 0) club_modal_runtime_ = std::move(staged_runtime);
return result;
};
}
} // namespace bmh::app