539 lines
25 KiB
C++
539 lines
25 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "modern/ui/model.hpp"
|
|
#include "modern/content/manager_name.hpp"
|
|
#include "modern/ui/demo_advertising.hpp"
|
|
#include "modern/ui/demo_almanac.hpp"
|
|
#include "modern/ui/demo_calendar.hpp"
|
|
#include "modern/ui/demo_career.hpp"
|
|
#include "modern/ui/demo_national_ui.hpp"
|
|
#include "modern/ui/demo_environment.hpp"
|
|
#include "modern/ui/demo_finance.hpp"
|
|
#include "modern/ui/demo_lineup.hpp"
|
|
#include "modern/ui/demo_live.hpp"
|
|
#include "modern/ui/demo_post_match.hpp"
|
|
#include "modern/ui/demo_news.hpp"
|
|
#include "modern/ui/demo_opening.hpp"
|
|
#include "modern/ui/demo_reports.hpp"
|
|
#include "modern/ui/demo_settings.hpp"
|
|
#include "modern/ui/demo_sports.hpp"
|
|
#include "modern/ui/demo_stadium.hpp"
|
|
#include "modern/ui/demo_statistics.hpp"
|
|
#include "modern/ui/demo_toto.hpp"
|
|
#include "modern/ui/demo_transfer.hpp"
|
|
#include "modern/ui/desktop.hpp"
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
|
|
namespace bmh::modern_ui {
|
|
std::optional<std::string> normalized_manager_name(std::string_view raw) {
|
|
return modern::normalized_manager_name(raw);
|
|
}
|
|
|
|
namespace {
|
|
bool bounded_integer(const Json &value, int low, int high) {
|
|
if (!value.is_number_integer())
|
|
return false;
|
|
if (value.is_number_unsigned())
|
|
return value.get<uint64_t>() >= uint64_t(low) &&
|
|
value.get<uint64_t>() <= uint64_t(high);
|
|
return value.get<int64_t>() >= low && value.get<int64_t>() <= high;
|
|
}
|
|
bool valid_start_setup(const Json &value) {
|
|
if (!value.is_object() || value.size() != 6)
|
|
return false;
|
|
for (const auto &[key, range] :
|
|
std::vector<std::pair<std::string, std::pair<int, int>>>{
|
|
{"duration", {1, 5}},
|
|
{"difficulty", {1, 10}},
|
|
{"players", {1, 4}},
|
|
{"mode", {1, 3}}})
|
|
if (!value.contains(key) ||
|
|
!bounded_integer(value.at(key), range.first, range.second))
|
|
return false;
|
|
if (!value.contains("league") || !value.at("league").is_boolean() ||
|
|
!value.contains("world") || !value.at("world").is_boolean())
|
|
return false;
|
|
const bool league = value.at("league").get<bool>(),
|
|
world = value.at("world").get<bool>();
|
|
return (league || world) && (league || value.at("players").get<int>() == 1);
|
|
}
|
|
std::string normalized_managers(const Json &raw, const Catalog &world,
|
|
Json &output) {
|
|
if (!raw.is_array() || raw.empty() || raw.size() > 4)
|
|
return "invalid_managers";
|
|
std::set<std::string> clubs;
|
|
std::set<int> portraits;
|
|
output = Json::array();
|
|
for (const auto &value : raw) {
|
|
if (!value.is_object() || !value.contains("club") ||
|
|
!value.at("club").is_string() || !value.contains("name") ||
|
|
!value.at("name").is_string())
|
|
return "invalid_manager";
|
|
const auto club = value.at("club").get<std::string>();
|
|
if (!world.manageable(club))
|
|
return "club_locked";
|
|
const auto name =
|
|
normalized_manager_name(value.at("name").get<std::string>());
|
|
const Json portrait = value.value("portrait", Json(0)),
|
|
strength = value.value("strength_choice", Json(1));
|
|
const Json style = value.value("portrait_style", Json("photo"));
|
|
if (!name || !bounded_integer(portrait, 0, 11) ||
|
|
!bounded_integer(strength, 0, 2) || !style.is_string() ||
|
|
(style.get<std::string>() != "photo" &&
|
|
style.get<std::string>() != "painted") ||
|
|
!clubs.insert(club).second ||
|
|
!portraits.insert(portrait.get<int>()).second)
|
|
return "invalid_manager";
|
|
auto manager = value;
|
|
manager["name"] = *name;
|
|
manager["portrait"] = portrait;
|
|
manager["portrait_style"] = style;
|
|
manager["strength_choice"] = strength;
|
|
output.push_back(std::move(manager));
|
|
}
|
|
return {};
|
|
}
|
|
bool valid_date(const Json &value) {
|
|
if (!value.is_string())
|
|
return false;
|
|
const auto text = value.get<std::string>();
|
|
if (text.size() != 10 || text[4] != '-' || text[7] != '-')
|
|
return false;
|
|
for (size_t i = 0; i < text.size(); ++i)
|
|
if (i != 4 && i != 7 && (text[i] < '0' || text[i] > '9'))
|
|
return false;
|
|
const int year = std::stoi(text.substr(0, 4)),
|
|
month = std::stoi(text.substr(5, 2)),
|
|
day = std::stoi(text.substr(8, 2));
|
|
return year > 0 &&
|
|
std::chrono::year_month_day{std::chrono::year{year},
|
|
std::chrono::month{unsigned(month)},
|
|
std::chrono::day{unsigned(day)}}
|
|
.ok();
|
|
}
|
|
bool camp_id(const Json &value) {
|
|
if (!value.is_string())
|
|
return false;
|
|
const auto id = value.get<std::string>();
|
|
for (int i = 0; i < 18; ++i)
|
|
if (id == "resort:" + std::to_string(i))
|
|
return true;
|
|
return false;
|
|
}
|
|
bool preferences(const Json &value) {
|
|
if (!value.is_object())
|
|
return false;
|
|
const auto theme = value.value("theme", std::string("midnight"));
|
|
return (theme == "midnight" || theme == "silver" || theme == "matchday") &&
|
|
(!value.contains("volume") ||
|
|
(value["volume"].is_number_integer() && value["volume"] >= 0 &&
|
|
value["volume"] <= 100)) &&
|
|
(!value.contains("effects") || value["effects"].is_boolean());
|
|
}
|
|
} // namespace
|
|
DemoSource::DemoSource(std::shared_ptr<const Catalog> catalog)
|
|
: catalog_(std::move(catalog)), almanac_(make_demo_almanac(*catalog_)) {
|
|
std::string club;
|
|
for (const auto *c : catalog_->clubs()) {
|
|
if (!catalog_->manageable(c->value("id", "")))
|
|
continue;
|
|
club = c->value("id", "");
|
|
break;
|
|
}
|
|
if (club.empty())
|
|
throw editor::Error("no_manageable_demo_club");
|
|
state_ = {
|
|
{"schema", "openbmh-ui-demo@1"},
|
|
{"world", catalog_->manifest().value("id", "")},
|
|
{"date", catalog_->manifest().value("start_date", "2026-07-01")},
|
|
{"managers", Json::array({{{"name", "Alex Berger"},
|
|
{"club", club},
|
|
{"portrait", 0},
|
|
{"portrait_style", "photo"},
|
|
{"strength_choice", 1}}})},
|
|
{"cash", 12450000},
|
|
{"deposit", 600000},
|
|
{"debt", 0},
|
|
{"ticket", 13},
|
|
{"fans", 67},
|
|
{"camp",
|
|
{{"selected", "resort:4"}, {"confirmed", ""}, {"focus", {5, 4, 6}}}},
|
|
{"opening", "complete"},
|
|
{"opening_created", false},
|
|
{"preferences",
|
|
{{"theme", "midnight"}, {"volume", 80}, {"effects", true}}},
|
|
{"edits", Json::object()}};
|
|
state_["training"] = demo_training(*catalog_, club);
|
|
state_["tactics"] = demo_tactics();
|
|
if (!valid_date(state_.at("date")))
|
|
throw editor::Error("invalid_demo_date");
|
|
state_["calendar"] = demo_calendar(*catalog_, state_.at("date"), club);
|
|
state_["reports"] = demo_reports(*catalog_);
|
|
if (!migrate_demo_finance(state_, *catalog_, club))
|
|
throw editor::Error("invalid_demo_finance");
|
|
if (!migrate_demo_environment(state_, *catalog_) ||
|
|
!migrate_demo_advertising(state_, *catalog_) ||
|
|
!migrate_demo_toto(state_, *catalog_))
|
|
throw editor::Error("invalid_demo_club");
|
|
if (!migrate_demo_lineup(state_, *catalog_, club) ||
|
|
!migrate_demo_transfer(state_, *catalog_, club))
|
|
throw editor::Error("invalid_demo_squad");
|
|
if (!migrate_demo_stadium(state_, *catalog_, club))
|
|
throw editor::Error("invalid_demo_stadium");
|
|
if (!migrate_demo_news(state_, *catalog_))
|
|
throw editor::Error("invalid_demo_news");
|
|
if (!migrate_demo_settings(state_))
|
|
throw editor::Error("invalid_demo_settings");
|
|
if (!migrate_demo_opening(state_, *catalog_))
|
|
throw editor::Error("Ungültige Saisonvorbereitung.");
|
|
if (!migrate_demo_career(state_, *catalog_))
|
|
throw editor::Error("invalid_demo_career");
|
|
if(!migrate_national_ui(state_))throw editor::Error("invalid_demo_national");
|
|
saved_ = state_;
|
|
}
|
|
Snapshot DemoSource::snapshot() const { return {revision_, catalog_, state_}; }
|
|
Json DemoSource::read_almanac(const Json &request) const {
|
|
return query_demo_almanac(almanac_, request, state_.at("date"));
|
|
}
|
|
Json DemoSource::read_statistics(const Json &request) const {
|
|
return demo_statistics(*catalog_, state_, request);
|
|
}
|
|
Json DemoSource::read_live(const Json &request) const {
|
|
return query_demo_live(*catalog_, state_, revision_, request);
|
|
}
|
|
Json DemoSource::read_post_match(const Json &request) const {
|
|
// This is an explicit UI-fixture path. Do not promote it to engine authority.
|
|
if (!request.is_object() || !request.contains("revision") || !request.contains("fixture_id"))
|
|
return {{"ok", false}, {"error", "post_match_identity_required"}};
|
|
return query_demo_post_match(make_demo_live(*catalog_, state_, revision_), request);
|
|
}
|
|
ActionResult DemoSource::apply(const Action &action) {
|
|
if (action.revision != revision_)
|
|
return {false, revision_, "stale_revision"};
|
|
if(state_.value("career",Json::object()).value("ended",false)&&action.kind!="start")return {false,revision_,"career_ended"};
|
|
auto next = state_;
|
|
try {
|
|
if(action.kind=="national"){const auto error=edit_national_ui(next,action.value);if(!error.empty())return {false,revision_,error};
|
|
} else if (action.kind == "career") {
|
|
const auto previous_club = demo_career_manager(next).value("club", "");
|
|
const auto old_view = demo_career_view(next);
|
|
const auto error = edit_demo_career(next, action.value, *catalog_);
|
|
if (!error.empty()) return {false, revision_, error};
|
|
const auto current_club = demo_career_manager(next).value("club", "");
|
|
if (current_club != previous_club) {
|
|
next["career_views"][previous_club] = old_view;
|
|
if (next["career_views"].contains(current_club))
|
|
restore_demo_career_view(next, next["career_views"].at(current_club));
|
|
else {
|
|
DemoSource fresh(catalog_);
|
|
const auto result = fresh.apply({0,"managers",Json::array({demo_career_manager(next)})});
|
|
if (!result.ok) return {false,revision_,result.error};
|
|
restore_demo_career_view(next,demo_career_view(fresh.snapshot().state));
|
|
}
|
|
}
|
|
if(!migrate_demo_lineup(next,*catalog_,current_club))return {false,revision_,"invalid_demo_lineup"};
|
|
} else if (action.kind == "settings") {
|
|
const auto error = edit_demo_settings(next, action.value);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "news") {
|
|
const auto error = edit_demo_news(next, action.value, *catalog_);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "ticket") {
|
|
if (!action.value.is_number_integer() || action.value < 0 ||
|
|
action.value > 25)
|
|
return {false, revision_, "invalid_demo_ticket"};
|
|
next["ticket"] = action.value;
|
|
} else if (action.kind == "managers" || action.kind == "start") {
|
|
const bool start = action.kind == "start";
|
|
if (start &&
|
|
(!action.value.is_object() || !action.value.contains("setup") ||
|
|
!action.value.contains("managers") ||
|
|
!valid_start_setup(action.value.at("setup"))))
|
|
return {false, revision_, "invalid_setup"};
|
|
const auto &raw = start ? action.value.at("managers") : action.value;
|
|
if (start &&
|
|
(!raw.is_array() ||
|
|
raw.size() !=
|
|
size_t(action.value.at("setup").at("players").get<int>())))
|
|
return {false, revision_, "invalid_managers"};
|
|
Json managers;
|
|
const auto error = normalized_managers(raw, *catalog_, managers);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
if (!start && next.contains("career") && next["career"].value("ended",false))
|
|
return {false,revision_,"career_ended"};
|
|
if (!start && !next.at("edits").value("setup",Json::object()).value("league",true) && managers.size()>1)
|
|
return {false,revision_,"national_one_manager"};
|
|
Json retained_preferences,retained_settings;
|
|
if(start){
|
|
retained_preferences=action.value.value("preferences",state_.at("preferences"));
|
|
retained_settings=action.value.value("settings",state_.at("settings"));
|
|
if(!preferences(retained_preferences))return {false,revision_,"invalid_preferences"};
|
|
// A new presentation career never inherits progression or team data.
|
|
DemoSource fresh(catalog_);next=fresh.snapshot().state;
|
|
}
|
|
next["managers"] = std::move(managers);
|
|
if (start) {
|
|
auto options=action.value.at("setup");options["mode"]=3;
|
|
next["edits"]["setup"]=options;
|
|
next["career"]=demo_career_defaults(next.at("managers"),options);
|
|
next["career_views"]=Json::object();
|
|
next["news"] = demo_news(*catalog_, next);
|
|
} else if (next.contains("career")) {
|
|
const int active=next["career"].value("active_portrait",0);
|
|
if (std::none_of(next["managers"].begin(),next["managers"].end(),[&](const auto &m){return m.value("portrait",0)==active;}))
|
|
next["career"]["active_portrait"]=next["managers"][0].value("portrait",0);
|
|
}
|
|
if(!start && next.contains("career")){
|
|
Json ai=Json::array();for(const auto &id:next["career"].at("ai_teams"))
|
|
if(std::none_of(next["managers"].begin(),next["managers"].end(),[&](const auto &m){return m.value("club","")==id.get<std::string>();}))ai.push_back(id);
|
|
next["career"]["ai_teams"]=std::move(ai);
|
|
}
|
|
const auto first=demo_career_manager(next).value("club", "");
|
|
if (next.at("training").at("club") != first) {
|
|
next["training"] = demo_training(*catalog_, first);
|
|
next["tactics"] = demo_tactics();
|
|
next["contracts"] = demo_contracts(*catalog_, first);
|
|
next["lineup"] = demo_lineup(*catalog_, first);
|
|
next["indoor_lineup"] = demo_lineup(*catalog_, first);
|
|
next["indoor_lineup"]["points"] = demo_lineup_formations(true)[0];
|
|
next["transfer"] = demo_transfer(*catalog_, first);
|
|
next["stadium"] = demo_stadium(*catalog_, first);
|
|
next["calendar"] = demo_calendar(*catalog_, next.at("date"), first);
|
|
const auto error = edit_demo_reports(
|
|
next["reports"],
|
|
{{"kind", "league"}, {"value", next["calendar"]["league"]}},
|
|
*catalog_);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
}
|
|
if (start) {
|
|
next["edits"]["setup"] = action.value.at("setup");
|
|
next["edits"]["setup"]["mode"] = 3;
|
|
next["opening"] = action.value.at("setup").at("league").get<bool>()
|
|
? "pending"
|
|
: "complete";
|
|
next["opening_created"] = false;
|
|
next["opening_flow"] = make_demo_opening(*catalog_, next, action.value.at("setup").at("league").get<bool>());
|
|
next["preferences"]=retained_preferences;
|
|
const auto settings_error=edit_demo_settings(next,retained_settings);
|
|
if(!settings_error.empty())return {false,revision_,settings_error};
|
|
}
|
|
} else if (action.kind == "environment" || action.kind == "advertising" ||
|
|
action.kind == "toto") {
|
|
const auto error =
|
|
action.kind == "environment"
|
|
? edit_demo_environment(next, action.value, *catalog_)
|
|
: action.kind == "advertising"
|
|
? edit_demo_advertising(next, action.value, *catalog_)
|
|
: edit_demo_toto(next, action.value, *catalog_);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "lineup" || action.kind == "transfer") {
|
|
const auto club = demo_career_manager(next).value("club", "");
|
|
const auto error =
|
|
action.kind == "lineup"
|
|
? edit_demo_lineup(next, action.value, *catalog_, club)
|
|
: edit_demo_transfer(next, action.value, *catalog_, club);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "stadium") {
|
|
const auto error = edit_demo_stadium(next, action.value, *catalog_,
|
|
demo_career_manager(next).value("club", ""));
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "finance") {
|
|
const auto error = edit_demo_finance(next, action.value, *catalog_,
|
|
demo_career_manager(next).value("club", ""));
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "training") {
|
|
const auto error = edit_demo_training(next["training"], action.value);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "tactics") {
|
|
const auto error = edit_demo_tactics(next["tactics"], action.value);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
} else if (action.kind == "calendar") {
|
|
const auto error =
|
|
edit_demo_calendar(next["calendar"], action.value, *catalog_,
|
|
demo_career_manager(next).value("club", ""));
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
if (action.value.value("kind", "") == "league") {
|
|
const auto report_error = edit_demo_reports(
|
|
next["reports"],
|
|
{{"kind", "league"}, {"value", next["calendar"]["league"]}},
|
|
*catalog_);
|
|
if (!report_error.empty())
|
|
return {false, revision_, report_error};
|
|
}
|
|
} else if (action.kind == "reports") {
|
|
const auto error =
|
|
edit_demo_reports(next["reports"], action.value, *catalog_);
|
|
if (!error.empty())
|
|
return {false, revision_, error};
|
|
next["calendar"]["league"] = next["reports"]["league"];
|
|
} else if (action.kind == "camp.select") {
|
|
if (!camp_id(action.value))
|
|
return {false, revision_, "camp_unknown"};
|
|
next["camp"]["selected"] = action.value;
|
|
} else if (action.kind == "camp.focus") {
|
|
if (!action.value.is_array() || action.value.size() != 3)
|
|
return {false, revision_, "invalid_focus"};
|
|
for (const auto &v : action.value)
|
|
if (!v.is_number_integer() || v < 0 || v > 15)
|
|
return {false, revision_, "invalid_focus"};
|
|
next["camp"]["focus"] = action.value;
|
|
} else if (action.kind == "camp.remember")
|
|
next["camp"]["confirmed"] = next["camp"]["selected"];
|
|
else if (action.kind == "opening.flow") {
|
|
const auto error = edit_demo_opening(next, action.value, *catalog_);
|
|
if (!error.empty()) return {false, revision_, error};
|
|
} else if (action.kind == "opening") {
|
|
if (!action.value.is_string() ||
|
|
(action.value.get<std::string>() != "complete" && action.value.get<std::string>() != "pending"))
|
|
return {false, revision_, "invalid_opening_state"};
|
|
if (!migrate_demo_opening(next, *catalog_)) return {false, revision_, "Ungültige gespeicherte Saisonvorbereitung."};
|
|
if (action.value.get<std::string>() == "complete") {
|
|
// Old callers may finish directly, without stepping the new UI flow.
|
|
auto &flow = next.at("opening_flow");
|
|
flow["created"] = true; flow["phase"] = "done";
|
|
flow["revealed"] = flow.at("order").size(); flow["playing"] = false;
|
|
next["opening"] = "complete";
|
|
next["opening_created"] = true;
|
|
} else {
|
|
next["opening"] = "pending"; next["opening_created"] = false;
|
|
next["opening_flow"] = make_demo_opening(*catalog_, next, true);
|
|
}
|
|
} else if (action.kind == "preferences") {
|
|
if (!preferences(action.value))
|
|
return {false, revision_, "invalid_preferences"};
|
|
next["preferences"] = action.value;
|
|
} else if (action.kind == "edit") {
|
|
const auto key = action.value.at("key").get<std::string>();
|
|
if (key.empty() || key.size() > 100)
|
|
return {false, revision_, "invalid_edit"};
|
|
next["edits"][key] = action.value.at("value");
|
|
} else
|
|
return {false, revision_, "unsupported_demo_action"};
|
|
} catch (const Json::exception &) {
|
|
return {false, revision_, "invalid_action"};
|
|
}
|
|
if (!migrate_demo_career(next,*catalog_)) return {false,revision_,"invalid_demo_career"};
|
|
sync_demo_settings_training(next);
|
|
state_ = std::move(next);
|
|
return {true, ++revision_, {}};
|
|
}
|
|
void DemoSource::save(const fs::path &file, const Json &desktop) {
|
|
if (!valid_desktop(desktop))
|
|
throw editor::Error("invalid_demo_desktop");
|
|
auto out = state_;
|
|
out["desktop"] = desktop;
|
|
editor::write_atomic(file, out.dump(2));
|
|
saved_ = state_;
|
|
}
|
|
Json DemoSource::load(const fs::path &file) {
|
|
return load_data(Json::parse(editor::read_file(file)));
|
|
}
|
|
bool DemoSource::mark_saved(uint64_t expected_revision) {
|
|
if (revision_ != expected_revision)
|
|
return false;
|
|
saved_ = state_;
|
|
return true;
|
|
}
|
|
Json DemoSource::load_data(Json data, bool saved) {
|
|
if (data.value("schema", "") != "openbmh-ui-demo@1" ||
|
|
data.value("world", "") != catalog_->manifest().value("id", ""))
|
|
throw editor::Error("wrong_demo_world");
|
|
auto validation = DemoSource(catalog_);
|
|
const auto result = validation.apply({0, "managers", data.at("managers")});
|
|
if (!result.ok)
|
|
throw editor::Error(result.error);
|
|
data["managers"] = validation.snapshot().state.at("managers");
|
|
if (data.contains("edits") && data.at("edits").contains("setup") && !valid_start_setup(data.at("edits").at("setup")))
|
|
throw editor::Error("invalid_setup");
|
|
if (!migrate_demo_career(data,*catalog_)) throw editor::Error("invalid_demo_career");
|
|
const auto club = demo_career_manager(data).value("club", "");
|
|
if (!data.contains("training"))
|
|
data["training"] = demo_training(*catalog_, club);
|
|
if (!data.contains("tactics"))
|
|
data["tactics"] = demo_tactics();
|
|
if (!valid_demo_training(data.at("training"), *catalog_, club) ||
|
|
!valid_demo_tactics(data.at("tactics")))
|
|
throw editor::Error("invalid_demo_sports");
|
|
if (!data.at("ticket").is_number_integer() || data.at("ticket") < 0 ||
|
|
data.at("ticket") > 25)
|
|
throw editor::Error("invalid_demo_ticket");
|
|
for (const auto *key : {"cash", "deposit", "debt", "fans"})
|
|
if (!data.at(key).is_number_integer())
|
|
throw editor::Error("invalid_demo_number");
|
|
if (!valid_date(data.at("date")) || !preferences(data.at("preferences")) ||
|
|
!data.at("edits").is_object() || !data.at("opening").is_string() ||
|
|
!camp_id(data.at("camp").at("selected")))
|
|
throw editor::Error("invalid_demo_state");
|
|
if (!data.contains("calendar"))
|
|
data["calendar"] = demo_calendar(*catalog_, data.at("date"), club);
|
|
if (!migrate_demo_calendar(data["calendar"], *catalog_, club))
|
|
throw editor::Error("invalid_demo_calendar");
|
|
if (!data.contains("reports")) {
|
|
data["reports"] = demo_reports(*catalog_);
|
|
const auto error = edit_demo_reports(
|
|
data["reports"],
|
|
{{"kind", "league"}, {"value", data["calendar"]["league"]}}, *catalog_);
|
|
if (!error.empty())
|
|
throw editor::Error(error);
|
|
}
|
|
if (!data.contains("opening_created"))
|
|
data["opening_created"] = false;
|
|
if (!migrate_demo_reports(data["reports"], *catalog_) ||
|
|
!data.at("opening_created").is_boolean())
|
|
throw editor::Error("invalid_demo_reports");
|
|
data["calendar"]["league"] = data["reports"]["league"];
|
|
const auto &focus = data.at("camp").at("focus");
|
|
if (!focus.is_array() || focus.size() != 3)
|
|
throw editor::Error("invalid_focus");
|
|
for (const auto &v : focus)
|
|
if (!v.is_number_integer() || v < 0 || v > 15)
|
|
throw editor::Error("invalid_focus");
|
|
if (!migrate_demo_finance(data, *catalog_, club))
|
|
throw editor::Error("invalid_demo_finance");
|
|
if (!migrate_demo_environment(data, *catalog_) ||
|
|
!migrate_demo_advertising(data, *catalog_) ||
|
|
!migrate_demo_toto(data, *catalog_))
|
|
throw editor::Error("invalid_demo_club");
|
|
if (!migrate_demo_lineup(data, *catalog_, club) ||
|
|
!migrate_demo_transfer(data, *catalog_, club))
|
|
throw editor::Error("invalid_demo_squad");
|
|
if (!migrate_demo_stadium(data, *catalog_, club))
|
|
throw editor::Error("invalid_demo_stadium");
|
|
if (!migrate_demo_news(data, *catalog_))
|
|
throw editor::Error("invalid_demo_news");
|
|
if (!migrate_demo_settings(data))
|
|
throw editor::Error("invalid_demo_settings");
|
|
if (!migrate_demo_opening(data, *catalog_))
|
|
throw editor::Error("Ungültige oder inkonsistente Saisonvorbereitung.");
|
|
if(!migrate_national_ui(data))throw editor::Error("invalid_demo_national");
|
|
for (const auto &[id,view]:data.at("career_views").items()) {
|
|
auto probe=data;probe["career_views"]=Json::object();probe["desktop"]=default_desktop();
|
|
probe["managers"]=Json::array({{{"name","Vorschau"},{"club",id},{"portrait",0}}});
|
|
const Json setup={{"duration",5},{"difficulty",3},{"players",1},{"mode",3},{"league",true},{"world",true}};
|
|
probe["edits"]["setup"]=setup;probe["career"]=demo_career_defaults(probe.at("managers"),setup);
|
|
restore_demo_career_view(probe,view);sync_demo_settings_training(probe);
|
|
DemoSource validator(catalog_);validator.load_data(std::move(probe));
|
|
}
|
|
auto next = data;
|
|
auto desktop = next.value("desktop", Json::object());
|
|
if (!migrate_desktop(desktop))
|
|
throw editor::Error("invalid_demo_desktop");
|
|
next.erase("desktop");
|
|
state_ = std::move(next);
|
|
if (saved) saved_ = state_;
|
|
++revision_;
|
|
return desktop;
|
|
}
|
|
} // namespace bmh::modern_ui
|