Bind tactics and training drafts to confirmed engine commits (by Codex)

This commit is contained in:
Codex committed 2026-10-28 09:57:12 +01:00
1 parent 7d3b3f1101
commit f75e0f8e49
18 files changed
+398 -43

No files matched your search

+109
View File
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/engine_bridge.hpp"
#include <algorithm>
#include <array>
#include <charconv>
#include <set>
@@ -168,4 +169,112 @@ Json engine_lineup_command(const Json &bundle, const Json &order, const std::str
{"expectedRevision", meta.at("stateRevision")}, {"owner", {{"managerId", meta.at("scope").at("managerId")}}},
{"kind", "lineup.commit"}, {"payload", {{"order", order}}}};
}
namespace {
Json sports_command(const Json &bundle, const char *kind, const Json &payload, const std::string &id) {
validate_engine_desk(bundle);
const auto &meta = bundle.at("desktop").at("meta");
const auto commands = meta.at("scope").value("allowedCommands", Json::array());
require(!id.empty() && commands.is_array() && std::find(commands.begin(), commands.end(), Json(kind)) != commands.end(),
"Diese Änderung ist im aktuellen Kontext nicht verfügbar.");
return {{"messageType", "command"}, {"requestId", id}, {"careerId", meta.at("careerId")},
{"expectedRevision", meta.at("stateRevision")}, {"owner", {{"managerId", meta.at("scope").at("managerId")}}},
{"kind", kind}, {"payload", payload}};
}
int whole_in_range(const Json &v, int lo, int hi) {
require(v.is_number_integer() && v.get<int64_t>() >= lo && v.get<int64_t>() <= hi,
"Wert außerhalb des verfügbaren Bereichs.");
return v.get<int>();
}
}
Json engine_tactics_projection(const Json &bundle) {
validate_engine_desk(bundle);
const auto &data = lineup_read(bundle, "tactics");
require(data.at("teamId") == bundle.at("desktop").at("meta").at("scope").at("teamId"), "Taktik gehört einer anderen Mannschaft.");
require(data.at("controls").is_array() && data.at("controls").size() == 8, "Unvollständige Taktikeinstellungen.");
Json out = {{"values", Json::array()}, {"limits", Json::array()}, {"minima", Json::array()}, {"labels", Json::array()}};
// These bounds describe the existing board's visual capacity, not engine rules.
const std::array<int, 8> visual_limits{3,3,3,3,1,1,1,11};
for (int i = 0; i < 8; ++i) {
const Json *control = nullptr;
for (const auto &item : data.at("controls")) if (item.at("id") == "tactic:" + std::to_string(i)) {
require(!control, "Doppelte Taktik-ID."); control = &item;
}
require(control, "Taktikeinstellung fehlt.");
const auto &range = control->at("range");
const int lo = whole_in_range(range.at("min"), 0, visual_limits[size_t(i)]);
const int hi = whole_in_range(range.at("max"), lo, visual_limits[size_t(i)]);
require(range.at("step") == 1, "Diese Taktikschrittweite wird noch nicht dargestellt.");
out["values"].push_back(whole_in_range(control->at("value"), lo, hi));
out["limits"].push_back(hi); out["minima"].push_back(lo);
out["labels"].push_back(control->at("label").at("text"));
}
const auto board = engine_lineup_projection(bundle).at("board");
require(board.at("points").size() == 11, "Die Taktiktafel benötigt gelieferte Spielfeldpositionen.");
std::set<std::string> occupied;
for (const auto &point : board.at("points")) require(point.is_array() && occupied.insert(point.dump()).second, "Spielfeldpositionen sind nicht vollständig bekannt.");
out["board"] = board;
return out;
}
Json engine_tactics_command(const Json &bundle, const Json &values, const std::string &id) {
const auto base = engine_tactics_projection(bundle);
require(values.is_array() && values.size() == 8, "Acht Taktikwerte werden benötigt.");
for (size_t i = 0; i < 8; ++i) (void)whole_in_range(values[i], base.at("minima")[i], base.at("limits")[i]);
return sports_command(bundle, "tactics.commit", {{"values", values}}, id);
}
Json engine_training_projection(const Json &bundle) {
validate_engine_desk(bundle);
const auto &data = lineup_read(bundle, "training"), &squad = lineup_read(bundle, "squad");
const auto &team = bundle.at("desktop").at("meta").at("scope").at("teamId");
require(data.at("teamId") == team && squad.at("team").at("id") == team, "Training gehört einer anderen Mannschaft.");
Json out = {{"club", team}, {"types", Json::array()}, {"areas", Json::array()}, {"players", Json::object()},
{"roster", Json::array()}, {"initialized", data.at("initialized")}, {"limits", data.at("limits")}};
const auto group = [&](const char *name, const std::vector<std::string> &ids) {
require(data.at(name).is_array() && data.at(name).size() == ids.size(), "Unvollständiger Trainingsplan.");
for (const auto &id : ids) {
const Json *chosen = nullptr;
for (const auto &item : data.at(name)) if (item.at("id") == id) { require(!chosen, "Doppelte Trainings-ID."); chosen = &item; }
require(chosen && chosen->at("min") == 1 && chosen->at("max") == 3, "Trainingsgruppe wird nicht unterstützt.");
out[name].push_back(whole_in_range(chosen->at("allocation"), 1, 3));
}
};
group("types", {"training:type/goalkeepers", "training:type/defence", "training:type/midfield", "training:type/attack"});
group("areas", {"training:area/fitness", "training:area/skill", "training:area/corner", "training:area/free_kick", "training:area/tackling", "training:area/pass", "training:area/shot", "training:area/speed", "training:area/game"});
std::map<std::string, Json> people;
for (const auto &row : squad.at("players")) require(people.emplace(row.at("player").at("id").get<std::string>(), row).second, "Doppelter Kaderspieler.");
for (const auto &row : data.at("players")) {
const auto id = row.at("playerId").get<std::string>();
require(people.contains(id) && !out.at("players").contains(id), "Fremder oder doppelter Trainingsspieler.");
const auto &person = people.at(id);
out["players"][id] = {{"intensity", whole_in_range(row.at("intensity"), 0, 3)}, {"focus", whole_in_range(row.at("focus"), 0, 7)}};
out["roster"].push_back({{"id", id}, {"name", person.at("player").at("name")}, {"positions", person.at("player").at("positions")},
{"attributes", {{"strength", metric_value(person, "strength")}}}});
}
require(out.at("players").size() == people.size(), "Trainingskader ist unvollständig.");
const int automation = whole_in_range(data.at("automation"), 0, 255);
// Reflect the original screen's four stored subordinate flags. This client
// never writes the automation byte; only the engine changes it on commit.
out["autos"] = Json::array({bool(automation & 2), bool(automation & 4), bool(automation & 8), bool(automation & 16)});
out["master_auto"] = bool(automation & 1);
return out;
}
Json engine_training_command(const Json &bundle, const Json &draft, const std::string &id) {
const auto base = engine_training_projection(bundle);
for (const auto *group : {"types", "areas"}) {
require(draft.at(group).is_array() && draft.at(group).size() == base.at(group).size(), "Trainingsplan ist unvollständig.");
for (const auto &n : draft.at(group)) (void)whole_in_range(n, 1, 3);
}
int types = 0, fitness = 0, areas = 0;
for (const auto &v : draft.at("types")) types += v.get<int>();
for (size_t i = 0; i < 9; ++i) (i < 2 ? fitness : areas) += draft.at("areas")[i].get<int>();
require(types <= base.at("limits").at("types").get<int>() && fitness <= base.at("limits").at("fitnessAndSkill").get<int>() && areas <= base.at("limits").at("otherAreas").get<int>(), "Ballbudget überschritten.");
require(draft.at("players").is_object() && draft.at("players").size() == base.at("players").size(), "Trainingskader ist unvollständig.");
Json changed = Json::array();
for (const auto &[pid, row] : draft.at("players").items()) {
require(base.at("players").contains(pid) && row.at("focus") == base.at("players").at(pid).at("focus"), "Spielerschwerpunkte sind noch schreibgeschützt.");
if (row.at("intensity") != base.at("players").at(pid).at("intensity"))
changed.push_back({{"playerId", pid}, {"intensity", whole_in_range(row.at("intensity"), 1, 3)}});
}
return sports_command(bundle, "training.commit", {{"types", draft.at("types")}, {"areas", draft.at("areas")}, {"players", changed}}, id);
}
} // namespace bmh::modern_ui