// SPDX-License-Identifier: GPL-3.0-only #include "modern/content/ui_contract.hpp" #include #include #include #include #include #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& 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:"), 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(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& 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(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(&p.value); if (!o || !(*o)["ok"].value.index() || !std::get((*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)["last"].value); money(last["paid"]), money(last["won"]); } else { for (const char* key : {"offer", "queued"}) if (auto* row = std::get_if(&(*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