// SPDX-License-Identifier: GPL-3.0-only #include "modern/ui/demo_finance.hpp" #include "modern/ui/demo_career.hpp" #include #include #include #include #include #include #include namespace bmh::modern_ui { namespace { constexpr int64_t money_cap = 99999999, debt_cap = 5000000, salary_cap = 200000; constexpr std::array property_prices{115000, 340000, 470000, 780000, 1350000, 3650000}; constexpr std::array property_names{"Eigentumswohnung", "Mehrfamilienhaus", "Einfamilienhaus", "Villa", "Hochhaus", "Bürogebäude"}; constexpr std::array stock_prices{124, 86, 207, 59, 310, 145, 97, 225, 68, 178, 112, 264}; constexpr std::array stock_names{"MainTech", "Nordlicht", "Hafenwerk", "Bergstrom", "Solaris", "Westbahn", "Rheinwerk", "Ballwerk", "Feldpunkt", "Stadtfunk", "Werkbank", "Sportnetz"}; constexpr std::array incomes{134000, 92000, 86200, 950000, 120000, 50000, 25000}; constexpr std::array income_names{"Trikotwerbung", "Bandenwerbung", "Fernsehrechte", "Zuschauer", "Stadionperipherie", "Mieten, Zinsen, Tilgung", "Sonstiges"}; constexpr std::array costs{650000, 420000, 80000, 120000, 60000, 45000, 250000, 50000, 35000, 0, 30000}; constexpr std::array cost_names{"Gehälter und Prämien", "Stadionkosten", "Nachwuchs", "Co-Trainer", "Arzt", "Physio", "Trainingslager", "Fanbetreuung", "PR-Arbeit", "Zinsen und Tilgung", "Sonstiges"}; constexpr std::array bonus_names{"Torprämie", "Punktprämie", "Auflaufprämie", "Meisterprämie", "Prämie Pl. 2–5", "Prämie Pl. 6–10", "Nichtabstiegsprämie"}; bool keys(const Json &v, std::initializer_list expected) { return v.is_object() && v.size() == expected.size() && std::all_of(expected.begin(), expected.end(), [&](auto *key) { return v.contains(key); }); } bool integer(const Json &v, int64_t lo, int64_t hi) { if (v.is_number_unsigned()) return hi >= 0 && v.get() <= uint64_t(hi) && (lo <= 0 || v.get() >= uint64_t(lo)); return v.is_number_integer() && v.get() >= lo && v.get() <= hi; } bool list(const Json &v, size_t size, int64_t lo, int64_t hi) { return v.is_array() && v.size() == size && std::all_of(v.begin(), v.end(), [&](const auto &item) { return integer(item, lo, hi); }); } Json error(const char *code) { return {{"ok", false}, {"error", code}}; } std::string own(const Catalog &world, const std::string &managed, const Json *state = nullptr) { if (!managed.empty()) { if (!world.manageable(managed)) throw editor::Error("invalid_finance_manager"); return managed; } if (state && state->contains("managers")) { const auto &managers = state->at("managers"); if (!managers.is_array() || managers.empty() || !managers[0].is_object() || !managers[0].contains("club") || !managers[0]["club"].is_string()) throw editor::Error("invalid_finance_manager"); if (demo_career_manager(*state).value("club", "").empty()) throw editor::Error("invalid_finance_manager"); return own(world, demo_career_manager(*state).value("club", "")); } for (const auto *club : world.clubs()) if (world.manageable(club->value("id", ""))) return club->value("id", ""); return ""; } bool valid_date(const Json &v) { if (!v.is_string()) return false; const auto d = v.get(); if (d.size() != 10 || d[4] != '-' || d[7] != '-') return false; for (size_t i = 0; i < d.size(); ++i) if (i != 4 && i != 7 && (d[i] < '0' || d[i] > '9')) return false; const int y = std::stoi(d.substr(0, 4)), m = std::stoi(d.substr(5, 2)), day = std::stoi(d.substr(8, 2)); return y > 0 && std::chrono::year_month_day{std::chrono::year{y}, std::chrono::month{unsigned(m)}, std::chrono::day{unsigned(day)}}.ok(); } Json initial_contract(const Catalog &world, const Json &p, size_t index, int64_t factor) { const auto date = world.manifest().value("start_date", Json("2026-07-01")); std::vector active; if (valid_date(date)) for (const auto &c : world.rows("contracts")) { if (c.value("person", Json()) != p.at("id") || c.value("team", Json()) != p.value("team", Json())) continue; bool in_range = true; for (const auto *bound : {"start", "end"}) if (c.contains(bound) && (!valid_date(c.at(bound)) || (std::string(bound) == "start" ? date < c.at(bound) : date > c.at(bound)))) in_range = false; if (in_range) active.push_back(&c); } Json salary = nullptr; std::string source = "unavailable"; if (active.size() == 1) { const auto &c = *active[0]; if (c.contains("salary") && integer(c.at("salary"), 0, salary_cap * factor * 12)) { // OBW stores a season salary. The editable preview uses whole monthly // display units, rounded half up; no Classic initializer is invoked. const auto raw = c.at("salary").get(); const auto monthly = (raw + 6 * factor) / (12 * factor); salary = monthly * factor; source = "obw_season"; } else if (!c.contains("salary") && c.contains("initialization") && c.at("initialization").is_object()) { salary = (4500 + int64_t(index % 40) * 750) * factor; source = "demo"; } } return {{"salary", salary}, {"months", 24 + int(index % 3) * 12}, {"insurance", 0}, {"source", source}}; } Json default_finance() { return {{"term", 12}, {"properties", {1, 0, 0, 0, 0, 0}}, {"stocks", Json::array({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})}}; } Json default_balance(int64_t factor) { Json plan = Json::array(); for (const auto value : costs) plan.push_back(value * factor); return {{"plan", plan}}; } Json attribute(const Json &player, const char *key) { const auto found = player.find("attributes"); if (found == player.end() || !found->is_object()) return nullptr; const auto value = found->find(key); return value != found->end() && value->is_number() && std::isfinite(value->get()) ? *value : Json(nullptr); } std::string position(const Json &p) { const auto found = p.find("positions"); if (found == p.end() || !found->is_array()) return ""; if (std::find(found->begin(), found->end(), "gk") != found->end()) return "gk"; for (const auto &v : *found) if (v.is_string()) return v.get(); return ""; } Json age(const Json &player, const Json &state) { if (player.contains("birth_date") && valid_date(player.at("birth_date")) && state.contains("date") && valid_date(state.at("date"))) { const auto birth = player.at("birth_date").get(), today = state.at("date").get(); const int years = std::stoi(today.substr(0, 4)) - std::stoi(birth.substr(0, 4)) - (today.substr(5) < birth.substr(5) ? 1 : 0); return years >= 0 && years <= 100 ? Json(years) : Json(nullptr); } const auto initial = player.value("age_at_start", Json()); return integer(initial, 0, 100) ? initial : Json(nullptr); } std::string source_label(const std::string &source) { return source == "obw_season" ? "Monatsvorschau aus OBW-Saisongehalt · Laufzeit fiktiv" : source == "demo" ? "Fiktives Demogehalt · Laufzeit fiktiv" : source == "offer" ? "Lokales Demoangebot" : "Kein Gehalt überliefert · Laufzeit fiktiv"; } } // namespace int64_t finance_currency_factor(const Catalog &world) { const auto currency = world.manifest().value("currency", Json::object()); if (!currency.is_object()) throw editor::Error("unsupported_currency_precision"); const auto precision = currency.value("minor_units", Json(0)); if (!integer(precision, 0, 2) || precision == 1) throw editor::Error("unsupported_currency_precision"); return precision == 2 ? 100 : 1; } Json demo_contracts(const Catalog &world, const std::string &managed) { const auto club = own(world, managed); const auto factor = finance_currency_factor(world); Json players = Json::object(); size_t index = 0; if (!club.empty()) for (const auto *p : world.squad(club)) players[p->at("id").get()] = initial_contract(world, *p, index++, factor); return {{"club", club}, {"players", players}, {"bonuses", {0, 0, 0, 0, 0, 0, 0}}}; } bool valid_demo_finance(const Json &state, const Catalog &world, const std::string &managed) { try { if (!state.is_object()) return false; const auto factor = finance_currency_factor(world), cap = money_cap * factor; for (const auto *key : {"cash", "deposit", "debt"}) if (!state.contains(key) || !integer(state.at(key), 0, std::string(key) == "debt" ? debt_cap * factor : cap)) return false; if (state.contains("ticket") && !integer(state.at("ticket"), 0, 25)) return false; const auto &f = state.at("finance"), &b = state.at("balance"), &c = state.at("contracts"); if (!keys(f, {"term", "properties", "stocks"}) || !integer(f.at("term"), 6, 60) || f.at("term").get() % 6 || !list(f.at("properties"), 6, 0, 9999) || !list(f.at("stocks"), 12, 0, 9999) || !keys(b, {"plan"}) || !list(b.at("plan"), 11, 0, cap) || !keys(c, {"club", "players", "bonuses"}) || !c.at("club").is_string() || !c.at("players").is_object() || !list(c.at("bonuses"), 7, 0, 255)) return false; const auto club = own(world, managed, &state); const auto squad = club.empty() ? std::vector{} : world.squad(club); if (c.at("club") != club || c.at("players").size() != squad.size()) return false; for (const auto *p : squad) { const auto &v = c.at("players").at(p->at("id").get()); if (!keys(v, {"salary", "months", "insurance", "source"}) || !integer(v.at("months"), 1, 48) || !integer(v.at("insurance"), 0, 24) || !(v.at("insurance") == 0 || v.at("insurance") == 12 || v.at("insurance") == 24) || !v.at("source").is_string()) return false; const auto source = v.at("source").get(); if (source == "unavailable") { if (!v.at("salary").is_null()) return false; } else if ((source != "demo" && source != "obw_season" && source != "offer") || !integer(v.at("salary"), 0, salary_cap * factor)) return false; } return true; } catch (const std::exception &) { return false; } } bool migrate_demo_finance(Json &state, const Catalog &world, const std::string &managed) { try { if (!state.is_object()) return false; auto next = state; const auto factor = finance_currency_factor(world); if (!next.contains("finance")) next["finance"] = default_finance(); if (!next.contains("balance")) next["balance"] = default_balance(factor); if (!next.contains("contracts")) next["contracts"] = demo_contracts(world, own(world, managed, &state)); if (!valid_demo_finance(next, world, managed)) return false; state = std::move(next); return true; } catch (const std::exception &) { return false; } } Json demo_bank_terms() { return Json::array({6, 12, 18, 24, 30, 36, 42, 48, 54, 60}); } Json demo_bank_assets(const Catalog &world) { const auto factor = finance_currency_factor(world); Json properties = Json::array(), stocks = Json::array(); for (size_t i = 0; i < property_prices.size(); ++i) properties.push_back({{"index", i}, {"name", property_names[i]}, {"price", property_prices[i] * factor}}); for (size_t i = 0; i < stock_prices.size(); ++i) stocks.push_back({{"index", i}, {"name", stock_names[i]}, {"price", stock_prices[i] * factor}, {"previous", (stock_prices[i] - (int(i % 3) - 1) * 3) * factor}}); return {{"properties", properties}, {"stocks", stocks}}; } Json demo_bank_quote(const Json &state, const Json &request, const Catalog &world) { if (!valid_demo_finance(state, world)) return error("invalid_finance_state"); try { if (!request.is_object() || !request.contains("kind") || !request.at("kind").is_string()) return error("invalid_finance_action"); const auto kind = request.at("kind").get(); const bool property = kind == "property-buy" || kind == "property-sell"; const bool stock = kind == "stock-buy" || kind == "stock-sell"; const bool quantity = property || stock; if (!(quantity ? keys(request, {"kind", "index"}) : keys(request, {"kind"}))) return error("invalid_finance_action"); const auto factor = finance_currency_factor(world), cap = money_cap * factor; const auto cash = state.at("cash").get(), deposit = state.at("deposit").get(), debt = state.at("debt").get(); int64_t max = 0, price = factor; Json index = nullptr; if (quantity) { if (!integer(request.at("index"), 0, property ? 5 : 11)) return error("invalid_finance_action"); const auto i = request.at("index").get(); index = i; price = (property ? property_prices[i] : stock_prices[i]) * factor; const auto owned = state.at("finance").at(property ? "properties" : "stocks")[i].get(); max = kind.ends_with("buy") ? std::min(9999 - owned, cash / price) : std::min(owned, (cap - cash) / price); } else if (kind == "deposit") max = std::min(cash, cap - deposit) / factor; else if (kind == "withdraw") max = std::min(deposit, cap - cash) / factor; else if (kind == "loan") max = debt ? 0 : std::min(debt_cap * factor, cap - cash) / factor; else if (kind == "repay") max = std::min(cash, debt) / factor; else return error("unknown_finance_action"); return {{"ok", true}, {"kind", kind}, {"min", 1}, {"max", max}, {"quantity", quantity}, {"index", index}, {"unit_price", price}, {"step", quantity ? 1 : 100000}}; } catch (const std::exception &) { return error("invalid_finance_action"); } } std::string edit_demo_finance(Json &state, const Json &action, const Catalog &world, const std::string &managed) { if (!valid_demo_finance(state, world, managed)) return "invalid_finance_state"; try { if (!action.is_object() || !action.contains("kind") || !action.at("kind").is_string()) return "invalid_finance_action"; const auto kind = action.at("kind").get(); auto next = state; if (kind == "term") { if (!keys(action, {"kind", "value"}) || !integer(action.at("value"), 6, 60) || action.at("value").get() % 6 || state.at("debt") != 0) return "invalid_finance_value"; next["finance"]["term"] = action.at("value"); } else if (kind == "plan" || kind == "bonus") { if (!keys(action, {"kind", "index", "value"}) || !integer(action.at("index"), 0, kind == "plan" ? 10 : 6) || !integer(action.at("value"), 0, kind == "plan" ? money_cap : 255)) return "invalid_finance_value"; const auto i = action.at("index").get(); const auto value = action.at("value").get(); if (kind == "plan") { if (value % 1000) return "invalid_finance_value"; next["balance"]["plan"][i] = value * finance_currency_factor(world); } else next["contracts"]["bonuses"][i] = value; } else if (kind == "contract-offer" || kind == "insurance") { if (!(kind == "contract-offer" ? keys(action, {"kind", "player", "salary", "months"}) : keys(action, {"kind", "player", "value"})) || !action.at("player").is_string()) return "invalid_finance_action"; const auto id = action.at("player").get(); if (!state.at("contracts").at("players").contains(id)) return "invalid_finance_player"; auto &contract = next["contracts"]["players"][id]; if (kind == "contract-offer") { if (!integer(action.at("salary"), 0, salary_cap) || !integer(action.at("months"), 1, 48)) return "invalid_finance_value"; contract["salary"] = action.at("salary").get() * finance_currency_factor(world); contract["months"] = action.at("months"); contract["source"] = "offer"; } else { if (!integer(action.at("value"), 0, 24) || !(action.at("value") == 0 || action.at("value") == 12 || action.at("value") == 24)) return "invalid_finance_value"; contract["insurance"] = action.at("value"); } } else { const bool quantity = kind == "property-buy" || kind == "property-sell" || kind == "stock-buy" || kind == "stock-sell"; if (!(quantity ? keys(action, {"kind", "index", "value"}) : keys(action, {"kind", "value"}))) return "invalid_finance_action"; auto request = action; request.erase("value"); const auto quote = demo_bank_quote(state, request, world); if (!quote.value("ok", false)) return quote.at("error").get(); if (!integer(action.at("value"), 1, quote.at("max").get())) return "invalid_finance_value"; const auto value = action.at("value").get(), total = value * quote.at("unit_price").get(); const auto cash = state.at("cash").get(), deposit = state.at("deposit").get(), debt = state.at("debt").get(); if (kind == "deposit") { next["cash"] = cash - total; next["deposit"] = deposit + total; } else if (kind == "withdraw") { next["cash"] = cash + total; next["deposit"] = deposit - total; } else if (kind == "loan") { next["cash"] = cash + total; next["debt"] = total; } else if (kind == "repay") { next["cash"] = cash - total; next["debt"] = debt - total; } else { const bool buying = kind.ends_with("buy"), property = kind.starts_with("property-"); const auto i = action.at("index").get(); next["cash"] = cash + (buying ? -total : total); next["finance"][property ? "properties" : "stocks"][i] = state.at("finance").at(property ? "properties" : "stocks")[i].get() + (buying ? value : -value); } } if (!valid_demo_finance(next, world, managed)) return "invalid_finance_state"; state = std::move(next); return {}; } catch (const std::exception &) { return "invalid_finance_action"; } } Json demo_bank_summary(const Json &state, const Catalog &world) { if (!valid_demo_finance(state, world)) return error("invalid_finance_state"); const auto factor = finance_currency_factor(world); const auto cash = state.at("cash").get(), deposit = state.at("deposit").get(), debt = state.at("debt").get(); int64_t properties = 0, stocks = 0; for (size_t i = 0; i < property_prices.size(); ++i) properties += property_prices[i] * factor * state.at("finance").at("properties")[i].get(); for (size_t i = 0; i < stock_prices.size(); ++i) stocks += stock_prices[i] * factor * state.at("finance").at("stocks")[i].get(); const int64_t term = state.at("finance").at("term"), principal = debt ? debt : 1000000 * factor; const int64_t denominator = 150 * term * factor; const int64_t monthly = ((debt * (150 + term) + denominator - 1) / denominator) * factor; Json schedule = Json::array(); for (int month = 0; month <= term; ++month) schedule.push_back({{"month", month}, {"remaining", (principal * (term - month) + term / 2) / term}}); return {{"ok", true}, {"cash", cash}, {"deposit", deposit}, {"debt", debt}, {"properties", properties}, {"stocks", stocks}, {"net", cash + deposit + properties + stocks - debt}, {"term", term}, {"savings_rate", 2.5}, {"credit_rate", 8}, {"savings_interest", (deposit * 25 + 500) / 1000}, {"credit_interest", (debt * 8 + 50) / 100}, {"monthly_rate", monthly}, {"schedule_principal", principal}, {"schedule_example", debt == 0}, {"schedule", schedule}}; } Json demo_balance_rows(const Json &state, const Catalog &world) { if (!valid_demo_finance(state, world)) return error("invalid_finance_state"); const auto factor = finance_currency_factor(world); Json in = Json::array(), out = Json::array(), plan = Json::array(); int64_t sum_in = 0, sum_out = 0, sum_plan = 0; for (size_t i = 0; i < incomes.size(); ++i) { const auto value = incomes[i] * factor; in.push_back({{"name", income_names[i]}, {"amount", value}}); sum_in += value; } for (size_t i = 0; i < costs.size(); ++i) { const auto actual = costs[i] * factor, planned = state.at("balance").at("plan")[i].get(); out.push_back({{"name", cost_names[i]}, {"amount", actual}}); plan.push_back({{"name", cost_names[i]}, {"amount", planned}}); sum_out += actual; sum_plan += planned; } return {{"ok", true}, {"income", in}, {"costs", out}, {"plan", plan}, {"income_total", sum_in}, {"cost_total", sum_out}, {"plan_total", sum_plan}, {"balance", sum_in - sum_out}, {"cash", state.at("cash")}, {"ticket", state.value("ticket", 0) * factor}, {"league_home_games", 14}, {"other_home_games", 4}, {"attendance_average", 28450}}; } Json demo_contract_rows(const Json &state, const Catalog &world, const std::string &managed) { if (!valid_demo_finance(state, world, managed)) return error("invalid_finance_state"); const auto club = own(world, managed, &state); Json rows = Json::array(); int64_t total = 0, known = 0, unknown = 0; if (!club.empty()) for (const auto *p : world.squad(club)) { const auto &c = state.at("contracts").at("players").at(p->at("id").get()); if (c.at("salary").is_null()) ++unknown; else { const auto salary = c.at("salary").get(); if (total > std::numeric_limits::max() - salary) return error("finance_sum_overflow"); total += salary; ++known; } rows.push_back({{"id", p->at("id")}, {"name", world.name(*p)}, {"position", position(*p).empty() ? Json(nullptr) : Json(position(*p))}, {"age", age(*p, state)}, {"strength", attribute(*p, "strength")}, {"condition", attribute(*p, "condition")}, {"technique", attribute(*p, "technique")}, {"form", attribute(*p, "form")}, {"shoot", attribute(*p, "shooting")}, {"pass", attribute(*p, "passing")}, {"team", attribute(*p, "teamplay")}, {"games", attribute(*p, "games")}, {"grade", attribute(*p, "grade")}, {"positions", p->value("positions", Json::array())}, {"attributes", p->value("attributes", Json::object())}, {"birth_date", p->value("birth_date", Json())}, {"salary", c.at("salary")}, {"months", c.at("months")}, {"insurance", c.at("insurance")}, {"source", c.at("source")}, {"source_label", source_label(c.at("source").get())}}); } Json bonuses = Json::array(); for (size_t i = 0; i < bonus_names.size(); ++i) bonuses.push_back({{"name", bonus_names[i]}, {"value", state.at("contracts").at("bonuses")[i]}}); return {{"ok", true}, {"club", club}, {"rows", rows}, {"salary_total", known ? Json(total) : Json(nullptr)}, {"salary_known", known}, {"salary_unknown", unknown}, {"bonuses", bonuses}}; } } // namespace bmh::modern_ui