Files
Dreierpack-Manager/src/modern/ui/model.cpp
T

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