Files
Dreierpack-Manager/src/modern/content/world_expand.cpp
T
ClaudeandClaude Opus 5.5 4639fe5a91 Add the base read queries for the new UI; fix ages and save limits
- ModernSession::read(request): status, leagues, table, fixtures and
  squad as JSON with the same club/player/league objects everywhere
  (docs/new_engine/ui-abfragen.md); the statistics answer through it.
  Further queries follow per menu once the GUI is finished.
- Ages: data set 1.3 gives ages only for the 840 added players (birth
  dates); the 2574 original players carry the placeholder 16 and now
  get their age drawn as in the original (human squad 20-25) instead
  of all being 16. Birth dates for all players go into data 1.4.
- Saves of Modern matchdays with more than six match groups (nine
  leagues on one day) were refused on loading; Classic keeps six.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 10:52:44 +02:00

458 lines
23 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "modern/content/world_expand.hpp"
// OpenBMH deviates from the original: Modern worlds have league sizes, clubs and players of their own; players whose nation has no single-byte nationality code carry a substitute foreign code.
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <stdexcept>
#include "formats/executable_layout.hpp"
#include "game/schedule.hpp"
#include "game/table.hpp"
#include "import/detail.hpp"
#include "modern/game/world_calendar.hpp"
namespace bmh::modern {
namespace {
using obw::detail::fail;
// MODERN_DEBUG=1 traces the expansion stages on stderr.
void stage(const char* name) {
static const bool on = std::getenv("MODERN_DEBUG") != nullptr;
if (on) std::fprintf(stderr, "expand: %s\n", name);
}
constexpr int kSquadSlots = 24;
// Decodes one UTF-8 code point; returns U+FFFD for malformed input.
char32_t next_code_point(const std::string& s, size_t& i) {
const auto byte = [&](size_t k) { return k < s.size() ? uint8_t(s[k]) : uint8_t(0); };
const uint8_t b = byte(i);
if (b < 0x80) return ++i, b;
if ((b >> 5) == 6 && (byte(i + 1) >> 6) == 2) {
const char32_t c = char32_t(b & 0x1f) << 6 | (byte(i + 1) & 0x3f);
i += 2;
return c;
}
if ((b >> 4) == 14 && (byte(i + 1) >> 6) == 2 && (byte(i + 2) >> 6) == 2) {
const char32_t c = char32_t(b & 0x0f) << 12 | char32_t(byte(i + 1) & 0x3f) << 6 | (byte(i + 2) & 0x3f);
i += 3;
return c;
}
++i;
while (i < s.size() && (byte(i) >> 6) == 2) ++i;
return 0xfffd;
}
// Letters of Latin Extended-A and similar that have no single-byte form: their base letter.
char base_letter(char32_t c) {
static const std::map<char32_t, char> letters = {
{0x0106, 'C'}, {0x0107, 'c'}, {0x010c, 'C'}, {0x010d, 'c'}, {0x0110, 'D'}, {0x0111, 'd'},
{0x0118, 'E'}, {0x0119, 'e'}, {0x011a, 'E'}, {0x011b, 'e'}, {0x011e, 'G'}, {0x011f, 'g'},
{0x0130, 'I'}, {0x0131, 'i'}, {0x0141, 'L'}, {0x0142, 'l'}, {0x0143, 'N'}, {0x0144, 'n'},
{0x0147, 'N'}, {0x0148, 'n'}, {0x0150, 'O'}, {0x0151, 'o'}, {0x0158, 'R'}, {0x0159, 'r'},
{0x015a, 'S'}, {0x015b, 's'}, {0x015e, 'S'}, {0x015f, 's'}, {0x0160, 'S'}, {0x0161, 's'},
{0x0162, 'T'}, {0x0163, 't'}, {0x0164, 'T'}, {0x0165, 't'}, {0x016e, 'U'}, {0x016f, 'u'},
{0x0170, 'U'}, {0x0171, 'u'}, {0x0179, 'Z'}, {0x017a, 'z'}, {0x017b, 'Z'}, {0x017c, 'z'},
{0x017d, 'Z'}, {0x017e, 'z'}, {0x0219, 's'}, {0x0218, 'S'}, {0x021b, 't'}, {0x021a, 'T'},
{0x2019, '\''}, {0x2013, '-'}, {0x2014, '-'}};
const auto it = letters.find(c);
return it == letters.end() ? '?' : it->second;
}
std::string upper(const std::string& legacy) {
std::string out = legacy;
for (char& ch : out) {
if (ch >= 'a' && ch <= 'z') ch = char(ch - 'a' + 'A');
else if (ch == '{') ch = '['; // ä -> Ä
else if (ch == '|') ch = '\\'; // ö -> Ö
else if (ch == '}') ch = ']'; // ü -> Ü
else if (uint8_t(ch) >= 0xe0 && uint8_t(ch) != 0xf7) ch = char(uint8_t(ch) - 0x20); // Latin-1
}
return out;
}
// Appends a zero-terminated name to a pool and returns its offset (pools use u16 offsets).
uint16_t append_name(std::vector<uint8_t>& pool, const std::string& name) {
if (pool.size() + name.size() + 1 > 0xffff) fail("name pool full (64 KB)");
const auto at = uint16_t(pool.size());
pool.insert(pool.end(), name.begin(), name.end());
pool.push_back(0);
return at;
}
// Copies per-team records of `width` bytes into the new id order; ids without an old record
// copy the record of their template id (the new id of an original club of the same league).
std::vector<uint8_t> remap_records(const std::vector<uint8_t>& old, size_t width, int old_count, int new_count,
const std::vector<int>& to_new, const std::vector<int>& template_of) {
std::vector<uint8_t> out(size_t(new_count) * width, 0);
std::vector<bool> filled(size_t(new_count), false);
for (int t = 0; t < old_count && size_t(t + 1) * width <= old.size(); ++t) {
const int n = to_new[size_t(t)];
if (n < 0 || n >= new_count) continue;
std::copy_n(old.begin() + long(size_t(t) * width), width, out.begin() + long(size_t(n) * width));
filled[size_t(n)] = true;
}
for (int n = 0; n < new_count; ++n)
if (!filled[size_t(n)] && template_of[size_t(n)] >= 0 && filled[size_t(template_of[size_t(n)])])
std::copy_n(out.begin() + long(size_t(template_of[size_t(n)]) * width), width,
out.begin() + long(size_t(n) * width));
return out;
}
std::vector<uint16_t> remap_words(const std::vector<uint16_t>& old, int new_count, const std::vector<int>& to_new,
const std::vector<int>& template_of) {
std::vector<uint8_t> bytes;
for (const uint16_t w : old) bytes.push_back(uint8_t(w)), bytes.push_back(uint8_t(w >> 8));
const auto out = remap_records(bytes, 2, int(old.size()), new_count, to_new, template_of);
std::vector<uint16_t> words;
for (size_t i = 0; i + 1 < out.size(); i += 2) words.push_back(uint16_t(out[i] | out[i + 1] << 8));
return words;
}
void remap_memory(StaticMemory& mem, uint32_t address, size_t width, int old_count, int new_count,
const std::vector<int>& to_new, const std::vector<int>& template_of, bool grow) {
if (!mem.has(address)) return;
std::vector<uint8_t> old;
for (int i = 0; i < old_count * int(width) && mem.has(address + uint32_t(i)); ++i) old.push_back(mem.u8(address + uint32_t(i)));
const auto out = remap_records(old, width, old_count, new_count, to_new, template_of);
if (grow) mem.grow_block(address, out.size());
for (size_t i = 0; i < out.size() && mem.has(address + uint32_t(i)); ++i) mem.set8(address + uint32_t(i), out[i]);
}
WorldLayout modern_layout(int league_clubs, int german_clubs) {
WorldLayout w;
w.league_teams = league_clubs;
w.german_teams = german_clubs;
w.squad_start.clear();
w.squad_size.clear();
for (int t = 0; t < league_clubs; ++t) {
w.squad_start.push_back(uint32_t(t) * kSquadSlots);
w.squad_size.push_back(kSquadSlots);
}
w.transfer_list = uint32_t(league_clubs) * kSquadSlots;
w.free_agents = w.transfer_list + 44;
w.foreign_offers = w.free_agents + 80;
w.pool_end = w.foreign_offers + 20;
w.total_slots = w.pool_end + w.no_team_slots + 54;
return w;
}
} // namespace
std::string legacy_encoding(const std::string& utf8) {
std::string out;
for (size_t i = 0; i < utf8.size();) {
const char32_t c = next_code_point(utf8, i);
switch (c) {
case U'Ä': out += '['; break;
case U'Ö': out += '\\'; break;
case U'Ü': out += ']'; break;
case U'ä': out += '{'; break;
case U'ö': out += '|'; break;
case U'ü': out += '}'; break;
case U'ß': out += '~'; break;
default:
if (c < 0x80 && c != '[' && c != '\\' && c != ']' && c != '{' && c != '|' && c != '}' && c != '~')
out += char(c);
else if (c >= 0xc0 && c <= 0xff)
out += char(uint8_t(c)); // Latin-1 letters, as the Classic pools store them
else
out += base_letter(c);
}
}
return out;
}
void install_world_dimensions(const World& world) {
int league_clubs = 0, german_clubs = 0;
uint8_t sizes[kLeagueCount] = {};
for (const WorldLeague& l : world.leagues) {
sizes[l.index] = uint8_t(l.members.size());
league_clubs += int(l.members.size());
if (l.index < 5) german_clubs += int(l.members.size());
}
WorldLayout layout = modern_layout(league_clubs, german_clubs);
// The league sizes are checked against the layout and need the per-league fixture tables.
kLeagueTablesPerLeague = true;
set_world_layout(layout);
set_league_sizes(sizes);
kNewcomerFirst = world_layout().first_amateur();
}
ExpandReport expand_to_world(ModernState& g, const World& world) {
const WorldLayout old = world_layout();
if (old.league_teams != 138 || old.total_teams() != 419) fail("the world expands a Classic start state only");
ExpandReport report;
// --- team ids: league clubs in the order of the world's leagues ----------------------
int league_clubs = 0;
uint8_t sizes[kLeagueCount] = {};
for (const WorldLeague& l : world.leagues) {
sizes[l.index] = uint8_t(l.members.size());
league_clubs += int(l.members.size());
}
const int added = league_clubs - old.league_teams;
if (added < 0) fail("a Modern world cannot have fewer league clubs than Classic");
const int new_total = old.total_teams() + added;
std::vector<int> to_new(size_t(old.total_teams()), -1); // Classic id -> new id
std::vector<int> template_of(size_t(new_total), -1); // new id -> template new id
std::vector<const WorldClub*> club_at(size_t(new_total), nullptr);
for (int t = old.league_teams; t < old.total_teams(); ++t) to_new[size_t(t)] = t + added;
int id = 0;
for (const WorldLeague& l : world.leagues) {
int template_id = -1;
const int first = id;
for (const std::string& member : l.members) {
const WorldClub* c = world.club(member);
if (!c) fail("unknown league member " + member);
if (c->legacy_index >= old.league_teams) fail("club " + member + " is not a Classic league club");
if (c->legacy_index >= 0) {
if (to_new[size_t(c->legacy_index)] >= 0) fail("Classic club in two leagues: " + member);
to_new[size_t(c->legacy_index)] = id;
if (template_id < 0) template_id = id;
}
club_at[size_t(id)] = c;
++id;
}
for (int n = first; n < id; ++n)
if (!club_at[size_t(n)] || club_at[size_t(n)]->legacy_index < 0) template_of[size_t(n)] = template_id;
if (template_id < 0 && id > first) fail("league without an original club: " + l.id);
}
for (int t = 0; t < old.league_teams; ++t)
if (to_new[size_t(t)] < 0) fail("Classic league club " + std::to_string(t) + " is missing from the world's leagues");
for (const WorldClub& c : world.clubs)
if (c.legacy_index >= old.league_teams && c.legacy_index < old.total_teams())
club_at[size_t(to_new[size_t(c.legacy_index)])] = &c;
report.league_clubs = league_clubs;
report.added_clubs = added;
stage("team ids");
// --- per-team tables -----------------------------------------------------------------
const int records = old.first_foreign_cup() + added; // clubs with records (league + amateurs)
g.team_morale = remap_records(g.team_morale, 1, old.total_teams(), new_total, to_new, template_of);
g.team_flags = remap_words(g.team_flags, new_total, to_new, template_of);
g.club_heap_78 = remap_records(g.club_heap_78, 2, old.total_teams(), new_total, to_new, template_of);
g.club_heap_bc = remap_records(g.club_heap_bc, 2, old.first_foreign_cup(), records, to_new, template_of);
g.club_heap_b8 = remap_records(g.club_heap_b8, 1, old.first_foreign_cup(), records, to_new, template_of);
if (!g.club_table.empty())
g.club_table = remap_records(g.club_table, 0x4a, old.first_foreign_cup(), records, to_new, template_of);
{
std::vector<int> no_template(template_of.size(), -1);
g.position_history = remap_records(g.position_history, 0x1a, old.league_teams, league_clubs, to_new, no_template);
std::vector<uint8_t> results;
const size_t managers = g.manager_results.size() / 0x690;
for (size_t m = 0; m < managers; ++m) {
const std::vector<uint8_t> one(g.manager_results.begin() + long(m * 0x690),
g.manager_results.begin() + long((m + 1) * 0x690));
const auto moved = remap_records(one, 10, old.first_foreign_cup(), records, to_new, no_template);
results.insert(results.end(), moved.begin(), moved.end());
}
g.manager_results = std::move(results);
}
// Club names: Classic clubs keep their pool entries; added clubs get one.
std::vector<uint16_t> club_ids(size_t(new_total), 0);
for (int t = 0; t < old.total_teams() && size_t(t) < g.club_ids.size(); ++t)
club_ids[size_t(to_new[size_t(t)])] = g.club_ids[size_t(t)];
for (int n = 0; n < new_total; ++n)
if (template_of[size_t(n)] >= 0 && club_at[size_t(n)])
club_ids[size_t(n)] = append_name(g.club_names, upper(legacy_encoding(club_at[size_t(n)]->name)));
g.club_ids = std::move(club_ids);
remap_memory(g.memory, ::bmh::layout::ClubShortNameOffsets, 1, old.first_foreign_cup(), records, to_new, template_of, true);
for (int n = 0; n < records; ++n) // added clubs: the short name is the start of the name
if (template_of[size_t(n)] >= 0 && club_at[size_t(n)])
g.memory.set8(::bmh::layout::ClubShortNameOffsets + uint32_t(n),
uint8_t(std::min<size_t>(legacy_encoding(club_at[size_t(n)]->name).size(), 16) - 1));
{ // Card counters per league club (fair-play table): 2 bytes each, room behind the block.
std::vector<int> no_template(template_of.size(), -1);
remap_memory(g.memory, ::bmh::layout::DeskRecords_Teams_RuntimeField, 2, old.league_teams, league_clubs, to_new,
no_template, true);
}
// Kit selectors are only moved on promotion; the block has no room for more clubs.
remap_memory(g.memory, ::bmh::layout::ClubKitSelectors, 1, old.total_teams(), old.total_teams(), to_new, template_of, false);
stage("per-team tables");
// --- players -------------------------------------------------------------------------
std::map<std::string, int> player_index;
std::vector<const WorldPlayer*> player_at;
for (const WorldPlayer& p : world.players)
if (p.legacy) {
if (p.legacy_index < 0 || size_t(p.legacy_index) >= g.players.size()) fail("invalid original player " + p.id);
player_index[p.id] = p.legacy_index;
}
int next_player = int(g.players.size());
for (const WorldPlayer& p : world.players)
if (!p.legacy) player_index[p.id] = next_player++;
if (next_player > 0xFFE) fail("too many players for 12-bit player ids");
player_at.assign(size_t(next_player), nullptr);
for (const WorldPlayer& p : world.players) player_at[size_t(player_index[p.id])] = &p;
const size_t original_players = g.players.size();
g.players.resize(size_t(next_player));
g.player_name_offsets.resize(size_t(next_player), 0);
g.player_cards.resize(size_t(next_player), 0);
if (g.player_bonus.size() < size_t(next_player) + 0x36) g.player_bonus.resize(size_t(next_player) + 0x36, 0);
for (size_t i = original_players; i < size_t(next_player); ++i) {
const WorldPlayer& p = *player_at[i];
const auto clamp7 = [](int v) { return uint32_t(std::clamp(v, 0, 127)); };
const auto skill = [](int v) { return uint32_t(std::clamp(v, 0, 3)); };
int nationality = 31;
if (const auto it = world.nationality.find(p.nation); it != world.nationality.end() && it->second < 32)
nationality = it->second;
else
++report.fallback_nationalities;
const int age = std::clamp(p.age < 0 ? 24 : p.age, 16, 47);
if (p.age >= 0) { // a birth date: the career start keeps this age (balance.md)
if (g.world_age_known.size() < size_t(next_player)) g.world_age_known.resize(size_t(next_player), false);
g.world_age_known[i] = true;
}
Player& pl = g.players[i];
pl.w35c = clamp7(p.form) | clamp7(p.technique) << 7 | clamp7(p.condition) << 14;
pl.w368 = skill(p.teamplay) | skill(p.speed) << 2 | skill(p.shooting) << 4 | skill(p.passing) << 6 |
skill(p.tackling) << 8 | skill(p.free_kick) << 10 | skill(p.corner) << 12 | uint32_t(nationality) << 27;
pl.w364 = uint32_t(p.position & 3) | uint32_t(age - 16) << 21;
g.player_bonus[i] = uint8_t(std::clamp(p.bonus, 0, 50));
g.player_name_offsets[i] = append_name(g.player_names, upper(legacy_encoding(p.last)));
++report.added_players;
}
stage("players");
// --- layout, squads, league sizes ----------------------------------------------------
WorldLayout layout = modern_layout(league_clubs, old.german_teams);
std::vector<uint16_t> slots(layout.total_slots, kEmptySlot);
// The pools behind the squads keep their Classic contents and order: transfer list, free
// agents, foreign offers, the no-club squad and the 54 reserve players the career start
// generates (the world lists those as players without a club).
std::vector<bool> pooled(size_t(next_player), false);
for (uint32_t s = old.transfer_list; s < old.total_slots && s < g.squad_slots.size(); ++s) {
const uint16_t v = g.squad_slots[s];
slots[layout.transfer_list + (s - old.transfer_list)] = v;
if ((v & 0x0FFF) != 0x0FFF && size_t(v & 0x0FFF) < pooled.size()) pooled[size_t(v & 0x0FFF)] = true;
}
std::map<std::string, std::vector<std::pair<int, int>>> squads; // club id -> (order, player)
std::vector<int> free_agents; // players the world adds without a club
for (const WorldPlayer& p : world.players) {
const int pid = player_index[p.id];
if (p.team.empty()) {
if (!pooled[size_t(pid)]) free_agents.push_back(pid);
continue;
}
squads[p.team].push_back({p.squad_order < 0 ? 999 : p.squad_order, pid});
}
for (int t = 0; t < league_clubs; ++t) {
auto& squad = squads[club_at[size_t(t)]->id];
std::stable_sort(squad.begin(), squad.end());
if (squad.size() > size_t(kSquadSlots)) fail("squad larger than 24 players: " + club_at[size_t(t)]->id);
for (size_t k = 0; k < squad.size(); ++k) slots[layout.squad_start[size_t(t)] + k] = uint16_t(squad[k].second);
}
for (const auto& [club, squad] : squads) {
const WorldClub* c = world.club(club);
if (!c || std::find(club_at.begin(), club_at.begin() + league_clubs, c) == club_at.begin() + league_clubs)
for (const auto& entry : squad) free_agents.push_back(entry.second); // players of squadless clubs
}
size_t free_slot = layout.free_agents;
for (const int pid : free_agents) {
while (free_slot < layout.foreign_offers && slots[free_slot] != kEmptySlot) ++free_slot;
if (free_slot == layout.foreign_offers) fail("no free-agent slot left for the world's players without a club");
slots[free_slot++] = uint16_t(pid);
}
report.free_agents = int(free_agents.size());
{ // Every player holds at most one slot (squad, pool or reserve).
std::vector<int> seen(size_t(next_player), -1);
for (size_t s = 0; s < slots.size(); ++s) {
const int pid = slots[s] & 0x0FFF;
if (pid == 0x0FFF) continue;
if (size_t(pid) >= seen.size()) fail("slot " + std::to_string(s) + " names an unknown player");
if (seen[size_t(pid)] >= 0)
fail("player " + std::to_string(pid) + " in slots " + std::to_string(seen[size_t(pid)]) + " and " +
std::to_string(s));
seen[size_t(pid)] = int(s);
}
}
g.squad_slots = std::move(slots);
stage("squads");
install_world_dimensions(world);
stage("layout and league sizes");
// --- league dates of the international group (calendar bit 4) -------------------------
const WorldLeague* dated = nullptr;
for (const WorldLeague& l : world.leagues)
if (l.index >= 5 && (!dated || l.dates.size() > dated->dates.size())) dated = &l;
if (dated && !dated->dates.empty()) {
std::vector<int> days;
for (const std::string& d : dated->dates) {
const int day = season_day_of(d, world.start_year);
if (day < 0) fail("invalid league date " + d);
days.push_back(day);
}
if (int(days.size()) < league_matchdays(dated->index)) fail("fewer league dates than matchdays: " + dated->id);
for (std::string& moved : install_league_dates(g, 4, days).moved) report.notes.push_back(std::move(moved));
}
stage("league dates");
// --- Modern names and identities -----------------------------------------------------
g.world_club_id.assign(size_t(new_total), {});
g.world_club_name.assign(size_t(new_total), {});
g.world_club_short.assign(size_t(new_total), {});
g.world_league_id.clear(), g.world_league_name.clear();
for (const WorldLeague& l : world.leagues) {
if (size_t(l.index) >= g.world_league_id.size()) {
g.world_league_id.resize(size_t(l.index) + 1);
g.world_league_name.resize(size_t(l.index) + 1);
}
g.world_league_id[size_t(l.index)] = l.id;
g.world_league_name[size_t(l.index)] = l.name;
}
for (int n = 0; n < new_total; ++n)
if (const WorldClub* c = club_at[size_t(n)]) {
g.world_club_id[size_t(n)] = c->id;
g.world_club_name[size_t(n)] = c->name;
g.world_club_short[size_t(n)] = c->short_name.empty() ? c->name : c->short_name;
}
g.world_player_id.assign(size_t(next_player), {});
g.player_first.assign(size_t(next_player), {});
g.player_last.assign(size_t(next_player), {});
g.player_nation.assign(size_t(next_player), {});
for (size_t i = 0; i < player_at.size(); ++i)
if (const WorldPlayer* p = player_at[i]) {
g.world_player_id[i] = p->id;
g.player_first[i] = p->first;
g.player_last[i] = p->last;
g.player_nation[i] = p->nation;
}
// Referees the data set added (data format F9): their names go to the referee pool and
// their name offsets behind the Classic ones in MasterDatabaseMetadata (u16 per referee).
// install_world_referees adds the matching property bytes to the database.
for (const WorldReferee& r : world.referees) {
if (r.legacy_index >= 0) continue;
const uint16_t at = append_name(g.referee_names, legacy_encoding(r.name));
g.master_database_metadata.push_back(uint8_t(at));
g.master_database_metadata.push_back(uint8_t(at >> 8));
++report.added_referees;
}
if (g.master_database_metadata.size() / 2 > 0xff) fail("more than 255 referees");
return report;
}
void install_world_referees(std::vector<uint8_t>& properties, const World& world) {
for (const WorldReferee& r : world.referees)
if (r.legacy_index < 0) properties.push_back(r.property_byte());
}
} // namespace bmh::modern
namespace bmh::modern {
void install_training_camps(ModernState& g, const World& world) {
const CampCatalogue& catalogue = world.camps ? *world.camps : default_camp_catalogue();
if (catalogue.camps.empty()) obw::detail::fail("the training camp catalogue is empty");
g.camp_maps = catalogue.maps;
g.training_camps = catalogue.camps;
}
} // namespace bmh::modern