Files
Dreierpack-Manager/src/modern/ui/engine_live.cpp
T
MichaelandClaude Fable 5.2 20d4f890cc Paper as the default theme; the club in every window head; the bank hall with either picture
The bank hall falls back to the first hall picture with its own places when a data set
lacks the newer one, and names its five services on tags. Window heads carry the
manager's crest and a rule in the club's colour. The glass cards of the desk lose their
shadow, which drew stray lines over the backdrop blur. A postponed league match is
called Nachholspiel on the match day.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-14 19:17:26 +01:00

432 lines
27 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
// The engine's kickoff recording, shaped for the live ticker. Nothing here simulates or
// estimates: the recording is copied, its phases and tables are renamed to the ticker's
// vocabulary and the desk manager's squad is attached for the team tab.
#include "modern/ui/engine_live.hpp"
#include <algorithm>
#include <cctype>
#include <map>
#include <set>
namespace bmh::modern_ui {
namespace {
Json failure(const std::string &error) { return {{"ok", false}, {"error", error}}; }
bool text(const Json &v, size_t max = 400) { return v.is_string() && v.get_ref<const std::string &>().size() <= max; }
bool count(const Json &v, uint64_t max = 1000000) { return v.is_number_integer() && v.get<int64_t>() >= 0 && uint64_t(v.get<int64_t>()) <= max; }
bool team_ok(const Json &v) { return v.is_object() && text(v.at("id")) && !v.at("id").get_ref<const std::string &>().empty() && text(v.at("name")); }
Json metric(const Json &player, const char *key) {
try {
const auto &value = player.at("metrics").at(key).at("value");
return value.is_number_integer() ? value : Json();
} catch (const std::exception &) { return Json(); }
}
} // namespace
Json engine_advance_command(const Json &bundle, const std::string &request_id, const Json &payload) {
validate_engine_desk(bundle);
if (request_id.empty()) throw editor::Error("Anfrage-ID fehlt.");
const auto &meta = bundle.at("desktop").at("meta");
const auto commands = meta.at("scope").value("allowedCommands", Json::array());
if (!commands.is_array() || std::find(commands.begin(), commands.end(), Json("session.advance")) == commands.end())
throw editor::Error("Der Anstoß ist in diesem Kontext gesperrt.");
return {{"messageType", "command"}, {"contractVersion", meta.at("contractVersion")}, {"requestId", request_id},
{"careerId", meta.at("careerId")}, {"expectedRevision", meta.at("stateRevision")},
{"owner", {{"managerId", meta.at("scope").at("managerId")}}},
{"kind", "session.advance"}, {"payload", payload.is_object() ? payload : Json::object()}};
}
bool valid_engine_live_fixture(const Json &v) {
try {
if (!v.is_object() || !v.value("ok", false) || v.at("schema") != "openbmh-live-fixture@1" ||
v.at("source") != "engine-recording" || !text(v.at("fixture_id")) || !count(v.at("source_revision"), UINT64_MAX >> 1) ||
!v.at("owners").is_array() || v.at("owners").empty() || v.at("owners").size() > 4 ||
!v.at("matches").is_array() || v.at("matches").empty() || v.at("matches").size() > 16 ||
!v.at("frames").is_array() || v.at("frames").size() < 2 || v.at("frames").size() > 2000 ||
!count(v.at("duration"), 200) || !count(v.at("field_count"), 11) ||
(v.at("role") != "club" && v.at("role") != "national") ||
(v.at("surface") != "outdoor" && v.at("surface") != "indoor")) return false;
std::set<std::string> match_ids, owner_ids;
for (const auto &match : v.at("matches")) {
if (!text(match.at("id")) || !match_ids.insert(match.at("id")).second || !team_ok(match.at("home")) ||
!team_ok(match.at("away")) || !match.at("owners").is_array()) return false;
for (const auto &id : match.at("owners")) if (!id.is_string()) return false;
}
for (const auto &owner : v.at("owners")) {
if (!text(owner.at("id")) || !owner_ids.insert(owner.at("id")).second || !text(owner.at("name")) ||
!count(owner.at("portrait"), 11) || !team_ok(owner.at("team")) || !match_ids.contains(owner.at("match_id")) ||
!owner.at("view").is_object() || owner.at("view").at("engine") != true || !owner.at("view").at("rows").is_array() ||
owner.at("view").at("rows").size() > 64) return false;
for (const auto &row : owner.at("view").at("rows"))
if (!text(row.at("id")) || !text(row.at("name")) || !row.contains("strength") || !row.contains("condition")) return false;
}
const int64_t duration = v.at("duration");
int64_t minute = -1; size_t sequence = 0;
for (const auto &frame : v.at("frames")) {
if (frame.at("sequence") != sequence++ || !count(frame.at("minute"), uint64_t(duration)) || frame.at("minute").get<int64_t>() < minute ||
!frame.at("events").is_array() || frame.at("events").size() > 8000 || !frame.at("matches").is_array() ||
frame.at("matches").size() != match_ids.size()) return false;
minute = frame.at("minute");
const auto phase = frame.value("phase", "");
if (phase != "first_half" && phase != "interval" && phase != "second_half" && phase != "extra_time" &&
phase != "shootout" && phase != "finished") return false;
// a kickoff still under way has no final frame yet
if (v.value("live_running", false) ? phase == "finished" : (phase == "finished") != (sequence == v.at("frames").size())) return false;
std::set<std::string> scored;
for (const auto &m : frame.at("matches")) {
if (!match_ids.contains(m.at("match_id")) || !scored.insert(m.at("match_id")).second) return false;
for (auto key : {"score", "chances", "yellow", "red", "players"})
if (!m.at(key).is_array() || m.at(key).size() != 2 || !count(m.at(key)[0], 1000) || !count(m.at(key)[1], 1000)) return false;
if (!m.at("standings").is_array() || m.at("standings").size() > 128) return false;
for (const auto &row : m.at("standings")) {
if (!team_ok(row.at("team"))) return false;
for (auto key : {"position", "played", "gf", "ga", "points"}) if (!count(row.at(key))) return false;
}
}
for (const auto &event : frame.at("events"))
if (!text(event.at("id")) || !match_ids.contains(event.at("match_id")) || !count(event.at("minute"), 200) ||
!text(event.at("headline")) || !text(event.at("body"), 2200) || !text(event.at("kind"), 40) ||
(event.at("side") != "home" && event.at("side") != "away") || !event.at("score").is_array() ||
event.at("score").size() != 2 || !count(event.at("score")[0], 1000) || !count(event.at("score")[1], 1000)) return false;
}
return true;
} catch (const std::exception &) { return false; }
}
Json engine_live_fixture(const Json &recording, const Json &bundle) {
try {
if (!recording.is_object()) return failure("live_unavailable");
if (!recording.value("ok", false)) return failure(recording.value("error", "live_unavailable"));
Json out = recording;
out["source"] = "engine-recording";
const std::string role = out.value("role", "club") == "national" ? "national" : "club";
out["role"] = role;
if (!out.contains("surface")) out["surface"] = "outdoor";
if (!out.contains("date")) out["date"] = "";
try { out["world"] = bundle.at("desktop").at("meta").at("worldId"); } catch (const std::exception &) { out["world"] = ""; }
// The desk manager's squad in line-up order (the squad after the kickoff).
std::string desk_team;
Json rows = Json::array();
try {
desk_team = bundle.at("desktop").at("meta").at("scope").at("teamId").get<std::string>();
const auto &players = bundle.at("squad").at("data").at("players");
std::map<std::string, const Json *> by_id;
std::vector<std::string> listed;
for (const auto &p : players) {
const std::string id = p.at("player").at("id");
by_id[id] = &p; listed.push_back(id);
}
std::vector<std::string> order;
try {
for (const auto &id : bundle.at("lineup").at("data").at("order")) if (id.is_string()) order.push_back(id);
} catch (const std::exception &) {}
std::set<std::string> seen;
const auto add = [&](const std::string &id) {
const auto at = by_id.find(id);
if (at == by_id.end() || !seen.insert(id).second) return;
const auto &p = *at->second;
rows.push_back({{"id", id}, {"name", p.at("player").at("name")}, {"slot", rows.size()},
{"strength", metric(p, "strength")}, {"condition", metric(p, "condition")},
{"position", p.at("player").value("positions", Json::array()).empty() ? Json() : p.at("player").at("positions").front()},
{"caps", nullptr}, {"international_goals", nullptr}});
};
for (const auto &id : order) add(id);
for (const auto &id : listed) add(id);
} catch (const std::exception &) { rows = Json::array(); }
if (!out.at("owners").is_array() || out.at("owners").empty()) return failure("live_no_human_match");
std::set<int> portraits;
for (auto &owner : out.at("owners")) {
int portrait = owner.value("portrait", 0);
portrait = std::clamp(portrait, 0, 11);
for (int tries = 0; tries < 12 && portraits.contains(portrait); ++tries) portrait = (portrait + 1) % 12;
portraits.insert(portrait);
owner["portrait"] = portrait;
if (!owner.at("team").contains("role")) owner["team"]["role"] = role;
const bool own = owner.at("team").at("id") == desk_team;
owner["view"] = {{"ok", true}, {"engine", true}, {"rows", own ? rows : Json::array()},
{"field_count", out.value("field_count", 11)}};
}
for (auto &match : out.at("matches")) {
for (auto side : {"home", "away"}) if (!match.at(side).contains("role")) match[side]["role"] = role;
if (!match.contains("owners") || !match.at("owners").is_array()) match["owners"] = Json::array();
}
// Tables arrive on the frame when they change; the ticker wants each match's table.
std::map<std::string, Json> tables; // competition id -> ticker rows
const int64_t duration = out.value("duration", 90);
auto &frames = out.at("frames");
for (size_t i = 0; i < frames.size(); ++i) {
auto &frame = frames[i];
const std::string phase = frame.value("phase", "");
const bool last = i + 1 == frames.size();
frame["phase"] = last ? "finished"
: phase == "kickoff" ? "first_half"
: phase == "restart" ? "second_half"
: phase == "fulltime" || phase == "shootout_end" || phase == "finished" ? "second_half"
: phase;
if (frame.at("minute").is_number_integer()) frame["minute"] = std::clamp<int64_t>(frame.at("minute").get<int64_t>(), 0, duration);
if (frame.contains("standings") && frame.at("standings").is_array())
for (const auto &table : frame.at("standings")) {
if (!table.is_object() || !table.contains("rows")) continue;
Json converted = Json::array();
for (const auto &row : table.at("rows")) {
Json team = row.at("team");
team["role"] = "club";
converted.push_back({{"team", team}, {"position", row.at("rank")}, {"played", row.at("played")},
{"gf", row.at("goalsFor")}, {"ga", row.at("goalsAgainst")}, {"points", row.at("points")},
{"won", row.value("won", Json())}, {"drawn", row.value("drawn", Json())}, {"lost", row.value("lost", Json())}});
}
tables[table.value("competitionId", std::string("table"))] = std::move(converted);
}
for (auto &score : frame.at("matches")) {
score["standings"] = Json::array();
for (auto key : {"score", "chances", "yellow", "red", "players"})
for (auto &value : score.at(key)) if (value.is_number_integer() && value.get<int64_t>() < 0) value = 0;
const Json *home = nullptr;
for (const auto &match : out.at("matches")) if (match.at("id") == score.at("match_id")) home = &match.at("home").at("id");
if (!home || role == "national") continue;
for (const auto &[id, table] : tables) {
(void)id;
const bool has = std::any_of(table.begin(), table.end(), [&](const Json &row) { return row.at("team").at("id") == *home; });
if (has) { score["standings"] = table; break; }
}
}
}
if (!valid_engine_live_fixture(out)) return failure("invalid_live_fixture");
return out;
} catch (const std::exception &) { return failure("invalid_live_fixture"); }
}
Json engine_live_command(const Json &bundle, const std::string &revision, const std::string &request_id,
const std::string &kind, const Json &payload) {
const auto &meta = bundle.at("desktop").at("meta");
return {{"messageType", "command"}, {"contractVersion", meta.at("contractVersion")}, {"requestId", request_id},
{"careerId", meta.at("careerId")}, {"expectedRevision", revision},
{"owner", {{"managerId", meta.at("scope").at("managerId")}}},
{"kind", kind}, {"payload", payload.is_object() ? payload : Json::object()}};
}
Json engine_post_match_records(const Json &read, const Json &fixture) {
try {
if (!read.is_object() || read.value("messageType", "") != "snapshot") return Json();
const auto &elevens = read.at("data").at("teamOfTheDay");
if (!elevens.is_array() || elevens.empty()) return Json();
// club names as the recording spells them (its matches and final tables)
std::map<std::string, std::string> clubs;
for (const auto &match : fixture.at("matches"))
for (auto side : {"home", "away"}) clubs[match.at(side).at("id")] = match.at(side).at("name");
for (const auto &snapshot : fixture.at("frames").back().at("matches"))
for (const auto &row : snapshot.at("standings")) clubs[row.at("team").at("id")] = row.at("team").at("name");
for (const auto &eleven : elevens) {
if (!eleven.contains("players") || !eleven.at("players").is_array() || eleven.at("players").size() != 11) continue;
Json rows = Json::array();
for (const auto &p : eleven.at("players")) {
const auto club = clubs.find(p.value("teamId", std::string()));
if (club == clubs.end()) break;
rows.push_back({{"player", {{"id", p.at("playerId")}, {"name", p.at("name")}}},
{"team", {{"id", club->first}, {"name", club->second}, {"role", "club"}}},
{"position", p.at("position")}, {"rating", nullptr}});
}
if (rows.size() != 11) continue;
return {{"schema", "openbmh-post-match-records@1"}, {"fixture_id", fixture.at("fixture_id")},
{"source_revision", fixture.at("source_revision")},
{"eleven", {{"available", true}, {"source", "supplied-records"},
{"notice", eleven.value("competition", std::string("Liga")) + " · nach Toren, Vorlagen, Karten und Ergebnis des Spieltags"},
{"formation", "3-4-3"}, {"rows", rows}}}};
}
return Json();
} catch (const std::exception &) { return Json(); }
}
Json engine_live_roster(const Json &bundle) {
Json rows = Json::array();
try {
const auto &players = bundle.at("squad").at("data").at("players");
std::map<std::string, const Json *> by_id;
std::vector<std::string> listed, order;
for (const auto &p : players) {
const std::string id = p.at("player").at("id");
by_id[id] = &p; listed.push_back(id);
}
try {
for (const auto &id : bundle.at("lineup").at("data").at("order")) if (id.is_string()) order.push_back(id);
} catch (const std::exception &) {}
std::set<std::string> seen;
const auto add = [&](const std::string &id) {
const auto at = by_id.find(id);
if (at == by_id.end() || !seen.insert(id).second) return;
const auto &p = *at->second;
rows.push_back({{"id", id}, {"name", p.at("player").at("name")}, {"slot", rows.size()},
{"strength", metric(p, "strength")}, {"condition", metric(p, "condition")},
{"position", p.at("player").value("positions", Json::array()).empty() ? Json() : p.at("player").at("positions").front()},
{"caps", nullptr}, {"international_goals", nullptr}});
};
for (const auto &id : order) add(id);
for (const auto &id : listed) add(id);
} catch (const std::exception &) { rows = Json::array(); }
return rows;
}
// The standing kickoff as the ticker's fixture: the frames so far plus one for this minute.
// Event texts are composed here from the engine's facts (kind, player, minute); the full
// recording with the engine's own wording replaces this fixture after the final whistle.
Json engine_live_progress(const Json &previous, const Json &state, const Json &bundle, const Json &roster) {
try {
if (!state.is_object() || !state.value("ok", false) || !state.value("live", false)) return failure("live_unavailable");
const auto &meta = bundle.at("desktop").at("meta");
const std::string desk_team = meta.at("scope").at("teamId"), desk_manager = meta.at("scope").at("managerId");
const std::string role = desk_team.starts_with("nt:") || meta.at("scope").value("role", "club") == "national" ? "national" : "club";
const int64_t minute = std::clamp<int64_t>(state.at("minute").get<int64_t>(), 0, 120);
Json out = previous.is_object() && previous.value("live_running", false) ? previous : Json();
if (!out.is_object()) {
out = {{"ok", true}, {"schema", "openbmh-live-fixture@1"}, {"source", "engine-recording"}, {"live_running", true},
{"fixture_id", "live:running:" + meta.at("date").get<std::string>()}, {"source_revision", 0},
{"date", meta.at("date")}, {"world", meta.value("worldId", std::string())}, {"role", role}, {"surface", "outdoor"},
{"duration", 90}, {"field_count", 11}, {"owners", Json::array()}, {"matches", Json::array()},
{"frames", Json::array()}, {"notice", "Der Spieltag läuft"}};
std::set<int> portraits;
for (const auto &m : state.at("matches")) {
const std::string id = "live:" + m.at("home").at("id").get<std::string>();
Json owners = Json::array();
for (auto side : {"home", "away"}) {
const auto &manager = m.at(std::string(side) + "ManagerId");
if (!manager.is_string() || out.at("owners").size() >= 4) continue;
const bool own = manager == desk_manager;
int portrait = int(out.at("owners").size());
Json team = m.at(side); team["role"] = role;
std::string name = own ? bundle.at("desktop").at("data").at("manager").value("name", std::string("Manager")) : std::string("Manager");
out["owners"].push_back({{"id", manager}, {"portrait", portrait}, {"name", name}, {"team", team}, {"match_id", id},
{"view", {{"ok", true}, {"engine", true}, {"rows", own ? roster : Json::array()}, {"field_count", 11}}}});
owners.push_back(manager);
}
Json home = m.at("home"), away = m.at("away");
home["role"] = role; away["role"] = role;
// the desk announced this fixture with its competition; other matches stay unnamed
std::string competition = "Spieltag";
try {
const auto &next = bundle.at("desktop").at("data").at("nextFixture");
if (next.is_object() && next.at("home").at("id") == m.at("home").at("id")) {
competition = next.at("competition").value("text", competition);
std::replace(competition.begin(), competition.end(), '\n', ' ');
// the original's column label for a postponed league match, spelled out
if (competition == "Verlegte Sp.") competition = "Nachholspiel";
// "24.Spieltag" of the original reads "24. Spieltag"
for (size_t i = 0; i + 1 < competition.size(); ++i)
if (competition[i] == '.' && std::isalpha(static_cast<unsigned char>(competition[i + 1]))) competition.insert(++i, 1, ' ');
}
} catch (const std::exception &) {}
out["matches"].push_back({{"id", id}, {"home", home}, {"away", away}, {"owners", owners}, {"competition", competition},
{"attendance", m.value("attendance", Json())}, {"weather", m.value("weather", Json())},
{"lineups", m.value("lineups", Json())}});
}
if (out.at("owners").empty() || out.at("matches").empty()) return failure("live_no_human_match");
}
// the desk manager's roster follows substitutions made during the match
for (auto &owner : out.at("owners")) if (owner.at("id") == desk_manager) owner["view"]["rows"] = roster;
if (minute > 90) out["duration"] = 120;
Json events = Json::array(), scores = Json::array();
const size_t sequence = out.at("frames").size() + (out.at("frames").empty() ? 1 : 0);
// earlier events keep the frame they first appeared in
std::map<std::string, Json> known;
if (!out.at("frames").empty())
for (const auto &e : out.at("frames").back().at("events")) known[e.at("id")] = e;
for (const auto &m : state.at("matches")) {
const std::string id = "live:" + m.at("home").at("id").get<std::string>();
int goals[2] = {0, 0}, chances[2] = {0, 0}, yellow[2] = {0, 0}, red[2] = {0, 0};
size_t index = 0;
for (const auto &e : m.at("events")) {
const std::string kind = e.value("kind", std::string());
const size_t side = e.value("side", std::string("home")) == "away" ? 1 : 0;
const std::string team = m.at(side ? "away" : "home").at("name");
const std::string player = e.at("player").is_object() ? e.at("player").value("name", std::string()) : std::string();
const std::string other = e.contains("other") && e.at("other").is_object() ? e.at("other").value("name", std::string()) : std::string();
std::string headline, body, shown = kind;
if (kind == "goal") {
++goals[side]; ++chances[side];
headline = "Tor für " + team;
body = (player.empty() ? std::string("Treffer") : player + " trifft") + " zum " + std::to_string(goals[0]) + ":" + std::to_string(goals[1]) + "." +
(other.empty() ? "" : " Vorlage: " + other + ".");
} else if (kind == "miss") {
++chances[side]; shown = "chance";
headline = "Chance für " + team; body = player.empty() ? "Die Chance bleibt ungenutzt." : player + " vergibt.";
} else if (kind == "yellow") {
++yellow[side]; headline = "Gelbe Karte"; body = (player.empty() ? "Ein Spieler" : player) + " (" + team + ") sieht Gelb.";
} else if (kind == "second_yellow" || kind == "red") {
++red[side]; shown = "red";
headline = kind == "red" ? "Rote Karte" : "Gelb-Rot"; body = (player.empty() ? "Ein Spieler" : player) + " (" + team + ") muss vom Platz.";
} else if (kind == "injury") {
headline = "Verletzung"; body = (player.empty() ? "Ein Spieler" : player) + " (" + team + ") muss behandelt werden.";
} else continue;
if (e.contains("headline") && e.at("headline").is_string() && e.contains("body") && e.at("body").is_string() &&
!e.at("headline").get<std::string>().empty()) {
headline = e.at("headline").get<std::string>(); body = e.at("body").get<std::string>();
}
const std::string event_id = id + ":event:" + std::to_string(index++);
const auto at = known.find(event_id);
events.push_back(at != known.end() ? at->second
: Json{{"id", event_id}, {"sequence", sequence}, {"match_id", id},
{"minute", std::clamp<int64_t>(e.value("minute", int64_t(minute)), 0, minute)}, {"kind", shown},
{"headline", headline}, {"body", body}, {"score", {goals[0], goals[1]}},
{"side", side ? "away" : "home"}, {"player", e.at("player")}, {"other", e.value("other", Json())}});
}
{
// the whistle, as in the recording: kickoff, and half time once the second half runs
const auto whistle = [&](const char *suffix, int64_t at, const char *kind, const std::string &headline, const std::string &body, int h, int a) {
const std::string event_id = id + suffix;
const auto known_at = known.find(event_id);
events.push_back(known_at != known.end() ? known_at->second
: Json{{"id", event_id}, {"sequence", sequence}, {"match_id", id}, {"minute", at}, {"kind", kind},
{"headline", headline}, {"body", body}, {"score", {h, a}}, {"side", "home"},
{"player", nullptr}, {"other", nullptr}});
};
whistle(":kickoff", 0, "kickoff", "Anpfiff", m.at("home").at("name").get<std::string>() + " gegen " + m.at("away").at("name").get<std::string>() + ": Der Ball rollt.", 0, 0);
if (minute > 45) {
int h = 0, a = 0;
for (const auto &e : m.at("events"))
if (e.value("kind", std::string()) == "goal" && e.value("minute", int64_t(0)) <= 45) ++(e.value("side", std::string("home")) == "away" ? a : h);
whistle(":interval", 45, "interval", "Halbzeit", "Zur Pause steht es " + std::to_string(h) + ":" + std::to_string(a) + ".", h, a);
}
}
Json score = m.value("score", Json::array({goals[0], goals[1]}));
Json standings = Json::array();
if (role == "club" && state.contains("standings"))
for (const auto &table : state.at("standings")) {
if (!table.is_object() || !table.contains("rows")) continue;
Json rows = Json::array(); bool has = false;
for (const auto &row : table.at("rows")) {
Json team = row.at("team"); team["role"] = "club";
has = has || team.at("id") == m.at("home").at("id");
rows.push_back({{"team", team}, {"position", row.at("rank")}, {"played", row.at("played")}, {"gf", row.at("goalsFor")},
{"ga", row.at("goalsAgainst")}, {"points", row.at("points")}, {"won", row.value("won", Json())},
{"drawn", row.value("drawn", Json())}, {"lost", row.value("lost", Json())}});
}
if (has) { standings = std::move(rows); break; }
}
scores.push_back({{"match_id", id}, {"score", score}, {"chances", {chances[0], chances[1]}}, {"yellow", {yellow[0], yellow[1]}},
{"red", {red[0], red[1]}}, {"players", {std::max(0, 11 - red[0]), std::max(0, 11 - red[1])}},
{"standings", standings}});
}
// events are shown newest last, in minute order across the matches
std::stable_sort(events.begin(), events.end(), [](const Json &a, const Json &b) { return a.at("minute").get<int64_t>() < b.at("minute").get<int64_t>(); });
if (out.at("frames").empty()) {
Json zero = Json::array();
for (const auto &s : scores) zero.push_back({{"match_id", s.at("match_id")}, {"score", {0, 0}}, {"chances", {0, 0}}, {"yellow", {0, 0}},
{"red", {0, 0}}, {"players", {11, 11}}, {"standings", s.at("standings")}});
out["frames"].push_back({{"sequence", 0}, {"minute", 0}, {"phase", "first_half"}, {"matches", zero}, {"events", Json::array()}});
}
const int64_t last_minute = out.at("frames").back().at("minute");
out["frames"].push_back({{"sequence", out.at("frames").size()}, {"minute", std::max(minute, last_minute)},
{"phase", minute <= 45 ? "first_half" : minute <= 90 ? "second_half" : "extra_time"},
{"matches", scores}, {"events", events}});
if (out.at("frames").size() > 1900) return failure("invalid_live_fixture");
if (!valid_engine_live_fixture(out)) return failure("invalid_live_fixture");
return out;
} catch (const std::exception &) { return failure("invalid_live_fixture"); }
}
} // namespace bmh::modern_ui