177 lines
8.6 KiB
C++
177 lines
8.6 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "modern/ui/demo_settings.hpp"
|
|
#include "modern/ui/engine_bridge.hpp"
|
|
#include "modern/ui/settings_presentation.hpp"
|
|
#include <set>
|
|
namespace bmh::modern_ui {
|
|
namespace {
|
|
void require_settings(bool yes, const char *message) {
|
|
if (!yes)
|
|
throw editor::Error(message);
|
|
}
|
|
} // namespace
|
|
Json engine_settings_projection(const Json &bundle) {
|
|
validate_engine_desk(bundle);
|
|
const auto &read = bundle.at("settings"),
|
|
&meta = bundle.at("desktop").at("meta");
|
|
require_settings(read.value("messageType", "") == "snapshot" &&
|
|
read.at("data").value("kind", "") == "settings",
|
|
"Einstellungen sind nicht verfügbar.");
|
|
for (auto *key : {"contractVersion", "careerId", "worldId", "worldRevision",
|
|
"stateRevision", "scope"})
|
|
require_settings(read.at("meta").at(key) == meta.at(key),
|
|
"Die Einstellungen sind veraltet.");
|
|
const auto &data = read.at("data");
|
|
require_settings(data.at("leagueGroups").is_array() &&
|
|
data.at("leagueGroups").size() == 5,
|
|
"Unvollständige Wettbewerbszuordnung.");
|
|
Json titles = Json::object();
|
|
std::set<std::string> leagues;
|
|
for (size_t i = 0; i < 5; ++i) {
|
|
const auto &group = data.at("leagueGroups")[i];
|
|
const auto row = std::string(1, char('A' + i));
|
|
const auto &id = group.at("competitionId"), &name = group.at("name");
|
|
require_settings(group.at("row") == row &&
|
|
((id.is_null() && name.is_null()) ||
|
|
(id.is_string() && !id.get<std::string>().empty() &&
|
|
name.is_string() && !name.get<std::string>().empty() &&
|
|
leagues.insert(id.get<std::string>()).second)),
|
|
"Ungültige Wettbewerbszuordnung.");
|
|
titles[row] = name.is_null() ? "Wettbewerb " + row : name.get<std::string>();
|
|
}
|
|
Json catalogue = live_settings_catalogue();
|
|
for (auto &group : catalogue.at("groups"))
|
|
if (group.contains("competitions"))
|
|
for (auto &competition : group["competitions"]) {
|
|
const auto code = competition.at("options").at(0).at("code").get<std::string>();
|
|
const auto row = code.substr(0, 1);
|
|
if (titles.contains(row))
|
|
competition["title"] = titles.at(row);
|
|
}
|
|
require_settings(data.at("cells").is_array() &&
|
|
data.at("cells").size() == 180,
|
|
"Unvollständige Spieloptionen.");
|
|
Json cells = Json::array(), capabilities = Json::object(),
|
|
automation = Json::object(), auto_caps = Json::object();
|
|
for (size_t i = 0; i < 180; ++i) {
|
|
const auto &row = data.at("cells")[i];
|
|
const auto code = row.at("code").get<std::string>();
|
|
require_settings(
|
|
settings_index(code) == int(i) && row.at("raw").is_number_integer() &&
|
|
row.at("raw") >= 0 && row.at("raw") <= 255 &&
|
|
row.at("displayRaw").is_number_integer() &&
|
|
row.at("displayRaw") >= 0 && row.at("displayRaw") <= 255 &&
|
|
row.at("editable").is_boolean(),
|
|
"Ungültige Einstellungszelle.");
|
|
const auto &value = row.at("value");
|
|
require_settings(value.is_null() || (value.is_number_integer() &&
|
|
value >= 0 && value <= 255),
|
|
"Ungültiger Einstellungswert.");
|
|
require_settings(row.at("min").is_number_integer() &&
|
|
row.at("max").is_number_integer() &&
|
|
row.at("min") >= 0 && row.at("max") >= row.at("min") &&
|
|
row.at("max") <= 255 && row.at("step") == 1,
|
|
"Ungültige Einstellungsgrenze.");
|
|
if (i % 9 < 7) {
|
|
const int binary = row.at("raw").get<int>() & 0x3f;
|
|
require_settings(
|
|
binary <= 1 ? value == 1 - binary : value.is_null(),
|
|
"Die Schalterbedeutung passt nicht zu den Originalbytes.");
|
|
}
|
|
if (row.at("editable") == true)
|
|
require_settings(value.is_number_integer() && value >= row.at("min") &&
|
|
value <= row.at("max"),
|
|
"Schreibbarer Wert außerhalb der Grenzen.");
|
|
cells.push_back(value);
|
|
capabilities[code] = row;
|
|
}
|
|
const std::set<std::string> keys{"lineup", "substitutions", "tactics",
|
|
"marking", "training"};
|
|
for (const auto &row : data.at("automation")) {
|
|
const auto key = row.at("id").get<std::string>();
|
|
require_settings(keys.contains(key) && !auto_caps.contains(key) &&
|
|
row.at("enabled").is_boolean() &&
|
|
row.at("editable").is_boolean(),
|
|
"Ungültige Automatik.");
|
|
automation[key] = row.at("enabled");
|
|
auto_caps[key] = row;
|
|
}
|
|
require_settings(auto_caps.size() == 5 && data.at("formations").is_array(),
|
|
"Unvollständige Automatik.");
|
|
std::set<int> slots;
|
|
for (const auto &slot : data.at("formations"))
|
|
require_settings(slot.at("value").is_number_integer() &&
|
|
slot.at("value") >= 1 && slot.at("value") <= 8 &&
|
|
slots.insert(slot.at("value").get<int>()).second &&
|
|
slot.at("label").is_string(),
|
|
"Ungültige gespeicherte Aufstellung.");
|
|
require_settings(data.at("formation").is_number_integer() &&
|
|
(data.at("formation") == 0 ||
|
|
slots.contains(data.at("formation").get<int>())),
|
|
"Gespeicherte Aufstellung nicht verfügbar.");
|
|
return {{"local",
|
|
{{"version", 1},
|
|
{"cells", cells},
|
|
{"automation", automation},
|
|
{"formation", data.at("formation")}}},
|
|
{"cells", capabilities},
|
|
{"automation", auto_caps},
|
|
{"catalogue", std::move(catalogue)},
|
|
{"formations", data.at("formations")}};
|
|
}
|
|
Json engine_settings_command(const Json &bundle, const Json &draft,
|
|
const std::string &request_id) {
|
|
const auto value = engine_settings_projection(bundle),
|
|
&base = value.at("local"), &meta = bundle.at("desktop").at("meta");
|
|
const auto commands = meta.at("scope").at("allowedCommands");
|
|
require_settings(!request_id.empty() &&
|
|
std::find(commands.begin(), commands.end(),
|
|
Json("settings.commit")) != commands.end(),
|
|
"Einstellungsänderungen sind gesperrt.");
|
|
require_settings(draft.at("version") == 1 && draft.at("cells").is_array() &&
|
|
draft.at("cells").size() == 180 &&
|
|
draft.at("automation").is_object() &&
|
|
draft.at("automation").size() == 5,
|
|
"Ungültiger Einstellungsentwurf.");
|
|
Json edits = Json::array(), autos = Json::array();
|
|
for (size_t i = 0; i < 180; ++i) {
|
|
if (draft.at("cells")[i] == base.at("cells")[i])
|
|
continue;
|
|
const auto code = std::string(1, char('A' + i / 9)) + char('1' + i % 9);
|
|
const auto &cap = value.at("cells").at(code), &v = draft.at("cells")[i];
|
|
require_settings(cap.at("editable") == true && v.is_number_integer() &&
|
|
v >= cap.at("min") && v <= cap.at("max"),
|
|
"Gesperrte oder ungültige Spieloption.");
|
|
edits.push_back({{"code", code}, {"value", v}});
|
|
}
|
|
for (const auto &[key, before] : base.at("automation").items()) {
|
|
const auto &on = draft.at("automation").at(key);
|
|
require_settings(on.is_boolean(), "Ungültige Automatik.");
|
|
const bool slot_changed = key == "lineup" && on == true &&
|
|
draft.at("formation") != base.at("formation");
|
|
if (on == before && !slot_changed)
|
|
continue;
|
|
require_settings(value.at("automation").at(key).at("editable") == true,
|
|
"Diese Automatik ist gesperrt.");
|
|
Json row = {{"id", key}, {"enabled", on}};
|
|
if (key == "lineup" && on == true) {
|
|
require_settings(draft.at("formation").is_number_integer(),
|
|
"Bitte eine gespeicherte Aufstellung wählen.");
|
|
bool found = false;
|
|
for (const auto &slot : value.at("formations"))
|
|
found |= slot.at("value") == draft.at("formation");
|
|
require_settings(found, "Diese Aufstellung ist nicht verfügbar.");
|
|
row["formation"] = draft.at("formation");
|
|
}
|
|
autos.push_back(row);
|
|
}
|
|
return {{"messageType", "command"},
|
|
{"requestId", request_id},
|
|
{"careerId", meta.at("careerId")},
|
|
{"expectedRevision", meta.at("stateRevision")},
|
|
{"owner", {{"managerId", meta.at("scope").at("managerId")}}},
|
|
{"kind", "settings.commit"},
|
|
{"payload", {{"edits", edits}, {"automation", autos}}}};
|
|
}
|
|
} // namespace bmh::modern_ui
|