Play the Modern kickoff live: minute steps, substitutions and tactics from the ticker

A rehearsal (session.advance with dryRun) settles questions of the run
before the kickoff; an extension answered there is agreed at the player's
demand of that moment. With an own match the kickoff runs live: one
live.step per beat of the speed control, substitutions and the tactics
board through live.substitute and live.tactics, and leaving the ticker
plays the match to its end. After the final whistle the engine's recording
replaces the frames composed on the way. The paused live read names clubs
in the world's spelling, and the review table shows wins, draws and losses.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
MichaelandClaude Fable 5.2 committed 2026-11-14 00:49:51 +01:00
1 parent 2d66609ca8
commit a5810b15ae
14 files changed
+456 -31

No files matched your search

+183 -5
View File
@@ -26,13 +26,147 @@ bool App::live_open() {
}
bool App::engine_live_open(const Json &recording) {
const auto fixture = engine_live_fixture(recording, engine_data_);
if (!fixture.value("ok", false) || !live_.open(fixture, "")) {
// after a kickoff that was followed live the ticker stays on the final whistle
const bool at_end = engine_live_at_end_ && scene_ == "live";
engine_live_at_end_ = false;
if (!fixture.value("ok", false) || !(at_end ? live_.follow(fixture) : live_.open(fixture, ""))) {
engine_notice_ = "Spieltag gespielt · Der Ticker kann diese Aufzeichnung nicht zeigen (" +
fixture.value("error", std::string("invalid_live_fixture")) + ").";
if (scene_ == "live") { scene_ = live_return_scene_; live_.close(); }
return false;
}
if (at_end) {
live_.speed(0); live_feedback_ = "Abpfiff."; live_reset_ticker_ = live_reset_detail_ = true;
live_selected_match_ = live_.fixture().at("matches").front().at("id");
for (const auto &owner : live_.fixture().at("owners")) if (owner.at("id") == live_.owner()) live_selected_match_ = owner.at("match_id");
live_dialog_.clear(); live_dialog_draft_ = Json(); postmatch_data_ = Json::object(); postmatch_scrolls_ = Json::object(); postmatch_playing_ = false;
focus_after_render_ = "live-review";
return true;
}
engine_live_enter();
live_.speed(2);
return true;
}
// The kickoff stands after its first minute: the ticker opens on it and plays on by live.step.
void App::engine_live_begin(const Json &state, const std::string &revision) {
engine_live_roster_ = engine_live_roster(engine_data_);
engine_live_revision_ = revision; engine_live_running_ = true; engine_live_busy_ = false;
engine_live_at_end_ = false; engine_live_elapsed_ = 0; engine_live_queue_ = Json(); engine_live_swap_ = Json();
engine_live_tactics_ = Json::array(); engine_live_tactics_sent_ = Json();
try {
for (const auto &control : engine_data_.at("tactics").at("data").at("controls"))
engine_live_tactics_.push_back({{"label", control.at("label").value("text", std::string("Taktik"))},
{"min", control.at("range").at("min")}, {"max", control.at("range").at("max")},
{"value", control.at("value")}});
} catch (const std::exception &) { engine_live_tactics_ = Json::array(); }
if (engine_live_tactics_.size() != 8) engine_live_tactics_ = Json::array();
const auto fixture = engine_live_progress(Json(), state, engine_data_, engine_live_roster_);
if (!fixture.value("ok", false) || !live_.open(fixture, "")) {
// nothing the ticker can show: the kickoff is simply played to its end
engine_notice_ = "Der Spieltag wird ohne Ticker zu Ende gespielt.";
engine_live_send("live.finish", Json::object());
return;
}
engine_live_enter();
live_.speed(2);
}
void App::engine_live_send(const std::string &kind, const Json &payload) {
if (!engine_live_running_ || !engine_link_) return;
if (engine_live_busy_) { engine_live_queue_ = {{"kind", kind}, {"payload", payload}}; return; }
const auto command = engine_live_command(engine_data_, engine_live_revision_, editor::new_id("request:ui-"), kind, payload);
auto link = engine_link_;
engine_live_busy_ = true;
engine_live_job_ = std::async(std::launch::async, [link, command, kind] {
Json result = {{"kind", kind}};
try {
result["response"] = link->command(command);
result["live"] = link->read_live({{"kind", "fixture"}});
} catch (const std::exception &e) { result["failure"] = e.what(); }
return result;
});
}
void App::engine_live_poll() {
if (!engine_live_busy_ || engine_live_job_.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) return;
engine_live_busy_ = false;
Json result;
try { result = engine_live_job_.get(); } catch (const std::exception &e) { result = {{"failure", e.what()}}; }
const std::string kind = result.value("kind", std::string());
const Json response = result.value("response", Json::object()), state = result.value("live", Json::object());
const bool accepted = response.value("messageType", "") == "command_result";
if (accepted) engine_live_revision_ = response.value("newRevision", engine_live_revision_);
if (kind == "live.substitute") {
if (accepted && engine_live_swap_.is_array() && engine_live_swap_.size() == 2) {
// the engine swapped the two rows of the line-up; the team tab follows
size_t a = engine_live_roster_.size(), b = engine_live_roster_.size();
for (size_t i = 0; i < engine_live_roster_.size(); ++i) {
if (engine_live_roster_[i].at("id") == engine_live_swap_[0]) a = i;
if (engine_live_roster_[i].at("id") == engine_live_swap_[1]) b = i;
}
if (a < engine_live_roster_.size() && b < engine_live_roster_.size()) {
std::swap(engine_live_roster_[a], engine_live_roster_[b]);
engine_live_roster_[a]["slot"] = a; engine_live_roster_[b]["slot"] = b;
}
live_feedback_ = "Wechsel ausgeführt.";
} else if (!accepted) {
const Json refusal = response.value("message", Json());
std::string reason = refusal.is_object() ? refusal.value("text", std::string()) : std::string();
if (reason.empty()) reason = response.value("code", std::string("substitution_refused"));
live_feedback_ = "Wechsel nicht möglich: " + reason;
}
engine_live_swap_ = Json();
}
if (kind == "live.tactics") {
if (accepted && engine_live_tactics_sent_.is_array() && engine_live_tactics_sent_.size() == engine_live_tactics_.size()) {
for (size_t i = 0; i < engine_live_tactics_.size(); ++i) engine_live_tactics_[i]["value"] = engine_live_tactics_sent_[i];
live_feedback_ = "Taktik geändert.";
} else if (!accepted) {
const Json refusal = response.value("message", Json());
std::string reason = refusal.is_object() ? refusal.value("text", std::string()) : std::string();
if (reason.empty()) reason = response.value("code", std::string("invalid_tactic"));
live_feedback_ = "Taktik nicht geändert: " + reason;
}
engine_live_tactics_sent_ = Json();
}
const bool standing =
state.is_object() && state.value("ok", false) && state.value("live", false);
if (standing) {
if (accepted || kind != "live.step") {
const auto fixture = engine_live_progress(live_.fixture(), state, engine_data_, engine_live_roster_);
if (fixture.value("ok", false)) live_.follow(fixture);
} else {
live_.speed(0);
live_feedback_ = "Der Spieltag steht: " + response.value("code", std::string("live_step_refused"));
}
if (engine_live_queue_.is_object()) {
const Json next = engine_live_queue_; engine_live_queue_ = Json();
engine_live_send(next.at("kind"), next.at("payload"));
}
refresh();
return;
}
// the run is over: its recording replaces the frames composed on the way, the desk is read anew
engine_live_running_ = false; engine_live_queue_ = Json();
auto link = engine_link_;
if (accepted) {
engine_live_at_end_ = true;
engine_start("Abpfiff …", [link, state] {
Json finished = {{"messageType", "live_finished"}, {"liveRecording", state}};
return EngineReply{link, link->snapshot(), finished, nullptr};
}, true);
} else {
// the engine took the kickoff back (a question it could not ask in time): back to the desk
scene_ = live_return_scene_; live_.close();
engine_start("Der Spieltag wurde zurückgenommen …", [link, response] {
Json refused = response; refused["advanceRefused"] = true;
return EngineReply{link, link->snapshot(), refused, nullptr};
}, false);
}
refresh();
}
void App::engine_live_enter() {
try { live_.owner(engine_data_.at("desktop").at("meta").at("scope").at("managerId").get<std::string>()); }
catch (const std::exception &) {}
const auto &fixture = live_.fixture();
live_source_ = nullptr; live_world_ = world_;
postmatch_data_=Json::object();postmatch_scrolls_=Json::object();postmatch_playing_=false;
live_drafts_ = Json::object(); live_dialog_.clear(); live_dialog_draft_ = Json();
@@ -45,11 +179,18 @@ bool App::engine_live_open(const Json &recording) {
live_review_ = false; live_speed_dragging_ = false;
if (scene_ != "live") live_return_scene_ = scene_;
scene_ = "live"; menu_.clear();
live_.speed(2); live_last_tick_ = SDL_GetTicks64();
live_last_tick_ = SDL_GetTicks64();
focus_after_render_ = "live-pause";
return true;
}
void App::live_close() {
if (engine_mode_ && engine_live_running_) {
// a kickoff under way cannot be left standing: it is played to its final whistle
live_dialog_.clear(); live_dialog_draft_ = Json(); live_.speed(0);
live_feedback_ = "Das Spiel wird zu Ende gespielt …";
engine_live_send("live.finish", Json::object());
refresh();
return;
}
live_review_=false;postmatch_playing_=false;
live_.speed(0); live_dialog_.clear(); live_dialog_draft_ = Json();
live_resume_speed_ = 0; live_speed_dragging_ = false;
@@ -76,6 +217,7 @@ void App::live_set_speed(int value) {
dirty_ = true;
}
void App::live_tick() {
if (engine_live_busy_) engine_live_poll();
if (scene_ != "live" || !live_.available()) return;
const auto now = SDL_GetTicks64(), elapsed = now - live_last_tick_; live_last_tick_ = now;
if(live_review_){postmatch_tick(now);return;}
@@ -87,12 +229,32 @@ void App::live_tick() {
if (live_feedback_ != "Die Quelle hat sich geändert. Diese Aufzeichnung bleibt pausiert; öffne Anstoß erneut.") { live_feedback_ = "Die Quelle hat sich geändert. Diese Aufzeichnung bleibt pausiert; öffne Anstoß erneut."; needs_render_ = true; }
return;
}
if (engine_live_running_) {
// one engine minute per beat; the beat follows the speed control
if (engine_live_busy_ || !live_.speed()) return;
static constexpr std::array<uint64_t, 5> beats{0, 1600, 900, 450, 150};
engine_live_elapsed_ += std::min<uint64_t>(elapsed, 2000);
if (engine_live_elapsed_ >= beats[size_t(live_.speed())]) { engine_live_elapsed_ = 0; engine_live_send("live.step", {{"minutes", 1}}); }
return;
}
if (live_.elapse(elapsed)) needs_render_ = true;
}
void App::live_dialog_close(bool apply_draft) {
if (live_dialog_.empty()) return;
if (apply_draft) {
if (apply_draft && engine_live_running_) {
if (live_dialog_ == "lineup" && !live_out_.empty() && !live_in_.empty()) {
engine_live_swap_ = Json::array({live_out_, live_in_});
live_feedback_ = "Wechsel wird ausgeführt …";
engine_live_send("live.substitute", {{"outPlayerId", live_out_}, {"inPlayerId", live_in_}});
}
if (live_dialog_ == "tactics" && live_dialog_draft_.is_object() && live_dialog_draft_.contains("values")) {
engine_live_tactics_sent_ = live_dialog_draft_.at("values");
live_feedback_ = "Taktik wird geändert …";
engine_live_send("live.tactics", {{"values", engine_live_tactics_sent_}});
}
} else if (apply_draft) {
auto proposed = live_dialog_draft_;
if (live_dialog_ == "lineup") {
const auto owner = live_owner();
const auto error = edit_demo_lineup(proposed, {{"kind", "swap"}, {"a", live_out_}, {"b", live_in_}},
@@ -143,6 +305,7 @@ bool App::live_action(const std::string &action, Rml::Element *target) {
}
live_reset_ticker_ = true;
} else if (action == "live-next") {
if (engine_live_running_) { engine_live_elapsed_ = 0; engine_live_send("live.step", {{"minutes", 1}}); return true; }
live_.next(); live_last_tick_ = SDL_GetTicks64();
} else if (action == "live-pause") {
live_set_speed(live_.speed() ? 0 : 1); return true;
@@ -151,8 +314,14 @@ bool App::live_action(const std::string &action, Rml::Element *target) {
} else if (action == "live-review-back") {
postmatch_action("postmatch-ticker",target);return true;
} else if (action == "live-intervene-lineup" || action == "live-intervene-tactics") {
if (live_.finished() || live_.fixture().at("source") == "engine-recording") return true;
if (live_.finished() || (live_.fixture().at("source") == "engine-recording" && !live_.running())) return true;
if (live_.running() && action == "live-intervene-tactics" && engine_live_tactics_.size() != 8) return true;
const auto owner = live_owner(); live_dialog_draft_ = live_owner_state(owner);
if (live_.running() && action == "live-intervene-tactics") {
Json values = Json::array();
for (const auto &control : engine_live_tactics_) values.push_back(control.at("value"));
live_dialog_draft_ = {{"values", values}};
}
live_dialog_ = action == "live-intervene-lineup" ? "lineup" : "tactics";
live_resume_speed_ = live_.speed(); live_.speed(0); live_last_tick_ = SDL_GetTicks64();
live_out_.clear(); live_in_.clear();
@@ -166,6 +335,15 @@ bool App::live_action(const std::string &action, Rml::Element *target) {
try {
const int index = std::stoi(id);
if (index < 0 || index > 7) return true;
if (engine_live_running_) {
// the next value of the engine's own range, wrapping to its lowest
const auto &control = engine_live_tactics_.at(size_t(index));
int value = live_dialog_draft_.at("values").at(size_t(index)).get<int>() + 1;
if (value > control.at("max").get<int>()) value = control.at("min").get<int>();
live_dialog_draft_["values"][size_t(index)] = value;
if (target) focus_after_render_ = target->GetId();
refresh(); return true;
}
const auto error = edit_demo_tactics(live_dialog_draft_["tactics"], {{"kind", "cycle"}, {"index", index}});
if (!error.empty()) return true;
} catch (const std::exception &) { return true; }