Port Bank, balance and contracts to the native Modern UI (by Codex)

This commit is contained in:
Codex committed 2026-10-24 10:12:59 +02:00
1 parent edd59db604
commit 2114598fba
33 files changed
+2688 -25

No files matched your search

+8 -2
View File
@@ -1,5 +1,5 @@
# SPDX-License-Identifier: GPL-3.0-only
add_library(bmh_modern_ui_core STATIC catalog.cpp model.cpp gui_assets.cpp desktop.cpp demo_sports.cpp demo_calendar.cpp demo_reports.cpp demo_almanac.cpp)
add_library(bmh_modern_ui_core STATIC catalog.cpp model.cpp gui_assets.cpp desktop.cpp demo_sports.cpp demo_calendar.cpp demo_reports.cpp demo_almanac.cpp demo_finance.cpp)
target_include_directories(bmh_modern_ui_core PUBLIC ../..)
target_link_libraries(bmh_modern_ui_core PUBLIC bmh_asset_io)
add_library(bmh_modern_ui STATIC view.cpp ticket_popover.cpp)
@@ -14,7 +14,7 @@ endif()
set(modern_assets "${CMAKE_BINARY_DIR}/assets/modern")
FetchContent_GetProperties(rmlui)
file(MAKE_DIRECTORY "${modern_assets}")
foreach(asset modern.rml theme.rcss ticket.rcss sports.rcss calendar.rcss reports.rcss report_details.rcss report_pickers.rcss indoor.rcss planning.rcss almanac.rcss)
foreach(asset modern.rml theme.rcss ticket.rcss sports.rcss calendar.rcss reports.rcss report_details.rcss report_pickers.rcss indoor.rcss planning.rcss almanac.rcss finance.rcss bank.rcss contracts.rcss amount.rcss)
configure_file("${CMAKE_SOURCE_DIR}/assets/modern/${asset}" "${modern_assets}/${asset}" COPYONLY)
endforeach()
file(GLOB modern_icons CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/assets/modern/icons/*.svg")
@@ -53,6 +53,12 @@ if(MSVC)
target_compile_options(modern_almanac_ui_tests PRIVATE /utf-8)
endif()
add_test(NAME modern_almanac_ui_tests COMMAND modern_almanac_ui_tests)
add_executable(modern_finance_ui_tests ../../../tests/modern_finance_ui_tests.cpp)
target_link_libraries(modern_finance_ui_tests PRIVATE bmh_modern_ui_core)
if(MSVC)
target_compile_options(modern_finance_ui_tests PRIVATE /utf-8)
endif()
add_test(NAME modern_finance_ui_tests COMMAND modern_finance_ui_tests)
add_executable(modern_reports_tests ../../../tests/modern_reports_tests.cpp)
target_link_libraries(modern_reports_tests PRIVATE bmh_modern_ui_core)
if(MSVC)
+277
View File
@@ -0,0 +1,277 @@
// SPDX-License-Identifier: GPL-3.0-only
std::optional<int64_t> App::amount_value() const {
if (!amount_ || amount_->raw.empty() || amount_->raw.size() > 8 ||
std::any_of(amount_->raw.begin(), amount_->raw.end(), [](char c) { return c < '0' || c > '9'; }))
return {};
return std::stoll(amount_->raw);
}
std::string App::amount_error() const {
if (!amount_) return {};
if (!amount_->error.empty()) return amount_->error;
const auto &r = amount_->request;
if (r.max < r.min) return "Derzeit ist kein Betrag oder Bestand verfügbar.";
const auto value = amount_value();
if (!value) return "Bitte eine ganze Zahl mit höchstens acht Ziffern eingeben.";
if (*value < r.min || *value > r.max)
return "Erlaubt: " + number(r.min) + " bis " + number(r.max) + (r.unit.empty() ? "" : " " + r.unit) + ".";
if ((*value - r.min) % r.step)
return "Bitte in Schritten von " + number(r.step) + " ab " + number(r.min) + " eingeben.";
return {};
}
void App::open_amount(AmountRequest request) {
if (!source_) return;
close_report_picker(false);
request.step = std::max<int64_t>(1, request.step);
request.suggestion_step = std::max<int64_t>(1, request.suggestion_step);
if (request.return_focus.empty() && context_->GetFocusElement())
request.return_focus = context_->GetFocusElement()->GetId();
amount_ = AmountDraft{std::move(request), {}, {}, menu_, false, snap().revision, world_};
amount_->raw = std::to_string(amount_->request.value);
amount_select_all_ = true;
amount_caret_end_ = false;
focus_after_render_ = "calculator-value";
refresh();
}
void App::close_amount(bool restore) {
if (!amount_) return;
const auto id = amount_->request.return_focus, menu = amount_->menu;
amount_.reset();
amount_select_all_ = false;
amount_caret_end_ = false;
if (restore && menu == menu_) focus_after_render_ = id;
refresh();
}
void App::update_amount(bool focus, bool select_all) {
if (!amount_ || amount_->review) return;
const auto error = amount_error();
if (auto *feedback = element("calculator-feedback")) {
feedback->SetInnerRML("<span>" + esc(error.empty()
? amount_->request.review ? "Nach „Übernehmen“ wird der Betrag noch einmal bestätigt." : "Erst „Übernehmen“ bestätigt den Wert."
: error) + "</span>");
feedback->SetClass("invalid", !error.empty());
}
if (auto *confirm = element("calculator-confirm")) {
if (error.empty()) confirm->RemoveAttribute("disabled");
else confirm->SetAttribute("disabled", true);
}
if (auto *input = dynamic_cast<Rml::ElementFormControlInput *>(element("calculator-value"))) {
if (input->GetValue() != amount_->raw) input->SetValue(amount_->raw);
if (focus) {
input->Focus(keyboard_navigation_);
if (select_all) input->Select();
else input->SetSelectionRange(int(amount_->raw.size()), int(amount_->raw.size()));
}
}
Rml::ElementList proposals;
if (auto *layer = element("number-calculator")) layer->QuerySelectorAll(proposals, ".amount-proposal");
const auto current = amount_value();
for (auto *button : proposals) {
const auto value = button->GetAttribute<int64_t>("data-value", -1);
button->SetClass("selected", current && *current == value);
button->SetAttribute("aria-pressed", current && *current == value ? "true" : "false");
}
dirty_ = true;
}
std::string App::render_amount() {
if (!amount_) return {};
const auto &r = amount_->request;
const auto button = [&](const std::string &action, const std::string &label,
const std::string &css, const std::string &attrs = "") {
return btn(action, esc(label), "amount-button " + css, attrs);
};
std::string out = "<div id=\"number-calculator\" class=\"amount-layer\">";
if (amount_->review) {
const auto value = amount_value().value_or(0);
const auto text = r.review_text ? r.review_text(value) : "Diesen Betrag übernehmen?";
return out + "<section class=\"amount-box amount-review\" role=\"dialog\" aria-modal=\"true\" aria-labelledby=\"calculator-review-title\">"
"<h2 id=\"calculator-review-title\">" + esc(r.title + " bestätigen") + "</h2><p>" + esc(text) +
"</p><strong>" + esc(number(value) + (r.unit.empty() ? "" : " " + r.unit)) + "</strong>" +
(amount_->error.empty() ? "" : "<p class=\"amount-review-error\">" + esc(amount_->error) + "</p>") +
"<footer class=\"amount-review-actions\">" +
button("calc-cancel", "Abbrechen", "", "id=\"calculator-cancel\"") +
button("calc-back", "Ändern", "", "id=\"calculator-back\"") +
button("calc-confirm", "Bestätigen", "amount-accept", "id=\"calculator-confirm\" " + std::string(amount_error().empty() ? "" : "disabled")) +
"</footer></section></div>";
}
out += "<section class=\"amount-box\" role=\"dialog\" aria-modal=\"true\" aria-labelledby=\"calculator-title\">"
"<header class=\"amount-header\">" + button("calc-cancel", "×", "amount-close", "id=\"calculator-close\" aria-label=\"Zahleneingabe schließen\"") +
"<h2 id=\"calculator-title\">" + esc(r.title) + "</h2></header><label class=\"amount-label\">" +
esc(r.unit == "Stück" ? "Stückzahl" : r.unit.empty() ? "Wert" : r.unit == "€" ? "Betrag in Euro" : "Betrag in " + r.unit) +
"</label><input type=\"text\" id=\"calculator-value\" maxlength=\"8\" value=\"" + esc(amount_->raw) +
"\" aria-label=\"" + esc(r.title) + "\"/><div class=\"amount-context\"><span class=\"amount-limit\"><span>" +
esc(number(r.min) + " – " + number(r.max) + (r.unit.empty() ? "" : " " + r.unit)) + "</span></span>" +
button("calc-clear", "C", "amount-clear", "id=\"calculator-clear\"") + button("calc-max", "MAX", "amount-max", "id=\"calculator-max\"") + "</div>";
const int64_t first = std::max<int64_t>(1, (r.min + r.suggestion_step - 1) / r.suggestion_step);
const auto value = amount_value();
for (int i = 0; i < 6; ++i) {
const int64_t proposal = (first + i) * r.suggestion_step;
const bool enabled = proposal >= r.min && proposal <= r.max && (proposal - r.min) % r.step == 0;
out += button("calc-preset", number(proposal), "amount-proposal" + std::string(value && *value == proposal ? " selected" : ""),
"id=\"calculator-preset-" + std::to_string(i) + "\" data-value=\"" + std::to_string(proposal) + "\" style=\"" +
rect(26 + (i % 2) * 388, 334 + (i / 2) * 74, 376, 64) + "\" " + (enabled ? "" : "disabled"));
}
const std::array<const char *, 12> keys = {"7","8","9","4","5","6","1","2","3","0","00","←"};
for (int i = 0; i < 12; ++i)
out += button("calc-digit", keys[size_t(i)], "amount-key", "id=\"calculator-key-" + std::to_string(i) + "\" data-id=\"" +
keys[size_t(i)] + "\" style=\"" + rect(26 + (i % 3) * 258, 566 + (i / 3) * 98, 248, 88) + "\"");
const auto error = amount_error();
out += "<p id=\"calculator-feedback\" class=\"amount-feedback " + std::string(error.empty() ? "" : "invalid") + "\"><span>" +
esc(error.empty() ? r.review ? "Nach „Übernehmen“ wird der Betrag noch einmal bestätigt." : "Erst „Übernehmen“ bestätigt den Wert." : error) +
"</span></p><div class=\"amount-actions\">" + button("calc-cancel", "Abbrechen", "", "id=\"calculator-cancel\"") +
button("calc-confirm", "Übernehmen", "amount-accept", "id=\"calculator-confirm\" " + std::string(error.empty() ? "" : "disabled"));
return out + "</div></section></div>";
}
bool App::amount_action(const std::string &action, Rml::Element *target) {
if (!action.starts_with("calc-")) return false;
if (!amount_) return true;
if (action == "calc-cancel") { close_amount(); return true; }
if (action == "calc-back") {
amount_->review = false;
focus_after_render_ = "calculator-value";
amount_select_all_ = false;
amount_caret_end_ = true;
refresh();
return true;
}
if (action == "calc-confirm") {
if (!amount_error().empty()) return true;
if (world_ != amount_->world || !source_ || snap().revision != amount_->revision) {
amount_->error = "Die Daten haben sich geändert. Bitte die Eingabe schließen und neu öffnen.";
if (amount_->review) refresh(); else update_amount();
return true;
}
if (amount_->request.review && !amount_->review) {
amount_->review = true;
focus_after_render_ = "calculator-confirm";
refresh();
return true;
}
const auto value = *amount_value();
auto accept = amount_->request.accept;
close_amount();
if (accept && !accept(value) && popup_.empty() && contracts_dialog_ != "notice")
message("Die Eingabe konnte nicht übernommen werden. Bitte den Dialog mit dem aktuellen Stand erneut öffnen.");
return true;
}
if (amount_->review) return true;
if (action == "calc-clear") amount_->raw = "0";
else if (action == "calc-max") amount_->raw = std::to_string(amount_->request.max);
else if (action == "calc-preset" && target) amount_->raw = target->GetAttribute<Rml::String>("data-value", "0");
else if (action == "calc-digit" && target) {
const auto digit = target->GetAttribute<Rml::String>("data-id", "");
int start = int(amount_->raw.size()), end = start;
if (auto *input = dynamic_cast<Rml::ElementFormControlInput *>(element("calculator-value"))) input->GetSelection(&start, &end, nullptr);
start = std::clamp(start, 0, int(amount_->raw.size()));
end = std::clamp(end, start, int(amount_->raw.size()));
if (digit == "←") {
if (start == end && start) --start;
amount_->raw.erase(size_t(start), size_t(end - start));
if (amount_->raw.empty()) amount_->raw = "0";
} else if ((digit.size() == 1 || digit == "00") && std::all_of(digit.begin(), digit.end(), [](char c) { return c >= '0' && c <= '9'; })) {
auto next = amount_->raw.substr(0, size_t(start)) + digit + amount_->raw.substr(size_t(end));
while (next.size() > 1 && next.front() == '0') next.erase(0, 1);
if (next.size() <= 8) amount_->raw = std::move(next);
}
} else return false;
update_amount(true);
return true;
}
bool App::amount_event(Rml::Event &event) {
if (!amount_ || !popup_.empty()) return false;
const auto type = event.GetType();
if (type == "contextmenu" || ((type == "mousedown" || type == "mouseup") && event.GetParameter<int>("button", 0) == 1)) {
event.StopImmediatePropagation(); return true;
}
bool inside = false;
for (auto *n = event.GetTargetElement(); n && n != doc_; n = n->GetParentNode()) if (n->GetId() == "number-calculator") inside = true;
const bool keyboard = type == "keydown";
const auto key = keyboard ? Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0)) : Rml::Input::KI_UNKNOWN;
if (keyboard && key == Rml::Input::KI_ESCAPE) { close_amount(); event.StopImmediatePropagation(); return true; }
if (keyboard && key == Rml::Input::KI_TAB) {
Rml::ElementList fields;
if (auto *layer = element("number-calculator")) layer->QuerySelectorAll(fields, "input,button");
std::erase_if(fields, [](auto *n) { return !n->IsVisible(true) || n->HasAttribute("disabled"); });
if (!fields.empty()) {
const auto at = std::find(fields.begin(), fields.end(), context_->GetFocusElement());
const int old = at == fields.end() ? -1 : int(at - fields.begin()), count = int(fields.size());
const bool back = event.GetParameter<int>("shift_key", 0) != 0;
const int next = old < 0 ? back ? count - 1 : 0 : (old + (back ? -1 : 1) + count) % count;
fields[size_t(next)]->Focus(true);
}
event.StopImmediatePropagation(); return true;
}
if (!inside) { if (type != "blur") event.StopImmediatePropagation(); return true; }
auto *target = event.GetTargetElement();
if ((type == "input" || type == "change") && target->GetId() == "calculator-value") {
if (!amount_->review) {
amount_->raw = dynamic_cast<Rml::ElementFormControlInput *>(target)->GetValue();
update_amount();
}
event.StopImmediatePropagation(); return true;
}
if (keyboard && !amount_->review && target->GetId() != "calculator-value" &&
!event.GetParameter<int>("ctrl_key", 0) && !event.GetParameter<int>("alt_key", 0) && !event.GetParameter<int>("meta_key", 0)) {
const int digit = key >= Rml::Input::KI_0 && key <= Rml::Input::KI_9 ? key - Rml::Input::KI_0
: key >= Rml::Input::KI_NUMPAD0 && key <= Rml::Input::KI_NUMPAD9 ? key - Rml::Input::KI_NUMPAD0 : -1;
if (digit >= 0 || key == Rml::Input::KI_BACK) {
const int keypad = digit < 0 ? 11 : digit == 0 ? 9 : (2 - (digit - 1) / 3) * 3 + (digit - 1) % 3;
if (auto *button = element("calculator-key-" + std::to_string(keypad))) amount_action("calc-digit", button);
event.StopImmediatePropagation(); return true;
}
}
if (keyboard && target->GetId() == "calculator-value" && (key == Rml::Input::KI_RETURN || key == Rml::Input::KI_NUMPADENTER)) {
amount_action("calc-confirm", target); event.StopImmediatePropagation(); return true;
}
if (type == "click" || (keyboard && (key == Rml::Input::KI_RETURN || key == Rml::Input::KI_NUMPADENTER || key == Rml::Input::KI_SPACE))) {
for (auto *node = target; node && node != doc_; node = node->GetParentNode())
if (node->HasAttribute("data-action")) {
if (!node->HasAttribute("disabled")) amount_action(node->GetAttribute<Rml::String>("data-action", ""), node);
event.StopImmediatePropagation(); return true;
}
}
return true; // Native text input retains its own default action; underlying menus do not see it.
}
bool App::amount_trigger_event(Rml::Event &event) {
if (amount_ || event.GetType() != "keydown") return false;
Rml::Element *trigger = nullptr;
for (auto *n = event.GetTargetElement(); n && n != doc_; n = n->GetParentNode())
if (n->IsClassSet("amount-trigger")) { trigger = n; break; }
if (!trigger || trigger->HasAttribute("disabled")) return false;
const auto key = Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0));
const bool modified = event.GetParameter<int>("ctrl_key", 0) || event.GetParameter<int>("meta_key", 0),
paste = modified && key == Rml::Input::KI_V;
const int digit = key >= Rml::Input::KI_0 && key <= Rml::Input::KI_9 ? key - Rml::Input::KI_0
: key >= Rml::Input::KI_NUMPAD0 && key <= Rml::Input::KI_NUMPAD9 ? key - Rml::Input::KI_NUMPAD0 : -1;
if (event.GetParameter<int>("alt_key", 0) || (modified && !paste) ||
(!paste && digit < 0 && key != Rml::Input::KI_RETURN && key != Rml::Input::KI_NUMPADENTER &&
key != Rml::Input::KI_SPACE && key != Rml::Input::KI_F4 && key != Rml::Input::KI_UP &&
key != Rml::Input::KI_DOWN && key != Rml::Input::KI_BACK && key != Rml::Input::KI_DELETE)) return false;
dispatch(trigger->GetAttribute<Rml::String>("data-action", ""), trigger);
if (amount_ && (digit >= 0 || paste)) {
if (paste) {
char *clipboard = SDL_GetClipboardText();
std::string raw = clipboard ? clipboard : "";
SDL_free(clipboard);
const auto first = raw.find_first_not_of(" \r\n\t"), last = raw.find_last_not_of(" \r\n\t");
raw = first == std::string::npos ? "" : raw.substr(first, last - first + 1);
if (raw.ends_with("€")) raw.resize(raw.size() - std::string("€").size());
while (!raw.empty() && raw.back() == ' ') raw.pop_back();
bool grouping = raw.find('.') != std::string::npos;
size_t start = 0, group = 0;
while (grouping && start < raw.size()) {
const auto dot = raw.find('.', start), end = dot == std::string::npos ? raw.size() : dot;
const auto length = end - start;
grouping = length > 0 && (group == 0 ? length <= 3 : length == 3) &&
std::all_of(raw.begin() + start, raw.begin() + end, [](char c) { return c >= '0' && c <= '9'; });
start = end + 1; ++group;
}
if (grouping && !raw.ends_with('.')) std::erase(raw, '.');
amount_->raw = std::move(raw);
} else amount_->raw = std::to_string(digit);
amount_select_all_ = false;
amount_caret_end_ = true;
}
event.StopImmediatePropagation();
return true;
}
+162
View File
@@ -0,0 +1,162 @@
// SPDX-License-Identifier: GPL-3.0-only
bool App::bank_action(const std::string &action, Rml::Element *target) {
if (menu_ != "bank" || !source_ || !world_) return false;
if (action == "close") {
if (bank_view_ == "entrance") return false;
bank_view_ = "entrance";
bank_hint_.clear();
focus_after_render_ = "window-close";
refresh();
return true;
}
if (action == "bank-view" && target) {
const auto view = target->GetAttribute<Rml::String>("data-view", "");
if (view != "properties" && view != "stocks" && view != "overview" && view != "savings" && view != "credit") return true;
bank_view_ = view;
bank_hint_.clear();
focus_after_render_ = "window-close";
refresh();
return true;
}
if (action == "property-next") {
if (bank_view_ != "properties") return true;
bank_property_ = (bank_property_ + 1) % 6;
focus_after_render_ = "property-next";
refresh();
return true;
}
if (action == "property-owned-next") {
if (bank_view_ != "properties") return true;
const auto state = snap().state;
for (int step = 1; step <= 6; ++step) {
const int next = (bank_owned_ + step) % 6;
if (state.at("finance").at("properties")[size_t(next)] != 0) { bank_owned_ = next; break; }
}
focus_after_render_ = "property-owned-next";
refresh();
return true;
}
if (action == "bank-stock" && target) {
const auto index = target->GetAttribute<int>("data-id", -1);
if (bank_view_ != "stocks" || index < 0 || index > 11) return true;
bank_stock_ = index;
focus_after_render_ = "bank-stock-" + std::to_string(index);
refresh();
return true;
}
if (action != "bank-calc" || !target) return false;
const auto kind = target->GetAttribute<Rml::String>("data-kind", "");
const bool property = kind == "property-buy" || kind == "property-sell";
const bool stock = kind == "stock-buy" || kind == "stock-sell";
if ((property && bank_view_ != "properties") || (stock && bank_view_ != "stocks") ||
((kind == "deposit" || kind == "withdraw") && bank_view_ != "savings") ||
((kind == "loan" || kind == "repay") && bank_view_ != "credit")) return true;
const auto snapshot = snap();
Json quote_request = {{"kind", kind}};
if (property) quote_request["index"] = kind == "property-buy" ? bank_property_ : bank_owned_;
if (stock) quote_request["index"] = bank_stock_;
const auto quote = demo_bank_quote(snapshot.state, quote_request, *world_);
if (!quote.value("ok", false)) return true;
const auto world = world_;
const auto *source = source_.get();
const auto view = bank_view_;
const auto revision = snapshot.revision;
const auto unit_price = quote.at("unit_price").get<int64_t>();
AmountRequest request;
const std::map<std::string, std::string> titles{{"deposit", "Einzahlen"}, {"withdraw", "Abheben"},
{"loan", "Kredit aufnehmen"}, {"repay", "Kredit tilgen"}, {"property-buy", "Immobilien kaufen"},
{"property-sell", "Immobilien verkaufen"}, {"stock-buy", "Aktien kaufen"}, {"stock-sell", "Aktien verkaufen"}};
request.title = titles.at(kind);
request.unit = property || stock ? "Stück" : money_unit();
request.return_focus = target->GetId();
request.value = 0;
request.min = quote.at("min");
request.max = quote.at("max");
request.step = 1;
request.suggestion_step = quote.at("step");
request.review = true;
if (property || stock) request.review_text = [world, unit_price](int64_t count) {
return "Gesamtbetrag: " + money(count * unit_price, world->manifest().value("currency", Json::object()));
};
request.accept = [this, world, source, view, revision, quote_request, kind](int64_t value) {
if (world != world_ || source != source_.get() || menu_ != "bank" || bank_view_ != view) return false;
auto action = quote_request;
action["value"] = value;
const bool accepted = commit_finance(action, revision);
if (accepted && kind == "property-buy") {
bank_owned_ = quote_request.at("index").get<int>();
refresh();
}
return accepted;
};
open_amount(std::move(request));
return true;
}
bool App::bank_event(Rml::Event &event) {
if (menu_ != "bank" || !source_ || amount_ || !popup_.empty()) return false;
const auto type = event.GetType();
auto *target = event.GetTargetElement();
const bool keyboard = type == "keydown";
const auto key = keyboard ? Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0)) : Rml::Input::KI_UNKNOWN;
if (bank_view_ != "entrance" && ((keyboard && key == Rml::Input::KI_ESCAPE) ||
(type == "mouseup" && event.GetParameter<int>("button", 0) == 1))) {
if (keyboard)
if (auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(element("bank-term"));
select && select->IsSelectBoxVisible()) {
select->CancelSelectBox();
select->Focus(true);
dirty_ = true;
event.StopImmediatePropagation();
return true;
}
bank_action("close", nullptr);
event.StopImmediatePropagation();
return true;
}
if (type == "contextmenu" && bank_view_ != "entrance") { event.StopImmediatePropagation(); return true; }
if (type == "click" && bank_view_ != "entrance")
for (auto *node = target; node && node != doc_; node = node->GetParentNode())
if (node->GetAttribute<Rml::String>("data-action", "") == "close") {
bank_action("close", node);
event.StopImmediatePropagation();
return true;
}
if (type == "change" && target->GetId() == "bank-term") {
auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(target);
if (!select || bank_view_ != "credit" || snap().state.at("debt") != 0) return true;
const auto raw = select->GetValue();
if (raw.empty() || raw.size() > 2 || raw.find_first_not_of("0123456789") != raw.npos) return true;
const int value = std::stoi(raw);
if (value < 6 || value > 60 || value % 6) return true;
// Initializing a native select may emit change; opening a view is read-only.
if (snap().state.at("finance").at("term") == value) {
event.StopImmediatePropagation();
return true;
}
focus_after_render_ = "bank-term";
commit_finance({{"kind", "term"}, {"value", value}}, snap().revision);
event.StopImmediatePropagation();
return true;
}
if (bank_view_ == "entrance" && (type == "mousemove" || type == "focus")) {
const auto hint = [&](Rml::Element *from) {
for (auto *node = from; node && node != doc_; node = node->GetParentNode())
if (node->HasAttribute("data-bank-hint")) return node->GetAttribute<Rml::String>("data-bank-hint", "");
return Rml::String();
};
auto text = hint(target);
// RmlUI dispatches focus to the whole new ancestor chain before updating
// Context's focus pointer. Ancestor notifications must not erase a hint
// just supplied by the actual hotspot. The close button resets it.
if (type == "focus" && text.empty() && target->GetId() != "window-close") return false;
if (type == "mousemove" && text.empty()) text = hint(context_->GetFocusElement());
if (bank_hint_ != text) {
bank_hint_ = text;
if (auto *label = element("bank-interaction-hint"))
label->SetInnerRML("<span>" + esc(text.empty() ? "Ein Element in der Bankhalle auswählen." : text) + "</span>");
dirty_ = true;
}
}
return false;
}
+149
View File
@@ -0,0 +1,149 @@
// SPDX-License-Identifier: GPL-3.0-only
std::string App::render_bank() {
const auto snapshot = snap();
const auto assets = demo_bank_assets(*world_);
const auto summary = demo_bank_summary(snapshot.state, *world_);
if (!summary.value("ok", false)) return {};
const auto &finance = snapshot.state.at("finance");
bank_property_ = std::clamp(bank_property_, 0, 5);
bank_stock_ = std::clamp(bank_stock_, 0, 11);
bank_owned_ = std::clamp(bank_owned_, 0, 5);
if (finance.at("properties")[size_t(bank_owned_)] == 0)
for (int i = 0; i < 6; ++i)
if (finance.at("properties")[size_t(i)] != 0) { bank_owned_ = i; break; }
const auto actions = [&](const char *left, const char *lk, const char *right, const char *rk) {
return "<nav class=\"bank-actions\">" +
btn("bank-calc", left, "bank-control", "id=\"bank-" + std::string(lk) + "\" data-kind=\"" + lk + "\"") +
btn("bank-calc", right, "bank-control", "id=\"bank-" + std::string(rk) + "\" data-kind=\"" + rk + "\"") + "</nav>";
};
std::string out = "<div class=\"bank-page\"><div class=\"bank-scene\">" +
img("art.bank-hall-v1.png", 2608, 1466.016746, false, false, 3000);
if (bank_view_ == "entrance") {
struct Service { const char *id, *label, *hint; double x, y, w, h; };
const std::array<Service, 5> services{{
{"properties", "Immobilien", "Immobilien – Gebäude ansehen, kaufen oder verkaufen.", .5, 18.5, 17.5, 43.5},
{"stocks", "Aktien", "Aktien – Kurse und Bestände ansehen, Aktien kaufen oder verkaufen.", 30, 30, 13.5, 19.5},
{"overview", "Finanzübersicht", "Finanzübersicht – Konto, Sparbuch, Immobilien, Aktien und Kredit im Überblick.", 30.5, 49.5, 13, 14.5},
{"savings", "Sparbuch", "Sparbuch – Guthaben ansehen, Geld einzahlen oder abheben.", 85, 60, 6.5, 7.5},
{"credit", "Kredit", "Kredit – Laufzeit wählen, einen Kredit aufnehmen oder tilgen.", 85.3, 31.5, 13.7, 27.5}}};
out += "<div class=\"bank-hotspots\">";
for (const auto &s : services)
out += btn("bank-view", "", "bank-hotspot", "id=\"bank-view-" + std::string(s.id) +
"\" data-view=\"" + s.id + "\" data-bank-hint=\"" + esc(s.hint) + "\" aria-label=\"" + s.label +
"\" style=\"left:" + scalar(s.x) + "%;top:" + scalar(s.y) + "%;width:" + scalar(s.w) + "%;height:" + scalar(s.h) + "%;\"");
out += "</div>";
}
out += "</div>";
if (bank_view_ == "entrance")
return out + "<p id=\"bank-interaction-hint\" role=\"status\" aria-live=\"polite\"><span>" +
esc(bank_hint_.empty() ? "Ein Element in der Bankhalle auswählen." : bank_hint_) + "</span></p></div>";
out += "<section class=\"bank-overlay " + esc(bank_view_) + "-overlay\">";
if (bank_view_ == "savings") {
out += "<div class=\"passbook\">" + img("art.bank-passbook-v1.png", 2100, 1293.109375, false, false, 2400) +
"<div class=\"passbook-left\"><h2>Waldpark Bank</h2><h3>Sparbuch</h3><p class=\"passbook-note-one\">Bitte beachten Sie:</p>"
"<p class=\"passbook-note-two\">Einzahlungen und Abhebungen werden hier als fiktive Vorschau verbucht.</p>"
"<p class=\"passbook-note-three\">2,5 % Beispielzins</p></div><div class=\"passbook-right\"><h2>Guthaben</h2><output>" +
esc(cash(snapshot.state.at("deposit").get<int64_t>())) + "</output></div></div>" + actions("Einzahlen", "deposit", "Abheben", "withdraw");
} else if (bank_view_ == "properties") {
out += "<h2>Immobilien</h2>";
const auto &owned = assets.at("properties")[size_t(bank_owned_)], &offer = assets.at("properties")[size_t(bank_property_)];
const auto count = finance.at("properties")[size_t(bank_owned_)].get<int64_t>();
out += "<div class=\"property-row owned-property\"><div class=\"property-description\"><h3>Ihre Immobilien</h3>" +
(count ? "<p>" + std::to_string(count) + " × " + esc(owned.at("name").get<std::string>()) + "</p><p>Wert: " +
esc(cash(count * owned.at("price").get<int64_t>())) + "</p>" : "<p>Keine Immobilien im Bestand</p>") +
"</div>" + btn("property-owned-next", count ? img("bank.property." + std::to_string(bank_owned_), 996, 566, false, false, 1200)
: "<span class=\"property-empty\"></span>", "property-picture", "id=\"property-owned-next\" aria-label=\"Nächste eigene Immobilie\" " + std::string(count ? "" : "disabled")) + "</div>";
out += "<div class=\"property-row offered-property\"><div class=\"property-description\"><h3>Kaufangebot</h3><p>" +
esc(offer.at("name").get<std::string>()) + "</p><p>Kaufpreis: " + esc(cash(offer.at("price").get<int64_t>())) +
"</p></div>" + btn("property-next", img("bank.property." + std::to_string(bank_property_), 996, 566, false, false, 1200),
"property-picture", "id=\"property-next\" aria-label=\"Nächstes Immobilienangebot\"") + "</div>" +
actions("Kaufen", "property-buy", "Verkaufen", "property-sell");
} else if (bank_view_ == "stocks") {
out += "<h2>Aktien</h2><div class=\"stock-table\"><div class=\"stock-row stock-head\">";
for (const auto *label : {"Wert", "Kurs", "Vortag", "Bestand"}) out += "<div><span>" + std::string(label) + "</span></div>";
out += "</div>";
const auto factor = finance_currency_factor(*world_);
for (int i = 0; i < 12; ++i) {
const auto &s = assets.at("stocks")[size_t(i)];
out += "<div class=\"stock-row\"><div>" + btn("bank-stock", esc(s.at("name").get<std::string>()), "stock-name",
"id=\"bank-stock-" + std::to_string(i) + "\" data-bank-stock=\"" + std::to_string(i) + "\" data-id=\"" + std::to_string(i) +
"\" aria-pressed=\"" + (i == bank_stock_ ? "true" : "false") + "\"") + "</div><div><span>" +
number(s.at("price").get<int64_t>() / factor) + "</span></div><div><span>" + number(s.at("previous").get<int64_t>() / factor) +
"</span></div><div><span>" + number(finance.at("stocks")[size_t(i)].get<int64_t>()) + "</span></div></div>";
}
const double price = assets.at("stocks")[size_t(bank_stock_)].at("price").get<double>() / factor;
std::array<double, 30> history{};
for (int i = 0; i < 30; ++i) history[size_t(i)] = price * (.85 + .08 * std::sin(i * .6 + bank_stock_) + i * .003);
const double lo = *std::min_element(history.begin(), history.end()) * .95, hi = *std::max_element(history.begin(), history.end()) * 1.05;
std::string points;
for (int i = 0; i < 30; ++i) points += scalar(20 + i * 690. / 29) + "," + scalar(900 - (history[size_t(i)] - lo) / (hi - lo) * 830) + " ";
const auto stroke = theme_ == "silver" ? "#526779" : theme_ == "matchday" ? "#b7b4b9" : "#9ac7d8";
const auto axis = theme_ == "silver" ? "#526779" : theme_ == "matchday" ? "#b7b4b9" : "#6c8798";
const auto svg = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"740\" height=\"1320\" viewBox=\"0 0 740 950\">"
"<path d=\"M10 10V930H730\" fill=\"none\" stroke=\"" + std::string(axis) + "\" stroke-width=\"5\"/>"
"<polyline points=\"" + points + "\" fill=\"none\" stroke=\"" + stroke + "\" stroke-width=\"9\"/></svg>";
out += "</div><div class=\"stock-chart\" role=\"img\" aria-label=\"Erfundener Kursverlauf für " +
esc(assets.at("stocks")[size_t(bank_stock_)].at("name").get<std::string>()) + "\">" +
picture(renderer_.diagram("bank-stock", svg, 1600), 740, 1320) + "</div>" + actions("Kaufen", "stock-buy", "Verkaufen", "stock-sell");
} else if (bank_view_ == "credit") {
out += "<h2>Kredit</h2><div class=\"credit-portrait\">" + img("art.bank-adviser-v1.png", 620, 515, false, false, 1000) +
"</div><div class=\"credit-facts\">";
const auto fact = [&](const char *label, const std::string &value, int row) {
constexpr std::array<int, 5> y{0, 83, 166, 273, 356};
return "<div class=\"credit-fact\" style=\"top:" + std::to_string(y[size_t(row)]) + "dp;\"><span>" + label + "</span><strong>" + value + "</strong></div>";
};
out += fact("Restschuld", esc(cash(summary.at("debt").get<int64_t>())), 0) + fact("Beispielzins", "8 % pro Jahr", 1);
std::string select = "<select id=\"bank-term\" aria-label=\"Kreditlaufzeit\" " + std::string(summary.at("debt") == 0 ? "" : "disabled") + ">";
for (const auto &term : demo_bank_terms()) select += "<option value=\"" + std::to_string(term.get<int>()) + "\" " +
std::string(term == finance.at("term") ? "selected" : "") + ">" + std::to_string(term.get<int>()) + " Monate</option>";
out += fact("Laufzeit", select + "</select>", 2) + fact("Monatsrate, Beispiel", esc(cash(summary.at("monthly_rate").get<int64_t>())), 3) +
fact("Maximaler Kredit", esc(cash(5000000 * finance_currency_factor(*world_))), 4) + "</div>";
const int term = finance.at("term");
const auto principal = summary.at("schedule_principal").get<int64_t>();
const auto color = theme_ == "silver" ? "#233443" : theme_ == "matchday" ? "#efeded" : "#a8c0cf";
const auto accent = theme_ == "silver" ? "#25617a" : theme_ == "matchday" ? "#efb2aa" : "#a9dfd1";
const auto grid_color = theme_ == "silver" ? "#58738c38" : "#b7d0de24";
std::string svg = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"2240\" height=\"420\" viewBox=\"0 0 2240 420\">"
"<defs><linearGradient id=\"fill\" x1=\"0\" y1=\"0\" x2=\"0\" y2=\"1\"><stop offset=\"0\" stop-color=\"#9ddbd1\" stop-opacity=\".23\"/>"
"<stop offset=\"1\" stop-color=\"#9ddbd1\" stop-opacity=\".01\"/></linearGradient></defs>";
for (int i = 0; i < 5; ++i) {
const auto y = 30 + i * 77.5;
svg += "<line x1=\"220\" y1=\"" + scalar(y) + "\" x2=\"2180\" y2=\"" + scalar(y) + "\" stroke=\"" + grid_color + "\" stroke-width=\"2\"/>"
"<text x=\"184\" y=\"" + scalar(y + 9) + "\" text-anchor=\"end\" fill=\"" + color + "\" font-size=\"28\" font-family=\"Arial, Liberation Sans, sans-serif\">" +
esc(cash((principal * (4 - i) + 2) / 4)) + "</text>";
}
const int interval = term <= 12 ? 3 : term <= 24 ? 6 : 12;
std::vector<int> labels;
for (int month = 0; month <= term; month += interval) labels.push_back(month);
if (labels.back() != term) labels.push_back(term);
for (const int month : labels) {
svg += "<text x=\"" + scalar(220 + double(month) / term * 1960) + "\" y=\"394\" text-anchor=\"" +
std::string(month == 0 ? "start" : month == term ? "end" : "middle") + "\" fill=\"" + color +
"\" font-size=\"28\" font-family=\"Arial, Liberation Sans, sans-serif\">" + (month == 0 ? "Heute" : std::to_string(month) + (month == term ? " Monate" : "")) + "</text>";
}
std::string points;
for (const auto &point : summary.at("schedule")) points += scalar(220 + point.at("month").get<double>() / term * 1960) + "," +
scalar(340 - point.at("remaining").get<double>() / principal * 310) + " ";
svg += "<path d=\"M220 340 L220 30 L2180 340 Z\" fill=\"url(#fill)\"/><polyline points=\"" + points + "\" fill=\"none\" stroke=\"" +
accent + "\" stroke-width=\"6\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><circle cx=\"220\" cy=\"30\" r=\"7\" fill=\"#c1ecdf\" stroke=\"#294553\" stroke-width=\"4\"/>"
"<circle cx=\"2180\" cy=\"340\" r=\"7\" fill=\"#c1ecdf\" stroke=\"#294553\" stroke-width=\"4\"/></svg>";
out += "<figure class=\"credit-schedule\"><div class=\"credit-schedule-caption\"><h3>Restschuld über die Laufzeit</h3><p class=\"credit-schedule-amount\">" +
esc(cash(principal)) + " <span>→</span> " + esc(cash(0)) + "</p><div class=\"credit-schedule-context\"><span>" + std::to_string(term) +
" Monate</span><p>" + (summary.at("schedule_example") == true ? "Beispiel · kein laufender Kredit" : "Aktueller Kredit") +
"</p></div></div><div class=\"credit-chart\" role=\"img\" aria-label=\"Restschuld über " + std::to_string(term) +
" Monate bei gleichmäßiger Tilgung ohne Zinsen\">" + picture(renderer_.diagram("bank-credit", svg, 2400), 2432, 420) +
"</div><p class=\"credit-schedule-note\">Gleichmäßige monatliche Tilgung · Restschuld ohne Zinsen</p></figure>"
"<p class=\"bank-note credit-note\">Fiktiver Kredit. Im POC erfolgen keine Zins- oder Ratenbuchungen.</p>" + actions("Aufnehmen", "loan", "Tilgen", "repay");
} else if (bank_view_ == "overview") {
out += "<h2>Finanzübersicht</h2><div class=\"bank-overview\">";
const std::array<std::pair<const char *, int64_t>, 6> fields{{
{"Konto", summary.at("cash")}, {"Sparbuch", summary.at("deposit")},
{"Immobilien", summary.at("properties")}, {"Aktien", summary.at("stocks")},
{"Kredit", -summary.at("debt").get<int64_t>()}, {"Saldo", summary.at("net")}}};
for (size_t i = 0; i < fields.size(); ++i)
out += "<div class=\"bank-overview-row " + std::string(i == 5 ? "bank-overview-total" : "") + "\"><span>" +
fields[i].first + "</span><strong>" + (i == 4 ? "-" + esc(cash(summary.at("debt").get<int64_t>())) : esc(cash(fields[i].second))) + "</strong></div>";
out += "</div><p class=\"bank-note overview-note\">Erfundene Bestände · Änderungen betreffen ausschließlich die Bankvorschau.</p>";
}
return out + "</section></div>";
}
+262
View File
@@ -0,0 +1,262 @@
// SPDX-License-Identifier: GPL-3.0-only
void App::close_contracts(bool focus) {
auto restore = contracts_return_focus_;
if (focus && !restore.empty()) {
const auto snapshot = snap();
const auto club = contracts_text(contracts_field(contract_draft_, "club"), "");
if ((contracts_world_ && snapshot.world != contracts_world_) ||
(!club.empty() && contracts_managed(snapshot) != club) ||
(restore.starts_with("contract-player-") &&
!contracts_row(contracts_projection(snapshot), contracts_player_).is_object()))
restore = "contracts-tab-" + std::to_string(contracts_tab_);
focus_after_render_ = restore;
}
contract_draft_ = Json();
contracts_dialog_.clear();
contracts_notice_.clear();
contracts_return_focus_.clear();
contracts_world_.reset();
contracts_revision_ = 0;
refresh();
}
bool App::contracts_action(const std::string &action, Rml::Element *target) {
if (menu_ != "contracts") return false;
constexpr std::array<std::string_view, 10> actions = {"contracts-tab", "contract-player", "contract-close",
"contract-term", "contract-salary", "contract-submit", "contract-insurance",
"contract-insure", "contracts-bonuses", "contract-bonus"};
if (std::find(actions.begin(), actions.end(), action) == actions.end()) return false;
const auto id = target ? target->GetAttribute<Rml::String>("data-id", "") : std::string();
const auto integer_id = [&]() -> std::optional<int> {
if (id.empty() || id.size() > 3 ||
std::any_of(id.begin(), id.end(), [](char c) { return c < '0' || c > '9'; })) return {};
return std::stoi(id);
};
const auto reject = [&](const std::string &text) {
contract_draft_ = {{"notice_title", "Nicht übernommen"},
{"club", contracts_text(contracts_field(contract_draft_, "club"), "")}};
contracts_notice_ = text;
contracts_dialog_ = "notice";
focus_after_render_ = "contract-close";
refresh();
};
const auto bound = [&](bool player) {
return contracts_bound(snap(), contracts_revision_, contracts_world_,
contracts_text(contracts_field(contract_draft_, "club"), ""), player ? contracts_player_ : "");
};
if (action == "contract-close") {
close_contracts(true);
return true;
}
if (action == "contracts-tab") {
const auto tab = integer_id();
if (!contracts_dialog_.empty() || !tab || *tab > 2) return true;
contracts_tab_ = *tab;
focus_after_render_ = "contracts-tab-" + std::to_string(*tab);
refresh();
return true;
}
if (action == "contract-player" || action == "contracts-bonuses") {
if (!contracts_dialog_.empty()) return true;
const auto snapshot = snap();
const auto projection = contracts_projection(snapshot);
if (!snapshot.world || !projection.value("ok", false)) return true;
const auto row = action == "contract-player" ? contracts_row(projection, id) : Json();
if (action == "contract-player" && !row.is_object()) return true;
contracts_world_ = snapshot.world;
contracts_revision_ = snapshot.revision;
contracts_return_focus_ = target ? target->GetId() : "contracts-bonuses";
contracts_notice_.clear();
contract_draft_ = {{"club", projection.at("club")}};
if (action == "contracts-bonuses") {
contracts_player_.clear();
contract_draft_["bonuses"] = projection.at("bonuses");
contracts_dialog_ = "bonuses";
focus_after_render_ = "contract-bonus-0";
} else {
contracts_player_ = id;
const auto factor = finance_currency_factor(*snapshot.world);
const auto &salary = contracts_field(row, "salary");
contract_draft_["row"] = row;
// The editor and the finance action both use whole display units. The
// source alone multiplies the accepted value by its currency factor.
contract_draft_["salary"] = salary.is_number_integer()
? Json(salary.get<int64_t>() / factor) : Json();
contract_draft_["months"] = contracts_field(row, "months");
contracts_dialog_ = "offer";
focus_after_render_ = "contract-term-12";
}
refresh();
return true;
}
if (action == "contract-term") {
const auto term = integer_id();
if (contracts_dialog_ != "offer" || !term ||
!(*term == 12 || *term == 24 || *term == 36 || *term == 48)) return true;
contract_draft_["months"] = *term;
focus_after_render_ = "contract-term-" + std::to_string(*term);
refresh();
return true;
}
if (action == "contract-salary") {
if (contracts_dialog_ != "offer" || !contracts_world_) return true;
const auto player = contracts_player_;
const auto world = contracts_world_;
const auto revision = contracts_revision_;
const auto &value = contracts_field(contract_draft_, "salary");
AmountRequest request;
const auto unit = money_unit();
request.title = "Angebotenes Monatsgehalt in " + (unit == "€" ? std::string("Euro") : unit);
request.unit = unit;
request.return_focus = "contract-salary";
request.value = value.is_number_integer() ? value.get<int64_t>() : 0;
request.min = 0;
request.max = 200000;
request.step = 1;
request.suggestion_step = 5000;
request.review = true;
request.accept = [this, player, world, revision](int64_t amount) {
if (menu_ != "contracts" || contracts_dialog_ != "offer" ||
contracts_player_ != player || contracts_world_ != world ||
contracts_revision_ != revision || amount < 0 || amount > 200000) return false;
contract_draft_["salary"] = amount;
refresh();
return true;
};
open_amount(std::move(request));
return true;
}
if (action == "contract-insurance") {
if (contracts_dialog_ != "offer") return true;
if (!bound(true)) {
reject("Der Vertragsstand hat sich geändert. Bitte den Spieler erneut auswählen.");
return true;
}
// Opening insurance discards the proposal. Cancelling it returns to the
// roster, never to the previous salary or term draft.
const auto row = contract_draft_.at("row"), club = contract_draft_.at("club");
contract_draft_ = {{"row", row}, {"club", club}};
contracts_dialog_ = "insurance";
focus_after_render_ = "contract-insure-0";
refresh();
return true;
}
if (action == "contract-submit" || action == "contract-insure") {
const bool offer = action == "contract-submit";
if (contracts_dialog_ != (offer ? "offer" : "insurance")) return true;
if (!bound(true)) {
reject("Der Vertragsstand hat sich geändert. Bitte den Spieler erneut auswählen.");
return true;
}
Json payload;
if (offer) {
const auto &salary = contracts_field(contract_draft_, "salary");
const auto &months = contracts_field(contract_draft_, "months");
if (!salary.is_number_integer() || salary < 0 || salary > 200000 ||
!months.is_number_integer() || months < 1 || months > 48) return true;
payload = {{"kind", "contract-offer"}, {"player", contracts_player_},
{"salary", salary}, {"months", months}};
} else {
const auto duration = integer_id();
if (!duration || !(*duration == 0 || *duration == 12 || *duration == 24)) return true;
payload = {{"kind", "insurance"}, {"player", contracts_player_}, {"value", *duration}};
}
const auto result = source_->apply({contracts_revision_, "finance", payload});
if (!result.ok) {
reject("Die Änderung konnte nicht übernommen werden. Bitte die Vertragsdaten erneut öffnen.");
return true;
}
if (!offer) {
close_contracts(true);
return true;
}
const auto row = contract_draft_.at("row");
const auto salary = contract_draft_.at("salary").get<int64_t>();
const auto months = contract_draft_.at("months").get<int>();
const auto club = contract_draft_.at("club");
const auto factor = finance_currency_factor(*contracts_world_);
contracts_notice_ = contracts_text(contracts_field(row, "name")) + " · " +
contracts_money(Json(salary * factor), *contracts_world_) + " · " + std::to_string(months) + " Monate";
contract_draft_ = {{"notice_title", "Vertrag vorgemerkt"}, {"club", club}};
contracts_revision_ = result.revision;
contracts_dialog_ = "notice";
focus_after_render_ = "contract-close";
refresh();
return true;
}
if (action == "contract-bonus") {
const auto index = integer_id();
if (contracts_dialog_ != "bonuses" || !index || *index > 6 || !contracts_world_) return true;
const auto &bonuses = contracts_field(contract_draft_, "bonuses");
if (!bonuses.is_array() || size_t(*index) >= bonuses.size()) return true;
const auto bonus = bonuses[size_t(*index)];
const auto world = contracts_world_;
const auto revision = contracts_revision_;
const auto club = contracts_text(contracts_field(contract_draft_, "club"), "");
AmountRequest request;
request.title = contracts_text(contracts_field(bonus, "name"));
request.unit = money_unit();
request.return_focus = "contract-bonus-" + std::to_string(*index);
request.value = bonus.at("value").get<int64_t>();
request.min = 0;
request.max = 255;
request.step = 1;
request.suggestion_step = 1;
request.review = true;
request.accept = [this, world, revision, club, index = *index](int64_t amount) {
if (menu_ != "contracts" || contracts_dialog_ != "bonuses" || contracts_world_ != world ||
contracts_revision_ != revision || amount < 0 || amount > 255 ||
!contracts_bound(snap(), revision, world, club)) return false;
const auto result = source_->apply({revision, "finance",
{{"kind", "bonus"}, {"index", index}, {"value", amount}}});
if (!result.ok) return false;
contract_draft_["bonuses"][size_t(index)]["value"] = amount;
contracts_revision_ = result.revision;
refresh();
return true;
};
open_amount(std::move(request));
return true;
}
return true;
}
bool App::contracts_event(Rml::Event &event) {
if (menu_ != "contracts" || contracts_dialog_.empty() || amount_) return false;
const auto type = event.GetType();
const bool keyboard = type == "keydown";
const auto key = keyboard ? Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0))
: Rml::Input::KI_UNKNOWN;
if ((keyboard && key == Rml::Input::KI_ESCAPE) || type == "contextmenu" ||
(type == "mouseup" && event.GetParameter<int>("button", 0) == 1)) {
close_contracts(true);
event.StopImmediatePropagation();
return true;
}
if (keyboard && key == Rml::Input::KI_TAB) {
Rml::ElementList buttons;
if (auto *dialog = element("contracts-dialog")) dialog->QuerySelectorAll(buttons, "button");
buttons.erase(std::remove_if(buttons.begin(), buttons.end(), [](auto *button) {
return button->HasAttribute("disabled");
}), buttons.end());
if (!buttons.empty()) {
const auto current = std::find(buttons.begin(), buttons.end(), context_->GetFocusElement());
const int count = int(buttons.size());
const int old = current == buttons.end() ? -1 : int(current - buttons.begin());
const bool backwards = event.GetParameter<int>("shift_key", 0) != 0;
const int next = old < 0 ? backwards ? count - 1 : 0 : (old + (backwards ? -1 : 1) + count) % count;
buttons[size_t(next)]->Focus(true);
}
event.StopImmediatePropagation();
return true;
}
bool inside = false;
for (auto *node = event.GetTargetElement(); node && node != doc_; node = node->GetParentNode())
if (node->GetId() == "contracts-dialog") inside = true;
if (!inside && (type == "click" || type == "dblclick" || type == "mousedown" ||
type == "mouseup" || keyboard)) {
event.StopImmediatePropagation();
return true;
}
return false;
}
+245
View File
@@ -0,0 +1,245 @@
// SPDX-License-Identifier: GPL-3.0-only
namespace {
const Json &contracts_field(const Json &object, const char *key) {
static const Json absent;
if (object.is_object()) {
const auto found = object.find(key);
if (found != object.end()) return *found;
}
return absent;
}
std::string contracts_text(const Json &value, const std::string &fallback = "—") {
return value.is_string() && !value.get_ref<const std::string &>().empty()
? value.get<std::string>() : fallback;
}
std::string contracts_managed(const Snapshot &snapshot) {
const auto &managers = contracts_field(snapshot.state, "managers");
return managers.is_array() && !managers.empty()
? contracts_text(contracts_field(managers[0], "club"), "") : "";
}
Json contracts_projection(const Snapshot &snapshot) {
if (!snapshot.world) return {{"ok", false}};
try {
return demo_contract_rows(snapshot.state, *snapshot.world, contracts_managed(snapshot));
} catch (const std::exception &) { return {{"ok", false}}; }
}
Json contracts_row(const Json &projection, const std::string &id) {
const auto &rows = contracts_field(projection, "rows");
if (rows.is_array())
for (const auto &row : rows)
if (contracts_field(row, "id") == id) return row;
return Json();
}
std::string contracts_number(const Json &value) {
if (!value.is_number()) return "—";
if (value.is_number_integer()) return number(value.get<int64_t>());
const double n = value.get<double>();
if (!std::isfinite(n)) return "—";
std::ostringstream out;
out << std::setprecision(6) << n;
auto text = out.str();
std::replace(text.begin(), text.end(), '.', ',');
return text;
}
std::string contracts_money(const Json &value, const Catalog &world) {
return value.is_number_integer()
? money(value.get<int64_t>(), world.manifest().value("currency", Json::object())) : "—";
}
std::string contracts_position_code(const std::string &code) {
return code == "gk" ? "TW" : code == "def" ? "ABW"
: code == "mid" ? "MIT" : code == "fwd" ? "STU" : code;
}
std::string contracts_position(const Json &row) {
const auto &positions = contracts_field(row, "positions");
std::string text;
if (positions.is_array())
for (const auto &value : positions) {
if (!value.is_string() || value.get_ref<const std::string &>().empty()) continue;
if (!text.empty()) text += " / ";
text += contracts_position_code(value.get<std::string>());
}
return text.empty() ? contracts_position_code(contracts_text(contracts_field(row, "position"))) : text;
}
bool contracts_bound(const Snapshot &snapshot, uint64_t revision,
const std::shared_ptr<const Catalog> &world,
const std::string &club, const std::string &player = "") {
if (!world || snapshot.world != world || snapshot.revision != revision ||
contracts_managed(snapshot) != club) return false;
const auto projection = contracts_projection(snapshot);
if (!projection.value("ok", false) || contracts_field(projection, "club") != club) return false;
return player.empty() || contracts_row(projection, player).is_object();
}
} // namespace
std::string App::render_contracts() {
const auto snapshot = snap();
const auto projection = contracts_projection(snapshot);
const bool ready = projection.value("ok", false) && snapshot.world;
const auto &rows = contracts_field(projection, "rows");
const size_t count = rows.is_array() ? rows.size() : 0;
if (contracts_tab_ < 0 || contracts_tab_ > 2) contracts_tab_ = 2;
if (contracts_dialog_.empty() && contracts_player_.empty() && count)
contracts_player_ = contracts_text(contracts_field(rows[0], "id"), "");
const auto managed = contracts_managed(snapshot);
const auto *own = snapshot.world ? snapshot.world->find("clubs", managed) : nullptr;
const auto club_name = own ? snapshot.world->name(*own) : std::string("—");
std::string output = "<div id=\"contracts-underlay\" class=\"contracts-overview\">"
"<header class=\"contracts-heading\"><div class=\"contracts-heading-club\"><div class=\"contracts-club-label\">" +
(own ? img(own->value("crest", ""), 58, 58, true) : "") +
"<span>" + esc(club_name) + "</span></div><p>" + std::to_string(count) +
" Spieler · Spieler anklicken, um einen Vertrag zu verhandeln</p></div>"
"<div class=\"contracts-salary-total\"><span>Monatsgehälter</span><span class=\"contracts-total-value\">" +
(ready ? esc(contracts_money(contracts_field(projection, "salary_total"), *snapshot.world)) : "—") +
"</span></div></header><div id=\"contracts-roster-scroll\" class=\"contracts-roster\">"
"<div class=\"contracts-table\" role=\"table\"><div class=\"contracts-row contracts-table-head\" role=\"row\">";
const std::array<std::vector<std::pair<std::string, std::string>>, 3> headings = {{
{{"name", "Spieler"}, {"position", "Pos."}, {"condition", "Kond."},
{"technique", "Technik"}, {"form", "Form"}, {"strength", "Stärke"}, {"age", "Alter"}},
{{"name", "Spieler"}, {"age", "Alter"}, {"shoot", "Schuss"}, {"pass", "Pass"},
{"team", "Team"}, {"games", "Spiele"}, {"grade", "Note"}},
{{"name", "Spieler"}, {"position", "Pos."}, {"strength", "Stärke"}, {"age", "Alter"},
{"salary", "Gehalt / Monat"}, {"months", "Vertrag"}, {"insurance", "Versicherung"}}
}};
const auto &columns = headings[size_t(contracts_tab_)];
for (size_t column = 0; column < columns.size(); ++column)
output += "<div class=\"contracts-cell c" + std::to_string(column) +
"\" role=\"columnheader\"><span>" + esc(columns[column].second) + "</span></div>";
output += "</div>";
if (rows.is_array())
for (size_t i = 0; i < rows.size(); ++i) {
const auto &row = rows[i];
const auto id = contracts_text(contracts_field(row, "id"), "");
const auto name = contracts_text(contracts_field(row, "name"));
output += "<div class=\"contracts-row " + std::string(i % 2 == 0 ? "striped " : "") +
(contracts_player_ == id ? "selected" : "") + "\" role=\"row\" data-player=\"" + esc(id) + "\">";
for (size_t column = 0; column < columns.size(); ++column) {
const auto key = columns[column].first;
const auto source = contracts_text(contracts_field(row, "source_label"), "");
output += "<div class=\"contracts-cell c" + std::to_string(column) +
"\" role=\"cell\" title=\"" + esc(key == "salary" ? source : "") + "\">";
if (column == 0)
output += btn("contract-player", "<span class=\"contract-player-rank\">" +
std::to_string(i + 1) + ".</span><span class=\"contract-player-name\" title=\"" +
esc(name) + "\">" + esc(name) + "</span>", "contract-player-button",
"id=\"contract-player-" + esc(id) + "\" data-id=\"" + esc(id) +
"\" aria-haspopup=\"dialog\" aria-pressed=\"" + (contracts_player_ == id ? "true" : "false") + "\"");
else {
std::string value;
if (key == "position") value = contracts_position(row);
else if (key == "salary") value = ready ? contracts_money(contracts_field(row, "salary"), *snapshot.world) : "—";
else if (key == "months") value = contracts_number(contracts_field(row, "months")) + " Monate";
else if (key == "insurance") {
const auto &insurance = contracts_field(row, "insurance");
value = insurance.is_number_integer() ? insurance.get<int>() == 0 ? "Ohne"
: contracts_number(insurance) + " Monate" : "—";
} else value = contracts_number(contracts_field(row, key.c_str()));
output += "<span class=\"contract-value\">" + esc(value) + "</span>";
}
output += "</div>";
}
output += "</div>";
}
output += "</div>";
if (!ready || count == 0)
output += "<p class=\"contracts-empty\">" + std::string(ready
? "Für diesen Verein sind keine Spieler im Katalog vorhanden."
: "Die Vertragsvorschau ist derzeit nicht verfügbar.") + "</p>";
output += "</div><nav class=\"contracts-actions\">";
const std::array<const char *, 3> tabs = {"Daten A", "Daten B", "Gehalt"};
for (int tab = 0; tab < 3; ++tab)
output += btn("contracts-tab", "<span>" + std::string(tabs[size_t(tab)]) + "</span>",
"contract-control " + std::string(contracts_tab_ == tab ? "selected" : ""),
"id=\"contracts-tab-" + std::to_string(tab) + "\" data-id=\"" + std::to_string(tab) +
"\" aria-pressed=\"" + (contracts_tab_ == tab ? "true" : "false") + "\"");
output += btn("contracts-bonuses", "<span>Team-Prämien</span>", "contract-control bonuses",
"id=\"contracts-bonuses\" " + std::string(ready ? "" : "disabled")) + "</nav></div>";
if (contracts_dialog_.empty()) return output;
const auto &draft_row = contracts_field(contract_draft_, "row");
const auto player_name = contracts_text(contracts_field(draft_row, "name"));
const auto &world = contracts_world_ ? contracts_world_ : snapshot.world;
const bool offer = contracts_dialog_ == "offer", insurance = contracts_dialog_ == "insurance";
std::string title = offer ? "Vertragsverhandlung · " + player_name
: insurance ? "Spielerversicherung · " + player_name
: contracts_dialog_ == "bonuses" ? "Team-Prämien"
: contracts_text(contracts_field(contract_draft_, "notice_title"), "Vertragsvorschau");
std::string body, actions;
const auto close = [&](const std::string &caption) {
return btn("contract-close", "<span>" + esc(caption) + "</span>", "contract-control",
"id=\"contract-close\"");
};
if (offer) {
const auto &salary = contracts_field(draft_row, "salary");
const auto &proposed = contracts_field(contract_draft_, "salary");
const auto &months = contracts_field(contract_draft_, "months");
const auto source = contracts_text(contracts_field(draft_row, "source_label"));
const int64_t factor = world ? finance_currency_factor(*world) : 1;
// Fictional asking price follows the HTML preview, never an engine demand.
const Json demand = salary.is_number_integer()
? Json(((salary.get<int64_t>() / factor * 11 + 5) / 10) * factor) : Json();
body = "<p class=\"contract-player-summary\">" + esc(contracts_position(draft_row)) +
" · Stärke " + esc(contracts_number(contracts_field(draft_row, "strength"))) +
" · " + esc(contracts_number(contracts_field(draft_row, "age"))) + " Jahre</p>"
"<div class=\"contract-scenes\"><div class=\"contract-scene\">" + img("contracts.scene.0", 955, 291.0625) +
"</div><div class=\"contract-scene\">" + img("contracts.scene.1", 955, 291.0625) + "</div></div>"
"<div class=\"contract-amounts\"><div class=\"contract-amount-card\" title=\"" + esc(source) +
"\"><span class=\"contract-amount-label\">Aktuelles Monatsgehalt</span><span class=\"contract-amount-value\">" +
(world ? esc(contracts_money(salary, *world)) : "—") +
"</span></div><div class=\"contract-amount-card\"><span class=\"contract-amount-label\">Fiktive Forderung</span>"
"<span class=\"contract-amount-value\">" + (world ? esc(contracts_money(demand, *world)) : "—") +
"</span></div></div><div class=\"contract-duration-heading\"><span>Laufzeit</span><span class=\"contract-duration-value\">" +
esc(contracts_number(months)) + " Monate</span></div><nav class=\"contract-duration\" aria-label=\"Vertragslaufzeit\">";
for (const int term : {12, 24, 36, 48})
body += btn("contract-term", "<span>" + std::to_string(term / 12) +
(term == 12 ? " Jahr" : " Jahre") + "</span>", "contract-control " +
std::string(months == term ? "selected" : ""), "id=\"contract-term-" + std::to_string(term) +
"\" data-id=\"" + std::to_string(term) + "\" aria-pressed=\"" + (months == term ? "true" : "false") + "\"");
body += "</nav><div class=\"contract-salary\"><div class=\"contract-salary-label\"><span>Dein Angebot pro Monat</span>"
"<span class=\"contract-salary-hint\">Betrag über die gemeinsame Zahleneingabe ändern</span></div>" +
btn("contract-salary", "<span>" + (world && proposed.is_number_integer()
? esc(std::to_string(proposed.get<int64_t>())) : "—") + "</span>",
"contract-salary-input amount-trigger", "id=\"contract-salary\" aria-haspopup=\"dialog\" aria-label=\"Angebotenes Monatsgehalt ändern\"") +
"</div><p class=\"contract-draft-note\">Erst „Angebot machen“ übernimmt Gehalt und Laufzeit.</p>";
actions = close("Abbrechen") +
btn("contract-insurance", "<span>Versichern</span>", "contract-control", "id=\"contract-insurance\"") +
btn("contract-submit", "<span>Angebot machen</span>", "contract-control contract-submit",
"id=\"contract-submit\" " + std::string(proposed.is_number_integer() ? "" : "disabled"));
} else if (insurance) {
const auto current = contracts_field(draft_row, "insurance");
body = "<p class=\"contract-insurance-prompt\">Wähle die Versicherungsdauer für diesen Spieler.</p>"
"<nav class=\"contract-insurance-options\">";
for (const int duration : {0, 12, 24})
body += btn("contract-insure", "<span class=\"contract-insurance-title\">" +
(duration ? std::to_string(duration) + " Monate" : "Ohne") +
"</span><span class=\"contract-insurance-caption\">" +
(duration ? "Versicherungslaufzeit" : "Keine Versicherung") + "</span>",
"contract-control " + std::string(current == duration ? "selected" : ""),
"id=\"contract-insure-" + std::to_string(duration) + "\" data-id=\"" +
std::to_string(duration) + "\" aria-pressed=\"" + (current == duration ? "true" : "false") + "\"");
body += "</nav>";
actions = close("Abbrechen");
} else if (contracts_dialog_ == "bonuses") {
body = "<p class=\"contract-player-summary\">Prämienvereinbarung für die gesamte Mannschaft</p>"
"<div class=\"contract-bonuses\">";
const auto &bonuses = contracts_field(contract_draft_, "bonuses");
const std::array<const char *, 7> names = {"Torprämie", "Punktprämie", "Auflaufprämie", "Meisterprämie",
"Prämie Pl. 2–5", "Prämie Pl. 6–10", "Nichtabstiegsprämie"};
for (size_t i = 0; i < names.size(); ++i) {
const Json bonus = bonuses.is_array() && i < bonuses.size() ? bonuses[i] : Json();
body += "<div class=\"contract-bonus-row\"><span>" + esc(contracts_text(contracts_field(bonus, "name"), names[i])) + "</span>" +
btn("contract-bonus", "<span>" + esc(contracts_number(contracts_field(bonus, "value"))) + "</span>",
"contract-control amount-trigger", "id=\"contract-bonus-" + std::to_string(i) + "\" data-id=\"" +
std::to_string(i) + "\" aria-haspopup=\"dialog\"") + "</div>";
}
body += "</div>";
actions = close("Zurück");
} else {
body = "<p class=\"contract-notice-text\">" + esc(contracts_notice_) + "</p>";
actions = close("Verstanden");
}
return output + "<div id=\"contracts-layer\" class=\"contracts-layer\"><section id=\"contracts-dialog\" "
"class=\"contracts-dialog contracts-dialog-" + esc(contracts_dialog_) +
"\" role=\"dialog\" aria-modal=\"true\" aria-labelledby=\"contract-dialog-title\">"
"<h2 id=\"contract-dialog-title\">" + esc(title) + "</h2>" + body +
"<nav class=\"contract-dialog-actions\">" + actions + "</nav></section></div>";
}
+20 -4
View File
@@ -135,6 +135,7 @@ void App::ProcessEvent(Rml::Event &event) try {
keyboard_navigation_ = true;
else if (type == "mousedown")
keyboard_navigation_ = false;
if (type == "blur" && popup_.empty()) bank_event(event);
if (type == "blur") {
if (auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(
event.GetTargetElement());
@@ -148,6 +149,10 @@ void App::ProcessEvent(Rml::Event &event) try {
n = n->GetParentNode())
if (n->GetId() == "native-ticket-layer")
return;
if (amount_event(event)) return;
if (popup_.empty() && amount_trigger_event(event)) return;
if (popup_.empty() && contracts_event(event)) return;
if (popup_.empty() && (bank_event(event) || finance_event(event))) return;
if (!planning_dialog_.empty() && popup_.empty()) {
const bool key_event = type == "keydown";
const auto key = key_event ? Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0)) : Rml::Input::KI_UNKNOWN;
@@ -389,7 +394,8 @@ void App::ProcessEvent(Rml::Event &event) try {
if (controls[size_t(next)]->GetId().starts_with("report-detail-player-") ||
controls[size_t(next)]->GetId().starts_with("report-club-") ||
controls[size_t(next)]->GetId().starts_with("friendly-opponent-") ||
controls[size_t(next)]->GetId().starts_with("alm-match-"))
controls[size_t(next)]->GetId().starts_with("alm-match-") ||
controls[size_t(next)]->GetId().starts_with("contract-player-"))
controls[size_t(next)]->ScrollIntoView(
Rml::ScrollIntoViewOptions(Rml::ScrollAlignment::Nearest));
event.StopImmediatePropagation();
@@ -429,6 +435,7 @@ void App::ProcessEvent(Rml::Event &event) try {
void App::dispatch(const std::string &action, Rml::Element *target) {
const auto id =
target ? target->GetAttribute<Rml::String>("data-id", "") : std::string();
if (amount_action(action, target) || bank_action(action, target) || finance_action(action, target) || contracts_action(action, target)) return;
if (almanac_action(action, target) || planning_action(action, target) || indoor_action(action, target)) return;
if (report_detail_action(action, target)) {
close_report_picker(false);
@@ -1040,11 +1047,12 @@ void App::dispatch(const std::string &action, Rml::Element *target) {
}
static const std::set<std::string> available = {
"tables", "strengths", "camp", "settings",
"save", "load", "training", "tactics", "calendar", "league", "other", "postpone", "friendlies", "indoor", "almanac"};
"save", "load", "training", "tactics", "calendar", "league", "other", "postpone", "friendlies", "indoor", "almanac", "bank", "balance", "contracts"};
if (!available.contains(route)) {
message("Diese native Ansicht wird im nächsten Menüpaket übertragen.");
return;
}
if (route == "bank") { bank_view_ = "entrance"; bank_hint_.clear(); }
menu_ = route;
report_picker_.clear();
report_detail_kind_.clear();
@@ -1393,12 +1401,16 @@ void App::script() {
context_->ProcessTextInput(command.value("value", std::string()));
else if (type == "key") {
const std::map<std::string, Rml::Input::KeyIdentifier> keys = {
{"ESC", Rml::Input::KI_ESCAPE}, {"ENTER", Rml::Input::KI_RETURN},
{"ESC", Rml::Input::KI_ESCAPE}, {"ENTER", Rml::Input::KI_RETURN}, {"NUMENTER", Rml::Input::KI_NUMPADENTER},
{"TAB", Rml::Input::KI_TAB}, {"SPACE", Rml::Input::KI_SPACE},
{"HOME", Rml::Input::KI_HOME}, {"END", Rml::Input::KI_END},
{"LEFT", Rml::Input::KI_LEFT}, {"RIGHT", Rml::Input::KI_RIGHT},
{"UP", Rml::Input::KI_UP}, {"DOWN", Rml::Input::KI_DOWN},
{"A", Rml::Input::KI_A}, {"Z", Rml::Input::KI_Z}};
{"A", Rml::Input::KI_A}, {"Z", Rml::Input::KI_Z}, {"V", Rml::Input::KI_V},
{"BACKSPACE", Rml::Input::KI_BACK}, {"DELETE", Rml::Input::KI_DELETE}, {"F4", Rml::Input::KI_F4},
{"0", Rml::Input::KI_0}, {"1", Rml::Input::KI_1}, {"2", Rml::Input::KI_2}, {"3", Rml::Input::KI_3},
{"4", Rml::Input::KI_4}, {"5", Rml::Input::KI_5}, {"6", Rml::Input::KI_6}, {"7", Rml::Input::KI_7},
{"8", Rml::Input::KI_8}, {"9", Rml::Input::KI_9}};
const auto name = command.at("value").get<std::string>();
if (!keys.contains(name))
throw editor::Error("Unbekannte UI-Skripttaste.");
@@ -1420,6 +1432,10 @@ void App::script() {
{"menu", menu_},
{"report_picker", report_picker_},
{"planning_dialog", planning_dialog_},
{"bank_view", bank_view_}, {"bank_property", bank_property_}, {"bank_stock", bank_stock_},
{"balance_future", balance_future_},
{"contracts_view", {{"dialog", contracts_dialog_}, {"player", contracts_player_}, {"tab", contracts_tab_}, {"draft", contract_draft_}}},
{"amount_editor", amount_ ? Json{{"title", amount_->request.title}, {"raw", amount_->raw}, {"review", amount_->review}, {"error", amount_error()}} : Json()},
{"source_revision", source_ ? Json(snap().revision) : Json()},
{"game_dirty", source_ && source_->dirty()},
{"desktop_dirty", desktop_ != saved_desktop_},
+391
View File
@@ -0,0 +1,391 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/demo_finance.hpp"
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <limits>
#include <numeric>
#include <set>
namespace bmh::modern_ui {
namespace {
constexpr int64_t money_cap = 99999999, debt_cap = 5000000, salary_cap = 200000;
constexpr std::array<int64_t, 6> property_prices{115000, 340000, 470000, 780000, 1350000, 3650000};
constexpr std::array<const char *, 6> property_names{"Eigentumswohnung", "Mehrfamilienhaus",
"Einfamilienhaus", "Villa", "Hochhaus", "Bürogebäude"};
constexpr std::array<int64_t, 12> stock_prices{124, 86, 207, 59, 310, 145, 97, 225, 68, 178, 112, 264};
constexpr std::array<const char *, 12> stock_names{"MainTech", "Nordlicht", "Hafenwerk", "Bergstrom",
"Solaris", "Westbahn", "Rheinwerk", "Ballwerk", "Feldpunkt", "Stadtfunk", "Werkbank", "Sportnetz"};
constexpr std::array<int64_t, 7> incomes{134000, 92000, 86200, 950000, 120000, 50000, 25000};
constexpr std::array<const char *, 7> income_names{"Trikotwerbung", "Bandenwerbung", "Fernsehrechte",
"Zuschauer", "Stadionperipherie", "Mieten, Zinsen, Tilgung", "Sonstiges"};
constexpr std::array<int64_t, 11> costs{650000, 420000, 80000, 120000, 60000, 45000,
250000, 50000, 35000, 0, 30000};
constexpr std::array<const char *, 11> cost_names{"Gehälter und Prämien", "Stadionkosten", "Nachwuchs",
"Co-Trainer", "Arzt", "Physio", "Trainingslager", "Fanbetreuung", "PR-Arbeit",
"Zinsen und Tilgung", "Sonstiges"};
constexpr std::array<const char *, 7> 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<const char *> 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>() <= uint64_t(hi) &&
(lo <= 0 || v.get<uint64_t>() >= uint64_t(lo));
return v.is_number_integer() && v.get<int64_t>() >= lo && v.get<int64_t>() <= 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 (managers[0]["club"].get<std::string>().empty())
throw editor::Error("invalid_finance_manager");
return own(world, managers[0]["club"].get<std::string>());
}
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<std::string>();
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<const Json *> 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<int64_t>();
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<double>())
? *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<std::string>();
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<std::string>(), today = state.at("date").get<std::string>();
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<std::string>()] = 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<int>() % 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<const Json *>{} : 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<std::string>());
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<std::string>();
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<std::string>();
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<int64_t>(), deposit = state.at("deposit").get<int64_t>(), debt = state.at("debt").get<int64_t>();
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<size_t>();
index = i;
price = (property ? property_prices[i] : stock_prices[i]) * factor;
const auto owned = state.at("finance").at(property ? "properties" : "stocks")[i].get<int64_t>();
max = kind.ends_with("buy") ? std::min<int64_t>(9999 - owned, cash / price)
: std::min<int64_t>(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<std::string>();
auto next = state;
if (kind == "term") {
if (!keys(action, {"kind", "value"}) || !integer(action.at("value"), 6, 60) ||
action.at("value").get<int>() % 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<size_t>();
const auto value = action.at("value").get<int64_t>();
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<std::string>();
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<int64_t>() * 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<std::string>();
if (!integer(action.at("value"), 1, quote.at("max").get<int64_t>())) return "invalid_finance_value";
const auto value = action.at("value").get<int64_t>(), total = value * quote.at("unit_price").get<int64_t>();
const auto cash = state.at("cash").get<int64_t>(), deposit = state.at("deposit").get<int64_t>(), debt = state.at("debt").get<int64_t>();
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<size_t>();
next["cash"] = cash + (buying ? -total : total);
next["finance"][property ? "properties" : "stocks"][i] =
state.at("finance").at(property ? "properties" : "stocks")[i].get<int64_t>() + (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<int64_t>(), deposit = state.at("deposit").get<int64_t>(), debt = state.at("debt").get<int64_t>();
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<int64_t>();
for (size_t i = 0; i < stock_prices.size(); ++i)
stocks += stock_prices[i] * factor * state.at("finance").at("stocks")[i].get<int64_t>();
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<int64_t>();
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<std::string>());
if (c.at("salary").is_null()) ++unknown;
else {
const auto salary = c.at("salary").get<int64_t>();
if (total > std::numeric_limits<int64_t>::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<std::string>())}});
}
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
+31
View File
@@ -0,0 +1,31 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "modern/ui/catalog.hpp"
namespace bmh::modern_ui {
// Full presentation state: cash/deposit/debt remain the sole shared balances.
// Money in the model/projections uses currency minor units. Action editor values
// use whole displayed currency units, or quantities for asset transactions.
int64_t finance_currency_factor(const Catalog &);
Json demo_contracts(const Catalog &, const std::string &managed_club = "");
bool migrate_demo_finance(Json &state, const Catalog &,
const std::string &managed_club = "");
bool valid_demo_finance(const Json &state, const Catalog &,
const std::string &managed_club = "");
std::string edit_demo_finance(Json &state, const Json &action, const Catalog &,
const std::string &managed_club = "");
// Helpers only project synthetic prices/rates. They never accrue money or time.
Json demo_bank_assets(const Catalog &);
Json demo_bank_terms();
// {kind:deposit|withdraw|loan|repay} or
// {kind:property-buy|property-sell|stock-buy|stock-sell,index:int}.
// Returns ok,kind,min,max,quantity,index,unit_price (raw),step. A max of zero
// disables confirmation. Every commit recomputes this quote from current state.
Json demo_bank_quote(const Json &state, const Json &request, const Catalog &);
Json demo_bank_summary(const Json &state, const Catalog &);
Json demo_balance_rows(const Json &state, const Catalog &);
// Returns {ok,club,rows:[catalogue values + stored contract],salary_total,
// salary_known,salary_unknown,bonuses}; total covers known salaries only.
Json demo_contract_rows(const Json &state, const Catalog &,
const std::string &managed_club = "");
} // namespace bmh::modern_ui
+57
View File
@@ -0,0 +1,57 @@
// SPDX-License-Identifier: GPL-3.0-only
bool App::commit_finance(const Json &change, uint64_t revision) {
if (!source_) return false;
const auto result = source_->apply({revision, "finance", change});
if (!result.ok) {
message("Die Eingabe konnte nicht übernommen werden. Bitte den aktuellen Stand prüfen und erneut eingeben. (" + result.error + ")");
return false;
}
refresh();
return true;
}
bool App::finance_action(const std::string &action, Rml::Element *target) {
if (menu_ != "balance") return false;
if (action == "balance-toggle") {
balance_future_ = !balance_future_;
focus_after_render_ = "balance-toggle";
refresh();
return true;
}
if (action == "balance-plan" && target) {
const int index = target->GetAttribute<int>("data-id", -1);
const auto rows = demo_balance_rows(snap().state, *world_);
if (!balance_future_ || !rows.value("ok", false) || index < 0 || size_t(index) >= rows.at("plan").size()) return true;
const auto &row = rows.at("plan")[size_t(index)];
const auto revision = snap().revision;
const auto world = world_;
AmountRequest request;
request.title = row.at("name").get<std::string>() + " in " + (money_unit() == "€" ? "Euro" : money_unit());
request.unit = money_unit();
request.value = row.at("amount").get<int64_t>() / finance_currency_factor(*world_);
request.min = 0;
request.max = 99999999;
request.step = 1000;
request.suggestion_step = 50000;
request.return_focus = target->GetId();
request.accept = [this, index, revision, world](int64_t value) {
if (world != world_ || menu_ != "balance") return false;
return commit_finance({{"kind", "plan"}, {"index", index}, {"value", value}}, revision);
};
open_amount(std::move(request));
return true;
}
return false;
}
bool App::finance_event(Rml::Event &event) {
if (menu_ != "balance" || !balance_future_ || amount_) return false;
const auto type = event.GetType();
if ((type == "keydown" && event.GetParameter<int>("key_identifier", 0) == Rml::Input::KI_ESCAPE) ||
(type == "mouseup" && event.GetParameter<int>("button", 0) == 1)) {
balance_future_ = false;
focus_after_render_ = "balance-toggle";
refresh();
event.StopImmediatePropagation();
return true;
}
return false;
}
+47
View File
@@ -0,0 +1,47 @@
// SPDX-License-Identifier: GPL-3.0-only
std::string App::render_balance() {
const auto rows = demo_balance_rows(snap().state, *world_);
if (!rows.value("ok", false)) throw editor::Error("Die Bilanzdaten sind ungültig.");
std::string out = "<div class=\"balance-native\">";
if (balance_future_) {
out += "<section class=\"balance-plan\"><h2>Ausgabenplanung</h2><div class=\"balance-plan-rows\">";
int i = 0;
for (const auto &row : rows.at("plan")) {
const auto name = row.at("name").get<std::string>();
out += "<div class=\"balance-plan-row\"><span>" + esc(name) + "</span>" +
btn("balance-plan", esc(number(row.at("amount").get<int64_t>() / finance_currency_factor(*world_))),
"balance-plan-value amount-trigger", "id=\"balance-plan-" + std::to_string(i) +
"\" data-id=\"" + std::to_string(i) + "\" aria-label=\"" + esc(name + " in " + (money_unit() == "€" ? "Euro" : money_unit())) + "\"") + "</div>";
++i;
}
out += "</div></section><p class=\"balance-plan-total\"><span>Geplante Ausgaben</span><span>" +
esc(cash(rows.at("plan_total").get<int64_t>())) + "</span></p>";
} else {
int index = 0;
for (const auto &kind : {std::string("income"), std::string("costs")}) {
out += "<section class=\"balance-panel\" style=\"left:" + std::to_string(index++ * 1322) +
"dp;\"><h2>" + (kind == "income" ? "Einnahmen" : "Ausgaben") + "</h2><div class=\"balance-table\">"
"<div class=\"balance-row balance-head\"><span>Position</span><span>Betrag</span></div>";
int n = 0;
for (const auto &row : rows.at(kind)) {
out += "<div class=\"balance-row" + std::string(n++ % 2 == 0 ? " striped" : "") + "\"><span>" +
esc(row.at("name").get<std::string>()) + "</span><span>" + esc(cash(row.at("amount").get<int64_t>())) + "</span></div>";
}
out += "</div></section>";
}
const std::array<std::string, 6> values = {
number(rows.at("league_home_games").get<int64_t>()) + " Liga-Heimspiele",
number(rows.at("other_home_games").get<int64_t>()) + " sonstige Heimspiele",
"Zuschauerschnitt: " + number(rows.at("attendance_average").get<int64_t>()),
"Eintrittspreis: " + cash(rows.at("ticket").get<int64_t>()),
"Kontostand: " + cash(rows.at("cash").get<int64_t>()),
"Saldo: " + cash(rows.at("balance").get<int64_t>())};
for (int i = 0; i < 6; ++i)
out += "<p class=\"balance-summary-item" + std::string(i == 5 ? " balance-net" : "") + "\" style=\"" +
rect(26 + (i % 2) * 1310, 1526 + (i / 2) * 68, 1250, 38) + "\">" + esc(values[size_t(i)]) + "</p>";
}
out += btn("balance-toggle", "<span>" + std::string(balance_future_ ? "Zukunft" : "Aktuell") +
"</span><span class=\"balance-cycle\" aria-hidden=\"true\"><span class=\"cycle-line cycle-top\"></span><span class=\"cycle-line cycle-bottom\"></span><span class=\"cycle-head cycle-right\"></span><span class=\"cycle-head cycle-left\"></span></span>", "balance-toggle report-reset",
"id=\"balance-toggle\" aria-label=\"Zwischen aktueller Bilanz und Zukunftsplanung wechseln\"");
return out + "</div>";
}
+9
View File
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/model.hpp"
#include "modern/ui/demo_almanac.hpp"
#include "modern/ui/demo_finance.hpp"
#include "modern/ui/demo_calendar.hpp"
#include "modern/ui/demo_reports.hpp"
#include "modern/ui/demo_sports.hpp"
@@ -84,6 +85,8 @@ DemoSource::DemoSource(std::shared_ptr<const Catalog> catalog)
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");
saved_ = state_;
}
Snapshot DemoSource::snapshot() const { return {revision_, catalog_, state_}; }
@@ -122,11 +125,15 @@ ActionResult DemoSource::apply(const Action &action) {
if (next.at("training").at("club") != first) {
next["training"] = demo_training(*catalog_, first);
next["tactics"] = demo_tactics();
next["contracts"] = demo_contracts(*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};
}
} else if (action.kind == "finance") {
const auto error = edit_demo_finance(next, action.value, *catalog_, next["managers"][0]["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())
@@ -246,6 +253,8 @@ Json DemoSource::load(const fs::path &file) {
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");
auto next = data;
auto desktop = next.value("desktop", Json::object());
if (!migrate_desktop(desktop))
+13 -1
View File
@@ -883,6 +883,12 @@ std::string App::render_menu(const std::string &key) {
body = render_friendlies();
else if (key == "indoor")
body = render_indoor();
else if (key == "bank")
body = render_bank();
else if (key == "balance")
body = render_balance();
else if (key == "contracts")
body = render_contracts();
else if (key == "training")
body = render_training();
else if (key == "tactics")
@@ -900,6 +906,12 @@ std::string App::render_menu(const std::string &key) {
body = render_desktop_tools(key);
else
throw editor::Error("Diese native Ansicht ist noch nicht verfügbar.");
std::string heading = key == "postpone" ? "Spiel verlegen" : title(key);
if (key == "bank" && bank_view_ != "entrance") {
const std::map<std::string, std::string> labels = {{"savings", "Sparbuch"}, {"properties", "Immobilien"},
{"stocks", "Aktien"}, {"credit", "Kredit"}, {"overview", "Finanzübersicht"}};
if (labels.contains(bank_view_)) heading += " · " + labels.at(bank_view_);
}
return "<div class=\"fill\" style=\"z-index:100;\">" +
window(key == "postpone" ? "Spiel verlegen" : title(key), body) + "</div>";
window(heading, body) + "</div>";
}
+94 -7
View File
@@ -6,6 +6,7 @@
#include "launch/rml_video.hpp"
#include "modern/ui/controls.hpp"
#include "modern/ui/demo_calendar.hpp"
#include "modern/ui/demo_finance.hpp"
#include "modern/ui/demo_reports.hpp"
#include "modern/ui/demo_sports.hpp"
#include "modern/ui/desktop.hpp"
@@ -16,6 +17,7 @@
#include "version.hpp"
#include <RmlUi/Core.h>
#include <RmlUi/Core/Elements/ElementFormControl.h>
#include <RmlUi/Core/Elements/ElementFormControlInput.h>
#include <RmlUi/Core/Elements/ElementFormControlSelect.h>
#include <RmlUi_Platform_SDL.h>
#include <SDL.h>
@@ -280,6 +282,20 @@ struct Mod {
fs::path file;
Json manifest;
};
struct AmountRequest {
std::string title, unit, return_focus;
int64_t value = 0, min = 0, max = 99999999, step = 1, suggestion_step = 100000;
bool review = true;
std::function<std::string(int64_t)> review_text;
std::function<bool(int64_t)> accept;
};
struct AmountDraft {
AmountRequest request;
std::string raw, error, menu;
bool review = false;
uint64_t revision = 0;
std::shared_ptr<const Catalog> world;
};
class App final : public Rml::EventListener {
fs::path executable_, root_, assets_, gui_root_;
launch::SaveMigrator migrate_;
@@ -317,6 +333,16 @@ class App final : public Rml::EventListener {
std::string planning_dialog_, planning_notice_, planning_return_focus_;
int almanac_year_ = 0;
std::string almanac_day_, almanac_match_, almanac_tab_ = "lineups";
std::optional<AmountDraft> amount_;
bool amount_select_all_ = false, amount_caret_end_ = false;
std::string bank_view_ = "entrance", bank_hint_;
int bank_property_ = 0, bank_owned_ = 0, bank_stock_ = 11;
bool balance_future_ = false;
Json contract_draft_;
std::string contracts_player_, contracts_dialog_, contracts_return_focus_, contracts_notice_;
int contracts_tab_ = 2;
uint64_t contracts_revision_ = 0;
std::shared_ptr<const Catalog> contracts_world_;
float device_ratio_ = 1.f;
Json desktop_ = Json::object(), saved_desktop_ = Json::object(),
options_ = Json::object();
@@ -369,6 +395,10 @@ class App final : public Rml::EventListener {
world_ ? world_->manifest().value("currency", Json::object())
: Json::object());
}
std::string money_unit() const {
const auto code = world_ ? world_->manifest().value("currency", Json::object()).value("code", std::string("EUR")) : "EUR";
return code == "EUR" ? "€" : code;
}
fs::path user_dir() const {
const auto id = world_ ? world_->manifest().value("id", std::string("none"))
: std::string("none");
@@ -422,10 +452,10 @@ class App final : public Rml::EventListener {
std::string window(const std::string &heading, const std::string &content,
bool close = true) {
return "<div class=\"window\"><div class=\"titlebar\">" +
(close ? btn("close", "<span>×</span>", "close")
(close ? btn("close", "<span>×</span>", "close", "id=\"window-close\" aria-label=\"" + std::string(menu_ == "bank" && bank_view_ != "entrance" ? "Zurück zur Bankhalle" : "Fenster schließen") + "\"")
: "<span style=\"width:76dp;\"></span>") +
"<h1>" + esc(heading) + "</h1></div><div class=\"content\">" +
content + "</div></div>";
content + "</div>" + (amount_ ? render_amount() : "") + "</div>";
}
std::string
select(const std::string &id,
@@ -526,6 +556,15 @@ class App final : public Rml::EventListener {
renderer_.world(next);
world_ = std::move(next);
source_ = std::move(demo);
amount_.reset();
amount_select_all_ = amount_caret_end_ = false;
contracts_dialog_.clear();
contracts_player_.clear();
contract_draft_ = Json();
contracts_world_.reset();
bank_view_ = "entrance";
bank_hint_.clear();
balance_future_ = false;
almanac_year_ = 0;
almanac_day_.clear();
almanac_match_.clear();
@@ -635,6 +674,26 @@ class App final : public Rml::EventListener {
std::string render_planning_dialog();
std::string planning_progress(bool, bool);
bool planning_action(const std::string &, Rml::Element *);
std::string render_amount();
void open_amount(AmountRequest);
void close_amount(bool restore = true);
void update_amount(bool focus = false, bool select_all = false);
bool amount_action(const std::string &, Rml::Element *);
bool amount_event(Rml::Event &);
bool amount_trigger_event(Rml::Event &);
std::optional<int64_t> amount_value() const;
std::string amount_error() const;
bool commit_finance(const Json &, uint64_t);
std::string render_bank();
bool bank_action(const std::string &, Rml::Element *);
bool bank_event(Rml::Event &);
std::string render_balance();
bool finance_action(const std::string &, Rml::Element *);
bool finance_event(Rml::Event &);
std::string render_contracts();
bool contracts_action(const std::string &, Rml::Element *);
bool contracts_event(Rml::Event &);
void close_contracts(bool restore = true);
std::string render_almanac();
bool almanac_action(const std::string &, Rml::Element *);
std::string render_indoor();
@@ -704,6 +763,9 @@ class App final : public Rml::EventListener {
// open. Never keep that menu's modal/input gate in the destination view.
if (menu_ != last_rendered_menu_) {
planning_dialog_.clear();
amount_.reset();
contracts_dialog_.clear();
contract_draft_ = Json();
report_detail_kind_.clear();
report_picker_.clear();
}
@@ -737,13 +799,21 @@ class App final : public Rml::EventListener {
if (!menu_.empty())
markup += render_menu(menu_);
element("canvas")->SetInnerRML(markup);
if (!report_detail_kind_.empty() || !planning_dialog_.empty()) {
if (!report_detail_kind_.empty() || !planning_dialog_.empty() || !contracts_dialog_.empty()) {
Rml::ElementList behind;
doc_->QuerySelectorAll(behind,
"#report-underlay button,#report-underlay input,#report-underlay select,.window .titlebar button");
"#report-underlay button,#report-underlay input,#report-underlay select,#contracts-underlay button,.window .titlebar button");
for (auto *node : behind)
node->SetProperty("pointer-events", "none");
}
if (amount_) {
Rml::ElementList underlay;
doc_->QuerySelectorAll(underlay, ".window>.content,.window>.titlebar");
for (auto *node : underlay) {
node->SetProperty("pointer-events", "none");
node->SetProperty("filter", "blur(10dp)");
}
}
const auto size = context_->GetDimensions();
const auto background =
img("background", size.x / scale_, size.y / scale_, false, true, 2048);
@@ -770,7 +840,8 @@ class App final : public Rml::EventListener {
node->Focus(keyboard_navigation_);
if (focus_after_render_.starts_with("report-option-") ||
focus_after_render_.starts_with("friendly-opponent-") ||
focus_after_render_.starts_with("alm-match-"))
focus_after_render_.starts_with("alm-match-") ||
focus_after_render_.starts_with("contract-player-"))
report_option_to_scroll_ = focus_after_render_;
focus_after_render_.clear();
}
@@ -855,6 +926,15 @@ class App final : public Rml::EventListener {
context_->Update();
if (center_selects(*doc_))
context_->Update();
if (amount_select_all_) {
if (auto *input = dynamic_cast<Rml::ElementFormControlInput *>(element("calculator-value"))) input->Select();
amount_select_all_ = false;
}
if (amount_caret_end_) {
if (auto *input = dynamic_cast<Rml::ElementFormControlInput *>(element("calculator-value")))
input->SetSelectionRange(int(input->GetValue().size()), int(input->GetValue().size()));
amount_caret_end_ = false;
}
if (center_fixture_columns())
context_->Update();
if (training_scroll_) {
@@ -986,9 +1066,9 @@ public:
throw std::runtime_error("Modern UI layout missing");
for (const char *event :
{"click", "dblclick", "change", "input", "keydown", "blur", "mousedown",
"mouseup", "mousemove", "contextmenu"})
"mouseup", "mousemove", "contextmenu", "focus"})
doc_->AddEventListener(event, this, Rml::String(event) == "keydown" ||
Rml::String(event) == "blur");
Rml::String(event) == "blur" || Rml::String(event) == "focus");
if (!config_.theme.empty())
theme_ = config_.theme;
if (theme_ != "midnight" && theme_ != "silver" && theme_ != "matchday")
@@ -1119,6 +1199,13 @@ public:
#include "modern/ui/planning_controls.inc"
#include "modern/ui/almanac_screens.inc"
#include "modern/ui/almanac_controls.inc"
#include "modern/ui/amount_entry.inc"
#include "modern/ui/bank_screens.inc"
#include "modern/ui/bank_controls.inc"
#include "modern/ui/finance_screens.inc"
#include "modern/ui/finance_controls.inc"
#include "modern/ui/contracts_screens.inc"
#include "modern/ui/contracts_controls.inc"
} // namespace
bool is_modern_world(const fs::path &file) {
try {