Files
Dreierpack-Manager/src/modern/content/ui_contract.cpp
T
ClaudeandClaude Opus 5.5 43317985e4 Modern UI contract: toto and exclusive sponsor reads and commands
toto and sponsor reads in the envelope (amounts as Money), toto.submit with
up to six columns and sponsor.answer for a camp's exclusive sponsor offer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 09:29:25 +01:00

400 lines
22 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "modern/content/ui_contract.hpp"
#include <algorithm>
#include <cstdio>
#include <random>
#include <string>
#include <variant>
#include "formats/executable_layout.hpp"
#include "game/state.hpp"
#include "game/table.hpp"
#include "modern/content/projections.hpp"
#include "modern/content/world_package.hpp"
#include "modern/game/almanac.hpp"
#include "modern/game/desk_actions.hpp"
namespace bmh::modern {
namespace {
using J = cli::Json;
using A = J::Array;
using O = J::Object;
constexpr const char* kContractVersion = "bmh-modern-ui@draft1";
constexpr size_t kRecord = 0xb0c;
const std::string& entry(const std::vector<std::string>& v, size_t i) {
static const std::string none;
return i < v.size() ? v[i] : none;
}
const J* field(const J& request, const char* key) {
const auto* o = request.object();
if (!o) return nullptr;
const auto it = o->find(key);
return it == o->end() ? nullptr : &it->second;
}
std::string text_field(const J& request, const char* key) {
const J* v = field(request, key);
return v && v->string() ? *v->string() : std::string{};
}
J text(const std::string& s) { return O{{"key", nullptr}, {"text", s}, {"locale", "de"}, {"args", O{}}}; }
J available() { return O{{"status", "available"}, {"reasonCode", nullptr}, {"missingFields", A{}}}; }
J unavailable(const char* reason) { return O{{"status", "unavailable"}, {"reasonCode", reason}, {"missingFields", A{}}}; }
std::string iso(const AlmanacDate& d) {
char out[16];
std::snprintf(out, sizeof out, "%04d-%02d-%02d", d.year, d.month, d.day);
return out;
}
// Managers with a human at their desk: during the national coach's takeover the coach sits in
// slot 0 and the others wait (OriginalManagerCount keeps their number).
int human_managers(const ModernState& g) {
if (g.memory.has(::bmh::layout::CoachActive) && g.memory.u8(::bmh::layout::CoachActive) != 0 &&
g.memory.has(::bmh::layout::OriginalManagerCount))
return g.memory.u8(::bmh::layout::OriginalManagerCount);
return int(g.manager_teams.size());
}
std::string manager_name(const ModernState& g, int manager) {
std::string name;
const size_t at = size_t(manager) * kRecord + 0xa8;
for (size_t i = 0; i < 30 && at + i < g.manager_records.size() && g.manager_records[at + i]; ++i)
name.push_back(char(g.manager_records[at + i]));
return almanac_utf8(name);
}
int64_t money_of(const ModernState& g, int manager) {
const size_t at = size_t(manager) * kRecord + 0x314;
if (at + 3 >= g.manager_records.size()) return 0;
return int32_t(uint32_t(g.manager_records[at]) | uint32_t(g.manager_records[at + 1]) << 8 |
uint32_t(g.manager_records[at + 2]) << 16 | uint32_t(g.manager_records[at + 3]) << 24);
}
int team_of(const ModernState& g, int manager) {
return manager >= 0 && size_t(manager) < g.manager_teams.size() ? g.manager_teams[size_t(manager)] : -1;
}
std::string team_id(const ModernState& g, int team) {
std::string id = entry(g.world_club_id, size_t(team));
return id.empty() ? "team:" + std::to_string(team) : id;
}
// TeamRef of the contract: id, kind, name, shortName, nationId, crestAssetId, nameAsOf.
J team_ref(const ModernState& g, int team, const std::string& as_of) {
if (team < 0) return nullptr;
std::string name = entry(g.world_club_name, size_t(team)), short_name = entry(g.world_club_short, size_t(team));
if (name.empty()) name = almanac_utf8(g.club_name(team));
if (short_name.empty()) short_name = name;
const bool national = team >= no_team();
return O{{"id", team_id(g, team)}, {"kind", national ? "national" : "club"}, {"name", name},
{"shortName", short_name}, {"nationId", nullptr}, {"crestAssetId", nullptr}, {"nameAsOf", as_of}};
}
std::string manager_id(const ModernState& g, int manager) {
const std::string& id = entry(g.manager_ids, size_t(manager));
return id.empty() ? "manager:slot-" + std::to_string(manager) : id;
}
J manager_json(const ModernState& g, int manager, bool at_desk) {
const int team = team_of(g, manager);
const size_t at = size_t(manager) * kRecord;
const int portrait = at + 0x221 < g.manager_records.size() ? g.manager_records[at + 0x221] : 0;
return O{{"id", manager_id(g, manager)}, {"slot", manager}, {"name", manager_name(g, manager)},
{"control", "human"}, {"status", at_desk ? "active" : "waiting"},
{"teamId", team >= 0 ? J(team_id(g, team)) : J(nullptr)},
{"portraitGuiKey", "gui:manager/photo/" + std::to_string(portrait)}, {"portraitStyle", "photo"},
{"strengthChoice", nullptr}, {"employments", A{}}};
}
J meta(const ModernState& g, const UiContext& c) {
const AlmanacDate today = almanac_date(g.date, g.display_start_year);
const int start = g.display_start_year + g.season, next = (start + 1) % 100;
const std::string label = std::to_string(start) + "/" + (next < 10 ? "0" : "") + std::to_string(next);
const int team = team_of(g, c.manager);
const bool national = team == no_team();
const std::string revision = std::to_string(c.state_revision);
const World* world = current_world();
return O{{"contractVersion", kContractVersion}, {"draft", true}, {"sourceRevision", nullptr},
{"careerId", g.career_id.empty() ? J(nullptr) : J(g.career_id)},
{"worldId", world ? J(world->id) : J(nullptr)},
{"worldRevision", world ? J(world->data_revision) : J(nullptr)},
{"stateRevision", revision}, {"projectionRevision", revision}, {"locale", "de"},
{"date", iso(today)},
{"season", O{{"id", "season:" + std::to_string(start) + "-" + (next < 10 ? "0" : "") + std::to_string(next)},
{"startDate", iso(AlmanacDate{start, 7, 1})}, {"endDate", iso(AlmanacDate{start + 1, 6, 30})},
{"label", label}, {"completed", false}}},
{"scope", O{{"managerId", manager_id(g, c.manager)},
{"teamId", team >= 0 ? J(team_id(g, team)) : J(nullptr)},
{"role", national ? "national" : "club"},
{"scopeId", "scope:desk-" + revision + "-" + std::to_string(c.manager)},
{"allowedCommands", A{}}}},
{"availability", available()},
{"currency", O{{"code", "EUR"}, {"minorUnits", 2}}}};
}
J snapshot(const std::string& request_id, J meta_json, J data) {
return O{{"messageType", "snapshot"}, {"requestId", request_id}, {"meta", std::move(meta_json)}, {"data", std::move(data)}};
}
J failure(const std::string& request_id, const char* code, const std::string& message, uint64_t revision) {
return O{{"messageType", "error"}, {"requestId", request_id}, {"code", code}, {"message", text(message)},
{"currentRevision", std::to_string(revision)}, {"retryable", false}, {"stateChanged", false}};
}
J session_data(const ModernState& g, const UiContext& c) {
A managers;
for (int m = 0; m < human_managers(g); ++m) managers.push_back(manager_json(g, m, m == c.manager));
return O{{"kind", "session"}, {"sessionState", "desktop"}, {"activeManagerId", manager_id(g, c.manager)},
{"managers", std::move(managers)}};
}
J desktop_data(const ModernState& g, const UiContext& c, const std::string& today) {
const int team = team_of(g, c.manager);
const bool national = team == no_team();
O data{{"kind", "desktop"}, {"manager", manager_json(g, c.manager, true)}, {"team", team_ref(g, team, today)}};
// the account: the bank's savings and credit follow with the bank read
data["accounts"] = O{{"cash", ui_money(money_of(g, c.manager))}, {"savings", nullptr}, {"debt", nullptr},
{"netAssets", nullptr}};
J next = nullptr;
if (c.next_opponent && *c.next_opponent >= 0) {
J own = team_ref(g, team, today), other = team_ref(g, *c.next_opponent, today);
next = O{{"competition", text(c.next_competition)}, {"home", c.next_away ? other : own},
{"away", c.next_away ? own : other}, {"status", "scheduled"}, {"result", nullptr}};
}
data["nextFixture"] = std::move(next);
// ui/desk_state.cpp: at the national coach's desk there is no toto, bank, camp, training or stadium
O menus;
for (const char* menu : {"squad", "lineup", "tactics", "training", "camps", "transfer", "contracts", "bank", "balance",
"advertising", "environment", "stadium", "toto", "calendar", "statistics", "almanac"}) {
const std::string m = menu;
const bool closed = national && (m == "toto" || m == "bank" || m == "camps" || m == "training" || m == "stadium");
menus[m] = closed ? unavailable("national_desk") : available();
}
data["menuAvailability"] = std::move(menus);
return data;
}
J metric(int value) {
return O{{"value", value}, {"unit", "rating"}, {"scale", nullptr}, {"availability", available()}};
}
// The team a request names (teamId: a world id or "team:<n>"), or the manager's own team.
int requested_team(const ModernState& g, const UiContext& c, const J& request) {
const std::string wanted = text_field(request, "teamId");
if (wanted.empty()) return team_of(g, c.manager);
for (int t = 0; t < int(g.world_club_id.size()); ++t)
if (g.world_club_id[size_t(t)] == wanted) return t;
if (wanted.starts_with("team:")) {
try {
const int t = std::stoi(wanted.substr(5));
if (t >= 0 && t < world_layout().total_teams()) return t;
} catch (const std::exception&) {
}
}
return -1;
}
// A squad: every player with identity, position, values, absence and (for the manager's own
// club, from his tactics board) monthly salary and remaining contract months.
J squad_data(const ModernState& g, const UiContext& c, int team, const std::string& today) {
static constexpr const char* kPositions[4] = {"gk", "def", "mid", "fwd"};
static constexpr const char* kSkills[7] = {"teamplay", "speed", "shooting", "passing", "tackling", "free_kick", "corner"};
const bool own = team == team_of(g, c.manager) && team < league_clubs();
const size_t board = size_t(c.manager) * 0x840;
const SquadRange r = squad_range(team);
A players;
for (size_t s = r.first; s < r.first + r.count && s < g.squad_slots.size(); ++s) {
const uint16_t e = g.squad_slots[s];
const int id = e & 0x0fff;
if (id == 0x0fff) continue;
const Player& p = g.players.at(size_t(id));
std::string pid = entry(g.world_player_id, size_t(id));
if (pid.empty()) pid = "player:legacy-" + std::to_string(id);
const std::string& first = entry(g.player_first, size_t(id));
std::string last = entry(g.player_last, size_t(id));
if (last.empty()) last = almanac_utf8(g.player_name(id));
const std::string& nation = entry(g.player_nation, size_t(id));
const uint32_t absence = p.w364 >> 16 & 0x1f; // weeks out; bit 4: banned instead of injured
const int injured = (absence & 0x10) ? 0 : int(absence), banned = (absence & 0x10) ? int(absence & 0xf) : 0;
O skills;
for (int k = 0; k < 7; ++k) skills[kSkills[k]] = int(p.w368 >> (2 * k) & 3);
O row{{"player", O{{"id", pid}, {"name", first.empty() ? last : first + " " + last}, {"photoAssetId", nullptr},
{"nationIds", nation.empty() ? A{} : A{J(nation)}}, {"positions", A{J(kPositions[p.position()])}},
{"shirtNumber", nullptr}}},
{"clubId", team < league_clubs() ? J(team_id(g, team)) : J(nullptr)},
{"squadTeamId", team_id(g, team)},
{"role", (e & 0x8000) ? "starter" : (e & 0x4000) ? "bench" : "reserve"},
{"availability", injured ? "injured" : banned ? "suspended" : "fit"},
{"injuryRemaining", O{{"value", injured}, {"unit", "weeks"}}},
{"suspensionRemaining", O{{"value", banned}, {"unit", "weeks"}}},
{"age", p.age()},
{"metrics", O{{"strength", metric(p.strength())}, {"condition", metric(p.condition())},
{"technique", metric(p.technique())}, {"form", metric(p.form())}}},
{"skills", std::move(skills)}};
const size_t at = board + (s - r.first) * 0x58;
if (own && at + 0x58 <= g.tactics.size()) {
const int64_t salary = int64_t(uint32_t(g.tactics[at + 0x50]) | uint32_t(g.tactics[at + 0x51]) << 8 |
uint32_t(g.tactics[at + 0x52]) << 16 | uint32_t(g.tactics[at + 0x53]) << 24);
row["salaryMonthly"] = ui_money(salary);
row["contractRemaining"] = O{{"value", int(g.tactics[at + 0x0c])}, {"unit", "months"}};
} else {
row["salaryMonthly"] = nullptr;
row["contractRemaining"] = nullptr;
}
row["contractUntil"] = nullptr;
players.push_back(std::move(row));
}
return O{{"kind", "squad"}, {"team", team_ref(g, team, today)}, {"players", std::move(players)}};
}
// The training camps (docs/new_engine/trainingslager.md): catalogue, the price for the own
// squad (base price + 5000 per player, no random draw: a binding quote), focus and bookings.
J camps_data(const ModernState& g, const UiContext& c, const std::string& revision) {
const size_t rec = size_t(c.manager) * kRecord;
const TrainingCampBookingBlock block = training_camp_booking_block(g, c.manager);
const char* reason = block == TrainingCampBookingBlock::booked_this_week ? "booked_this_week"
: block == TrainingCampBookingBlock::visit_limit ? "visit_limit"
: block == TrainingCampBookingBlock::invalid_request ? "no_club"
: nullptr;
const int64_t cash = money_of(g, c.manager);
A maps;
for (const CampMap& m : g.camp_maps)
maps.push_back(O{{"id", m.id}, {"name", text(m.name)}, {"guiAssetKey", "gui:map/" + (m.id.starts_with("map:") ? m.id.substr(4) : m.id)},
{"width", m.width ? J(*m.width) : J(nullptr)}, {"height", m.height ? J(*m.height) : J(nullptr)}});
A camps;
for (size_t i = 0; i < g.training_camps.size(); ++i) {
const TrainingCamp& t = g.training_camps[i];
J quote = nullptr;
if (block != TrainingCampBookingBlock::invalid_request) {
const int64_t price = training_camp_price(g, c.manager, int(i));
const int64_t base = t.base_price;
const char* blocked = reason ? reason : nullptr;
// book_money allows the credit line too; the read names only the plain case
quote = O{{"id", "quote:camp-" + revision + "-" + std::to_string(i)}, {"ownerManagerId", manager_id(g, c.manager)},
{"teamId", team_id(g, team_of(g, c.manager))}, {"expectedRevision", revision},
{"scopeId", "scope:desk-" + revision + "-" + std::to_string(c.manager)}, {"expiresOn", nullptr},
{"total", ui_money(price)}, {"totalBasis", "immediate"}, {"chargesNow", ui_money(price)},
{"breakdown", A{O{{"code", "base"}, {"amount", ui_money(base)}},
O{{"code", "squad"}, {"amount", ui_money(price - base)}}}},
{"allowed", blocked == nullptr}, {"reasonCode", blocked ? J(blocked) : J(nullptr)},
{"exceedsCash", price > cash}};
}
camps.push_back(O{{"id", t.id}, {"mapId", t.map}, {"name", text(t.name)}, {"place", t.place},
{"nationId", t.country.empty() ? J(nullptr) : J(t.country)},
{"position", t.x && t.y ? J(O{{"x", *t.x}, {"y", *t.y}}) : J(nullptr)},
{"quality", O{{"pitch", int(t.quality[0])}, {"fitness", int(t.quality[1])},
{"catering", int(t.quality[2])}, {"lodging", int(t.quality[3])}}},
{"guiImageKey", "gui:camp/" + std::to_string(i)}, {"worldImageAssetId", nullptr},
{"sponsorChance", t.sponsor_chance}, {"quote", std::move(quote)}});
}
const uint8_t stays = rec + 0x21f < g.manager_records.size() ? g.manager_records[rec + 0x21f] : 0;
O focus;
if (rec + 0xc4 < g.manager_records.size())
focus = O{{"condition", int(g.manager_records[rec + 0xc1])}, {"technique", int(g.manager_records[rec + 0xc2])},
{"play", int(g.manager_records[rec + 0xc3])}, {"recovery", int(g.manager_records[rec + 0xc4])}};
return O{{"kind", "camps"}, {"maps", std::move(maps)}, {"camps", std::move(camps)}, {"focus", std::move(focus)},
{"staysThisSeason", int(stays & 0x7f)}, {"staysLimit", 3}, {"bookedThisWeek", (stays & 0x80) != 0},
{"availability", reason ? unavailable(reason) : available()}};
}
} // namespace
void ensure_ui_identities(ModernState& g) {
if (g.career_id.empty()) {
std::random_device device;
const uint64_t value = uint64_t(device()) << 32 | device();
char id[32];
std::snprintf(id, sizeof id, "career:%016llx", static_cast<unsigned long long>(value));
g.career_id = id;
}
const size_t humans = size_t(std::max(0, human_managers(g)));
if (g.manager_ids.size() < humans) g.manager_ids.resize(humans);
for (auto& id : g.manager_ids)
if (id.empty()) id = "manager:" + std::to_string(++g.manager_serial);
}
cli::Json ui_command_result(const std::string& request_id, uint64_t previous, uint64_t next,
const std::vector<std::string>& changed_reads, const std::string& feedback) {
A changed;
for (const auto& k : changed_reads) changed.push_back(k);
return O{{"messageType", "command_result"}, {"requestId", request_id}, {"accepted", true},
{"previousRevision", std::to_string(previous)}, {"newRevision", std::to_string(next)},
{"outcome", next == previous ? "no_change" : "applied"}, {"changedReadKinds", std::move(changed)},
{"ownershipChange", nullptr}, {"feedback", text(feedback)}};
}
cli::Json ui_error(const std::string& request_id, const std::string& code, const std::string& message,
uint64_t revision, bool retryable) {
return O{{"messageType", "error"}, {"requestId", request_id}, {"code", code}, {"message", text(message)},
{"currentRevision", std::to_string(revision)}, {"retryable", retryable}, {"stateChanged", false}};
}
std::string ui_manager_id(const ModernState& g, int manager) { return manager_id(g, manager); }
cli::Json ui_money(int64_t euros) {
return O{{"minor", std::to_string(euros * 100)}, {"currency", "EUR"}, {"minorUnits", 2}};
}
cli::Json ui_snapshot(const ModernState& g, const UiContext& c, const std::string& request_id, cli::Json data) {
return snapshot(request_id, meta(g, c), std::move(data));
}
std::string ui_team_id(const ModernState& g, int team) { return team_id(g, team); }
std::string ui_player_id(const ModernState& g, int player) {
std::string id = entry(g.world_player_id, size_t(player));
return id.empty() ? "player:legacy-" + std::to_string(player) : id;
}
cli::Json ui_read(const ModernState& g, const UiContext& c, const cli::Json& request) {
const std::string request_id = text_field(request, "requestId");
const std::string kind = text_field(request, "kind");
if (c.manager < 0 || c.manager >= int(g.manager_teams.size()))
return failure(request_id, "no_active_manager", "Kein Manager am Schreibtisch.", c.state_revision);
// A read names the manager it is for; it must be the one at the desk (the session decides
// who acts, not the request).
if (const std::string wanted = text_field(request, "managerId"); !wanted.empty() && wanted != manager_id(g, c.manager))
return failure(request_id, "manager_not_active", "Dieser Manager sitzt nicht am Schreibtisch.", c.state_revision);
J m = meta(g, c);
const std::string today = *std::get<O>(m.value).at("date").string();
if (kind == "session") return snapshot(request_id, std::move(m), session_data(g, c));
if (kind == "desktop") return snapshot(request_id, std::move(m), desktop_data(g, c, today));
if (kind == "camps") return snapshot(request_id, std::move(m), camps_data(g, c, std::to_string(c.state_revision)));
if (kind == "toto" || kind == "sponsor") {
// the existing projections (ui-abfragen.md), amounts as Money
J p = query_projection(g, c.manager, O{{"kind", kind}});
auto* o = std::get_if<O>(&p.value);
if (!o || !(*o)["ok"].value.index() || !std::get<bool>((*o)["ok"].value))
return failure(request_id, "unavailable", "Nicht verfügbar.", c.state_revision);
o->erase("ok");
const auto money = [](J& v) { if (v.integer()) v = ui_money(*v.integer()); };
if (kind == "toto") {
money((*o)["stake"]), money((*o)["cost"]);
auto& last = std::get<O>((*o)["last"].value);
money(last["paid"]), money(last["won"]);
} else {
for (const char* key : {"offer", "queued"})
if (auto* row = std::get_if<O>(&(*o)[key].value)) money((*row)["monthly"]);
}
(*o)["kind"] = kind;
return snapshot(request_id, std::move(m), std::move(p));
}
if (kind == "squad") {
const int team = requested_team(g, c, request);
if (team < 0 || !fields_players(g, team))
return failure(request_id, "unknown_team", "Dieses Team hat keinen Kader.", c.state_revision);
return snapshot(request_id, std::move(m), squad_data(g, c, team, today));
}
return failure(request_id, "unknown_read", "Unbekannte Abfrage: " + kind, c.state_revision);
}
} // namespace bmh::modern