Port native Training and Tactics from the HTML reference (by Codex)

This commit is contained in:
Codex committed 2026-10-23 20:41:19 +02:00
1 parent c737c17870
commit 79bf38aa78
18 files changed
+952 -12

No files matched your search

+1 -1
View File
@@ -1,5 +1,5 @@
<rml>
<head><title>OpenBMH</title><link type="text/rcss" href="theme.rcss"/><link type="text/rcss" href="ticket.rcss"/></head>
<head><title>OpenBMH</title><link type="text/rcss" href="theme.rcss"/><link type="text/rcss" href="ticket.rcss"/><link type="text/rcss" href="sports.rcss"/></head>
<body class="midnight">
<div id="background"></div>
<div id="canvas"></div>
+49
View File
@@ -0,0 +1,49 @@
/* SPDX-License-Identifier: GPL-3.0-only */
.training-skills {position:absolute;left:0;top:0;width:1060dp;height:1008dp;}
.training-skill {height:112dp;display:flex;align-items:center;gap:14dp;font-size:36dp;}
.training-skill>div,.training-skill>span {flex-shrink:0;}
.training-balls {display:flex;align-items:center;justify-content:flex-start;}
.training-ball {display:flex;align-items:center;justify-content:center;padding:0;border:0dp;background-color:transparent;flex-shrink:0;}
.training-ball:hover,.training-ball:disabled {background-color:transparent;}
.training-ball.is-empty {opacity:.18;filter:grayscale(1);}
.training-ball.overtraining {filter:sepia(1) saturate(9) hue-rotate(310deg);}
.training-pitch {position:absolute;left:0;top:1040dp;width:570dp;height:390dp;border:3dp var(--border);border-radius:12dp;overflow:hidden;box-shadow:0dp 0dp 0dp 3dp #244c38;}
.training-midline {position:absolute;left:50%;top:0;width:2dp;height:100%;background-color:#d5efd2;}
.training-circle {position:absolute;left:50%;top:50%;width:110dp;height:110dp;margin-left:-55dp;margin-top:-55dp;border:3dp #d5efd2;border-radius:55dp;}
.training-box {position:absolute;top:22%;width:19%;height:56%;border:3dp #d5efd2;}
.left-box {left:-4dp;}.right-box {right:-4dp;}
.training-type-cell {position:absolute;width:227dp;height:156dp;display:flex;align-items:center;justify-content:center;}
.training-auto {font-size:32dp;}
.training-auto.auto-players {font-size:29dp;}
.training-budget {position:absolute;left:604dp;top:1338dp;width:440dp;font-size:27dp;line-height:1.5;color:var(--muted);}
.training-roster {position:absolute;left:1120dp;right:0;top:0;bottom:80dp;overflow-y:auto;overflow-x:hidden;}
.training-row {display:flex;align-items:center;height:99dp;border-bottom:2dp var(--border);font-size:34dp;}
.training-row>div {flex-shrink:0;}
.training-header {height:62dp;font-size:31dp;color:var(--muted);border-bottom:2dp var(--border);}
.training-position {font-size:30dp;color:var(--muted);}
.training-name {overflow:hidden;white-space:nowrap;text-overflow:ellipsis;padding-right:10dp;}
.training-row.striped {background-color:var(--soft);}
.training-roster select {width:490dp;height:62dp;padding:10dp 12dp;border:2dp var(--border);border-radius:8dp;font-size:32dp;}
.training-roster select selectbox {width:490dp;max-height:480dp;margin-top:8dp;padding:10dp;border-radius:16dp;}
.training-roster select option {min-height:72dp;padding:10dp 14dp;line-height:1.3;}
.tactics-board {position:absolute;left:76dp;top:0;width:2300dp;height:100%;}
.tactics-surface {position:absolute;left:0;right:0;top:0;bottom:100dp;border:2dp var(--border);border-radius:28dp;decorator:linear-gradient(130deg,#bfd9e40a,#9ecbb809);}
.tactics-board>.image-frame {filter:drop-shadow(0dp 0dp 1dp #e0edbc);}
.tactic-hotspot {padding:0;border:0dp;background-color:transparent;}
.tactic-hotspot:hover,.tactic-hotspot:active {background-color:transparent;}
.tactic-hotspot:focus-visible {border:3dp var(--accent);}
.tactic-effort {position:absolute;left:1021.188dp;top:1021.469dp;width:1012dp;height:316.875dp;color:#d4e6b3;}
body.silver .tactic-effort {color:#536f66;}
.tactic-effort-label {display:flex;align-items:baseline;gap:18dp;font-family:Chalk;font-size:60dp;line-height:1.2;letter-spacing:4dp;font-effect:shadow(2dp 2dp #386824);}
.tactic-effort-marks {font-size:52dp;letter-spacing:1dp;line-height:1.2;}
.tactic-effort input {position:absolute;left:2dp;top:96dp;width:96%;height:20dp;}
.tactic-effort input slidertrack {margin:8dp 0;height:4dp;}
.tactic-effort input sliderprogress {height:4dp;background-color:var(--accent);border-radius:2dp;}
.tactic-effort input sliderbar {width:16dp;height:16dp;margin-top:2dp;border:0dp;border-radius:8dp;background-color:var(--accent);}
.tactic-hint {position:absolute;left:0;right:0;bottom:34dp;height:39dp;text-align:center;font-size:34dp;color:var(--text);}
body.midnight .training-skill {color:#c6d6df;}
body.midnight .training-row {color:#d8e3eb;}
body.midnight .training-header,body.midnight .training-position {color:#9fb2c3;}
body.midnight .training-budget {color:#9fb6c6;}
body.midnight .training-pitch {border-color:#9eb9a5;}
body.midnight .tactic-hint {color:#b8cddc;}
+10
View File
@@ -30,6 +30,11 @@ wird ausdrücklich mit `OPENBMH_BUILD_MODERN_UI=ON` gebaut.
Ansichten vorhanden; ihr vollständiger Bedienungsabgleich bleibt offen.
- Separate UI-Demostände und Desktopansichten. Ansichten speichern zusätzlich
einen Screenshot; die Standardansicht kann nicht gelöscht werden.
- [Training](desktop/training/README.md): neun Übungen, vier Arten, Kader mit
Schwerpunkt/Intensität, Automatikgruppen und gemeinsame Automatik.
- [Taktik](desktop/tactics/README.md): sieben interaktive Diagrammflächen,
zyklische Einstellungen und Einsatzregler. Die Grafik aktualisiert sich
unmittelbar und speichert ausschließlich UI-Vorschaueinstellungen.
**Anstoß führt keine Aktion aus**, weder per Maus noch per Tastatur. Das gilt
auch für die direkte Aktionsschnittstelle des Demoanbieters.
@@ -94,6 +99,11 @@ Die [dedizierte Schrift-QA](typography-qa.md) prüft zusätzlich Buttons und
Dropdowns gegen das HTML-Mockup, einschließlich tatsächlicher Textmitten,
Pixeldichten sowie Escape- und Fokusverhalten.
Die [Menü-QA](menu-qa.md) hält den Gesamtkatalog einschließlich fehlender
Ports nach. Training/Taktik wurden in zwölf tatsächlichen Rendererläufen
mit drei Themes und zwei Auflösungen verglichen. Die native UI und die
synthetischen Kontrolltests bauen in der CI unter Linux, Windows und macOS.
Ein nativer Linux-/OpenGL-Durchlauf mit externem Diamond-Datensatz führt über
das Hauptmenü, die Managerwahl und Auslosung zum Desktop, verändert den
Eintrittspreis nach Bestätigung, öffnet das Nahost-Lager und prüft Verschieben
+3
View File
@@ -10,10 +10,13 @@ Implementierung in der Spiel-Engine.
| Umsetzung | [Abgestimmter Umfang der nativen UI bis zum Anstoß](PLAN.md) |
| Nativer Stand | [Unterbau, erster Durchlauf und noch offene Übertragungen](NATIVE_STATUS.md) |
| Schrift-QA | [Button-/Dropdown-Ausrichtung und unabhängiger Vergleich](typography-qa.md) |
| Menü-QA | [Wiederholbarer Gesamtkatalog und Meilenstein-Abnahme](menu-qa.md) |
| Ressourcen | [GUI-Assets, Weltbilder und spätere Paketbereinigung](assets.md) |
| Desktop | [Statusleiste, Gestaltung und Fenster](desktop/README.md) |
| Eintrittspreis | [Kompakter Schieberegler im Konto-Widget](desktop/entry-price/README.md) |
| Trainingslager | [Alle 18 Angebote, Qualitätswerte und Bedienung](desktop/trainingcamp/README.md) |
| Training | [Übungen, Kader, Intensität und Demo-Automatik](desktop/training/README.md) |
| Taktik | [Interaktive Diagramme und Einsatzregler](desktop/tactics/README.md) |
| Transfers | [Ablöse-Kasten und Positionsfilter](desktop/transfers/README.md) |
Jeder Bereich nennt die geprüfte Quelle, bestehende Funktionen und offene
+50
View File
@@ -0,0 +1,50 @@
# Taktik · native Modern UI
Stand: 23. Oktober 2026. Quelle: privates HTML-Mockup `bmh_4k_ui`, Revision
`0bf0f2afd2ff8d5dabb96c795db2a5d0abaaf278`, `desktop/squad-menus.js`,
`squad-menus.css` und `table-window.css`. Der Port verwendet dieselbe
Geometrie, Farben und Interaktionsflächen.
## Darstellung und Bedienung
Die transparente Tafel liegt im gemeinsamen 4:3-Fenster. Spielfelder,
Spielerpunkte, Pfeile und Kurven entstehen als skalierbares Diagramm mit
erhaltenem Seitenverhältnis. Es gibt keine sichtbaren Hoverkästen;
Tastaturfokus bleibt sichtbar.
Sieben Flächen wechseln zyklisch Defensiv/offensiv, drei Pass-/Schussbilder,
flache/hohe Bälle und zwei Flügelbilder. Der dezente Regler stellt den
Einsatz von 0 bis 11 ein. Ausrufezeichen und Hinweis aktualisieren sich
während der Bedienung. Die drei Themes verwenden ihre Referenzfarben,
einschließlich der dunklen Linien in Silver.
Die dynamische Textur verwendet einen festen Cacheplatz. Bei Änderungen wird
die vorherige GPU-Textur freigegeben; wiederholte Klicks legen keine
unbegrenzte Bildsammlung an. Kein zusätzliches Tafelbild im OBW ist nötig.
## Demo und spätere Anbindung
`Snapshot.state.tactics.values` enthält acht Vorschaueinstellungen.
Revisionierte `tactics`-Aktionen mit `cycle` oder `effort` gehen ausschließlich
an den Demoanbieter. Die HTML-Startwerte sind `[2, 1, 1, 0, 1, 0, 1, 6]`;
Speichern, Laden und Wiederöffnen erhalten Änderungen. Keine Matchfunktion
wird ausgeführt.
Die Formation ist derzeit dieselbe feste Vorschau wie im HTML-POC. Sie ist
noch nicht mit einer nativen Aufstellungsansicht verbunden. Der Sessionadapter
liefert später Formation, erlaubte Werte und Wirkungen. Die Kreideschrift
nutzt verfügbare Systemschriften mit Rückfall auf die mitgelieferte UI-Schrift;
geringe Metrikunterschiede zwischen Betriebssystemen sind noch zu prüfen.
## QA
Zwölf vollständige Trainings-/Taktikläufe decken drei Themes und zwei
Auflösungen ab. Geprüft: alle sieben Wechsel samt Rückkehr zu Startwerten,
tatsächlich aktualisierte Diagramme, beide Reglerenden, Tastaturbedienung,
Wiederöffnen und Wiederherstellung in einem zweiten Prozess. Zusätzliche
Silver-Aufnahmen prüfen Reglerknopf, Fortschritt und Schatten.
Linux/OpenGL wurde tatsächlich gerendert. Windows/macOS haben CI-Builds und
synthetische Tests; ihre visuelle Laufzeitabnahme ist damit nicht erledigt.
Kleine Schrift-/Kantenrasterungsunterschiede bleiben protokolliert.
Siehe [wiederholbare Menü-QA](../../menu-qa.md).
+57
View File
@@ -0,0 +1,57 @@
# Training · native Modern UI
Stand: 23. Oktober 2026. Verbindliche Quelle: privates HTML-Mockup
`bmh_4k_ui`, Revision `0bf0f2afd2ff8d5dabb96c795db2a5d0abaaf278`,
`desktop/squad-menus.js`, `squad-menus.css` und `table-window.css`.
Der native Port liegt in `src/modern/ui/sports_screens.inc`.
## Darstellung und Bedienung
- Neun Übungen mit dem unveränderten GUI-Iconatlas und drei Bällen je Zeile:
Kondition, Technik, Eckball, Freistoß, Zweikampf, Pass, Schuss,
Schnelligkeit und Teamplay.
- Vier Trainingsarten auf dem gezeichneten Spielfeld; Automatik für Arten,
Kondition/Technik, Fertigkeiten und Spieler sowie der gemeinsame Schalter.
- Rechts der vollständige OBW-Kader mit Position, Name, Stärke,
Schwerpunkt und Intensität. Lange Namen werden mit Abstand zur Stärke
gekürzt. Die Liste scrollt bei größeren Kadern.
- Ein bereits gewählter Intensitätsball schaltet die Spielerintensität auf
null. Escape verwirft die Schwerpunktwahl; Fokus und Listenposition bleiben
bei Änderungen erhalten.
- Automatik sperrt manuelle Eingaben der jeweiligen Gruppe. Die
Spielerautomatik behält Schwerpunkte bei; der gemeinsame Schalter schaltet
alle vier Gruppen zusammen.
Der Demoanbieter übernimmt die HTML-Vorschaubudgets 8/4/18 für Arten,
Kondition/Technik und Fertigkeiten. Ab 15 Fertigkeitsbällen zeigt er hohe
Belastung. Überschreitungen werden ohne teilweise Übernahme abgewiesen.
**Dies sind UI-Dummydaten, keine Trainingsregel oder Spielerentwicklung.**
## Daten und spätere Engine-Anbindung
`Snapshot.state.training` enthält Vereins-ID, neun Übungswerte, vier
Artenwerte, vier Automatikflags sowie Intensität/Schwerpunkt nach Spieler-ID.
Revisionierte `training`-Aktionen gehen ausschließlich an `DemoSource`.
Der erste Manager bestimmt den angezeigten Kader. Ein Vereinswechsel erzeugt
eine passende neue Vorschau. Ältere UI-Demostände werden beim Laden ergänzt;
echte `.obs`-Spielstände bleiben davon unberührt.
Der spätere Sessionadapter muss Budgets, Automatik und Wirkungen liefern.
Die Verbindung zur globalen Einstellungsautomatik steht noch aus.
Namen/Positionen/Stärke stammen aus dem schreibgeschützten OBW-Katalog;
Icons und Ballgrafik sind [GUI-Ressourcen](../../assets.md).
Die Referenz hat 16 fiktive Spieler, der geprüfte Diamond-Kader 20.
Diese Datenabweichung wird nicht durch Entfernen von Spielern kaschiert.
## QA
Zwölf tatsächliche Trainings-/Taktikläufe decken drei Themes und zwei Größen
(1280 × 720, 1920 × 1080) ab. Geprüft: Budgets, Überlastungsfarbe,
Schwerpunktwahl/Escape, Intensität null, Automatik, echtes Mausrad,
Scroll-/Fokuserhalt, Wiederöffnen und gespeicherte Wiederherstellung.
Die Budgetumbrüche wurden in allen sechs Training-Konfigurationen nachgeprüft.
Synthetische Tests ergänzen atomare Ablehnung, Revisionen und Migration.
Die gemeinsame Dropdown-Markierungsspalte und geringe Unterschiede der
Kantenglättung bleiben dokumentierte Abweichungen. Screenshots, Eingaben und
passende Demostände: [wiederholbare Menü-QA](../../menu-qa.md).
+51
View File
@@ -0,0 +1,51 @@
# Wiederholbare Menü-QA gegen HTML
Die HTML-Version ist der verbindliche Gestaltungsstandard. Der Vergleich
begleitet fortlaufend die Portierung bis Anstoß. Eine Bildschirmaufnahme
allein bedeutet keine visuelle Abnahme.
## Arbeitsweise
1. Unveränderte HTML-Quelle lesen; Browserbilder, Geometrie, Schrift und
Interaktionszustände aufnehmen.
2. Native Ansicht mit Dummydaten hinter `DataSource` umsetzen.
Datenabweichungen ausdrücklich nennen und das Referenzlayout beibehalten.
3. Dedizierten QA-Agenten den tatsächlichen Renderer gegen HTML prüfen lassen:
drei Themes × 1280 × 720 und 1920 × 1080, einschließlich Buttons,
Dropdowns, langer Texte, Scrollen, Fokus und Abbrechen.
4. Befunde mit Eingabeskript und ladbarem UI-Demostand belegen. Korrekturen
gezielt nachprüfen; vollständige Interaktionsmatrix am Menü-Meilenstein.
5. Gesamtkatalog und offene Befunde fortschreiben. Fehlende Ports bleiben offen.
Das private Mockup-Repository enthält dafür
`tools/qa/native_mockup_compare.py` mit deutscher Anleitung.
`--scenes all` nimmt jede katalogisierte Ansicht bis Anstoß auf; fehlende
native Ports erhalten weiterhin eine HTML-Aufnahme. Native Fälle enthalten
PNG, DOM, Snapshot, Eingabeskript und ladbaren Demostand. Das Werkzeug ist
ein endlicher QA-Lauf, kein unbeaufsichtigter Dauerprozess. Folgende
Menü-Meilensteine verwenden denselben Katalog erneut.
Die Matrix trennt technische Aufnahme, Datenabgleich und visuelle Freigabe.
Reviewer, Zeitpunkt und fünf Prüfbereiche werden gespeichert. Unvollständige
Vergleiche bleiben `UNIMPLEMENTED` beziehungsweise `PENDING`. Protokolliert
werden außerdem Binärdatei-, Welt-, GUI- und Demostand-Hashes sowie Referenzrevision.
## Automatisierte Regression
`.github/workflows/modern-ui.yml` baut die aktivierte native UI unter Linux,
Windows und macOS. Fensterlose Tests mit synthetischen Daten prüfen unter
anderem Text-/Pfeilmitten, Dropdown-Schriftgrößen, Themes/Pixeldichten und das
Verwerfen von Eingaben. Private Ressourcen werden dort nicht vorausgesetzt.
CI ergänzt die tatsächlichen Renderer-/HTML-Vergleiche. Ein erfolgreicher
Build bestätigt keine visuelle Abnahme auf dem jeweiligen Betriebssystem.
## Nachweise
Private Bilder und passende UI-Demostände liegen im Mockup-Repository unter
`docs/qa/native-rmlui-2026-10-23/`. Sie enthalten Weltinhalte und gehören
deshalb nicht ins öffentliche Quellcode-Repository. Öffentliche Zusammenfassung:
- [Nativer Stand](NATIVE_STATUS.md)
- [Typografie-Befunde](typography-qa.md)
- [Training](desktop/training/README.md) und [Taktik](desktop/tactics/README.md)
+2 -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)
add_library(bmh_modern_ui_core STATIC catalog.cpp model.cpp gui_assets.cpp desktop.cpp demo_sports.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)
foreach(asset modern.rml theme.rcss ticket.rcss sports.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")
+4 -4
View File
@@ -29,13 +29,13 @@ inline bool center_selects(Rml::ElementDocument &document) {
bool changed = false;
Rml::ElementList controls;
document.QuerySelectorAll(controls, "select");
const auto set_pixels = [&](Rml::Element *element, const char *name,
const auto set_pixels = [&](Rml::Element *element, Rml::PropertyId name,
float value) {
const auto *old = element->GetLocalProperty(name);
if (old && old->unit == Rml::Unit::PX &&
std::abs(old->Get<float>() - value) < .02f)
return;
element->SetProperty(name, std::to_string(value) + "px");
element->SetProperty(name, Rml::Property(value, Rml::Unit::PX));
changed = true;
};
for (auto *select : controls) {
@@ -48,8 +48,8 @@ inline bool center_selects(Rml::ElementDocument &document) {
continue;
// WidgetDropDown fixes both offsets at the content-box top. A flex
// selectvalue loses its text in pinned RmlUI; center its line instead.
set_pixels(caption, "line-height", height);
set_pixels(arrow, "margin-top",
set_pixels(caption, Rml::PropertyId::LineHeight, height);
set_pixels(arrow, Rml::PropertyId::MarginTop,
std::max(0.f, (height -
arrow->GetBox().GetSize(Rml::BoxArea::Border).y) /
2));
+68 -2
View File
@@ -131,6 +131,10 @@ void App::drag_event(Rml::Event &event) {
}
void App::ProcessEvent(Rml::Event &event) try {
const auto type = event.GetType();
if (type == "keydown")
keyboard_navigation_ = true;
else if (type == "mousedown")
keyboard_navigation_ = false;
for (auto *n = event.GetTargetElement(); n && n != doc_;
n = n->GetParentNode())
if (n->GetId() == "native-ticket-layer")
@@ -267,7 +271,10 @@ void App::ProcessEvent(Rml::Event &event) try {
}
}
if (type == "change") {
change(target);
if (target->HasAttribute("data-input"))
input(target);
else
change(target);
return;
}
if (type == "input") {
@@ -879,7 +886,8 @@ void App::dispatch(const std::string &action, Rml::Element *target) {
return;
}
static const std::set<std::string> available = {
"tables", "strengths", "camp", "settings", "save", "load"};
"tables", "strengths", "camp", "settings",
"save", "load", "training", "tactics"};
if (!available.contains(route)) {
message("Diese native Ansicht wird im nächsten Menüpaket übertragen.");
return;
@@ -892,6 +900,39 @@ void App::dispatch(const std::string &action, Rml::Element *target) {
refresh();
return;
}
if (action == "training-auto" || action == "training-auto-all" ||
action == "training-ball") {
Json change;
if (action == "training-auto-all")
change = {{"kind", "auto-all"}};
else if (action == "training-auto")
change = {{"kind", "auto"}, {"index", std::stoi(id)}};
else {
const auto group = target->GetAttribute<Rml::String>("data-group", "");
change = {{"kind", "ball"},
{"group", group},
{"index", std::stoi(id)},
{"value", target->GetAttribute<int>("data-value", 1)}};
if (group == "player")
change["player"] = target->GetAttribute<Rml::String>("data-player", "");
}
if (apply("training", change)) {
focus_after_render_ = target->GetId();
refresh();
}
return;
}
if (action == "tactic-cycle") {
const int i = std::stoi(id);
if (i < 0 || i > 6)
return;
if (apply("tactics", {{"kind", "cycle"}, {"index", i}})) {
last_tactic_ = i;
focus_after_render_ = "tactic-cycle-" + id;
refresh();
}
return;
}
if (action == "ticket") {
if (ticket_) {
ticket_->open(target, device_ratio_);
@@ -1061,6 +1102,19 @@ void App::change(Rml::Element *target) {
pending_selects_.insert(target->GetId());
return;
}
if (kind == "training-focus") {
const auto player = target->GetAttribute<Rml::String>("data-player", "");
const int focus = std::stoi(value);
if (snap().state.at("training").at("players").at(player).at("focus") ==
focus)
return;
if (apply("training",
{{"kind", "focus"}, {"player", player}, {"value", focus}})) {
focus_after_render_ = target->GetId();
refresh();
}
return;
}
if ((kind == "manager-country" || kind == "table-country") &&
value == country_)
return;
@@ -1097,6 +1151,18 @@ void App::input(Rml::Element *target) {
if (!control)
return;
const auto value = control->GetValue();
if (kind == "tactic-effort") {
const int value = std::stoi(control->GetValue());
if (apply("tactics", {{"kind", "effort"}, {"value", value}})) {
last_tactic_ = 7;
element("tactic-effort-value")
->SetInnerRML(std::string(size_t(value), '!'));
element("tactic-hint")
->SetInnerRML("Einsatz: " + std::to_string(value) + " / 11");
dirty_ = true;
}
return;
}
if (kind == "sound-volume") {
const int n = std::stoi(value);
draft_preferences_["volume"] = n;
+264
View File
@@ -0,0 +1,264 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/demo_sports.hpp"
#include <algorithm>
#include <array>
#include <numeric>
#include <sstream>
namespace bmh::modern_ui {
namespace {
bool integers(const Json &a, size_t size, int low, int high) {
if (!a.is_array() || a.size() != size)
return false;
return std::all_of(a.begin(), a.end(), [&](const auto &v) {
return v.is_number_integer() && v >= low && v <= high;
});
}
int sum(const Json &a, size_t begin, size_t end) {
int n = 0;
for (size_t i = begin; i < end; ++i)
n += a.at(i).template get<int>();
return n;
}
constexpr std::array<int, 8> tactic_limits = {3, 3, 3, 3, 1, 1, 1, 11};
} // namespace
Json demo_training(const Catalog &world, const std::string &club) {
Json players = Json::object();
size_t i = 0;
for (auto *player : world.squad(club)) {
players[player->value("id", "")] = {{"intensity", i % 5 == 0 ? 1 : 2},
{"focus", int(i % 8)}};
++i;
}
return {{"club", club},
{"areas", {2, 2, 1, 1, 2, 2, 2, 2, 3}},
{"types", {2, 2, 2, 2}},
{"autos", {false, false, false, false}},
{"players", players}};
}
bool valid_demo_training(const Json &value, const Catalog &world,
const std::string &club) {
try {
if (!value.is_object() || value.at("club") != club ||
!integers(value.at("areas"), 9, 1, 3) ||
!integers(value.at("types"), 4, 1, 3))
return false;
if (sum(value["types"], 0, 4) > 8 || sum(value["areas"], 0, 2) > 4 ||
sum(value["areas"], 2, 9) > 18)
return false;
const auto &autos = value.at("autos");
if (!autos.is_array() || autos.size() != 4)
return false;
for (const auto &v : autos)
if (!v.is_boolean())
return false;
const auto &players = value.at("players");
const auto squad = world.squad(club);
if (!players.is_object() || players.size() != squad.size())
return false;
for (auto *p : squad) {
const auto &v = players.at(p->value("id", ""));
if (!v.at("intensity").is_number_integer() || v["intensity"] < 0 ||
v["intensity"] > 3 || !v.at("focus").is_number_integer() ||
v["focus"] < 0 || v["focus"] > 7)
return false;
}
return true;
} catch (const Json::exception &) {
return false;
}
}
std::string edit_demo_training(Json &state, const Json &action) {
for (const auto *key : {"index", "value"})
if (action.contains(key) && (!action[key].is_number_integer() ||
action[key] < 0 || action[key] > 100))
return "invalid_training_value";
auto next = state;
const auto kind = action.at("kind").get<std::string>();
if (kind == "auto" || kind == "auto-all") {
const int group = kind == "auto-all" ? -1 : action.at("index").get<int>();
if (group < -1 || group > 3)
return "invalid_training_group";
const bool enabled =
kind == "auto-all"
? !std::all_of(next["autos"].begin(), next["autos"].end(),
[](const auto &v) { return v == true; })
: !next["autos"][size_t(group)].get<bool>();
for (int i = 0; i < 4; ++i)
if (group == -1 || group == i) {
next["autos"][size_t(i)] = enabled;
if (!enabled)
continue;
if (i == 0)
next["types"] = {2, 2, 2, 2};
if (i == 1) {
next["areas"][0] = 2;
next["areas"][1] = 2;
}
if (i == 2)
for (size_t j = 2; j < 9; ++j)
next["areas"][j] = 2;
if (i == 3)
for (auto &[id, p] : next["players"].items()) {
(void)id;
p["intensity"] = 2;
}
}
} else if (kind == "focus") {
const auto player = action.at("player").get<std::string>();
const int value = action.at("value").get<int>();
if (!next["players"].contains(player) || value < 0 || value > 7)
return "invalid_training_player";
if (next["autos"][3] == true)
return "training_automatic";
next["players"][player]["focus"] = value;
} else if (kind == "ball") {
const auto group = action.at("group").get<std::string>();
const int value = action.at("value").get<int>();
if (value < 1 || value > 3)
return "invalid_training_value";
if (group == "player") {
const auto player = action.at("player").get<std::string>();
if (!next["players"].contains(player))
return "invalid_training_player";
if (next["autos"][3] == true)
return "training_automatic";
auto &v = next["players"][player]["intensity"];
v = v == value ? 0 : value;
} else {
const int index = action.at("index").get<int>();
const bool area = group == "area";
if ((!area && group != "type") || index < 0 || index >= (area ? 9 : 4))
return "invalid_training_group";
if (next["autos"][size_t(area ? (index < 2 ? 1 : 2) : 0)] == true)
return "training_automatic";
auto &list = next[area ? "areas" : "types"];
list[size_t(index)] = value;
if (sum(next["types"], 0, 4) > 8 || sum(next["areas"], 0, 2) > 4 ||
sum(next["areas"], 2, 9) > 18)
return "training_preview_budget";
}
} else
return "unknown_training_action";
state = std::move(next);
return {};
}
Json demo_tactics() { return {{"values", {2, 1, 1, 0, 1, 0, 1, 6}}}; }
bool valid_demo_tactics(const Json &value) {
try {
const auto &v = value.at("values");
if (!integers(v, 8, 0, 11))
return false;
for (size_t i = 0; i < 8; ++i)
if (v[i] > tactic_limits[i])
return false;
return true;
} catch (const Json::exception &) {
return false;
}
}
std::string edit_demo_tactics(Json &state, const Json &action) {
for (const auto *key : {"index", "value"})
if (action.contains(key) && (!action[key].is_number_integer() ||
action[key] < 0 || action[key] > 100))
return "invalid_tactic_value";
const auto kind = action.at("kind").get<std::string>();
const int index = kind == "effort" ? 7 : action.at("index").get<int>();
if (index < 0 || index > 7)
return "invalid_tactic_index";
if (kind == "cycle")
state["values"][size_t(index)] =
(state["values"][size_t(index)].get<int>() + 1) %
(tactic_limits[size_t(index)] + 1);
else if (kind == "effort") {
const int v = action.at("value").get<int>();
if (v < 0 || v > 11)
return "invalid_tactic_value";
state["values"][7] = v;
} else
return "unknown_tactic_action";
return {};
}
std::string tactics_diagram(const Json &state, const std::string &theme) {
const auto values = state.at("values").get<std::array<int, 8>>();
const std::string line = theme == "silver" ? "#536f66" : "#dfe8bf";
const auto field_line = theme == "silver" ? "#536f66" : "#d7edbf",
man_line = theme == "silver" ? "#536f66" : "#c9e6ae",
curve_line = theme == "silver" ? "#536f66" : "#d4e7ba";
const std::string defence = theme == "silver" ? "#85600c" : "#ffdd6b";
std::ostringstream out;
out.imbue(std::locale::classic());
out << "<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 295 "
"206'><defs><marker id='arrow' markerWidth='5' markerHeight='5' "
"refX='4' refY='2.5' orient='auto'><path d='M0 0L5 2.5L0 5Z' fill='"
<< line << "'/></marker></defs>";
const auto field = [&](double x, double y, double w, double h) {
out << "<g fill='none' stroke='" << field_line
<< "' stroke-width='.65'><path d='M" << x << ' ' << y << 'h' << w << 'v'
<< h << 'h' << -w << "Z M" << x + w / 2 << ' ' << y << 'v' << h << " M"
<< x << ' ' << y + h * .25 << 'h' << w * .15 << 'v' << h * .5 << 'h'
<< -w * .15 << " M" << x + w << ' ' << y + h * .25 << 'h' << -w * .15
<< 'v' << h * .5 << 'h' << w * .15 << "'/><circle cx='" << x + w / 2
<< "' cy='" << y + h / 2 << "' r='" << h * .14 << "'/></g>";
};
const auto dot = [&](double x, double y, bool opponent = false) {
out << "<circle cx='" << x << "' cy='" << y << "' r='2.4' fill='"
<< (opponent ? "#e46145" : defence)
<< "' stroke='#809344' stroke-width='.4'/>";
};
const auto arrow = [&](double x, double y, double dx, double dy,
bool dashed = false) {
out << "<path d='M" << x << ' ' << y << 'l' << dx << ' ' << dy
<< "' fill='none' stroke='" << line << "' stroke-width='.85' "
<< (dashed ? "stroke-dasharray='2 1.3'" : "")
<< " marker-end='url(#arrow)'/>";
};
field(19, 9, 104, 62);
field(19, 82, 104, 62);
field(137, 10, 58, 37);
field(205, 10, 58, 37);
const std::array<std::pair<int, int>, 10> formation = {{{5, 1},
{5, 3},
{5, 5},
{5, 7},
{10, 1},
{10, 3},
{10, 5},
{10, 7},
{16, 3},
{16, 5}}};
for (const auto &[x, y] : formation) {
const double px = 25 + x / 18.0 * 82, py = 16 + y / 8.0 * 49;
arrow(px, py, std::array<int, 4>{-16, -7, 7, 16}[size_t(values[0])], 0);
dot(px, py);
}
for (int k = 0; k < 2; ++k) {
const int x = 137 + k * 68;
dot(x + 12, 27);
dot(x + 25, 20);
dot(x + 25, 37);
dot(x + 43, 28, true);
if (values[size_t(5 + k)] == 0)
out << "<path d='M" << x + 3 << " 12l52 32 M" << x + 55
<< " 12l-52 32' stroke='" << line << "' stroke-width='1.6'/>";
}
dot(29, 111);
dot(76, 94);
dot(76, 119);
dot(101, 118);
dot(111, 120, true);
arrow(29, 111, 10 + values[3] * 10, -values[3] * 5, true);
arrow(76, 94, 10 + values[2] * 8, 12 - values[2] * 5);
arrow(76, 119, 10 + values[1] * 8, -8 + values[1] * 4, true);
for (int x : {181, 222})
out << "<g fill='none' stroke='" << man_line
<< "' stroke-width='.8'><circle cx='" << x
<< "' cy='65' r='2'/><path d='M" << x
<< " 67l-2 7 5 4 m-5-4 -4 4 m5-8 -5 2 m5-2 5 2'/></g>";
out << "<path d='M188 72Q201 " << (values[4] ? 45 : 72)
<< " 215 72' fill='none' stroke='" << curve_line
<< "' stroke-width='.9' stroke-dasharray='1 1.5' "
"marker-end='url(#arrow)'/></svg>";
return out.str();
}
} // namespace bmh::modern_ui
+15
View File
@@ -0,0 +1,15 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "modern/ui/catalog.hpp"
namespace bmh::modern_ui {
// UI fixtures from the HTML reference; these never run a training/match rule.
Json demo_training(const Catalog &, const std::string &club);
bool valid_demo_training(const Json &, const Catalog &,
const std::string &club);
std::string edit_demo_training(Json &, const Json &action);
Json demo_tactics();
bool valid_demo_tactics(const Json &);
std::string edit_demo_tactics(Json &, const Json &action);
std::string tactics_diagram(const Json &, const std::string &theme);
} // namespace bmh::modern_ui
+25 -1
View File
@@ -1,5 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/model.hpp"
#include "modern/ui/demo_sports.hpp"
#include "modern/ui/desktop.hpp"
#include <algorithm>
#include <chrono>
@@ -73,6 +74,8 @@ DemoSource::DemoSource(std::shared_ptr<const Catalog> catalog)
{"preferences",
{{"theme", "midnight"}, {"volume", 80}, {"effects", true}}},
{"edits", Json::object()}};
state_["training"] = demo_training(*catalog_, club);
state_["tactics"] = demo_tactics();
saved_ = state_;
if (!valid_date(state_.at("date")))
throw editor::Error("invalid_demo_date");
@@ -106,6 +109,19 @@ ActionResult DemoSource::apply(const Action &action) {
return {false, revision_, "invalid_manager"};
}
next["managers"] = action.value;
const auto first = action.value.at(0).at("club").get<std::string>();
if (next.at("training").at("club") != first) {
next["training"] = demo_training(*catalog_, first);
next["tactics"] = demo_tactics();
}
} else if (action.kind == "training") {
const auto error = edit_demo_training(next["training"], action.value);
if (!error.empty())
return {false, revision_, error};
} else if (action.kind == "tactics") {
const auto error = edit_demo_tactics(next["tactics"], action.value);
if (!error.empty())
return {false, revision_, error};
} else if (action.kind == "camp.select") {
if (!camp_id(action.value))
return {false, revision_, "camp_unknown"};
@@ -147,7 +163,7 @@ void DemoSource::save(const fs::path &file, const Json &desktop) {
saved_ = state_;
}
Json DemoSource::load(const fs::path &file) {
const auto data = Json::parse(editor::read_file(file));
auto data = Json::parse(editor::read_file(file));
if (data.value("schema", "") != "openbmh-ui-demo@1" ||
data.value("world", "") != catalog_->manifest().value("id", ""))
throw editor::Error("wrong_demo_world");
@@ -155,6 +171,14 @@ Json DemoSource::load(const fs::path &file) {
const auto result = validation.apply({0, "managers", data.at("managers")});
if (!result.ok)
throw editor::Error(result.error);
const auto club = data.at("managers").at(0).at("club").get<std::string>();
if (!data.contains("training"))
data["training"] = demo_training(*catalog_, club);
if (!data.contains("tactics"))
data["tactics"] = demo_tactics();
if (!valid_demo_training(data.at("training"), *catalog_, club) ||
!valid_demo_tactics(data.at("tactics")))
throw editor::Error("invalid_demo_sports");
if (!data.at("ticket").is_number_integer() || data.at("ticket") < 0 ||
data.at("ticket") > 25)
throw editor::Error("invalid_demo_ticket");
+4
View File
@@ -963,6 +963,10 @@ std::string App::render_menu(const std::string &key) {
std::string body;
if (key == "tables" || key == "strengths")
body = render_table(key == "strengths", false);
else if (key == "training")
body = render_training();
else if (key == "tactics")
body = render_tactics();
else if (key == "camp")
body = render_camp();
else if (key == "settings")
+181
View File
@@ -0,0 +1,181 @@
// SPDX-License-Identifier: GPL-3.0-only
std::string App::training_balls(const std::string &group, int index, int value,
bool automatic, const std::string &player,
int size, int gap, bool overtraining) {
std::string body =
"<div class=\"training-balls\" style=\"gap:" + std::to_string(gap) +
"dp;\">";
for (int i = 1; i <= 3; ++i)
body += btn(
"training-ball", img("training.ball", size, size, false, false, 128),
std::string("training-ball ") +
(i <= value ? "is-selected" : "is-empty") +
(overtraining && i <= value ? " overtraining" : ""),
"id=\"training-ball-" + group + "-" + std::to_string(index) + "-" +
std::to_string(i) + "\" data-group=\"" + group + "\" data-id=\"" +
std::to_string(index) + "\" data-player=\"" + esc(player) +
"\" data-value=\"" + std::to_string(i) + "\" style=\"width:" +
std::to_string(size) + "dp;height:" + std::to_string(size) +
"dp;\" " + (automatic ? "disabled" : ""));
return body + "</div>";
}
std::string App::render_training() {
const auto s = snap();
const auto &t = s.state.at("training"), &automatic = t.at("autos");
const std::array<const char *, 9> skills = {
"Kondition", "Technik", "Eckball", "Freistoß", "Zweikampf",
"Pass", "Schuss", "Schnelligkeit", "Teamplay"};
const std::vector<std::pair<std::string, std::string>> focuses = {
{"0", "Allgemein"}, {"1", "Eckball"}, {"2", "Freistoß"},
{"3", "Zweikampf"}, {"4", "Pass"}, {"5", "Schuss"},
{"6", "Schnelligkeit"}, {"7", "Teamplay"}};
int skill_total = 0, type_total = 0;
for (size_t i = 2; i < 9; ++i)
skill_total += t["areas"][i].get<int>();
for (const auto &v : t["types"])
type_total += v.get<int>();
std::string body = "<div class=\"training-skills\">";
for (size_t i = 0; i < 9; ++i)
body +=
"<div class=\"training-skill\"><div style=\"width:86dp;\">" +
img("training.skill." + std::to_string(i), 80, 80, false, false, 160) +
"</div><span style=\"width:677dp;\">" + skills[i] +
"</span><span style=\"width:35dp;\">:</span><div "
"style=\"width:220dp;\">" +
training_balls("area", int(i), t["areas"][i].get<int>(),
automatic[i < 2 ? 1 : 2].get<bool>(), {}, 56, 10,
i >= 2 && skill_total > 14) +
"</div></div>";
body += "</div><div class=\"training-pitch\">";
for (int i = 0; i < 10; ++i)
body += "<div style=\"position:absolute;left:0;right:0;top:" +
std::to_string(i * 43) + "dp;height:43dp;background-color:" +
std::string(i % 2 ? "#306b4c" : "#2d6447") + ";\"></div>";
body += "<div class=\"training-midline\"></div><div "
"class=\"training-circle\"></div><div class=\"training-box "
"left-box\"></div><div class=\"training-box right-box\"></div>";
for (int i = 0; i < 4; ++i)
body += "<div class=\"training-type-cell\" style=\"left:" +
std::to_string(30 + (i % 2) * 277) +
"dp;top:" + std::to_string(26 + (i / 2) * 176) + "dp;\">" +
training_balls("type", i, t["types"][size_t(i)].get<int>(),
automatic[0].get<bool>(), {}, 48, 5) +
"</div>";
body += "</div>";
const std::array<const char *, 4> auto_names = {
"AUTO · Arten", "AUTO · Kondition", "AUTO · Fertigkeiten",
"AUTO · Spieler"};
const std::array<std::array<int, 4>, 4> auto_boxes = {
{{0, 1456, 570, 76},
{604, 1040, 440, 76},
{604, 1136, 440, 76},
{2312, 1803, 300, 61}}};
for (size_t i = 0; i < 4; ++i) {
const auto a = auto_boxes[i];
body += btn(
"training-auto", auto_names[i],
std::string(i == 3 ? "training-auto auto-players " : "training-auto ") +
(automatic[i].get<bool>() ? "primary" : ""),
"id=\"training-auto-" + std::to_string(i) + "\" data-id=\"" +
std::to_string(i) + "\" style=\"position:absolute;" +
rect(a[0], a[1], a[2], a[3]) + "\"");
}
const bool all_auto = std::all_of(automatic.begin(), automatic.end(),
[](const auto &v) { return v == true; });
body += btn("training-auto-all", "Automatisch",
std::string("training-auto ") + (all_auto ? "primary" : ""),
"id=\"training-auto-all\" style=\"position:absolute;" +
rect(604, 1232, 440, 76) + "\"");
body += "<p class=\"training-budget\">Arten: " + std::to_string(type_total) +
" / 8 Bälle ·<br/>Kondition/Technik: " +
std::to_string(t["areas"][0].get<int>() + t["areas"][1].get<int>()) +
" / 4 ·<br/>Fertigkeiten: " + std::to_string(skill_total) + " / 18" +
(skill_total > 14 ? " · hohe<br/>Belastung" : "") +
"</p><div id=\"training-roster\" class=\"training-roster\"><div "
"class=\"training-row "
"training-header\">";
const std::array<const char *, 5> headings = {"Pos.", "Spieler", "Stärke",
"Schwerpunkt", "Intensität"};
const std::array<int, 5> widths = {90, 300, 95, 510, 497};
for (size_t i = 0; i < 5; ++i)
body += "<div style=\"width:" + std::to_string(widths[i]) + "dp;\">" +
headings[i] + "</div>";
body += "</div>";
const auto players = world_->squad(t.value("club", ""));
for (size_t i = 0; i < players.size(); ++i) {
const auto *p = players[i];
const auto id = p->value("id", "");
const auto &row = t["players"].at(id);
const auto position = p->value("positions", Json::array());
const auto pos = position.empty() ? "" : position[0].get<std::string>();
body +=
"<div class=\"training-row " + std::string(i % 2 ? "striped" : "") +
"\"><div class=\"training-position\" style=\"width:90dp;\">" +
std::string(pos == "gk" ? "TW"
: pos == "def" ? "ABW"
: pos == "mid" ? "MIT"
: pos == "fwd" ? "STU"
: pos) +
"</div><div class=\"training-name\" style=\"width:300dp;\" title=\"" +
esc(world_->name(*p)) + "\">" + esc(world_->name(*p)) +
"</div><div style=\"width:95dp;\">" +
std::to_string(
p->value("attributes", Json::object()).value("strength", 0)) +
"</div><div style=\"width:510dp;\">";
auto selector =
select("training-focus-" + std::to_string(i), focuses,
std::to_string(row.value("focus", 0)), "training-focus");
const auto end = selector.find('>');
selector.insert(end, " data-player=\"" + esc(id) + "\" " +
(automatic[3] == true ? "disabled" : ""));
body += selector + "</div><div style=\"width:497dp;\">" +
training_balls("player", int(i), row.value("intensity", 0),
automatic[3].get<bool>(), id, 50, 9) +
"</div></div>";
}
return body + "</div>";
}
std::string App::render_tactics() {
const auto t = snap().state.at("tactics");
const std::array<const char *, 8> names = {
"Defensiv / offensiv", "Pass-/Schussbild unten",
"Pass-/Schussbild Mitte", "Pass-/Schussbild links",
"Flache / hohe Bälle", "Flügelbild links",
"Flügelbild rechts", "Einsatz"};
const std::array<int, 8> limits = {3, 3, 3, 3, 1, 1, 1, 11};
const std::array<std::array<int, 4>, 7> areas = {{{19, 9, 104, 62},
{61, 108, 50, 34},
{63, 84, 54, 30},
{26, 95, 24, 24},
{168, 53, 71, 34},
{137, 10, 58, 37},
{205, 10, 58, 37}}};
std::string body =
"<div class=\"tactics-board\"><div class=\"tactics-surface\"></div>" +
picture(renderer_.diagram("tactics", tactics_diagram(t, theme_)), 2300,
1864);
for (size_t i = 0; i < 7; ++i) {
const auto a = areas[i];
body += btn("tactic-cycle", "", "tactic-hotspot",
"id=\"tactic-cycle-" + std::to_string(i) + "\" data-id=\"" +
std::to_string(i) + "\" aria-label=\"" + esc(names[i]) +
"\" style=\"position:absolute;" +
rect(a[0] / 295.0 * 2300, a[1] / 206.0 * 1864,
a[2] / 295.0 * 2300, a[3] / 206.0 * 1864) +
"z-index:" + std::to_string(8 - i) + ";\"");
}
const int effort = t["values"][7].get<int>();
body +=
"<div class=\"tactic-effort\"><div "
"class=\"tactic-effort-label\"><span>EINSATZ</span><span "
"id=\"tactic-effort-value\" class=\"tactic-effort-marks\">" +
std::string(size_t(effort), '!') +
"</span></div><input type=\"range\" id=\"tactic-effort\" "
"data-input=\"tactic-effort\" min=\"0\" max=\"11\" step=\"1\" value=\"" +
std::to_string(effort) +
"\"/></div><p id=\"tactic-hint\" class=\"tactic-hint\">" +
esc(names[size_t(last_tactic_)]) + ": " +
std::to_string(t["values"][size_t(last_tactic_)].get<int>()) + " / " +
std::to_string(limits[size_t(last_tactic_)]) + "</p></div>";
return body;
}
+76 -2
View File
@@ -5,6 +5,7 @@
#include "launch/rml_path.hpp"
#include "launch/rml_video.hpp"
#include "modern/ui/controls.hpp"
#include "modern/ui/demo_sports.hpp"
#include "modern/ui/desktop.hpp"
#include "modern/ui/gui_assets.hpp"
#include "modern/ui/model.hpp"
@@ -24,6 +25,7 @@
#include <functional>
#include <iomanip>
#include <nfd.hpp>
#include <optional>
#include <sstream>
namespace bmh::modern_ui {
@@ -129,11 +131,29 @@ class Renderer final : public rml::Renderer {
};
std::map<std::string, Entry> entries_;
std::map<std::string, std::string> keys_;
std::map<std::string, std::string> loaded_sources_;
size_t serial_ = 0;
public:
Renderer(rml::Video &video, GuiAssets &gui, fs::path assets)
: rml::Renderer(video), gui_(gui), assets_(std::move(assets)) {}
Picture diagram(const std::string &slot, const std::string &svg,
int pixels = 2400) {
const auto token = "modern-dynamic-" + slot + ".png",
digest = content::sha256(svg);
auto found = entries_.find(token);
if (found == entries_.end() || found->second.key != digest) {
auto raster = editor::images::decode(svg, ".svg", pixels);
if (const auto loaded = loaded_sources_.find(token);
loaded != loaded_sources_.end()) {
Rml::ReleaseTexture(loaded->second, this);
loaded_sources_.erase(loaded);
}
entries_[token] = {digest, false, pixels, std::move(raster)};
}
const auto &r = entries_.at(token).raster;
return {token, r.width, r.height};
}
Picture local_image(const fs::path &file, int pixels) {
const auto identity =
editor::utf8(file) + ":" +
@@ -155,6 +175,7 @@ public:
Rml::ReleaseTextures(this);
entries_.clear();
keys_.clear();
loaded_sources_.clear();
world_ = std::move(value);
}
Picture image(const std::string &key, bool world = false, int pixels = 512) {
@@ -239,6 +260,7 @@ public:
auto found = entries_.find(token);
if (found == entries_.end())
return rml::Renderer::LoadTexture(dimensions, source);
loaded_sources_[token] = source;
auto pixels = found->second.raster.pixels;
for (size_t i = 0; i < pixels.size(); i += 4)
for (int c = 0; c < 3; ++c)
@@ -278,6 +300,9 @@ class App final : public Rml::EventListener {
bool focus_ticket_ = false;
std::set<std::string> pending_selects_;
std::string focus_after_render_;
bool keyboard_navigation_ = false;
std::string last_rendered_menu_;
std::optional<float> training_scroll_;
float device_ratio_ = 1.f;
Json desktop_ = Json::object(), saved_desktop_ = Json::object(),
options_ = Json::object();
@@ -305,6 +330,7 @@ class App final : public Rml::EventListener {
std::string context_id_;
int context_x_ = 0, context_y_ = 0;
int opening_page_ = 0, draw_revealed_ = 0;
int last_tactic_ = 0;
bool draw_playing_ = true;
uint64_t draw_at_ = 0;
std::string settings_category_ = "display";
@@ -336,7 +362,10 @@ class App final : public Rml::EventListener {
}
std::string img(const std::string &key, double w, double h,
bool world = false, bool cover = false, int pixels = 512) {
const auto p = renderer_.image(key, world, pixels);
return picture(renderer_.image(key, world, pixels), w, h, cover);
}
std::string picture(const Picture &p, double w, double h,
bool cover = false) {
if (p.token.empty())
return "<div style=\"width:" + scalar(w) + "dp;height:" + scalar(h) +
"dp;\"></div>";
@@ -398,6 +427,14 @@ class App final : public Rml::EventListener {
bool apply(const std::string &kind, const Json &value) {
const auto r = source_->apply({source_->snapshot().revision, kind, value});
if (!r.ok) {
if (kind == "training" && r.error == "training_preview_budget") {
const int limit = value.value("group", "") == "type" ? 8
: value.value("index", 0) < 2 ? 4
: 18;
message("Für diesen Trainingsbereich stehen höchstens " +
std::to_string(limit) + " Bälle zur Verfügung.");
return false;
}
message("Die Eingabe konnte nicht übernommen werden: " + r.error);
return false;
}
@@ -559,6 +596,11 @@ class App final : public Rml::EventListener {
std::string widget(const std::string &, const Json &);
std::string render_table(bool strengths = false, bool indoor = false);
std::string render_camp();
std::string render_training();
std::string render_tactics();
std::string training_balls(const std::string &, int, int, bool,
const std::string &player = {}, int size = 56,
int gap = 10, bool overtraining = false);
std::string render_settings();
std::string render_save(bool save);
std::string render_desktop_tools(const std::string &);
@@ -605,6 +647,10 @@ class App final : public Rml::EventListener {
dirty_ = true;
}
void render() {
training_scroll_.reset();
if (menu_ == "training" && last_rendered_menu_ == "training")
if (auto *roster = element("training-roster"))
training_scroll_ = roster->GetScrollTop();
if (ticket_)
ticket_->close(false);
context_open_ = false;
@@ -638,6 +684,7 @@ class App final : public Rml::EventListener {
? "saturate(0.13) brightness(0.56)"
: "saturate(0.34) brightness(0.70)");
needs_render_ = false;
last_rendered_menu_ = menu_;
dirty_ = true;
if (focus_ticket_) {
if (auto *n = element("desktop-ticket"))
@@ -646,7 +693,7 @@ class App final : public Rml::EventListener {
}
if (!focus_after_render_.empty()) {
if (auto *node = element(focus_after_render_))
node->Focus(true);
node->Focus(keyboard_navigation_);
focus_after_render_.clear();
}
}
@@ -691,6 +738,11 @@ class App final : public Rml::EventListener {
context_->Update();
if (center_selects(*doc_))
context_->Update();
if (training_scroll_) {
if (auto *roster = element("training-roster"))
roster->SetScrollTop(*training_scroll_);
training_scroll_.reset();
}
renderer_.Clear();
renderer_.BeginFrame();
context_->Render();
@@ -750,6 +802,27 @@ class App final : public Rml::EventListener {
bold = Rml::LoadFontFace(rml::asset_path(assets_ / "LatoLatin-Bold.ttf"),
"Modern", Rml::Style::FontStyle::Normal,
Rml::Style::FontWeight::Bold);
std::vector<fs::path> chalk_fonts;
#ifdef _WIN32
if (const char *windir = std::getenv("WINDIR")) {
chalk_fonts.push_back(fs::path(windir) / "Fonts" / "comic.ttf");
chalk_fonts.push_back(fs::path(windir) / "Fonts" / "times.ttf");
}
#elif defined(__APPLE__)
chalk_fonts = {"/System/Library/Fonts/Supplemental/Comic Sans MS.ttf",
"/System/Library/Fonts/Supplemental/Apple Chancery.ttf",
"/System/Library/Fonts/Times.ttc"};
#else
chalk_fonts = {
"/usr/share/fonts/truetype/liberation2/LiberationSerif-Regular.ttf",
"/usr/share/fonts/truetype/liberation/LiberationSerif-Regular.ttf"};
#endif
chalk_fonts.push_back(assets_ / "LatoLatin-Regular.ttf");
for (const auto &font : chalk_fonts)
if (fs::exists(font) && Rml::LoadFontFace(rml::asset_path(font), "Chalk",
Rml::Style::FontStyle::Normal,
Rml::Style::FontWeight::Normal))
break;
if (!regular || !bold)
throw std::runtime_error(
"GUI-Schriften fehlen. Bitte das vollständige Paket entpacken.");
@@ -906,6 +979,7 @@ public:
#include "modern/ui/controls.inc"
#include "modern/ui/desktop_screens.inc"
#include "modern/ui/screens.inc"
#include "modern/ui/sports_screens.inc"
} // namespace
bool is_modern_world(const fs::path &file) {
try {
+88
View File
@@ -1,4 +1,5 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/demo_sports.hpp"
#include "modern/ui/desktop.hpp"
#include "modern/ui/gui_assets.hpp"
#include "modern/ui/model.hpp"
@@ -174,6 +175,93 @@ int main(int argc, char **argv) try {
require(rejected && source.snapshot().state == accepted.state &&
source.snapshot().revision == accepted.revision,
"Invalid desktop partially restored demo");
DemoSource sports(world);
const auto initial_sports = sports.snapshot();
require(!sports
.apply({0,
"training",
{{"kind", "ball"},
{"group", "type"},
{"index", 0},
{"value", 3}}})
.ok,
"Training preview budget exceeded");
require(sports.snapshot().state == initial_sports.state &&
sports.snapshot().revision == 0,
"Rejected training mutated demo");
require(!sports
.apply({0,
"training",
{{"kind", "ball"},
{"group", "area"},
{"index", 0},
{"value", 1.5}}})
.ok,
"Fractional training value accepted");
const auto player = world->squad("club:a").front()->value("id", "");
require(sports
.apply({0,
"training",
{{"kind", "ball"},
{"group", "player"},
{"player", player},
{"value", 1}}})
.ok,
"Player intensity action failed");
require(sports.snapshot().state["training"]["players"][player]["intensity"] ==
0,
"Selected intensity must toggle to zero in UI demo");
require(sports
.apply({1,
"training",
{{"kind", "focus"}, {"player", player}, {"value", 7}}})
.ok,
"Direct focus selection failed");
for (int i = 0; i < 4; ++i)
require(sports
.apply({sports.snapshot().revision,
"tactics",
{{"kind", "cycle"}, {"index", 0}}})
.ok,
"Tactic cycle failed");
require(sports.snapshot().state["tactics"]["values"][0] ==
initial_sports.state["tactics"]["values"][0],
"Tactic cycle did not wrap");
require(
sports
.apply(
{sports.snapshot().revision, "training", {{"kind", "auto-all"}}})
.ok,
"Global automatic training failed");
const auto automated = sports.snapshot();
require(automated.state["training"]["players"][player]["intensity"] == 2 &&
automated.state["training"]["players"][player]["focus"] == 7,
"Automatic training must preserve focuses");
require(!sports.apply({automated.revision,
"training",
{{"kind", "focus"}, {"player", player}, {"value", 0}}})
.ok &&
sports.snapshot().state == automated.state,
"Automatic player controls accepted manual changes");
sports.save(root / "sports.ui.json", default_desktop());
DemoSource restored_sports(world);
restored_sports.load(root / "sports.ui.json");
require(restored_sports.snapshot().state == sports.snapshot().state,
"Training/tactics were lost on restoration");
auto legacy = Json::parse(bmh::editor::read_file(root / "sports.ui.json"));
legacy.erase("training");
legacy.erase("tactics");
write(root, "legacy-ui.json", legacy);
restored_sports.load(root / "legacy-ui.json");
require(valid_demo_training(restored_sports.snapshot().state["training"],
*world, "club:a"),
"Older UI checkpoint did not migrate safely");
for (const auto *theme : {"midnight", "silver", "matchday"}) {
const auto diagram = bmh::editor::images::decode(
tactics_diagram(demo_tactics(), theme), ".svg", 256);
require(diagram.width == 256 && diagram.height > 0,
"Tactic SVG failed to decode");
}
GuiAssets absent(root / "missing-gui");
require(!absent.available(),
"World resources were mistaken for GUI resources");
+4
View File
@@ -55,6 +55,10 @@ def main():
for route, button in zip(routes, buttons, strict=True):
add('button.' + route, button['src'].removeprefix('../'))
add('button.news', 'assets/vector/desktop-news.svg')
for i in range(9):
add('training.skill.' + str(i), 'assets/studies/submenus/training-icons-v2.png',
[(i % 3) / 3, (i // 3) / 3, 1 / 3, 1 / 3])
add('training.ball', 'assets/studies/submenus/training-ball-v1.png')
for i in range(12):
add('manager.' + str(i), 'assets/studies/submenus/manager-portraits-photo-v1.png',
[(i % 4) / 4, (i // 4) / 3, 1 / 4, 1 / 3])