Files
Dreierpack-Manager/src/modern/content/world_save.cpp
T
MichaelandClaude Fable 5.2 8be27f8e57 The lounge and four buildings of the periphery can be extended in stages
Once it stands, the V.I.P. lounge goes up to four stages, the shopping
centre and the clubhouse to three, the car park to four, the restaurant to
two. A stage costs money and months of building and then brings a monthly
income by league. The stadium page lists them under "Ausbaustufen".

Engine: expansions.hpp, stadium read expansions, command stadium.expand;
saved in state/modern.json.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-17 18:47:23 +01:00

417 lines
24 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "modern/content/world_save.hpp"
#include <algorithm>
#include <bit>
#include <cstdio>
#include <utility>
#include <variant>
#include <set>
#include "content/digest.hpp"
#include "content/package.hpp"
#include "content/save.hpp"
#include "formats/native_state.hpp"
#include "import/detail.hpp"
#include "modern/game/save.hpp"
#include "formats/executable_layout.hpp"
namespace bmh::modern {
namespace {
using namespace obw::detail;
J generator(uint32_t seed, uint64_t calls) {
return O{{"seed", int64_t(seed)}, {"calls", std::to_string(calls)}};
}
uint64_t draw_count(const J& value) {
const auto s = str(get(value, "calls"));
if (s.empty() || s.size() > 20 || !std::all_of(s.begin(), s.end(), [](unsigned char c) { return c >= '0' && c <= '9'; }))
fail("invalid random draw counter");
return std::stoull(s);
}
uint32_t seed_of(const J& value) {
const auto n = num(get(value, "seed"));
if (n < 0 || n > int64_t(UINT32_MAX)) fail("invalid random seed");
return uint32_t(n);
}
J strings(const std::vector<std::string>& values) {
A out;
for (const auto& v : values) out.push_back(v);
return out;
}
std::vector<std::string> strings(const J& value) {
std::vector<std::string> out;
for (const J& v : arr(value)) out.push_back(str(v));
return out;
}
J manager_presentations_json(const std::vector<ModernState::ManagerPresentation>& values) {
A out;
for (const auto& p : values) out.push_back(O{{"id", p.id}, {"name", p.name}, {"portrait_style", p.portrait_style}});
return out;
}
std::vector<ModernState::ManagerPresentation> manager_presentations_json(const J& value) {
std::vector<ModernState::ManagerPresentation> out; std::set<std::string> ids;
for (const auto& row : arr(value)) {
ModernState::ManagerPresentation p{str(get(row, "id")), str(get(row, "name")), str(get(row, "portrait_style"))};
if (!p.id.starts_with("manager:") || p.id.size() > 64 || !ids.insert(p.id).second || p.name.empty() || p.name.size() > 96 || p.name.find('\0') != std::string::npos || (p.portrait_style != "photo" && p.portrait_style != "painted")) fail("invalid manager presentation");
out.push_back(std::move(p));
}
return out;
}
std::string world_identity(const World& world) { return world.id + "@" + world.data_revision; }
// Exclusive sponsor offers and queued contracts per manager (docs/new_engine/trainingslager.md).
J sponsors_json(const std::vector<ModernState::ExclusiveSponsor>& sponsors) {
A out;
for (const auto& s : sponsors)
out.push_back(O{{"offered", s.offered}, {"queued", s.queued}, {"kind", int(s.kind)}, {"units", int(s.units)},
{"months", int(s.months)}, {"sponsor", int(s.sponsor)}, {"monthly", int64_t(s.monthly)}, {"score", int(s.score)}, {"camp", s.camp}});
return out;
}
std::vector<ModernState::ExclusiveSponsor> sponsors_json(const J& value) {
std::vector<ModernState::ExclusiveSponsor> out;
for (const J& row : arr(value)) {
ModernState::ExclusiveSponsor s;
const J& offered = get(row, "offered");
const J& queued = get(row, "queued");
if (!std::holds_alternative<bool>(offered.value) || !std::holds_alternative<bool>(queued.value)) fail("invalid sponsor flags");
s.offered = std::get<bool>(offered.value), s.queued = std::get<bool>(queued.value);
s.kind = uint8_t(num(get(row, "kind"))), s.units = uint8_t(num(get(row, "units")));
s.months = uint8_t(num(get(row, "months"))), s.sponsor = uint8_t(num(get(row, "sponsor")));
s.monthly = uint32_t(num(get(row, "monthly"))), s.camp = str(get(row, "camp"));
s.score = uint16_t(num(get(row, "score")));
if (s.kind > 1 || s.units > 14 || s.sponsor > 9) fail("invalid exclusive sponsor");
out.push_back(std::move(s));
}
return out;
}
// The press journal (content/press_journal.hpp): the entries with their facts as JSON text.
J press_json(const std::vector<ModernState::PressEntry>& press) {
A out;
for (const auto& e : press)
out.push_back(O{{"id", e.id}, {"type", e.type}, {"team", e.team}, {"date", int64_t(e.date)}, {"data", e.data}});
return out;
}
std::vector<ModernState::PressEntry> press_json(const J& value) {
std::vector<ModernState::PressEntry> out;
for (const J& row : arr(value))
out.push_back({str(get(row, "id")), str(get(row, "type")), str(get(row, "team")), uint32_t(num(get(row, "date"))), str(get(row, "data"))});
return out;
}
// The Toto columns 2-6 and the last settlement per manager (docs/new_engine/toto.md).
J pools_json(const std::vector<ModernState::PoolsColumns>& pools) {
A out;
for (const auto& p : pools) {
A extra, hits;
for (const auto& column : p.extra) {
A tips;
for (uint8_t t : column) tips.push_back(int(t));
extra.push_back(std::move(tips));
}
for (uint8_t h : p.hits) hits.push_back(int(h));
out.push_back(O{{"extra", std::move(extra)}, {"hits", std::move(hits)}, {"paid", int64_t(p.paid)}, {"won", int64_t(p.won)}});
}
return out;
}
std::vector<ModernState::PoolsColumns> pools_json(const J& value) {
std::vector<ModernState::PoolsColumns> out;
for (const J& row : arr(value)) {
ModernState::PoolsColumns p;
for (const J& column : arr(get(row, "extra"))) {
const A& tips = arr(column);
if (tips.size() != 11) fail("invalid Toto column");
std::array<uint8_t, 11> c{};
for (size_t i = 0; i < 11; ++i) {
const int64_t t = num(tips[i]);
if (t < 0 || t > 2) fail("invalid Toto tip");
c[i] = uint8_t(t);
}
p.extra.push_back(c);
}
for (const J& h : arr(get(row, "hits"))) p.hits.push_back(uint8_t(num(h)));
p.paid = uint32_t(num(get(row, "paid"))), p.won = uint32_t(num(get(row, "won")));
out.push_back(std::move(p));
}
return out;
}
} // namespace
void save_world_career(const std::filesystem::path& path, const World& world, const ModernState& state,
const WatcomRandom& random, const GameRandom& game, const TurnDriver& driver, bool overwrite,
const cli::Json& session) {
if (driver.stage != TurnDriver::Stage::Empty && driver.stage != TurnDriver::Stage::MatchdayDesks &&
driver.stage != TurnDriver::Stage::SeasonEndDesk)
fail("save unavailable outside a manager desk");
obw::Documents docs;
put(docs, "manifest.json",
O{{"format", "openbmh-world"}, {"format_version", "1.1"}, {"kind", "save"},
{"save_profile", "modern-career-v1"}, {"requires", A{J("runtime:modern-v1")}},
{"world", O{{"id", world.id}, {"data_revision", world.data_revision}, {"title", world.title}}}});
put(docs, "state/career.json", encode_native_state(state));
put(docs, "state/modern.json",
O{{"schema", state.manager_presentations.empty() ? "modern-state@1.1" : "modern-state@1.2"},
{"club_ids", strings(state.world_club_id)},
{"club_names", strings(state.world_club_name)},
{"club_short_names", strings(state.world_club_short)},
{"player_ids", strings(state.world_player_id)},
{"player_first", strings(state.player_first)},
{"player_last", strings(state.player_last)},
{"player_nations", strings(state.player_nation)},
{"league_ids", strings(state.world_league_id)},
{"league_names", strings(state.world_league_name)},
{"generated_players", int64_t(state.almanac.generated_players)},
{"pools", pools_json(state.pools)},
{"exclusive_sponsors", sponsors_json(state.exclusive_sponsors)},
{"career_id", state.career_id},
{"manager_ids", strings(state.manager_ids)},
{"manager_serial", int64_t(state.manager_serial)},
{"manager_presentations", manager_presentations_json(state.manager_presentations)},
{"traffic_scale", int64_t(state.traffic_scale)},
{"press", press_json(state.press)},
{"press_serial", int64_t(state.press_serial)},
{"news_marks", [&] {
O managers;
for (const auto& [manager, marks] : state.news_marks) {
O m;
for (const auto& [message, flags] : marks) m[message] = int(flags);
managers[manager] = std::move(m);
}
return J(std::move(managers));
}()},
{"press_month", int64_t(state.press_month)},
{"press_month_cash", [&] { A a; for (int64_t v : state.press_month_cash) a.push_back(v); return J(std::move(a)); }()},
{"career_end_reason", state.career_end_reason},
{"career_end_date", int64_t(state.career_end_date)},
{"assembly", [&] {
A rows;
for (const auto& m : state.assembly)
rows.push_back(O{{"assets", m.assets}, {"place", int64_t(m.place)}, {"voted_season", int64_t(m.voted_season)}});
return J(std::move(rows));
}()},
{"dismissals", state.dismissals},
{"expansions", [&] {
A rows;
for (const auto& e : state.expansions) {
A stage, months;
for (size_t k = 0; k < 5; ++k) stage.push_back(int64_t(e.stage[k])), months.push_back(int64_t(e.months[k]));
rows.push_back(O{{"stage", std::move(stage)}, {"months", std::move(months)}});
}
return J(std::move(rows));
}()},
{"estates", [&] {
A rows;
for (const auto& held : state.estates) rows.push_back(A{J(int64_t(held[0])), J(int64_t(held[1])), J(int64_t(held[2])), J(int64_t(held[3]))});
return J(std::move(rows));
}()},
{"estate_prices", A{J(int64_t(state.estate_prices[0])), J(int64_t(state.estate_prices[1])), J(int64_t(state.estate_prices[2])), J(int64_t(state.estate_prices[3]))}},
{"shirt_numbers", [&] {
// only the players who have a number: [player, number] pairs
A rows;
for (size_t p = 0; p < state.shirt_numbers.size(); ++p)
if (state.shirt_numbers[p]) rows.push_back(A{J(int64_t(p)), J(int64_t(state.shirt_numbers[p]))});
return J(std::move(rows));
}()},
{"marketing", [&] {
A rows;
for (const auto& m : state.marketing) rows.push_back(O{{"budget", int64_t(m.budget)}, {"reach", int64_t(m.reach)}});
return J(std::move(rows));
}()},
{"stadiums", [&] {
A rows;
for (const auto& s : state.stadiums)
rows.push_back(O{{"name", s.name}, {"sponsor", int64_t(s.sponsor)}, {"monthly", int64_t(s.monthly)}, {"months", int64_t(s.months)}});
return J(std::move(rows));
}()}});
// The almanac: finished seasons unchanged, the running one encoded now.
for (const auto& [name, bytes] : state.almanac.finished) docs[name] = bytes;
if (state.almanac.current.season >= 0) docs["history/current.bin"] = encode_almanac_season(state.almanac.current);
put(docs, "state/rng.json",
O{{"schema", "classic-rng@1.0"},
{"watcom", generator(random.seed(), random.calls())},
{"game", generator(uint32_t(game.seed()), game.calls())}});
put(docs, "state/session.json", session);
put(docs, "state/driver.json", content::driver_checkpoint(driver));
put(docs, "state/information.json", encode_native_bytes(modern::save_header(state)));
O checks;
for (const auto& [name, value] : docs)
if (name.starts_with("state/") || name.starts_with("history/")) checks[name] = content::sha256(value);
put(docs, "state/integrity.json", O{{"schema", "save-integrity@1.0"}, {"entries", std::move(checks)}});
content::write_archive(docs, path, overwrite);
}
SavedWorldCareer load_world_career(const std::filesystem::path& path, const World& world) {
const auto docs = content::read_archive(path);
const auto manifest = parse(docs, "manifest.json");
if (str(get(manifest, "kind")) != "save" || str(get(manifest, "save_profile")) != "modern-career-v1")
fail("not a Modern career save");
const auto& saved_world = get(manifest, "world");
if (str(get(saved_world, "id")) != world.id || str(get(saved_world, "data_revision")) != world.data_revision)
fail("the save belongs to another world: " + str(get(saved_world, "id")) + "@" +
str(get(saved_world, "data_revision")) + ", loaded " + world_identity(world));
const auto integrity = parse(docs, "state/integrity.json");
if (str(get(integrity, "schema")) != "save-integrity@1.0") fail("unsupported save integrity");
O checks;
for (const auto& [name, value] : docs)
if ((name.starts_with("state/") || name.starts_with("history/")) && name != "state/integrity.json") checks[name] = content::sha256(value);
if (cli::dump_json(get(integrity, "entries")) != cli::dump_json(checks)) fail("damaged Modern save");
SavedWorldCareer out;
out.state = ModernState(decode_native_state(parse(docs, "state/career.json")));
const auto modern = parse(docs, "state/modern.json");
const auto modern_schema = str(get(modern, "schema"));
if (modern_schema != "modern-state@1.1" && modern_schema != "modern-state@1.2") fail("unsupported Modern state");
out.state.world_club_id = strings(get(modern, "club_ids"));
out.state.world_club_name = strings(get(modern, "club_names"));
out.state.world_club_short = strings(get(modern, "club_short_names"));
out.state.world_player_id = strings(get(modern, "player_ids"));
out.state.player_first = strings(get(modern, "player_first"));
out.state.player_last = strings(get(modern, "player_last"));
out.state.player_nation = strings(get(modern, "player_nations"));
out.state.world_league_id = strings(get(modern, "league_ids"));
out.state.world_league_name = strings(get(modern, "league_names"));
out.state.almanac.generated_players = uint32_t(num(get(modern, "generated_players")));
out.state.pools = pools_json(get(modern, "pools"));
out.state.exclusive_sponsors = sponsors_json(get(modern, "exclusive_sponsors"));
// interface identities (since 27 October 2026); older saves get them on load (ensure_ui_identities)
if (const auto* o = modern.object(); o && o->count("career_id")) {
out.state.career_id = str(get(modern, "career_id"));
out.state.manager_ids = strings(get(modern, "manager_ids"));
out.state.manager_serial = uint32_t(num(get(modern, "manager_serial")));
if (o->count("manager_presentations")) out.state.manager_presentations = manager_presentations_json(get(modern, "manager_presentations"));
if (o->count("traffic_scale")) out.state.traffic_scale = uint8_t(num(get(modern, "traffic_scale")));
if (o->count("press")) {
out.state.press = press_json(get(modern, "press"));
out.state.press_serial = uint32_t(num(get(modern, "press_serial")));
}
if (const auto it = o->find("news_marks"); it != o->end() && it->second.object())
for (const auto& [manager, marks] : *it->second.object())
if (marks.object())
for (const auto& [message, flags] : *marks.object()) out.state.news_marks[manager][message] = uint8_t(num(flags));
if (o->count("press_month")) {
out.state.press_month = uint32_t(num(get(modern, "press_month")));
for (const J& v : arr(get(modern, "press_month_cash"))) out.state.press_month_cash.push_back(int64_t(num(v)));
}
// the annual general meeting (since 17 November 2026); older saves start without a base
if (o->count("assembly")) {
for (const J& row : arr(get(modern, "assembly")))
out.state.assembly.push_back({int64_t(num(get(row, "assets"))), int32_t(num(get(row, "place"))), int32_t(num(get(row, "voted_season")))});
if (const auto it = o->find("dismissals"); it != o->end() && std::holds_alternative<bool>(it->second.value))
out.state.dismissals = std::get<bool>(it->second.value);
}
// further stages of lounge and periphery (since 17 November 2026)
if (o->count("expansions"))
for (const J& row : arr(get(modern, "expansions"))) {
const A& stage = arr(get(row, "stage"));
const A& months = arr(get(row, "months"));
if (stage.size() != 5 || months.size() != 5) fail("invalid expansions");
ModernState::Expansions e;
for (size_t k = 0; k < 5; ++k) {
if (num(stage[k]) < 0 || num(stage[k]) > 3 || num(months[k]) < 0 || num(months[k]) > 12) fail("invalid expansions");
e.stage[k] = uint8_t(num(stage[k])), e.months[k] = uint8_t(num(months[k]));
}
out.state.expansions.push_back(e);
}
// the four further properties (since 17 November 2026)
if (o->count("estates") && o->count("estate_prices")) {
for (const J& row : arr(get(modern, "estates"))) {
const A& held = arr(row);
if (held.size() != 4) fail("invalid properties");
std::array<uint16_t, 4> pieces{};
for (size_t k = 0; k < 4; ++k) {
if (num(held[k]) < 0 || num(held[k]) > 20) fail("invalid properties");
pieces[k] = uint16_t(num(held[k]));
}
out.state.estates.push_back(pieces);
}
const A& prices = arr(get(modern, "estate_prices"));
if (prices.size() != 4) fail("invalid property prices");
for (size_t k = 0; k < 4; ++k) out.state.estate_prices[k] = uint32_t(num(prices[k]));
}
// shirt numbers (since 17 November 2026)
if (o->count("shirt_numbers"))
for (const J& row : arr(get(modern, "shirt_numbers"))) {
const A& pair = arr(row);
if (pair.size() != 2) fail("invalid shirt number");
const int64_t player = num(pair[0]), number = num(pair[1]);
if (player < 0 || size_t(player) >= out.state.players.size() || number < 1 || number > 99) fail("invalid shirt number");
if (out.state.shirt_numbers.size() <= size_t(player)) out.state.shirt_numbers.resize(out.state.players.size(), 0);
out.state.shirt_numbers[size_t(player)] = uint8_t(number);
}
// international marketing (since 17 November 2026)
if (o->count("marketing"))
for (const J& row : arr(get(modern, "marketing"))) {
ModernState::Marketing m;
m.budget = int32_t(num(get(row, "budget"))), m.reach = uint16_t(num(get(row, "reach")));
if (m.budget < 0 || m.budget > 500000 || m.reach > 1000) fail("invalid marketing state");
out.state.marketing.push_back(m);
}
// stadium names and naming rights (since 17 November 2026)
if (o->count("stadiums"))
for (const J& row : arr(get(modern, "stadiums"))) {
ModernState::StadiumName s;
s.name = str(get(row, "name")), s.sponsor = uint8_t(num(get(row, "sponsor"))), s.monthly = uint32_t(num(get(row, "monthly"))), s.months = uint16_t(num(get(row, "months")));
if (s.name.size() > 40 || s.months > 60 || (s.months && s.sponsor > 9)) fail("invalid stadium name");
out.state.stadiums.push_back(std::move(s));
}
if (o->count("career_end_reason")) {
out.state.career_end_reason = str(get(modern, "career_end_reason"));
out.state.career_end_date = uint32_t(num(get(modern, "career_end_date")));
}
}
for (const auto& [name, bytes] : docs) {
if (!name.starts_with("history/season-")) continue;
decode_almanac_season(bytes); // a damaged season fails here, not in the almanac screen
out.state.almanac.finished.emplace_back(name, bytes);
}
if (const auto it = docs.find("history/current.bin"); it != docs.end())
out.state.almanac.current = decode_almanac_season(it->second);
if (out.state.world_player_id.size() != out.state.players.size() ||
out.state.world_club_id.size() != out.state.club_ids.size())
fail("Modern names do not match the saved state");
const auto generators = parse(docs, "state/rng.json");
if (str(get(generators, "schema")) != "classic-rng@1.0") fail("unsupported RNG checkpoint");
out.random.restore(seed_of(get(generators, "watcom")), draw_count(get(generators, "watcom")));
out.game.restore(std::bit_cast<int32_t>(seed_of(get(generators, "game"))), draw_count(get(generators, "game")));
out.session = parse(docs, "state/session.json");
out.driver = parse(docs, "state/driver.json");
out.header = decode_native_bytes(parse(docs, "state/information.json"), 172);
return out;
}
cli::Json world_career_metadata(const World& world,const ModernState& state) {
const bool coach=state.memory.has(::bmh::layout::CoachActive)&&state.memory.u8(::bmh::layout::CoachActive)!=0;
const int count=coach?state.memory.u8(::bmh::layout::OriginalManagerCount):int(state.manager_teams.size());
if(count<1||count>4)fail("unsupported saved manager count");
const int runtime=coach?0:state.memory.has(::bmh::layout::ActiveManager)?state.memory.u8(::bmh::layout::ActiveManager):0;
const int active=state.human_manager_slot(runtime);if(active<0||active>=count)fail("invalid saved active manager");
A managers;int active_team=-1;
for(int human=0;human<count;++human) {
const int record=state.manager_record_slot(human);const size_t at=size_t(record)*0xb0c;
if(at+0x292>state.manager_records.size())fail("saved manager record missing");
const int team=record>=0&&size_t(record)<state.manager_teams.size()?state.manager_teams[size_t(record)]:int(uint16_t(state.manager_records[at+0x290])|uint16_t(state.manager_records[at+0x291])<<8);
if(team<0||size_t(team)>=state.world_club_id.size())fail("saved manager team missing");
const auto* presentation=state.manager_presentation_for_human(human);std::string name;
if(presentation)name=presentation->name;else {for(size_t n=0;n<25&&state.manager_records[at+0xa8+n];++n)name.push_back(char(state.manager_records[at+0xa8+n]));name=almanac_utf8(name);}
const auto id=size_t(human)<state.manager_ids.size()&&!state.manager_ids[size_t(human)].empty()?state.manager_ids[size_t(human)]:"manager:slot-"+std::to_string(human);
managers.push_back(O{{"id",id},{"name",name},{"club",state.world_club_id[size_t(team)]},{"team_name",coach&&record==0?std::string("Deutschland"):size_t(team)<state.world_club_name.size()?state.world_club_name[size_t(team)]:std::string()},{"portrait",int(state.manager_records[at+0x221])},{"portrait_style",presentation?presentation->portrait_style:"photo"},{"national",coach&&record==0}});
if(human==active)active_team=team;
}
const auto date=almanac_date(state.date,state.display_start_year);char iso[16];std::snprintf(iso,sizeof iso,"%04d-%02d-%02d",date.year,date.month,date.day);
const int year=state.display_start_year+state.season,next=(year+1)%100;const auto season=std::to_string(year)+"/"+(next<10?"0":"")+std::to_string(next);std::string round="—";
if(!coach) {
std::vector<const WorldLeague*> leagues;for(const auto& l:world.leagues)if(l.index>=0)leagues.push_back(&l);std::sort(leagues.begin(),leagues.end(),[](auto* a,auto* b){return a->index<b->index;});
int first=0;for(const auto* l:leagues){const int size=int(l->members.size());if(active_team>=first&&active_team<first+size&&size>1&&size_t(l->index)<state.league_rounds.size())round=std::to_string(std::min(int(state.league_rounds[size_t(l->index)])+1,(size-1)*2))+". Spieltag";first+=size;}
}
return O{{"schema","modern-career-metadata@1"},{"career_id",state.career_id},{"world_id",world.id},{"world_revision",world.data_revision},{"date",iso},{"season",season},{"matchday",round},{"role",coach?"national":"club"},{"human_count",count},{"current_manager",managers.at(size_t(active))},{"managers",std::move(managers)}};
}
cli::Json read_world_career_metadata(const std::filesystem::path& path,const World& world) {
const auto saved=load_world_career(path,world);return world_career_metadata(world,saved.state);
}
} // namespace bmh::modern